linux/scripts/dtc/dtc-parser.tab.c_shipped
<<
>>
Prefs
   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