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