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