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

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