1 2 /* A Bison parser, made by GNU Bison 2.4.1. */ 3 4 /* Skeleton implementation for Bison's Yacc-like parsers in C 5 6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 7 Free Software Foundation, Inc. 8 9 This program is free software: you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation, either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* As a special exception, you may create a larger work that contains 23 part or all of the Bison parser skeleton and distribute that work 24 under terms of your choice, so long as that work isn't itself a 25 parser generator using the skeleton or a modified version thereof 26 as a parser skeleton. Alternatively, if you modify or redistribute 27 the parser skeleton itself, you may (at your option) remove this 28 special exception, which will cause the skeleton and the resulting 29 Bison output files to be licensed under the GNU General Public 30 License without this special exception. 31 32 This special exception was added by the Free Software Foundation in 33 version 2.2 of Bison. */ 34 35 /* C LALR(1) parser skeleton written by Richard Stallman, by 36 simplifying the original so-called "semantic" parser. */ 37 38 /* All symbols defined below should begin with yy or YY, to avoid 39 infringing on user name space. This should be done even for local 40 variables, as they might otherwise be expanded by user macros. 41 There are some unavoidable exceptions within include files to 42 define necessary library symbols; they are noted "INFRINGES ON 43 USER NAME SPACE" below. */ 44 45 /* Identify Bison output. */ 46 #define YYBISON 1 47 48 /* Bison version. */ 49 #define YYBISON_VERSION "2.4.1" 50 51 /* Skeleton name. */ 52 #define YYSKELETON_NAME "yacc.c" 53 54 /* Pure parsers. */ 55 #define YYPURE 0 56 57 /* Push parsers. */ 58 #define YYPUSH 0 59 60 /* Pull parsers. */ 61 #define YYPULL 1 62 63 /* Using locations. */ 64 #define YYLSP_NEEDED 0 65 66 67 68 /* Copy the first part of user declarations. */ 69 70 /* Line 189 of yacc.c */ 71 #line 1 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 72 73 /****************************************************************************** 74 * 75 * Module Name: prparser.y - Bison input file for preprocessor parser 76 * 77 *****************************************************************************/ 78 79 /* 80 * Copyright (C) 2000 - 2025, Intel Corp. 81 * All rights reserved. 82 * 83 * Redistribution and use in source and binary forms, with or without 84 * modification, are permitted provided that the following conditions 85 * are met: 86 * 1. Redistributions of source code must retain the above copyright 87 * notice, this list of conditions, and the following disclaimer, 88 * without modification. 89 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 90 * substantially similar to the "NO WARRANTY" disclaimer below 91 * ("Disclaimer") and any redistribution must be conditioned upon 92 * including a substantially similar Disclaimer requirement for further 93 * binary redistribution. 94 * 3. Neither the names of the above-listed copyright holders nor the names 95 * of any contributors may be used to endorse or promote products derived 96 * from this software without specific prior written permission. 97 * 98 * Alternatively, this software may be distributed under the terms of the 99 * GNU General Public License ("GPL") version 2 as published by the Free 100 * Software Foundation. 101 * 102 * NO WARRANTY 103 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 104 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 105 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 106 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 107 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 108 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 109 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 110 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 111 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 112 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 113 * POSSIBILITY OF SUCH DAMAGES. 114 */ 115 116 #include "aslcompiler.h" 117 118 #define _COMPONENT ASL_PREPROCESSOR 119 ACPI_MODULE_NAME ("prparser") 120 121 void * AslLocalAllocate (unsigned int Size); 122 123 /* Bison/yacc configuration */ 124 125 #undef alloca 126 #define alloca AslLocalAllocate 127 128 int PrParserlex (void); 129 int PrParserparse (void); 130 void PrParsererror (char const *msg); 131 extern char *PrParsertext; 132 133 UINT64 PrParserResult; /* Expression return value */ 134 135 /* Bison/yacc configuration */ 136 137 #define yytname PrParsername 138 #define YYDEBUG 1 /* Enable debug output */ 139 #define YYERROR_VERBOSE 1 /* Verbose error messages */ 140 #define YYFLAG -32768 141 142 /* Define YYMALLOC/YYFREE to prevent redefinition errors */ 143 144 #define YYMALLOC malloc 145 #define YYFREE free 146 147 148 /* Line 189 of yacc.c */ 149 #line 258 "prparser.tab.c" 150 151 /* Enabling traces. */ 152 #ifndef YYDEBUG 153 # define YYDEBUG 0 154 #endif 155 156 /* Enabling verbose error messages. */ 157 #ifdef YYERROR_VERBOSE 158 # undef YYERROR_VERBOSE 159 # define YYERROR_VERBOSE 1 160 #else 161 # define YYERROR_VERBOSE 0 162 #endif 163 164 /* Enabling the token table. */ 165 #ifndef YYTOKEN_TABLE 166 # define YYTOKEN_TABLE 0 167 #endif 168 169 170 /* Tokens. */ 171 #ifndef YYTOKENTYPE 172 # define YYTOKENTYPE 173 /* Put the tokens into the symbol table, so that GDB and other debuggers 174 know about them. */ 175 enum yytokentype { 176 EXPOP_EOF = 258, 177 EXPOP_NEW_LINE = 259, 178 EXPOP_NUMBER = 260, 179 EXPOP_HEX_NUMBER = 261, 180 EXPOP_RESERVED1 = 262, 181 EXPOP_RESERVED2 = 263, 182 EXPOP_PAREN_OPEN = 264, 183 EXPOP_PAREN_CLOSE = 265, 184 EXPOP_LOGICAL_OR = 266, 185 EXPOP_LOGICAL_AND = 267, 186 EXPOP_OR = 268, 187 EXPOP_XOR = 269, 188 EXPOP_AND = 270, 189 EXPOP_NOT_EQUAL = 271, 190 EXPOP_EQUAL = 272, 191 EXPOP_LESS_EQUAL = 273, 192 EXPOP_GREATER_EQUAL = 274, 193 EXPOP_LESS = 275, 194 EXPOP_GREATER = 276, 195 EXPOP_SHIFT_LEFT = 277, 196 EXPOP_SHIFT_RIGHT = 278, 197 EXPOP_SUBTRACT = 279, 198 EXPOP_ADD = 280, 199 EXPOP_MODULO = 281, 200 EXPOP_DIVIDE = 282, 201 EXPOP_MULTIPLY = 283, 202 EXPOP_LOGICAL_NOT = 284, 203 EXPOP_ONES_COMPLIMENT = 285, 204 EXPOP_DEFINE = 286, 205 EXPOP_IDENTIFIER = 287 206 }; 207 #endif 208 209 210 211 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 212 typedef union YYSTYPE 213 { 214 215 /* Line 214 of yacc.c */ 216 #line 186 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 217 218 UINT64 value; 219 UINT32 op; 220 char *str; 221 222 223 224 /* Line 214 of yacc.c */ 225 #line 334 "prparser.tab.c" 226 } YYSTYPE; 227 # define YYSTYPE_IS_TRIVIAL 1 228 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 229 # define YYSTYPE_IS_DECLARED 1 230 #endif 231 232 233 /* Copy the second part of user declarations. */ 234 235 236 /* Line 264 of yacc.c */ 237 #line 346 "prparser.tab.c" 238 239 #ifdef short 240 # undef short 241 #endif 242 243 #ifdef YYTYPE_UINT8 244 typedef YYTYPE_UINT8 yytype_uint8; 245 #else 246 typedef unsigned char yytype_uint8; 247 #endif 248 249 #ifdef YYTYPE_INT8 250 typedef YYTYPE_INT8 yytype_int8; 251 #elif (defined __STDC__ || defined __C99__FUNC__ \ 252 || defined __cplusplus || defined _MSC_VER) 253 typedef signed char yytype_int8; 254 #else 255 typedef short int yytype_int8; 256 #endif 257 258 #ifdef YYTYPE_UINT16 259 typedef YYTYPE_UINT16 yytype_uint16; 260 #else 261 typedef unsigned short int yytype_uint16; 262 #endif 263 264 #ifdef YYTYPE_INT16 265 typedef YYTYPE_INT16 yytype_int16; 266 #else 267 typedef short int yytype_int16; 268 #endif 269 270 #ifndef YYSIZE_T 271 # ifdef __SIZE_TYPE__ 272 # define YYSIZE_T __SIZE_TYPE__ 273 # elif defined size_t 274 # define YYSIZE_T size_t 275 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 276 || defined __cplusplus || defined _MSC_VER) 277 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 278 # define YYSIZE_T size_t 279 # else 280 # define YYSIZE_T unsigned int 281 # endif 282 #endif 283 284 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 285 286 #ifndef YY_ 287 # if YYENABLE_NLS 288 # if ENABLE_NLS 289 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 290 # define YY_(msgid) dgettext ("bison-runtime", msgid) 291 # endif 292 # endif 293 # ifndef YY_ 294 # define YY_(msgid) msgid 295 # endif 296 #endif 297 298 /* Suppress unused-variable warnings by "using" E. */ 299 #if ! defined lint || defined __GNUC__ 300 # define YYUSE(e) ((void) (e)) 301 #else 302 # define YYUSE(e) /* empty */ 303 #endif 304 305 /* Identity function, used to suppress warnings about constant conditions. */ 306 #ifndef lint 307 # define YYID(n) (n) 308 #else 309 #if (defined __STDC__ || defined __C99__FUNC__ \ 310 || defined __cplusplus || defined _MSC_VER) 311 static int 312 YYID (int yyi) 313 #else 314 static int 315 YYID (yyi) 316 int yyi; 317 #endif 318 { 319 return yyi; 320 } 321 #endif 322 323 #if ! defined yyoverflow || YYERROR_VERBOSE 324 325 /* The parser invokes alloca or malloc; define the necessary symbols. */ 326 327 # ifdef YYSTACK_USE_ALLOCA 328 # if YYSTACK_USE_ALLOCA 329 # ifdef __GNUC__ 330 # define YYSTACK_ALLOC __builtin_alloca 331 # elif defined __BUILTIN_VA_ARG_INCR 332 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 333 # elif defined _AIX 334 # define YYSTACK_ALLOC __alloca 335 # elif defined _MSC_VER 336 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 337 # define alloca _alloca 338 # else 339 # define YYSTACK_ALLOC alloca 340 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 341 || defined __cplusplus || defined _MSC_VER) 342 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 343 # ifndef _STDLIB_H 344 # define _STDLIB_H 1 345 # endif 346 # endif 347 # endif 348 # endif 349 # endif 350 351 # ifdef YYSTACK_ALLOC 352 /* Pacify GCC's `empty if-body' warning. */ 353 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 354 # ifndef YYSTACK_ALLOC_MAXIMUM 355 /* The OS might guarantee only one guard page at the bottom of the stack, 356 and a page size can be as small as 4096 bytes. So we cannot safely 357 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 358 to allow for a few compiler-allocated temporary stack slots. */ 359 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 360 # endif 361 # else 362 # define YYSTACK_ALLOC YYMALLOC 363 # define YYSTACK_FREE YYFREE 364 # ifndef YYSTACK_ALLOC_MAXIMUM 365 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 366 # endif 367 # if (defined __cplusplus && ! defined _STDLIB_H \ 368 && ! ((defined YYMALLOC || defined malloc) \ 369 && (defined YYFREE || defined free))) 370 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 371 # ifndef _STDLIB_H 372 # define _STDLIB_H 1 373 # endif 374 # endif 375 # ifndef YYMALLOC 376 # define YYMALLOC malloc 377 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 378 || defined __cplusplus || defined _MSC_VER) 379 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 380 # endif 381 # endif 382 # ifndef YYFREE 383 # define YYFREE free 384 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 385 || defined __cplusplus || defined _MSC_VER) 386 void free (void *); /* INFRINGES ON USER NAME SPACE */ 387 # endif 388 # endif 389 # endif 390 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 391 392 393 #if (! defined yyoverflow \ 394 && (! defined __cplusplus \ 395 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 396 397 /* A type that is properly aligned for any stack member. */ 398 union yyalloc 399 { 400 yytype_int16 yyss_alloc; 401 YYSTYPE yyvs_alloc; 402 }; 403 404 /* The size of the maximum gap between one aligned stack and the next. */ 405 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 406 407 /* The size of an array large to enough to hold all stacks, each with 408 N elements. */ 409 # define YYSTACK_BYTES(N) \ 410 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 411 + YYSTACK_GAP_MAXIMUM) 412 413 /* Copy COUNT objects from FROM to TO. The source and destination do 414 not overlap. */ 415 # ifndef YYCOPY 416 # if defined __GNUC__ && 1 < __GNUC__ 417 # define YYCOPY(To, From, Count) \ 418 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 419 # else 420 # define YYCOPY(To, From, Count) \ 421 do \ 422 { \ 423 YYSIZE_T yyi; \ 424 for (yyi = 0; yyi < (Count); yyi++) \ 425 (To)[yyi] = (From)[yyi]; \ 426 } \ 427 while (YYID (0)) 428 # endif 429 # endif 430 431 /* Relocate STACK from its old location to the new one. The 432 local variables YYSIZE and YYSTACKSIZE give the old and new number of 433 elements in the stack, and YYPTR gives the new location of the 434 stack. Advance YYPTR to a properly aligned location for the next 435 stack. */ 436 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 437 do \ 438 { \ 439 YYSIZE_T yynewbytes; \ 440 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 441 Stack = &yyptr->Stack_alloc; \ 442 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 443 yyptr += yynewbytes / sizeof (*yyptr); \ 444 } \ 445 while (YYID (0)) 446 447 #endif 448 449 /* YYFINAL -- State number of the termination state. */ 450 #define YYFINAL 15 451 /* YYLAST -- Last index in YYTABLE. */ 452 #define YYLAST 175 453 454 /* YYNTOKENS -- Number of terminals. */ 455 #define YYNTOKENS 33 456 /* YYNNTS -- Number of nonterminals. */ 457 #define YYNNTS 3 458 /* YYNRULES -- Number of rules. */ 459 #define YYNRULES 29 460 /* YYNRULES -- Number of states. */ 461 #define YYNSTATES 57 462 463 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 464 #define YYUNDEFTOK 2 465 #define YYMAXUTOK 287 466 467 #define YYTRANSLATE(YYX) \ 468 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 469 470 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 471 static const yytype_uint8 yytranslate[] = 472 { 473 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 474 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 475 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 476 2, 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, 2, 2, 2, 2, 488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 499 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 500 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 501 25, 26, 27, 28, 29, 30, 31, 32 502 }; 503 504 #if YYDEBUG 505 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 506 YYRHS. */ 507 static const yytype_uint8 yyprhs[] = 508 { 509 0, 0, 3, 6, 9, 12, 15, 19, 23, 27, 510 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 511 71, 75, 79, 83, 87, 91, 96, 99, 101, 103 512 }; 513 514 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 515 static const yytype_int8 yyrhs[] = 516 { 517 34, 0, -1, 35, 4, -1, 35, 3, -1, 29, 518 35, -1, 30, 35, -1, 35, 28, 35, -1, 35, 519 27, 35, -1, 35, 26, 35, -1, 35, 25, 35, 520 -1, 35, 24, 35, -1, 35, 23, 35, -1, 35, 521 22, 35, -1, 35, 21, 35, -1, 35, 20, 35, 522 -1, 35, 19, 35, -1, 35, 18, 35, -1, 35, 523 17, 35, -1, 35, 16, 35, -1, 35, 15, 35, 524 -1, 35, 14, 35, -1, 35, 13, 35, -1, 35, 525 12, 35, -1, 35, 11, 35, -1, 9, 35, 10, 526 -1, 31, 9, 32, 10, -1, 31, 32, -1, 32, 527 -1, 5, -1, 6, -1 528 }; 529 530 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 531 static const yytype_uint16 yyrline[] = 532 { 533 0, 244, 244, 245, 252, 253, 257, 258, 259, 260, 534 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 535 271, 272, 273, 274, 278, 283, 286, 288, 292, 296 536 }; 537 #endif 538 539 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 540 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 541 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 542 static const char *const yytname[] = 543 { 544 "$end", "error", "$undefined", "EXPOP_EOF", "EXPOP_NEW_LINE", 545 "EXPOP_NUMBER", "EXPOP_HEX_NUMBER", "EXPOP_RESERVED1", "EXPOP_RESERVED2", 546 "EXPOP_PAREN_OPEN", "EXPOP_PAREN_CLOSE", "EXPOP_LOGICAL_OR", 547 "EXPOP_LOGICAL_AND", "EXPOP_OR", "EXPOP_XOR", "EXPOP_AND", 548 "EXPOP_NOT_EQUAL", "EXPOP_EQUAL", "EXPOP_LESS_EQUAL", 549 "EXPOP_GREATER_EQUAL", "EXPOP_LESS", "EXPOP_GREATER", "EXPOP_SHIFT_LEFT", 550 "EXPOP_SHIFT_RIGHT", "EXPOP_SUBTRACT", "EXPOP_ADD", "EXPOP_MODULO", 551 "EXPOP_DIVIDE", "EXPOP_MULTIPLY", "EXPOP_LOGICAL_NOT", 552 "EXPOP_ONES_COMPLIMENT", "EXPOP_DEFINE", "EXPOP_IDENTIFIER", "$accept", 553 "Value", "Expression", 0 554 }; 555 #endif 556 557 # ifdef YYPRINT 558 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 559 token YYLEX-NUM. */ 560 static const yytype_uint16 yytoknum[] = 561 { 562 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 563 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 564 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 565 285, 286, 287 566 }; 567 # endif 568 569 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 570 static const yytype_uint8 yyr1[] = 571 { 572 0, 33, 34, 34, 35, 35, 35, 35, 35, 35, 573 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 574 35, 35, 35, 35, 35, 35, 35, 35, 35, 35 575 }; 576 577 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 578 static const yytype_uint8 yyr2[] = 579 { 580 0, 2, 2, 2, 2, 2, 3, 3, 3, 3, 581 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 582 3, 3, 3, 3, 3, 4, 2, 1, 1, 1 583 }; 584 585 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 586 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 587 means the default is an error. */ 588 static const yytype_uint8 yydefact[] = 589 { 590 0, 28, 29, 0, 0, 0, 0, 27, 0, 0, 591 0, 4, 5, 0, 26, 1, 3, 2, 0, 0, 592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 593 0, 0, 0, 0, 0, 0, 24, 0, 23, 22, 594 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 595 11, 10, 9, 8, 7, 6, 25 596 }; 597 598 /* YYDEFGOTO[NTERM-NUM]. */ 599 static const yytype_int8 yydefgoto[] = 600 { 601 -1, 8, 9 602 }; 603 604 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 605 STATE-NUM. */ 606 #define YYPACT_NINF -22 607 static const yytype_int16 yypact[] = 608 { 609 4, -22, -22, 4, 4, 4, 31, -22, 8, 34, 610 54, -22, -22, -20, -22, -22, -22, -22, 4, 4, 611 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 612 4, 4, 4, 4, 4, 4, -22, 1, 71, 87, 613 102, 116, 129, 140, 140, 147, 147, 147, 147, -21, 614 -21, 15, 15, -22, -22, -22, -22 615 }; 616 617 /* YYPGOTO[NTERM-NUM]. */ 618 static const yytype_int8 yypgoto[] = 619 { 620 -22, -22, -3 621 }; 622 623 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 624 positive, shift that token. If negative, reduce the rule which 625 number is the opposite. If zero, do what YYDEFACT says. 626 If YYTABLE_NINF, syntax error. */ 627 #define YYTABLE_NINF -1 628 static const yytype_uint8 yytable[] = 629 { 630 10, 11, 12, 31, 32, 33, 34, 35, 15, 1, 631 2, 56, 37, 3, 0, 38, 39, 40, 41, 42, 632 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 633 53, 54, 55, 4, 5, 6, 7, 16, 17, 0, 634 13, 33, 34, 35, 0, 18, 19, 20, 21, 22, 635 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 636 33, 34, 35, 14, 36, 18, 19, 20, 21, 22, 637 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 638 33, 34, 35, 19, 20, 21, 22, 23, 24, 25, 639 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 640 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 641 30, 31, 32, 33, 34, 35, 21, 22, 23, 24, 642 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 643 35, 22, 23, 24, 25, 26, 27, 28, 29, 30, 644 31, 32, 33, 34, 35, 23, 24, 25, 26, 27, 645 28, 29, 30, 31, 32, 33, 34, 35, 25, 26, 646 27, 28, 29, 30, 31, 32, 33, 34, 35, 29, 647 30, 31, 32, 33, 34, 35 648 }; 649 650 static const yytype_int8 yycheck[] = 651 { 652 3, 4, 5, 24, 25, 26, 27, 28, 0, 5, 653 6, 10, 32, 9, -1, 18, 19, 20, 21, 22, 654 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 655 33, 34, 35, 29, 30, 31, 32, 3, 4, -1, 656 9, 26, 27, 28, -1, 11, 12, 13, 14, 15, 657 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 658 26, 27, 28, 32, 10, 11, 12, 13, 14, 15, 659 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 660 26, 27, 28, 12, 13, 14, 15, 16, 17, 18, 661 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 662 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 663 23, 24, 25, 26, 27, 28, 14, 15, 16, 17, 664 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 665 28, 15, 16, 17, 18, 19, 20, 21, 22, 23, 666 24, 25, 26, 27, 28, 16, 17, 18, 19, 20, 667 21, 22, 23, 24, 25, 26, 27, 28, 18, 19, 668 20, 21, 22, 23, 24, 25, 26, 27, 28, 22, 669 23, 24, 25, 26, 27, 28 670 }; 671 672 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 673 symbol of state STATE-NUM. */ 674 static const yytype_uint8 yystos[] = 675 { 676 0, 5, 6, 9, 29, 30, 31, 32, 34, 35, 677 35, 35, 35, 9, 32, 0, 3, 4, 11, 12, 678 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 679 23, 24, 25, 26, 27, 28, 10, 32, 35, 35, 680 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 681 35, 35, 35, 35, 35, 35, 10 682 }; 683 684 #define yyerrok (yyerrstatus = 0) 685 #define yyclearin (yychar = YYEMPTY) 686 #define YYEMPTY (-2) 687 #define YYEOF 0 688 689 #define YYACCEPT goto yyacceptlab 690 #define YYABORT goto yyabortlab 691 #define YYERROR goto yyerrorlab 692 693 694 /* Like YYERROR except do call yyerror. This remains here temporarily 695 to ease the transition to the new meaning of YYERROR, for GCC. 696 Once GCC version 2 has supplanted version 1, this can go. */ 697 698 #define YYFAIL goto yyerrlab 699 700 #define YYRECOVERING() (!!yyerrstatus) 701 702 #define YYBACKUP(Token, Value) \ 703 do \ 704 if (yychar == YYEMPTY && yylen == 1) \ 705 { \ 706 yychar = (Token); \ 707 yylval = (Value); \ 708 yytoken = YYTRANSLATE (yychar); \ 709 YYPOPSTACK (1); \ 710 goto yybackup; \ 711 } \ 712 else \ 713 { \ 714 yyerror (YY_("syntax error: cannot back up")); \ 715 YYERROR; \ 716 } \ 717 while (YYID (0)) 718 719 720 #define YYTERROR 1 721 #define YYERRCODE 256 722 723 724 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 725 If N is 0, then set CURRENT to the empty location which ends 726 the previous symbol: RHS[0] (always defined). */ 727 728 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 729 #ifndef YYLLOC_DEFAULT 730 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 731 do \ 732 if (YYID (N)) \ 733 { \ 734 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 735 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 736 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 737 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 738 } \ 739 else \ 740 { \ 741 (Current).first_line = (Current).last_line = \ 742 YYRHSLOC (Rhs, 0).last_line; \ 743 (Current).first_column = (Current).last_column = \ 744 YYRHSLOC (Rhs, 0).last_column; \ 745 } \ 746 while (YYID (0)) 747 #endif 748 749 750 /* YY_LOCATION_PRINT -- Print the location on the stream. 751 This macro was not mandated originally: define only if we know 752 we won't break user code: when these are the locations we know. */ 753 754 #ifndef YY_LOCATION_PRINT 755 # if YYLTYPE_IS_TRIVIAL 756 # define YY_LOCATION_PRINT(File, Loc) \ 757 fprintf (File, "%d.%d-%d.%d", \ 758 (Loc).first_line, (Loc).first_column, \ 759 (Loc).last_line, (Loc).last_column) 760 # else 761 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 762 # endif 763 #endif 764 765 766 /* YYLEX -- calling `yylex' with the right arguments. */ 767 768 #ifdef YYLEX_PARAM 769 # define YYLEX yylex (YYLEX_PARAM) 770 #else 771 # define YYLEX yylex () 772 #endif 773 774 /* Enable debugging if requested. */ 775 #if YYDEBUG 776 777 # ifndef YYFPRINTF 778 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 779 # define YYFPRINTF fprintf 780 # endif 781 782 # define YYDPRINTF(Args) \ 783 do { \ 784 if (yydebug) \ 785 YYFPRINTF Args; \ 786 } while (YYID (0)) 787 788 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 789 do { \ 790 if (yydebug) \ 791 { \ 792 YYFPRINTF (stderr, "%s ", Title); \ 793 yy_symbol_print (stderr, \ 794 Type, Value); \ 795 YYFPRINTF (stderr, "\n"); \ 796 } \ 797 } while (YYID (0)) 798 799 800 /*--------------------------------. 801 | Print this symbol on YYOUTPUT. | 802 `--------------------------------*/ 803 804 /*ARGSUSED*/ 805 #if (defined __STDC__ || defined __C99__FUNC__ \ 806 || defined __cplusplus || defined _MSC_VER) 807 static void 808 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 809 #else 810 static void 811 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 812 FILE *yyoutput; 813 int yytype; 814 YYSTYPE const * const yyvaluep; 815 #endif 816 { 817 if (!yyvaluep) 818 return; 819 # ifdef YYPRINT 820 if (yytype < YYNTOKENS) 821 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 822 # else 823 YYUSE (yyoutput); 824 # endif 825 switch (yytype) 826 { 827 default: 828 break; 829 } 830 } 831 832 833 /*--------------------------------. 834 | Print this symbol on YYOUTPUT. | 835 `--------------------------------*/ 836 837 #if (defined __STDC__ || defined __C99__FUNC__ \ 838 || defined __cplusplus || defined _MSC_VER) 839 static void 840 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 841 #else 842 static void 843 yy_symbol_print (yyoutput, yytype, yyvaluep) 844 FILE *yyoutput; 845 int yytype; 846 YYSTYPE const * const yyvaluep; 847 #endif 848 { 849 if (yytype < YYNTOKENS) 850 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 851 else 852 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 853 854 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 855 YYFPRINTF (yyoutput, ")"); 856 } 857 858 /*------------------------------------------------------------------. 859 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 860 | TOP (included). | 861 `------------------------------------------------------------------*/ 862 863 #if (defined __STDC__ || defined __C99__FUNC__ \ 864 || defined __cplusplus || defined _MSC_VER) 865 static void 866 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 867 #else 868 static void 869 yy_stack_print (yybottom, yytop) 870 yytype_int16 *yybottom; 871 yytype_int16 *yytop; 872 #endif 873 { 874 YYFPRINTF (stderr, "Stack now"); 875 for (; yybottom <= yytop; yybottom++) 876 { 877 int yybot = *yybottom; 878 YYFPRINTF (stderr, " %d", yybot); 879 } 880 YYFPRINTF (stderr, "\n"); 881 } 882 883 # define YY_STACK_PRINT(Bottom, Top) \ 884 do { \ 885 if (yydebug) \ 886 yy_stack_print ((Bottom), (Top)); \ 887 } while (YYID (0)) 888 889 890 /*------------------------------------------------. 891 | Report that the YYRULE is going to be reduced. | 892 `------------------------------------------------*/ 893 894 #if (defined __STDC__ || defined __C99__FUNC__ \ 895 || defined __cplusplus || defined _MSC_VER) 896 static void 897 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 898 #else 899 static void 900 yy_reduce_print (yyvsp, yyrule) 901 YYSTYPE *yyvsp; 902 int yyrule; 903 #endif 904 { 905 int yynrhs = yyr2[yyrule]; 906 int yyi; 907 unsigned long int yylno = yyrline[yyrule]; 908 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 909 yyrule - 1, yylno); 910 /* The symbols being reduced. */ 911 for (yyi = 0; yyi < yynrhs; yyi++) 912 { 913 YYFPRINTF (stderr, " $%d = ", yyi + 1); 914 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 915 &(yyvsp[(yyi + 1) - (yynrhs)]) 916 ); 917 YYFPRINTF (stderr, "\n"); 918 } 919 } 920 921 # define YY_REDUCE_PRINT(Rule) \ 922 do { \ 923 if (yydebug) \ 924 yy_reduce_print (yyvsp, Rule); \ 925 } while (YYID (0)) 926 927 /* Nonzero means print parse trace. It is left uninitialized so that 928 multiple parsers can coexist. */ 929 int yydebug; 930 #else /* !YYDEBUG */ 931 # define YYDPRINTF(Args) 932 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 933 # define YY_STACK_PRINT(Bottom, Top) 934 # define YY_REDUCE_PRINT(Rule) 935 #endif /* !YYDEBUG */ 936 937 938 /* YYINITDEPTH -- initial size of the parser's stacks. */ 939 #ifndef YYINITDEPTH 940 # define YYINITDEPTH 200 941 #endif 942 943 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 944 if the built-in stack extension method is used). 945 946 Do not make this value too large; the results are undefined if 947 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 948 evaluated with infinite-precision integer arithmetic. */ 949 950 #ifndef YYMAXDEPTH 951 # define YYMAXDEPTH 10000 952 #endif 953 954 955 957 #if YYERROR_VERBOSE 958 959 # ifndef yystrlen 960 # if defined __GLIBC__ && defined _STRING_H 961 # define yystrlen strlen 962 # else 963 /* Return the length of YYSTR. */ 964 #if (defined __STDC__ || defined __C99__FUNC__ \ 965 || defined __cplusplus || defined _MSC_VER) 966 static YYSIZE_T 967 yystrlen (const char *yystr) 968 #else 969 static YYSIZE_T 970 yystrlen (yystr) 971 const char *yystr; 972 #endif 973 { 974 YYSIZE_T yylen; 975 for (yylen = 0; yystr[yylen]; yylen++) 976 continue; 977 return yylen; 978 } 979 # endif 980 # endif 981 982 # ifndef yystpcpy 983 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 984 # define yystpcpy stpcpy 985 # else 986 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 987 YYDEST. */ 988 #if (defined __STDC__ || defined __C99__FUNC__ \ 989 || defined __cplusplus || defined _MSC_VER) 990 static char * 991 yystpcpy (char *yydest, const char *yysrc) 992 #else 993 static char * 994 yystpcpy (yydest, yysrc) 995 char *yydest; 996 const char *yysrc; 997 #endif 998 { 999 char *yyd = yydest; 1000 const char *yys = yysrc; 1001 1002 while ((*yyd++ = *yys++) != '\0') 1003 continue; 1004 1005 return yyd - 1; 1006 } 1007 # endif 1008 # endif 1009 1010 # ifndef yytnamerr 1011 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1012 quotes and backslashes, so that it's suitable for yyerror. The 1013 heuristic is that double-quoting is unnecessary unless the string 1014 contains an apostrophe, a comma, or backslash (other than 1015 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1016 null, do not copy; instead, return the length of what the result 1017 would have been. */ 1018 static YYSIZE_T 1019 yytnamerr (char *yyres, const char *yystr) 1020 { 1021 if (*yystr == '"') 1022 { 1023 YYSIZE_T yyn = 0; 1024 char const *yyp = yystr; 1025 1026 for (;;) 1027 switch (*++yyp) 1028 { 1029 case '\'': 1030 case ',': 1031 goto do_not_strip_quotes; 1032 1033 case '\\': 1034 if (*++yyp != '\\') 1035 goto do_not_strip_quotes; 1036 /* Fall through. */ 1037 default: 1038 if (yyres) 1039 yyres[yyn] = *yyp; 1040 yyn++; 1041 break; 1042 1043 case '"': 1044 if (yyres) 1045 yyres[yyn] = '\0'; 1046 return yyn; 1047 } 1048 do_not_strip_quotes: ; 1049 } 1050 1051 if (! yyres) 1052 return yystrlen (yystr); 1053 1054 return yystpcpy (yyres, yystr) - yyres; 1055 } 1056 # endif 1057 1058 /* Copy into YYRESULT an error message about the unexpected token 1059 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1060 including the terminating null byte. If YYRESULT is null, do not 1061 copy anything; just return the number of bytes that would be 1062 copied. As a special case, return 0 if an ordinary "syntax error" 1063 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1064 size calculation. */ 1065 static YYSIZE_T 1066 yysyntax_error (char *yyresult, int yystate, int yychar) 1067 { 1068 int yyn = yypact[yystate]; 1069 1070 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1071 return 0; 1072 else 1073 { 1074 int yytype = YYTRANSLATE (yychar); 1075 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1076 YYSIZE_T yysize = yysize0; 1077 YYSIZE_T yysize1; 1078 int yysize_overflow = 0; 1079 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1080 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1081 int yyx; 1082 1083 # if 0 1084 /* This is so xgettext sees the translatable formats that are 1085 constructed on the fly. */ 1086 YY_("syntax error, unexpected %s"); 1087 YY_("syntax error, unexpected %s, expecting %s"); 1088 YY_("syntax error, unexpected %s, expecting %s or %s"); 1089 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1090 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1091 # endif 1092 char *yyfmt; 1093 char const *yyf; 1094 static char const yyunexpected[] = "syntax error, unexpected %s"; 1095 static char const yyexpecting[] = ", expecting %s"; 1096 static char const yyor[] = " or %s"; 1097 char yyformat[sizeof yyunexpected 1098 + sizeof yyexpecting - 1 1099 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1100 * (sizeof yyor - 1))]; 1101 char const *yyprefix = yyexpecting; 1102 1103 /* Start YYX at -YYN if negative to avoid negative indexes in 1104 YYCHECK. */ 1105 int yyxbegin = yyn < 0 ? -yyn : 0; 1106 1107 /* Stay within bounds of both yycheck and yytname. */ 1108 int yychecklim = YYLAST - yyn + 1; 1109 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1110 int yycount = 1; 1111 1112 yyarg[0] = yytname[yytype]; 1113 yyfmt = yystpcpy (yyformat, yyunexpected); 1114 1115 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1116 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1117 { 1118 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1119 { 1120 yycount = 1; 1121 yysize = yysize0; 1122 yyformat[sizeof yyunexpected - 1] = '\0'; 1123 break; 1124 } 1125 yyarg[yycount++] = yytname[yyx]; 1126 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1127 yysize_overflow |= (yysize1 < yysize); 1128 yysize = yysize1; 1129 yyfmt = yystpcpy (yyfmt, yyprefix); 1130 yyprefix = yyor; 1131 } 1132 1133 yyf = YY_(yyformat); 1134 yysize1 = yysize + yystrlen (yyf); 1135 yysize_overflow |= (yysize1 < yysize); 1136 yysize = yysize1; 1137 1138 if (yysize_overflow) 1139 return YYSIZE_MAXIMUM; 1140 1141 if (yyresult) 1142 { 1143 /* Avoid sprintf, as that infringes on the user's name space. 1144 Don't have undefined behavior even if the translation 1145 produced a string with the wrong number of "%s"s. */ 1146 char *yyp = yyresult; 1147 int yyi = 0; 1148 while ((*yyp = *yyf) != '\0') 1149 { 1150 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1151 { 1152 yyp += yytnamerr (yyp, yyarg[yyi++]); 1153 yyf += 2; 1154 } 1155 else 1156 { 1157 yyp++; 1158 yyf++; 1159 } 1160 } 1161 } 1162 return yysize; 1163 } 1164 } 1165 #endif /* YYERROR_VERBOSE */ 1166 1167 1169 /*-----------------------------------------------. 1170 | Release the memory associated to this symbol. | 1171 `-----------------------------------------------*/ 1172 1173 /*ARGSUSED*/ 1174 #if (defined __STDC__ || defined __C99__FUNC__ \ 1175 || defined __cplusplus || defined _MSC_VER) 1176 static void 1177 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1178 #else 1179 static void 1180 yydestruct (yymsg, yytype, yyvaluep) 1181 const char *yymsg; 1182 int yytype; 1183 YYSTYPE *yyvaluep; 1184 #endif 1185 { 1186 YYUSE (yyvaluep); 1187 1188 if (!yymsg) 1189 yymsg = "Deleting"; 1190 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1191 1192 switch (yytype) 1193 { 1194 1195 default: 1196 break; 1197 } 1198 } 1199 1200 /* Prevent warnings from -Wmissing-prototypes. */ 1201 #ifdef YYPARSE_PARAM 1202 #if defined __STDC__ || defined __cplusplus 1203 int yyparse (void *YYPARSE_PARAM); 1204 #else 1205 int yyparse (); 1206 #endif 1207 #else /* ! YYPARSE_PARAM */ 1208 #if defined __STDC__ || defined __cplusplus 1209 int yyparse (void); 1210 #else 1211 int yyparse (); 1212 #endif 1213 #endif /* ! YYPARSE_PARAM */ 1214 1215 1216 /* The lookahead symbol. */ 1217 int yychar; 1218 1219 /* The semantic value of the lookahead symbol. */ 1220 YYSTYPE yylval; 1221 1222 /* Number of syntax errors so far. */ 1223 int yynerrs; 1224 1225 1226 1227 /*-------------------------. 1228 | yyparse or yypush_parse. | 1229 `-------------------------*/ 1230 1231 #ifdef YYPARSE_PARAM 1232 #if (defined __STDC__ || defined __C99__FUNC__ \ 1233 || defined __cplusplus || defined _MSC_VER) 1234 int 1235 yyparse (void *YYPARSE_PARAM) 1236 #else 1237 int 1238 yyparse (YYPARSE_PARAM) 1239 void *YYPARSE_PARAM; 1240 #endif 1241 #else /* ! YYPARSE_PARAM */ 1242 #if (defined __STDC__ || defined __C99__FUNC__ \ 1243 || defined __cplusplus || defined _MSC_VER) 1244 int 1245 yyparse (void) 1246 #else 1247 int 1248 yyparse () 1249 1250 #endif 1251 #endif 1252 { 1253 1254 1255 int yystate; 1256 /* Number of tokens to shift before error messages enabled. */ 1257 int yyerrstatus; 1258 1259 /* The stacks and their tools: 1260 `yyss': related to states. 1261 `yyvs': related to semantic values. 1262 1263 Refer to the stacks thru separate pointers, to allow yyoverflow 1264 to reallocate them elsewhere. */ 1265 1266 /* The state stack. */ 1267 yytype_int16 yyssa[YYINITDEPTH]; 1268 yytype_int16 *yyss; 1269 yytype_int16 *yyssp; 1270 1271 /* The semantic value stack. */ 1272 YYSTYPE yyvsa[YYINITDEPTH]; 1273 YYSTYPE *yyvs; 1274 YYSTYPE *yyvsp; 1275 1276 YYSIZE_T yystacksize; 1277 1278 int yyn; 1279 int yyresult; 1280 /* Lookahead token as an internal (translated) token number. */ 1281 int yytoken; 1282 /* The variables used to return semantic value and location from the 1283 action routines. */ 1284 YYSTYPE yyval; 1285 1286 #if YYERROR_VERBOSE 1287 /* Buffer for error messages, and its allocated size. */ 1288 char yymsgbuf[128]; 1289 char *yymsg = yymsgbuf; 1290 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1291 #endif 1292 1293 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1294 1295 /* The number of symbols on the RHS of the reduced rule. 1296 Keep to zero when no symbol should be popped. */ 1297 int yylen = 0; 1298 1299 yytoken = 0; 1300 yyss = yyssa; 1301 yyvs = yyvsa; 1302 yystacksize = YYINITDEPTH; 1303 1304 YYDPRINTF ((stderr, "Starting parse\n")); 1305 1306 yystate = 0; 1307 yyerrstatus = 0; 1308 yynerrs = 0; 1309 yychar = YYEMPTY; /* Cause a token to be read. */ 1310 1311 /* Initialize stack pointers. 1312 Waste one element of value and location stack 1313 so that they stay on the same level as the state stack. 1314 The wasted elements are never initialized. */ 1315 yyssp = yyss; 1316 yyvsp = yyvs; 1317 1318 goto yysetstate; 1319 1320 /*------------------------------------------------------------. 1321 | yynewstate -- Push a new state, which is found in yystate. | 1322 `------------------------------------------------------------*/ 1323 yynewstate: 1324 /* In all cases, when you get here, the value and location stacks 1325 have just been pushed. So pushing a state here evens the stacks. */ 1326 yyssp++; 1327 1328 yysetstate: 1329 *yyssp = yystate; 1330 1331 if (yyss + yystacksize - 1 <= yyssp) 1332 { 1333 /* Get the current used size of the three stacks, in elements. */ 1334 YYSIZE_T yysize = yyssp - yyss + 1; 1335 1336 #ifdef yyoverflow 1337 { 1338 /* Give user a chance to reallocate the stack. Use copies of 1339 these so that the &'s don't force the real ones into 1340 memory. */ 1341 YYSTYPE *yyvs1 = yyvs; 1342 yytype_int16 *yyss1 = yyss; 1343 1344 /* Each stack pointer address is followed by the size of the 1345 data in use in that stack, in bytes. This used to be a 1346 conditional around just the two extra args, but that might 1347 be undefined if yyoverflow is a macro. */ 1348 yyoverflow (YY_("memory exhausted"), 1349 &yyss1, yysize * sizeof (*yyssp), 1350 &yyvs1, yysize * sizeof (*yyvsp), 1351 &yystacksize); 1352 1353 yyss = yyss1; 1354 yyvs = yyvs1; 1355 } 1356 #else /* no yyoverflow */ 1357 # ifndef YYSTACK_RELOCATE 1358 goto yyexhaustedlab; 1359 # else 1360 /* Extend the stack our own way. */ 1361 if (YYMAXDEPTH <= yystacksize) 1362 goto yyexhaustedlab; 1363 yystacksize *= 2; 1364 if (YYMAXDEPTH < yystacksize) 1365 yystacksize = YYMAXDEPTH; 1366 1367 { 1368 yytype_int16 *yyss1 = yyss; 1369 union yyalloc *yyptr = 1370 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1371 if (! yyptr) 1372 goto yyexhaustedlab; 1373 YYSTACK_RELOCATE (yyss_alloc, yyss); 1374 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1375 # undef YYSTACK_RELOCATE 1376 if (yyss1 != yyssa) 1377 YYSTACK_FREE (yyss1); 1378 } 1379 # endif 1380 #endif /* no yyoverflow */ 1381 1382 yyssp = yyss + yysize - 1; 1383 yyvsp = yyvs + yysize - 1; 1384 1385 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1386 (unsigned long int) yystacksize)); 1387 1388 if (yyss + yystacksize - 1 <= yyssp) 1389 YYABORT; 1390 } 1391 1392 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1393 1394 if (yystate == YYFINAL) 1395 YYACCEPT; 1396 1397 goto yybackup; 1398 1399 /*-----------. 1400 | yybackup. | 1401 `-----------*/ 1402 yybackup: 1403 1404 /* Do appropriate processing given the current state. Read a 1405 lookahead token if we need one and don't already have one. */ 1406 1407 /* First try to decide what to do without reference to lookahead token. */ 1408 yyn = yypact[yystate]; 1409 if (yyn == YYPACT_NINF) 1410 goto yydefault; 1411 1412 /* Not known => get a lookahead token if don't already have one. */ 1413 1414 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1415 if (yychar == YYEMPTY) 1416 { 1417 YYDPRINTF ((stderr, "Reading a token: ")); 1418 yychar = YYLEX; 1419 } 1420 1421 if (yychar <= YYEOF) 1422 { 1423 yychar = yytoken = YYEOF; 1424 YYDPRINTF ((stderr, "Now at end of input.\n")); 1425 } 1426 else 1427 { 1428 yytoken = YYTRANSLATE (yychar); 1429 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1430 } 1431 1432 /* If the proper action on seeing token YYTOKEN is to reduce or to 1433 detect an error, take that action. */ 1434 yyn += yytoken; 1435 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1436 goto yydefault; 1437 yyn = yytable[yyn]; 1438 if (yyn <= 0) 1439 { 1440 if (yyn == 0 || yyn == YYTABLE_NINF) 1441 goto yyerrlab; 1442 yyn = -yyn; 1443 goto yyreduce; 1444 } 1445 1446 /* Count tokens shifted since error; after three, turn off error 1447 status. */ 1448 if (yyerrstatus) 1449 yyerrstatus--; 1450 1451 /* Shift the lookahead token. */ 1452 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1453 1454 /* Discard the shifted token. */ 1455 yychar = YYEMPTY; 1456 1457 yystate = yyn; 1458 *++yyvsp = yylval; 1459 1460 goto yynewstate; 1461 1462 1463 /*-----------------------------------------------------------. 1464 | yydefault -- do the default action for the current state. | 1465 `-----------------------------------------------------------*/ 1466 yydefault: 1467 yyn = yydefact[yystate]; 1468 if (yyn == 0) 1469 goto yyerrlab; 1470 goto yyreduce; 1471 1472 1473 /*-----------------------------. 1474 | yyreduce -- Do a reduction. | 1475 `-----------------------------*/ 1476 yyreduce: 1477 /* yyn is the number of a rule to reduce with. */ 1478 yylen = yyr2[yyn]; 1479 1480 /* If YYLEN is nonzero, implement the default value of the action: 1481 `$$ = $1'. 1482 1483 Otherwise, the following line sets YYVAL to garbage. 1484 This behavior is undocumented and Bison 1485 users should not rely upon it. Assigning to YYVAL 1486 unconditionally makes the parser a bit smaller, and it avoids a 1487 GCC warning that YYVAL may be used uninitialized. */ 1488 yyval = yyvsp[1-yylen]; 1489 1490 1491 YY_REDUCE_PRINT (yyn); 1492 switch (yyn) 1493 { 1494 case 2: 1495 1496 /* Line 1455 of yacc.c */ 1497 #line 244 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1498 { PrParserResult=(yyvsp[(1) - (2)].value); return 0; ;} 1499 break; 1500 1501 case 3: 1502 1503 /* Line 1455 of yacc.c */ 1504 #line 245 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1505 { PrParserResult=(yyvsp[(1) - (2)].value); return 0; ;} 1506 break; 1507 1508 case 4: 1509 1510 /* Line 1455 of yacc.c */ 1511 #line 252 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1512 { (yyval.value) = DtDoOperator ((yyvsp[(2) - (2)].value), EXPOP_LOGICAL_NOT, (yyvsp[(2) - (2)].value));;} 1513 break; 1514 1515 case 5: 1516 1517 /* Line 1455 of yacc.c */ 1518 #line 253 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1519 { (yyval.value) = DtDoOperator ((yyvsp[(2) - (2)].value), EXPOP_ONES_COMPLIMENT, (yyvsp[(2) - (2)].value));;} 1520 break; 1521 1522 case 6: 1523 1524 /* Line 1455 of yacc.c */ 1525 #line 257 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1526 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_MULTIPLY, (yyvsp[(3) - (3)].value));;} 1527 break; 1528 1529 case 7: 1530 1531 /* Line 1455 of yacc.c */ 1532 #line 258 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1533 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_DIVIDE, (yyvsp[(3) - (3)].value));;} 1534 break; 1535 1536 case 8: 1537 1538 /* Line 1455 of yacc.c */ 1539 #line 259 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1540 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_MODULO, (yyvsp[(3) - (3)].value));;} 1541 break; 1542 1543 case 9: 1544 1545 /* Line 1455 of yacc.c */ 1546 #line 260 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1547 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_ADD, (yyvsp[(3) - (3)].value));;} 1548 break; 1549 1550 case 10: 1551 1552 /* Line 1455 of yacc.c */ 1553 #line 261 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1554 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_SUBTRACT, (yyvsp[(3) - (3)].value));;} 1555 break; 1556 1557 case 11: 1558 1559 /* Line 1455 of yacc.c */ 1560 #line 262 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1561 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_SHIFT_RIGHT, (yyvsp[(3) - (3)].value));;} 1562 break; 1563 1564 case 12: 1565 1566 /* Line 1455 of yacc.c */ 1567 #line 263 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1568 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_SHIFT_LEFT, (yyvsp[(3) - (3)].value));;} 1569 break; 1570 1571 case 13: 1572 1573 /* Line 1455 of yacc.c */ 1574 #line 264 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1575 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_GREATER, (yyvsp[(3) - (3)].value));;} 1576 break; 1577 1578 case 14: 1579 1580 /* Line 1455 of yacc.c */ 1581 #line 265 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1582 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_LESS, (yyvsp[(3) - (3)].value));;} 1583 break; 1584 1585 case 15: 1586 1587 /* Line 1455 of yacc.c */ 1588 #line 266 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1589 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_GREATER_EQUAL, (yyvsp[(3) - (3)].value));;} 1590 break; 1591 1592 case 16: 1593 1594 /* Line 1455 of yacc.c */ 1595 #line 267 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1596 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_LESS_EQUAL, (yyvsp[(3) - (3)].value));;} 1597 break; 1598 1599 case 17: 1600 1601 /* Line 1455 of yacc.c */ 1602 #line 268 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1603 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_EQUAL, (yyvsp[(3) - (3)].value));;} 1604 break; 1605 1606 case 18: 1607 1608 /* Line 1455 of yacc.c */ 1609 #line 269 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1610 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_NOT_EQUAL, (yyvsp[(3) - (3)].value));;} 1611 break; 1612 1613 case 19: 1614 1615 /* Line 1455 of yacc.c */ 1616 #line 270 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1617 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_AND, (yyvsp[(3) - (3)].value));;} 1618 break; 1619 1620 case 20: 1621 1622 /* Line 1455 of yacc.c */ 1623 #line 271 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1624 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_XOR, (yyvsp[(3) - (3)].value));;} 1625 break; 1626 1627 case 21: 1628 1629 /* Line 1455 of yacc.c */ 1630 #line 272 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1631 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_OR, (yyvsp[(3) - (3)].value));;} 1632 break; 1633 1634 case 22: 1635 1636 /* Line 1455 of yacc.c */ 1637 #line 273 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1638 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_LOGICAL_AND, (yyvsp[(3) - (3)].value));;} 1639 break; 1640 1641 case 23: 1642 1643 /* Line 1455 of yacc.c */ 1644 #line 274 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1645 { (yyval.value) = DtDoOperator ((yyvsp[(1) - (3)].value), EXPOP_LOGICAL_OR, (yyvsp[(3) - (3)].value));;} 1646 break; 1647 1648 case 24: 1649 1650 /* Line 1455 of yacc.c */ 1651 #line 279 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1652 { (yyval.value) = (yyvsp[(2) - (3)].value);;} 1653 break; 1654 1655 case 25: 1656 1657 /* Line 1455 of yacc.c */ 1658 #line 284 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1659 { (yyval.value) = PrIsDefined (PrParserlval.str);;} 1660 break; 1661 1662 case 26: 1663 1664 /* Line 1455 of yacc.c */ 1665 #line 286 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1666 { (yyval.value) = PrIsDefined (PrParserlval.str);;} 1667 break; 1668 1669 case 27: 1670 1671 /* Line 1455 of yacc.c */ 1672 #line 288 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1673 { (yyval.value) = PrResolveDefine (PrParserlval.str);;} 1674 break; 1675 1676 case 28: 1677 1678 /* Line 1455 of yacc.c */ 1679 #line 292 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1680 { AcpiUtStrtoul64 (PrParsertext, &(yyval.value));;} 1681 break; 1682 1683 case 29: 1684 1685 /* Line 1455 of yacc.c */ 1686 #line 296 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1687 { AcpiUtStrtoul64 (PrParsertext, &(yyval.value));;} 1688 break; 1689 1690 1691 1692 /* Line 1455 of yacc.c */ 1693 #line 1800 "prparser.tab.c" 1694 default: break; 1695 } 1696 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1697 1698 YYPOPSTACK (yylen); 1699 yylen = 0; 1700 YY_STACK_PRINT (yyss, yyssp); 1701 1702 *++yyvsp = yyval; 1703 1704 /* Now `shift' the result of the reduction. Determine what state 1705 that goes to, based on the state we popped back to and the rule 1706 number reduced by. */ 1707 1708 yyn = yyr1[yyn]; 1709 1710 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1711 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1712 yystate = yytable[yystate]; 1713 else 1714 yystate = yydefgoto[yyn - YYNTOKENS]; 1715 1716 goto yynewstate; 1717 1718 1719 /*------------------------------------. 1720 | yyerrlab -- here on detecting error | 1721 `------------------------------------*/ 1722 yyerrlab: 1723 /* If not already recovering from an error, report this error. */ 1724 if (!yyerrstatus) 1725 { 1726 ++yynerrs; 1727 #if ! YYERROR_VERBOSE 1728 yyerror (YY_("syntax error")); 1729 #else 1730 { 1731 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1732 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1733 { 1734 YYSIZE_T yyalloc = 2 * yysize; 1735 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1736 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1737 if (yymsg != yymsgbuf) 1738 YYSTACK_FREE (yymsg); 1739 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1740 if (yymsg) 1741 yymsg_alloc = yyalloc; 1742 else 1743 { 1744 yymsg = yymsgbuf; 1745 yymsg_alloc = sizeof yymsgbuf; 1746 } 1747 } 1748 1749 if (0 < yysize && yysize <= yymsg_alloc) 1750 { 1751 (void) yysyntax_error (yymsg, yystate, yychar); 1752 yyerror (yymsg); 1753 } 1754 else 1755 { 1756 yyerror (YY_("syntax error")); 1757 if (yysize != 0) 1758 goto yyexhaustedlab; 1759 } 1760 } 1761 #endif 1762 } 1763 1764 1765 1766 if (yyerrstatus == 3) 1767 { 1768 /* If just tried and failed to reuse lookahead token after an 1769 error, discard it. */ 1770 1771 if (yychar <= YYEOF) 1772 { 1773 /* Return failure if at end of input. */ 1774 if (yychar == YYEOF) 1775 YYABORT; 1776 } 1777 else 1778 { 1779 yydestruct ("Error: discarding", 1780 yytoken, &yylval); 1781 yychar = YYEMPTY; 1782 } 1783 } 1784 1785 /* Else will try to reuse lookahead token after shifting the error 1786 token. */ 1787 goto yyerrlab1; 1788 1789 1790 /*---------------------------------------------------. 1791 | yyerrorlab -- error raised explicitly by YYERROR. | 1792 `---------------------------------------------------*/ 1793 yyerrorlab: 1794 1795 /* Pacify compilers like GCC when the user code never invokes 1796 YYERROR and the label yyerrorlab therefore never appears in user 1797 code. */ 1798 if (/*CONSTCOND*/ 0) 1799 goto yyerrorlab; 1800 1801 /* Do not reclaim the symbols of the rule which action triggered 1802 this YYERROR. */ 1803 YYPOPSTACK (yylen); 1804 yylen = 0; 1805 YY_STACK_PRINT (yyss, yyssp); 1806 yystate = *yyssp; 1807 goto yyerrlab1; 1808 1809 1810 /*-------------------------------------------------------------. 1811 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1812 `-------------------------------------------------------------*/ 1813 yyerrlab1: 1814 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1815 1816 for (;;) 1817 { 1818 yyn = yypact[yystate]; 1819 if (yyn != YYPACT_NINF) 1820 { 1821 yyn += YYTERROR; 1822 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1823 { 1824 yyn = yytable[yyn]; 1825 if (0 < yyn) 1826 break; 1827 } 1828 } 1829 1830 /* Pop the current state because it cannot handle the error token. */ 1831 if (yyssp == yyss) 1832 YYABORT; 1833 1834 1835 yydestruct ("Error: popping", 1836 yystos[yystate], yyvsp); 1837 YYPOPSTACK (1); 1838 yystate = *yyssp; 1839 YY_STACK_PRINT (yyss, yyssp); 1840 } 1841 1842 *++yyvsp = yylval; 1843 1844 1845 /* Shift the error token. */ 1846 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1847 1848 yystate = yyn; 1849 goto yynewstate; 1850 1851 1852 /*-------------------------------------. 1853 | yyacceptlab -- YYACCEPT comes here. | 1854 `-------------------------------------*/ 1855 yyacceptlab: 1856 yyresult = 0; 1857 goto yyreturn; 1858 1859 /*-----------------------------------. 1860 | yyabortlab -- YYABORT comes here. | 1861 `-----------------------------------*/ 1862 yyabortlab: 1863 yyresult = 1; 1864 goto yyreturn; 1865 1866 #if !defined(yyoverflow) || YYERROR_VERBOSE 1867 /*-------------------------------------------------. 1868 | yyexhaustedlab -- memory exhaustion comes here. | 1869 `-------------------------------------------------*/ 1870 yyexhaustedlab: 1871 yyerror (YY_("memory exhausted")); 1872 yyresult = 2; 1873 /* Fall through. */ 1874 #endif 1875 1876 yyreturn: 1877 if (yychar != YYEMPTY) 1878 yydestruct ("Cleanup: discarding lookahead", 1879 yytoken, &yylval); 1880 /* Do not reclaim the symbols of the rule which action triggered 1881 this YYABORT or YYACCEPT. */ 1882 YYPOPSTACK (yylen); 1883 YY_STACK_PRINT (yyss, yyssp); 1884 while (yyssp != yyss) 1885 { 1886 yydestruct ("Cleanup: popping", 1887 yystos[*yyssp], yyvsp); 1888 YYPOPSTACK (1); 1889 } 1890 #ifndef yyoverflow 1891 if (yyss != yyssa) 1892 YYSTACK_FREE (yyss); 1893 #endif 1894 #if YYERROR_VERBOSE 1895 if (yymsg != yymsgbuf) 1896 YYSTACK_FREE (yymsg); 1897 #endif 1898 /* Make sure YYID is used. */ 1899 return YYID (yyresult); 1900 } 1901 1902 1903 1904 /* Line 1675 of yacc.c */ 1905 #line 298 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.y" 1906 1907 1908 /* 1909 * Local support functions, including parser entry point 1910 */ 1911 #define PR_FIRST_PARSE_OPCODE EXPOP_EOF 1912 #define PR_YYTNAME_START 3 1913 1914 1915 /****************************************************************************** 1916 * 1917 * FUNCTION: PrParsererror 1918 * 1919 * PARAMETERS: Message - Parser-generated error message 1920 * 1921 * RETURN: None 1922 * 1923 * DESCRIPTION: Handler for parser errors 1924 * 1925 *****************************************************************************/ 1926 1927 void 1928 PrParsererror ( 1929 char const *Message) 1930 { 1931 1932 sprintf (AslGbl_StringBuffer, "Preprocessor Parser : %s (near line %u)", 1933 Message, AslGbl_CurrentLineNumber); 1934 DtError (ASL_ERROR, ASL_MSG_SYNTAX, 1935 NULL, (char *) AslGbl_StringBuffer); 1936 } 1937 1938 1939 /****************************************************************************** 1940 * 1941 * FUNCTION: PrGetOpName 1942 * 1943 * PARAMETERS: ParseOpcode - Parser token (EXPOP_*) 1944 * 1945 * RETURN: Pointer to the opcode name 1946 * 1947 * DESCRIPTION: Get the ascii name of the parse opcode for debug output 1948 * 1949 *****************************************************************************/ 1950 1951 char * 1952 PrGetOpName ( 1953 UINT32 ParseOpcode) 1954 { 1955 #ifdef ASL_YYTNAME_START 1956 /* 1957 * First entries (PR_YYTNAME_START) in yytname are special reserved names. 1958 * Ignore first 6 characters of name (EXPOP_) 1959 */ 1960 return ((char *) yytname 1961 [(ParseOpcode - PR_FIRST_PARSE_OPCODE) + PR_YYTNAME_START] + 6); 1962 #else 1963 return ("[Unknown parser generator]"); 1964 #endif 1965 } 1966 1967 1968 /****************************************************************************** 1969 * 1970 * FUNCTION: PrEvaluateExpression 1971 * 1972 * PARAMETERS: ExprString - Expression to be evaluated. Must be 1973 * terminated by either a newline or a NUL 1974 * string terminator 1975 * 1976 * RETURN: 64-bit value for the expression 1977 * 1978 * DESCRIPTION: Main entry point for the DT expression parser 1979 * 1980 *****************************************************************************/ 1981 1982 UINT64 1983 PrEvaluateExpression ( 1984 char *ExprString) 1985 { 1986 1987 DbgPrint (ASL_DEBUG_OUTPUT, 1988 "**** Input expression: %s\n", ExprString); 1989 1990 /* Point lexer to the input string */ 1991 1992 if (PrInitLexer (ExprString)) 1993 { 1994 DtError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, 1995 NULL, "Could not initialize lexer"); 1996 return (0); 1997 } 1998 1999 /* Parse/Evaluate the input string (value returned in PrParserResult) */ 2000 2001 PrParserparse (); 2002 PrTerminateLexer (); 2003 2004 DbgPrint (ASL_DEBUG_OUTPUT, 2005 "**** Parser returned value: %u (%8.8X%8.8X)\n", 2006 (UINT32) PrParserResult, ACPI_FORMAT_UINT64 (PrParserResult)); 2007 2008 return (PrParserResult); 2009 } 2010 2011
Indexes created Sun Feb 22 08:20:21 UTC 2026