Root/scripts/dtc/dtc-parser.tab.c_shipped

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

Archive Download this file



interactive