| blob | aea514fa69286401700e2d6786af0bd587acd8b4 |
1 /* A Bison parser, made by GNU Bison 3.0.4. */
3 /* Bison implementation for Yacc-like parsers in C
5 Copyright (C) 1984, 1989-1990, 2000-2015 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.4"
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. */
65 #line 20 "dtc-parser.y" /* yacc.c:339 */
67 #include <stdio.h>
68 #include <inttypes.h>
70 #include "dtc.h"
71 #include "srcpos.h"
73 extern int yylex(void);
74 extern void yyerror(char const *s);
75 #define ERROR(loc, ...) \
76 do { \
77 srcpos_error((loc), "Error", __VA_ARGS__); \
78 treesource_error = true; \
79 } while (0)
81 extern struct dt_info *parser_output;
82 extern bool treesource_error;
84 #line 85 "dtc-parser.tab.c" /* yacc.c:339 */
86 # ifndef YY_NULLPTR
87 # if defined __cplusplus && 201103L <= __cplusplus
88 # define YY_NULLPTR nullptr
89 # else
90 # define YY_NULLPTR 0
91 # endif
92 # endif
94 /* Enabling verbose error messages. */
95 #ifdef YYERROR_VERBOSE
96 # undef YYERROR_VERBOSE
97 # define YYERROR_VERBOSE 1
98 #else
99 # define YYERROR_VERBOSE 0
100 #endif
102 /* In a future release of Bison, this section will be replaced
103 by #include "dtc-parser.tab.h". */
104 #ifndef YY_YY_DTC_PARSER_TAB_H_INCLUDED
105 # define YY_YY_DTC_PARSER_TAB_H_INCLUDED
106 /* Debug traces. */
107 #ifndef YYDEBUG
108 # define YYDEBUG 0
109 #endif
110 #if YYDEBUG
111 extern int yydebug;
112 #endif
114 /* Token type. */
115 #ifndef YYTOKENTYPE
116 # define YYTOKENTYPE
117 enum yytokentype
118 {
119 DT_V1 = 258,
120 DT_PLUGIN = 259,
121 DT_MEMRESERVE = 260,
122 DT_LSHIFT = 261,
123 DT_RSHIFT = 262,
124 DT_LE = 263,
125 DT_GE = 264,
126 DT_EQ = 265,
127 DT_NE = 266,
128 DT_AND = 267,
129 DT_OR = 268,
130 DT_BITS = 269,
131 DT_DEL_PROP = 270,
132 DT_DEL_NODE = 271,
133 DT_PROPNODENAME = 272,
134 DT_LITERAL = 273,
135 DT_CHAR_LITERAL = 274,
136 DT_BYTE = 275,
137 DT_STRING = 276,
138 DT_LABEL = 277,
139 DT_REF = 278,
140 DT_INCBIN = 279
141 };
142 #endif
144 /* Value type. */
145 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
147 union YYSTYPE
148 {
149 #line 39 "dtc-parser.y" /* yacc.c:355 */
151 char *propnodename;
152 char *labelref;
153 uint8_t byte;
154 struct data data;
156 struct {
157 struct data data;
158 int bits;
159 } array;
161 struct property *prop;
162 struct property *proplist;
163 struct node *node;
164 struct node *nodelist;
165 struct reserve_info *re;
166 uint64_t integer;
167 unsigned int flags;
169 #line 170 "dtc-parser.tab.c" /* yacc.c:355 */
170 };
172 typedef union YYSTYPE YYSTYPE;
173 # define YYSTYPE_IS_TRIVIAL 1
174 # define YYSTYPE_IS_DECLARED 1
175 #endif
177 /* Location type. */
178 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
179 typedef struct YYLTYPE YYLTYPE;
180 struct YYLTYPE
181 {
182 int first_line;
183 int first_column;
184 int last_line;
185 int last_column;
186 };
187 # define YYLTYPE_IS_DECLARED 1
188 # define YYLTYPE_IS_TRIVIAL 1
189 #endif
192 extern YYSTYPE yylval;
193 extern YYLTYPE yylloc;
194 int yyparse (void);
196 #endif /* !YY_YY_DTC_PARSER_TAB_H_INCLUDED */
198 /* Copy the second part of user declarations. */
200 #line 201 "dtc-parser.tab.c" /* yacc.c:358 */
202 #ifdef short
203 # undef short
204 #endif
206 #ifdef YYTYPE_UINT8
207 typedef YYTYPE_UINT8 yytype_uint8;
208 #else
209 typedef unsigned char yytype_uint8;
210 #endif
212 #ifdef YYTYPE_INT8
213 typedef YYTYPE_INT8 yytype_int8;
214 #else
215 typedef signed char yytype_int8;
216 #endif
218 #ifdef YYTYPE_UINT16
219 typedef YYTYPE_UINT16 yytype_uint16;
220 #else
221 typedef unsigned short int yytype_uint16;
222 #endif
224 #ifdef YYTYPE_INT16
225 typedef YYTYPE_INT16 yytype_int16;
226 #else
227 typedef short int yytype_int16;
228 #endif
230 #ifndef YYSIZE_T
231 # ifdef __SIZE_TYPE__
232 # define YYSIZE_T __SIZE_TYPE__
233 # elif defined size_t
234 # define YYSIZE_T size_t
235 # elif ! defined YYSIZE_T
236 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
237 # define YYSIZE_T size_t
238 # else
239 # define YYSIZE_T unsigned int
240 # endif
241 #endif
243 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
245 #ifndef YY_
246 # if defined YYENABLE_NLS && YYENABLE_NLS
247 # if ENABLE_NLS
248 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
249 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
250 # endif
251 # endif
252 # ifndef YY_
253 # define YY_(Msgid) Msgid
254 # endif
255 #endif
257 #ifndef YY_ATTRIBUTE
258 # if (defined __GNUC__ \
259 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
260 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
261 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
262 # else
263 # define YY_ATTRIBUTE(Spec) /* empty */
264 # endif
265 #endif
267 #ifndef YY_ATTRIBUTE_PURE
268 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
269 #endif
271 #ifndef YY_ATTRIBUTE_UNUSED
272 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
273 #endif
275 #if !defined _Noreturn \
276 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
277 # if defined _MSC_VER && 1200 <= _MSC_VER
278 # define _Noreturn __declspec (noreturn)
279 # else
280 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
281 # endif
282 #endif
284 /* Suppress unused-variable warnings by "using" E. */
285 #if ! defined lint || defined __GNUC__
286 # define YYUSE(E) ((void) (E))
287 #else
288 # define YYUSE(E) /* empty */
289 #endif
291 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
292 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
293 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
294 _Pragma ("GCC diagnostic push") \
295 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
296 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
297 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
298 _Pragma ("GCC diagnostic pop")
299 #else
300 # define YY_INITIAL_VALUE(Value) Value
301 #endif
302 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
303 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
304 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
305 #endif
306 #ifndef YY_INITIAL_VALUE
307 # define YY_INITIAL_VALUE(Value) /* Nothing. */
308 #endif
311 #if ! defined yyoverflow || YYERROR_VERBOSE
313 /* The parser invokes alloca or malloc; define the necessary symbols. */
315 # ifdef YYSTACK_USE_ALLOCA
316 # if YYSTACK_USE_ALLOCA
317 # ifdef __GNUC__
318 # define YYSTACK_ALLOC __builtin_alloca
319 # elif defined __BUILTIN_VA_ARG_INCR
320 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
321 # elif defined _AIX
322 # define YYSTACK_ALLOC __alloca
323 # elif defined _MSC_VER
324 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
325 # define alloca _alloca
326 # else
327 # define YYSTACK_ALLOC alloca
328 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
329 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
330 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
331 # ifndef EXIT_SUCCESS
332 # define EXIT_SUCCESS 0
333 # endif
334 # endif
335 # endif
336 # endif
337 # endif
339 # ifdef YYSTACK_ALLOC
340 /* Pacify GCC's 'empty if-body' warning. */
341 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
342 # ifndef YYSTACK_ALLOC_MAXIMUM
343 /* The OS might guarantee only one guard page at the bottom of the stack,
344 and a page size can be as small as 4096 bytes. So we cannot safely
345 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
346 to allow for a few compiler-allocated temporary stack slots. */
347 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
348 # endif
349 # else
350 # define YYSTACK_ALLOC YYMALLOC
351 # define YYSTACK_FREE YYFREE
352 # ifndef YYSTACK_ALLOC_MAXIMUM
353 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
354 # endif
355 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
356 && ! ((defined YYMALLOC || defined malloc) \
357 && (defined YYFREE || defined free)))
358 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
359 # ifndef EXIT_SUCCESS
360 # define EXIT_SUCCESS 0
361 # endif
362 # endif
363 # ifndef YYMALLOC
364 # define YYMALLOC malloc
365 # if ! defined malloc && ! defined EXIT_SUCCESS
366 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
367 # endif
368 # endif
369 # ifndef YYFREE
370 # define YYFREE free
371 # if ! defined free && ! defined EXIT_SUCCESS
372 void free (void *); /* INFRINGES ON USER NAME SPACE */
373 # endif
374 # endif
375 # endif
376 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
379 #if (! defined yyoverflow \
380 && (! defined __cplusplus \
381 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
382 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
384 /* A type that is properly aligned for any stack member. */
385 union yyalloc
386 {
387 yytype_int16 yyss_alloc;
388 YYSTYPE yyvs_alloc;
389 YYLTYPE yyls_alloc;
390 };
392 /* The size of the maximum gap between one aligned stack and the next. */
393 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
395 /* The size of an array large to enough to hold all stacks, each with
396 N elements. */
397 # define YYSTACK_BYTES(N) \
398 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
399 + 2 * YYSTACK_GAP_MAXIMUM)
401 # define YYCOPY_NEEDED 1
403 /* Relocate STACK from its old location to the new one. The
404 local variables YYSIZE and YYSTACKSIZE give the old and new number of
405 elements in the stack, and YYPTR gives the new location of the
406 stack. Advance YYPTR to a properly aligned location for the next
407 stack. */
408 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
409 do \
410 { \
411 YYSIZE_T yynewbytes; \
412 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
413 Stack = &yyptr->Stack_alloc; \
414 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
415 yyptr += yynewbytes / sizeof (*yyptr); \
416 } \
417 while (0)
419 #endif
421 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
422 /* Copy COUNT objects from SRC to DST. The source and destination do
423 not overlap. */
424 # ifndef YYCOPY
425 # if defined __GNUC__ && 1 < __GNUC__
426 # define YYCOPY(Dst, Src, Count) \
427 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
428 # else
429 # define YYCOPY(Dst, Src, Count) \
430 do \
431 { \
432 YYSIZE_T yyi; \
433 for (yyi = 0; yyi < (Count); yyi++) \
434 (Dst)[yyi] = (Src)[yyi]; \
435 } \
436 while (0)
437 # endif
438 # endif
439 #endif /* !YYCOPY_NEEDED */
441 /* YYFINAL -- State number of the termination state. */
442 #define YYFINAL 6
443 /* YYLAST -- Last index in YYTABLE. */
444 #define YYLAST 138
446 /* YYNTOKENS -- Number of terminals. */
447 #define YYNTOKENS 48
448 /* YYNNTS -- Number of nonterminals. */
449 #define YYNNTS 30
450 /* YYNRULES -- Number of rules. */
451 #define YYNRULES 85
452 /* YYNSTATES -- Number of states. */
453 #define YYNSTATES 149
455 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
456 by yylex, with out-of-bounds checking. */
457 #define YYUNDEFTOK 2
458 #define YYMAXUTOK 279
460 #define YYTRANSLATE(YYX) \
461 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
463 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
464 as returned by yylex, without out-of-bounds checking. */
465 static const yytype_uint8 yytranslate[] =
466 {
467 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
468 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
469 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470 2, 2, 2, 47, 2, 2, 2, 45, 41, 2,
471 33, 35, 44, 42, 34, 43, 2, 26, 2, 2,
472 2, 2, 2, 2, 2, 2, 2, 2, 38, 25,
473 36, 29, 30, 37, 2, 2, 2, 2, 2, 2,
474 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
475 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
476 2, 31, 2, 32, 40, 2, 2, 2, 2, 2,
477 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 27, 39, 28, 46, 2, 2, 2,
480 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
493 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
494 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
495 };
497 #if YYDEBUG
498 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
499 static const yytype_uint16 yyrline[] =
500 {
501 0, 109, 109, 117, 121, 128, 129, 139, 142, 149,
502 153, 161, 165, 170, 181, 200, 213, 220, 228, 231,
503 238, 242, 246, 250, 258, 262, 266, 270, 274, 290,
504 300, 308, 311, 315, 322, 338, 343, 362, 376, 383,
505 384, 385, 392, 396, 397, 401, 402, 406, 407, 411,
506 412, 416, 417, 421, 422, 426, 427, 428, 432, 433,
507 434, 435, 436, 440, 441, 442, 446, 447, 448, 452,
508 453, 462, 471, 475, 476, 477, 478, 483, 486, 490,
509 498, 501, 505, 513, 517, 521
510 };
511 #endif
513 #if YYDEBUG || YYERROR_VERBOSE || 0
514 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
515 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
516 static const char *const yytname[] =
517 {
518 "$end", "error", "$undefined", "DT_V1", "DT_PLUGIN", "DT_MEMRESERVE",
519 "DT_LSHIFT", "DT_RSHIFT", "DT_LE", "DT_GE", "DT_EQ", "DT_NE", "DT_AND",
520 "DT_OR", "DT_BITS", "DT_DEL_PROP", "DT_DEL_NODE", "DT_PROPNODENAME",
521 "DT_LITERAL", "DT_CHAR_LITERAL", "DT_BYTE", "DT_STRING", "DT_LABEL",
522 "DT_REF", "DT_INCBIN", "';'", "'/'", "'{'", "'}'", "'='", "'>'", "'['",
523 "']'", "'('", "','", "')'", "'<'", "'?'", "':'", "'|'", "'^'", "'&'",
524 "'+'", "'-'", "'*'", "'%'", "'~'", "'!'", "$accept", "sourcefile",
525 "header", "headers", "memreserves", "memreserve", "devicetree",
526 "nodedef", "proplist", "propdef", "propdata", "propdataprefix",
527 "arrayprefix", "integer_prim", "integer_expr", "integer_trinary",
528 "integer_or", "integer_and", "integer_bitor", "integer_bitxor",
529 "integer_bitand", "integer_eq", "integer_rela", "integer_shift",
530 "integer_add", "integer_mul", "integer_unary", "bytestring", "subnodes",
531 "subnode", YY_NULLPTR
532 };
533 #endif
535 # ifdef YYPRINT
536 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
537 (internal) symbol number NUM (which must be that of a token). */
538 static const yytype_uint16 yytoknum[] =
539 {
540 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
541 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
542 275, 276, 277, 278, 279, 59, 47, 123, 125, 61,
543 62, 91, 93, 40, 44, 41, 60, 63, 58, 124,
544 94, 38, 43, 45, 42, 37, 126, 33
545 };
546 # endif
548 #define YYPACT_NINF -44
550 #define yypact_value_is_default(Yystate) \
551 (!!((Yystate) == (-44)))
553 #define YYTABLE_NINF -1
555 #define yytable_value_is_error(Yytable_value) \
556 0
558 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
559 STATE-NUM. */
560 static const yytype_int8 yypact[] =
561 {
562 14, 27, 61, 14, 8, 18, -44, -44, 37, 8,
563 40, 8, 64, -44, -44, -12, 37, -44, 50, 52,
564 -44, -44, -12, -12, -12, -44, 51, -44, -4, 78,
565 53, 54, 55, 17, 2, 30, 38, -3, -44, 66,
566 -44, -44, 70, 72, 50, 50, -44, -44, -44, -44,
567 -12, -12, -12, -12, -12, -12, -12, -12, -12, -12,
568 -12, -12, -12, -12, -12, -12, -12, -12, -12, -44,
569 3, 73, 50, -44, -44, 78, 59, 53, 54, 55,
570 17, 2, 2, 30, 30, 30, 30, 38, 38, -3,
571 -3, -44, -44, -44, 82, 83, 44, 3, -44, 74,
572 3, -44, -44, -12, 76, 79, -44, -44, -44, -44,
573 -44, 80, -44, -44, -44, -44, -44, -10, 36, -44,
574 -44, -44, -44, 85, -44, -44, -44, 75, -44, -44,
575 21, 71, 88, -6, -44, -44, -44, -44, -44, 11,
576 -44, -44, -44, 37, -44, 77, 37, 81, -44
577 };
579 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
580 Performed when YYTABLE does not specify something else to do. Zero
581 means the default is an error. */
582 static const yytype_uint8 yydefact[] =
583 {
584 0, 0, 0, 5, 7, 3, 1, 6, 0, 0,
585 16, 7, 0, 39, 40, 0, 0, 10, 0, 2,
586 8, 4, 0, 0, 0, 73, 0, 42, 43, 45,
587 47, 49, 51, 53, 55, 58, 65, 68, 72, 0,
588 18, 11, 0, 0, 0, 0, 74, 75, 76, 41,
589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
590 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
591 80, 0, 0, 14, 12, 46, 0, 48, 50, 52,
592 54, 56, 57, 61, 62, 60, 59, 63, 64, 66,
593 67, 70, 69, 71, 0, 0, 0, 0, 19, 0,
594 80, 15, 13, 0, 0, 0, 21, 31, 83, 23,
595 85, 0, 82, 81, 44, 22, 84, 0, 0, 17,
596 30, 20, 32, 0, 24, 33, 27, 0, 77, 35,
597 0, 0, 0, 0, 38, 37, 25, 36, 34, 0,
598 78, 79, 26, 0, 29, 0, 0, 0, 28
599 };
601 /* YYPGOTO[NTERM-NUM]. */
602 static const yytype_int8 yypgoto[] =
603 {
604 -44, -44, -44, 103, 99, 104, -44, -43, -44, -21,
605 -44, -44, -44, -8, 63, 9, -44, 65, 67, 68,
606 69, 62, 26, 4, 22, 23, -19, -44, 20, 28
607 };
609 /* YYDEFGOTO[NTERM-NUM]. */
610 static const yytype_int16 yydefgoto[] =
611 {
612 -1, 2, 3, 4, 10, 11, 19, 41, 70, 98,
613 117, 118, 130, 25, 26, 27, 28, 29, 30, 31,
614 32, 33, 34, 35, 36, 37, 38, 133, 99, 100
615 };
617 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
618 positive, shift that token. If negative, reduce the rule whose
619 number is the opposite. If YYTABLE_NINF, syntax error. */
620 static const yytype_uint8 yytable[] =
621 {
622 16, 73, 74, 46, 47, 48, 13, 14, 39, 50,
623 58, 59, 120, 8, 140, 121, 141, 1, 94, 95,
624 96, 15, 12, 66, 122, 97, 142, 56, 57, 102,
625 9, 22, 60, 51, 23, 24, 62, 63, 61, 13,
626 14, 67, 68, 134, 135, 143, 144, 91, 92, 93,
627 123, 136, 5, 108, 15, 13, 14, 124, 125, 126,
628 127, 6, 83, 84, 85, 86, 18, 128, 42, 106,
629 15, 40, 129, 107, 43, 44, 109, 40, 45, 112,
630 64, 65, 81, 82, 87, 88, 49, 89, 90, 21,
631 52, 69, 53, 71, 54, 72, 55, 103, 101, 104,
632 105, 115, 111, 131, 116, 119, 7, 138, 132, 139,
633 20, 146, 114, 17, 76, 75, 148, 80, 0, 77,
634 113, 78, 137, 79, 0, 110, 0, 0, 0, 0,
635 0, 0, 0, 0, 0, 145, 0, 0, 147
636 };
638 static const yytype_int16 yycheck[] =
639 {
640 8, 44, 45, 22, 23, 24, 18, 19, 16, 13,
641 8, 9, 22, 5, 20, 25, 22, 3, 15, 16,
642 17, 33, 4, 26, 34, 22, 32, 10, 11, 72,
643 22, 43, 30, 37, 46, 47, 6, 7, 36, 18,
644 19, 44, 45, 22, 23, 34, 35, 66, 67, 68,
645 14, 30, 25, 96, 33, 18, 19, 21, 22, 23,
646 24, 0, 58, 59, 60, 61, 26, 31, 16, 25,
647 33, 27, 36, 29, 22, 23, 97, 27, 26, 100,
648 42, 43, 56, 57, 62, 63, 35, 64, 65, 25,
649 12, 25, 39, 23, 40, 23, 41, 38, 25, 17,
650 17, 25, 28, 18, 25, 25, 3, 36, 33, 21,
651 11, 34, 103, 9, 51, 50, 35, 55, -1, 52,
652 100, 53, 130, 54, -1, 97, -1, -1, -1, -1,
653 -1, -1, -1, -1, -1, 143, -1, -1, 146
654 };
656 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
657 symbol of state STATE-NUM. */
658 static const yytype_uint8 yystos[] =
659 {
660 0, 3, 49, 50, 51, 25, 0, 51, 5, 22,
661 52, 53, 4, 18, 19, 33, 61, 53, 26, 54,
662 52, 25, 43, 46, 47, 61, 62, 63, 64, 65,
663 66, 67, 68, 69, 70, 71, 72, 73, 74, 61,
664 27, 55, 16, 22, 23, 26, 74, 74, 74, 35,
665 13, 37, 12, 39, 40, 41, 10, 11, 8, 9,
666 30, 36, 6, 7, 42, 43, 26, 44, 45, 25,
667 56, 23, 23, 55, 55, 65, 62, 66, 67, 68,
668 69, 70, 70, 71, 71, 71, 71, 72, 72, 73,
669 73, 74, 74, 74, 15, 16, 17, 22, 57, 76,
670 77, 25, 55, 38, 17, 17, 25, 29, 55, 57,
671 77, 28, 57, 76, 63, 25, 25, 58, 59, 25,
672 22, 25, 34, 14, 21, 22, 23, 24, 31, 36,
673 60, 18, 33, 75, 22, 23, 30, 61, 36, 21,
674 20, 22, 32, 34, 35, 61, 34, 61, 35
675 };
677 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
678 static const yytype_uint8 yyr1[] =
679 {
680 0, 48, 49, 50, 50, 51, 51, 52, 52, 53,
681 53, 54, 54, 54, 54, 54, 54, 55, 56, 56,
682 57, 57, 57, 57, 58, 58, 58, 58, 58, 58,
683 58, 59, 59, 59, 60, 60, 60, 60, 60, 61,
684 61, 61, 62, 63, 63, 64, 64, 65, 65, 66,
685 66, 67, 67, 68, 68, 69, 69, 69, 70, 70,
686 70, 70, 70, 71, 71, 71, 72, 72, 72, 73,
687 73, 73, 73, 74, 74, 74, 74, 75, 75, 75,
688 76, 76, 76, 77, 77, 77
689 };
691 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
692 static const yytype_uint8 yyr2[] =
693 {
694 0, 2, 3, 2, 4, 1, 2, 0, 2, 4,
695 2, 2, 3, 4, 3, 4, 0, 5, 0, 2,
696 4, 2, 3, 2, 2, 3, 4, 2, 9, 5,
697 2, 0, 2, 2, 3, 1, 2, 2, 2, 1,
698 1, 3, 1, 1, 5, 1, 3, 1, 3, 1,
699 3, 1, 3, 1, 3, 1, 3, 3, 1, 3,
700 3, 3, 3, 3, 3, 1, 3, 3, 1, 3,
701 3, 3, 1, 1, 2, 2, 2, 0, 2, 2,
702 0, 2, 2, 2, 3, 2
703 };
706 #define yyerrok (yyerrstatus = 0)
707 #define yyclearin (yychar = YYEMPTY)
708 #define YYEMPTY (-2)
709 #define YYEOF 0
711 #define YYACCEPT goto yyacceptlab
712 #define YYABORT goto yyabortlab
713 #define YYERROR goto yyerrorlab
716 #define YYRECOVERING() (!!yyerrstatus)
718 #define YYBACKUP(Token, Value) \
719 do \
720 if (yychar == YYEMPTY) \
721 { \
722 yychar = (Token); \
723 yylval = (Value); \
724 YYPOPSTACK (yylen); \
725 yystate = *yyssp; \
726 goto yybackup; \
727 } \
728 else \
729 { \
730 yyerror (YY_("syntax error: cannot back up")); \
731 YYERROR; \
732 } \
733 while (0)
735 /* Error token number */
736 #define YYTERROR 1
737 #define YYERRCODE 256
740 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
741 If N is 0, then set CURRENT to the empty location which ends
742 the previous symbol: RHS[0] (always defined). */
744 #ifndef YYLLOC_DEFAULT
745 # define YYLLOC_DEFAULT(Current, Rhs, N) \
746 do \
747 if (N) \
748 { \
749 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
750 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
751 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
752 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
753 } \
754 else \
755 { \
756 (Current).first_line = (Current).last_line = \
757 YYRHSLOC (Rhs, 0).last_line; \
758 (Current).first_column = (Current).last_column = \
759 YYRHSLOC (Rhs, 0).last_column; \
760 } \
761 while (0)
762 #endif
764 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
767 /* Enable debugging if requested. */
768 #if YYDEBUG
770 # ifndef YYFPRINTF
771 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
772 # define YYFPRINTF fprintf
773 # endif
775 # define YYDPRINTF(Args) \
776 do { \
777 if (yydebug) \
778 YYFPRINTF Args; \
779 } while (0)
782 /* YY_LOCATION_PRINT -- Print the location on the stream.
783 This macro was not mandated originally: define only if we know
784 we won't break user code: when these are the locations we know. */
786 #ifndef YY_LOCATION_PRINT
787 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
789 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
791 YY_ATTRIBUTE_UNUSED
792 static unsigned
793 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
794 {
795 unsigned res = 0;
796 int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
797 if (0 <= yylocp->first_line)
798 {
799 res += YYFPRINTF (yyo, "%d", yylocp->first_line);
800 if (0 <= yylocp->first_column)
801 res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
802 }
803 if (0 <= yylocp->last_line)
804 {
805 if (yylocp->first_line < yylocp->last_line)
806 {
807 res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
808 if (0 <= end_col)
809 res += YYFPRINTF (yyo, ".%d", end_col);
810 }
811 else if (0 <= end_col && yylocp->first_column < end_col)
812 res += YYFPRINTF (yyo, "-%d", end_col);
813 }
814 return res;
815 }
817 # define YY_LOCATION_PRINT(File, Loc) \
818 yy_location_print_ (File, &(Loc))
820 # else
821 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
822 # endif
823 #endif
826 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
827 do { \
828 if (yydebug) \
829 { \
830 YYFPRINTF (stderr, "%s ", Title); \
831 yy_symbol_print (stderr, \
832 Type, Value, Location); \
833 YYFPRINTF (stderr, "\n"); \
834 } \
835 } while (0)
838 /*----------------------------------------.
839 | Print this symbol's value on YYOUTPUT. |
840 `----------------------------------------*/
842 static void
843 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
844 {
845 FILE *yyo = yyoutput;
846 YYUSE (yyo);
847 YYUSE (yylocationp);
848 if (!yyvaluep)
849 return;
850 # ifdef YYPRINT
851 if (yytype < YYNTOKENS)
852 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
853 # endif
854 YYUSE (yytype);
855 }
858 /*--------------------------------.
859 | Print this symbol on YYOUTPUT. |
860 `--------------------------------*/
862 static void
863 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
864 {
865 YYFPRINTF (yyoutput, "%s %s (",
866 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
868 YY_LOCATION_PRINT (yyoutput, *yylocationp);
869 YYFPRINTF (yyoutput, ": ");
870 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
871 YYFPRINTF (yyoutput, ")");
872 }
874 /*------------------------------------------------------------------.
875 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
876 | TOP (included). |
877 `------------------------------------------------------------------*/
879 static void
880 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
881 {
882 YYFPRINTF (stderr, "Stack now");
883 for (; yybottom <= yytop; yybottom++)
884 {
885 int yybot = *yybottom;
886 YYFPRINTF (stderr, " %d", yybot);
887 }
888 YYFPRINTF (stderr, "\n");
889 }
891 # define YY_STACK_PRINT(Bottom, Top) \
892 do { \
893 if (yydebug) \
894 yy_stack_print ((Bottom), (Top)); \
895 } while (0)
898 /*------------------------------------------------.
899 | Report that the YYRULE is going to be reduced. |
900 `------------------------------------------------*/
902 static void
903 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
904 {
905 unsigned long int yylno = yyrline[yyrule];
906 int yynrhs = yyr2[yyrule];
907 int yyi;
908 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
909 yyrule - 1, yylno);
910 /* The symbols being reduced. */
911 for (yyi = 0; yyi < yynrhs; yyi++)
912 {
913 YYFPRINTF (stderr, " $%d = ", yyi + 1);
914 yy_symbol_print (stderr,
915 yystos[yyssp[yyi + 1 - yynrhs]],
916 &(yyvsp[(yyi + 1) - (yynrhs)])
917 , &(yylsp[(yyi + 1) - (yynrhs)]) );
918 YYFPRINTF (stderr, "\n");
919 }
920 }
922 # define YY_REDUCE_PRINT(Rule) \
923 do { \
924 if (yydebug) \
925 yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
926 } while (0)
928 /* Nonzero means print parse trace. It is left uninitialized so that
929 multiple parsers can coexist. */
930 int yydebug;
931 #else /* !YYDEBUG */
932 # define YYDPRINTF(Args)
933 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
934 # define YY_STACK_PRINT(Bottom, Top)
935 # define YY_REDUCE_PRINT(Rule)
936 #endif /* !YYDEBUG */
939 /* YYINITDEPTH -- initial size of the parser's stacks. */
940 #ifndef YYINITDEPTH
941 # define YYINITDEPTH 200
942 #endif
944 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
945 if the built-in stack extension method is used).
947 Do not make this value too large; the results are undefined if
948 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
949 evaluated with infinite-precision integer arithmetic. */
951 #ifndef YYMAXDEPTH
952 # define YYMAXDEPTH 10000
953 #endif
956 #if YYERROR_VERBOSE
958 # ifndef yystrlen
959 # if defined __GLIBC__ && defined _STRING_H
960 # define yystrlen strlen
961 # else
962 /* Return the length of YYSTR. */
963 static YYSIZE_T
964 yystrlen (const char *yystr)
965 {
966 YYSIZE_T yylen;
967 for (yylen = 0; yystr[yylen]; yylen++)
968 continue;
969 return yylen;
970 }
971 # endif
972 # endif
974 # ifndef yystpcpy
975 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
976 # define yystpcpy stpcpy
977 # else
978 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
979 YYDEST. */
980 static char *
981 yystpcpy (char *yydest, const char *yysrc)
982 {
983 char *yyd = yydest;
984 const char *yys = yysrc;
986 while ((*yyd++ = *yys++) != '\0')
987 continue;
989 return yyd - 1;
990 }
991 # endif
992 # endif
994 # ifndef yytnamerr
995 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
996 quotes and backslashes, so that it's suitable for yyerror. The
997 heuristic is that double-quoting is unnecessary unless the string
998 contains an apostrophe, a comma, or backslash (other than
999 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1000 null, do not copy; instead, return the length of what the result
1001 would have been. */
1002 static YYSIZE_T
1003 yytnamerr (char *yyres, const char *yystr)
1004 {
1005 if (*yystr == '"')
1006 {
1007 YYSIZE_T yyn = 0;
1008 char const *yyp = yystr;
1010 for (;;)
1011 switch (*++yyp)
1012 {
1013 case '\'':
1014 case ',':
1015 goto do_not_strip_quotes;
1017 case '\\':
1018 if (*++yyp != '\\')
1019 goto do_not_strip_quotes;
1020 /* Fall through. */
1021 default:
1022 if (yyres)
1023 yyres[yyn] = *yyp;
1024 yyn++;
1025 break;
1027 case '"':
1028 if (yyres)
1029 yyres[yyn] = '\0';
1030 return yyn;
1031 }
1032 do_not_strip_quotes: ;
1033 }
1035 if (! yyres)
1036 return yystrlen (yystr);
1038 return yystpcpy (yyres, yystr) - yyres;
1039 }
1040 # endif
1042 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1043 about the unexpected token YYTOKEN for the state stack whose top is
1044 YYSSP.
1046 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1047 not large enough to hold the message. In that case, also set
1048 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1049 required number of bytes is too large to store. */
1050 static int
1051 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1052 yytype_int16 *yyssp, int yytoken)
1053 {
1054 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1055 YYSIZE_T yysize = yysize0;
1056 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1057 /* Internationalized format string. */
1058 const char *yyformat = YY_NULLPTR;
1059 /* Arguments of yyformat. */
1060 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1061 /* Number of reported tokens (one for the "unexpected", one per
1062 "expected"). */
1063 int yycount = 0;
1065 /* There are many possibilities here to consider:
1066 - If this state is a consistent state with a default action, then
1067 the only way this function was invoked is if the default action
1068 is an error action. In that case, don't check for expected
1069 tokens because there are none.
1070 - The only way there can be no lookahead present (in yychar) is if
1071 this state is a consistent state with a default action. Thus,
1072 detecting the absence of a lookahead is sufficient to determine
1073 that there is no unexpected or expected token to report. In that
1074 case, just report a simple "syntax error".
1075 - Don't assume there isn't a lookahead just because this state is a
1076 consistent state with a default action. There might have been a
1077 previous inconsistent state, consistent state with a non-default
1078 action, or user semantic action that manipulated yychar.
1079 - Of course, the expected token list depends on states to have
1080 correct lookahead information, and it depends on the parser not
1081 to perform extra reductions after fetching a lookahead from the
1082 scanner and before detecting a syntax error. Thus, state merging
1083 (from LALR or IELR) and default reductions corrupt the expected
1084 token list. However, the list is correct for canonical LR with
1085 one exception: it will still contain any token that will not be
1086 accepted due to an error action in a later state.
1087 */
1088 if (yytoken != YYEMPTY)
1089 {
1090 int yyn = yypact[*yyssp];
1091 yyarg[yycount++] = yytname[yytoken];
1092 if (!yypact_value_is_default (yyn))
1093 {
1094 /* Start YYX at -YYN if negative to avoid negative indexes in
1095 YYCHECK. In other words, skip the first -YYN actions for
1096 this state because they are default actions. */
1097 int yyxbegin = yyn < 0 ? -yyn : 0;
1098 /* Stay within bounds of both yycheck and yytname. */
1099 int yychecklim = YYLAST - yyn + 1;
1100 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1101 int yyx;
1103 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1104 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1105 && !yytable_value_is_error (yytable[yyx + yyn]))
1106 {
1107 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1108 {
1109 yycount = 1;
1110 yysize = yysize0;
1111 break;
1112 }
1113 yyarg[yycount++] = yytname[yyx];
1114 {
1115 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1116 if (! (yysize <= yysize1
1117 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1118 return 2;
1119 yysize = yysize1;
1120 }
1121 }
1122 }
1123 }
1125 switch (yycount)
1126 {
1127 # define YYCASE_(N, S) \
1128 case N: \
1129 yyformat = S; \
1130 break
1131 YYCASE_(0, YY_("syntax error"));
1132 YYCASE_(1, YY_("syntax error, unexpected %s"));
1133 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1134 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1135 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1136 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1137 # undef YYCASE_
1138 }
1140 {
1141 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1142 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1143 return 2;
1144 yysize = yysize1;
1145 }
1147 if (*yymsg_alloc < yysize)
1148 {
1149 *yymsg_alloc = 2 * yysize;
1150 if (! (yysize <= *yymsg_alloc
1151 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1152 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1153 return 1;
1154 }
1156 /* Avoid sprintf, as that infringes on the user's name space.
1157 Don't have undefined behavior even if the translation
1158 produced a string with the wrong number of "%s"s. */
1159 {
1160 char *yyp = *yymsg;
1161 int yyi = 0;
1162 while ((*yyp = *yyformat) != '\0')
1163 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1164 {
1165 yyp += yytnamerr (yyp, yyarg[yyi++]);
1166 yyformat += 2;
1167 }
1168 else
1169 {
1170 yyp++;
1171 yyformat++;
1172 }
1173 }
1174 return 0;
1175 }
1176 #endif /* YYERROR_VERBOSE */
1178 /*-----------------------------------------------.
1179 | Release the memory associated to this symbol. |
1180 `-----------------------------------------------*/
1182 static void
1183 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1184 {
1185 YYUSE (yyvaluep);
1186 YYUSE (yylocationp);
1187 if (!yymsg)
1188 yymsg = "Deleting";
1189 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1191 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1192 YYUSE (yytype);
1193 YY_IGNORE_MAYBE_UNINITIALIZED_END
1194 }
1199 /* The lookahead symbol. */
1200 int yychar;
1202 /* The semantic value of the lookahead symbol. */
1203 YYSTYPE yylval;
1204 /* Location data for the lookahead symbol. */
1205 YYLTYPE yylloc
1206 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1207 = { 1, 1, 1, 1 }
1208 # endif
1209 ;
1210 /* Number of syntax errors so far. */
1211 int yynerrs;
1214 /*----------.
1215 | yyparse. |
1216 `----------*/
1218 int
1219 yyparse (void)
1220 {
1221 int yystate;
1222 /* Number of tokens to shift before error messages enabled. */
1223 int yyerrstatus;
1225 /* The stacks and their tools:
1226 'yyss': related to states.
1227 'yyvs': related to semantic values.
1228 'yyls': related to locations.
1230 Refer to the stacks through separate pointers, to allow yyoverflow
1231 to reallocate them elsewhere. */
1233 /* The state stack. */
1234 yytype_int16 yyssa[YYINITDEPTH];
1235 yytype_int16 *yyss;
1236 yytype_int16 *yyssp;
1238 /* The semantic value stack. */
1239 YYSTYPE yyvsa[YYINITDEPTH];
1240 YYSTYPE *yyvs;
1241 YYSTYPE *yyvsp;
1243 /* The location stack. */
1244 YYLTYPE yylsa[YYINITDEPTH];
1245 YYLTYPE *yyls;
1246 YYLTYPE *yylsp;
1248 /* The locations where the error started and ended. */
1249 YYLTYPE yyerror_range[3];
1251 YYSIZE_T yystacksize;
1253 int yyn;
1254 int yyresult;
1255 /* Lookahead token as an internal (translated) token number. */
1256 int yytoken = 0;
1257 /* The variables used to return semantic value and location from the
1258 action routines. */
1259 YYSTYPE yyval;
1260 YYLTYPE yyloc;
1262 #if YYERROR_VERBOSE
1263 /* Buffer for error messages, and its allocated size. */
1264 char yymsgbuf[128];
1265 char *yymsg = yymsgbuf;
1266 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1267 #endif
1269 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1271 /* The number of symbols on the RHS of the reduced rule.
1272 Keep to zero when no symbol should be popped. */
1273 int yylen = 0;
1275 yyssp = yyss = yyssa;
1276 yyvsp = yyvs = yyvsa;
1277 yylsp = yyls = yylsa;
1278 yystacksize = YYINITDEPTH;
1280 YYDPRINTF ((stderr, "Starting parse\n"));
1282 yystate = 0;
1283 yyerrstatus = 0;
1284 yynerrs = 0;
1285 yychar = YYEMPTY; /* Cause a token to be read. */
1286 yylsp[0] = yylloc;
1287 goto yysetstate;
1289 /*------------------------------------------------------------.
1290 | yynewstate -- Push a new state, which is found in yystate. |
1291 `------------------------------------------------------------*/
1292 yynewstate:
1293 /* In all cases, when you get here, the value and location stacks
1294 have just been pushed. So pushing a state here evens the stacks. */
1295 yyssp++;
1297 yysetstate:
1298 *yyssp = yystate;
1300 if (yyss + yystacksize - 1 <= yyssp)
1301 {
1302 /* Get the current used size of the three stacks, in elements. */
1303 YYSIZE_T yysize = yyssp - yyss + 1;
1305 #ifdef yyoverflow
1306 {
1307 /* Give user a chance to reallocate the stack. Use copies of
1308 these so that the &'s don't force the real ones into
1309 memory. */
1310 YYSTYPE *yyvs1 = yyvs;
1311 yytype_int16 *yyss1 = yyss;
1312 YYLTYPE *yyls1 = yyls;
1314 /* Each stack pointer address is followed by the size of the
1315 data in use in that stack, in bytes. This used to be a
1316 conditional around just the two extra args, but that might
1317 be undefined if yyoverflow is a macro. */
1318 yyoverflow (YY_("memory exhausted"),
1319 &yyss1, yysize * sizeof (*yyssp),
1320 &yyvs1, yysize * sizeof (*yyvsp),
1321 &yyls1, yysize * sizeof (*yylsp),
1322 &yystacksize);
1324 yyls = yyls1;
1325 yyss = yyss1;
1326 yyvs = yyvs1;
1327 }
1328 #else /* no yyoverflow */
1329 # ifndef YYSTACK_RELOCATE
1330 goto yyexhaustedlab;
1331 # else
1332 /* Extend the stack our own way. */
1333 if (YYMAXDEPTH <= yystacksize)
1334 goto yyexhaustedlab;
1335 yystacksize *= 2;
1336 if (YYMAXDEPTH < yystacksize)
1337 yystacksize = YYMAXDEPTH;
1339 {
1340 yytype_int16 *yyss1 = yyss;
1341 union yyalloc *yyptr =
1342 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1343 if (! yyptr)
1344 goto yyexhaustedlab;
1345 YYSTACK_RELOCATE (yyss_alloc, yyss);
1346 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1347 YYSTACK_RELOCATE (yyls_alloc, yyls);
1348 # undef YYSTACK_RELOCATE
1349 if (yyss1 != yyssa)
1350 YYSTACK_FREE (yyss1);
1351 }
1352 # endif
1353 #endif /* no yyoverflow */
1355 yyssp = yyss + yysize - 1;
1356 yyvsp = yyvs + yysize - 1;
1357 yylsp = yyls + yysize - 1;
1359 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1360 (unsigned long int) yystacksize));
1362 if (yyss + yystacksize - 1 <= yyssp)
1363 YYABORT;
1364 }
1366 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1368 if (yystate == YYFINAL)
1369 YYACCEPT;
1371 goto yybackup;
1373 /*-----------.
1374 | yybackup. |
1375 `-----------*/
1376 yybackup:
1378 /* Do appropriate processing given the current state. Read a
1379 lookahead token if we need one and don't already have one. */
1381 /* First try to decide what to do without reference to lookahead token. */
1382 yyn = yypact[yystate];
1383 if (yypact_value_is_default (yyn))
1384 goto yydefault;
1386 /* Not known => get a lookahead token if don't already have one. */
1388 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1389 if (yychar == YYEMPTY)
1390 {
1391 YYDPRINTF ((stderr, "Reading a token: "));
1392 yychar = yylex ();
1393 }
1395 if (yychar <= YYEOF)
1396 {
1397 yychar = yytoken = YYEOF;
1398 YYDPRINTF ((stderr, "Now at end of input.\n"));
1399 }
1400 else
1401 {
1402 yytoken = YYTRANSLATE (yychar);
1403 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1404 }
1406 /* If the proper action on seeing token YYTOKEN is to reduce or to
1407 detect an error, take that action. */
1408 yyn += yytoken;
1409 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1410 goto yydefault;
1411 yyn = yytable[yyn];
1412 if (yyn <= 0)
1413 {
1414 if (yytable_value_is_error (yyn))
1415 goto yyerrlab;
1416 yyn = -yyn;
1417 goto yyreduce;
1418 }
1420 /* Count tokens shifted since error; after three, turn off error
1421 status. */
1422 if (yyerrstatus)
1423 yyerrstatus--;
1425 /* Shift the lookahead token. */
1426 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1428 /* Discard the shifted token. */
1429 yychar = YYEMPTY;
1431 yystate = yyn;
1432 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1433 *++yyvsp = yylval;
1434 YY_IGNORE_MAYBE_UNINITIALIZED_END
1435 *++yylsp = yylloc;
1436 goto yynewstate;
1439 /*-----------------------------------------------------------.
1440 | yydefault -- do the default action for the current state. |
1441 `-----------------------------------------------------------*/
1442 yydefault:
1443 yyn = yydefact[yystate];
1444 if (yyn == 0)
1445 goto yyerrlab;
1446 goto yyreduce;
1449 /*-----------------------------.
1450 | yyreduce -- Do a reduction. |
1451 `-----------------------------*/
1452 yyreduce:
1453 /* yyn is the number of a rule to reduce with. */
1454 yylen = yyr2[yyn];
1456 /* If YYLEN is nonzero, implement the default value of the action:
1457 '$$ = $1'.
1459 Otherwise, the following line sets YYVAL to garbage.
1460 This behavior is undocumented and Bison
1461 users should not rely upon it. Assigning to YYVAL
1462 unconditionally makes the parser a bit smaller, and it avoids a
1463 GCC warning that YYVAL may be used uninitialized. */
1464 yyval = yyvsp[1-yylen];
1466 /* Default location. */
1467 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1468 YY_REDUCE_PRINT (yyn);
1469 switch (yyn)
1470 {
1471 case 2:
1472 #line 110 "dtc-parser.y" /* yacc.c:1646 */
1473 {
1474 parser_output = build_dt_info((yyvsp[-2].flags), (yyvsp[-1].re), (yyvsp[0].node),
1475 guess_boot_cpuid((yyvsp[0].node)));
1476 }
1477 #line 1478 "dtc-parser.tab.c" /* yacc.c:1646 */
1478 break;
1480 case 3:
1481 #line 118 "dtc-parser.y" /* yacc.c:1646 */
1482 {
1483 (yyval.flags) = DTSF_V1;
1484 }
1485 #line 1486 "dtc-parser.tab.c" /* yacc.c:1646 */
1486 break;
1488 case 4:
1489 #line 122 "dtc-parser.y" /* yacc.c:1646 */
1490 {
1491 (yyval.flags) = DTSF_V1 | DTSF_PLUGIN;
1492 }
1493 #line 1494 "dtc-parser.tab.c" /* yacc.c:1646 */
1494 break;
1496 case 6:
1497 #line 130 "dtc-parser.y" /* yacc.c:1646 */
1498 {
1499 if ((yyvsp[0].flags) != (yyvsp[-1].flags))
1500 ERROR(&(yylsp[0]), "Header flags don't match earlier ones");
1501 (yyval.flags) = (yyvsp[-1].flags);
1502 }
1503 #line 1504 "dtc-parser.tab.c" /* yacc.c:1646 */
1504 break;
1506 case 7:
1507 #line 139 "dtc-parser.y" /* yacc.c:1646 */
1508 {
1509 (yyval.re) = NULL;
1510 }
1511 #line 1512 "dtc-parser.tab.c" /* yacc.c:1646 */
1512 break;
1514 case 8:
1515 #line 143 "dtc-parser.y" /* yacc.c:1646 */
1516 {
1517 (yyval.re) = chain_reserve_entry((yyvsp[-1].re), (yyvsp[0].re));
1518 }
1519 #line 1520 "dtc-parser.tab.c" /* yacc.c:1646 */
1520 break;
1522 case 9:
1523 #line 150 "dtc-parser.y" /* yacc.c:1646 */
1524 {
1525 (yyval.re) = build_reserve_entry((yyvsp[-2].integer), (yyvsp[-1].integer));
1526 }
1527 #line 1528 "dtc-parser.tab.c" /* yacc.c:1646 */
1528 break;
1530 case 10:
1531 #line 154 "dtc-parser.y" /* yacc.c:1646 */
1532 {
1533 add_label(&(yyvsp[0].re)->labels, (yyvsp[-1].labelref));
1534 (yyval.re) = (yyvsp[0].re);
1535 }
1536 #line 1537 "dtc-parser.tab.c" /* yacc.c:1646 */
1537 break;
1539 case 11:
1540 #line 162 "dtc-parser.y" /* yacc.c:1646 */
1541 {
1542 (yyval.node) = name_node((yyvsp[0].node), "");
1543 }
1544 #line 1545 "dtc-parser.tab.c" /* yacc.c:1646 */
1545 break;
1547 case 12:
1548 #line 166 "dtc-parser.y" /* yacc.c:1646 */
1549 {
1550 (yyval.node) = merge_nodes((yyvsp[-2].node), (yyvsp[0].node));
1551 }
1552 #line 1553 "dtc-parser.tab.c" /* yacc.c:1646 */
1553 break;
1555 case 13:
1556 #line 171 "dtc-parser.y" /* yacc.c:1646 */
1557 {
1558 struct node *target = get_node_by_ref((yyvsp[-3].node), (yyvsp[-1].labelref));
1560 if (target) {
1561 add_label(&target->labels, (yyvsp[-2].labelref));
1562 merge_nodes(target, (yyvsp[0].node));
1563 } else
1564 ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref));
1565 (yyval.node) = (yyvsp[-3].node);
1566 }
1567 #line 1568 "dtc-parser.tab.c" /* yacc.c:1646 */
1568 break;
1570 case 14:
1571 #line 182 "dtc-parser.y" /* yacc.c:1646 */
1572 {
1573 struct node *target = get_node_by_ref((yyvsp[-2].node), (yyvsp[-1].labelref));
1575 if (target) {
1576 merge_nodes(target, (yyvsp[0].node));
1577 } else {
1578 /*
1579 * We rely on the rule being always:
1580 * versioninfo plugindecl memreserves devicetree
1581 * so $-1 is what we want (plugindecl)
1582 */
1583 if ((yyvsp[(-1) - (3)].flags) & DTSF_PLUGIN)
1584 add_orphan_node((yyvsp[-2].node), (yyvsp[0].node), (yyvsp[-1].labelref));
1585 else
1586 ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref));
1587 }
1588 (yyval.node) = (yyvsp[-2].node);
1589 }
1590 #line 1591 "dtc-parser.tab.c" /* yacc.c:1646 */
1591 break;
1593 case 15:
1594 #line 201 "dtc-parser.y" /* yacc.c:1646 */
1595 {
1596 struct node *target = get_node_by_ref((yyvsp[-3].node), (yyvsp[-1].labelref));
1598 if (target)
1599 delete_node(target);
1600 else
1601 ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref));
1604 (yyval.node) = (yyvsp[-3].node);
1605 }
1606 #line 1607 "dtc-parser.tab.c" /* yacc.c:1646 */
1607 break;
1609 case 16:
1610 #line 213 "dtc-parser.y" /* yacc.c:1646 */
1611 {
1612 /* build empty node */
1613 (yyval.node) = name_node(build_node(NULL, NULL), "");
1614 }
1615 #line 1616 "dtc-parser.tab.c" /* yacc.c:1646 */
1616 break;
1618 case 17:
1619 #line 221 "dtc-parser.y" /* yacc.c:1646 */
1620 {
1621 (yyval.node) = build_node((yyvsp[-3].proplist), (yyvsp[-2].nodelist));
1622 }
1623 #line 1624 "dtc-parser.tab.c" /* yacc.c:1646 */
1624 break;
1626 case 18:
1627 #line 228 "dtc-parser.y" /* yacc.c:1646 */
1628 {
1629 (yyval.proplist) = NULL;
1630 }
1631 #line 1632 "dtc-parser.tab.c" /* yacc.c:1646 */
1632 break;
1634 case 19:
1635 #line 232 "dtc-parser.y" /* yacc.c:1646 */
1636 {
1637 (yyval.proplist) = chain_property((yyvsp[0].prop), (yyvsp[-1].proplist));
1638 }
1639 #line 1640 "dtc-parser.tab.c" /* yacc.c:1646 */
1640 break;
1642 case 20:
1643 #line 239 "dtc-parser.y" /* yacc.c:1646 */
1644 {
1645 (yyval.prop) = build_property((yyvsp[-3].propnodename), (yyvsp[-1].data));
1646 }
1647 #line 1648 "dtc-parser.tab.c" /* yacc.c:1646 */
1648 break;
1650 case 21:
1651 #line 243 "dtc-parser.y" /* yacc.c:1646 */
1652 {
1653 (yyval.prop) = build_property((yyvsp[-1].propnodename), empty_data);
1654 }
1655 #line 1656 "dtc-parser.tab.c" /* yacc.c:1646 */
1656 break;
1658 case 22:
1659 #line 247 "dtc-parser.y" /* yacc.c:1646 */
1660 {
1661 (yyval.prop) = build_property_delete((yyvsp[-1].propnodename));
1662 }
1663 #line 1664 "dtc-parser.tab.c" /* yacc.c:1646 */
1664 break;
1666 case 23:
1667 #line 251 "dtc-parser.y" /* yacc.c:1646 */
1668 {
1669 add_label(&(yyvsp[0].prop)->labels, (yyvsp[-1].labelref));
1670 (yyval.prop) = (yyvsp[0].prop);
1671 }
1672 #line 1673 "dtc-parser.tab.c" /* yacc.c:1646 */
1673 break;
1675 case 24:
1676 #line 259 "dtc-parser.y" /* yacc.c:1646 */
1677 {
1678 (yyval.data) = data_merge((yyvsp[-1].data), (yyvsp[0].data));
1679 }
1680 #line 1681 "dtc-parser.tab.c" /* yacc.c:1646 */
1681 break;
1683 case 25:
1684 #line 263 "dtc-parser.y" /* yacc.c:1646 */
1685 {
1686 (yyval.data) = data_merge((yyvsp[-2].data), (yyvsp[-1].array).data);
1687 }
1688 #line 1689 "dtc-parser.tab.c" /* yacc.c:1646 */
1689 break;
1691 case 26:
1692 #line 267 "dtc-parser.y" /* yacc.c:1646 */
1693 {
1694 (yyval.data) = data_merge((yyvsp[-3].data), (yyvsp[-1].data));
1695 }
1696 #line 1697 "dtc-parser.tab.c" /* yacc.c:1646 */
1697 break;
1699 case 27:
1700 #line 271 "dtc-parser.y" /* yacc.c:1646 */
1701 {
1702 (yyval.data) = data_add_marker((yyvsp[-1].data), REF_PATH, (yyvsp[0].labelref));
1703 }
1704 #line 1705 "dtc-parser.tab.c" /* yacc.c:1646 */
1705 break;
1707 case 28:
1708 #line 275 "dtc-parser.y" /* yacc.c:1646 */
1709 {
1710 FILE *f = srcfile_relative_open((yyvsp[-5].data).val, NULL);
1711 struct data d;
1713 if ((yyvsp[-3].integer) != 0)
1714 if (fseek(f, (yyvsp[-3].integer), SEEK_SET) != 0)
1715 die("Couldn't seek to offset %llu in \"%s\": %s",
1716 (unsigned long long)(yyvsp[-3].integer), (yyvsp[-5].data).val,
1717 strerror(errno));
1719 d = data_copy_file(f, (yyvsp[-1].integer));
1721 (yyval.data) = data_merge((yyvsp[-8].data), d);
1722 fclose(f);
1723 }
1724 #line 1725 "dtc-parser.tab.c" /* yacc.c:1646 */
1725 break;
1727 case 29:
1728 #line 291 "dtc-parser.y" /* yacc.c:1646 */
1729 {
1730 FILE *f = srcfile_relative_open((yyvsp[-1].data).val, NULL);
1731 struct data d = empty_data;
1733 d = data_copy_file(f, -1);
1735 (yyval.data) = data_merge((yyvsp[-4].data), d);
1736 fclose(f);
1737 }
1738 #line 1739 "dtc-parser.tab.c" /* yacc.c:1646 */
1739 break;
1741 case 30:
1742 #line 301 "dtc-parser.y" /* yacc.c:1646 */
1743 {
1744 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref));
1745 }
1746 #line 1747 "dtc-parser.tab.c" /* yacc.c:1646 */
1747 break;
1749 case 31:
1750 #line 308 "dtc-parser.y" /* yacc.c:1646 */
1751 {
1752 (yyval.data) = empty_data;
1753 }
1754 #line 1755 "dtc-parser.tab.c" /* yacc.c:1646 */
1755 break;
1757 case 32:
1758 #line 312 "dtc-parser.y" /* yacc.c:1646 */
1759 {
1760 (yyval.data) = (yyvsp[-1].data);
1761 }
1762 #line 1763 "dtc-parser.tab.c" /* yacc.c:1646 */
1763 break;
1765 case 33:
1766 #line 316 "dtc-parser.y" /* yacc.c:1646 */
1767 {
1768 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref));
1769 }
1770 #line 1771 "dtc-parser.tab.c" /* yacc.c:1646 */
1771 break;
1773 case 34:
1774 #line 323 "dtc-parser.y" /* yacc.c:1646 */
1775 {
1776 unsigned long long bits;
1778 bits = (yyvsp[-1].integer);
1780 if ((bits != 8) && (bits != 16) &&
1781 (bits != 32) && (bits != 64)) {
1782 ERROR(&(yylsp[-1]), "Array elements must be"
1783 " 8, 16, 32 or 64-bits");
1784 bits = 32;
1785 }
1787 (yyval.array).data = empty_data;
1788 (yyval.array).bits = bits;
1789 }
1790 #line 1791 "dtc-parser.tab.c" /* yacc.c:1646 */
1791 break;
1793 case 35:
1794 #line 339 "dtc-parser.y" /* yacc.c:1646 */
1795 {
1796 (yyval.array).data = empty_data;
1797 (yyval.array).bits = 32;
1798 }
1799 #line 1800 "dtc-parser.tab.c" /* yacc.c:1646 */
1800 break;
1802 case 36:
1803 #line 344 "dtc-parser.y" /* yacc.c:1646 */
1804 {
1805 if ((yyvsp[-1].array).bits < 64) {
1806 uint64_t mask = (1ULL << (yyvsp[-1].array).bits) - 1;
1807 /*
1808 * Bits above mask must either be all zero
1809 * (positive within range of mask) or all one
1810 * (negative and sign-extended). The second
1811 * condition is true if when we set all bits
1812 * within the mask to one (i.e. | in the
1813 * mask), all bits are one.
1814 */
1815 if (((yyvsp[0].integer) > mask) && (((yyvsp[0].integer) | mask) != -1ULL))
1816 ERROR(&(yylsp[0]), "Value out of range for"
1817 " %d-bit array element", (yyvsp[-1].array).bits);
1818 }
1820 (yyval.array).data = data_append_integer((yyvsp[-1].array).data, (yyvsp[0].integer), (yyvsp[-1].array).bits);
1821 }
1822 #line 1823 "dtc-parser.tab.c" /* yacc.c:1646 */
1823 break;
1825 case 37:
1826 #line 363 "dtc-parser.y" /* yacc.c:1646 */
1827 {
1828 uint64_t val = ~0ULL >> (64 - (yyvsp[-1].array).bits);
1830 if ((yyvsp[-1].array).bits == 32)
1831 (yyvsp[-1].array).data = data_add_marker((yyvsp[-1].array).data,
1832 REF_PHANDLE,
1833 (yyvsp[0].labelref));
1834 else
1835 ERROR(&(yylsp[0]), "References are only allowed in "
1836 "arrays with 32-bit elements.");
1838 (yyval.array).data = data_append_integer((yyvsp[-1].array).data, val, (yyvsp[-1].array).bits);
1839 }
1840 #line 1841 "dtc-parser.tab.c" /* yacc.c:1646 */
1841 break;
1843 case 38:
1844 #line 377 "dtc-parser.y" /* yacc.c:1646 */
1845 {
1846 (yyval.array).data = data_add_marker((yyvsp[-1].array).data, LABEL, (yyvsp[0].labelref));
1847 }
1848 #line 1849 "dtc-parser.tab.c" /* yacc.c:1646 */
1849 break;
1851 case 41:
1852 #line 386 "dtc-parser.y" /* yacc.c:1646 */
1853 {
1854 (yyval.integer) = (yyvsp[-1].integer);
1855 }
1856 #line 1857 "dtc-parser.tab.c" /* yacc.c:1646 */
1857 break;
1859 case 44:
1860 #line 397 "dtc-parser.y" /* yacc.c:1646 */
1861 { (yyval.integer) = (yyvsp[-4].integer) ? (yyvsp[-2].integer) : (yyvsp[0].integer); }
1862 #line 1863 "dtc-parser.tab.c" /* yacc.c:1646 */
1863 break;
1865 case 46:
1866 #line 402 "dtc-parser.y" /* yacc.c:1646 */
1867 { (yyval.integer) = (yyvsp[-2].integer) || (yyvsp[0].integer); }
1868 #line 1869 "dtc-parser.tab.c" /* yacc.c:1646 */
1869 break;
1871 case 48:
1872 #line 407 "dtc-parser.y" /* yacc.c:1646 */
1873 { (yyval.integer) = (yyvsp[-2].integer) && (yyvsp[0].integer); }
1874 #line 1875 "dtc-parser.tab.c" /* yacc.c:1646 */
1875 break;
1877 case 50:
1878 #line 412 "dtc-parser.y" /* yacc.c:1646 */
1879 { (yyval.integer) = (yyvsp[-2].integer) | (yyvsp[0].integer); }
1880 #line 1881 "dtc-parser.tab.c" /* yacc.c:1646 */
1881 break;
1883 case 52:
1884 #line 417 "dtc-parser.y" /* yacc.c:1646 */
1885 { (yyval.integer) = (yyvsp[-2].integer) ^ (yyvsp[0].integer); }
1886 #line 1887 "dtc-parser.tab.c" /* yacc.c:1646 */
1887 break;
1889 case 54:
1890 #line 422 "dtc-parser.y" /* yacc.c:1646 */
1891 { (yyval.integer) = (yyvsp[-2].integer) & (yyvsp[0].integer); }
1892 #line 1893 "dtc-parser.tab.c" /* yacc.c:1646 */
1893 break;
1895 case 56:
1896 #line 427 "dtc-parser.y" /* yacc.c:1646 */
1897 { (yyval.integer) = (yyvsp[-2].integer) == (yyvsp[0].integer); }
1898 #line 1899 "dtc-parser.tab.c" /* yacc.c:1646 */
1899 break;
1901 case 57:
1902 #line 428 "dtc-parser.y" /* yacc.c:1646 */
1903 { (yyval.integer) = (yyvsp[-2].integer) != (yyvsp[0].integer); }
1904 #line 1905 "dtc-parser.tab.c" /* yacc.c:1646 */
1905 break;
1907 case 59:
1908 #line 433 "dtc-parser.y" /* yacc.c:1646 */
1909 { (yyval.integer) = (yyvsp[-2].integer) < (yyvsp[0].integer); }
1910 #line 1911 "dtc-parser.tab.c" /* yacc.c:1646 */
1911 break;
1913 case 60:
1914 #line 434 "dtc-parser.y" /* yacc.c:1646 */
1915 { (yyval.integer) = (yyvsp[-2].integer) > (yyvsp[0].integer); }
1916 #line 1917 "dtc-parser.tab.c" /* yacc.c:1646 */
1917 break;
1919 case 61:
1920 #line 435 "dtc-parser.y" /* yacc.c:1646 */
1921 { (yyval.integer) = (yyvsp[-2].integer) <= (yyvsp[0].integer); }
1922 #line 1923 "dtc-parser.tab.c" /* yacc.c:1646 */
1923 break;
1925 case 62:
1926 #line 436 "dtc-parser.y" /* yacc.c:1646 */
1927 { (yyval.integer) = (yyvsp[-2].integer) >= (yyvsp[0].integer); }
1928 #line 1929 "dtc-parser.tab.c" /* yacc.c:1646 */
1929 break;
1931 case 63:
1932 #line 440 "dtc-parser.y" /* yacc.c:1646 */
1933 { (yyval.integer) = (yyvsp[-2].integer) << (yyvsp[0].integer); }
1934 #line 1935 "dtc-parser.tab.c" /* yacc.c:1646 */
1935 break;
1937 case 64:
1938 #line 441 "dtc-parser.y" /* yacc.c:1646 */
1939 { (yyval.integer) = (yyvsp[-2].integer) >> (yyvsp[0].integer); }
1940 #line 1941 "dtc-parser.tab.c" /* yacc.c:1646 */
1941 break;
1943 case 66:
1944 #line 446 "dtc-parser.y" /* yacc.c:1646 */
1945 { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); }
1946 #line 1947 "dtc-parser.tab.c" /* yacc.c:1646 */
1947 break;
1949 case 67:
1950 #line 447 "dtc-parser.y" /* yacc.c:1646 */
1951 { (yyval.integer) = (yyvsp[-2].integer) - (yyvsp[0].integer); }
1952 #line 1953 "dtc-parser.tab.c" /* yacc.c:1646 */
1953 break;
1955 case 69:
1956 #line 452 "dtc-parser.y" /* yacc.c:1646 */
1957 { (yyval.integer) = (yyvsp[-2].integer) * (yyvsp[0].integer); }
1958 #line 1959 "dtc-parser.tab.c" /* yacc.c:1646 */
1959 break;
1961 case 70:
1962 #line 454 "dtc-parser.y" /* yacc.c:1646 */
1963 {
1964 if ((yyvsp[0].integer) != 0) {
1965 (yyval.integer) = (yyvsp[-2].integer) / (yyvsp[0].integer);
1966 } else {
1967 ERROR(&(yyloc), "Division by zero");
1968 (yyval.integer) = 0;
1969 }
1970 }
1971 #line 1972 "dtc-parser.tab.c" /* yacc.c:1646 */
1972 break;
1974 case 71:
1975 #line 463 "dtc-parser.y" /* yacc.c:1646 */
1976 {
1977 if ((yyvsp[0].integer) != 0) {
1978 (yyval.integer) = (yyvsp[-2].integer) % (yyvsp[0].integer);
1979 } else {
1980 ERROR(&(yyloc), "Division by zero");
1981 (yyval.integer) = 0;
1982 }
1983 }
1984 #line 1985 "dtc-parser.tab.c" /* yacc.c:1646 */
1985 break;
1987 case 74:
1988 #line 476 "dtc-parser.y" /* yacc.c:1646 */
1989 { (yyval.integer) = -(yyvsp[0].integer); }
1990 #line 1991 "dtc-parser.tab.c" /* yacc.c:1646 */
1991 break;
1993 case 75:
1994 #line 477 "dtc-parser.y" /* yacc.c:1646 */
1995 { (yyval.integer) = ~(yyvsp[0].integer); }
1996 #line 1997 "dtc-parser.tab.c" /* yacc.c:1646 */
1997 break;
1999 case 76:
2000 #line 478 "dtc-parser.y" /* yacc.c:1646 */
2001 { (yyval.integer) = !(yyvsp[0].integer); }
2002 #line 2003 "dtc-parser.tab.c" /* yacc.c:1646 */
2003 break;
2005 case 77:
2006 #line 483 "dtc-parser.y" /* yacc.c:1646 */
2007 {
2008 (yyval.data) = empty_data;
2009 }
2010 #line 2011 "dtc-parser.tab.c" /* yacc.c:1646 */
2011 break;
2013 case 78:
2014 #line 487 "dtc-parser.y" /* yacc.c:1646 */
2015 {
2016 (yyval.data) = data_append_byte((yyvsp[-1].data), (yyvsp[0].byte));
2017 }
2018 #line 2019 "dtc-parser.tab.c" /* yacc.c:1646 */
2019 break;
2021 case 79:
2022 #line 491 "dtc-parser.y" /* yacc.c:1646 */
2023 {
2024 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref));
2025 }
2026 #line 2027 "dtc-parser.tab.c" /* yacc.c:1646 */
2027 break;
2029 case 80:
2030 #line 498 "dtc-parser.y" /* yacc.c:1646 */
2031 {
2032 (yyval.nodelist) = NULL;
2033 }
2034 #line 2035 "dtc-parser.tab.c" /* yacc.c:1646 */
2035 break;
2037 case 81:
2038 #line 502 "dtc-parser.y" /* yacc.c:1646 */
2039 {
2040 (yyval.nodelist) = chain_node((yyvsp[-1].node), (yyvsp[0].nodelist));
2041 }
2042 #line 2043 "dtc-parser.tab.c" /* yacc.c:1646 */
2043 break;
2045 case 82:
2046 #line 506 "dtc-parser.y" /* yacc.c:1646 */
2047 {
2048 ERROR(&(yylsp[0]), "Properties must precede subnodes");
2049 YYERROR;
2050 }
2051 #line 2052 "dtc-parser.tab.c" /* yacc.c:1646 */
2052 break;
2054 case 83:
2055 #line 514 "dtc-parser.y" /* yacc.c:1646 */
2056 {
2057 (yyval.node) = name_node((yyvsp[0].node), (yyvsp[-1].propnodename));
2058 }
2059 #line 2060 "dtc-parser.tab.c" /* yacc.c:1646 */
2060 break;
2062 case 84:
2063 #line 518 "dtc-parser.y" /* yacc.c:1646 */
2064 {
2065 (yyval.node) = name_node(build_node_delete(), (yyvsp[-1].propnodename));
2066 }
2067 #line 2068 "dtc-parser.tab.c" /* yacc.c:1646 */
2068 break;
2070 case 85:
2071 #line 522 "dtc-parser.y" /* yacc.c:1646 */
2072 {
2073 add_label(&(yyvsp[0].node)->labels, (yyvsp[-1].labelref));
2074 (yyval.node) = (yyvsp[0].node);
2075 }
2076 #line 2077 "dtc-parser.tab.c" /* yacc.c:1646 */
2077 break;
2080 #line 2081 "dtc-parser.tab.c" /* yacc.c:1646 */
2081 default: break;
2082 }
2083 /* User semantic actions sometimes alter yychar, and that requires
2084 that yytoken be updated with the new translation. We take the
2085 approach of translating immediately before every use of yytoken.
2086 One alternative is translating here after every semantic action,
2087 but that translation would be missed if the semantic action invokes
2088 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2089 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2090 incorrect destructor might then be invoked immediately. In the
2091 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2092 to an incorrect destructor call or verbose syntax error message
2093 before the lookahead is translated. */
2094 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2096 YYPOPSTACK (yylen);
2097 yylen = 0;
2098 YY_STACK_PRINT (yyss, yyssp);
2100 *++yyvsp = yyval;
2101 *++yylsp = yyloc;
2103 /* Now 'shift' the result of the reduction. Determine what state
2104 that goes to, based on the state we popped back to and the rule
2105 number reduced by. */
2107 yyn = yyr1[yyn];
2109 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2110 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2111 yystate = yytable[yystate];
2112 else
2113 yystate = yydefgoto[yyn - YYNTOKENS];
2115 goto yynewstate;
2118 /*--------------------------------------.
2119 | yyerrlab -- here on detecting error. |
2120 `--------------------------------------*/
2121 yyerrlab:
2122 /* Make sure we have latest lookahead translation. See comments at
2123 user semantic actions for why this is necessary. */
2124 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2126 /* If not already recovering from an error, report this error. */
2127 if (!yyerrstatus)
2128 {
2129 ++yynerrs;
2130 #if ! YYERROR_VERBOSE
2131 yyerror (YY_("syntax error"));
2132 #else
2133 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2134 yyssp, yytoken)
2135 {
2136 char const *yymsgp = YY_("syntax error");
2137 int yysyntax_error_status;
2138 yysyntax_error_status = YYSYNTAX_ERROR;
2139 if (yysyntax_error_status == 0)
2140 yymsgp = yymsg;
2141 else if (yysyntax_error_status == 1)
2142 {
2143 if (yymsg != yymsgbuf)
2144 YYSTACK_FREE (yymsg);
2145 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2146 if (!yymsg)
2147 {
2148 yymsg = yymsgbuf;
2149 yymsg_alloc = sizeof yymsgbuf;
2150 yysyntax_error_status = 2;
2151 }
2152 else
2153 {
2154 yysyntax_error_status = YYSYNTAX_ERROR;
2155 yymsgp = yymsg;
2156 }
2157 }
2158 yyerror (yymsgp);
2159 if (yysyntax_error_status == 2)
2160 goto yyexhaustedlab;
2161 }
2162 # undef YYSYNTAX_ERROR
2163 #endif
2164 }
2166 yyerror_range[1] = yylloc;
2168 if (yyerrstatus == 3)
2169 {
2170 /* If just tried and failed to reuse lookahead token after an
2171 error, discard it. */
2173 if (yychar <= YYEOF)
2174 {
2175 /* Return failure if at end of input. */
2176 if (yychar == YYEOF)
2177 YYABORT;
2178 }
2179 else
2180 {
2181 yydestruct ("Error: discarding",
2182 yytoken, &yylval, &yylloc);
2183 yychar = YYEMPTY;
2184 }
2185 }
2187 /* Else will try to reuse lookahead token after shifting the error
2188 token. */
2189 goto yyerrlab1;
2192 /*---------------------------------------------------.
2193 | yyerrorlab -- error raised explicitly by YYERROR. |
2194 `---------------------------------------------------*/
2195 yyerrorlab:
2197 /* Pacify compilers like GCC when the user code never invokes
2198 YYERROR and the label yyerrorlab therefore never appears in user
2199 code. */
2200 if (/*CONSTCOND*/ 0)
2201 goto yyerrorlab;
2203 yyerror_range[1] = yylsp[1-yylen];
2204 /* Do not reclaim the symbols of the rule whose action triggered
2205 this YYERROR. */
2206 YYPOPSTACK (yylen);
2207 yylen = 0;
2208 YY_STACK_PRINT (yyss, yyssp);
2209 yystate = *yyssp;
2210 goto yyerrlab1;
2213 /*-------------------------------------------------------------.
2214 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2215 `-------------------------------------------------------------*/
2216 yyerrlab1:
2217 yyerrstatus = 3; /* Each real token shifted decrements this. */
2219 for (;;)
2220 {
2221 yyn = yypact[yystate];
2222 if (!yypact_value_is_default (yyn))
2223 {
2224 yyn += YYTERROR;
2225 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2226 {
2227 yyn = yytable[yyn];
2228 if (0 < yyn)
2229 break;
2230 }
2231 }
2233 /* Pop the current state because it cannot handle the error token. */
2234 if (yyssp == yyss)
2235 YYABORT;
2237 yyerror_range[1] = *yylsp;
2238 yydestruct ("Error: popping",
2239 yystos[yystate], yyvsp, yylsp);
2240 YYPOPSTACK (1);
2241 yystate = *yyssp;
2242 YY_STACK_PRINT (yyss, yyssp);
2243 }
2245 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2246 *++yyvsp = yylval;
2247 YY_IGNORE_MAYBE_UNINITIALIZED_END
2249 yyerror_range[2] = yylloc;
2250 /* Using YYLLOC is tempting, but would change the location of
2251 the lookahead. YYLOC is available though. */
2252 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
2253 *++yylsp = yyloc;
2255 /* Shift the error token. */
2256 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2258 yystate = yyn;
2259 goto yynewstate;
2262 /*-------------------------------------.
2263 | yyacceptlab -- YYACCEPT comes here. |
2264 `-------------------------------------*/
2265 yyacceptlab:
2266 yyresult = 0;
2267 goto yyreturn;
2269 /*-----------------------------------.
2270 | yyabortlab -- YYABORT comes here. |
2271 `-----------------------------------*/
2272 yyabortlab:
2273 yyresult = 1;
2274 goto yyreturn;
2276 #if !defined yyoverflow || YYERROR_VERBOSE
2277 /*-------------------------------------------------.
2278 | yyexhaustedlab -- memory exhaustion comes here. |
2279 `-------------------------------------------------*/
2280 yyexhaustedlab:
2281 yyerror (YY_("memory exhausted"));
2282 yyresult = 2;
2283 /* Fall through. */
2284 #endif
2286 yyreturn:
2287 if (yychar != YYEMPTY)
2288 {
2289 /* Make sure we have latest lookahead translation. See comments at
2290 user semantic actions for why this is necessary. */
2291 yytoken = YYTRANSLATE (yychar);
2292 yydestruct ("Cleanup: discarding lookahead",
2293 yytoken, &yylval, &yylloc);
2294 }
2295 /* Do not reclaim the symbols of the rule whose action triggered
2296 this YYABORT or YYACCEPT. */
2297 YYPOPSTACK (yylen);
2298 YY_STACK_PRINT (yyss, yyssp);
2299 while (yyssp != yyss)
2300 {
2301 yydestruct ("Cleanup: popping",
2302 yystos[*yyssp], yyvsp, yylsp);
2303 YYPOPSTACK (1);
2304 }
2305 #ifndef yyoverflow
2306 if (yyss != yyssa)
2307 YYSTACK_FREE (yyss);
2308 #endif
2309 #if YYERROR_VERBOSE
2310 if (yymsg != yymsgbuf)
2311 YYSTACK_FREE (yymsg);
2312 #endif
2313 return yyresult;
2314 }
2315 #line 528 "dtc-parser.y" /* yacc.c:1906 */
2318 void yyerror(char const *s)
2319 {
2320 ERROR(&yylloc, "%s", s);
2321 }