git.sur5r.net Git - u-boot/blob - scripts/dtc/dtc-parser.tab.c_shipped

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