1 /*
2  * avrdude - A Downloader/Uploader for AVR device programmers
3  * Copyright (C) 2000-2004  Brian S. Dean <bsd@bsdhome.com>
4  * Copyright (C) 2006 Joerg Wunsch <j@uriah.heep.sax.de>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 /* $Id$ */
21 %{
22 
23 #include "ac_cfg.h"
24 
25 #include <stdlib.h>
26 #include <string.h>
27 #include <math.h>
28 
29 #include "avrdude.h"
30 #include "libavrdude.h"
31 #include "config.h"
32 
33 #if defined(WIN32NATIVE)
34 #define strtok_r( _s, _sep, _lasts ) \
35     ( *(_lasts) = strtok( (_s), (_sep) ) )
36 #endif
37 
38 #define STRINGIFY(x) #x
39 #define TOSTRING(x) STRINGIFY(x)
40 
41 int yylex(void);
42 int yyerror(char * errmsg, ...);
43 int yywarning(char * errmsg, ...);
44 
45 static int assign_pin(int pinno, TOKEN * v, int invert);
46 static int assign_pin_list(int invert);
47 static int which_opcode(TOKEN * opcode);
48 static int parse_cmdbits(OPCODE * op);
49 
50 static int pin_name;
51 %}
52 
53 %token K_READ
54 %token K_WRITE
55 %token K_READ_LO
56 %token K_READ_HI
57 %token K_WRITE_LO
58 %token K_WRITE_HI
59 %token K_LOADPAGE_LO
60 %token K_LOADPAGE_HI
61 %token K_LOAD_EXT_ADDR
62 %token K_WRITEPAGE
63 %token K_CHIP_ERASE
64 %token K_PGM_ENABLE
65 
66 %token K_MEMORY
67 
68 %token K_PAGE_SIZE
69 %token K_PAGED
70 
71 %token K_BAUDRATE
72 %token K_BS2
73 %token K_BUFF
74 %token K_CHIP_ERASE_DELAY
75 %token K_CONNTYPE
76 %token K_DEDICATED
77 %token K_DEFAULT_BITCLOCK
78 %token K_DEFAULT_PARALLEL
79 %token K_DEFAULT_PROGRAMMER
80 %token K_DEFAULT_SAFEMODE
81 %token K_DEFAULT_SERIAL
82 %token K_DESC
83 %token K_DEVICECODE
84 %token K_STK500_DEVCODE
85 %token K_AVR910_DEVCODE
86 %token K_EEPROM
87 %token K_ERRLED
88 %token K_FLASH
89 %token K_ID
90 %token K_IO
91 %token K_LOADPAGE
92 %token K_MAX_WRITE_DELAY
93 %token K_MCU_BASE
94 %token K_MIN_WRITE_DELAY
95 %token K_MISO
96 %token K_MOSI
97 %token K_NUM_PAGES
98 %token K_NVM_BASE
99 %token K_OCDREV
100 %token K_OFFSET
101 %token K_PAGEL
102 %token K_PARALLEL
103 %token K_PARENT
104 %token K_PART
105 %token K_PGMLED
106 %token K_PROGRAMMER
107 %token K_PSEUDO
108 %token K_PWROFF_AFTER_WRITE
109 %token K_RDYLED
110 %token K_READBACK_P1
111 %token K_READBACK_P2
112 %token K_READMEM
113 %token K_RESET
114 %token K_RETRY_PULSE
115 %token K_SERIAL
116 %token K_SCK
117 %token K_SIGNATURE
118 %token K_SIZE
119 %token K_USB
120 %token K_USBDEV
121 %token K_USBSN
122 %token K_USBPID
123 %token K_USBPRODUCT
124 %token K_USBVENDOR
125 %token K_USBVID
126 %token K_TYPE
127 %token K_VCC
128 %token K_VFYLED
129 
130 %token K_NO
131 %token K_YES
132 
133 /* stk500 v2 xml file parameters */
134 /* ISP */
135 %token K_TIMEOUT
136 %token K_STABDELAY
137 %token K_CMDEXEDELAY
138 %token K_HVSPCMDEXEDELAY
139 %token K_SYNCHLOOPS
140 %token K_BYTEDELAY
141 %token K_POLLVALUE
142 %token K_POLLINDEX
143 %token K_PREDELAY
144 %token K_POSTDELAY
145 %token K_POLLMETHOD
146 %token K_MODE
147 %token K_DELAY
148 %token K_BLOCKSIZE
149 %token K_READSIZE
150 /* HV mode */
151 %token K_HVENTERSTABDELAY
152 %token K_PROGMODEDELAY
153 %token K_LATCHCYCLES
154 %token K_TOGGLEVTG
155 %token K_POWEROFFDELAY
156 %token K_RESETDELAYMS
157 %token K_RESETDELAYUS
158 %token K_HVLEAVESTABDELAY
159 %token K_RESETDELAY
160 %token K_SYNCHCYCLES
161 %token K_HVCMDEXEDELAY
162 
163 %token K_CHIPERASEPULSEWIDTH
164 %token K_CHIPERASEPOLLTIMEOUT
165 %token K_CHIPERASETIME
166 %token K_PROGRAMFUSEPULSEWIDTH
167 %token K_PROGRAMFUSEPOLLTIMEOUT
168 %token K_PROGRAMLOCKPULSEWIDTH
169 %token K_PROGRAMLOCKPOLLTIMEOUT
170 
171 %token K_PP_CONTROLSTACK
172 %token K_HVSP_CONTROLSTACK
173 
174 /* JTAG ICE mkII specific parameters */
175 %token K_ALLOWFULLPAGEBITSTREAM	/*
176 				 * Internal parameter for the JTAG
177 				 * ICE; describes the internal JTAG
178 				 * streaming behaviour inside the MCU.
179 				 * 1 for all older chips, 0 for newer
180 				 * MCUs.
181 				 */
182 %token K_ENABLEPAGEPROGRAMMING	/* ? yes for mega256*, mega406 */
183 %token K_HAS_JTAG		/* MCU has JTAG i/f. */
184 %token K_HAS_DW			/* MCU has debugWire i/f. */
185 %token K_HAS_PDI                /* MCU has PDI i/f rather than ISP (ATxmega). */
186 %token K_HAS_TPI                /* MCU has TPI i/f rather than ISP (ATtiny4/5/9/10). */
187 %token K_IDR			/* address of OCD register in IO space */
188 %token K_IS_AT90S1200		/* chip is an AT90S1200 (needs special treatment) */
189 %token K_IS_AVR32               /* chip is in the avr32 family */
190 %token K_RAMPZ			/* address of RAMPZ reg. in IO space */
191 %token K_SPMCR			/* address of SPMC[S]R in memory space */
192 %token K_EECR    		/* address of EECR in memory space */
193 %token K_FLASH_INSTR		/* flash instructions */
194 %token K_EEPROM_INSTR		/* EEPROM instructions */
195 
196 %token TKN_COMMA
197 %token TKN_EQUAL
198 %token TKN_SEMI
199 %token TKN_TILDE
200 %token TKN_LEFT_PAREN
201 %token TKN_RIGHT_PAREN
202 %token TKN_NUMBER
203 %token TKN_NUMBER_REAL
204 %token TKN_STRING
205 
206 %start configuration
207 
208 %%
209 
210 number_real :
211  TKN_NUMBER {
212     $$ = $1;
213     /* convert value to real */
214     $$->value.number_real = $$->value.number;
215     $$->value.type = V_NUM_REAL;
216   } |
217   TKN_NUMBER_REAL {
218     $$ = $1;
219   }
220 
221 configuration :
222   /* empty */ | config
223 ;
224 
225 config :
226   def |
227   config def
228 ;
229 
230 
231 def :
232   prog_def TKN_SEMI |
233 
234   part_def TKN_SEMI |
235 
236   K_DEFAULT_PROGRAMMER TKN_EQUAL TKN_STRING TKN_SEMI {
237     strncpy(default_programmer, $3->value.string, MAX_STR_CONST);
238     default_programmer[MAX_STR_CONST-1] = 0;
239     free_token($3);
240   } |
241 
242   K_DEFAULT_PARALLEL TKN_EQUAL TKN_STRING TKN_SEMI {
243     strncpy(default_parallel, $3->value.string, PATH_MAX);
244     default_parallel[PATH_MAX-1] = 0;
245     free_token($3);
246   } |
247 
248   K_DEFAULT_SERIAL TKN_EQUAL TKN_STRING TKN_SEMI {
249     strncpy(default_serial, $3->value.string, PATH_MAX);
250     default_serial[PATH_MAX-1] = 0;
251     free_token($3);
252   } |
253 
254   K_DEFAULT_BITCLOCK TKN_EQUAL number_real TKN_SEMI {
255     default_bitclock = $3->value.number_real;
256     free_token($3);
257   } |
258 
259   K_DEFAULT_SAFEMODE TKN_EQUAL yesno TKN_SEMI {
260     if ($3->primary == K_YES)
261       default_safemode = 1;
262     else if ($3->primary == K_NO)
263       default_safemode = 0;
264     free_token($3);
265   }
266 ;
267 
268 
269 prog_def :
270   prog_decl prog_parms
271     {
272       PROGRAMMER * existing_prog;
273       char * id;
274       if (lsize(current_prog->id) == 0) {
275         yyerror("required parameter id not specified");
276         YYABORT;
277       }
278       if (current_prog->initpgm == NULL) {
279         yyerror("programmer type not specified");
280         YYABORT;
281       }
282       id = ldata(lfirst(current_prog->id));
283       existing_prog = locate_programmer(programmers, id);
284       if (existing_prog) {
285         { /* temporarly set lineno to lineno of programmer start */
286           int temp = lineno; lineno = current_prog->lineno;
287           yywarning("programmer %s overwrites previous definition %s:%d.",
288                 id, existing_prog->config_file, existing_prog->lineno);
289           lineno = temp;
290         }
291         lrmv_d(programmers, existing_prog);
292         pgm_free(existing_prog);
293       }
294       PUSH(programmers, current_prog);
295 //      pgm_fill_old_pins(current_prog); // TODO to be removed if old pin data no longer needed
296 //      pgm_display_generic(current_prog, id);
297       current_prog = NULL;
298     }
299 ;
300 
301 
302 prog_decl :
303   K_PROGRAMMER
304     { current_prog = pgm_new();
305       if (current_prog == NULL) {
306         yyerror("could not create pgm instance");
307         YYABORT;
308       }
309       strcpy(current_prog->config_file, infile);
310       current_prog->lineno = lineno;
311     }
312     |
313   K_PROGRAMMER K_PARENT TKN_STRING
314     {
315       struct programmer_t * pgm = locate_programmer(programmers, $3->value.string);
316       if (pgm == NULL) {
317         yyerror("parent programmer %s not found", $3->value.string);
318         free_token($3);
319         YYABORT;
320       }
321       current_prog = pgm_dup(pgm);
322       if (current_prog == NULL) {
323         yyerror("could not duplicate pgm instance");
324         free_token($3);
325         YYABORT;
326       }
327       strcpy(current_prog->config_file, infile);
328       current_prog->lineno = lineno;
329       free_token($3);
330     }
331 ;
332 
333 
334 part_def :
335   part_decl part_parms
336     {
337       LNODEID ln;
338       AVRMEM * m;
339       AVRPART * existing_part;
340 
341       if (current_part->id[0] == 0) {
342         yyerror("required parameter id not specified");
343         YYABORT;
344       }
345 
346       /*
347        * perform some sanity checking, and compute the number of bits
348        * to shift a page for constructing the page address for
349        * page-addressed memories.
350        */
351       for (ln=lfirst(current_part->mem); ln; ln=lnext(ln)) {
352         m = ldata(ln);
353         if (m->paged) {
354           if (m->page_size == 0) {
355             yyerror("must specify page_size for paged memory");
356             YYABORT;
357           }
358           if (m->num_pages == 0) {
359             yyerror("must specify num_pages for paged memory");
360             YYABORT;
361           }
362           if (m->size != m->page_size * m->num_pages) {
363             yyerror("page size (%u) * num_pages (%u) = "
364                     "%u does not match memory size (%u)",
365                     m->page_size,
366                     m->num_pages,
367                     m->page_size * m->num_pages,
368                     m->size);
369             YYABORT;
370           }
371 
372         }
373       }
374 
375       existing_part = locate_part(part_list, current_part->id);
376       if (existing_part) {
377         { /* temporarly set lineno to lineno of part start */
378           int temp = lineno; lineno = current_part->lineno;
379           yywarning("part %s overwrites previous definition %s:%d.",
380                 current_part->id,
381                 existing_part->config_file, existing_part->lineno);
382           lineno = temp;
383         }
384         lrmv_d(part_list, existing_part);
385         avr_free_part(existing_part);
386       }
387       PUSH(part_list, current_part);
388       current_part = NULL;
389     }
390 ;
391 
392 part_decl :
393   K_PART
394     {
395       current_part = avr_new_part();
396       if (current_part == NULL) {
397         yyerror("could not create part instance");
398         YYABORT;
399       }
400       strcpy(current_part->config_file, infile);
401       current_part->lineno = lineno;
402     } |
403   K_PART K_PARENT TKN_STRING
404     {
405       AVRPART * parent_part = locate_part(part_list, $3->value.string);
406       if (parent_part == NULL) {
407         yyerror("can't find parent part");
408         free_token($3);
409         YYABORT;
410       }
411 
412       current_part = avr_dup_part(parent_part);
413       if (current_part == NULL) {
414         yyerror("could not duplicate part instance");
415         free_token($3);
416         YYABORT;
417       }
418       strcpy(current_part->config_file, infile);
419       current_part->lineno = lineno;
420 
421       free_token($3);
422     }
423 ;
424 
425 string_list :
426   TKN_STRING { ladd(string_list, $1); } |
427   string_list TKN_COMMA TKN_STRING { ladd(string_list, $3); }
428 ;
429 
430 
431 num_list :
432   TKN_NUMBER { ladd(number_list, $1); } |
433   num_list TKN_COMMA TKN_NUMBER { ladd(number_list, $3); }
434 ;
435 
436 prog_parms :
437   prog_parm TKN_SEMI |
438   prog_parms prog_parm TKN_SEMI
439 ;
440 
441 prog_parm :
442   K_ID TKN_EQUAL string_list {
443     {
444       TOKEN * t;
445       char *s;
446       int do_yyabort = 0;
447       while (lsize(string_list)) {
448         t = lrmv_n(string_list, 1);
449         if (!do_yyabort) {
450           s = dup_string(t->value.string);
451           if (s == NULL) {
452             do_yyabort = 1;
453           } else {
454             ladd(current_prog->id, s);
455           }
456         }
457         /* if do_yyabort == 1 just make the list empty */
458         free_token(t);
459       }
460       if (do_yyabort) {
461         YYABORT;
462       }
463     }
464   } |
465   prog_parm_type
466   |
467   prog_parm_pins
468   |
469   prog_parm_usb
470   |
471   prog_parm_conntype
472   |
473   K_DESC TKN_EQUAL TKN_STRING {
474     strncpy(current_prog->desc, $3->value.string, PGM_DESCLEN);
475     current_prog->desc[PGM_DESCLEN-1] = 0;
476     free_token($3);
477   } |
478   K_BAUDRATE TKN_EQUAL TKN_NUMBER {
479     {
480       current_prog->baudrate = $3->value.number;
481       free_token($3);
482     }
483   }
484 ;
485 
486 prog_parm_type:
487   K_TYPE TKN_EQUAL prog_parm_type_id
488 ;
489 
490 prog_parm_type_id:
491   TKN_STRING        {
492   const struct programmer_type_t * pgm_type = locate_programmer_type($1->value.string);
493     if (pgm_type == NULL) {
494         yyerror("programmer type %s not found", $1->value.string);
495         free_token($1);
496         YYABORT;
497     }
498     current_prog->initpgm = pgm_type->initpgm;
499     free_token($1);
500 }
501   | error
502 {
503         yyerror("programmer type must be written as \"id_type\"");
504         YYABORT;
505 }
506 ;
507 
508 prog_parm_conntype:
509   K_CONNTYPE TKN_EQUAL prog_parm_conntype_id
510 ;
511 
512 prog_parm_conntype_id:
513   K_PARALLEL        { current_prog->conntype = CONNTYPE_PARALLEL; } |
514   K_SERIAL          { current_prog->conntype = CONNTYPE_SERIAL; } |
515   K_USB             { current_prog->conntype = CONNTYPE_USB; }
516 ;
517 
518 prog_parm_usb:
519   K_USBDEV TKN_EQUAL TKN_STRING {
520     {
521       strncpy(current_prog->usbdev, $3->value.string, PGM_USBSTRINGLEN);
522       current_prog->usbdev[PGM_USBSTRINGLEN-1] = 0;
523       free_token($3);
524     }
525   } |
526   K_USBVID TKN_EQUAL TKN_NUMBER {
527     {
528       current_prog->usbvid = $3->value.number;
529       free_token($3);
530     }
531   } |
532   K_USBPID TKN_EQUAL usb_pid_list |
533   K_USBSN TKN_EQUAL TKN_STRING {
534     {
535       strncpy(current_prog->usbsn, $3->value.string, PGM_USBSTRINGLEN);
536       current_prog->usbsn[PGM_USBSTRINGLEN-1] = 0;
537       free_token($3);
538     }
539   } |
540   K_USBVENDOR TKN_EQUAL TKN_STRING {
541     {
542       strncpy(current_prog->usbvendor, $3->value.string, PGM_USBSTRINGLEN);
543       current_prog->usbvendor[PGM_USBSTRINGLEN-1] = 0;
544       free_token($3);
545     }
546   } |
547   K_USBPRODUCT TKN_EQUAL TKN_STRING {
548     {
549       strncpy(current_prog->usbproduct, $3->value.string, PGM_USBSTRINGLEN);
550       current_prog->usbproduct[PGM_USBSTRINGLEN-1] = 0;
551       free_token($3);
552     }
553   }
554 ;
555 
556 usb_pid_list:
557   TKN_NUMBER {
558     {
559       /* overwrite pids, so clear the existing entries */
560       ldestroy_cb(current_prog->usbpid, free);
561       current_prog->usbpid = lcreat(NULL, 0);
562     }
563     {
564       int *ip = malloc(sizeof(int));
565       if (ip) {
566         *ip = $1->value.number;
567         ladd(current_prog->usbpid, ip);
568       }
569       free_token($1);
570     }
571   } |
572   usb_pid_list TKN_COMMA TKN_NUMBER {
573     {
574       int *ip = malloc(sizeof(int));
575       if (ip) {
576         *ip = $3->value.number;
577         ladd(current_prog->usbpid, ip);
578       }
579       free_token($3);
580     }
581   }
582 ;
583 
584 pin_number_non_empty:
585   TKN_NUMBER { if(0 != assign_pin(pin_name, $1, 0)) YYABORT;  }
586   |
587   TKN_TILDE TKN_NUMBER { if(0 != assign_pin(pin_name, $2, 1)) YYABORT; }
588 ;
589 
590 pin_number:
591   pin_number_non_empty
592   |
593   /* empty */ { pin_clear_all(&(current_prog->pin[pin_name])); }
594 ;
595 
596 pin_list_element:
597   pin_number_non_empty
598   |
599   TKN_TILDE TKN_LEFT_PAREN num_list TKN_RIGHT_PAREN { if(0 != assign_pin_list(1)) YYABORT; }
600 ;
601 
602 pin_list_non_empty:
603   pin_list_element
604   |
605   pin_list_non_empty TKN_COMMA pin_list_element
606 ;
607 
608 
609 pin_list:
610   pin_list_non_empty
611   |
612   /* empty */ { pin_clear_all(&(current_prog->pin[pin_name])); }
613 ;
614 
615 prog_parm_pins:
616   K_VCC    TKN_EQUAL {pin_name = PPI_AVR_VCC;  } pin_list |
617   K_BUFF   TKN_EQUAL {pin_name = PPI_AVR_BUFF; } pin_list |
618   K_RESET  TKN_EQUAL {pin_name = PIN_AVR_RESET;} pin_number { free_token($1); } |
619   K_SCK    TKN_EQUAL {pin_name = PIN_AVR_SCK;  } pin_number { free_token($1); } |
620   K_MOSI   TKN_EQUAL {pin_name = PIN_AVR_MOSI; } pin_number |
621   K_MISO   TKN_EQUAL {pin_name = PIN_AVR_MISO; } pin_number |
622   K_ERRLED TKN_EQUAL {pin_name = PIN_LED_ERR;  } pin_number |
623   K_RDYLED TKN_EQUAL {pin_name = PIN_LED_RDY;  } pin_number |
624   K_PGMLED TKN_EQUAL {pin_name = PIN_LED_PGM;  } pin_number |
625   K_VFYLED TKN_EQUAL {pin_name = PIN_LED_VFY;  } pin_number
626 ;
627 
628 opcode :
629   K_READ         |
630   K_WRITE        |
631   K_READ_LO      |
632   K_READ_HI      |
633   K_WRITE_LO     |
634   K_WRITE_HI     |
635   K_LOADPAGE_LO  |
636   K_LOADPAGE_HI  |
637   K_LOAD_EXT_ADDR |
638   K_WRITEPAGE    |
639   K_CHIP_ERASE   |
640   K_PGM_ENABLE
641 ;
642 
643 
644 part_parms :
645   part_parm TKN_SEMI |
646   part_parms part_parm TKN_SEMI
647 ;
648 
649 
650 reset_disposition :
651   K_DEDICATED | K_IO
652 ;
653 
654 parallel_modes :
655   yesno | K_PSEUDO
656 ;
657 
658 retry_lines :
659   K_RESET | K_SCK
660 ;
661 
662 part_parm :
663   K_ID TKN_EQUAL TKN_STRING
664     {
665       strncpy(current_part->id, $3->value.string, AVR_IDLEN);
666       current_part->id[AVR_IDLEN-1] = 0;
667       free_token($3);
668     } |
669 
670   K_DESC TKN_EQUAL TKN_STRING
671     {
672       strncpy(current_part->desc, $3->value.string, AVR_DESCLEN);
673       current_part->desc[AVR_DESCLEN-1] = 0;
674       free_token($3);
675     } |
676 
677   K_DEVICECODE TKN_EQUAL TKN_NUMBER {
678     {
679       yyerror("devicecode is deprecated, use "
680               "stk500_devcode instead");
681       YYABORT;
682     }
683   } |
684 
685   K_STK500_DEVCODE TKN_EQUAL TKN_NUMBER {
686     {
687       current_part->stk500_devcode = $3->value.number;
688       free_token($3);
689     }
690   } |
691 
692   K_AVR910_DEVCODE TKN_EQUAL TKN_NUMBER {
693     {
694       current_part->avr910_devcode = $3->value.number;
695       free_token($3);
696     }
697   } |
698 
699   K_SIGNATURE TKN_EQUAL TKN_NUMBER TKN_NUMBER TKN_NUMBER {
700     {
701       current_part->signature[0] = $3->value.number;
702       current_part->signature[1] = $4->value.number;
703       current_part->signature[2] = $5->value.number;
704       free_token($3);
705       free_token($4);
706       free_token($5);
707     }
708   } |
709 
710  K_USBPID TKN_EQUAL TKN_NUMBER {
711     {
712       current_part->usbpid = $3->value.number;
713       free_token($3);
714     }
715   } |
716 
717   K_PP_CONTROLSTACK TKN_EQUAL num_list {
718     {
719       TOKEN * t;
720       unsigned nbytes;
721       int ok;
722 
723       current_part->ctl_stack_type = CTL_STACK_PP;
724       nbytes = 0;
725       ok = 1;
726 
727       memset(current_part->controlstack, 0, CTL_STACK_SIZE);
728       while (lsize(number_list)) {
729         t = lrmv_n(number_list, 1);
730 	if (nbytes < CTL_STACK_SIZE)
731 	  {
732 	    current_part->controlstack[nbytes] = t->value.number;
733 	    nbytes++;
734 	  }
735 	else
736 	  {
737 	    ok = 0;
738 	  }
739         free_token(t);
740       }
741       if (!ok)
742 	{
743 	  yywarning("too many bytes in control stack");
744         }
745     }
746   } |
747 
748   K_HVSP_CONTROLSTACK TKN_EQUAL num_list {
749     {
750       TOKEN * t;
751       unsigned nbytes;
752       int ok;
753 
754       current_part->ctl_stack_type = CTL_STACK_HVSP;
755       nbytes = 0;
756       ok = 1;
757 
758       memset(current_part->controlstack, 0, CTL_STACK_SIZE);
759       while (lsize(number_list)) {
760         t = lrmv_n(number_list, 1);
761 	if (nbytes < CTL_STACK_SIZE)
762 	  {
763 	    current_part->controlstack[nbytes] = t->value.number;
764 	    nbytes++;
765 	  }
766 	else
767 	  {
768 	    ok = 0;
769 	  }
770         free_token(t);
771       }
772       if (!ok)
773 	{
774 	  yywarning("too many bytes in control stack");
775         }
776     }
777   } |
778 
779   K_FLASH_INSTR TKN_EQUAL num_list {
780     {
781       TOKEN * t;
782       unsigned nbytes;
783       int ok;
784 
785       nbytes = 0;
786       ok = 1;
787 
788       memset(current_part->flash_instr, 0, FLASH_INSTR_SIZE);
789       while (lsize(number_list)) {
790         t = lrmv_n(number_list, 1);
791 	if (nbytes < FLASH_INSTR_SIZE)
792 	  {
793 	    current_part->flash_instr[nbytes] = t->value.number;
794 	    nbytes++;
795 	  }
796 	else
797 	  {
798 	    ok = 0;
799 	  }
800         free_token(t);
801       }
802       if (!ok)
803 	{
804 	  yywarning("too many bytes in flash instructions");
805         }
806     }
807   } |
808 
809   K_EEPROM_INSTR TKN_EQUAL num_list {
810     {
811       TOKEN * t;
812       unsigned nbytes;
813       int ok;
814 
815       nbytes = 0;
816       ok = 1;
817 
818       memset(current_part->eeprom_instr, 0, EEPROM_INSTR_SIZE);
819       while (lsize(number_list)) {
820         t = lrmv_n(number_list, 1);
821 	if (nbytes < EEPROM_INSTR_SIZE)
822 	  {
823 	    current_part->eeprom_instr[nbytes] = t->value.number;
824 	    nbytes++;
825 	  }
826 	else
827 	  {
828 	    ok = 0;
829 	  }
830         free_token(t);
831       }
832       if (!ok)
833 	{
834 	  yywarning("too many bytes in EEPROM instructions");
835         }
836     }
837   } |
838 
839   K_CHIP_ERASE_DELAY TKN_EQUAL TKN_NUMBER
840     {
841       current_part->chip_erase_delay = $3->value.number;
842       free_token($3);
843     } |
844 
845   K_PAGEL TKN_EQUAL TKN_NUMBER
846     {
847       current_part->pagel = $3->value.number;
848       free_token($3);
849     } |
850 
851   K_BS2 TKN_EQUAL TKN_NUMBER
852     {
853       current_part->bs2 = $3->value.number;
854       free_token($3);
855     } |
856 
857   K_RESET TKN_EQUAL reset_disposition
858     {
859       if ($3->primary == K_DEDICATED)
860         current_part->reset_disposition = RESET_DEDICATED;
861       else if ($3->primary == K_IO)
862         current_part->reset_disposition = RESET_IO;
863 
864       free_tokens(2, $1, $3);
865     } |
866 
867   K_TIMEOUT TKN_EQUAL TKN_NUMBER
868     {
869       current_part->timeout = $3->value.number;
870       free_token($3);
871     } |
872 
873   K_STABDELAY TKN_EQUAL TKN_NUMBER
874     {
875       current_part->stabdelay = $3->value.number;
876       free_token($3);
877     } |
878 
879   K_CMDEXEDELAY TKN_EQUAL TKN_NUMBER
880     {
881       current_part->cmdexedelay = $3->value.number;
882       free_token($3);
883     } |
884 
885   K_HVSPCMDEXEDELAY TKN_EQUAL TKN_NUMBER
886     {
887       current_part->hvspcmdexedelay = $3->value.number;
888       free_token($3);
889     } |
890 
891   K_SYNCHLOOPS TKN_EQUAL TKN_NUMBER
892     {
893       current_part->synchloops = $3->value.number;
894       free_token($3);
895     } |
896 
897   K_BYTEDELAY TKN_EQUAL TKN_NUMBER
898     {
899       current_part->bytedelay = $3->value.number;
900       free_token($3);
901     } |
902 
903   K_POLLVALUE TKN_EQUAL TKN_NUMBER
904     {
905       current_part->pollvalue = $3->value.number;
906       free_token($3);
907     } |
908 
909   K_POLLINDEX TKN_EQUAL TKN_NUMBER
910     {
911       current_part->pollindex = $3->value.number;
912       free_token($3);
913     } |
914 
915   K_PREDELAY TKN_EQUAL TKN_NUMBER
916     {
917       current_part->predelay = $3->value.number;
918       free_token($3);
919     } |
920 
921   K_POSTDELAY TKN_EQUAL TKN_NUMBER
922     {
923       current_part->postdelay = $3->value.number;
924       free_token($3);
925     } |
926 
927   K_POLLMETHOD TKN_EQUAL TKN_NUMBER
928     {
929       current_part->pollmethod = $3->value.number;
930       free_token($3);
931     } |
932 
933   K_HVENTERSTABDELAY TKN_EQUAL TKN_NUMBER
934     {
935       current_part->hventerstabdelay = $3->value.number;
936       free_token($3);
937     } |
938 
939   K_PROGMODEDELAY TKN_EQUAL TKN_NUMBER
940     {
941       current_part->progmodedelay = $3->value.number;
942       free_token($3);
943     } |
944 
945   K_LATCHCYCLES TKN_EQUAL TKN_NUMBER
946     {
947       current_part->latchcycles = $3->value.number;
948       free_token($3);
949     } |
950 
951   K_TOGGLEVTG TKN_EQUAL TKN_NUMBER
952     {
953       current_part->togglevtg = $3->value.number;
954       free_token($3);
955     } |
956 
957   K_POWEROFFDELAY TKN_EQUAL TKN_NUMBER
958     {
959       current_part->poweroffdelay = $3->value.number;
960       free_token($3);
961     } |
962 
963   K_RESETDELAYMS TKN_EQUAL TKN_NUMBER
964     {
965       current_part->resetdelayms = $3->value.number;
966       free_token($3);
967     } |
968 
969   K_RESETDELAYUS TKN_EQUAL TKN_NUMBER
970     {
971       current_part->resetdelayus = $3->value.number;
972       free_token($3);
973     } |
974 
975   K_HVLEAVESTABDELAY TKN_EQUAL TKN_NUMBER
976     {
977       current_part->hvleavestabdelay = $3->value.number;
978       free_token($3);
979     } |
980 
981   K_RESETDELAY TKN_EQUAL TKN_NUMBER
982     {
983       current_part->resetdelay = $3->value.number;
984       free_token($3);
985     } |
986 
987   K_CHIPERASEPULSEWIDTH TKN_EQUAL TKN_NUMBER
988     {
989       current_part->chiperasepulsewidth = $3->value.number;
990       free_token($3);
991     } |
992 
993   K_CHIPERASEPOLLTIMEOUT TKN_EQUAL TKN_NUMBER
994     {
995       current_part->chiperasepolltimeout = $3->value.number;
996       free_token($3);
997     } |
998 
999   K_CHIPERASETIME TKN_EQUAL TKN_NUMBER
1000     {
1001       current_part->chiperasetime = $3->value.number;
1002       free_token($3);
1003     } |
1004 
1005   K_PROGRAMFUSEPULSEWIDTH TKN_EQUAL TKN_NUMBER
1006     {
1007       current_part->programfusepulsewidth = $3->value.number;
1008       free_token($3);
1009     } |
1010 
1011   K_PROGRAMFUSEPOLLTIMEOUT TKN_EQUAL TKN_NUMBER
1012     {
1013       current_part->programfusepolltimeout = $3->value.number;
1014       free_token($3);
1015     } |
1016 
1017   K_PROGRAMLOCKPULSEWIDTH TKN_EQUAL TKN_NUMBER
1018     {
1019       current_part->programlockpulsewidth = $3->value.number;
1020       free_token($3);
1021     } |
1022 
1023   K_PROGRAMLOCKPOLLTIMEOUT TKN_EQUAL TKN_NUMBER
1024     {
1025       current_part->programlockpolltimeout = $3->value.number;
1026       free_token($3);
1027     } |
1028 
1029   K_SYNCHCYCLES TKN_EQUAL TKN_NUMBER
1030     {
1031       current_part->synchcycles = $3->value.number;
1032       free_token($3);
1033     } |
1034 
1035   K_HAS_JTAG TKN_EQUAL yesno
1036     {
1037       if ($3->primary == K_YES)
1038         current_part->flags |= AVRPART_HAS_JTAG;
1039       else if ($3->primary == K_NO)
1040         current_part->flags &= ~AVRPART_HAS_JTAG;
1041 
1042       free_token($3);
1043     } |
1044 
1045   K_HAS_DW TKN_EQUAL yesno
1046     {
1047       if ($3->primary == K_YES)
1048         current_part->flags |= AVRPART_HAS_DW;
1049       else if ($3->primary == K_NO)
1050         current_part->flags &= ~AVRPART_HAS_DW;
1051 
1052       free_token($3);
1053     } |
1054 
1055   K_HAS_PDI TKN_EQUAL yesno
1056     {
1057       if ($3->primary == K_YES)
1058         current_part->flags |= AVRPART_HAS_PDI;
1059       else if ($3->primary == K_NO)
1060         current_part->flags &= ~AVRPART_HAS_PDI;
1061 
1062       free_token($3);
1063     } |
1064 
1065   K_HAS_TPI TKN_EQUAL yesno
1066     {
1067       if ($3->primary == K_YES)
1068         current_part->flags |= AVRPART_HAS_TPI;
1069       else if ($3->primary == K_NO)
1070         current_part->flags &= ~AVRPART_HAS_TPI;
1071 
1072       free_token($3);
1073     } |
1074 
1075   K_IS_AT90S1200 TKN_EQUAL yesno
1076     {
1077       if ($3->primary == K_YES)
1078         current_part->flags |= AVRPART_IS_AT90S1200;
1079       else if ($3->primary == K_NO)
1080         current_part->flags &= ~AVRPART_IS_AT90S1200;
1081 
1082       free_token($3);
1083     } |
1084 
1085   K_IS_AVR32 TKN_EQUAL yesno
1086     {
1087       if ($3->primary == K_YES)
1088         current_part->flags |= AVRPART_AVR32;
1089       else if ($3->primary == K_NO)
1090         current_part->flags &= ~AVRPART_AVR32;
1091 
1092       free_token($3);
1093     } |
1094 
1095   K_ALLOWFULLPAGEBITSTREAM TKN_EQUAL yesno
1096     {
1097       if ($3->primary == K_YES)
1098         current_part->flags |= AVRPART_ALLOWFULLPAGEBITSTREAM;
1099       else if ($3->primary == K_NO)
1100         current_part->flags &= ~AVRPART_ALLOWFULLPAGEBITSTREAM;
1101 
1102       free_token($3);
1103     } |
1104 
1105   K_ENABLEPAGEPROGRAMMING TKN_EQUAL yesno
1106     {
1107       if ($3->primary == K_YES)
1108         current_part->flags |= AVRPART_ENABLEPAGEPROGRAMMING;
1109       else if ($3->primary == K_NO)
1110         current_part->flags &= ~AVRPART_ENABLEPAGEPROGRAMMING;
1111 
1112       free_token($3);
1113     } |
1114 
1115   K_IDR TKN_EQUAL TKN_NUMBER
1116     {
1117       current_part->idr = $3->value.number;
1118       free_token($3);
1119     } |
1120 
1121   K_RAMPZ TKN_EQUAL TKN_NUMBER
1122     {
1123       current_part->rampz = $3->value.number;
1124       free_token($3);
1125     } |
1126 
1127   K_SPMCR TKN_EQUAL TKN_NUMBER
1128     {
1129       current_part->spmcr = $3->value.number;
1130       free_token($3);
1131     } |
1132 
1133   K_EECR TKN_EQUAL TKN_NUMBER
1134     {
1135       current_part->eecr = $3->value.number;
1136       free_token($3);
1137     } |
1138 
1139   K_MCU_BASE TKN_EQUAL TKN_NUMBER
1140     {
1141       current_part->mcu_base = $3->value.number;
1142       free_token($3);
1143     } |
1144 
1145   K_NVM_BASE TKN_EQUAL TKN_NUMBER
1146     {
1147       current_part->nvm_base = $3->value.number;
1148       free_token($3);
1149     } |
1150 
1151   K_OCDREV          TKN_EQUAL TKN_NUMBER
1152     {
1153       current_part->ocdrev = $3->value.number;
1154       free_token($3);
1155     } |
1156 
1157   K_SERIAL TKN_EQUAL yesno
1158     {
1159       if ($3->primary == K_YES)
1160         current_part->flags |= AVRPART_SERIALOK;
1161       else if ($3->primary == K_NO)
1162         current_part->flags &= ~AVRPART_SERIALOK;
1163 
1164       free_token($3);
1165     } |
1166 
1167   K_PARALLEL TKN_EQUAL parallel_modes
1168     {
1169       if ($3->primary == K_YES) {
1170         current_part->flags |= AVRPART_PARALLELOK;
1171         current_part->flags &= ~AVRPART_PSEUDOPARALLEL;
1172       }
1173       else if ($3->primary == K_NO) {
1174         current_part->flags &= ~AVRPART_PARALLELOK;
1175         current_part->flags &= ~AVRPART_PSEUDOPARALLEL;
1176       }
1177       else if ($3->primary == K_PSEUDO) {
1178         current_part->flags |= AVRPART_PARALLELOK;
1179         current_part->flags |= AVRPART_PSEUDOPARALLEL;
1180       }
1181 
1182 
1183       free_token($3);
1184     } |
1185 
1186   K_RETRY_PULSE TKN_EQUAL retry_lines
1187     {
1188       switch ($3->primary) {
1189         case K_RESET :
1190           current_part->retry_pulse = PIN_AVR_RESET;
1191           break;
1192         case K_SCK :
1193           current_part->retry_pulse = PIN_AVR_SCK;
1194           break;
1195       }
1196 
1197       free_token($1);
1198     } |
1199 
1200 
1201 /*
1202   K_EEPROM { current_mem = AVR_M_EEPROM; }
1203     mem_specs |
1204 
1205   K_FLASH { current_mem = AVR_M_FLASH; }
1206     mem_specs |
1207 */
1208 
1209   K_MEMORY TKN_STRING
1210     {
1211       current_mem = avr_new_memtype();
1212       if (current_mem == NULL) {
1213         yyerror("could not create mem instance");
1214         free_token($2);
1215         YYABORT;
1216       }
1217       strncpy(current_mem->desc, $2->value.string, AVR_MEMDESCLEN);
1218       current_mem->desc[AVR_MEMDESCLEN-1] = 0;
1219       free_token($2);
1220     }
1221     mem_specs
1222     {
1223       AVRMEM * existing_mem;
1224 
1225       existing_mem = avr_locate_mem(current_part, current_mem->desc);
1226       if (existing_mem != NULL) {
1227         lrmv_d(current_part->mem, existing_mem);
1228         avr_free_mem(existing_mem);
1229       }
1230       ladd(current_part->mem, current_mem);
1231       current_mem = NULL;
1232     } |
1233 
1234   opcode TKN_EQUAL string_list {
1235     {
1236       int opnum;
1237       OPCODE * op;
1238 
1239       opnum = which_opcode($1);
1240       if (opnum < 0) YYABORT;
1241       op = avr_new_opcode();
1242       if (op == NULL) {
1243         yyerror("could not create opcode instance");
1244         free_token($1);
1245         YYABORT;
1246       }
1247       if(0 != parse_cmdbits(op)) YYABORT;
1248       if (current_part->op[opnum] != NULL) {
1249         /*yywarning("operation redefined");*/
1250         avr_free_opcode(current_part->op[opnum]);
1251       }
1252       current_part->op[opnum] = op;
1253 
1254       free_token($1);
1255     }
1256   }
1257 ;
1258 
1259 
1260 yesno :
1261   K_YES | K_NO
1262 ;
1263 
1264 
1265 mem_specs :
1266   mem_spec TKN_SEMI |
1267   mem_specs mem_spec TKN_SEMI
1268 ;
1269 
1270 
1271 mem_spec :
1272   K_PAGED          TKN_EQUAL yesno
1273     {
1274       current_mem->paged = $3->primary == K_YES ? 1 : 0;
1275       free_token($3);
1276     } |
1277 
1278   K_SIZE            TKN_EQUAL TKN_NUMBER
1279     {
1280       current_mem->size = $3->value.number;
1281       free_token($3);
1282     } |
1283 
1284 
1285   K_PAGE_SIZE       TKN_EQUAL TKN_NUMBER
1286     {
1287       current_mem->page_size = $3->value.number;
1288       free_token($3);
1289     } |
1290 
1291   K_NUM_PAGES       TKN_EQUAL TKN_NUMBER
1292     {
1293       current_mem->num_pages = $3->value.number;
1294       free_token($3);
1295     } |
1296 
1297   K_OFFSET          TKN_EQUAL TKN_NUMBER
1298     {
1299       current_mem->offset = $3->value.number;
1300       free_token($3);
1301     } |
1302 
1303   K_MIN_WRITE_DELAY TKN_EQUAL TKN_NUMBER
1304     {
1305       current_mem->min_write_delay = $3->value.number;
1306       free_token($3);
1307     } |
1308 
1309   K_MAX_WRITE_DELAY TKN_EQUAL TKN_NUMBER
1310     {
1311       current_mem->max_write_delay = $3->value.number;
1312       free_token($3);
1313     } |
1314 
1315   K_PWROFF_AFTER_WRITE TKN_EQUAL yesno
1316     {
1317       current_mem->pwroff_after_write = $3->primary == K_YES ? 1 : 0;
1318       free_token($3);
1319     } |
1320 
1321   K_READBACK_P1     TKN_EQUAL TKN_NUMBER
1322     {
1323       current_mem->readback[0] = $3->value.number;
1324       free_token($3);
1325     } |
1326 
1327   K_READBACK_P2     TKN_EQUAL TKN_NUMBER
1328     {
1329       current_mem->readback[1] = $3->value.number;
1330       free_token($3);
1331     } |
1332 
1333 
1334   K_MODE TKN_EQUAL TKN_NUMBER
1335     {
1336       current_mem->mode = $3->value.number;
1337       free_token($3);
1338     } |
1339 
1340   K_DELAY TKN_EQUAL TKN_NUMBER
1341     {
1342       current_mem->delay = $3->value.number;
1343       free_token($3);
1344     } |
1345 
1346   K_BLOCKSIZE TKN_EQUAL TKN_NUMBER
1347     {
1348       current_mem->blocksize = $3->value.number;
1349       free_token($3);
1350     } |
1351 
1352   K_READSIZE TKN_EQUAL TKN_NUMBER
1353     {
1354       current_mem->readsize = $3->value.number;
1355       free_token($3);
1356     } |
1357 
1358   K_POLLINDEX TKN_EQUAL TKN_NUMBER
1359     {
1360       current_mem->pollindex = $3->value.number;
1361       free_token($3);
1362     } |
1363 
1364 
1365   opcode TKN_EQUAL string_list {
1366     {
1367       int opnum;
1368       OPCODE * op;
1369 
1370       opnum = which_opcode($1);
1371       if (opnum < 0) YYABORT;
1372       op = avr_new_opcode();
1373       if (op == NULL) {
1374         yyerror("could not create opcode instance");
1375         free_token($1);
1376         YYABORT;
1377       }
1378       if(0 != parse_cmdbits(op)) YYABORT;
1379       if (current_mem->op[opnum] != NULL) {
1380         /*yywarning("operation redefined");*/
1381         avr_free_opcode(current_mem->op[opnum]);
1382       }
1383       current_mem->op[opnum] = op;
1384 
1385       free_token($1);
1386     }
1387   }
1388 ;
1389 
1390 
1391 %%
1392 
1393 #if 0
1394 static char * vtypestr(int type)
1395 {
1396   switch (type) {
1397     case V_NUM : return "INTEGER";
1398     case V_NUM_REAL: return "REAL";
1399     case V_STR : return "STRING";
1400     default:
1401       return "<UNKNOWN>";
1402   }
1403 }
1404 #endif
1405 
1406 
1407 static int assign_pin(int pinno, TOKEN * v, int invert)
1408 {
1409   int value;
1410 
1411   value = v->value.number;
1412   free_token(v);
1413 
1414   if ((value < PIN_MIN) || (value > PIN_MAX)) {
1415     yyerror("pin must be in the range " TOSTRING(PIN_MIN) "-"  TOSTRING(PIN_MAX));
1416     return -1;
1417   }
1418 
1419   pin_set_value(&(current_prog->pin[pinno]), value, invert);
1420 
1421   return 0;
1422 }
1423 
assign_pin_list(int invert)1424 static int assign_pin_list(int invert)
1425 {
1426   TOKEN * t;
1427   int pin;
1428   int rv = 0;
1429 
1430   current_prog->pinno[pin_name] = 0;
1431   while (lsize(number_list)) {
1432     t = lrmv_n(number_list, 1);
1433     if (rv == 0) {
1434       pin = t->value.number;
1435       if ((pin < PIN_MIN) || (pin > PIN_MAX)) {
1436         yyerror("pin must be in the range " TOSTRING(PIN_MIN) "-"  TOSTRING(PIN_MAX));
1437         rv = -1;
1438       /* loop clears list and frees tokens */
1439       }
1440       pin_set_value(&(current_prog->pin[pin_name]), pin, invert);
1441     }
1442     free_token(t);
1443   }
1444   return rv;
1445 }
1446 
which_opcode(TOKEN * opcode)1447 static int which_opcode(TOKEN * opcode)
1448 {
1449   switch (opcode->primary) {
1450     case K_READ        : return AVR_OP_READ; break;
1451     case K_WRITE       : return AVR_OP_WRITE; break;
1452     case K_READ_LO     : return AVR_OP_READ_LO; break;
1453     case K_READ_HI     : return AVR_OP_READ_HI; break;
1454     case K_WRITE_LO    : return AVR_OP_WRITE_LO; break;
1455     case K_WRITE_HI    : return AVR_OP_WRITE_HI; break;
1456     case K_LOADPAGE_LO : return AVR_OP_LOADPAGE_LO; break;
1457     case K_LOADPAGE_HI : return AVR_OP_LOADPAGE_HI; break;
1458     case K_LOAD_EXT_ADDR : return AVR_OP_LOAD_EXT_ADDR; break;
1459     case K_WRITEPAGE   : return AVR_OP_WRITEPAGE; break;
1460     case K_CHIP_ERASE  : return AVR_OP_CHIP_ERASE; break;
1461     case K_PGM_ENABLE  : return AVR_OP_PGM_ENABLE; break;
1462     default :
1463       yyerror("invalid opcode");
1464       return -1;
1465       break;
1466   }
1467 }
1468 
1469 
parse_cmdbits(OPCODE * op)1470 static int parse_cmdbits(OPCODE * op)
1471 {
1472   TOKEN * t;
1473   int bitno;
1474   char ch;
1475   char * e;
1476   char * q;
1477   int len;
1478   char * s, *brkt = NULL;
1479   int rv = 0;
1480 
1481   bitno = 32;
1482   while (lsize(string_list)) {
1483 
1484     t = lrmv_n(string_list, 1);
1485 
1486     s = strtok_r(t->value.string, " ", &brkt);
1487     while (rv == 0 && s != NULL) {
1488 
1489       bitno--;
1490       if (bitno < 0) {
1491         yyerror("too many opcode bits for instruction");
1492         rv = -1;
1493         break;
1494       }
1495 
1496       len = (int)strlen(s);
1497 
1498       if (len == 0) {
1499         yyerror("invalid bit specifier \"\"");
1500         rv = -1;
1501         break;
1502       }
1503 
1504       ch = s[0];
1505 
1506       if (len == 1) {
1507         switch (ch) {
1508           case '1':
1509             op->bit[bitno].type  = AVR_CMDBIT_VALUE;
1510             op->bit[bitno].value = 1;
1511             op->bit[bitno].bitno = bitno % 8;
1512             break;
1513           case '0':
1514             op->bit[bitno].type  = AVR_CMDBIT_VALUE;
1515             op->bit[bitno].value = 0;
1516             op->bit[bitno].bitno = bitno % 8;
1517             break;
1518           case 'x':
1519             op->bit[bitno].type  = AVR_CMDBIT_IGNORE;
1520             op->bit[bitno].value = 0;
1521             op->bit[bitno].bitno = bitno % 8;
1522             break;
1523           case 'a':
1524             op->bit[bitno].type  = AVR_CMDBIT_ADDRESS;
1525             op->bit[bitno].value = 0;
1526             op->bit[bitno].bitno = 8*(bitno/8) + bitno % 8;
1527             break;
1528           case 'i':
1529             op->bit[bitno].type  = AVR_CMDBIT_INPUT;
1530             op->bit[bitno].value = 0;
1531             op->bit[bitno].bitno = bitno % 8;
1532             break;
1533           case 'o':
1534             op->bit[bitno].type  = AVR_CMDBIT_OUTPUT;
1535             op->bit[bitno].value = 0;
1536             op->bit[bitno].bitno = bitno % 8;
1537             break;
1538           default :
1539             yyerror("invalid bit specifier '%c'", ch);
1540             rv = -1;
1541             break;
1542         }
1543       }
1544       else {
1545         if (ch == 'a') {
1546           q = &s[1];
1547           op->bit[bitno].bitno = strtol(q, &e, 0);
1548           if ((e == q)||(*e != 0)) {
1549             yyerror("can't parse bit number from \"%s\"", q);
1550             rv = -1;
1551             break;
1552           }
1553           op->bit[bitno].type = AVR_CMDBIT_ADDRESS;
1554           op->bit[bitno].value = 0;
1555         }
1556         else {
1557           yyerror("invalid bit specifier \"%s\"", s);
1558           rv = -1;
1559           break;
1560         }
1561       }
1562 
1563       s = strtok_r(NULL, " ", &brkt);
1564     } /* while */
1565 
1566     free_token(t);
1567 
1568   }  /* while */
1569 
1570   return rv;
1571 }
1572