Loading...
1/* A Bison parser, made by GNU Bison 2.4.3. */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21/* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34/* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37/* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44/* Identify Bison output. */
45#define YYBISON 1
46
47/* Bison version. */
48#define YYBISON_VERSION "2.4.3"
49
50/* Skeleton name. */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers. */
54#define YYPURE 0
55
56/* Push parsers. */
57#define YYPUSH 0
58
59/* Pull parsers. */
60#define YYPULL 1
61
62/* Using locations. */
63#define YYLSP_NEEDED 0
64
65
66
67/* Copy the first part of user declarations. */
68
69
70#include <stdio.h>
71
72#include "dtc.h"
73#include "srcpos.h"
74
75YYLTYPE yylloc;
76
77extern int yylex(void);
78extern void print_error(char const *fmt, ...);
79extern void yyerror(char const *s);
80
81extern struct boot_info *the_boot_info;
82extern int treesource_error;
83
84static unsigned long long eval_literal(const char *s, int base, int bits);
85
86
87
88/* Enabling traces. */
89#ifndef YYDEBUG
90# define YYDEBUG 1
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/* Enabling the token table. */
102#ifndef YYTOKEN_TABLE
103# define YYTOKEN_TABLE 0
104#endif
105
106
107/* Tokens. */
108#ifndef YYTOKENTYPE
109# define YYTOKENTYPE
110 /* Put the tokens into the symbol table, so that GDB and other debuggers
111 know about them. */
112 enum yytokentype {
113 DT_V1 = 258,
114 DT_MEMRESERVE = 259,
115 DT_PROPNODENAME = 260,
116 DT_LITERAL = 261,
117 DT_BASE = 262,
118 DT_BYTE = 263,
119 DT_STRING = 264,
120 DT_LABEL = 265,
121 DT_REF = 266,
122 DT_INCBIN = 267
123 };
124#endif
125
126
127
128#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
129typedef union YYSTYPE
130{
131
132
133 char *propnodename;
134 char *literal;
135 char *labelref;
136 unsigned int cbase;
137 uint8_t byte;
138 struct data data;
139
140 uint64_t addr;
141 cell_t cell;
142 struct property *prop;
143 struct property *proplist;
144 struct node *node;
145 struct node *nodelist;
146 struct reserve_info *re;
147
148
149
150} YYSTYPE;
151# define YYSTYPE_IS_TRIVIAL 1
152# define yystype YYSTYPE /* obsolescent; will be withdrawn */
153# define YYSTYPE_IS_DECLARED 1
154#endif
155
156
157/* Copy the second part of user declarations. */
158
159
160
161#ifdef short
162# undef short
163#endif
164
165#ifdef YYTYPE_UINT8
166typedef YYTYPE_UINT8 yytype_uint8;
167#else
168typedef unsigned char yytype_uint8;
169#endif
170
171#ifdef YYTYPE_INT8
172typedef YYTYPE_INT8 yytype_int8;
173#elif (defined __STDC__ || defined __C99__FUNC__ \
174 || defined __cplusplus || defined _MSC_VER)
175typedef signed char yytype_int8;
176#else
177typedef short int yytype_int8;
178#endif
179
180#ifdef YYTYPE_UINT16
181typedef YYTYPE_UINT16 yytype_uint16;
182#else
183typedef unsigned short int yytype_uint16;
184#endif
185
186#ifdef YYTYPE_INT16
187typedef YYTYPE_INT16 yytype_int16;
188#else
189typedef short int yytype_int16;
190#endif
191
192#ifndef YYSIZE_T
193# ifdef __SIZE_TYPE__
194# define YYSIZE_T __SIZE_TYPE__
195# elif defined size_t
196# define YYSIZE_T size_t
197# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
198 || defined __cplusplus || defined _MSC_VER)
199# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
200# define YYSIZE_T size_t
201# else
202# define YYSIZE_T unsigned int
203# endif
204#endif
205
206#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
207
208#ifndef YY_
209# if defined YYENABLE_NLS && YYENABLE_NLS
210# if ENABLE_NLS
211# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
212# define YY_(msgid) dgettext ("bison-runtime", msgid)
213# endif
214# endif
215# ifndef YY_
216# define YY_(msgid) msgid
217# endif
218#endif
219
220/* Suppress unused-variable warnings by "using" E. */
221#if ! defined lint || defined __GNUC__
222# define YYUSE(e) ((void) (e))
223#else
224# define YYUSE(e) /* empty */
225#endif
226
227/* Identity function, used to suppress warnings about constant conditions. */
228#ifndef lint
229# define YYID(n) (n)
230#else
231#if (defined __STDC__ || defined __C99__FUNC__ \
232 || defined __cplusplus || defined _MSC_VER)
233static int
234YYID (int yyi)
235#else
236static int
237YYID (yyi)
238 int yyi;
239#endif
240{
241 return yyi;
242}
243#endif
244
245#if ! defined yyoverflow || YYERROR_VERBOSE
246
247/* The parser invokes alloca or malloc; define the necessary symbols. */
248
249# ifdef YYSTACK_USE_ALLOCA
250# if YYSTACK_USE_ALLOCA
251# ifdef __GNUC__
252# define YYSTACK_ALLOC __builtin_alloca
253# elif defined __BUILTIN_VA_ARG_INCR
254# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
255# elif defined _AIX
256# define YYSTACK_ALLOC __alloca
257# elif defined _MSC_VER
258# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
259# define alloca _alloca
260# else
261# define YYSTACK_ALLOC alloca
262# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
263 || defined __cplusplus || defined _MSC_VER)
264# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
265# ifndef _STDLIB_H
266# define _STDLIB_H 1
267# endif
268# endif
269# endif
270# endif
271# endif
272
273# ifdef YYSTACK_ALLOC
274 /* Pacify GCC's `empty if-body' warning. */
275# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
276# ifndef YYSTACK_ALLOC_MAXIMUM
277 /* The OS might guarantee only one guard page at the bottom of the stack,
278 and a page size can be as small as 4096 bytes. So we cannot safely
279 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
280 to allow for a few compiler-allocated temporary stack slots. */
281# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
282# endif
283# else
284# define YYSTACK_ALLOC YYMALLOC
285# define YYSTACK_FREE YYFREE
286# ifndef YYSTACK_ALLOC_MAXIMUM
287# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
288# endif
289# if (defined __cplusplus && ! defined _STDLIB_H \
290 && ! ((defined YYMALLOC || defined malloc) \
291 && (defined YYFREE || defined free)))
292# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
293# ifndef _STDLIB_H
294# define _STDLIB_H 1
295# endif
296# endif
297# ifndef YYMALLOC
298# define YYMALLOC malloc
299# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
300 || defined __cplusplus || defined _MSC_VER)
301void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
302# endif
303# endif
304# ifndef YYFREE
305# define YYFREE free
306# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
307 || defined __cplusplus || defined _MSC_VER)
308void free (void *); /* INFRINGES ON USER NAME SPACE */
309# endif
310# endif
311# endif
312#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
313
314
315#if (! defined yyoverflow \
316 && (! defined __cplusplus \
317 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
318
319/* A type that is properly aligned for any stack member. */
320union yyalloc
321{
322 yytype_int16 yyss_alloc;
323 YYSTYPE yyvs_alloc;
324};
325
326/* The size of the maximum gap between one aligned stack and the next. */
327# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
328
329/* The size of an array large to enough to hold all stacks, each with
330 N elements. */
331# define YYSTACK_BYTES(N) \
332 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
333 + YYSTACK_GAP_MAXIMUM)
334
335/* Copy COUNT objects from FROM to TO. The source and destination do
336 not overlap. */
337# ifndef YYCOPY
338# if defined __GNUC__ && 1 < __GNUC__
339# define YYCOPY(To, From, Count) \
340 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
341# else
342# define YYCOPY(To, From, Count) \
343 do \
344 { \
345 YYSIZE_T yyi; \
346 for (yyi = 0; yyi < (Count); yyi++) \
347 (To)[yyi] = (From)[yyi]; \
348 } \
349 while (YYID (0))
350# endif
351# endif
352
353/* Relocate STACK from its old location to the new one. The
354 local variables YYSIZE and YYSTACKSIZE give the old and new number of
355 elements in the stack, and YYPTR gives the new location of the
356 stack. Advance YYPTR to a properly aligned location for the next
357 stack. */
358# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
359 do \
360 { \
361 YYSIZE_T yynewbytes; \
362 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
363 Stack = &yyptr->Stack_alloc; \
364 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
365 yyptr += yynewbytes / sizeof (*yyptr); \
366 } \
367 while (YYID (0))
368
369#endif
370
371/* YYFINAL -- State number of the termination state. */
372#define YYFINAL 4
373/* YYLAST -- Last index in YYTABLE. */
374#define YYLAST 56
375
376/* YYNTOKENS -- Number of terminals. */
377#define YYNTOKENS 25
378/* YYNNTS -- Number of nonterminals. */
379#define YYNNTS 16
380/* YYNRULES -- Number of rules. */
381#define YYNRULES 39
382/* YYNRULES -- Number of states. */
383#define YYNSTATES 67
384
385/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
386#define YYUNDEFTOK 2
387#define YYMAXUTOK 267
388
389#define YYTRANSLATE(YYX) \
390 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
391
392/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
393static const yytype_uint8 yytranslate[] =
394{
395 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
396 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
397 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
398 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
399 22, 24, 2, 2, 23, 2, 2, 14, 2, 2,
400 2, 2, 2, 2, 2, 2, 2, 2, 2, 13,
401 18, 17, 19, 2, 2, 2, 2, 2, 2, 2,
402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
403 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
404 2, 20, 2, 21, 2, 2, 2, 2, 2, 2,
405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
407 2, 2, 2, 15, 2, 16, 2, 2, 2, 2,
408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
421 5, 6, 7, 8, 9, 10, 11, 12
422};
423
424#if YYDEBUG
425/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
426 YYRHS. */
427static const yytype_uint8 yyprhs[] =
428{
429 0, 0, 3, 8, 9, 12, 17, 20, 22, 25,
430 29, 33, 39, 40, 43, 48, 51, 54, 57, 62,
431 67, 70, 80, 86, 89, 90, 93, 96, 97, 100,
432 103, 106, 108, 109, 112, 115, 116, 119, 122, 125
433};
434
435/* YYRHS -- A `-1'-separated list of the rules' RHS. */
436static const yytype_int8 yyrhs[] =
437{
438 26, 0, -1, 3, 13, 27, 30, -1, -1, 28,
439 27, -1, 4, 29, 29, 13, -1, 10, 28, -1,
440 6, -1, 14, 31, -1, 30, 14, 31, -1, 30,
441 11, 31, -1, 15, 32, 39, 16, 13, -1, -1,
442 32, 33, -1, 5, 17, 34, 13, -1, 5, 13,
443 -1, 10, 33, -1, 35, 9, -1, 35, 18, 36,
444 19, -1, 35, 20, 38, 21, -1, 35, 11, -1,
445 35, 12, 22, 9, 23, 29, 23, 29, 24, -1,
446 35, 12, 22, 9, 24, -1, 34, 10, -1, -1,
447 34, 23, -1, 35, 10, -1, -1, 36, 37, -1,
448 36, 11, -1, 36, 10, -1, 6, -1, -1, 38,
449 8, -1, 38, 10, -1, -1, 40, 39, -1, 40,
450 33, -1, 5, 31, -1, 10, 40, -1
451};
452
453/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
454static const yytype_uint16 yyrline[] =
455{
456 0, 86, 86, 95, 98, 105, 109, 117, 124, 128,
457 132, 145, 153, 156, 163, 167, 171, 179, 183, 187,
458 191, 195, 212, 222, 230, 233, 237, 245, 248, 252,
459 257, 264, 272, 275, 279, 287, 290, 294, 302, 306
460};
461#endif
462
463#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
464/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
465 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
466static const char *const yytname[] =
467{
468 "$end", "error", "$undefined", "DT_V1", "DT_MEMRESERVE",
469 "DT_PROPNODENAME", "DT_LITERAL", "DT_BASE", "DT_BYTE", "DT_STRING",
470 "DT_LABEL", "DT_REF", "DT_INCBIN", "';'", "'/'", "'{'", "'}'", "'='",
471 "'<'", "'>'", "'['", "']'", "'('", "','", "')'", "$accept", "sourcefile",
472 "memreserves", "memreserve", "addr", "devicetree", "nodedef", "proplist",
473 "propdef", "propdata", "propdataprefix", "celllist", "cellval",
474 "bytestring", "subnodes", "subnode", 0
475};
476#endif
477
478# ifdef YYPRINT
479/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
480 token YYLEX-NUM. */
481static const yytype_uint16 yytoknum[] =
482{
483 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
484 265, 266, 267, 59, 47, 123, 125, 61, 60, 62,
485 91, 93, 40, 44, 41
486};
487# endif
488
489/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
490static const yytype_uint8 yyr1[] =
491{
492 0, 25, 26, 27, 27, 28, 28, 29, 30, 30,
493 30, 31, 32, 32, 33, 33, 33, 34, 34, 34,
494 34, 34, 34, 34, 35, 35, 35, 36, 36, 36,
495 36, 37, 38, 38, 38, 39, 39, 39, 40, 40
496};
497
498/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
499static const yytype_uint8 yyr2[] =
500{
501 0, 2, 4, 0, 2, 4, 2, 1, 2, 3,
502 3, 5, 0, 2, 4, 2, 2, 2, 4, 4,
503 2, 9, 5, 2, 0, 2, 2, 0, 2, 2,
504 2, 1, 0, 2, 2, 0, 2, 2, 2, 2
505};
506
507/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
508 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
509 means the default is an error. */
510static const yytype_uint8 yydefact[] =
511{
512 0, 0, 0, 3, 1, 0, 0, 0, 3, 7,
513 0, 6, 0, 2, 4, 0, 12, 8, 0, 0,
514 5, 35, 10, 9, 0, 0, 13, 0, 35, 15,
515 24, 38, 16, 39, 0, 37, 36, 0, 0, 11,
516 23, 14, 25, 17, 26, 20, 0, 27, 32, 0,
517 0, 0, 0, 31, 30, 29, 18, 28, 33, 34,
518 19, 0, 22, 0, 0, 0, 21
519};
520
521/* YYDEFGOTO[NTERM-NUM]. */
522static const yytype_int8 yydefgoto[] =
523{
524 -1, 2, 7, 8, 10, 13, 17, 21, 26, 37,
525 38, 50, 57, 51, 27, 28
526};
527
528/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
529 STATE-NUM. */
530#define YYPACT_NINF -12
531static const yytype_int8 yypact[] =
532{
533 10, -11, 18, -1, -12, 22, -1, 15, -1, -12,
534 22, -12, 20, 1, -12, 17, -12, -12, 20, 20,
535 -12, 6, -12, -12, 21, 6, -12, 23, 6, -12,
536 -12, -12, -12, -12, 28, -12, -12, -6, 13, -12,
537 -12, -12, -12, -12, -12, -12, 24, -12, -12, 33,
538 -5, 0, -4, -12, -12, -12, -12, -12, -12, -12,
539 -12, 22, -12, 25, 22, 19, -12
540};
541
542/* YYPGOTO[NTERM-NUM]. */
543static const yytype_int8 yypgoto[] =
544{
545 -12, -12, 36, 39, -10, -12, 8, -12, 12, -12,
546 -12, -12, -12, -12, 27, 31
547};
548
549/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
550 positive, shift that token. If negative, reduce the rule which
551 number is the opposite. If zero, do what YYDEFACT says.
552 If YYTABLE_NINF, syntax error. */
553#define YYTABLE_NINF -1
554static const yytype_uint8 yytable[] =
555{
556 15, 53, 3, 5, 40, 54, 55, 41, 58, 6,
557 59, 24, 18, 1, 56, 19, 25, 42, 4, 61,
558 62, 60, 43, 44, 45, 46, 22, 23, 9, 12,
559 20, 47, 31, 48, 29, 16, 16, 32, 30, 34,
560 35, 39, 52, 66, 14, 11, 49, 0, 64, 0,
561 0, 63, 0, 0, 65, 36, 33
562};
563
564static const yytype_int8 yycheck[] =
565{
566 10, 6, 13, 4, 10, 10, 11, 13, 8, 10,
567 10, 5, 11, 3, 19, 14, 10, 23, 0, 23,
568 24, 21, 9, 10, 11, 12, 18, 19, 6, 14,
569 13, 18, 24, 20, 13, 15, 15, 25, 17, 16,
570 28, 13, 9, 24, 8, 6, 22, -1, 23, -1,
571 -1, 61, -1, -1, 64, 28, 25
572};
573
574/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
575 symbol of state STATE-NUM. */
576static const yytype_uint8 yystos[] =
577{
578 0, 3, 26, 13, 0, 4, 10, 27, 28, 6,
579 29, 28, 14, 30, 27, 29, 15, 31, 11, 14,
580 13, 32, 31, 31, 5, 10, 33, 39, 40, 13,
581 17, 31, 33, 40, 16, 33, 39, 34, 35, 13,
582 10, 13, 23, 9, 10, 11, 12, 18, 20, 22,
583 36, 38, 9, 6, 10, 11, 19, 37, 8, 10,
584 21, 23, 24, 29, 23, 29, 24
585};
586
587#define yyerrok (yyerrstatus = 0)
588#define yyclearin (yychar = YYEMPTY)
589#define YYEMPTY (-2)
590#define YYEOF 0
591
592#define YYACCEPT goto yyacceptlab
593#define YYABORT goto yyabortlab
594#define YYERROR goto yyerrorlab
595
596
597/* Like YYERROR except do call yyerror. This remains here temporarily
598 to ease the transition to the new meaning of YYERROR, for GCC.
599 Once GCC version 2 has supplanted version 1, this can go. However,
600 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
601 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
602 discussed. */
603
604#define YYFAIL goto yyerrlab
605#if defined YYFAIL
606 /* This is here to suppress warnings from the GCC cpp's
607 -Wunused-macros. Normally we don't worry about that warning, but
608 some users do, and we want to make it easy for users to remove
609 YYFAIL uses, which will produce warnings from Bison 2.5. */
610#endif
611
612#define YYRECOVERING() (!!yyerrstatus)
613
614#define YYBACKUP(Token, Value) \
615do \
616 if (yychar == YYEMPTY && yylen == 1) \
617 { \
618 yychar = (Token); \
619 yylval = (Value); \
620 yytoken = YYTRANSLATE (yychar); \
621 YYPOPSTACK (1); \
622 goto yybackup; \
623 } \
624 else \
625 { \
626 yyerror (YY_("syntax error: cannot back up")); \
627 YYERROR; \
628 } \
629while (YYID (0))
630
631
632#define YYTERROR 1
633#define YYERRCODE 256
634
635
636/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
637 If N is 0, then set CURRENT to the empty location which ends
638 the previous symbol: RHS[0] (always defined). */
639
640#define YYRHSLOC(Rhs, K) ((Rhs)[K])
641#ifndef YYLLOC_DEFAULT
642# define YYLLOC_DEFAULT(Current, Rhs, N) \
643 do \
644 if (YYID (N)) \
645 { \
646 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
647 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
648 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
649 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
650 } \
651 else \
652 { \
653 (Current).first_line = (Current).last_line = \
654 YYRHSLOC (Rhs, 0).last_line; \
655 (Current).first_column = (Current).last_column = \
656 YYRHSLOC (Rhs, 0).last_column; \
657 } \
658 while (YYID (0))
659#endif
660
661
662/* YY_LOCATION_PRINT -- Print the location on the stream.
663 This macro was not mandated originally: define only if we know
664 we won't break user code: when these are the locations we know. */
665
666#ifndef YY_LOCATION_PRINT
667# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
668# define YY_LOCATION_PRINT(File, Loc) \
669 fprintf (File, "%d.%d-%d.%d", \
670 (Loc).first_line, (Loc).first_column, \
671 (Loc).last_line, (Loc).last_column)
672# else
673# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
674# endif
675#endif
676
677
678/* YYLEX -- calling `yylex' with the right arguments. */
679
680#ifdef YYLEX_PARAM
681# define YYLEX yylex (YYLEX_PARAM)
682#else
683# define YYLEX yylex ()
684#endif
685
686/* Enable debugging if requested. */
687#if YYDEBUG
688
689# ifndef YYFPRINTF
690# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
691# define YYFPRINTF fprintf
692# endif
693
694# define YYDPRINTF(Args) \
695do { \
696 if (yydebug) \
697 YYFPRINTF Args; \
698} while (YYID (0))
699
700# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
701do { \
702 if (yydebug) \
703 { \
704 YYFPRINTF (stderr, "%s ", Title); \
705 yy_symbol_print (stderr, \
706 Type, Value); \
707 YYFPRINTF (stderr, "\n"); \
708 } \
709} while (YYID (0))
710
711
712/*--------------------------------.
713| Print this symbol on YYOUTPUT. |
714`--------------------------------*/
715
716/*ARGSUSED*/
717#if (defined __STDC__ || defined __C99__FUNC__ \
718 || defined __cplusplus || defined _MSC_VER)
719static void
720yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
721#else
722static void
723yy_symbol_value_print (yyoutput, yytype, yyvaluep)
724 FILE *yyoutput;
725 int yytype;
726 YYSTYPE const * const yyvaluep;
727#endif
728{
729 if (!yyvaluep)
730 return;
731# ifdef YYPRINT
732 if (yytype < YYNTOKENS)
733 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
734# else
735 YYUSE (yyoutput);
736# endif
737 switch (yytype)
738 {
739 default:
740 break;
741 }
742}
743
744
745/*--------------------------------.
746| Print this symbol on YYOUTPUT. |
747`--------------------------------*/
748
749#if (defined __STDC__ || defined __C99__FUNC__ \
750 || defined __cplusplus || defined _MSC_VER)
751static void
752yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
753#else
754static void
755yy_symbol_print (yyoutput, yytype, yyvaluep)
756 FILE *yyoutput;
757 int yytype;
758 YYSTYPE const * const yyvaluep;
759#endif
760{
761 if (yytype < YYNTOKENS)
762 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
763 else
764 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
765
766 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
767 YYFPRINTF (yyoutput, ")");
768}
769
770/*------------------------------------------------------------------.
771| yy_stack_print -- Print the state stack from its BOTTOM up to its |
772| TOP (included). |
773`------------------------------------------------------------------*/
774
775#if (defined __STDC__ || defined __C99__FUNC__ \
776 || defined __cplusplus || defined _MSC_VER)
777static void
778yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
779#else
780static void
781yy_stack_print (yybottom, yytop)
782 yytype_int16 *yybottom;
783 yytype_int16 *yytop;
784#endif
785{
786 YYFPRINTF (stderr, "Stack now");
787 for (; yybottom <= yytop; yybottom++)
788 {
789 int yybot = *yybottom;
790 YYFPRINTF (stderr, " %d", yybot);
791 }
792 YYFPRINTF (stderr, "\n");
793}
794
795# define YY_STACK_PRINT(Bottom, Top) \
796do { \
797 if (yydebug) \
798 yy_stack_print ((Bottom), (Top)); \
799} while (YYID (0))
800
801
802/*------------------------------------------------.
803| Report that the YYRULE is going to be reduced. |
804`------------------------------------------------*/
805
806#if (defined __STDC__ || defined __C99__FUNC__ \
807 || defined __cplusplus || defined _MSC_VER)
808static void
809yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
810#else
811static void
812yy_reduce_print (yyvsp, yyrule)
813 YYSTYPE *yyvsp;
814 int yyrule;
815#endif
816{
817 int yynrhs = yyr2[yyrule];
818 int yyi;
819 unsigned long int yylno = yyrline[yyrule];
820 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
821 yyrule - 1, yylno);
822 /* The symbols being reduced. */
823 for (yyi = 0; yyi < yynrhs; yyi++)
824 {
825 YYFPRINTF (stderr, " $%d = ", yyi + 1);
826 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
827 &(yyvsp[(yyi + 1) - (yynrhs)])
828 );
829 YYFPRINTF (stderr, "\n");
830 }
831}
832
833# define YY_REDUCE_PRINT(Rule) \
834do { \
835 if (yydebug) \
836 yy_reduce_print (yyvsp, Rule); \
837} while (YYID (0))
838
839/* Nonzero means print parse trace. It is left uninitialized so that
840 multiple parsers can coexist. */
841int yydebug;
842#else /* !YYDEBUG */
843# define YYDPRINTF(Args)
844# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
845# define YY_STACK_PRINT(Bottom, Top)
846# define YY_REDUCE_PRINT(Rule)
847#endif /* !YYDEBUG */
848
849
850/* YYINITDEPTH -- initial size of the parser's stacks. */
851#ifndef YYINITDEPTH
852# define YYINITDEPTH 200
853#endif
854
855/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
856 if the built-in stack extension method is used).
857
858 Do not make this value too large; the results are undefined if
859 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
860 evaluated with infinite-precision integer arithmetic. */
861
862#ifndef YYMAXDEPTH
863# define YYMAXDEPTH 10000
864#endif
865
866
867
868#if YYERROR_VERBOSE
869
870# ifndef yystrlen
871# if defined __GLIBC__ && defined _STRING_H
872# define yystrlen strlen
873# else
874/* Return the length of YYSTR. */
875#if (defined __STDC__ || defined __C99__FUNC__ \
876 || defined __cplusplus || defined _MSC_VER)
877static YYSIZE_T
878yystrlen (const char *yystr)
879#else
880static YYSIZE_T
881yystrlen (yystr)
882 const char *yystr;
883#endif
884{
885 YYSIZE_T yylen;
886 for (yylen = 0; yystr[yylen]; yylen++)
887 continue;
888 return yylen;
889}
890# endif
891# endif
892
893# ifndef yystpcpy
894# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
895# define yystpcpy stpcpy
896# else
897/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
898 YYDEST. */
899#if (defined __STDC__ || defined __C99__FUNC__ \
900 || defined __cplusplus || defined _MSC_VER)
901static char *
902yystpcpy (char *yydest, const char *yysrc)
903#else
904static char *
905yystpcpy (yydest, yysrc)
906 char *yydest;
907 const char *yysrc;
908#endif
909{
910 char *yyd = yydest;
911 const char *yys = yysrc;
912
913 while ((*yyd++ = *yys++) != '\0')
914 continue;
915
916 return yyd - 1;
917}
918# endif
919# endif
920
921# ifndef yytnamerr
922/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
923 quotes and backslashes, so that it's suitable for yyerror. The
924 heuristic is that double-quoting is unnecessary unless the string
925 contains an apostrophe, a comma, or backslash (other than
926 backslash-backslash). YYSTR is taken from yytname. If YYRES is
927 null, do not copy; instead, return the length of what the result
928 would have been. */
929static YYSIZE_T
930yytnamerr (char *yyres, const char *yystr)
931{
932 if (*yystr == '"')
933 {
934 YYSIZE_T yyn = 0;
935 char const *yyp = yystr;
936
937 for (;;)
938 switch (*++yyp)
939 {
940 case '\'':
941 case ',':
942 goto do_not_strip_quotes;
943
944 case '\\':
945 if (*++yyp != '\\')
946 goto do_not_strip_quotes;
947 /* Fall through. */
948 default:
949 if (yyres)
950 yyres[yyn] = *yyp;
951 yyn++;
952 break;
953
954 case '"':
955 if (yyres)
956 yyres[yyn] = '\0';
957 return yyn;
958 }
959 do_not_strip_quotes: ;
960 }
961
962 if (! yyres)
963 return yystrlen (yystr);
964
965 return yystpcpy (yyres, yystr) - yyres;
966}
967# endif
968
969/* Copy into YYRESULT an error message about the unexpected token
970 YYCHAR while in state YYSTATE. Return the number of bytes copied,
971 including the terminating null byte. If YYRESULT is null, do not
972 copy anything; just return the number of bytes that would be
973 copied. As a special case, return 0 if an ordinary "syntax error"
974 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
975 size calculation. */
976static YYSIZE_T
977yysyntax_error (char *yyresult, int yystate, int yychar)
978{
979 int yyn = yypact[yystate];
980
981 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
982 return 0;
983 else
984 {
985 int yytype = YYTRANSLATE (yychar);
986 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
987 YYSIZE_T yysize = yysize0;
988 YYSIZE_T yysize1;
989 int yysize_overflow = 0;
990 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
991 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
992 int yyx;
993
994# if 0
995 /* This is so xgettext sees the translatable formats that are
996 constructed on the fly. */
997 YY_("syntax error, unexpected %s");
998 YY_("syntax error, unexpected %s, expecting %s");
999 YY_("syntax error, unexpected %s, expecting %s or %s");
1000 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1001 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1002# endif
1003 char *yyfmt;
1004 char const *yyf;
1005 static char const yyunexpected[] = "syntax error, unexpected %s";
1006 static char const yyexpecting[] = ", expecting %s";
1007 static char const yyor[] = " or %s";
1008 char yyformat[sizeof yyunexpected
1009 + sizeof yyexpecting - 1
1010 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1011 * (sizeof yyor - 1))];
1012 char const *yyprefix = yyexpecting;
1013
1014 /* Start YYX at -YYN if negative to avoid negative indexes in
1015 YYCHECK. */
1016 int yyxbegin = yyn < 0 ? -yyn : 0;
1017
1018 /* Stay within bounds of both yycheck and yytname. */
1019 int yychecklim = YYLAST - yyn + 1;
1020 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1021 int yycount = 1;
1022
1023 yyarg[0] = yytname[yytype];
1024 yyfmt = yystpcpy (yyformat, yyunexpected);
1025
1026 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1027 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1028 {
1029 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1030 {
1031 yycount = 1;
1032 yysize = yysize0;
1033 yyformat[sizeof yyunexpected - 1] = '\0';
1034 break;
1035 }
1036 yyarg[yycount++] = yytname[yyx];
1037 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1038 yysize_overflow |= (yysize1 < yysize);
1039 yysize = yysize1;
1040 yyfmt = yystpcpy (yyfmt, yyprefix);
1041 yyprefix = yyor;
1042 }
1043
1044 yyf = YY_(yyformat);
1045 yysize1 = yysize + yystrlen (yyf);
1046 yysize_overflow |= (yysize1 < yysize);
1047 yysize = yysize1;
1048
1049 if (yysize_overflow)
1050 return YYSIZE_MAXIMUM;
1051
1052 if (yyresult)
1053 {
1054 /* Avoid sprintf, as that infringes on the user's name space.
1055 Don't have undefined behavior even if the translation
1056 produced a string with the wrong number of "%s"s. */
1057 char *yyp = yyresult;
1058 int yyi = 0;
1059 while ((*yyp = *yyf) != '\0')
1060 {
1061 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1062 {
1063 yyp += yytnamerr (yyp, yyarg[yyi++]);
1064 yyf += 2;
1065 }
1066 else
1067 {
1068 yyp++;
1069 yyf++;
1070 }
1071 }
1072 }
1073 return yysize;
1074 }
1075}
1076#endif /* YYERROR_VERBOSE */
1077
1078
1079/*-----------------------------------------------.
1080| Release the memory associated to this symbol. |
1081`-----------------------------------------------*/
1082
1083/*ARGSUSED*/
1084#if (defined __STDC__ || defined __C99__FUNC__ \
1085 || defined __cplusplus || defined _MSC_VER)
1086static void
1087yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1088#else
1089static void
1090yydestruct (yymsg, yytype, yyvaluep)
1091 const char *yymsg;
1092 int yytype;
1093 YYSTYPE *yyvaluep;
1094#endif
1095{
1096 YYUSE (yyvaluep);
1097
1098 if (!yymsg)
1099 yymsg = "Deleting";
1100 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1101
1102 switch (yytype)
1103 {
1104
1105 default:
1106 break;
1107 }
1108}
1109
1110/* Prevent warnings from -Wmissing-prototypes. */
1111#ifdef YYPARSE_PARAM
1112#if defined __STDC__ || defined __cplusplus
1113int yyparse (void *YYPARSE_PARAM);
1114#else
1115int yyparse ();
1116#endif
1117#else /* ! YYPARSE_PARAM */
1118#if defined __STDC__ || defined __cplusplus
1119int yyparse (void);
1120#else
1121int yyparse ();
1122#endif
1123#endif /* ! YYPARSE_PARAM */
1124
1125
1126/* The lookahead symbol. */
1127int yychar;
1128
1129/* The semantic value of the lookahead symbol. */
1130YYSTYPE yylval;
1131
1132/* Number of syntax errors so far. */
1133int yynerrs;
1134
1135
1136
1137/*-------------------------.
1138| yyparse or yypush_parse. |
1139`-------------------------*/
1140
1141#ifdef YYPARSE_PARAM
1142#if (defined __STDC__ || defined __C99__FUNC__ \
1143 || defined __cplusplus || defined _MSC_VER)
1144int
1145yyparse (void *YYPARSE_PARAM)
1146#else
1147int
1148yyparse (YYPARSE_PARAM)
1149 void *YYPARSE_PARAM;
1150#endif
1151#else /* ! YYPARSE_PARAM */
1152#if (defined __STDC__ || defined __C99__FUNC__ \
1153 || defined __cplusplus || defined _MSC_VER)
1154int
1155yyparse (void)
1156#else
1157int
1158yyparse ()
1159
1160#endif
1161#endif
1162{
1163
1164
1165 int yystate;
1166 /* Number of tokens to shift before error messages enabled. */
1167 int yyerrstatus;
1168
1169 /* The stacks and their tools:
1170 `yyss': related to states.
1171 `yyvs': related to semantic values.
1172
1173 Refer to the stacks thru separate pointers, to allow yyoverflow
1174 to reallocate them elsewhere. */
1175
1176 /* The state stack. */
1177 yytype_int16 yyssa[YYINITDEPTH];
1178 yytype_int16 *yyss;
1179 yytype_int16 *yyssp;
1180
1181 /* The semantic value stack. */
1182 YYSTYPE yyvsa[YYINITDEPTH];
1183 YYSTYPE *yyvs;
1184 YYSTYPE *yyvsp;
1185
1186 YYSIZE_T yystacksize;
1187
1188 int yyn;
1189 int yyresult;
1190 /* Lookahead token as an internal (translated) token number. */
1191 int yytoken;
1192 /* The variables used to return semantic value and location from the
1193 action routines. */
1194 YYSTYPE yyval;
1195
1196#if YYERROR_VERBOSE
1197 /* Buffer for error messages, and its allocated size. */
1198 char yymsgbuf[128];
1199 char *yymsg = yymsgbuf;
1200 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1201#endif
1202
1203#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1204
1205 /* The number of symbols on the RHS of the reduced rule.
1206 Keep to zero when no symbol should be popped. */
1207 int yylen = 0;
1208
1209 yytoken = 0;
1210 yyss = yyssa;
1211 yyvs = yyvsa;
1212 yystacksize = YYINITDEPTH;
1213
1214 YYDPRINTF ((stderr, "Starting parse\n"));
1215
1216 yystate = 0;
1217 yyerrstatus = 0;
1218 yynerrs = 0;
1219 yychar = YYEMPTY; /* Cause a token to be read. */
1220
1221 /* Initialize stack pointers.
1222 Waste one element of value and location stack
1223 so that they stay on the same level as the state stack.
1224 The wasted elements are never initialized. */
1225 yyssp = yyss;
1226 yyvsp = yyvs;
1227
1228 goto yysetstate;
1229
1230/*------------------------------------------------------------.
1231| yynewstate -- Push a new state, which is found in yystate. |
1232`------------------------------------------------------------*/
1233 yynewstate:
1234 /* In all cases, when you get here, the value and location stacks
1235 have just been pushed. So pushing a state here evens the stacks. */
1236 yyssp++;
1237
1238 yysetstate:
1239 *yyssp = yystate;
1240
1241 if (yyss + yystacksize - 1 <= yyssp)
1242 {
1243 /* Get the current used size of the three stacks, in elements. */
1244 YYSIZE_T yysize = yyssp - yyss + 1;
1245
1246#ifdef yyoverflow
1247 {
1248 /* Give user a chance to reallocate the stack. Use copies of
1249 these so that the &'s don't force the real ones into
1250 memory. */
1251 YYSTYPE *yyvs1 = yyvs;
1252 yytype_int16 *yyss1 = yyss;
1253
1254 /* Each stack pointer address is followed by the size of the
1255 data in use in that stack, in bytes. This used to be a
1256 conditional around just the two extra args, but that might
1257 be undefined if yyoverflow is a macro. */
1258 yyoverflow (YY_("memory exhausted"),
1259 &yyss1, yysize * sizeof (*yyssp),
1260 &yyvs1, yysize * sizeof (*yyvsp),
1261 &yystacksize);
1262
1263 yyss = yyss1;
1264 yyvs = yyvs1;
1265 }
1266#else /* no yyoverflow */
1267# ifndef YYSTACK_RELOCATE
1268 goto yyexhaustedlab;
1269# else
1270 /* Extend the stack our own way. */
1271 if (YYMAXDEPTH <= yystacksize)
1272 goto yyexhaustedlab;
1273 yystacksize *= 2;
1274 if (YYMAXDEPTH < yystacksize)
1275 yystacksize = YYMAXDEPTH;
1276
1277 {
1278 yytype_int16 *yyss1 = yyss;
1279 union yyalloc *yyptr =
1280 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1281 if (! yyptr)
1282 goto yyexhaustedlab;
1283 YYSTACK_RELOCATE (yyss_alloc, yyss);
1284 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1285# undef YYSTACK_RELOCATE
1286 if (yyss1 != yyssa)
1287 YYSTACK_FREE (yyss1);
1288 }
1289# endif
1290#endif /* no yyoverflow */
1291
1292 yyssp = yyss + yysize - 1;
1293 yyvsp = yyvs + yysize - 1;
1294
1295 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1296 (unsigned long int) yystacksize));
1297
1298 if (yyss + yystacksize - 1 <= yyssp)
1299 YYABORT;
1300 }
1301
1302 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1303
1304 if (yystate == YYFINAL)
1305 YYACCEPT;
1306
1307 goto yybackup;
1308
1309/*-----------.
1310| yybackup. |
1311`-----------*/
1312yybackup:
1313
1314 /* Do appropriate processing given the current state. Read a
1315 lookahead token if we need one and don't already have one. */
1316
1317 /* First try to decide what to do without reference to lookahead token. */
1318 yyn = yypact[yystate];
1319 if (yyn == YYPACT_NINF)
1320 goto yydefault;
1321
1322 /* Not known => get a lookahead token if don't already have one. */
1323
1324 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1325 if (yychar == YYEMPTY)
1326 {
1327 YYDPRINTF ((stderr, "Reading a token: "));
1328 yychar = YYLEX;
1329 }
1330
1331 if (yychar <= YYEOF)
1332 {
1333 yychar = yytoken = YYEOF;
1334 YYDPRINTF ((stderr, "Now at end of input.\n"));
1335 }
1336 else
1337 {
1338 yytoken = YYTRANSLATE (yychar);
1339 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1340 }
1341
1342 /* If the proper action on seeing token YYTOKEN is to reduce or to
1343 detect an error, take that action. */
1344 yyn += yytoken;
1345 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1346 goto yydefault;
1347 yyn = yytable[yyn];
1348 if (yyn <= 0)
1349 {
1350 if (yyn == 0 || yyn == YYTABLE_NINF)
1351 goto yyerrlab;
1352 yyn = -yyn;
1353 goto yyreduce;
1354 }
1355
1356 /* Count tokens shifted since error; after three, turn off error
1357 status. */
1358 if (yyerrstatus)
1359 yyerrstatus--;
1360
1361 /* Shift the lookahead token. */
1362 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1363
1364 /* Discard the shifted token. */
1365 yychar = YYEMPTY;
1366
1367 yystate = yyn;
1368 *++yyvsp = yylval;
1369
1370 goto yynewstate;
1371
1372
1373/*-----------------------------------------------------------.
1374| yydefault -- do the default action for the current state. |
1375`-----------------------------------------------------------*/
1376yydefault:
1377 yyn = yydefact[yystate];
1378 if (yyn == 0)
1379 goto yyerrlab;
1380 goto yyreduce;
1381
1382
1383/*-----------------------------.
1384| yyreduce -- Do a reduction. |
1385`-----------------------------*/
1386yyreduce:
1387 /* yyn is the number of a rule to reduce with. */
1388 yylen = yyr2[yyn];
1389
1390 /* If YYLEN is nonzero, implement the default value of the action:
1391 `$$ = $1'.
1392
1393 Otherwise, the following line sets YYVAL to garbage.
1394 This behavior is undocumented and Bison
1395 users should not rely upon it. Assigning to YYVAL
1396 unconditionally makes the parser a bit smaller, and it avoids a
1397 GCC warning that YYVAL may be used uninitialized. */
1398 yyval = yyvsp[1-yylen];
1399
1400
1401 YY_REDUCE_PRINT (yyn);
1402 switch (yyn)
1403 {
1404 case 2:
1405
1406 {
1407 the_boot_info = build_boot_info((yyvsp[(3) - (4)].re), (yyvsp[(4) - (4)].node),
1408 guess_boot_cpuid((yyvsp[(4) - (4)].node)));
1409 ;}
1410 break;
1411
1412 case 3:
1413
1414 {
1415 (yyval.re) = NULL;
1416 ;}
1417 break;
1418
1419 case 4:
1420
1421 {
1422 (yyval.re) = chain_reserve_entry((yyvsp[(1) - (2)].re), (yyvsp[(2) - (2)].re));
1423 ;}
1424 break;
1425
1426 case 5:
1427
1428 {
1429 (yyval.re) = build_reserve_entry((yyvsp[(2) - (4)].addr), (yyvsp[(3) - (4)].addr));
1430 ;}
1431 break;
1432
1433 case 6:
1434
1435 {
1436 add_label(&(yyvsp[(2) - (2)].re)->labels, (yyvsp[(1) - (2)].labelref));
1437 (yyval.re) = (yyvsp[(2) - (2)].re);
1438 ;}
1439 break;
1440
1441 case 7:
1442
1443 {
1444 (yyval.addr) = eval_literal((yyvsp[(1) - (1)].literal), 0, 64);
1445 ;}
1446 break;
1447
1448 case 8:
1449
1450 {
1451 (yyval.node) = name_node((yyvsp[(2) - (2)].node), "");
1452 ;}
1453 break;
1454
1455 case 9:
1456
1457 {
1458 (yyval.node) = merge_nodes((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
1459 ;}
1460 break;
1461
1462 case 10:
1463
1464 {
1465 struct node *target = get_node_by_ref((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].labelref));
1466
1467 if (target)
1468 merge_nodes(target, (yyvsp[(3) - (3)].node));
1469 else
1470 print_error("label or path, '%s', not found", (yyvsp[(2) - (3)].labelref));
1471 (yyval.node) = (yyvsp[(1) - (3)].node);
1472 ;}
1473 break;
1474
1475 case 11:
1476
1477 {
1478 (yyval.node) = build_node((yyvsp[(2) - (5)].proplist), (yyvsp[(3) - (5)].nodelist));
1479 ;}
1480 break;
1481
1482 case 12:
1483
1484 {
1485 (yyval.proplist) = NULL;
1486 ;}
1487 break;
1488
1489 case 13:
1490
1491 {
1492 (yyval.proplist) = chain_property((yyvsp[(2) - (2)].prop), (yyvsp[(1) - (2)].proplist));
1493 ;}
1494 break;
1495
1496 case 14:
1497
1498 {
1499 (yyval.prop) = build_property((yyvsp[(1) - (4)].propnodename), (yyvsp[(3) - (4)].data));
1500 ;}
1501 break;
1502
1503 case 15:
1504
1505 {
1506 (yyval.prop) = build_property((yyvsp[(1) - (2)].propnodename), empty_data);
1507 ;}
1508 break;
1509
1510 case 16:
1511
1512 {
1513 add_label(&(yyvsp[(2) - (2)].prop)->labels, (yyvsp[(1) - (2)].labelref));
1514 (yyval.prop) = (yyvsp[(2) - (2)].prop);
1515 ;}
1516 break;
1517
1518 case 17:
1519
1520 {
1521 (yyval.data) = data_merge((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].data));
1522 ;}
1523 break;
1524
1525 case 18:
1526
1527 {
1528 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data));
1529 ;}
1530 break;
1531
1532 case 19:
1533
1534 {
1535 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data));
1536 ;}
1537 break;
1538
1539 case 20:
1540
1541 {
1542 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), REF_PATH, (yyvsp[(2) - (2)].labelref));
1543 ;}
1544 break;
1545
1546 case 21:
1547
1548 {
1549 FILE *f = srcfile_relative_open((yyvsp[(4) - (9)].data).val, NULL);
1550 struct data d;
1551
1552 if ((yyvsp[(6) - (9)].addr) != 0)
1553 if (fseek(f, (yyvsp[(6) - (9)].addr), SEEK_SET) != 0)
1554 print_error("Couldn't seek to offset %llu in \"%s\": %s",
1555 (unsigned long long)(yyvsp[(6) - (9)].addr),
1556 (yyvsp[(4) - (9)].data).val,
1557 strerror(errno));
1558
1559 d = data_copy_file(f, (yyvsp[(8) - (9)].addr));
1560
1561 (yyval.data) = data_merge((yyvsp[(1) - (9)].data), d);
1562 fclose(f);
1563 ;}
1564 break;
1565
1566 case 22:
1567
1568 {
1569 FILE *f = srcfile_relative_open((yyvsp[(4) - (5)].data).val, NULL);
1570 struct data d = empty_data;
1571
1572 d = data_copy_file(f, -1);
1573
1574 (yyval.data) = data_merge((yyvsp[(1) - (5)].data), d);
1575 fclose(f);
1576 ;}
1577 break;
1578
1579 case 23:
1580
1581 {
1582 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1583 ;}
1584 break;
1585
1586 case 24:
1587
1588 {
1589 (yyval.data) = empty_data;
1590 ;}
1591 break;
1592
1593 case 25:
1594
1595 {
1596 (yyval.data) = (yyvsp[(1) - (2)].data);
1597 ;}
1598 break;
1599
1600 case 26:
1601
1602 {
1603 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1604 ;}
1605 break;
1606
1607 case 27:
1608
1609 {
1610 (yyval.data) = empty_data;
1611 ;}
1612 break;
1613
1614 case 28:
1615
1616 {
1617 (yyval.data) = data_append_cell((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].cell));
1618 ;}
1619 break;
1620
1621 case 29:
1622
1623 {
1624 (yyval.data) = data_append_cell(data_add_marker((yyvsp[(1) - (2)].data), REF_PHANDLE,
1625 (yyvsp[(2) - (2)].labelref)), -1);
1626 ;}
1627 break;
1628
1629 case 30:
1630
1631 {
1632 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1633 ;}
1634 break;
1635
1636 case 31:
1637
1638 {
1639 (yyval.cell) = eval_literal((yyvsp[(1) - (1)].literal), 0, 32);
1640 ;}
1641 break;
1642
1643 case 32:
1644
1645 {
1646 (yyval.data) = empty_data;
1647 ;}
1648 break;
1649
1650 case 33:
1651
1652 {
1653 (yyval.data) = data_append_byte((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].byte));
1654 ;}
1655 break;
1656
1657 case 34:
1658
1659 {
1660 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1661 ;}
1662 break;
1663
1664 case 35:
1665
1666 {
1667 (yyval.nodelist) = NULL;
1668 ;}
1669 break;
1670
1671 case 36:
1672
1673 {
1674 (yyval.nodelist) = chain_node((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].nodelist));
1675 ;}
1676 break;
1677
1678 case 37:
1679
1680 {
1681 print_error("syntax error: properties must precede subnodes");
1682 YYERROR;
1683 ;}
1684 break;
1685
1686 case 38:
1687
1688 {
1689 (yyval.node) = name_node((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].propnodename));
1690 ;}
1691 break;
1692
1693 case 39:
1694
1695 {
1696 add_label(&(yyvsp[(2) - (2)].node)->labels, (yyvsp[(1) - (2)].labelref));
1697 (yyval.node) = (yyvsp[(2) - (2)].node);
1698 ;}
1699 break;
1700
1701
1702
1703 default: break;
1704 }
1705 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1706
1707 YYPOPSTACK (yylen);
1708 yylen = 0;
1709 YY_STACK_PRINT (yyss, yyssp);
1710
1711 *++yyvsp = yyval;
1712
1713 /* Now `shift' the result of the reduction. Determine what state
1714 that goes to, based on the state we popped back to and the rule
1715 number reduced by. */
1716
1717 yyn = yyr1[yyn];
1718
1719 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1720 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1721 yystate = yytable[yystate];
1722 else
1723 yystate = yydefgoto[yyn - YYNTOKENS];
1724
1725 goto yynewstate;
1726
1727
1728/*------------------------------------.
1729| yyerrlab -- here on detecting error |
1730`------------------------------------*/
1731yyerrlab:
1732 /* If not already recovering from an error, report this error. */
1733 if (!yyerrstatus)
1734 {
1735 ++yynerrs;
1736#if ! YYERROR_VERBOSE
1737 yyerror (YY_("syntax error"));
1738#else
1739 {
1740 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1741 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1742 {
1743 YYSIZE_T yyalloc = 2 * yysize;
1744 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1745 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1746 if (yymsg != yymsgbuf)
1747 YYSTACK_FREE (yymsg);
1748 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1749 if (yymsg)
1750 yymsg_alloc = yyalloc;
1751 else
1752 {
1753 yymsg = yymsgbuf;
1754 yymsg_alloc = sizeof yymsgbuf;
1755 }
1756 }
1757
1758 if (0 < yysize && yysize <= yymsg_alloc)
1759 {
1760 (void) yysyntax_error (yymsg, yystate, yychar);
1761 yyerror (yymsg);
1762 }
1763 else
1764 {
1765 yyerror (YY_("syntax error"));
1766 if (yysize != 0)
1767 goto yyexhaustedlab;
1768 }
1769 }
1770#endif
1771 }
1772
1773
1774
1775 if (yyerrstatus == 3)
1776 {
1777 /* If just tried and failed to reuse lookahead token after an
1778 error, discard it. */
1779
1780 if (yychar <= YYEOF)
1781 {
1782 /* Return failure if at end of input. */
1783 if (yychar == YYEOF)
1784 YYABORT;
1785 }
1786 else
1787 {
1788 yydestruct ("Error: discarding",
1789 yytoken, &yylval);
1790 yychar = YYEMPTY;
1791 }
1792 }
1793
1794 /* Else will try to reuse lookahead token after shifting the error
1795 token. */
1796 goto yyerrlab1;
1797
1798
1799/*---------------------------------------------------.
1800| yyerrorlab -- error raised explicitly by YYERROR. |
1801`---------------------------------------------------*/
1802yyerrorlab:
1803
1804 /* Pacify compilers like GCC when the user code never invokes
1805 YYERROR and the label yyerrorlab therefore never appears in user
1806 code. */
1807 if (/*CONSTCOND*/ 0)
1808 goto yyerrorlab;
1809
1810 /* Do not reclaim the symbols of the rule which action triggered
1811 this YYERROR. */
1812 YYPOPSTACK (yylen);
1813 yylen = 0;
1814 YY_STACK_PRINT (yyss, yyssp);
1815 yystate = *yyssp;
1816 goto yyerrlab1;
1817
1818
1819/*-------------------------------------------------------------.
1820| yyerrlab1 -- common code for both syntax error and YYERROR. |
1821`-------------------------------------------------------------*/
1822yyerrlab1:
1823 yyerrstatus = 3; /* Each real token shifted decrements this. */
1824
1825 for (;;)
1826 {
1827 yyn = yypact[yystate];
1828 if (yyn != YYPACT_NINF)
1829 {
1830 yyn += YYTERROR;
1831 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1832 {
1833 yyn = yytable[yyn];
1834 if (0 < yyn)
1835 break;
1836 }
1837 }
1838
1839 /* Pop the current state because it cannot handle the error token. */
1840 if (yyssp == yyss)
1841 YYABORT;
1842
1843
1844 yydestruct ("Error: popping",
1845 yystos[yystate], yyvsp);
1846 YYPOPSTACK (1);
1847 yystate = *yyssp;
1848 YY_STACK_PRINT (yyss, yyssp);
1849 }
1850
1851 *++yyvsp = yylval;
1852
1853
1854 /* Shift the error token. */
1855 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1856
1857 yystate = yyn;
1858 goto yynewstate;
1859
1860
1861/*-------------------------------------.
1862| yyacceptlab -- YYACCEPT comes here. |
1863`-------------------------------------*/
1864yyacceptlab:
1865 yyresult = 0;
1866 goto yyreturn;
1867
1868/*-----------------------------------.
1869| yyabortlab -- YYABORT comes here. |
1870`-----------------------------------*/
1871yyabortlab:
1872 yyresult = 1;
1873 goto yyreturn;
1874
1875#if !defined(yyoverflow) || YYERROR_VERBOSE
1876/*-------------------------------------------------.
1877| yyexhaustedlab -- memory exhaustion comes here. |
1878`-------------------------------------------------*/
1879yyexhaustedlab:
1880 yyerror (YY_("memory exhausted"));
1881 yyresult = 2;
1882 /* Fall through. */
1883#endif
1884
1885yyreturn:
1886 if (yychar != YYEMPTY)
1887 yydestruct ("Cleanup: discarding lookahead",
1888 yytoken, &yylval);
1889 /* Do not reclaim the symbols of the rule which action triggered
1890 this YYABORT or YYACCEPT. */
1891 YYPOPSTACK (yylen);
1892 YY_STACK_PRINT (yyss, yyssp);
1893 while (yyssp != yyss)
1894 {
1895 yydestruct ("Cleanup: popping",
1896 yystos[*yyssp], yyvsp);
1897 YYPOPSTACK (1);
1898 }
1899#ifndef yyoverflow
1900 if (yyss != yyssa)
1901 YYSTACK_FREE (yyss);
1902#endif
1903#if YYERROR_VERBOSE
1904 if (yymsg != yymsgbuf)
1905 YYSTACK_FREE (yymsg);
1906#endif
1907 /* Make sure YYID is used. */
1908 return YYID (yyresult);
1909}
1910
1911
1912
1913
1914
1915void print_error(char const *fmt, ...)
1916{
1917 va_list va;
1918
1919 va_start(va, fmt);
1920 srcpos_verror(&yylloc, fmt, va);
1921 va_end(va);
1922
1923 treesource_error = 1;
1924}
1925
1926void yyerror(char const *s) {
1927 print_error("%s", s);
1928}
1929
1930static unsigned long long eval_literal(const char *s, int base, int bits)
1931{
1932 unsigned long long val;
1933 char *e;
1934
1935 errno = 0;
1936 val = strtoull(s, &e, base);
1937 if (*e)
1938 print_error("bad characters in literal");
1939 else if ((errno == ERANGE)
1940 || ((bits < 64) && (val >= (1ULL << bits))))
1941 print_error("literal out of range");
1942 else if (errno != 0)
1943 print_error("bad literal");
1944 return val;
1945}
1946
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}