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