projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-3.5' of git://linux-nfs.org/~bfields/linux
[deliverable/linux.git] / scripts / dtc / dtc-parser.tab.c_shipped
CommitLineData
edfc86aa 1/* A Bison parser, made by GNU Bison 2.4.3. */
a4da2e3e 2
658f29a5
JB		 3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
edfc86aa
AL		 5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
658f29a5
JB		 7
8 This program is free software: you can redistribute it and/or modify
a4da2e3e 9 it under the terms of the GNU General Public License as published by
658f29a5
JB		 10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
a4da2e3e
DG		 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.
658f29a5 17
a4da2e3e 18 You should have received a copy of the GNU General Public License
658f29a5 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
a4da2e3e
DG		 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.
658f29a5 30
a4da2e3e
DG		 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. */
edfc86aa 48#define YYBISON_VERSION "2.4.3"
a4da2e3e
DG		 49
50/* Skeleton name. */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers. */
54#define YYPURE 0
55
658f29a5
JB		 56/* Push parsers. */
57#define YYPUSH 0
a4da2e3e 58
658f29a5
JB		 59/* Pull parsers. */
60#define YYPULL 1
a4da2e3e 61
658f29a5
JB		 62/* Using locations. */
63#define YYLSP_NEEDED 0
a4da2e3e
DG		 64
65
66
67/* Copy the first part of user declarations. */
658f29a5 68
a4da2e3e 69
ed95d745
DG		 70#include <stdio.h>
71
a4da2e3e
DG		 72#include "dtc.h"
73#include "srcpos.h"
74
658f29a5
JB		 75YYLTYPE yylloc;
76
ed95d745 77extern int yylex(void);
658f29a5
JB		 78extern void print_error(char const *fmt, ...);
79extern void yyerror(char const *s);
a4da2e3e
DG		 80
81extern struct boot_info *the_boot_info;
ed95d745 82extern int treesource_error;
a4da2e3e 83
ed95d745 84static unsigned long long eval_literal(const char *s, int base, int bits);
a4da2e3e
DG		 85
86
658f29a5 87
a4da2e3e
DG		 88/* Enabling traces. */
89#ifndef YYDEBUG
edfc86aa 90# define YYDEBUG 1
a4da2e3e
DG		 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
658f29a5
JB		 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
a4da2e3e
DG		 128#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
129typedef union YYSTYPE
a4da2e3e 130{
658f29a5 131
658f29a5 132
a4da2e3e
DG		 133 char *propnodename;
134 char *literal;
135 char *labelref;
136 unsigned int cbase;
ed95d745 137 uint8_t byte;
a4da2e3e
DG		 138 struct data data;
139
ed95d745 140 uint64_t addr;
a4da2e3e
DG		 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;
658f29a5
JB		 147
148
149
658f29a5
JB		 150} YYSTYPE;
151# define YYSTYPE_IS_TRIVIAL 1
a4da2e3e
DG		 152# define yystype YYSTYPE /* obsolescent; will be withdrawn */
153# define YYSTYPE_IS_DECLARED 1
a4da2e3e
DG		 154#endif
155
156
157/* Copy the second part of user declarations. */
158
159
a4da2e3e
DG		 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_
edfc86aa 209# if defined YYENABLE_NLS && YYENABLE_NLS
a4da2e3e
DG		 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
658f29a5 234YYID (int yyi)
a4da2e3e
DG		 235#else
236static int
658f29a5
JB		 237YYID (yyi)
238 int yyi;
a4da2e3e
DG		 239#endif
240{
658f29a5 241 return yyi;
a4da2e3e
DG		 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 \
658f29a5 317 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
a4da2e3e
DG		 318
319/* A type that is properly aligned for any stack member. */
320union yyalloc
321{
658f29a5
JB		 322 yytype_int16 yyss_alloc;
323 YYSTYPE yyvs_alloc;
a4da2e3e
DG		 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) \
658f29a5
JB		 332 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
333 + YYSTACK_GAP_MAXIMUM)
a4da2e3e
DG		 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. */
658f29a5 358# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
a4da2e3e
DG		 359 do \
360 { \
361 YYSIZE_T yynewbytes; \
658f29a5
JB		 362 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
363 Stack = &yyptr->Stack_alloc; \
a4da2e3e
DG		 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. */
658f29a5 372#define YYFINAL 4
a4da2e3e 373/* YYLAST -- Last index in YYTABLE. */
658f29a5 374#define YYLAST 56
a4da2e3e
DG		 375
376/* YYNTOKENS -- Number of terminals. */
658f29a5 377#define YYNTOKENS 25
a4da2e3e 378/* YYNNTS -- Number of nonterminals. */
658f29a5 379#define YYNNTS 16
a4da2e3e 380/* YYNRULES -- Number of rules. */
658f29a5 381#define YYNRULES 39
a4da2e3e 382/* YYNRULES -- Number of states. */
658f29a5 383#define YYNSTATES 67
a4da2e3e
DG		 384
385/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
386#define YYUNDEFTOK 2
658f29a5 387#define YYMAXUTOK 267
a4da2e3e
DG		 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,
658f29a5
JB		 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,
a4da2e3e
DG		 402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
403 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
658f29a5 404 2, 20, 2, 21, 2, 2, 2, 2, 2, 2,
a4da2e3e
DG		 405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
658f29a5 407 2, 2, 2, 15, 2, 16, 2, 2, 2, 2,
a4da2e3e
DG		 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,
658f29a5 421 5, 6, 7, 8, 9, 10, 11, 12
a4da2e3e
DG		 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{
658f29a5
JB		 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
a4da2e3e
DG		 433};
434
435/* YYRHS -- A `-1'-separated list of the rules' RHS. */
436static const yytype_int8 yyrhs[] =
437{
658f29a5
JB		 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
a4da2e3e
DG		 451};
452
453/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
454static const yytype_uint16 yyrline[] =
455{
658f29a5
JB		 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
a4da2e3e
DG		 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",
658f29a5
JB		 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
a4da2e3e
DG		 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,
658f29a5
JB		 484 265, 266, 267, 59, 47, 123, 125, 61, 60, 62,
485 91, 93, 40, 44, 41
a4da2e3e
DG		 486};
487# endif
488
489/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
490static const yytype_uint8 yyr1[] =
491{
658f29a5
JB		 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
a4da2e3e
DG		 496};
497
498/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
499static const yytype_uint8 yyr2[] =
500{
658f29a5
JB		 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
a4da2e3e
DG		 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{
658f29a5
JB		 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
a4da2e3e
DG		 519};
520
521/* YYDEFGOTO[NTERM-NUM]. */
522static const yytype_int8 yydefgoto[] =
523{
658f29a5
JB		 524 -1, 2, 7, 8, 10, 13, 17, 21, 26, 37,
525 38, 50, 57, 51, 27, 28
a4da2e3e
DG		 526};
527
528/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
529 STATE-NUM. */
658f29a5 530#define YYPACT_NINF -12
a4da2e3e
DG		 531static const yytype_int8 yypact[] =
532{
658f29a5
JB		 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
a4da2e3e
DG		 540};
541
542/* YYPGOTO[NTERM-NUM]. */
543static const yytype_int8 yypgoto[] =
544{
658f29a5
JB		 545 -12, -12, 36, 39, -10, -12, 8, -12, 12, -12,
546 -12, -12, -12, -12, 27, 31
a4da2e3e
DG		 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. */
658f29a5
JB		 553#define YYTABLE_NINF -1
554static const yytype_uint8 yytable[] =
a4da2e3e 555{
658f29a5
JB		 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
a4da2e3e
DG		 562};
563
564static const yytype_int8 yycheck[] =
565{
658f29a5
JB		 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
a4da2e3e
DG		 572};
573
574/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
575 symbol of state STATE-NUM. */
576static const yytype_uint8 yystos[] =
577{
658f29a5
JB		 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
a4da2e3e
DG		 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.
edfc86aa
AL		 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. */
a4da2e3e
DG		 603
604#define YYFAIL goto yyerrlab
edfc86aa
AL		 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
a4da2e3e
DG		 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
edfc86aa 667# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
a4da2e3e
DG		 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, \
658f29a5 706 Type, Value); \
a4da2e3e
DG		 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
658f29a5 720yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
a4da2e3e
DG		 721#else
722static void
658f29a5 723yy_symbol_value_print (yyoutput, yytype, yyvaluep)
a4da2e3e
DG		 724 FILE *yyoutput;
725 int yytype;
726 YYSTYPE const * const yyvaluep;
a4da2e3e
DG		 727#endif
728{
729 if (!yyvaluep)
730 return;
a4da2e3e
DG		 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
658f29a5 752yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
a4da2e3e
DG		 753#else
754static void
658f29a5 755yy_symbol_print (yyoutput, yytype, yyvaluep)
a4da2e3e
DG		 756 FILE *yyoutput;
757 int yytype;
758 YYSTYPE const * const yyvaluep;
a4da2e3e
DG		 759#endif
760{
761 if (yytype < YYNTOKENS)
762 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
763 else
764 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
765
658f29a5 766 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
a4da2e3e
DG		 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
658f29a5 778yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
a4da2e3e
DG		 779#else
780static void
658f29a5
JB		 781yy_stack_print (yybottom, yytop)
782 yytype_int16 *yybottom;
783 yytype_int16 *yytop;
a4da2e3e
DG		 784#endif
785{
786 YYFPRINTF (stderr, "Stack now");
658f29a5
JB		 787 for (; yybottom <= yytop; yybottom++)
788 {
789 int yybot = *yybottom;
790 YYFPRINTF (stderr, " %d", yybot);
791 }
a4da2e3e
DG		 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
658f29a5 809yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
a4da2e3e
DG		 810#else
811static void
658f29a5 812yy_reduce_print (yyvsp, yyrule)
a4da2e3e 813 YYSTYPE *yyvsp;
a4da2e3e
DG		 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 {
658f29a5 825 YYFPRINTF (stderr, " $%d = ", yyi + 1);
a4da2e3e
DG		 826 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
827 &(yyvsp[(yyi + 1) - (yynrhs)])
658f29a5
JB		 828 );
829 YYFPRINTF (stderr, "\n");
a4da2e3e
DG		 830 }
831}
832
833# define YY_REDUCE_PRINT(Rule) \
834do { \
835 if (yydebug) \
658f29a5 836 yy_reduce_print (yyvsp, Rule); \
a4da2e3e
DG		 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\f
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\f
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
658f29a5 1087yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
a4da2e3e
DG		 1088#else
1089static void
658f29a5 1090yydestruct (yymsg, yytype, yyvaluep)
a4da2e3e
DG		 1091 const char *yymsg;
1092 int yytype;
1093 YYSTYPE *yyvaluep;
a4da2e3e
DG		 1094#endif
1095{
1096 YYUSE (yyvaluep);
a4da2e3e
DG		 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}
a4da2e3e
DG		 1109
1110/* Prevent warnings from -Wmissing-prototypes. */
a4da2e3e
DG		 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
658f29a5 1126/* The lookahead symbol. */
a4da2e3e
DG		 1127int yychar;
1128
658f29a5 1129/* The semantic value of the lookahead symbol. */
a4da2e3e
DG		 1130YYSTYPE yylval;
1131
1132/* Number of syntax errors so far. */
1133int yynerrs;
a4da2e3e
DG		 1134
1135
1136
658f29a5
JB		 1137/*-------------------------.
1138| yyparse or yypush_parse. |
1139`-------------------------*/
a4da2e3e
DG		 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{
a4da2e3e 1163
a4da2e3e 1164
658f29a5
JB		 1165 int yystate;
1166 /* Number of tokens to shift before error messages enabled. */
1167 int yyerrstatus;
a4da2e3e 1168
658f29a5
JB		 1169 /* The stacks and their tools:
1170 `yyss': related to states.
1171 `yyvs': related to semantic values.
a4da2e3e 1172
658f29a5
JB		 1173 Refer to the stacks thru separate pointers, to allow yyoverflow
1174 to reallocate them elsewhere. */
a4da2e3e 1175
658f29a5
JB		 1176 /* The state stack. */
1177 yytype_int16 yyssa[YYINITDEPTH];
1178 yytype_int16 *yyss;
1179 yytype_int16 *yyssp;
a4da2e3e 1180
658f29a5
JB		 1181 /* The semantic value stack. */
1182 YYSTYPE yyvsa[YYINITDEPTH];
1183 YYSTYPE *yyvs;
1184 YYSTYPE *yyvsp;
a4da2e3e 1185
658f29a5 1186 YYSIZE_T yystacksize;
a4da2e3e 1187
658f29a5
JB		 1188 int yyn;
1189 int yyresult;
1190 /* Lookahead token as an internal (translated) token number. */
1191 int yytoken;
a4da2e3e
DG		 1192 /* The variables used to return semantic value and location from the
1193 action routines. */
1194 YYSTYPE yyval;
658f29a5
JB		 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))
a4da2e3e
DG		 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
658f29a5
JB		 1209 yytoken = 0;
1210 yyss = yyssa;
1211 yyvs = yyvsa;
1212 yystacksize = YYINITDEPTH;
1213
a4da2e3e
DG		 1214 YYDPRINTF ((stderr, "Starting parse\n"));
1215
1216 yystate = 0;
1217 yyerrstatus = 0;
1218 yynerrs = 0;
658f29a5 1219 yychar = YYEMPTY; /* Cause a token to be read. */
a4da2e3e
DG		 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. */
a4da2e3e
DG		 1225 yyssp = yyss;
1226 yyvsp = yyvs;
a4da2e3e
DG		 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;
a4da2e3e
DG		 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),
a4da2e3e 1261 &yystacksize);
658f29a5 1262
a4da2e3e
DG		 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;
658f29a5
JB		 1283 YYSTACK_RELOCATE (yyss_alloc, yyss);
1284 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
a4da2e3e
DG		 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;
a4da2e3e
DG		 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
658f29a5
JB		 1304 if (yystate == YYFINAL)
1305 YYACCEPT;
1306
a4da2e3e
DG		 1307 goto yybackup;
1308
1309/*-----------.
1310| yybackup. |
1311`-----------*/
1312yybackup:
1313
1314 /* Do appropriate processing given the current state. Read a
658f29a5 1315 lookahead token if we need one and don't already have one. */
a4da2e3e 1316
658f29a5 1317 /* First try to decide what to do without reference to lookahead token. */
a4da2e3e
DG		 1318 yyn = yypact[yystate];
1319 if (yyn == YYPACT_NINF)
1320 goto yydefault;
1321
658f29a5 1322 /* Not known => get a lookahead token if don't already have one. */
a4da2e3e 1323
658f29a5 1324 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
a4da2e3e
DG		 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
a4da2e3e
DG		 1356 /* Count tokens shifted since error; after three, turn off error
1357 status. */
1358 if (yyerrstatus)
1359 yyerrstatus--;
1360
658f29a5 1361 /* Shift the lookahead token. */
a4da2e3e
DG		 1362 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1363
658f29a5
JB		 1364 /* Discard the shifted token. */
1365 yychar = YYEMPTY;
a4da2e3e
DG		 1366
1367 yystate = yyn;
1368 *++yyvsp = yylval;
658f29a5 1369
a4da2e3e
DG		 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
658f29a5 1400
a4da2e3e
DG		 1401 YY_REDUCE_PRINT (yyn);
1402 switch (yyn)
1403 {
1404 case 2:
658f29a5 1405
a4da2e3e 1406 {
658f29a5
JB		 1407 the_boot_info = build_boot_info((yyvsp[(3) - (4)].re), (yyvsp[(4) - (4)].node),
1408 guess_boot_cpuid((yyvsp[(4) - (4)].node)));
a4da2e3e
DG		 1409 ;}
1410 break;
1411
1412 case 3:
658f29a5 1413
a4da2e3e 1414 {
658f29a5 1415 (yyval.re) = NULL;
a4da2e3e
DG		 1416 ;}
1417 break;
1418
1419 case 4:
658f29a5 1420
a4da2e3e 1421 {
658f29a5 1422 (yyval.re) = chain_reserve_entry((yyvsp[(1) - (2)].re), (yyvsp[(2) - (2)].re));
a4da2e3e
DG		 1423 ;}
1424 break;
1425
1426 case 5:
658f29a5 1427
a4da2e3e 1428 {
658f29a5 1429 (yyval.re) = build_reserve_entry((yyvsp[(2) - (4)].addr), (yyvsp[(3) - (4)].addr));
a4da2e3e
DG		 1430 ;}
1431 break;
1432
1433 case 6:
658f29a5 1434
a4da2e3e 1435 {
658f29a5
JB		 1436 add_label(&(yyvsp[(2) - (2)].re)->labels, (yyvsp[(1) - (2)].labelref));
1437 (yyval.re) = (yyvsp[(2) - (2)].re);
a4da2e3e
DG		 1438 ;}
1439 break;
1440
1441 case 7:
658f29a5 1442
a4da2e3e 1443 {
658f29a5 1444 (yyval.addr) = eval_literal((yyvsp[(1) - (1)].literal), 0, 64);
a4da2e3e
DG		 1445 ;}
1446 break;
1447
1448 case 8:
658f29a5 1449
a4da2e3e 1450 {
658f29a5 1451 (yyval.node) = name_node((yyvsp[(2) - (2)].node), "");
a4da2e3e
DG		 1452 ;}
1453 break;
1454
1455 case 9:
658f29a5 1456
a4da2e3e 1457 {
658f29a5 1458 (yyval.node) = merge_nodes((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
a4da2e3e
DG		 1459 ;}
1460 break;
1461
1462 case 10:
658f29a5 1463
a4da2e3e 1464 {
658f29a5
JB		 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);
a4da2e3e
DG		 1472 ;}
1473 break;
1474
1475 case 11:
658f29a5 1476
a4da2e3e 1477 {
658f29a5 1478 (yyval.node) = build_node((yyvsp[(2) - (5)].proplist), (yyvsp[(3) - (5)].nodelist));
a4da2e3e
DG		 1479 ;}
1480 break;
1481
1482 case 12:
658f29a5 1483
a4da2e3e 1484 {
658f29a5 1485 (yyval.proplist) = NULL;
a4da2e3e
DG		 1486 ;}
1487 break;
1488
1489 case 13:
658f29a5 1490
a4da2e3e 1491 {
658f29a5 1492 (yyval.proplist) = chain_property((yyvsp[(2) - (2)].prop), (yyvsp[(1) - (2)].proplist));
a4da2e3e
DG		 1493 ;}
1494 break;
1495
1496 case 14:
658f29a5 1497
a4da2e3e 1498 {
658f29a5 1499 (yyval.prop) = build_property((yyvsp[(1) - (4)].propnodename), (yyvsp[(3) - (4)].data));
a4da2e3e
DG		 1500 ;}
1501 break;
1502
1503 case 15:
658f29a5 1504
a4da2e3e 1505 {
658f29a5 1506 (yyval.prop) = build_property((yyvsp[(1) - (2)].propnodename), empty_data);
a4da2e3e
DG		 1507 ;}
1508 break;
1509
1510 case 16:
658f29a5 1511
a4da2e3e 1512 {
658f29a5
JB		 1513 add_label(&(yyvsp[(2) - (2)].prop)->labels, (yyvsp[(1) - (2)].labelref));
1514 (yyval.prop) = (yyvsp[(2) - (2)].prop);
a4da2e3e
DG		 1515 ;}
1516 break;
1517
1518 case 17:
658f29a5 1519
a4da2e3e 1520 {
658f29a5 1521 (yyval.data) = data_merge((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].data));
a4da2e3e
DG		 1522 ;}
1523 break;
1524
1525 case 18:
658f29a5 1526
a4da2e3e 1527 {
658f29a5 1528 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data));
a4da2e3e
DG		 1529 ;}
1530 break;
1531
1532 case 19:
658f29a5 1533
a4da2e3e 1534 {
658f29a5 1535 (yyval.data) = data_merge((yyvsp[(1) - (4)].data), (yyvsp[(3) - (4)].data));
a4da2e3e
DG		 1536 ;}
1537 break;
1538
1539 case 20:
658f29a5 1540
a4da2e3e 1541 {
658f29a5 1542 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), REF_PATH, (yyvsp[(2) - (2)].labelref));
a4da2e3e
DG		 1543 ;}
1544 break;
1545
1546 case 21:
a4da2e3e 1547
a4da2e3e 1548 {
658f29a5
JB		 1549 FILE *f = srcfile_relative_open((yyvsp[(4) - (9)].data).val, NULL);
1550 struct data d;
ed95d745
DG		 1551
1552 if ((yyvsp[(6) - (9)].addr) != 0)
658f29a5
JB		 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));
ed95d745 1558
658f29a5 1559 d = data_copy_file(f, (yyvsp[(8) - (9)].addr));
ed95d745
DG		 1560
1561 (yyval.data) = data_merge((yyvsp[(1) - (9)].data), d);
658f29a5 1562 fclose(f);
a4da2e3e
DG		 1563 ;}
1564 break;
1565
658f29a5
JB		 1566 case 22:
1567
a4da2e3e 1568 {
658f29a5 1569 FILE *f = srcfile_relative_open((yyvsp[(4) - (5)].data).val, NULL);
ed95d745
DG		 1570 struct data d = empty_data;
1571
658f29a5 1572 d = data_copy_file(f, -1);
ed95d745
DG		 1573
1574 (yyval.data) = data_merge((yyvsp[(1) - (5)].data), d);
658f29a5 1575 fclose(f);
a4da2e3e
DG		 1576 ;}
1577 break;
1578
658f29a5
JB		 1579 case 23:
1580
a4da2e3e 1581 {
ed95d745 1582 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
a4da2e3e
DG		 1583 ;}
1584 break;
1585
658f29a5
JB		 1586 case 24:
1587
a4da2e3e 1588 {
ed95d745 1589 (yyval.data) = empty_data;
a4da2e3e
DG		 1590 ;}
1591 break;
1592
658f29a5
JB		 1593 case 25:
1594
a4da2e3e 1595 {
ed95d745 1596 (yyval.data) = (yyvsp[(1) - (2)].data);
a4da2e3e
DG		 1597 ;}
1598 break;
1599
658f29a5
JB		 1600 case 26:
1601
a4da2e3e 1602 {
ed95d745 1603 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
a4da2e3e
DG		 1604 ;}
1605 break;
1606
658f29a5
JB		 1607 case 27:
1608
ed95d745
DG		 1609 {
1610 (yyval.data) = empty_data;
1611 ;}
1612 break;
1613
658f29a5
JB		 1614 case 28:
1615
ed95d745
DG		 1616 {
1617 (yyval.data) = data_append_cell((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].cell));
1618 ;}
1619 break;
1620
658f29a5
JB		 1621 case 29:
1622
a4da2e3e
DG		 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
658f29a5
JB		 1629 case 30:
1630
a4da2e3e
DG		 1631 {
1632 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1633 ;}
1634 break;
1635
658f29a5 1636 case 31:
a4da2e3e 1637
a4da2e3e
DG		 1638 {
1639 (yyval.cell) = eval_literal((yyvsp[(1) - (1)].literal), 0, 32);
1640 ;}
1641 break;
1642
658f29a5 1643 case 32:
a4da2e3e 1644
a4da2e3e
DG		 1645 {
1646 (yyval.data) = empty_data;
1647 ;}
1648 break;
1649
658f29a5
JB		 1650 case 33:
1651
a4da2e3e
DG		 1652 {
1653 (yyval.data) = data_append_byte((yyvsp[(1) - (2)].data), (yyvsp[(2) - (2)].byte));
1654 ;}
1655 break;
1656
658f29a5
JB		 1657 case 34:
1658
a4da2e3e
DG		 1659 {
1660 (yyval.data) = data_add_marker((yyvsp[(1) - (2)].data), LABEL, (yyvsp[(2) - (2)].labelref));
1661 ;}
1662 break;
1663
658f29a5
JB		 1664 case 35:
1665
a4da2e3e
DG		 1666 {
1667 (yyval.nodelist) = NULL;
1668 ;}
1669 break;
1670
658f29a5
JB		 1671 case 36:
1672
a4da2e3e
DG		 1673 {
1674 (yyval.nodelist) = chain_node((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].nodelist));
1675 ;}
1676 break;
1677
658f29a5
JB		 1678 case 37:
1679
a4da2e3e 1680 {
658f29a5 1681 print_error("syntax error: properties must precede subnodes");
a4da2e3e
DG		 1682 YYERROR;
1683 ;}
1684 break;
1685
658f29a5 1686 case 38:
a4da2e3e 1687
a4da2e3e 1688 {
658f29a5 1689 (yyval.node) = name_node((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].propnodename));
a4da2e3e
DG		 1690 ;}
1691 break;
1692
658f29a5
JB		 1693 case 39:
1694
a4da2e3e 1695 {
658f29a5
JB		 1696 add_label(&(yyvsp[(2) - (2)].node)->labels, (yyvsp[(1) - (2)].labelref));
1697 (yyval.node) = (yyvsp[(2) - (2)].node);
a4da2e3e
DG		 1698 ;}
1699 break;
1700
1701
658f29a5 1702
a4da2e3e
DG		 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;
a4da2e3e
DG		 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
658f29a5 1773
a4da2e3e
DG		 1774
1775 if (yyerrstatus == 3)
1776 {
658f29a5 1777 /* If just tried and failed to reuse lookahead token after an
a4da2e3e
DG		 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",
658f29a5 1789 yytoken, &yylval);
a4da2e3e
DG		 1790 yychar = YYEMPTY;
1791 }
1792 }
1793
658f29a5 1794 /* Else will try to reuse lookahead token after shifting the error
a4da2e3e
DG		 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
a4da2e3e
DG		 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
658f29a5 1843
a4da2e3e 1844 yydestruct ("Error: popping",
658f29a5 1845 yystos[yystate], yyvsp);
a4da2e3e
DG		 1846 YYPOPSTACK (1);
1847 yystate = *yyssp;
1848 YY_STACK_PRINT (yyss, yyssp);
1849 }
1850
a4da2e3e
DG		 1851 *++yyvsp = yylval;
1852
a4da2e3e
DG		 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
658f29a5 1875#if !defined(yyoverflow) || YYERROR_VERBOSE
a4da2e3e
DG		 1876/*-------------------------------------------------.
1877| yyexhaustedlab -- memory exhaustion comes here. |
1878`-------------------------------------------------*/
1879yyexhaustedlab:
1880 yyerror (YY_("memory exhausted"));
1881 yyresult = 2;
1882 /* Fall through. */
1883#endif
1884
1885yyreturn:
658f29a5 1886 if (yychar != YYEMPTY)
a4da2e3e 1887 yydestruct ("Cleanup: discarding lookahead",
658f29a5 1888 yytoken, &yylval);
a4da2e3e
DG		 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",
658f29a5 1896 yystos[*yyssp], yyvsp);
a4da2e3e
DG		 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
658f29a5 1912
a4da2e3e
DG		 1913
1914
658f29a5 1915void print_error(char const *fmt, ...)
a4da2e3e 1916{
ed95d745 1917 va_list va;
a4da2e3e 1918
658f29a5
JB		 1919 va_start(va, fmt);
1920 srcpos_verror(&yylloc, fmt, va);
1921 va_end(va);
ed95d745
DG		 1922
1923 treesource_error = 1;
ed95d745
DG		 1924}
1925
658f29a5
JB		 1926void yyerror(char const *s) {
1927 print_error("%s", s);
a4da2e3e
DG		 1928}
1929
ed95d745 1930static unsigned long long eval_literal(const char *s, int base, int bits)
a4da2e3e
DG		 1931{
1932 unsigned long long val;
1933 char *e;
1934
1935 errno = 0;
1936 val = strtoull(s, &e, base);
1937 if (*e)
658f29a5 1938 print_error("bad characters in literal");
a4da2e3e
DG		 1939 else if ((errno == ERANGE)
1940 || ((bits < 64) && (val >= (1ULL << bits))))
658f29a5 1941 print_error("literal out of range");
a4da2e3e 1942 else if (errno != 0)
658f29a5 1943 print_error("bad literal");
a4da2e3e
DG		 1944 return val;
1945}
1946
Linux kernel - Deliverables
This page took 0.467941 seconds and 5 git commands to generate.