scripts/dtc/dtc-parser.tab.c_shipped

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