| blob | a76f40ecbdb64d54753f8cdd4b4879cf4f9e7813 |
1 /* A Bison parser, made by GNU Bison 3.0.2. */
3 /* Bison implementation for Yacc-like parsers in C
5 Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
43 /* Identify Bison output. */
44 #define YYBISON 1
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0.2"
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
52 /* Pure parsers. */
53 #define YYPURE 0
55 /* Push parsers. */
56 #define YYPUSH 0
58 /* Pull parsers. */
59 #define YYPULL 1
64 /* Copy the first part of user declarations. */
67 #include <stdio.h>
68 #include <inttypes.h>
69 #include <stdlib.h>
70 #include <string.h>
71 //#define YYDEBUG 1
72 int yylex (void);
73 void yyerror (char const *);
75 struct field {
76 char *name;
77 unsigned int width;
78 unsigned int value;
79 struct field *next;
80 };
82 extern struct field *sym_table;
83 struct field *putsym (char const *, unsigned int);
84 struct field *getsym (char const *);
86 struct field *sym_table;
87 struct field *sym_table_tail;
89 FILE* fp;
91 /* Bit array intermediary representation */
92 struct blob {
93 unsigned int bloblen;
94 unsigned char *blb;
95 unsigned short checksum;
96 unsigned char *actualblob;
97 unsigned int lenactualblob;
98 };
100 #define VALID_BIT 0x80
101 #define MAX_WIDTH 32
102 #define CHECKSUM_SIZE 16
104 struct blob *binary;
106 static void check_pointer (void *ptr)
107 {
108 if (ptr == NULL) {
109 printf("Error: Out of memory\n");
110 exit(1);
111 }
112 }
114 static unsigned char* value_to_bits (unsigned int v, unsigned int w)
115 {
116 unsigned int i;
117 unsigned char* bitarr;
119 if (w > MAX_WIDTH) w = MAX_WIDTH;
120 bitarr = (unsigned char *) malloc (w * sizeof (unsigned char));
121 check_pointer(bitarr);
122 memset (bitarr, 0, w);
124 for (i = 0; i < w; i++) {
125 bitarr[i] = VALID_BIT | ((v & (1 << i)) >> i);
126 }
127 return bitarr;
128 }
130 /* Store each bit of a bitfield in a new byte sequentially 0x80 or 0x81 */
131 static void append_field_to_blob (unsigned char b[], unsigned int w)
132 {
133 unsigned int i, j;
134 binary->blb = (unsigned char *) realloc (binary->blb, binary->bloblen + w);
135 check_pointer(binary->blb);
136 for (j = 0, i = binary->bloblen; i < binary->bloblen + w; i++, j++) {
137 binary->blb[i] = VALID_BIT | (b[j] & 1);
138 //fprintf (stderr, "blob[%d] = %d\n", i, binary->blb[i] & 1);
139 }
140 binary->bloblen += w;
141 }
143 static void set_bitfield(char *name, unsigned int value)
144 {
145 unsigned long long i;
146 struct field *bf = getsym (name);
147 if (bf) {
148 bf->value = value & 0xffffffff;
149 i = (1 << bf->width) - 1;
150 if (bf->width > 8 * sizeof (unsigned int)) {
151 fprintf(stderr, "Overflow in bitfield, truncating bits to fit\n");
152 bf->value = value & i;
153 }
154 //fprintf(stderr, "Setting `%s` = %d\n", bf->name, bf->value);
155 } else {
156 fprintf(stderr, "Can't find bitfield `%s` in spec\n", name);
157 }
158 }
160 static void set_bitfield_array(char *name, unsigned int n, unsigned int value)
161 {
162 unsigned int i;
163 unsigned long len = strlen (name);
164 char *namen = (char *) malloc ((len + 9) * sizeof (char));
165 check_pointer(namen);
166 for (i = 0; i < n; i++) {
167 snprintf (namen, len + 8, "%s%x", name, i);
168 set_bitfield (namen, value);
169 }
170 free(namen);
171 }
173 static void create_new_bitfield(char *name, unsigned int width)
174 {
175 struct field *bf;
177 if (!(bf = putsym (name, width))) return;
178 //fprintf(stderr, "Added bitfield `%s` : %d\n", bf->name, width);
179 }
181 static void create_new_bitfields(char *name, unsigned int n, unsigned int width)
182 {
183 unsigned int i;
184 unsigned long len = strlen (name);
185 char *namen = (char *) malloc ((len + 9) * sizeof (char));
186 check_pointer(namen);
187 for (i = 0; i < n; i++) {
188 snprintf (namen, len + 8, "%s%x", name, i);
189 create_new_bitfield (namen, width);
190 }
191 free(namen);
192 }
194 struct field *putsym (char const *sym_name, unsigned int w)
195 {
196 if (getsym(sym_name)) {
197 fprintf(stderr, "Cannot add duplicate named bitfield `%s`\n", sym_name);
198 return 0;
199 }
200 struct field *ptr = (struct field *) malloc (sizeof (struct field));
201 check_pointer(ptr);
202 ptr->name = (char *) malloc (strlen (sym_name) + 1);
203 check_pointer(ptr->name);
204 strcpy (ptr->name, sym_name);
205 ptr->width = w;
206 ptr->value = 0;
207 ptr->next = (struct field *)0;
208 if (sym_table_tail) {
209 sym_table_tail->next = ptr;
210 } else {
211 sym_table = ptr;
212 }
213 sym_table_tail = ptr;
214 return ptr;
215 }
217 struct field *getsym (char const *sym_name)
218 {
219 struct field *ptr;
220 for (ptr = sym_table; ptr != (struct field *) 0;
221 ptr = (struct field *)ptr->next) {
222 if (strcmp (ptr->name, sym_name) == 0)
223 return ptr;
224 }
225 return 0;
226 }
228 static void dump_all_values (void)
229 {
230 struct field *ptr;
231 for (ptr = sym_table; ptr != (struct field *) 0;
232 ptr = (struct field *)ptr->next) {
233 fprintf(stderr, "%s = %d (%d bits)\n",
234 ptr->name,
235 ptr->value,
236 ptr->width);
237 }
238 }
240 static void empty_field_table(void)
241 {
242 struct field *ptr;
243 struct field *ptrnext;
245 for (ptr = sym_table; ptr != (struct field *) 0; ptr = ptrnext) {
246 if (ptr) {
247 ptrnext = ptr->next;
248 free(ptr);
249 } else {
250 ptrnext = (struct field *) 0;
251 }
252 }
253 sym_table = 0;
254 sym_table_tail = 0;
255 }
257 static void create_binary_blob (void)
258 {
259 if (binary && binary->blb) {
260 free(binary->blb);
261 free(binary);
262 }
263 binary = (struct blob *) malloc (sizeof (struct blob));
264 check_pointer(binary);
265 binary->blb = (unsigned char *) malloc (sizeof (unsigned char));
266 check_pointer(binary->blb);
267 binary->bloblen = 0;
268 binary->blb[0] = VALID_BIT;
269 }
271 static void interpret_next_blob_value (struct field *f)
272 {
273 unsigned int i;
274 unsigned int v = 0;
276 if (binary->bloblen >= binary->lenactualblob * 8) {
277 f->value = 0;
278 return;
279 }
281 for (i = 0; i < f->width; i++) {
282 v |= (binary->blb[binary->bloblen++] & 1) << i;
283 }
285 f->value = v;
286 }
288 /* {}%BIN -> {} */
289 static void generate_setter_bitfields(unsigned char *bin)
290 {
291 unsigned int i;
292 struct field *ptr;
294 /* Convert bytes to bit array */
295 for (i = 0; i < binary->lenactualblob; i++) {
296 append_field_to_blob (value_to_bits(bin[i], 8), 8);
297 }
299 /* Reset blob position to zero */
300 binary->bloblen = 0;
302 fprintf (fp, "# AUTOGENERATED SETTER BY BINCFG\n{\n");
304 /* Traverse spec and output bitfield setters based on blob values */
305 for (ptr = sym_table; ptr != (struct field *) 0; ptr = ptr->next) {
307 interpret_next_blob_value(ptr);
308 fprintf (fp, "\t\"%s\" = 0x%x,\n", ptr->name, ptr->value);
309 }
310 fseek(fp, -2, SEEK_CUR);
311 fprintf (fp, "\n}\n");
312 }
314 static void generate_binary_with_gbe_checksum(void)
315 {
316 int i;
317 unsigned short checksum;
319 /* traverse spec, push to blob and add up for checksum */
320 struct field *ptr;
321 unsigned int uptochksum = 0;
322 for (ptr = sym_table; ptr != (struct field *) 0; ptr = ptr->next) {
323 if (strcmp (ptr->name, "checksum_gbe") == 0) {
324 /* Stop traversing because we hit checksum */
325 ptr = ptr->next;
326 break;
327 }
328 append_field_to_blob (
329 value_to_bits(ptr->value, ptr->width),
330 ptr->width);
331 uptochksum += ptr->width;
332 }
334 /* deserialize bits of blob up to checksum */
335 for (i = 0; i < uptochksum; i += 8) {
336 unsigned char byte = (((binary->blb[i+0] & 1) << 0)
337 | ((binary->blb[i+1] & 1) << 1)
338 | ((binary->blb[i+2] & 1) << 2)
339 | ((binary->blb[i+3] & 1) << 3)
340 | ((binary->blb[i+4] & 1) << 4)
341 | ((binary->blb[i+5] & 1) << 5)
342 | ((binary->blb[i+6] & 1) << 6)
343 | ((binary->blb[i+7] & 1) << 7)
344 );
345 fprintf(fp, "%c", byte);
347 /* incremental 16 bit checksum */
348 if ((i % 16) < 8) {
349 binary->checksum += byte;
350 } else {
351 binary->checksum += byte << 8;
352 }
353 }
355 checksum = (0xbaba - binary->checksum) & 0xffff;
357 /* Now write checksum */
358 set_bitfield ("checksum_gbe", checksum);
360 fprintf(fp, "%c", checksum & 0xff);
361 fprintf(fp, "%c", (checksum & 0xff00) >> 8);
363 append_field_to_blob (value_to_bits(checksum, 16), 16);
365 for (; ptr != (struct field *) 0; ptr = ptr->next) {
366 append_field_to_blob (
367 value_to_bits(ptr->value, ptr->width), ptr->width);
368 }
370 /* deserialize rest of blob past checksum */
371 for (i = uptochksum + CHECKSUM_SIZE; i < binary->bloblen; i += 8) {
372 unsigned char byte = (((binary->blb[i+0] & 1) << 0)
373 | ((binary->blb[i+1] & 1) << 1)
374 | ((binary->blb[i+2] & 1) << 2)
375 | ((binary->blb[i+3] & 1) << 3)
376 | ((binary->blb[i+4] & 1) << 4)
377 | ((binary->blb[i+5] & 1) << 5)
378 | ((binary->blb[i+6] & 1) << 6)
379 | ((binary->blb[i+7] & 1) << 7)
380 );
381 fprintf(fp, "%c", byte);
382 }
383 }
385 /* {}{} -> BIN */
386 static void generate_binary(void)
387 {
388 unsigned int i;
389 struct field *ptr;
391 if (binary->bloblen % 8) {
392 fprintf (stderr, "ERROR: Spec must be multiple of 8 bits wide\n");
393 exit (1);
394 }
396 if (getsym ("checksum_gbe")) {
397 generate_binary_with_gbe_checksum();
398 return;
399 }
401 /* traverse spec, push to blob */
402 for (ptr = sym_table; ptr != (struct field *) 0; ptr = ptr->next) {
403 append_field_to_blob (
404 value_to_bits(ptr->value, ptr->width),
405 ptr->width);
406 }
408 /* deserialize bits of blob */
409 for (i = 0; i < binary->bloblen; i += 8) {
410 unsigned char byte = (((binary->blb[i+0] & 1) << 0)
411 | ((binary->blb[i+1] & 1) << 1)
412 | ((binary->blb[i+2] & 1) << 2)
413 | ((binary->blb[i+3] & 1) << 3)
414 | ((binary->blb[i+4] & 1) << 4)
415 | ((binary->blb[i+5] & 1) << 5)
416 | ((binary->blb[i+6] & 1) << 6)
417 | ((binary->blb[i+7] & 1) << 7)
418 );
419 fprintf(fp, "%c", byte);
420 }
421 }
426 # ifndef YY_NULLPTR
427 # if defined __cplusplus && 201103L <= __cplusplus
428 # define YY_NULLPTR nullptr
429 # else
430 # define YY_NULLPTR 0
431 # endif
432 # endif
434 /* Enabling verbose error messages. */
435 #ifdef YYERROR_VERBOSE
436 # undef YYERROR_VERBOSE
437 # define YYERROR_VERBOSE 1
438 #else
439 # define YYERROR_VERBOSE 0
440 #endif
442 /* In a future release of Bison, this section will be replaced
443 by #include "bincfg.tab.h_shipped". */
444 #ifndef YY_YY_COREBOOT_UTIL_BINCFG_BINCFG_TAB_H_SHIPPED_INCLUDED
445 # define YY_YY_COREBOOT_UTIL_BINCFG_BINCFG_TAB_H_SHIPPED_INCLUDED
446 /* Debug traces. */
447 #ifndef YYDEBUG
448 # define YYDEBUG 0
449 #endif
450 #if YYDEBUG
451 extern int yydebug;
452 #endif
454 /* Token type. */
455 #ifndef YYTOKENTYPE
456 # define YYTOKENTYPE
457 enum yytokentype
458 {
459 name = 258,
460 val = 259,
461 vals = 260,
462 hexbyte = 261,
463 binblob = 262,
464 eof = 263
465 };
466 #endif
468 /* Value type. */
469 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
470 typedef union YYSTYPE YYSTYPE;
471 union YYSTYPE
472 {
475 char *str;
476 unsigned int u32;
477 unsigned int *u32array;
478 unsigned char u8;
479 unsigned char *u8array;
482 };
483 # define YYSTYPE_IS_TRIVIAL 1
484 # define YYSTYPE_IS_DECLARED 1
485 #endif
488 extern YYSTYPE yylval;
490 int yyparse (void);
492 #endif /* !YY_YY_COREBOOT_UTIL_BINCFG_BINCFG_TAB_H_SHIPPED_INCLUDED */
494 /* Copy the second part of user declarations. */
498 #ifdef short
499 # undef short
500 #endif
502 #ifdef YYTYPE_UINT8
503 typedef YYTYPE_UINT8 yytype_uint8;
504 #else
505 typedef unsigned char yytype_uint8;
506 #endif
508 #ifdef YYTYPE_INT8
509 typedef YYTYPE_INT8 yytype_int8;
510 #else
511 typedef signed char yytype_int8;
512 #endif
514 #ifdef YYTYPE_UINT16
515 typedef YYTYPE_UINT16 yytype_uint16;
516 #else
517 typedef unsigned short int yytype_uint16;
518 #endif
520 #ifdef YYTYPE_INT16
521 typedef YYTYPE_INT16 yytype_int16;
522 #else
523 typedef short int yytype_int16;
524 #endif
526 #ifndef YYSIZE_T
527 # ifdef __SIZE_TYPE__
528 # define YYSIZE_T __SIZE_TYPE__
529 # elif defined size_t
530 # define YYSIZE_T size_t
531 # elif ! defined YYSIZE_T
532 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
533 # define YYSIZE_T size_t
534 # else
535 # define YYSIZE_T unsigned int
536 # endif
537 #endif
539 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
541 #ifndef YY_
542 # if defined YYENABLE_NLS && YYENABLE_NLS
543 # if ENABLE_NLS
544 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
545 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
546 # endif
547 # endif
548 # ifndef YY_
549 # define YY_(Msgid) Msgid
550 # endif
551 #endif
553 #ifndef YY_ATTRIBUTE
554 # if (defined __GNUC__ \
555 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
556 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
557 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
558 # else
559 # define YY_ATTRIBUTE(Spec) /* empty */
560 # endif
561 #endif
563 #ifndef YY_ATTRIBUTE_PURE
564 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
565 #endif
567 #ifndef YY_ATTRIBUTE_UNUSED
568 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
569 #endif
571 #if !defined _Noreturn \
572 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
573 # if defined _MSC_VER && 1200 <= _MSC_VER
574 # define _Noreturn __declspec (noreturn)
575 # else
576 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
577 # endif
578 #endif
580 /* Suppress unused-variable warnings by "using" E. */
581 #if ! defined lint || defined __GNUC__
582 # define YYUSE(E) ((void) (E))
583 #else
584 # define YYUSE(E) /* empty */
585 #endif
587 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
588 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
589 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
590 _Pragma ("GCC diagnostic push") \
591 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
592 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
593 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
594 _Pragma ("GCC diagnostic pop")
595 #else
596 # define YY_INITIAL_VALUE(Value) Value
597 #endif
598 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
599 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
600 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
601 #endif
602 #ifndef YY_INITIAL_VALUE
603 # define YY_INITIAL_VALUE(Value) /* Nothing. */
604 #endif
607 #if ! defined yyoverflow || YYERROR_VERBOSE
609 /* The parser invokes alloca or malloc; define the necessary symbols. */
611 # ifdef YYSTACK_USE_ALLOCA
612 # if YYSTACK_USE_ALLOCA
613 # ifdef __GNUC__
614 # define YYSTACK_ALLOC __builtin_alloca
615 # elif defined __BUILTIN_VA_ARG_INCR
616 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
617 # elif defined _AIX
618 # define YYSTACK_ALLOC __alloca
619 # elif defined _MSC_VER
620 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
621 # define alloca _alloca
622 # else
623 # define YYSTACK_ALLOC alloca
624 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
625 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
626 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
627 # ifndef EXIT_SUCCESS
628 # define EXIT_SUCCESS 0
629 # endif
630 # endif
631 # endif
632 # endif
633 # endif
635 # ifdef YYSTACK_ALLOC
636 /* Pacify GCC's 'empty if-body' warning. */
637 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
638 # ifndef YYSTACK_ALLOC_MAXIMUM
639 /* The OS might guarantee only one guard page at the bottom of the stack,
640 and a page size can be as small as 4096 bytes. So we cannot safely
641 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
642 to allow for a few compiler-allocated temporary stack slots. */
643 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
644 # endif
645 # else
646 # define YYSTACK_ALLOC YYMALLOC
647 # define YYSTACK_FREE YYFREE
648 # ifndef YYSTACK_ALLOC_MAXIMUM
649 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
650 # endif
651 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
652 && ! ((defined YYMALLOC || defined malloc) \
653 && (defined YYFREE || defined free)))
654 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
655 # ifndef EXIT_SUCCESS
656 # define EXIT_SUCCESS 0
657 # endif
658 # endif
659 # ifndef YYMALLOC
660 # define YYMALLOC malloc
661 # if ! defined malloc && ! defined EXIT_SUCCESS
662 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
663 # endif
664 # endif
665 # ifndef YYFREE
666 # define YYFREE free
667 # if ! defined free && ! defined EXIT_SUCCESS
668 void free (void *); /* INFRINGES ON USER NAME SPACE */
669 # endif
670 # endif
671 # endif
672 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
675 #if (! defined yyoverflow \
676 && (! defined __cplusplus \
677 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
679 /* A type that is properly aligned for any stack member. */
680 union yyalloc
681 {
682 yytype_int16 yyss_alloc;
683 YYSTYPE yyvs_alloc;
684 };
686 /* The size of the maximum gap between one aligned stack and the next. */
687 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
689 /* The size of an array large to enough to hold all stacks, each with
690 N elements. */
691 # define YYSTACK_BYTES(N) \
692 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
693 + YYSTACK_GAP_MAXIMUM)
695 # define YYCOPY_NEEDED 1
697 /* Relocate STACK from its old location to the new one. The
698 local variables YYSIZE and YYSTACKSIZE give the old and new number of
699 elements in the stack, and YYPTR gives the new location of the
700 stack. Advance YYPTR to a properly aligned location for the next
701 stack. */
702 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
703 do \
704 { \
705 YYSIZE_T yynewbytes; \
706 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
707 Stack = &yyptr->Stack_alloc; \
708 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
709 yyptr += yynewbytes / sizeof (*yyptr); \
710 } \
711 while (0)
713 #endif
715 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
716 /* Copy COUNT objects from SRC to DST. The source and destination do
717 not overlap. */
718 # ifndef YYCOPY
719 # if defined __GNUC__ && 1 < __GNUC__
720 # define YYCOPY(Dst, Src, Count) \
721 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
722 # else
723 # define YYCOPY(Dst, Src, Count) \
724 do \
725 { \
726 YYSIZE_T yyi; \
727 for (yyi = 0; yyi < (Count); yyi++) \
728 (Dst)[yyi] = (Src)[yyi]; \
729 } \
730 while (0)
731 # endif
732 # endif
733 #endif /* !YYCOPY_NEEDED */
735 /* YYFINAL -- State number of the termination state. */
736 #define YYFINAL 2
737 /* YYLAST -- Last index in YYTABLE. */
738 #define YYLAST 32
740 /* YYNTOKENS -- Number of terminals. */
741 #define YYNTOKENS 17
742 /* YYNNTS -- Number of nonterminals. */
743 #define YYNNTS 9
744 /* YYNRULES -- Number of rules. */
745 #define YYNRULES 17
746 /* YYNSTATES -- Number of states. */
747 #define YYNSTATES 39
749 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
750 by yylex, with out-of-bounds checking. */
751 #define YYUNDEFTOK 2
752 #define YYMAXUTOK 263
754 #define YYTRANSLATE(YYX) \
755 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
757 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
758 as returned by yylex, without out-of-bounds checking. */
759 static const yytype_uint8 yytranslate[] =
760 {
761 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
762 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
763 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
764 2, 2, 2, 2, 2, 2, 2, 9, 2, 2,
765 2, 2, 2, 2, 12, 2, 2, 2, 2, 2,
766 2, 2, 2, 2, 2, 2, 2, 2, 13, 2,
767 2, 14, 2, 2, 2, 2, 2, 2, 2, 2,
768 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
769 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
770 2, 15, 2, 16, 2, 2, 2, 2, 2, 2,
771 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
772 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
773 2, 2, 2, 10, 2, 11, 2, 2, 2, 2,
774 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
775 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
776 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
777 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
778 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
779 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
780 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
781 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
782 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
783 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
784 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
785 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
786 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
787 5, 6, 7, 8
788 };
790 #if YYDEBUG
791 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
792 static const yytype_uint16 yyrline[] =
793 {
794 0, 399, 399, 401, 402, 407, 411, 412, 417, 418,
795 422, 423, 427, 428, 433, 434, 438, 439
796 };
797 #endif
799 #if YYDEBUG || YYERROR_VERBOSE || 0
800 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
801 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
802 static const char *const yytname[] =
803 {
804 "$end", "error", "$undefined", "name", "val", "vals", "hexbyte",
805 "binblob", "eof", "'%'", "'{'", "'}'", "','", "':'", "'='", "'['", "']'",
806 "$accept", "input", "blob", "spec", "specmembers", "specpair", "setter",
807 "valuemembers", "setpair", YY_NULLPTR
808 };
809 #endif
811 # ifdef YYPRINT
812 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
813 (internal) symbol number NUM (which must be that of a token). */
814 static const yytype_uint16 yytoknum[] =
815 {
816 0, 256, 257, 258, 259, 260, 261, 262, 263, 37,
817 123, 125, 44, 58, 61, 91, 93
818 };
819 # endif
821 #define YYPACT_NINF -11
823 #define yypact_value_is_default(Yystate) \
824 (!!((Yystate) == (-11)))
826 #define YYTABLE_NINF -1
828 #define yytable_value_is_error(Yytable_value) \
829 0
831 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
832 STATE-NUM. */
833 static const yytype_int8 yypact[] =
834 {
835 -11, 0, -11, -2, -3, -10, -11, -9, -4, 3,
836 1, -11, 7, 12, 13, -11, 15, -11, -1, -11,
837 8, 9, -11, -11, 4, -11, 18, 19, -11, 21,
838 14, -11, 10, -11, 24, 11, -11, 25, -11
839 };
841 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
842 Performed when YYTABLE does not specify something else to do. Zero
843 means the default is an error. */
844 static const yytype_uint8 yydefact[] =
845 {
846 2, 0, 1, 0, 0, 0, 6, 0, 8, 0,
847 0, 4, 0, 0, 0, 7, 0, 5, 0, 12,
848 0, 14, 3, 10, 0, 9, 0, 0, 13, 0,
849 0, 16, 0, 15, 0, 0, 11, 0, 17
850 };
852 /* YYPGOTO[NTERM-NUM]. */
853 static const yytype_int8 yypgoto[] =
854 {
855 -11, -11, -11, -11, 16, -11, -11, 2, -11
856 };
858 /* YYDEFGOTO[NTERM-NUM]. */
859 static const yytype_int8 yydefgoto[] =
860 {
861 -1, 1, 11, 4, 7, 8, 12, 20, 21
862 };
864 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
865 positive, shift that token. If negative, reduce the rule whose
866 number is the opposite. If YYTABLE_NINF, syntax error. */
867 static const yytype_uint8 yytable[] =
868 {
869 2, 5, 15, 13, 18, 14, 9, 10, 16, 6,
870 3, 17, 19, 26, 27, 22, 23, 24, 5, 28,
871 30, 29, 31, 32, 18, 37, 35, 34, 36, 38,
872 0, 33, 25
873 };
875 static const yytype_int8 yycheck[] =
876 {
877 0, 3, 11, 13, 3, 15, 9, 10, 12, 11,
878 10, 8, 11, 14, 15, 8, 4, 4, 3, 11,
879 16, 12, 4, 4, 3, 14, 16, 13, 4, 4,
880 -1, 29, 16
881 };
883 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
884 symbol of state STATE-NUM. */
885 static const yytype_uint8 yystos[] =
886 {
887 0, 18, 0, 10, 20, 3, 11, 21, 22, 9,
888 10, 19, 23, 13, 15, 11, 12, 8, 3, 11,
889 24, 25, 8, 4, 4, 21, 14, 15, 11, 12,
890 16, 4, 4, 24, 13, 16, 4, 14, 4
891 };
893 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
894 static const yytype_uint8 yyr1[] =
895 {
896 0, 17, 18, 18, 18, 19, 20, 20, 21, 21,
897 22, 22, 23, 23, 24, 24, 25, 25
898 };
900 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
901 static const yytype_uint8 yyr2[] =
902 {
903 0, 2, 0, 4, 3, 2, 2, 3, 1, 3,
904 3, 6, 2, 3, 1, 3, 3, 6
905 };
908 #define yyerrok (yyerrstatus = 0)
909 #define yyclearin (yychar = YYEMPTY)
910 #define YYEMPTY (-2)
911 #define YYEOF 0
913 #define YYACCEPT goto yyacceptlab
914 #define YYABORT goto yyabortlab
915 #define YYERROR goto yyerrorlab
918 #define YYRECOVERING() (!!yyerrstatus)
920 #define YYBACKUP(Token, Value) \
921 do \
922 if (yychar == YYEMPTY) \
923 { \
924 yychar = (Token); \
925 yylval = (Value); \
926 YYPOPSTACK (yylen); \
927 yystate = *yyssp; \
928 goto yybackup; \
929 } \
930 else \
931 { \
932 yyerror (YY_("syntax error: cannot back up")); \
933 YYERROR; \
934 } \
935 while (0)
937 /* Error token number */
938 #define YYTERROR 1
939 #define YYERRCODE 256
943 /* Enable debugging if requested. */
944 #if YYDEBUG
946 # ifndef YYFPRINTF
947 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
948 # define YYFPRINTF fprintf
949 # endif
951 # define YYDPRINTF(Args) \
952 do { \
953 if (yydebug) \
954 YYFPRINTF Args; \
955 } while (0)
957 /* This macro is provided for backward compatibility. */
958 #ifndef YY_LOCATION_PRINT
959 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
960 #endif
963 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
964 do { \
965 if (yydebug) \
966 { \
967 YYFPRINTF (stderr, "%s ", Title); \
968 yy_symbol_print (stderr, \
969 Type, Value); \
970 YYFPRINTF (stderr, "\n"); \
971 } \
972 } while (0)
975 /*----------------------------------------.
976 | Print this symbol's value on YYOUTPUT. |
977 `----------------------------------------*/
979 static void
980 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
981 {
982 FILE *yyo = yyoutput;
983 YYUSE (yyo);
984 if (!yyvaluep)
985 return;
986 # ifdef YYPRINT
987 if (yytype < YYNTOKENS)
988 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
989 # endif
990 YYUSE (yytype);
991 }
994 /*--------------------------------.
995 | Print this symbol on YYOUTPUT. |
996 `--------------------------------*/
998 static void
999 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1000 {
1001 YYFPRINTF (yyoutput, "%s %s (",
1002 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1004 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1005 YYFPRINTF (yyoutput, ")");
1006 }
1008 /*------------------------------------------------------------------.
1009 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1010 | TOP (included). |
1011 `------------------------------------------------------------------*/
1013 static void
1014 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1015 {
1016 YYFPRINTF (stderr, "Stack now");
1017 for (; yybottom <= yytop; yybottom++)
1018 {
1019 int yybot = *yybottom;
1020 YYFPRINTF (stderr, " %d", yybot);
1021 }
1022 YYFPRINTF (stderr, "\n");
1023 }
1025 # define YY_STACK_PRINT(Bottom, Top) \
1026 do { \
1027 if (yydebug) \
1028 yy_stack_print ((Bottom), (Top)); \
1029 } while (0)
1032 /*------------------------------------------------.
1033 | Report that the YYRULE is going to be reduced. |
1034 `------------------------------------------------*/
1036 static void
1037 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
1038 {
1039 unsigned long int yylno = yyrline[yyrule];
1040 int yynrhs = yyr2[yyrule];
1041 int yyi;
1042 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1043 yyrule - 1, yylno);
1044 /* The symbols being reduced. */
1045 for (yyi = 0; yyi < yynrhs; yyi++)
1046 {
1047 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1048 yy_symbol_print (stderr,
1049 yystos[yyssp[yyi + 1 - yynrhs]],
1050 &(yyvsp[(yyi + 1) - (yynrhs)])
1051 );
1052 YYFPRINTF (stderr, "\n");
1053 }
1054 }
1056 # define YY_REDUCE_PRINT(Rule) \
1057 do { \
1058 if (yydebug) \
1059 yy_reduce_print (yyssp, yyvsp, Rule); \
1060 } while (0)
1062 /* Nonzero means print parse trace. It is left uninitialized so that
1063 multiple parsers can coexist. */
1064 int yydebug;
1065 #else /* !YYDEBUG */
1066 # define YYDPRINTF(Args)
1067 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1068 # define YY_STACK_PRINT(Bottom, Top)
1069 # define YY_REDUCE_PRINT(Rule)
1070 #endif /* !YYDEBUG */
1073 /* YYINITDEPTH -- initial size of the parser's stacks. */
1074 #ifndef YYINITDEPTH
1075 # define YYINITDEPTH 200
1076 #endif
1078 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1079 if the built-in stack extension method is used).
1081 Do not make this value too large; the results are undefined if
1082 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1083 evaluated with infinite-precision integer arithmetic. */
1085 #ifndef YYMAXDEPTH
1086 # define YYMAXDEPTH 10000
1087 #endif
1090 #if YYERROR_VERBOSE
1092 # ifndef yystrlen
1093 # if defined __GLIBC__ && defined _STRING_H
1094 # define yystrlen strlen
1095 # else
1096 /* Return the length of YYSTR. */
1097 static YYSIZE_T
1098 yystrlen (const char *yystr)
1099 {
1100 YYSIZE_T yylen;
1101 for (yylen = 0; yystr[yylen]; yylen++)
1102 continue;
1103 return yylen;
1104 }
1105 # endif
1106 # endif
1108 # ifndef yystpcpy
1109 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1110 # define yystpcpy stpcpy
1111 # else
1112 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1113 YYDEST. */
1114 static char *
1115 yystpcpy (char *yydest, const char *yysrc)
1116 {
1117 char *yyd = yydest;
1118 const char *yys = yysrc;
1120 while ((*yyd++ = *yys++) != '\0')
1121 continue;
1123 return yyd - 1;
1124 }
1125 # endif
1126 # endif
1128 # ifndef yytnamerr
1129 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1130 quotes and backslashes, so that it's suitable for yyerror. The
1131 heuristic is that double-quoting is unnecessary unless the string
1132 contains an apostrophe, a comma, or backslash (other than
1133 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1134 null, do not copy; instead, return the length of what the result
1135 would have been. */
1136 static YYSIZE_T
1137 yytnamerr (char *yyres, const char *yystr)
1138 {
1139 if (*yystr == '"')
1140 {
1141 YYSIZE_T yyn = 0;
1142 char const *yyp = yystr;
1144 for (;;)
1145 switch (*++yyp)
1146 {
1147 case '\'':
1148 case ',':
1149 goto do_not_strip_quotes;
1151 case '\\':
1152 if (*++yyp != '\\')
1153 goto do_not_strip_quotes;
1154 /* Fall through. */
1155 default:
1156 if (yyres)
1157 yyres[yyn] = *yyp;
1158 yyn++;
1159 break;
1161 case '"':
1162 if (yyres)
1163 yyres[yyn] = '\0';
1164 return yyn;
1165 }
1166 do_not_strip_quotes: ;
1167 }
1169 if (! yyres)
1170 return yystrlen (yystr);
1172 return yystpcpy (yyres, yystr) - yyres;
1173 }
1174 # endif
1176 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1177 about the unexpected token YYTOKEN for the state stack whose top is
1178 YYSSP.
1180 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1181 not large enough to hold the message. In that case, also set
1182 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1183 required number of bytes is too large to store. */
1184 static int
1185 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1186 yytype_int16 *yyssp, int yytoken)
1187 {
1188 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1189 YYSIZE_T yysize = yysize0;
1190 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1191 /* Internationalized format string. */
1192 const char *yyformat = YY_NULLPTR;
1193 /* Arguments of yyformat. */
1194 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1195 /* Number of reported tokens (one for the "unexpected", one per
1196 "expected"). */
1197 int yycount = 0;
1199 /* There are many possibilities here to consider:
1200 - If this state is a consistent state with a default action, then
1201 the only way this function was invoked is if the default action
1202 is an error action. In that case, don't check for expected
1203 tokens because there are none.
1204 - The only way there can be no lookahead present (in yychar) is if
1205 this state is a consistent state with a default action. Thus,
1206 detecting the absence of a lookahead is sufficient to determine
1207 that there is no unexpected or expected token to report. In that
1208 case, just report a simple "syntax error".
1209 - Don't assume there isn't a lookahead just because this state is a
1210 consistent state with a default action. There might have been a
1211 previous inconsistent state, consistent state with a non-default
1212 action, or user semantic action that manipulated yychar.
1213 - Of course, the expected token list depends on states to have
1214 correct lookahead information, and it depends on the parser not
1215 to perform extra reductions after fetching a lookahead from the
1216 scanner and before detecting a syntax error. Thus, state merging
1217 (from LALR or IELR) and default reductions corrupt the expected
1218 token list. However, the list is correct for canonical LR with
1219 one exception: it will still contain any token that will not be
1220 accepted due to an error action in a later state.
1221 */
1222 if (yytoken != YYEMPTY)
1223 {
1224 int yyn = yypact[*yyssp];
1225 yyarg[yycount++] = yytname[yytoken];
1226 if (!yypact_value_is_default (yyn))
1227 {
1228 /* Start YYX at -YYN if negative to avoid negative indexes in
1229 YYCHECK. In other words, skip the first -YYN actions for
1230 this state because they are default actions. */
1231 int yyxbegin = yyn < 0 ? -yyn : 0;
1232 /* Stay within bounds of both yycheck and yytname. */
1233 int yychecklim = YYLAST - yyn + 1;
1234 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1235 int yyx;
1237 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1238 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1239 && !yytable_value_is_error (yytable[yyx + yyn]))
1240 {
1241 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1242 {
1243 yycount = 1;
1244 yysize = yysize0;
1245 break;
1246 }
1247 yyarg[yycount++] = yytname[yyx];
1248 {
1249 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1250 if (! (yysize <= yysize1
1251 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1252 return 2;
1253 yysize = yysize1;
1254 }
1255 }
1256 }
1257 }
1259 switch (yycount)
1260 {
1261 # define YYCASE_(N, S) \
1262 case N: \
1263 yyformat = S; \
1264 break
1265 YYCASE_(0, YY_("syntax error"));
1266 YYCASE_(1, YY_("syntax error, unexpected %s"));
1267 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1268 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1269 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1270 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1271 # undef YYCASE_
1272 }
1274 {
1275 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1276 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1277 return 2;
1278 yysize = yysize1;
1279 }
1281 if (*yymsg_alloc < yysize)
1282 {
1283 *yymsg_alloc = 2 * yysize;
1284 if (! (yysize <= *yymsg_alloc
1285 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1286 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1287 return 1;
1288 }
1290 /* Avoid sprintf, as that infringes on the user's name space.
1291 Don't have undefined behavior even if the translation
1292 produced a string with the wrong number of "%s"s. */
1293 {
1294 char *yyp = *yymsg;
1295 int yyi = 0;
1296 while ((*yyp = *yyformat) != '\0')
1297 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1298 {
1299 yyp += yytnamerr (yyp, yyarg[yyi++]);
1300 yyformat += 2;
1301 }
1302 else
1303 {
1304 yyp++;
1305 yyformat++;
1306 }
1307 }
1308 return 0;
1309 }
1310 #endif /* YYERROR_VERBOSE */
1312 /*-----------------------------------------------.
1313 | Release the memory associated to this symbol. |
1314 `-----------------------------------------------*/
1316 static void
1317 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1318 {
1319 YYUSE (yyvaluep);
1320 if (!yymsg)
1321 yymsg = "Deleting";
1322 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1324 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1325 YYUSE (yytype);
1326 YY_IGNORE_MAYBE_UNINITIALIZED_END
1327 }
1332 /* The lookahead symbol. */
1333 int yychar;
1335 /* The semantic value of the lookahead symbol. */
1336 YYSTYPE yylval;
1337 /* Number of syntax errors so far. */
1338 int yynerrs;
1341 /*----------.
1342 | yyparse. |
1343 `----------*/
1345 int
1346 yyparse (void)
1347 {
1348 int yystate;
1349 /* Number of tokens to shift before error messages enabled. */
1350 int yyerrstatus;
1352 /* The stacks and their tools:
1353 'yyss': related to states.
1354 'yyvs': related to semantic values.
1356 Refer to the stacks through separate pointers, to allow yyoverflow
1357 to reallocate them elsewhere. */
1359 /* The state stack. */
1360 yytype_int16 yyssa[YYINITDEPTH];
1361 yytype_int16 *yyss;
1362 yytype_int16 *yyssp;
1364 /* The semantic value stack. */
1365 YYSTYPE yyvsa[YYINITDEPTH];
1366 YYSTYPE *yyvs;
1367 YYSTYPE *yyvsp;
1369 YYSIZE_T yystacksize;
1371 int yyn;
1372 int yyresult;
1373 /* Lookahead token as an internal (translated) token number. */
1374 int yytoken = 0;
1375 /* The variables used to return semantic value and location from the
1376 action routines. */
1377 YYSTYPE yyval;
1379 #if YYERROR_VERBOSE
1380 /* Buffer for error messages, and its allocated size. */
1381 char yymsgbuf[128];
1382 char *yymsg = yymsgbuf;
1383 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1384 #endif
1386 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1388 /* The number of symbols on the RHS of the reduced rule.
1389 Keep to zero when no symbol should be popped. */
1390 int yylen = 0;
1392 yyssp = yyss = yyssa;
1393 yyvsp = yyvs = yyvsa;
1394 yystacksize = YYINITDEPTH;
1396 YYDPRINTF ((stderr, "Starting parse\n"));
1398 yystate = 0;
1399 yyerrstatus = 0;
1400 yynerrs = 0;
1401 yychar = YYEMPTY; /* Cause a token to be read. */
1402 goto yysetstate;
1404 /*------------------------------------------------------------.
1405 | yynewstate -- Push a new state, which is found in yystate. |
1406 `------------------------------------------------------------*/
1407 yynewstate:
1408 /* In all cases, when you get here, the value and location stacks
1409 have just been pushed. So pushing a state here evens the stacks. */
1410 yyssp++;
1412 yysetstate:
1413 *yyssp = yystate;
1415 if (yyss + yystacksize - 1 <= yyssp)
1416 {
1417 /* Get the current used size of the three stacks, in elements. */
1418 YYSIZE_T yysize = yyssp - yyss + 1;
1420 #ifdef yyoverflow
1421 {
1422 /* Give user a chance to reallocate the stack. Use copies of
1423 these so that the &'s don't force the real ones into
1424 memory. */
1425 YYSTYPE *yyvs1 = yyvs;
1426 yytype_int16 *yyss1 = yyss;
1428 /* Each stack pointer address is followed by the size of the
1429 data in use in that stack, in bytes. This used to be a
1430 conditional around just the two extra args, but that might
1431 be undefined if yyoverflow is a macro. */
1432 yyoverflow (YY_("memory exhausted"),
1433 &yyss1, yysize * sizeof (*yyssp),
1434 &yyvs1, yysize * sizeof (*yyvsp),
1435 &yystacksize);
1437 yyss = yyss1;
1438 yyvs = yyvs1;
1439 }
1440 #else /* no yyoverflow */
1441 # ifndef YYSTACK_RELOCATE
1442 goto yyexhaustedlab;
1443 # else
1444 /* Extend the stack our own way. */
1445 if (YYMAXDEPTH <= yystacksize)
1446 goto yyexhaustedlab;
1447 yystacksize *= 2;
1448 if (YYMAXDEPTH < yystacksize)
1449 yystacksize = YYMAXDEPTH;
1451 {
1452 yytype_int16 *yyss1 = yyss;
1453 union yyalloc *yyptr =
1454 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1455 if (! yyptr)
1456 goto yyexhaustedlab;
1457 YYSTACK_RELOCATE (yyss_alloc, yyss);
1458 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1459 # undef YYSTACK_RELOCATE
1460 if (yyss1 != yyssa)
1461 YYSTACK_FREE (yyss1);
1462 }
1463 # endif
1464 #endif /* no yyoverflow */
1466 yyssp = yyss + yysize - 1;
1467 yyvsp = yyvs + yysize - 1;
1469 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1470 (unsigned long int) yystacksize));
1472 if (yyss + yystacksize - 1 <= yyssp)
1473 YYABORT;
1474 }
1476 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1478 if (yystate == YYFINAL)
1479 YYACCEPT;
1481 goto yybackup;
1483 /*-----------.
1484 | yybackup. |
1485 `-----------*/
1486 yybackup:
1488 /* Do appropriate processing given the current state. Read a
1489 lookahead token if we need one and don't already have one. */
1491 /* First try to decide what to do without reference to lookahead token. */
1492 yyn = yypact[yystate];
1493 if (yypact_value_is_default (yyn))
1494 goto yydefault;
1496 /* Not known => get a lookahead token if don't already have one. */
1498 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1499 if (yychar == YYEMPTY)
1500 {
1501 YYDPRINTF ((stderr, "Reading a token: "));
1502 yychar = yylex ();
1503 }
1505 if (yychar <= YYEOF)
1506 {
1507 yychar = yytoken = YYEOF;
1508 YYDPRINTF ((stderr, "Now at end of input.\n"));
1509 }
1510 else
1511 {
1512 yytoken = YYTRANSLATE (yychar);
1513 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1514 }
1516 /* If the proper action on seeing token YYTOKEN is to reduce or to
1517 detect an error, take that action. */
1518 yyn += yytoken;
1519 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1520 goto yydefault;
1521 yyn = yytable[yyn];
1522 if (yyn <= 0)
1523 {
1524 if (yytable_value_is_error (yyn))
1525 goto yyerrlab;
1526 yyn = -yyn;
1527 goto yyreduce;
1528 }
1530 /* Count tokens shifted since error; after three, turn off error
1531 status. */
1532 if (yyerrstatus)
1533 yyerrstatus--;
1535 /* Shift the lookahead token. */
1536 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1538 /* Discard the shifted token. */
1539 yychar = YYEMPTY;
1541 yystate = yyn;
1542 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1543 *++yyvsp = yylval;
1544 YY_IGNORE_MAYBE_UNINITIALIZED_END
1546 goto yynewstate;
1549 /*-----------------------------------------------------------.
1550 | yydefault -- do the default action for the current state. |
1551 `-----------------------------------------------------------*/
1552 yydefault:
1553 yyn = yydefact[yystate];
1554 if (yyn == 0)
1555 goto yyerrlab;
1556 goto yyreduce;
1559 /*-----------------------------.
1560 | yyreduce -- Do a reduction. |
1561 `-----------------------------*/
1562 yyreduce:
1563 /* yyn is the number of a rule to reduce with. */
1564 yylen = yyr2[yyn];
1566 /* If YYLEN is nonzero, implement the default value of the action:
1567 '$$ = $1'.
1569 Otherwise, the following line sets YYVAL to garbage.
1570 This behavior is undocumented and Bison
1571 users should not rely upon it. Assigning to YYVAL
1572 unconditionally makes the parser a bit smaller, and it avoids a
1573 GCC warning that YYVAL may be used uninitialized. */
1574 yyval = yyvsp[1-yylen];
1577 YY_REDUCE_PRINT (yyn);
1578 switch (yyn)
1579 {
1580 case 3:
1582 { empty_field_table(); YYACCEPT;}
1584 break;
1586 case 4:
1588 { fprintf (stderr, "Parsed all bytes\n");
1589 empty_field_table(); YYACCEPT;}
1591 break;
1593 case 5:
1595 { generate_setter_bitfields(binary->actualblob); }
1597 break;
1599 case 6:
1601 { fprintf (stderr, "No spec\n"); }
1603 break;
1605 case 7:
1607 { fprintf (stderr, "Parsed all spec\n");
1608 create_binary_blob(); }
1610 break;
1612 case 10:
1614 { create_new_bitfield((yyvsp[-2].str), (yyvsp[0].u32)); }
1616 break;
1618 case 11:
1620 { create_new_bitfields((yyvsp[-5].str), (yyvsp[-3].u32), (yyvsp[0].u32)); }
1622 break;
1624 case 12:
1626 { fprintf (stderr, "No values\n"); }
1628 break;
1630 case 13:
1632 { fprintf (stderr, "Parsed all values\n");
1633 generate_binary(); }
1635 break;
1637 case 16:
1639 { set_bitfield((yyvsp[-2].str), (yyvsp[0].u32)); }
1641 break;
1643 case 17:
1645 { set_bitfield_array((yyvsp[-5].str), (yyvsp[-3].u32), (yyvsp[0].u32)); }
1647 break;
1651 default: break;
1652 }
1653 /* User semantic actions sometimes alter yychar, and that requires
1654 that yytoken be updated with the new translation. We take the
1655 approach of translating immediately before every use of yytoken.
1656 One alternative is translating here after every semantic action,
1657 but that translation would be missed if the semantic action invokes
1658 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1659 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1660 incorrect destructor might then be invoked immediately. In the
1661 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1662 to an incorrect destructor call or verbose syntax error message
1663 before the lookahead is translated. */
1664 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1666 YYPOPSTACK (yylen);
1667 yylen = 0;
1668 YY_STACK_PRINT (yyss, yyssp);
1670 *++yyvsp = yyval;
1672 /* Now 'shift' the result of the reduction. Determine what state
1673 that goes to, based on the state we popped back to and the rule
1674 number reduced by. */
1676 yyn = yyr1[yyn];
1678 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1679 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1680 yystate = yytable[yystate];
1681 else
1682 yystate = yydefgoto[yyn - YYNTOKENS];
1684 goto yynewstate;
1687 /*--------------------------------------.
1688 | yyerrlab -- here on detecting error. |
1689 `--------------------------------------*/
1690 yyerrlab:
1691 /* Make sure we have latest lookahead translation. See comments at
1692 user semantic actions for why this is necessary. */
1693 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1695 /* If not already recovering from an error, report this error. */
1696 if (!yyerrstatus)
1697 {
1698 ++yynerrs;
1699 #if ! YYERROR_VERBOSE
1700 yyerror (YY_("syntax error"));
1701 #else
1702 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1703 yyssp, yytoken)
1704 {
1705 char const *yymsgp = YY_("syntax error");
1706 int yysyntax_error_status;
1707 yysyntax_error_status = YYSYNTAX_ERROR;
1708 if (yysyntax_error_status == 0)
1709 yymsgp = yymsg;
1710 else if (yysyntax_error_status == 1)
1711 {
1712 if (yymsg != yymsgbuf)
1713 YYSTACK_FREE (yymsg);
1714 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1715 if (!yymsg)
1716 {
1717 yymsg = yymsgbuf;
1718 yymsg_alloc = sizeof yymsgbuf;
1719 yysyntax_error_status = 2;
1720 }
1721 else
1722 {
1723 yysyntax_error_status = YYSYNTAX_ERROR;
1724 yymsgp = yymsg;
1725 }
1726 }
1727 yyerror (yymsgp);
1728 if (yysyntax_error_status == 2)
1729 goto yyexhaustedlab;
1730 }
1731 # undef YYSYNTAX_ERROR
1732 #endif
1733 }
1737 if (yyerrstatus == 3)
1738 {
1739 /* If just tried and failed to reuse lookahead token after an
1740 error, discard it. */
1742 if (yychar <= YYEOF)
1743 {
1744 /* Return failure if at end of input. */
1745 if (yychar == YYEOF)
1746 YYABORT;
1747 }
1748 else
1749 {
1750 yydestruct ("Error: discarding",
1751 yytoken, &yylval);
1752 yychar = YYEMPTY;
1753 }
1754 }
1756 /* Else will try to reuse lookahead token after shifting the error
1757 token. */
1758 goto yyerrlab1;
1761 /*---------------------------------------------------.
1762 | yyerrorlab -- error raised explicitly by YYERROR. |
1763 `---------------------------------------------------*/
1764 yyerrorlab:
1766 /* Pacify compilers like GCC when the user code never invokes
1767 YYERROR and the label yyerrorlab therefore never appears in user
1768 code. */
1769 if (/*CONSTCOND*/ 0)
1770 goto yyerrorlab;
1772 /* Do not reclaim the symbols of the rule whose action triggered
1773 this YYERROR. */
1774 YYPOPSTACK (yylen);
1775 yylen = 0;
1776 YY_STACK_PRINT (yyss, yyssp);
1777 yystate = *yyssp;
1778 goto yyerrlab1;
1781 /*-------------------------------------------------------------.
1782 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1783 `-------------------------------------------------------------*/
1784 yyerrlab1:
1785 yyerrstatus = 3; /* Each real token shifted decrements this. */
1787 for (;;)
1788 {
1789 yyn = yypact[yystate];
1790 if (!yypact_value_is_default (yyn))
1791 {
1792 yyn += YYTERROR;
1793 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1794 {
1795 yyn = yytable[yyn];
1796 if (0 < yyn)
1797 break;
1798 }
1799 }
1801 /* Pop the current state because it cannot handle the error token. */
1802 if (yyssp == yyss)
1803 YYABORT;
1806 yydestruct ("Error: popping",
1807 yystos[yystate], yyvsp);
1808 YYPOPSTACK (1);
1809 yystate = *yyssp;
1810 YY_STACK_PRINT (yyss, yyssp);
1811 }
1813 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1814 *++yyvsp = yylval;
1815 YY_IGNORE_MAYBE_UNINITIALIZED_END
1818 /* Shift the error token. */
1819 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1821 yystate = yyn;
1822 goto yynewstate;
1825 /*-------------------------------------.
1826 | yyacceptlab -- YYACCEPT comes here. |
1827 `-------------------------------------*/
1828 yyacceptlab:
1829 yyresult = 0;
1830 goto yyreturn;
1832 /*-----------------------------------.
1833 | yyabortlab -- YYABORT comes here. |
1834 `-----------------------------------*/
1835 yyabortlab:
1836 yyresult = 1;
1837 goto yyreturn;
1839 #if !defined yyoverflow || YYERROR_VERBOSE
1840 /*-------------------------------------------------.
1841 | yyexhaustedlab -- memory exhaustion comes here. |
1842 `-------------------------------------------------*/
1843 yyexhaustedlab:
1844 yyerror (YY_("memory exhausted"));
1845 yyresult = 2;
1846 /* Fall through. */
1847 #endif
1849 yyreturn:
1850 if (yychar != YYEMPTY)
1851 {
1852 /* Make sure we have latest lookahead translation. See comments at
1853 user semantic actions for why this is necessary. */
1854 yytoken = YYTRANSLATE (yychar);
1855 yydestruct ("Cleanup: discarding lookahead",
1856 yytoken, &yylval);
1857 }
1858 /* Do not reclaim the symbols of the rule whose action triggered
1859 this YYABORT or YYACCEPT. */
1860 YYPOPSTACK (yylen);
1861 YY_STACK_PRINT (yyss, yyssp);
1862 while (yyssp != yyss)
1863 {
1864 yydestruct ("Cleanup: popping",
1865 yystos[*yyssp], yyvsp);
1866 YYPOPSTACK (1);
1867 }
1868 #ifndef yyoverflow
1869 if (yyss != yyssa)
1870 YYSTACK_FREE (yyss);
1871 #endif
1872 #if YYERROR_VERBOSE
1873 if (yymsg != yymsgbuf)
1874 YYSTACK_FREE (yymsg);
1875 #endif
1876 return yyresult;
1877 }
1881 /* Called by yyparse on error. */
1882 void yyerror (char const *s)
1883 {
1884 fprintf (stderr, "yyerror: %s\n", s);
1885 }
1887 /* Declarations */
1888 void set_input_string(char* in);
1890 /* This function parses a string */
1891 static int parse_string(unsigned char* in) {
1892 set_input_string ((char *)in);
1893 return yyparse ();
1894 }
1896 static unsigned int loadfile (char *file, char *filetype,
1897 unsigned char **parsestring, unsigned int lenstr)
1898 {
1899 unsigned int lenfile;
1901 if ((fp = fopen(file, "r")) == NULL) {
1902 printf("Error: Could not open %s file: %s\n",filetype,file);
1903 exit(1);
1904 }
1905 fseek(fp, 0, SEEK_END);
1906 lenfile = ftell(fp);
1907 fseek(fp, 0, SEEK_SET);
1909 if (lenstr == 0)
1910 *parsestring = (unsigned char *) malloc (lenfile + 2);
1911 else
1912 *parsestring = (unsigned char *) realloc (*parsestring,
1913 lenfile + lenstr);
1915 check_pointer(*parsestring);
1916 fread(*parsestring + lenstr, 1, lenfile, fp);
1917 fclose(fp);
1918 return lenfile;
1919 }
1921 int main (int argc, char *argv[])
1922 {
1923 unsigned int lenspec;
1924 unsigned char *parsestring;
1925 unsigned char c;
1926 unsigned int pos = 0;
1927 int ret = 0;
1929 #if YYDEBUG == 1
1930 yydebug = 1;
1931 #endif
1932 create_binary_blob();
1933 binary->lenactualblob = 0;
1935 if (argc == 4 && strcmp(argv[1], "-d") != 0) {
1936 /* Compile mode */
1938 /* Load Spec */
1939 lenspec = loadfile(argv[1], "spec", &parsestring, 0);
1940 loadfile(argv[2], "setter", &parsestring, lenspec);
1942 /* Open output and parse string - output to fp */
1943 if ((fp = fopen(argv[3], "wb")) == NULL) {
1944 printf("Error: Could not open output file: %s\n",argv[3]);
1945 exit(1);
1946 }
1947 ret = parse_string(parsestring);
1948 free(parsestring);
1949 } else if (argc == 5 && strcmp (argv[1], "-d") == 0) {
1950 /* Decompile mode */
1952 /* Load Spec */
1953 lenspec = loadfile(argv[2], "spec", &parsestring, 0);
1955 parsestring[lenspec] = '%';
1956 parsestring[lenspec + 1] = '\0';
1958 /* Load Actual Binary */
1959 if ((fp = fopen(argv[3], "rb")) == NULL) {
1960 printf("Error: Could not open binary file: %s\n",argv[3]);
1961 exit(1);
1962 }
1963 fseek(fp, 0, SEEK_END);
1964 binary->lenactualblob = ftell(fp);
1965 fseek(fp, 0, SEEK_SET);
1966 binary->actualblob = (unsigned char *) malloc (binary->lenactualblob);
1967 check_pointer(binary->actualblob);
1968 fread(binary->actualblob, 1, binary->lenactualblob, fp);
1969 fclose(fp);
1971 /* Open output and parse - output to fp */
1972 if ((fp = fopen(argv[4], "w")) == NULL) {
1973 printf("Error: Could not open output file: %s\n",argv[4]);
1974 exit(1);
1975 }
1976 ret = parse_string(parsestring);
1977 free(parsestring);
1978 free(binary->actualblob);
1979 fclose(fp);
1980 } else {
1981 printf("Usage: Compile mode\n\n");
1982 printf(" bincfg spec setter binaryoutput\n");
1983 printf(" (file) (file) (file)\n");
1984 printf(" OR : Decompile mode\n\n");
1985 printf(" bincfg -d spec binary setteroutput\n");
1986 }
1987 return ret;
1988 }