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