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 84 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, 191, 206, 214, 217, 224, 503 228, 232, 236, 244, 248, 252, 256, 260, 276, 286, 504 294, 297, 301, 308, 324, 329, 348, 362, 369, 370, 505 371, 378, 382, 383, 387, 388, 392, 393, 397, 398, 506 402, 403, 407, 408, 412, 413, 414, 418, 419, 420, 507 421, 422, 426, 427, 428, 432, 433, 434, 438, 439, 508 448, 457, 461, 462, 463, 464, 469, 472, 476, 484, 509 487, 491, 499, 503, 507 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 0, 7, 0, 38, 39, 0, 0, 10, 0, 2, 586 8, 4, 0, 0, 0, 72, 0, 41, 42, 44, 587 46, 48, 50, 52, 54, 57, 64, 67, 71, 0, 588 17, 11, 0, 0, 0, 0, 73, 74, 75, 40, 589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 590 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 591 79, 0, 0, 14, 12, 45, 0, 47, 49, 51, 592 53, 55, 56, 60, 61, 59, 58, 62, 63, 65, 593 66, 69, 68, 70, 0, 0, 0, 0, 18, 0, 594 79, 15, 13, 0, 0, 0, 20, 30, 82, 22, 595 84, 0, 81, 80, 43, 21, 83, 0, 0, 16, 596 29, 19, 31, 0, 23, 32, 26, 0, 76, 34, 597 0, 0, 0, 0, 37, 36, 24, 35, 33, 0, 598 77, 78, 25, 0, 28, 0, 0, 0, 27 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, 55, 56, 56, 57, 682 57, 57, 57, 58, 58, 58, 58, 58, 58, 58, 683 59, 59, 59, 60, 60, 60, 60, 60, 61, 61, 684 61, 62, 63, 63, 64, 64, 65, 65, 66, 66, 685 67, 67, 68, 68, 69, 69, 69, 70, 70, 70, 686 70, 70, 71, 71, 71, 72, 72, 72, 73, 73, 687 73, 73, 74, 74, 74, 74, 75, 75, 75, 76, 688 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, 5, 0, 2, 4, 696 2, 3, 2, 2, 3, 4, 2, 9, 5, 2, 697 0, 2, 2, 3, 1, 2, 2, 2, 1, 1, 698 3, 1, 1, 5, 1, 3, 1, 3, 1, 3, 699 1, 3, 1, 3, 1, 3, 3, 1, 3, 3, 700 3, 3, 3, 3, 1, 3, 3, 1, 3, 3, 701 3, 1, 1, 2, 2, 2, 0, 2, 2, 0, 702 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 ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref)); 1579 (yyval.node) = (yyvsp[-2].node); 1580 } 1581#line 1582 "dtc-parser.tab.c" /* yacc.c:1646 */ 1582 break; 1583 1584 case 15: 1585#line 192 "dtc-parser.y" /* yacc.c:1646 */ 1586 { 1587 struct node *target = get_node_by_ref((yyvsp[-3].node), (yyvsp[-1].labelref)); 1588 1589 if (target) 1590 delete_node(target); 1591 else 1592 ERROR(&(yylsp[-1]), "Label or path %s not found", (yyvsp[-1].labelref)); 1593 1594 1595 (yyval.node) = (yyvsp[-3].node); 1596 } 1597#line 1598 "dtc-parser.tab.c" /* yacc.c:1646 */ 1598 break; 1599 1600 case 16: 1601#line 207 "dtc-parser.y" /* yacc.c:1646 */ 1602 { 1603 (yyval.node) = build_node((yyvsp[-3].proplist), (yyvsp[-2].nodelist)); 1604 } 1605#line 1606 "dtc-parser.tab.c" /* yacc.c:1646 */ 1606 break; 1607 1608 case 17: 1609#line 214 "dtc-parser.y" /* yacc.c:1646 */ 1610 { 1611 (yyval.proplist) = NULL; 1612 } 1613#line 1614 "dtc-parser.tab.c" /* yacc.c:1646 */ 1614 break; 1615 1616 case 18: 1617#line 218 "dtc-parser.y" /* yacc.c:1646 */ 1618 { 1619 (yyval.proplist) = chain_property((yyvsp[0].prop), (yyvsp[-1].proplist)); 1620 } 1621#line 1622 "dtc-parser.tab.c" /* yacc.c:1646 */ 1622 break; 1623 1624 case 19: 1625#line 225 "dtc-parser.y" /* yacc.c:1646 */ 1626 { 1627 (yyval.prop) = build_property((yyvsp[-3].propnodename), (yyvsp[-1].data)); 1628 } 1629#line 1630 "dtc-parser.tab.c" /* yacc.c:1646 */ 1630 break; 1631 1632 case 20: 1633#line 229 "dtc-parser.y" /* yacc.c:1646 */ 1634 { 1635 (yyval.prop) = build_property((yyvsp[-1].propnodename), empty_data); 1636 } 1637#line 1638 "dtc-parser.tab.c" /* yacc.c:1646 */ 1638 break; 1639 1640 case 21: 1641#line 233 "dtc-parser.y" /* yacc.c:1646 */ 1642 { 1643 (yyval.prop) = build_property_delete((yyvsp[-1].propnodename)); 1644 } 1645#line 1646 "dtc-parser.tab.c" /* yacc.c:1646 */ 1646 break; 1647 1648 case 22: 1649#line 237 "dtc-parser.y" /* yacc.c:1646 */ 1650 { 1651 add_label(&(yyvsp[0].prop)->labels, (yyvsp[-1].labelref)); 1652 (yyval.prop) = (yyvsp[0].prop); 1653 } 1654#line 1655 "dtc-parser.tab.c" /* yacc.c:1646 */ 1655 break; 1656 1657 case 23: 1658#line 245 "dtc-parser.y" /* yacc.c:1646 */ 1659 { 1660 (yyval.data) = data_merge((yyvsp[-1].data), (yyvsp[0].data)); 1661 } 1662#line 1663 "dtc-parser.tab.c" /* yacc.c:1646 */ 1663 break; 1664 1665 case 24: 1666#line 249 "dtc-parser.y" /* yacc.c:1646 */ 1667 { 1668 (yyval.data) = data_merge((yyvsp[-2].data), (yyvsp[-1].array).data); 1669 } 1670#line 1671 "dtc-parser.tab.c" /* yacc.c:1646 */ 1671 break; 1672 1673 case 25: 1674#line 253 "dtc-parser.y" /* yacc.c:1646 */ 1675 { 1676 (yyval.data) = data_merge((yyvsp[-3].data), (yyvsp[-1].data)); 1677 } 1678#line 1679 "dtc-parser.tab.c" /* yacc.c:1646 */ 1679 break; 1680 1681 case 26: 1682#line 257 "dtc-parser.y" /* yacc.c:1646 */ 1683 { 1684 (yyval.data) = data_add_marker((yyvsp[-1].data), REF_PATH, (yyvsp[0].labelref)); 1685 } 1686#line 1687 "dtc-parser.tab.c" /* yacc.c:1646 */ 1687 break; 1688 1689 case 27: 1690#line 261 "dtc-parser.y" /* yacc.c:1646 */ 1691 { 1692 FILE *f = srcfile_relative_open((yyvsp[-5].data).val, NULL); 1693 struct data d; 1694 1695 if ((yyvsp[-3].integer) != 0) 1696 if (fseek(f, (yyvsp[-3].integer), SEEK_SET) != 0) 1697 die("Couldn't seek to offset %llu in \"%s\": %s", 1698 (unsigned long long)(yyvsp[-3].integer), (yyvsp[-5].data).val, 1699 strerror(errno)); 1700 1701 d = data_copy_file(f, (yyvsp[-1].integer)); 1702 1703 (yyval.data) = data_merge((yyvsp[-8].data), d); 1704 fclose(f); 1705 } 1706#line 1707 "dtc-parser.tab.c" /* yacc.c:1646 */ 1707 break; 1708 1709 case 28: 1710#line 277 "dtc-parser.y" /* yacc.c:1646 */ 1711 { 1712 FILE *f = srcfile_relative_open((yyvsp[-1].data).val, NULL); 1713 struct data d = empty_data; 1714 1715 d = data_copy_file(f, -1); 1716 1717 (yyval.data) = data_merge((yyvsp[-4].data), d); 1718 fclose(f); 1719 } 1720#line 1721 "dtc-parser.tab.c" /* yacc.c:1646 */ 1721 break; 1722 1723 case 29: 1724#line 287 "dtc-parser.y" /* yacc.c:1646 */ 1725 { 1726 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref)); 1727 } 1728#line 1729 "dtc-parser.tab.c" /* yacc.c:1646 */ 1729 break; 1730 1731 case 30: 1732#line 294 "dtc-parser.y" /* yacc.c:1646 */ 1733 { 1734 (yyval.data) = empty_data; 1735 } 1736#line 1737 "dtc-parser.tab.c" /* yacc.c:1646 */ 1737 break; 1738 1739 case 31: 1740#line 298 "dtc-parser.y" /* yacc.c:1646 */ 1741 { 1742 (yyval.data) = (yyvsp[-1].data); 1743 } 1744#line 1745 "dtc-parser.tab.c" /* yacc.c:1646 */ 1745 break; 1746 1747 case 32: 1748#line 302 "dtc-parser.y" /* yacc.c:1646 */ 1749 { 1750 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref)); 1751 } 1752#line 1753 "dtc-parser.tab.c" /* yacc.c:1646 */ 1753 break; 1754 1755 case 33: 1756#line 309 "dtc-parser.y" /* yacc.c:1646 */ 1757 { 1758 unsigned long long bits; 1759 1760 bits = (yyvsp[-1].integer); 1761 1762 if ((bits != 8) && (bits != 16) && 1763 (bits != 32) && (bits != 64)) { 1764 ERROR(&(yylsp[-1]), "Array elements must be" 1765 " 8, 16, 32 or 64-bits"); 1766 bits = 32; 1767 } 1768 1769 (yyval.array).data = empty_data; 1770 (yyval.array).bits = bits; 1771 } 1772#line 1773 "dtc-parser.tab.c" /* yacc.c:1646 */ 1773 break; 1774 1775 case 34: 1776#line 325 "dtc-parser.y" /* yacc.c:1646 */ 1777 { 1778 (yyval.array).data = empty_data; 1779 (yyval.array).bits = 32; 1780 } 1781#line 1782 "dtc-parser.tab.c" /* yacc.c:1646 */ 1782 break; 1783 1784 case 35: 1785#line 330 "dtc-parser.y" /* yacc.c:1646 */ 1786 { 1787 if ((yyvsp[-1].array).bits < 64) { 1788 uint64_t mask = (1ULL << (yyvsp[-1].array).bits) - 1; 1789 /* 1790 * Bits above mask must either be all zero 1791 * (positive within range of mask) or all one 1792 * (negative and sign-extended). The second 1793 * condition is true if when we set all bits 1794 * within the mask to one (i.e. | in the 1795 * mask), all bits are one. 1796 */ 1797 if (((yyvsp[0].integer) > mask) && (((yyvsp[0].integer) | mask) != -1ULL)) 1798 ERROR(&(yylsp[0]), "Value out of range for" 1799 " %d-bit array element", (yyvsp[-1].array).bits); 1800 } 1801 1802 (yyval.array).data = data_append_integer((yyvsp[-1].array).data, (yyvsp[0].integer), (yyvsp[-1].array).bits); 1803 } 1804#line 1805 "dtc-parser.tab.c" /* yacc.c:1646 */ 1805 break; 1806 1807 case 36: 1808#line 349 "dtc-parser.y" /* yacc.c:1646 */ 1809 { 1810 uint64_t val = ~0ULL >> (64 - (yyvsp[-1].array).bits); 1811 1812 if ((yyvsp[-1].array).bits == 32) 1813 (yyvsp[-1].array).data = data_add_marker((yyvsp[-1].array).data, 1814 REF_PHANDLE, 1815 (yyvsp[0].labelref)); 1816 else 1817 ERROR(&(yylsp[0]), "References are only allowed in " 1818 "arrays with 32-bit elements."); 1819 1820 (yyval.array).data = data_append_integer((yyvsp[-1].array).data, val, (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 (yyval.array).data = data_add_marker((yyvsp[-1].array).data, LABEL, (yyvsp[0].labelref)); 1829 } 1830#line 1831 "dtc-parser.tab.c" /* yacc.c:1646 */ 1831 break; 1832 1833 case 40: 1834#line 372 "dtc-parser.y" /* yacc.c:1646 */ 1835 { 1836 (yyval.integer) = (yyvsp[-1].integer); 1837 } 1838#line 1839 "dtc-parser.tab.c" /* yacc.c:1646 */ 1839 break; 1840 1841 case 43: 1842#line 383 "dtc-parser.y" /* yacc.c:1646 */ 1843 { (yyval.integer) = (yyvsp[-4].integer) ? (yyvsp[-2].integer) : (yyvsp[0].integer); } 1844#line 1845 "dtc-parser.tab.c" /* yacc.c:1646 */ 1845 break; 1846 1847 case 45: 1848#line 388 "dtc-parser.y" /* yacc.c:1646 */ 1849 { (yyval.integer) = (yyvsp[-2].integer) || (yyvsp[0].integer); } 1850#line 1851 "dtc-parser.tab.c" /* yacc.c:1646 */ 1851 break; 1852 1853 case 47: 1854#line 393 "dtc-parser.y" /* yacc.c:1646 */ 1855 { (yyval.integer) = (yyvsp[-2].integer) && (yyvsp[0].integer); } 1856#line 1857 "dtc-parser.tab.c" /* yacc.c:1646 */ 1857 break; 1858 1859 case 49: 1860#line 398 "dtc-parser.y" /* yacc.c:1646 */ 1861 { (yyval.integer) = (yyvsp[-2].integer) | (yyvsp[0].integer); } 1862#line 1863 "dtc-parser.tab.c" /* yacc.c:1646 */ 1863 break; 1864 1865 case 51: 1866#line 403 "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 53: 1872#line 408 "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 55: 1878#line 413 "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 56: 1884#line 414 "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 58: 1890#line 419 "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 59: 1896#line 420 "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 60: 1902#line 421 "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 61: 1908#line 422 "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 62: 1914#line 426 "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 63: 1920#line 427 "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 65: 1926#line 432 "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 66: 1932#line 433 "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 68: 1938#line 438 "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 69: 1944#line 440 "dtc-parser.y" /* yacc.c:1646 */ 1945 { 1946 if ((yyvsp[0].integer) != 0) { 1947 (yyval.integer) = (yyvsp[-2].integer) / (yyvsp[0].integer); 1948 } else { 1949 ERROR(&(yyloc), "Division by zero"); 1950 (yyval.integer) = 0; 1951 } 1952 } 1953#line 1954 "dtc-parser.tab.c" /* yacc.c:1646 */ 1954 break; 1955 1956 case 70: 1957#line 449 "dtc-parser.y" /* yacc.c:1646 */ 1958 { 1959 if ((yyvsp[0].integer) != 0) { 1960 (yyval.integer) = (yyvsp[-2].integer) % (yyvsp[0].integer); 1961 } else { 1962 ERROR(&(yyloc), "Division by zero"); 1963 (yyval.integer) = 0; 1964 } 1965 } 1966#line 1967 "dtc-parser.tab.c" /* yacc.c:1646 */ 1967 break; 1968 1969 case 73: 1970#line 462 "dtc-parser.y" /* yacc.c:1646 */ 1971 { (yyval.integer) = -(yyvsp[0].integer); } 1972#line 1973 "dtc-parser.tab.c" /* yacc.c:1646 */ 1973 break; 1974 1975 case 74: 1976#line 463 "dtc-parser.y" /* yacc.c:1646 */ 1977 { (yyval.integer) = ~(yyvsp[0].integer); } 1978#line 1979 "dtc-parser.tab.c" /* yacc.c:1646 */ 1979 break; 1980 1981 case 75: 1982#line 464 "dtc-parser.y" /* yacc.c:1646 */ 1983 { (yyval.integer) = !(yyvsp[0].integer); } 1984#line 1985 "dtc-parser.tab.c" /* yacc.c:1646 */ 1985 break; 1986 1987 case 76: 1988#line 469 "dtc-parser.y" /* yacc.c:1646 */ 1989 { 1990 (yyval.data) = empty_data; 1991 } 1992#line 1993 "dtc-parser.tab.c" /* yacc.c:1646 */ 1993 break; 1994 1995 case 77: 1996#line 473 "dtc-parser.y" /* yacc.c:1646 */ 1997 { 1998 (yyval.data) = data_append_byte((yyvsp[-1].data), (yyvsp[0].byte)); 1999 } 2000#line 2001 "dtc-parser.tab.c" /* yacc.c:1646 */
2001 break; 2002 2003 case 78: 2004#line 477 "dtc-parser.y" /* yacc.c:1646 */ 2005 { 2006 (yyval.data) = data_add_marker((yyvsp[-1].data), LABEL, (yyvsp[0].labelref)); 2007 } 2008#line 2009 "dtc-parser.tab.c" /* yacc.c:1646 */ 2009 break; 2010 2011 case 79: 2012#line 484 "dtc-parser.y" /* yacc.c:1646 */ 2013 { 2014 (yyval.nodelist) = NULL; 2015 } 2016#line 2017 "dtc-parser.tab.c" /* yacc.c:1646 */ 2017 break; 2018 2019 case 80: 2020#line 488 "dtc-parser.y" /* yacc.c:1646 */ 2021 { 2022 (yyval.nodelist) = chain_node((yyvsp[-1].node), (yyvsp[0].nodelist)); 2023 } 2024#line 2025 "dtc-parser.tab.c" /* yacc.c:1646 */ 2025 break; 2026 2027 case 81: 2028#line 492 "dtc-parser.y" /* yacc.c:1646 */ 2029 { 2030 ERROR(&(yylsp[0]), "Properties must precede subnodes"); 2031 YYERROR; 2032 } 2033#line 2034 "dtc-parser.tab.c" /* yacc.c:1646 */ 2034 break; 2035 2036 case 82: 2037#line 500 "dtc-parser.y" /* yacc.c:1646 */ 2038 { 2039 (yyval.node) = name_node((yyvsp[0].node), (yyvsp[-1].propnodename)); 2040 } 2041#line 2042 "dtc-parser.tab.c" /* yacc.c:1646 */ 2042 break; 2043 2044 case 83: 2045#line 504 "dtc-parser.y" /* yacc.c:1646 */ 2046 { 2047 (yyval.node) = name_node(build_node_delete(), (yyvsp[-1].propnodename)); 2048 } 2049#line 2050 "dtc-parser.tab.c" /* yacc.c:1646 */ 2050 break; 2051 2052 case 84: 2053#line 508 "dtc-parser.y" /* yacc.c:1646 */ 2054 { 2055 add_label(&(yyvsp[0].node)->labels, (yyvsp[-1].labelref)); 2056 (yyval.node) = (yyvsp[0].node); 2057 } 2058#line 2059 "dtc-parser.tab.c" /* yacc.c:1646 */ 2059 break; 2060 2061 2062#line 2063 "dtc-parser.tab.c" /* yacc.c:1646 */ 2063 default: break; 2064 } 2065 /* User semantic actions sometimes alter yychar, and that requires 2066 that yytoken be updated with the new translation. We take the 2067 approach of translating immediately before every use of yytoken. 2068 One alternative is translating here after every semantic action, 2069 but that translation would be missed if the semantic action invokes 2070 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2071 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2072 incorrect destructor might then be invoked immediately. In the 2073 case of YYERROR or YYBACKUP, subsequent parser actions might lead 2074 to an incorrect destructor call or verbose syntax error message 2075 before the lookahead is translated. */ 2076 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2077 2078 YYPOPSTACK (yylen); 2079 yylen = 0; 2080 YY_STACK_PRINT (yyss, yyssp); 2081 2082 *++yyvsp = yyval; 2083 *++yylsp = yyloc; 2084 2085 /* Now 'shift' the result of the reduction. Determine what state 2086 that goes to, based on the state we popped back to and the rule 2087 number reduced by. */ 2088 2089 yyn = yyr1[yyn]; 2090 2091 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2092 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2093 yystate = yytable[yystate]; 2094 else 2095 yystate = yydefgoto[yyn - YYNTOKENS]; 2096 2097 goto yynewstate; 2098 2099 2100/*--------------------------------------. 2101| yyerrlab -- here on detecting error. | 2102`--------------------------------------*/ 2103yyerrlab: 2104 /* Make sure we have latest lookahead translation. See comments at 2105 user semantic actions for why this is necessary. */ 2106 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 2107 2108 /* If not already recovering from an error, report this error. */ 2109 if (!yyerrstatus) 2110 { 2111 ++yynerrs; 2112#if ! YYERROR_VERBOSE 2113 yyerror (YY_("syntax error")); 2114#else 2115# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2116 yyssp, yytoken) 2117 { 2118 char const *yymsgp = YY_("syntax error"); 2119 int yysyntax_error_status; 2120 yysyntax_error_status = YYSYNTAX_ERROR; 2121 if (yysyntax_error_status == 0) 2122 yymsgp = yymsg; 2123 else if (yysyntax_error_status == 1) 2124 { 2125 if (yymsg != yymsgbuf) 2126 YYSTACK_FREE (yymsg); 2127 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 2128 if (!yymsg) 2129 { 2130 yymsg = yymsgbuf; 2131 yymsg_alloc = sizeof yymsgbuf; 2132 yysyntax_error_status = 2; 2133 } 2134 else 2135 { 2136 yysyntax_error_status = YYSYNTAX_ERROR; 2137 yymsgp = yymsg; 2138 } 2139 } 2140 yyerror (yymsgp); 2141 if (yysyntax_error_status == 2) 2142 goto yyexhaustedlab; 2143 } 2144# undef YYSYNTAX_ERROR 2145#endif 2146 } 2147 2148 yyerror_range[1] = yylloc; 2149 2150 if (yyerrstatus == 3) 2151 { 2152 /* If just tried and failed to reuse lookahead token after an 2153 error, discard it. */ 2154 2155 if (yychar <= YYEOF) 2156 { 2157 /* Return failure if at end of input. */ 2158 if (yychar == YYEOF) 2159 YYABORT; 2160 } 2161 else 2162 { 2163 yydestruct ("Error: discarding", 2164 yytoken, &yylval, &yylloc); 2165 yychar = YYEMPTY; 2166 } 2167 } 2168 2169 /* Else will try to reuse lookahead token after shifting the error 2170 token. */ 2171 goto yyerrlab1; 2172 2173 2174/*---------------------------------------------------. 2175| yyerrorlab -- error raised explicitly by YYERROR. | 2176`---------------------------------------------------*/ 2177yyerrorlab: 2178 2179 /* Pacify compilers like GCC when the user code never invokes 2180 YYERROR and the label yyerrorlab therefore never appears in user 2181 code. */ 2182 if (/*CONSTCOND*/ 0) 2183 goto yyerrorlab; 2184 2185 yyerror_range[1] = yylsp[1-yylen]; 2186 /* Do not reclaim the symbols of the rule whose action triggered 2187 this YYERROR. */ 2188 YYPOPSTACK (yylen); 2189 yylen = 0; 2190 YY_STACK_PRINT (yyss, yyssp); 2191 yystate = *yyssp; 2192 goto yyerrlab1; 2193 2194 2195/*-------------------------------------------------------------. 2196| yyerrlab1 -- common code for both syntax error and YYERROR. | 2197`-------------------------------------------------------------*/ 2198yyerrlab1: 2199 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2200 2201 for (;;) 2202 { 2203 yyn = yypact[yystate]; 2204 if (!yypact_value_is_default (yyn)) 2205 { 2206 yyn += YYTERROR; 2207 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2208 { 2209 yyn = yytable[yyn]; 2210 if (0 < yyn) 2211 break; 2212 } 2213 } 2214 2215 /* Pop the current state because it cannot handle the error token. */ 2216 if (yyssp == yyss) 2217 YYABORT; 2218 2219 yyerror_range[1] = *yylsp; 2220 yydestruct ("Error: popping", 2221 yystos[yystate], yyvsp, yylsp); 2222 YYPOPSTACK (1); 2223 yystate = *yyssp; 2224 YY_STACK_PRINT (yyss, yyssp); 2225 } 2226 2227 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2228 *++yyvsp = yylval; 2229 YY_IGNORE_MAYBE_UNINITIALIZED_END 2230 2231 yyerror_range[2] = yylloc; 2232 /* Using YYLLOC is tempting, but would change the location of 2233 the lookahead. YYLOC is available though. */ 2234 YYLLOC_DEFAULT (yyloc, yyerror_range, 2); 2235 *++yylsp = yyloc; 2236 2237 /* Shift the error token. */ 2238 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2239 2240 yystate = yyn; 2241 goto yynewstate; 2242 2243 2244/*-------------------------------------. 2245| yyacceptlab -- YYACCEPT comes here. | 2246`-------------------------------------*/ 2247yyacceptlab: 2248 yyresult = 0; 2249 goto yyreturn; 2250 2251/*-----------------------------------. 2252| yyabortlab -- YYABORT comes here. | 2253`-----------------------------------*/ 2254yyabortlab: 2255 yyresult = 1; 2256 goto yyreturn; 2257 2258#if !defined yyoverflow || YYERROR_VERBOSE 2259/*-------------------------------------------------. 2260| yyexhaustedlab -- memory exhaustion comes here. | 2261`-------------------------------------------------*/ 2262yyexhaustedlab: 2263 yyerror (YY_("memory exhausted")); 2264 yyresult = 2; 2265 /* Fall through. */ 2266#endif 2267 2268yyreturn: 2269 if (yychar != YYEMPTY) 2270 { 2271 /* Make sure we have latest lookahead translation. See comments at 2272 user semantic actions for why this is necessary. */ 2273 yytoken = YYTRANSLATE (yychar); 2274 yydestruct ("Cleanup: discarding lookahead", 2275 yytoken, &yylval, &yylloc); 2276 } 2277 /* Do not reclaim the symbols of the rule whose action triggered 2278 this YYABORT or YYACCEPT. */ 2279 YYPOPSTACK (yylen); 2280 YY_STACK_PRINT (yyss, yyssp); 2281 while (yyssp != yyss) 2282 { 2283 yydestruct ("Cleanup: popping", 2284 yystos[*yyssp], yyvsp, yylsp); 2285 YYPOPSTACK (1); 2286 } 2287#ifndef yyoverflow 2288 if (yyss != yyssa) 2289 YYSTACK_FREE (yyss); 2290#endif 2291#if YYERROR_VERBOSE 2292 if (yymsg != yymsgbuf) 2293 YYSTACK_FREE (yymsg); 2294#endif 2295 return yyresult; 2296} 2297#line 514 "dtc-parser.y" /* yacc.c:1906 */ 2298 2299 2300void yyerror(char const *s) 2301{ 2302 ERROR(&yylloc, "%s", s); 2303} 2304