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