sconfig.tab.c_shipped
1 /* A Bison parser, made by GNU Bison 3.8.2. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 Inc. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 20 21 /* As a special exception, you may create a larger work that contains 22 part or all of the Bison parser skeleton and distribute that work 23 under terms of your choice, so long as that work isn't itself a 24 parser generator using the skeleton or a modified version thereof 25 as a parser skeleton. Alternatively, if you modify or redistribute 26 the parser skeleton itself, you may (at your option) remove this 27 special exception, which will cause the skeleton and the resulting 28 Bison output files to be licensed under the GNU General Public 29 License without this special exception. 30 31 This special exception was added by the Free Software Foundation in 32 version 2.2 of Bison. */ 33 34 /* C LALR(1) parser skeleton written by Richard Stallman, by 35 simplifying the original so-called "semantic" parser. */ 36 37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 38 especially those whose name start with YY_ or yy_. They are 39 private implementation details that can be changed or removed. */ 40 41 /* All symbols defined below should begin with yy or YY, to avoid 42 infringing on user name space. This should be done even for local 43 variables, as they might otherwise be expanded by user macros. 44 There are some unavoidable exceptions within include files to 45 define necessary library symbols; they are noted "INFRINGES ON 46 USER NAME SPACE" below. */ 47 48 /* Identify Bison output, and Bison version. */ 49 #define YYBISON 30802 50 51 /* Bison version string. */ 52 #define YYBISON_VERSION "3.8.2" 53 54 /* Skeleton name. */ 55 #define YYSKELETON_NAME "yacc.c" 56 57 /* Pure parsers. */ 58 #define YYPURE 0 59 60 /* Push parsers. */ 61 #define YYPUSH 0 62 63 /* Pull parsers. */ 64 #define YYPULL 1 65 66 67 68 69 /* First part of user prologue. */ 70 71 /* sconfig, coreboot device tree compiler */ 72 /* SPDX-License-Identifier: GPL-2.0-only */ 73 74 #include <stdint.h> 75 #include "sconfig.h" 76 77 int yylex(); 78 void yyerror(const char *s); 79 80 static struct bus *cur_parent; 81 static struct chip_instance *cur_chip_instance; 82 static struct fw_config_field *cur_field; 83 static struct fw_config_field_bits *cur_bits; 84 85 86 87 # ifndef YY_CAST 88 # ifdef __cplusplus 89 # define YY_CAST(Type, Val) static_cast<Type> (Val) 90 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 91 # else 92 # define YY_CAST(Type, Val) ((Type) (Val)) 93 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 94 # endif 95 # endif 96 # ifndef YY_NULLPTR 97 # if defined __cplusplus 98 # if 201103L <= __cplusplus 99 # define YY_NULLPTR nullptr 100 # else 101 # define YY_NULLPTR 0 102 # endif 103 # else 104 # define YY_NULLPTR ((void*)0) 105 # endif 106 # endif 107 108 #include "sconfig.tab.h_shipped" 109 /* Symbol kind. */ 110 enum yysymbol_kind_t 111 { 112 YYSYMBOL_YYEMPTY = -2, 113 YYSYMBOL_YYEOF = 0, /* "end of file" */ 114 YYSYMBOL_YYerror = 1, /* error */ 115 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 116 YYSYMBOL_CHIP = 3, /* CHIP */ 117 YYSYMBOL_DEVICE = 4, /* DEVICE */ 118 YYSYMBOL_REGISTER = 5, /* REGISTER */ 119 YYSYMBOL_ALIAS = 6, /* ALIAS */ 120 YYSYMBOL_REFERENCE = 7, /* REFERENCE */ 121 YYSYMBOL_ASSOCIATION = 8, /* ASSOCIATION */ 122 YYSYMBOL_BOOL = 9, /* BOOL */ 123 YYSYMBOL_STATUS = 10, /* STATUS */ 124 YYSYMBOL_MANDATORY = 11, /* MANDATORY */ 125 YYSYMBOL_BUS = 12, /* BUS */ 126 YYSYMBOL_RESOURCE = 13, /* RESOURCE */ 127 YYSYMBOL_END = 14, /* END */ 128 YYSYMBOL_EQUALS = 15, /* EQUALS */ 129 YYSYMBOL_HEX = 16, /* HEX */ 130 YYSYMBOL_STRING = 17, /* STRING */ 131 YYSYMBOL_PCI = 18, /* PCI */ 132 YYSYMBOL_PNP = 19, /* PNP */ 133 YYSYMBOL_I2C = 20, /* I2C */ 134 YYSYMBOL_CPU_CLUSTER = 21, /* CPU_CLUSTER */ 135 YYSYMBOL_CPU = 22, /* CPU */ 136 YYSYMBOL_DOMAIN = 23, /* DOMAIN */ 137 YYSYMBOL_IRQ = 24, /* IRQ */ 138 YYSYMBOL_DRQ = 25, /* DRQ */ 139 YYSYMBOL_SLOT_DESC = 26, /* SLOT_DESC */ 140 YYSYMBOL_SMBIOS_DEV_INFO = 27, /* SMBIOS_DEV_INFO */ 141 YYSYMBOL_IO = 28, /* IO */ 142 YYSYMBOL_NUMBER = 29, /* NUMBER */ 143 YYSYMBOL_SUBSYSTEMID = 30, /* SUBSYSTEMID */ 144 YYSYMBOL_INHERIT = 31, /* INHERIT */ 145 YYSYMBOL_PCIINT = 32, /* PCIINT */ 146 YYSYMBOL_GENERIC = 33, /* GENERIC */ 147 YYSYMBOL_SPI = 34, /* SPI */ 148 YYSYMBOL_USB = 35, /* USB */ 149 YYSYMBOL_MMIO = 36, /* MMIO */ 150 YYSYMBOL_GPIO = 37, /* GPIO */ 151 YYSYMBOL_MDIO = 38, /* MDIO */ 152 YYSYMBOL_FW_CONFIG_TABLE = 39, /* FW_CONFIG_TABLE */ 153 YYSYMBOL_FW_CONFIG_FIELD = 40, /* FW_CONFIG_FIELD */ 154 YYSYMBOL_FW_CONFIG_OPTION = 41, /* FW_CONFIG_OPTION */ 155 YYSYMBOL_FW_CONFIG_PROBE = 42, /* FW_CONFIG_PROBE */ 156 YYSYMBOL_FW_CONFIG_UNPROVISIONED = 43, /* FW_CONFIG_UNPROVISIONED */ 157 YYSYMBOL_PIPE = 44, /* PIPE */ 158 YYSYMBOL_OPS = 45, /* OPS */ 159 YYSYMBOL_YYACCEPT = 46, /* $accept */ 160 YYSYMBOL_devtree = 47, /* devtree */ 161 YYSYMBOL_chipchild_nondev = 48, /* chipchild_nondev */ 162 YYSYMBOL_chipchild = 49, /* chipchild */ 163 YYSYMBOL_chipchildren = 50, /* chipchildren */ 164 YYSYMBOL_chipchildren_dev = 51, /* chipchildren_dev */ 165 YYSYMBOL_devicechildren = 52, /* devicechildren */ 166 YYSYMBOL_chip = 53, /* chip */ 167 YYSYMBOL_54_1 = 54, /* @1 */ 168 YYSYMBOL_device = 55, /* device */ 169 YYSYMBOL_56_2 = 56, /* @2 */ 170 YYSYMBOL_57_3 = 57, /* @3 */ 171 YYSYMBOL_alias = 58, /* alias */ 172 YYSYMBOL_status = 59, /* status */ 173 YYSYMBOL_resource = 60, /* resource */ 174 YYSYMBOL_reference = 61, /* reference */ 175 YYSYMBOL_registers = 62, /* registers */ 176 YYSYMBOL_subsystemid = 63, /* subsystemid */ 177 YYSYMBOL_smbios_slot_desc = 64, /* smbios_slot_desc */ 178 YYSYMBOL_smbios_dev_info = 65, /* smbios_dev_info */ 179 YYSYMBOL_fw_config_table = 66, /* fw_config_table */ 180 YYSYMBOL_fw_config_table_children = 67, /* fw_config_table_children */ 181 YYSYMBOL_fw_config_field_children = 68, /* fw_config_field_children */ 182 YYSYMBOL_fw_config_field_bits = 69, /* fw_config_field_bits */ 183 YYSYMBOL_fw_config_field_bits_repeating = 70, /* fw_config_field_bits_repeating */ 184 YYSYMBOL_fw_config_field = 71, /* fw_config_field */ 185 YYSYMBOL_72_4 = 72, /* $@4 */ 186 YYSYMBOL_73_5 = 73, /* $@5 */ 187 YYSYMBOL_74_6 = 74, /* $@6 */ 188 YYSYMBOL_fw_config_option = 75, /* fw_config_option */ 189 YYSYMBOL_fw_config_probe = 76, /* fw_config_probe */ 190 YYSYMBOL_ops = 77 /* ops */ 191 }; 192 typedef enum yysymbol_kind_t yysymbol_kind_t; 193 194 195 196 197 #ifdef short 198 # undef short 199 #endif 200 201 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 202 <limits.h> and (if available) <stdint.h> are included 203 so that the code can choose integer types of a good width. */ 204 205 #ifndef __PTRDIFF_MAX__ 206 # include <limits.h> /* INFRINGES ON USER NAME SPACE */ 207 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 208 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */ 209 # define YY_STDINT_H 210 # endif 211 #endif 212 213 /* Narrow types that promote to a signed type and that can represent a 214 signed or unsigned integer of at least N bits. In tables they can 215 save space and decrease cache pressure. Promoting to a signed type 216 helps avoid bugs in integer arithmetic. */ 217 218 #ifdef __INT_LEAST8_MAX__ 219 typedef __INT_LEAST8_TYPE__ yytype_int8; 220 #elif defined YY_STDINT_H 221 typedef int_least8_t yytype_int8; 222 #else 223 typedef signed char yytype_int8; 224 #endif 225 226 #ifdef __INT_LEAST16_MAX__ 227 typedef __INT_LEAST16_TYPE__ yytype_int16; 228 #elif defined YY_STDINT_H 229 typedef int_least16_t yytype_int16; 230 #else 231 typedef short yytype_int16; 232 #endif 233 234 /* Work around bug in HP-UX 11.23, which defines these macros 235 incorrectly for preprocessor constants. This workaround can likely 236 be removed in 2023, as HPE has promised support for HP-UX 11.23 237 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 238 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ 239 #ifdef __hpux 240 # undef UINT_LEAST8_MAX 241 # undef UINT_LEAST16_MAX 242 # define UINT_LEAST8_MAX 255 243 # define UINT_LEAST16_MAX 65535 244 #endif 245 246 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 247 typedef __UINT_LEAST8_TYPE__ yytype_uint8; 248 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 249 && UINT_LEAST8_MAX <= INT_MAX) 250 typedef uint_least8_t yytype_uint8; 251 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 252 typedef unsigned char yytype_uint8; 253 #else 254 typedef short yytype_uint8; 255 #endif 256 257 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 258 typedef __UINT_LEAST16_TYPE__ yytype_uint16; 259 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 260 && UINT_LEAST16_MAX <= INT_MAX) 261 typedef uint_least16_t yytype_uint16; 262 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 263 typedef unsigned short yytype_uint16; 264 #else 265 typedef int yytype_uint16; 266 #endif 267 268 #ifndef YYPTRDIFF_T 269 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 270 # define YYPTRDIFF_T __PTRDIFF_TYPE__ 271 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 272 # elif defined PTRDIFF_MAX 273 # ifndef ptrdiff_t 274 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 275 # endif 276 # define YYPTRDIFF_T ptrdiff_t 277 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 278 # else 279 # define YYPTRDIFF_T long 280 # define YYPTRDIFF_MAXIMUM LONG_MAX 281 # endif 282 #endif 283 284 #ifndef YYSIZE_T 285 # ifdef __SIZE_TYPE__ 286 # define YYSIZE_T __SIZE_TYPE__ 287 # elif defined size_t 288 # define YYSIZE_T size_t 289 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 290 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 291 # define YYSIZE_T size_t 292 # else 293 # define YYSIZE_T unsigned 294 # endif 295 #endif 296 297 #define YYSIZE_MAXIMUM \ 298 YY_CAST (YYPTRDIFF_T, \ 299 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 300 ? YYPTRDIFF_MAXIMUM \ 301 : YY_CAST (YYSIZE_T, -1))) 302 303 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 304 305 306 /* Stored state numbers (used for stacks). */ 307 typedef yytype_int8 yy_state_t; 308 309 /* State numbers in computations. */ 310 typedef int yy_state_fast_t; 311 312 #ifndef YY_ 313 # if defined YYENABLE_NLS && YYENABLE_NLS 314 # if ENABLE_NLS 315 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 316 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 317 # endif 318 # endif 319 # ifndef YY_ 320 # define YY_(Msgid) Msgid 321 # endif 322 #endif 323 324 325 #ifndef YY_ATTRIBUTE_PURE 326 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 327 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 328 # else 329 # define YY_ATTRIBUTE_PURE 330 # endif 331 #endif 332 333 #ifndef YY_ATTRIBUTE_UNUSED 334 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 335 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 336 # else 337 # define YY_ATTRIBUTE_UNUSED 338 # endif 339 #endif 340 341 /* Suppress unused-variable warnings by "using" E. */ 342 #if ! defined lint || defined __GNUC__ 343 # define YY_USE(E) ((void) (E)) 344 #else 345 # define YY_USE(E) /* empty */ 346 #endif 347 348 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 349 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 350 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407 351 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 352 _Pragma ("GCC diagnostic push") \ 353 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 354 # else 355 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 356 _Pragma ("GCC diagnostic push") \ 357 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 358 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 359 # endif 360 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 361 _Pragma ("GCC diagnostic pop") 362 #else 363 # define YY_INITIAL_VALUE(Value) Value 364 #endif 365 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 366 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 367 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 368 #endif 369 #ifndef YY_INITIAL_VALUE 370 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 371 #endif 372 373 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 374 # define YY_IGNORE_USELESS_CAST_BEGIN \ 375 _Pragma ("GCC diagnostic push") \ 376 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 377 # define YY_IGNORE_USELESS_CAST_END \ 378 _Pragma ("GCC diagnostic pop") 379 #endif 380 #ifndef YY_IGNORE_USELESS_CAST_BEGIN 381 # define YY_IGNORE_USELESS_CAST_BEGIN 382 # define YY_IGNORE_USELESS_CAST_END 383 #endif 384 385 386 #define YY_ASSERT(E) ((void) (0 && (E))) 387 388 #if !defined yyoverflow 389 390 /* The parser invokes alloca or malloc; define the necessary symbols. */ 391 392 # ifdef YYSTACK_USE_ALLOCA 393 # if YYSTACK_USE_ALLOCA 394 # ifdef __GNUC__ 395 # define YYSTACK_ALLOC __builtin_alloca 396 # elif defined __BUILTIN_VA_ARG_INCR 397 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 398 # elif defined _AIX 399 # define YYSTACK_ALLOC __alloca 400 # elif defined _MSC_VER 401 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 402 # define alloca _alloca 403 # else 404 # define YYSTACK_ALLOC alloca 405 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 406 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 407 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 408 # ifndef EXIT_SUCCESS 409 # define EXIT_SUCCESS 0 410 # endif 411 # endif 412 # endif 413 # endif 414 # endif 415 416 # ifdef YYSTACK_ALLOC 417 /* Pacify GCC's 'empty if-body' warning. */ 418 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 419 # ifndef YYSTACK_ALLOC_MAXIMUM 420 /* The OS might guarantee only one guard page at the bottom of the stack, 421 and a page size can be as small as 4096 bytes. So we cannot safely 422 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 423 to allow for a few compiler-allocated temporary stack slots. */ 424 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 425 # endif 426 # else 427 # define YYSTACK_ALLOC YYMALLOC 428 # define YYSTACK_FREE YYFREE 429 # ifndef YYSTACK_ALLOC_MAXIMUM 430 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 431 # endif 432 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 433 && ! ((defined YYMALLOC || defined malloc) \ 434 && (defined YYFREE || defined free))) 435 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 436 # ifndef EXIT_SUCCESS 437 # define EXIT_SUCCESS 0 438 # endif 439 # endif 440 # ifndef YYMALLOC 441 # define YYMALLOC malloc 442 # if ! defined malloc && ! defined EXIT_SUCCESS 443 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 444 # endif 445 # endif 446 # ifndef YYFREE 447 # define YYFREE free 448 # if ! defined free && ! defined EXIT_SUCCESS 449 void free (void *); /* INFRINGES ON USER NAME SPACE */ 450 # endif 451 # endif 452 # endif 453 #endif /* !defined yyoverflow */ 454 455 #if (! defined yyoverflow \ 456 && (! defined __cplusplus \ 457 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 458 459 /* A type that is properly aligned for any stack member. */ 460 union yyalloc 461 { 462 yy_state_t yyss_alloc; 463 YYSTYPE yyvs_alloc; 464 }; 465 466 /* The size of the maximum gap between one aligned stack and the next. */ 467 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 468 469 /* The size of an array large to enough to hold all stacks, each with 470 N elements. */ 471 # define YYSTACK_BYTES(N) \ 472 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 473 + YYSTACK_GAP_MAXIMUM) 474 475 # define YYCOPY_NEEDED 1 476 477 /* Relocate STACK from its old location to the new one. The 478 local variables YYSIZE and YYSTACKSIZE give the old and new number of 479 elements in the stack, and YYPTR gives the new location of the 480 stack. Advance YYPTR to a properly aligned location for the next 481 stack. */ 482 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 483 do \ 484 { \ 485 YYPTRDIFF_T yynewbytes; \ 486 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 487 Stack = &yyptr->Stack_alloc; \ 488 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 489 yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 490 } \ 491 while (0) 492 493 #endif 494 495 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 496 /* Copy COUNT objects from SRC to DST. The source and destination do 497 not overlap. */ 498 # ifndef YYCOPY 499 # if defined __GNUC__ && 1 < __GNUC__ 500 # define YYCOPY(Dst, Src, Count) \ 501 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 502 # else 503 # define YYCOPY(Dst, Src, Count) \ 504 do \ 505 { \ 506 YYPTRDIFF_T yyi; \ 507 for (yyi = 0; yyi < (Count); yyi++) \ 508 (Dst)[yyi] = (Src)[yyi]; \ 509 } \ 510 while (0) 511 # endif 512 # endif 513 #endif /* !YYCOPY_NEEDED */ 514 515 /* YYFINAL -- State number of the termination state. */ 516 #define YYFINAL 2 517 /* YYLAST -- Last index in YYTABLE. */ 518 #define YYLAST 93 519 520 /* YYNTOKENS -- Number of terminals. */ 521 #define YYNTOKENS 46 522 /* YYNNTS -- Number of nonterminals. */ 523 #define YYNNTS 32 524 /* YYNRULES -- Number of rules. */ 525 #define YYNRULES 61 526 /* YYNSTATES -- Number of states. */ 527 #define YYNSTATES 104 528 529 /* YYMAXUTOK -- Last valid token kind. */ 530 #define YYMAXUTOK 300 531 532 533 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 534 as returned by yylex, with out-of-bounds checking. */ 535 #define YYTRANSLATE(YYX) \ 536 (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 537 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 538 : YYSYMBOL_YYUNDEF) 539 540 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 541 as returned by yylex. */ 542 static const yytype_int8 yytranslate[] = 543 { 544 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 549 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 550 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 552 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 553 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 554 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 555 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 556 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 559 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 569 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 570 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 571 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 572 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 573 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 574 45 575 }; 576 577 #if YYDEBUG 578 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 579 static const yytype_uint8 yyrline[] = 580 { 581 0, 26, 26, 26, 26, 29, 29, 29, 30, 30, 582 31, 31, 32, 32, 34, 34, 34, 34, 34, 34, 583 34, 34, 34, 34, 36, 36, 45, 45, 53, 53, 584 61, 63, 67, 67, 69, 72, 75, 78, 81, 84, 585 87, 90, 93, 96, 100, 103, 103, 106, 106, 109, 586 115, 115, 118, 117, 122, 122, 130, 130, 136, 140, 587 143, 146 588 }; 589 #endif 590 591 /** Accessing symbol of state STATE. */ 592 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 593 594 #if YYDEBUG || 0 595 /* The user-facing name of the symbol whose (internal) number is 596 YYSYMBOL. No bounds checking. */ 597 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 598 599 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 600 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 601 static const char *const yytname[] = 602 { 603 "\"end of file\"", "error", "\"invalid token\"", "CHIP", "DEVICE", 604 "REGISTER", "ALIAS", "REFERENCE", "ASSOCIATION", "BOOL", "STATUS", 605 "MANDATORY", "BUS", "RESOURCE", "END", "EQUALS", "HEX", "STRING", "PCI", 606 "PNP", "I2C", "CPU_CLUSTER", "CPU", "DOMAIN", "IRQ", "DRQ", "SLOT_DESC", 607 "SMBIOS_DEV_INFO", "IO", "NUMBER", "SUBSYSTEMID", "INHERIT", "PCIINT", 608 "GENERIC", "SPI", "USB", "MMIO", "GPIO", "MDIO", "FW_CONFIG_TABLE", 609 "FW_CONFIG_FIELD", "FW_CONFIG_OPTION", "FW_CONFIG_PROBE", 610 "FW_CONFIG_UNPROVISIONED", "PIPE", "OPS", "$accept", "devtree", 611 "chipchild_nondev", "chipchild", "chipchildren", "chipchildren_dev", 612 "devicechildren", "chip", "@1", "device", "@2", "@3", "alias", "status", 613 "resource", "reference", "registers", "subsystemid", "smbios_slot_desc", 614 "smbios_dev_info", "fw_config_table", "fw_config_table_children", 615 "fw_config_field_children", "fw_config_field_bits", 616 "fw_config_field_bits_repeating", "fw_config_field", "$@4", "$@5", "$@6", 617 "fw_config_option", "fw_config_probe", "ops", YY_NULLPTR 618 }; 619 620 static const char * 621 yysymbol_name (yysymbol_kind_t yysymbol) 622 { 623 return yytname[yysymbol]; 624 } 625 #endif 626 627 #define YYPACT_NINF (-51) 628 629 #define yypact_value_is_default(Yyn) \ 630 ((Yyn) == YYPACT_NINF) 631 632 #define YYTABLE_NINF (-1) 633 634 #define yytable_value_is_error(Yyn) \ 635 0 636 637 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 638 STATE-NUM. */ 639 static const yytype_int8 yypact[] = 640 { 641 -51, 12, -51, 4, -51, -51, -51, -51, -3, 49, 642 -51, 11, -51, 10, 23, 24, 49, 29, -51, -51, 643 -51, -51, 15, 31, 20, 40, 51, -51, -51, 49, 644 28, 16, -51, 14, 55, 45, 46, -51, -51, -51, 645 -51, -51, 35, -51, -12, -51, -51, -51, 50, 14, 646 -51, -51, -8, 28, 16, -51, -51, 52, -51, -51, 647 -51, -51, -51, -51, -7, 37, 0, -51, -51, -51, 648 39, -51, 53, 42, 43, 3, 56, -51, -51, -51, 649 -51, -51, -51, -51, -51, -51, 5, 59, 58, 60, 650 47, 61, -51, -51, -51, 54, 62, -51, 57, -51, 651 -51, 63, -51, -51 652 }; 653 654 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 655 Performed when YYTABLE does not specify something else to do. Zero 656 means the default is an error. */ 657 static const yytype_int8 yydefact[] = 658 { 659 2, 0, 1, 0, 46, 3, 4, 24, 0, 0, 660 44, 0, 45, 0, 0, 0, 0, 0, 5, 11, 661 7, 6, 56, 0, 0, 0, 0, 13, 25, 12, 662 54, 51, 48, 0, 30, 0, 0, 9, 10, 8, 663 49, 48, 0, 52, 0, 32, 33, 28, 0, 0, 664 36, 35, 0, 0, 51, 48, 57, 0, 47, 23, 665 31, 26, 55, 50, 0, 0, 0, 23, 53, 58, 666 0, 29, 0, 0, 0, 0, 0, 15, 14, 16, 667 20, 17, 18, 19, 21, 22, 0, 0, 0, 43, 668 0, 0, 60, 61, 27, 0, 41, 42, 37, 59, 669 34, 40, 38, 39 670 }; 671 672 /* YYPGOTO[NTERM-NUM]. */ 673 static const yytype_int8 yypgoto[] = 674 { 675 -51, -51, 64, -51, -51, 65, 17, -1, -51, -28, 676 -51, -51, -51, 33, -51, -51, -50, -51, -51, -51, 677 -51, -51, -16, 44, 36, -51, -51, -51, -51, -51, 678 -51, -51 679 }; 680 681 /* YYDEFGOTO[NTERM-NUM]. */ 682 static const yytype_int8 yydefgoto[] = 683 { 684 0, 1, 16, 38, 29, 17, 66, 18, 9, 19, 685 67, 59, 49, 47, 79, 20, 21, 81, 82, 83, 686 6, 8, 44, 31, 43, 12, 55, 41, 32, 58, 687 84, 85 688 }; 689 690 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 691 positive, shift that token. If negative, reduce the rule whose 692 number is the opposite. If YYTABLE_NINF, syntax error. */ 693 static const yytype_int8 yytable[] = 694 { 695 5, 39, 56, 3, 13, 14, 62, 68, 3, 13, 696 14, 10, 2, 70, 71, 3, 80, 23, 70, 94, 697 91, 7, 24, 45, 46, 52, 72, 73, 22, 57, 698 74, 72, 73, 57, 57, 74, 80, 11, 78, 64, 699 25, 26, 75, 28, 30, 76, 92, 75, 33, 34, 700 76, 4, 3, 13, 14, 35, 15, 40, 78, 36, 701 42, 48, 50, 51, 53, 77, 69, 60, 87, 65, 702 88, 89, 90, 93, 95, 96, 98, 97, 99, 101, 703 103, 27, 61, 100, 86, 77, 54, 0, 102, 0, 704 63, 0, 0, 37 705 }; 706 707 static const yytype_int8 yycheck[] = 708 { 709 1, 29, 14, 3, 4, 5, 14, 14, 3, 4, 710 5, 14, 0, 13, 14, 3, 66, 7, 13, 14, 711 17, 17, 12, 9, 10, 41, 26, 27, 17, 41, 712 30, 26, 27, 41, 41, 30, 86, 40, 66, 55, 713 17, 17, 42, 14, 29, 45, 43, 42, 17, 29, 714 45, 39, 3, 4, 5, 15, 7, 29, 86, 8, 715 44, 6, 17, 17, 29, 66, 29, 17, 29, 17, 716 17, 29, 29, 17, 15, 17, 29, 17, 17, 17, 717 17, 16, 49, 29, 67, 86, 42, -1, 31, -1, 718 54, -1, -1, 29 719 }; 720 721 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of 722 state STATE-NUM. */ 723 static const yytype_int8 yystos[] = 724 { 725 0, 47, 0, 3, 39, 53, 66, 17, 67, 54, 726 14, 40, 71, 4, 5, 7, 48, 51, 53, 55, 727 61, 62, 17, 7, 12, 17, 17, 51, 14, 50, 728 29, 69, 74, 17, 29, 15, 8, 48, 49, 55, 729 29, 73, 44, 70, 68, 9, 10, 59, 6, 58, 730 17, 17, 68, 29, 69, 72, 14, 41, 75, 57, 731 17, 59, 14, 70, 68, 17, 52, 56, 14, 29, 732 13, 14, 26, 27, 30, 42, 45, 53, 55, 60, 733 62, 63, 64, 65, 76, 77, 52, 29, 17, 29, 734 29, 17, 43, 17, 14, 15, 17, 17, 29, 17, 735 29, 17, 31, 17 736 }; 737 738 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ 739 static const yytype_int8 yyr1[] = 740 { 741 0, 46, 47, 47, 47, 48, 48, 48, 49, 49, 742 50, 50, 51, 51, 52, 52, 52, 52, 52, 52, 743 52, 52, 52, 52, 54, 53, 56, 55, 57, 55, 744 58, 58, 59, 59, 60, 61, 62, 63, 63, 64, 745 64, 64, 65, 65, 66, 67, 67, 68, 68, 69, 746 70, 70, 72, 71, 73, 71, 74, 71, 75, 76, 747 76, 77 748 }; 749 750 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ 751 static const yytype_int8 yyr2[] = 752 { 753 0, 2, 0, 2, 2, 1, 1, 1, 1, 1, 754 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 755 2, 2, 2, 0, 0, 5, 0, 8, 0, 7, 756 0, 2, 1, 1, 4, 4, 4, 3, 4, 5, 757 4, 3, 3, 2, 3, 2, 0, 2, 0, 2, 758 3, 0, 0, 7, 0, 6, 0, 5, 3, 3, 759 2, 2 760 }; 761 762 763 enum { YYENOMEM = -2 }; 764 765 #define yyerrok (yyerrstatus = 0) 766 #define yyclearin (yychar = YYEMPTY) 767 768 #define YYACCEPT goto yyacceptlab 769 #define YYABORT goto yyabortlab 770 #define YYERROR goto yyerrorlab 771 #define YYNOMEM goto yyexhaustedlab 772 773 774 #define YYRECOVERING() (!!yyerrstatus) 775 776 #define YYBACKUP(Token, Value) \ 777 do \ 778 if (yychar == YYEMPTY) \ 779 { \ 780 yychar = (Token); \ 781 yylval = (Value); \ 782 YYPOPSTACK (yylen); \ 783 yystate = *yyssp; \ 784 goto yybackup; \ 785 } \ 786 else \ 787 { \ 788 yyerror (YY_("syntax error: cannot back up")); \ 789 YYERROR; \ 790 } \ 791 while (0) 792 793 /* Backward compatibility with an undocumented macro. 794 Use YYerror or YYUNDEF. */ 795 #define YYERRCODE YYUNDEF 796 797 798 /* Enable debugging if requested. */ 799 #if YYDEBUG 800 801 # ifndef YYFPRINTF 802 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 803 # define YYFPRINTF fprintf 804 # endif 805 806 # define YYDPRINTF(Args) \ 807 do { \ 808 if (yydebug) \ 809 YYFPRINTF Args; \ 810 } while (0) 811 812 813 814 815 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 816 do { \ 817 if (yydebug) \ 818 { \ 819 YYFPRINTF (stderr, "%s ", Title); \ 820 yy_symbol_print (stderr, \ 821 Kind, Value); \ 822 YYFPRINTF (stderr, "\n"); \ 823 } \ 824 } while (0) 825 826 827 /*-----------------------------------. 828 | Print this symbol's value on YYO. | 829 `-----------------------------------*/ 830 831 static void 832 yy_symbol_value_print (FILE *yyo, 833 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 834 { 835 FILE *yyoutput = yyo; 836 YY_USE (yyoutput); 837 if (!yyvaluep) 838 return; 839 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 840 YY_USE (yykind); 841 YY_IGNORE_MAYBE_UNINITIALIZED_END 842 } 843 844 845 /*---------------------------. 846 | Print this symbol on YYO. | 847 `---------------------------*/ 848 849 static void 850 yy_symbol_print (FILE *yyo, 851 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 852 { 853 YYFPRINTF (yyo, "%s %s (", 854 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 855 856 yy_symbol_value_print (yyo, yykind, yyvaluep); 857 YYFPRINTF (yyo, ")"); 858 } 859 860 /*------------------------------------------------------------------. 861 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 862 | TOP (included). | 863 `------------------------------------------------------------------*/ 864 865 static void 866 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 867 { 868 YYFPRINTF (stderr, "Stack now"); 869 for (; yybottom <= yytop; yybottom++) 870 { 871 int yybot = *yybottom; 872 YYFPRINTF (stderr, " %d", yybot); 873 } 874 YYFPRINTF (stderr, "\n"); 875 } 876 877 # define YY_STACK_PRINT(Bottom, Top) \ 878 do { \ 879 if (yydebug) \ 880 yy_stack_print ((Bottom), (Top)); \ 881 } while (0) 882 883 884 /*------------------------------------------------. 885 | Report that the YYRULE is going to be reduced. | 886 `------------------------------------------------*/ 887 888 static void 889 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 890 int yyrule) 891 { 892 int yylno = yyrline[yyrule]; 893 int yynrhs = yyr2[yyrule]; 894 int yyi; 895 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 896 yyrule - 1, yylno); 897 /* The symbols being reduced. */ 898 for (yyi = 0; yyi < yynrhs; yyi++) 899 { 900 YYFPRINTF (stderr, " $%d = ", yyi + 1); 901 yy_symbol_print (stderr, 902 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 903 &yyvsp[(yyi + 1) - (yynrhs)]); 904 YYFPRINTF (stderr, "\n"); 905 } 906 } 907 908 # define YY_REDUCE_PRINT(Rule) \ 909 do { \ 910 if (yydebug) \ 911 yy_reduce_print (yyssp, yyvsp, Rule); \ 912 } while (0) 913 914 /* Nonzero means print parse trace. It is left uninitialized so that 915 multiple parsers can coexist. */ 916 int yydebug; 917 #else /* !YYDEBUG */ 918 # define YYDPRINTF(Args) ((void) 0) 919 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 920 # define YY_STACK_PRINT(Bottom, Top) 921 # define YY_REDUCE_PRINT(Rule) 922 #endif /* !YYDEBUG */ 923 924 925 /* YYINITDEPTH -- initial size of the parser's stacks. */ 926 #ifndef YYINITDEPTH 927 # define YYINITDEPTH 200 928 #endif 929 930 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 931 if the built-in stack extension method is used). 932 933 Do not make this value too large; the results are undefined if 934 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 935 evaluated with infinite-precision integer arithmetic. */ 936 937 #ifndef YYMAXDEPTH 938 # define YYMAXDEPTH 10000 939 #endif 940 941 942 943 944 945 946 /*-----------------------------------------------. 947 | Release the memory associated to this symbol. | 948 `-----------------------------------------------*/ 949 950 static void 951 yydestruct (const char *yymsg, 952 yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 953 { 954 YY_USE (yyvaluep); 955 if (!yymsg) 956 yymsg = "Deleting"; 957 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 958 959 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 960 YY_USE (yykind); 961 YY_IGNORE_MAYBE_UNINITIALIZED_END 962 } 963 964 965 /* Lookahead token kind. */ 966 int yychar; 967 968 /* The semantic value of the lookahead symbol. */ 969 YYSTYPE yylval; 970 /* Number of syntax errors so far. */ 971 int yynerrs; 972 973 974 975 976 /*----------. 977 | yyparse. | 978 `----------*/ 979 980 int 981 yyparse (void) 982 { 983 yy_state_fast_t yystate = 0; 984 /* Number of tokens to shift before error messages enabled. */ 985 int yyerrstatus = 0; 986 987 /* Refer to the stacks through separate pointers, to allow yyoverflow 988 to reallocate them elsewhere. */ 989 990 /* Their size. */ 991 YYPTRDIFF_T yystacksize = YYINITDEPTH; 992 993 /* The state stack: array, bottom, top. */ 994 yy_state_t yyssa[YYINITDEPTH]; 995 yy_state_t *yyss = yyssa; 996 yy_state_t *yyssp = yyss; 997 998 /* The semantic value stack: array, bottom, top. */ 999 YYSTYPE yyvsa[YYINITDEPTH]; 1000 YYSTYPE *yyvs = yyvsa; 1001 YYSTYPE *yyvsp = yyvs; 1002 1003 int yyn; 1004 /* The return value of yyparse. */ 1005 int yyresult; 1006 /* Lookahead symbol kind. */ 1007 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1008 /* The variables used to return semantic value and location from the 1009 action routines. */ 1010 YYSTYPE yyval; 1011 1012 1013 1014 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1015 1016 /* The number of symbols on the RHS of the reduced rule. 1017 Keep to zero when no symbol should be popped. */ 1018 int yylen = 0; 1019 1020 YYDPRINTF ((stderr, "Starting parse\n")); 1021 1022 yychar = YYEMPTY; /* Cause a token to be read. */ 1023 1024 goto yysetstate; 1025 1026 1027 /*------------------------------------------------------------. 1028 | yynewstate -- push a new state, which is found in yystate. | 1029 `------------------------------------------------------------*/ 1030 yynewstate: 1031 /* In all cases, when you get here, the value and location stacks 1032 have just been pushed. So pushing a state here evens the stacks. */ 1033 yyssp++; 1034 1035 1036 /*--------------------------------------------------------------------. 1037 | yysetstate -- set current state (the top of the stack) to yystate. | 1038 `--------------------------------------------------------------------*/ 1039 yysetstate: 1040 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1041 YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 1042 YY_IGNORE_USELESS_CAST_BEGIN 1043 *yyssp = YY_CAST (yy_state_t, yystate); 1044 YY_IGNORE_USELESS_CAST_END 1045 YY_STACK_PRINT (yyss, yyssp); 1046 1047 if (yyss + yystacksize - 1 <= yyssp) 1048 #if !defined yyoverflow && !defined YYSTACK_RELOCATE 1049 YYNOMEM; 1050 #else 1051 { 1052 /* Get the current used size of the three stacks, in elements. */ 1053 YYPTRDIFF_T yysize = yyssp - yyss + 1; 1054 1055 # if defined yyoverflow 1056 { 1057 /* Give user a chance to reallocate the stack. Use copies of 1058 these so that the &'s don't force the real ones into 1059 memory. */ 1060 yy_state_t *yyss1 = yyss; 1061 YYSTYPE *yyvs1 = yyvs; 1062 1063 /* Each stack pointer address is followed by the size of the 1064 data in use in that stack, in bytes. This used to be a 1065 conditional around just the two extra args, but that might 1066 be undefined if yyoverflow is a macro. */ 1067 yyoverflow (YY_("memory exhausted"), 1068 &yyss1, yysize * YYSIZEOF (*yyssp), 1069 &yyvs1, yysize * YYSIZEOF (*yyvsp), 1070 &yystacksize); 1071 yyss = yyss1; 1072 yyvs = yyvs1; 1073 } 1074 # else /* defined YYSTACK_RELOCATE */ 1075 /* Extend the stack our own way. */ 1076 if (YYMAXDEPTH <= yystacksize) 1077 YYNOMEM; 1078 yystacksize *= 2; 1079 if (YYMAXDEPTH < yystacksize) 1080 yystacksize = YYMAXDEPTH; 1081 1082 { 1083 yy_state_t *yyss1 = yyss; 1084 union yyalloc *yyptr = 1085 YY_CAST (union yyalloc *, 1086 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1087 if (! yyptr) 1088 YYNOMEM; 1089 YYSTACK_RELOCATE (yyss_alloc, yyss); 1090 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1091 # undef YYSTACK_RELOCATE 1092 if (yyss1 != yyssa) 1093 YYSTACK_FREE (yyss1); 1094 } 1095 # endif 1096 1097 yyssp = yyss + yysize - 1; 1098 yyvsp = yyvs + yysize - 1; 1099 1100 YY_IGNORE_USELESS_CAST_BEGIN 1101 YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1102 YY_CAST (long, yystacksize))); 1103 YY_IGNORE_USELESS_CAST_END 1104 1105 if (yyss + yystacksize - 1 <= yyssp) 1106 YYABORT; 1107 } 1108 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1109 1110 1111 if (yystate == YYFINAL) 1112 YYACCEPT; 1113 1114 goto yybackup; 1115 1116 1117 /*-----------. 1118 | yybackup. | 1119 `-----------*/ 1120 yybackup: 1121 /* Do appropriate processing given the current state. Read a 1122 lookahead token if we need one and don't already have one. */ 1123 1124 /* First try to decide what to do without reference to lookahead token. */ 1125 yyn = yypact[yystate]; 1126 if (yypact_value_is_default (yyn)) 1127 goto yydefault; 1128 1129 /* Not known => get a lookahead token if don't already have one. */ 1130 1131 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1132 if (yychar == YYEMPTY) 1133 { 1134 YYDPRINTF ((stderr, "Reading a token\n")); 1135 yychar = yylex (); 1136 } 1137 1138 if (yychar <= YYEOF) 1139 { 1140 yychar = YYEOF; 1141 yytoken = YYSYMBOL_YYEOF; 1142 YYDPRINTF ((stderr, "Now at end of input.\n")); 1143 } 1144 else if (yychar == YYerror) 1145 { 1146 /* The scanner already issued an error message, process directly 1147 to error recovery. But do not keep the error token as 1148 lookahead, it is too special and may lead us to an endless 1149 loop in error recovery. */ 1150 yychar = YYUNDEF; 1151 yytoken = YYSYMBOL_YYerror; 1152 goto yyerrlab1; 1153 } 1154 else 1155 { 1156 yytoken = YYTRANSLATE (yychar); 1157 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1158 } 1159 1160 /* If the proper action on seeing token YYTOKEN is to reduce or to 1161 detect an error, take that action. */ 1162 yyn += yytoken; 1163 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1164 goto yydefault; 1165 yyn = yytable[yyn]; 1166 if (yyn <= 0) 1167 { 1168 if (yytable_value_is_error (yyn)) 1169 goto yyerrlab; 1170 yyn = -yyn; 1171 goto yyreduce; 1172 } 1173 1174 /* Count tokens shifted since error; after three, turn off error 1175 status. */ 1176 if (yyerrstatus) 1177 yyerrstatus--; 1178 1179 /* Shift the lookahead token. */ 1180 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1181 yystate = yyn; 1182 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1183 *++yyvsp = yylval; 1184 YY_IGNORE_MAYBE_UNINITIALIZED_END 1185 1186 /* Discard the shifted token. */ 1187 yychar = YYEMPTY; 1188 goto yynewstate; 1189 1190 1191 /*-----------------------------------------------------------. 1192 | yydefault -- do the default action for the current state. | 1193 `-----------------------------------------------------------*/ 1194 yydefault: 1195 yyn = yydefact[yystate]; 1196 if (yyn == 0) 1197 goto yyerrlab; 1198 goto yyreduce; 1199 1200 1201 /*-----------------------------. 1202 | yyreduce -- do a reduction. | 1203 `-----------------------------*/ 1204 yyreduce: 1205 /* yyn is the number of a rule to reduce with. */ 1206 yylen = yyr2[yyn]; 1207 1208 /* If YYLEN is nonzero, implement the default value of the action: 1209 '$$ = $1'. 1210 1211 Otherwise, the following line sets YYVAL to garbage. 1212 This behavior is undocumented and Bison 1213 users should not rely upon it. Assigning to YYVAL 1214 unconditionally makes the parser a bit smaller, and it avoids a 1215 GCC warning that YYVAL may be used uninitialized. */ 1216 yyval = yyvsp[1-yylen]; 1217 1218 1219 YY_REDUCE_PRINT (yyn); 1220 switch (yyn) 1221 { 1222 case 2: /* devtree: %empty */ 1223 { cur_parent = root_parent; } 1224 break; 1225 1226 case 24: /* @1: %empty */ 1227 { 1228 (yyval.chip_instance) = new_chip_instance((yyvsp[0].string)); 1229 chip_enqueue_tail(cur_chip_instance); 1230 cur_chip_instance = (yyval.chip_instance); 1231 } 1232 break; 1233 1234 case 25: /* chip: CHIP STRING @1 chipchildren_dev END */ 1235 { 1236 cur_chip_instance = chip_dequeue_tail(); 1237 } 1238 break; 1239 1240 case 26: /* @2: %empty */ 1241 { 1242 (yyval.dev) = new_device_raw(cur_parent, cur_chip_instance, (yyvsp[-3].number), (yyvsp[-2].string), (yyvsp[-1].string), (yyvsp[0].number)); 1243 cur_parent = (yyval.dev)->bus; 1244 } 1245 break; 1246 1247 case 27: /* device: DEVICE BUS NUMBER alias status @2 devicechildren END */ 1248 { 1249 cur_parent = (yyvsp[-2].dev)->parent; 1250 } 1251 break; 1252 1253 case 28: /* @3: %empty */ 1254 { 1255 (yyval.dev) = new_device_reference(cur_parent, cur_chip_instance, (yyvsp[-1].string), (yyvsp[0].number)); 1256 cur_parent = (yyval.dev)->bus; 1257 } 1258 break; 1259 1260 case 29: /* device: DEVICE REFERENCE STRING status @3 devicechildren END */ 1261 { 1262 cur_parent = (yyvsp[-2].dev)->parent; 1263 } 1264 break; 1265 1266 case 30: /* alias: %empty */ 1267 { 1268 (yyval.string) = NULL; 1269 } 1270 break; 1271 1272 case 31: /* alias: ALIAS STRING */ 1273 { 1274 (yyval.string) = (yyvsp[0].string); 1275 } 1276 break; 1277 1278 case 34: /* resource: RESOURCE NUMBER EQUALS NUMBER */ 1279 { add_resource(cur_parent, (yyvsp[-3].number), strtol((yyvsp[-2].string), NULL, 0), strtol((yyvsp[0].string), NULL, 0)); } 1280 break; 1281 1282 case 35: /* reference: REFERENCE STRING ASSOCIATION STRING */ 1283 { add_reference(cur_chip_instance, (yyvsp[0].string), (yyvsp[-2].string)); } 1284 break; 1285 1286 case 36: /* registers: REGISTER STRING EQUALS STRING */ 1287 { add_register(cur_chip_instance, (yyvsp[-2].string), (yyvsp[0].string)); } 1288 break; 1289 1290 case 37: /* subsystemid: SUBSYSTEMID NUMBER NUMBER */ 1291 { add_pci_subsystem_ids(cur_parent, strtol((yyvsp[-1].string), NULL, 16), strtol((yyvsp[0].string), NULL, 16), 0); } 1292 break; 1293 1294 case 38: /* subsystemid: SUBSYSTEMID NUMBER NUMBER INHERIT */ 1295 { add_pci_subsystem_ids(cur_parent, strtol((yyvsp[-2].string), NULL, 16), strtol((yyvsp[-1].string), NULL, 16), 1); } 1296 break; 1297 1298 case 39: /* smbios_slot_desc: SLOT_DESC STRING STRING STRING STRING */ 1299 { add_slot_desc(cur_parent, (yyvsp[-3].string), (yyvsp[-2].string), (yyvsp[-1].string), (yyvsp[0].string)); } 1300 break; 1301 1302 case 40: /* smbios_slot_desc: SLOT_DESC STRING STRING STRING */ 1303 { add_slot_desc(cur_parent, (yyvsp[-2].string), (yyvsp[-1].string), (yyvsp[0].string), NULL); } 1304 break; 1305 1306 case 41: /* smbios_slot_desc: SLOT_DESC STRING STRING */ 1307 { add_slot_desc(cur_parent, (yyvsp[-1].string), (yyvsp[0].string), NULL, NULL); } 1308 break; 1309 1310 case 42: /* smbios_dev_info: SMBIOS_DEV_INFO NUMBER STRING */ 1311 { add_smbios_dev_info(cur_parent, strtol((yyvsp[-1].string), NULL, 0), (yyvsp[0].string)); } 1312 break; 1313 1314 case 43: /* smbios_dev_info: SMBIOS_DEV_INFO NUMBER */ 1315 { add_smbios_dev_info(cur_parent, strtol((yyvsp[0].string), NULL, 0), NULL); } 1316 break; 1317 1318 case 44: /* fw_config_table: FW_CONFIG_TABLE fw_config_table_children END */ 1319 { } 1320 break; 1321 1322 case 49: /* fw_config_field_bits: NUMBER NUMBER */ 1323 { 1324 append_fw_config_bits(&cur_bits, strtoul((yyvsp[-1].string), NULL, 0), strtoul((yyvsp[0].string), NULL, 0)); 1325 } 1326 break; 1327 1328 case 52: /* $@4: %empty */ 1329 { cur_field = new_fw_config_field((yyvsp[-2].string), cur_bits); } 1330 break; 1331 1332 case 53: /* fw_config_field: FW_CONFIG_FIELD STRING fw_config_field_bits fw_config_field_bits_repeating $@4 fw_config_field_children END */ 1333 { cur_bits = NULL; } 1334 break; 1335 1336 case 54: /* $@5: %empty */ 1337 { 1338 cur_bits = NULL; 1339 append_fw_config_bits(&cur_bits, strtoul((yyvsp[0].string), NULL, 0), strtoul((yyvsp[0].string), NULL, 0)); 1340 cur_field = new_fw_config_field((yyvsp[-1].string), cur_bits); 1341 } 1342 break; 1343 1344 case 55: /* fw_config_field: FW_CONFIG_FIELD STRING NUMBER $@5 fw_config_field_children END */ 1345 { cur_bits = NULL; } 1346 break; 1347 1348 case 56: /* $@6: %empty */ 1349 { 1350 cur_field = get_fw_config_field((yyvsp[0].string)); 1351 } 1352 break; 1353 1354 case 57: /* fw_config_field: FW_CONFIG_FIELD STRING $@6 fw_config_field_children END */ 1355 { cur_bits = NULL; } 1356 break; 1357 1358 case 58: /* fw_config_option: FW_CONFIG_OPTION STRING NUMBER */ 1359 { add_fw_config_option(cur_field, (yyvsp[-1].string), strtoull((yyvsp[0].string), NULL, 0)); } 1360 break; 1361 1362 case 59: /* fw_config_probe: FW_CONFIG_PROBE STRING STRING */ 1363 { add_fw_config_probe(cur_parent, (yyvsp[-1].string), (yyvsp[0].string)); } 1364 break; 1365 1366 case 60: /* fw_config_probe: FW_CONFIG_PROBE FW_CONFIG_UNPROVISIONED */ 1367 { probe_unprovisioned_fw_config(cur_parent); } 1368 break; 1369 1370 case 61: /* ops: OPS STRING */ 1371 { add_device_ops(cur_parent, (yyvsp[0].string)); } 1372 break; 1373 1374 1375 1376 default: break; 1377 } 1378 /* User semantic actions sometimes alter yychar, and that requires 1379 that yytoken be updated with the new translation. We take the 1380 approach of translating immediately before every use of yytoken. 1381 One alternative is translating here after every semantic action, 1382 but that translation would be missed if the semantic action invokes 1383 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1384 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1385 incorrect destructor might then be invoked immediately. In the 1386 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1387 to an incorrect destructor call or verbose syntax error message 1388 before the lookahead is translated. */ 1389 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1390 1391 YYPOPSTACK (yylen); 1392 yylen = 0; 1393 1394 *++yyvsp = yyval; 1395 1396 /* Now 'shift' the result of the reduction. Determine what state 1397 that goes to, based on the state we popped back to and the rule 1398 number reduced by. */ 1399 { 1400 const int yylhs = yyr1[yyn] - YYNTOKENS; 1401 const int yyi = yypgoto[yylhs] + *yyssp; 1402 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 1403 ? yytable[yyi] 1404 : yydefgoto[yylhs]); 1405 } 1406 1407 goto yynewstate; 1408 1409 1410 /*--------------------------------------. 1411 | yyerrlab -- here on detecting error. | 1412 `--------------------------------------*/ 1413 yyerrlab: 1414 /* Make sure we have latest lookahead translation. See comments at 1415 user semantic actions for why this is necessary. */ 1416 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 1417 /* If not already recovering from an error, report this error. */ 1418 if (!yyerrstatus) 1419 { 1420 ++yynerrs; 1421 yyerror (YY_("syntax error")); 1422 } 1423 1424 if (yyerrstatus == 3) 1425 { 1426 /* If just tried and failed to reuse lookahead token after an 1427 error, discard it. */ 1428 1429 if (yychar <= YYEOF) 1430 { 1431 /* Return failure if at end of input. */ 1432 if (yychar == YYEOF) 1433 YYABORT; 1434 } 1435 else 1436 { 1437 yydestruct ("Error: discarding", 1438 yytoken, &yylval); 1439 yychar = YYEMPTY; 1440 } 1441 } 1442 1443 /* Else will try to reuse lookahead token after shifting the error 1444 token. */ 1445 goto yyerrlab1; 1446 1447 1448 /*---------------------------------------------------. 1449 | yyerrorlab -- error raised explicitly by YYERROR. | 1450 `---------------------------------------------------*/ 1451 yyerrorlab: 1452 /* Pacify compilers when the user code never invokes YYERROR and the 1453 label yyerrorlab therefore never appears in user code. */ 1454 if (0) 1455 YYERROR; 1456 ++yynerrs; 1457 1458 /* Do not reclaim the symbols of the rule whose action triggered 1459 this YYERROR. */ 1460 YYPOPSTACK (yylen); 1461 yylen = 0; 1462 YY_STACK_PRINT (yyss, yyssp); 1463 yystate = *yyssp; 1464 goto yyerrlab1; 1465 1466 1467 /*-------------------------------------------------------------. 1468 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1469 `-------------------------------------------------------------*/ 1470 yyerrlab1: 1471 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1472 1473 /* Pop stack until we find a state that shifts the error token. */ 1474 for (;;) 1475 { 1476 yyn = yypact[yystate]; 1477 if (!yypact_value_is_default (yyn)) 1478 { 1479 yyn += YYSYMBOL_YYerror; 1480 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 1481 { 1482 yyn = yytable[yyn]; 1483 if (0 < yyn) 1484 break; 1485 } 1486 } 1487 1488 /* Pop the current state because it cannot handle the error token. */ 1489 if (yyssp == yyss) 1490 YYABORT; 1491 1492 1493 yydestruct ("Error: popping", 1494 YY_ACCESSING_SYMBOL (yystate), yyvsp); 1495 YYPOPSTACK (1); 1496 yystate = *yyssp; 1497 YY_STACK_PRINT (yyss, yyssp); 1498 } 1499 1500 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1501 *++yyvsp = yylval; 1502 YY_IGNORE_MAYBE_UNINITIALIZED_END 1503 1504 1505 /* Shift the error token. */ 1506 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1507 1508 yystate = yyn; 1509 goto yynewstate; 1510 1511 1512 /*-------------------------------------. 1513 | yyacceptlab -- YYACCEPT comes here. | 1514 `-------------------------------------*/ 1515 yyacceptlab: 1516 yyresult = 0; 1517 goto yyreturnlab; 1518 1519 1520 /*-----------------------------------. 1521 | yyabortlab -- YYABORT comes here. | 1522 `-----------------------------------*/ 1523 yyabortlab: 1524 yyresult = 1; 1525 goto yyreturnlab; 1526 1527 1528 /*-----------------------------------------------------------. 1529 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1530 `-----------------------------------------------------------*/ 1531 yyexhaustedlab: 1532 yyerror (YY_("memory exhausted")); 1533 yyresult = 2; 1534 goto yyreturnlab; 1535 1536 1537 /*----------------------------------------------------------. 1538 | yyreturnlab -- parsing is finished, clean up and return. | 1539 `----------------------------------------------------------*/ 1540 yyreturnlab: 1541 if (yychar != YYEMPTY) 1542 { 1543 /* Make sure we have latest lookahead translation. See comments at 1544 user semantic actions for why this is necessary. */ 1545 yytoken = YYTRANSLATE (yychar); 1546 yydestruct ("Cleanup: discarding lookahead", 1547 yytoken, &yylval); 1548 } 1549 /* Do not reclaim the symbols of the rule whose action triggered 1550 this YYABORT or YYACCEPT. */ 1551 YYPOPSTACK (yylen); 1552 YY_STACK_PRINT (yyss, yyssp); 1553 while (yyssp != yyss) 1554 { 1555 yydestruct ("Cleanup: popping", 1556 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 1557 YYPOPSTACK (1); 1558 } 1559 #ifndef yyoverflow 1560 if (yyss != yyssa) 1561 YYSTACK_FREE (yyss); 1562 #endif 1563 1564 return yyresult; 1565 } 1566 1567