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 73extern int yylex(void); 74extern 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 81extern struct dt_info *parser_output; 82extern 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 111extern 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 147union 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 172typedef 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 179typedef struct YYLTYPE YYLTYPE; 180struct 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 192extern YYSTYPE yylval; 193extern YYLTYPE yylloc; 194int 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 207typedef YYTYPE_UINT8 yytype_uint8; 208#else 209typedef unsigned char yytype_uint8; 210#endif 211 212#ifdef YYTYPE_INT8 213typedef YYTYPE_INT8 yytype_int8; 214#else 215typedef signed char yytype_int8; 216#endif 217 218#ifdef YYTYPE_UINT16 219typedef YYTYPE_UINT16 yytype_uint16; 220#else 221typedef unsigned short int yytype_uint16; 222#endif 223 224#ifdef YYTYPE_INT16 225typedef YYTYPE_INT16 yytype_int16; 226#else 227typedef 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 366void *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 372void 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. */ 385union 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. */ 465static 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. */ 499static 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. */ 516static 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). */ 538static 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. */ 560static 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. */ 582static 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]. */ 602static 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]. */ 610static 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. */ 620static 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 638static 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. */ 658static 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. */ 678static 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. */ 692static 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) \ 719do \ 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 } \ 733while (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) \ 776do { \ 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 791YY_ATTRIBUTE_UNUSED 792static unsigned 793yy_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) \ 827do { \ 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 842static void 843yy_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 862static void 863yy_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 879static void 880yy_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) \ 892do { \ 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 902static void 903yy_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) \ 923do { \ 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. */ 930int 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. */ 963static YYSIZE_T 964yystrlen (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. */ 980static char * 981yystpcpy (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. */ 1002static YYSIZE_T 1003yytnamerr (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. */ 1050static int 1051yysyntax_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 1182static void 1183yydestruct (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. */ 1200int yychar; 1201 1202/* The semantic value of the lookahead symbol. */ 1203YYSTYPE yylval; 1204/* Location data for the lookahead symbol. */ 1205YYLTYPE 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. */ 1211int yynerrs; 1212 1213 1214/*----------. 1215| yyparse. | 1216`----------*/ 1217 1218int 1219yyparse (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`-----------*/ 1376yybackup: 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`-----------------------------------------------------------*/ 1442yydefault: 1443 yyn = yydefact[yystate]; 1444 if (yyn == 0) 1445 goto yyerrlab; 1446 goto yyreduce; 1447 1448 1449/*-----------------------------. 1450| yyreduce -- Do a reduction. | 1451`-----------------------------*/ 1452yyreduce: 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`--------------------------------------*/ 2121yyerrlab: 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`---------------------------------------------------*/ 2195yyerrorlab: 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`-------------------------------------------------------------*/ 2216yyerrlab1: 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`-------------------------------------*/ 2265yyacceptlab: 2266 yyresult = 0; 2267 goto yyreturn; 2268 2269/*-----------------------------------. 2270| yyabortlab -- YYABORT comes here. | 2271`-----------------------------------*/ 2272yyabortlab: 2273 yyresult = 1; 2274 goto yyreturn; 2275 2276#if !defined yyoverflow || YYERROR_VERBOSE 2277/*-------------------------------------------------. 2278| yyexhaustedlab -- memory exhaustion comes here. | 2279`-------------------------------------------------*/ 2280yyexhaustedlab: 2281 yyerror (YY_("memory exhausted")); 2282 yyresult = 2; 2283 /* Fall through. */ 2284#endif 2285 2286yyreturn: 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 2318void yyerror(char const *s) 2319{ 2320 ERROR(&yylloc, "%s", s); 2321} 2322