1 | /* A Bison parser, made by GNU Bison 2.6.2. */ 2 | 3 | /* Bison implementation for Yacc-like parsers in C 4 | 5 | Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc. 6 | 7 | This program is free software: you can redistribute it and/or modify 8 | it under the terms of the GNU General Public License as published by 9 | the Free Software Foundation, either version 3 of the License, or 10 | (at your option) any later version. 11 | 12 | This program is distributed in the hope that it will be useful, 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | GNU General Public License for more details. 16 | 17 | You should have received a copy of the GNU General Public License 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 | 20 | /* As a special exception, you may create a larger work that contains 21 | part or all of the Bison parser skeleton and distribute that work 22 | under terms of your choice, so long as that work isn't itself a 23 | parser generator using the skeleton or a modified version thereof 24 | as a parser skeleton. Alternatively, if you modify or redistribute 25 | the parser skeleton itself, you may (at your option) remove this 26 | special exception, which will cause the skeleton and the resulting 27 | Bison output files to be licensed under the GNU General Public 28 | License without this special exception. 29 | 30 | This special exception was added by the Free Software Foundation in 31 | version 2.2 of Bison. */ 32 | 33 | /* C LALR(1) parser skeleton written by Richard Stallman, by 34 | simplifying the original so-called "semantic" parser. */ 35 | 36 | /* All symbols defined below should begin with yy or YY, to avoid 37 | infringing on user name space. This should be done even for local 38 | variables, as they might otherwise be expanded by user macros. 39 | There are some unavoidable exceptions within include files to 40 | define necessary library symbols; they are noted "INFRINGES ON 41 | USER NAME SPACE" below. */ 42 | 43 | /* Identify Bison output. */ 44 | #define YYBISON 1 45 | 46 | /* Bison version. */ 47 | #define YYBISON_VERSION "2.6.2" 48 | 49 | /* Skeleton name. */ 50 | #define YYSKELETON_NAME "yacc.c" 51 | 52 | /* Pure parsers. */ 53 | #define YYPURE 0 54 | 55 | /* Push parsers. */ 56 | #define YYPUSH 0 57 | 58 | /* Pull parsers. */ 59 | #define YYPULL 1 60 | 61 | 62 | 63 | 64 | /* Copy the first part of user declarations. */ 65 | /* Line 336 of yacc.c */ 66 | #line 1 "./parse.y" 67 | 68 | /*************************************** 69 | C Cross Referencing & Documentation tool. Version 1.6e. 70 | 71 | C parser. 72 | ******************/ /****************** 73 | Written by Andrew M. Bishop 74 | 75 | This file Copyright 1995-2011 Andrew M. Bishop 76 | It may be distributed under the GNU Public License, version 2, or 77 | any higher version. See section COPYING of the GNU Public license 78 | for conditions under which this file may be redistributed. 79 | ***************************************/ 80 | 81 | #include <string.h> 82 | #include "parse-yy.h" 83 | #include "cxref.h" 84 | #include "memory.h" 85 | 86 | /*+ A structure to hold the information about an object. +*/ 87 | typedef struct _stack 88 | { 89 | char *name; /*+ The name of the object. +*/ 90 | char *type; /*+ The type of the object. +*/ 91 | char *qual; /*+ The type qualifier of the object. +*/ 92 | } 93 | stack; 94 | 95 | #define yylex cxref_yylex 96 | 97 | static int cxref_yylex(void); 98 | 99 | static void yyerror(char *s); 100 | 101 | /*+ When in a header file, some stuff can be skipped over quickly. +*/ 102 | extern int in_header; 103 | 104 | /*+ A flag that is set to true when typedef is seen in a statement. +*/ 105 | int in_typedef=0; 106 | 107 | /*+ The scope of the function / variable that is being examined. +*/ 108 | static int scope; 109 | 110 | /*+ The variable must be LOCAL or EXTERNAL or GLOBAL, so this checks and sets that. +*/ 111 | #define SCOPE ( scope&(LOCAL|EXTERNAL|EXTERN_H|EXTERN_F) ? scope : scope|GLOBAL ) 112 | 113 | /*+ When in a function or a function definition, the behaviour is different. +*/ 114 | static int in_function=0,in_funcdef=0,in_funcbody=0; 115 | 116 | /*+ The parsing stack +*/ 117 | static stack first={NULL,NULL,NULL}, /*+ first value. +*/ 118 | *list=NULL, /*+ list of all values. +*/ 119 | *current=&first; /*+ current values. +*/ 120 | 121 | /*+ The depth of the stack +*/ 122 | static int depth=0, /*+ currently in use. +*/ 123 | maxdepth=0; /*+ total malloced. +*/ 124 | 125 | /*+ Declarations that are in the same statement share this comment. +*/ 126 | static char* common_comment=NULL; 127 | 128 | /*+ When inside a struct / union / enum definition, this is the depth. +*/ 129 | static int in_structunion=0; 130 | 131 | /*+ When inside a struct / union definition, this is the component type. +*/ 132 | static char *comp_type=NULL; 133 | 134 | /*+ To solve the problem where a type name is used as an identifier. +*/ 135 | static int in_type_spec=0; 136 | 137 | 138 | /*++++++++++++++++++++++++++++++++++++++ 139 | Reset the current level on the stack. 140 | ++++++++++++++++++++++++++++++++++++++*/ 141 | 142 | static void reset(void) 143 | { 144 | current->name=NULL; 145 | current->type=NULL; 146 | current->qual=NULL; 147 | } 148 | 149 | 150 | /*++++++++++++++++++++++++++++++++++++++ 151 | Push a level onto the stack. 152 | ++++++++++++++++++++++++++++++++++++++*/ 153 | 154 | static void push(void) 155 | { 156 | if(list==NULL) 157 | { 158 | list=(stack*)Malloc(8*sizeof(struct _stack)); 159 | list[0]=first; 160 | maxdepth=8; 161 | } 162 | else if(depth==(maxdepth-1)) 163 | { 164 | list=Realloc(list,(maxdepth+8)*sizeof(struct _stack)); 165 | maxdepth+=8; 166 | } 167 | 168 | depth++; 169 | current=&list[depth]; 170 | 171 | reset(); 172 | } 173 | 174 | 175 | /*++++++++++++++++++++++++++++++++++++++ 176 | Pop a level from the stack. 177 | ++++++++++++++++++++++++++++++++++++++*/ 178 | 179 | static void pop(void) 180 | { 181 | reset(); 182 | 183 | depth--; 184 | current=&list[depth]; 185 | } 186 | 187 | 188 | /*++++++++++++++++++++++++++++++++++++++ 189 | Reset the Parser, ready for the next file. 190 | ++++++++++++++++++++++++++++++++++++++*/ 191 | 192 | void ResetParser(void) 193 | { 194 | in_typedef=0; 195 | scope=0; 196 | in_function=0; 197 | in_funcdef=0; 198 | in_funcbody=0; 199 | depth=0; 200 | maxdepth=0; 201 | if(list) Free(list); 202 | list=NULL; 203 | current=&first; 204 | reset(); 205 | common_comment=NULL; 206 | in_structunion=0; 207 | comp_type=NULL; 208 | in_type_spec=0; 209 | } 210 | 211 | 212 | /* Line 336 of yacc.c */ 213 | #line 214 "y.tab.c" 214 | 215 | # ifndef YY_NULL 216 | # if defined __cplusplus && 201103L <= __cplusplus 217 | # define YY_NULL nullptr 218 | # else 219 | # define YY_NULL 0 220 | # endif 221 | # endif 222 | 223 | /* Enabling verbose error messages. */ 224 | #ifdef YYERROR_VERBOSE 225 | # undef YYERROR_VERBOSE 226 | # define YYERROR_VERBOSE 1 227 | #else 228 | # define YYERROR_VERBOSE 0 229 | #endif 230 | 231 | /* In a future release of Bison, this section will be replaced 232 | by #include "y.tab.h". */ 233 | #ifndef YY_Y_TAB_H 234 | # define YY_Y_TAB_H 235 | /* Enabling traces. */ 236 | #ifndef YYDEBUG 237 | # define YYDEBUG 0 238 | #endif 239 | #if YYDEBUG 240 | extern int yydebug; 241 | #endif 242 | 243 | /* Tokens. */ 244 | #ifndef YYTOKENTYPE 245 | # define YYTOKENTYPE 246 | /* Put the tokens into the symbol table, so that GDB and other debuggers 247 | know about them. */ 248 | enum yytokentype { 249 | IDENTIFIER = 258, 250 | TYPE_NAME = 259, 251 | LITERAL = 260, 252 | STRING_LITERAL = 261, 253 | ELLIPSES = 262, 254 | MUL_ASSIGN = 263, 255 | DIV_ASSIGN = 264, 256 | MOD_ASSIGN = 265, 257 | ADD_ASSIGN = 266, 258 | SUB_ASSIGN = 267, 259 | LEFT_ASSIGN = 268, 260 | RIGHT_ASSIGN = 269, 261 | AND_ASSIGN = 270, 262 | XOR_ASSIGN = 271, 263 | OR_ASSIGN = 272, 264 | EQ_OP = 273, 265 | NE_OP = 274, 266 | PTR_OP = 275, 267 | AND_OP = 276, 268 | OR_OP = 277, 269 | DEC_OP = 278, 270 | INC_OP = 279, 271 | LE_OP = 280, 272 | GE_OP = 281, 273 | LEFT_SHIFT = 282, 274 | RIGHT_SHIFT = 283, 275 | SIZEOF = 284, 276 | TYPEDEF = 285, 277 | EXTERN = 286, 278 | STATIC = 287, 279 | AUTO = 288, 280 | REGISTER = 289, 281 | CONST = 290, 282 | VOLATILE = 291, 283 | VOID = 292, 284 | INLINE = 293, 285 | CHAR = 294, 286 | SHORT = 295, 287 | INT = 296, 288 | LONG = 297, 289 | SIGNED = 298, 290 | UNSIGNED = 299, 291 | FLOAT = 300, 292 | DOUBLE = 301, 293 | BOOL = 302, 294 | STRUCT = 303, 295 | UNION = 304, 296 | ENUM = 305, 297 | CASE = 306, 298 | DEFAULT = 307, 299 | IF = 308, 300 | ELSE = 309, 301 | SWITCH = 310, 302 | WHILE = 311, 303 | DO = 312, 304 | FOR = 313, 305 | GOTO = 314, 306 | CONTINUE = 315, 307 | BREAK = 316, 308 | RETURN = 317, 309 | ASM = 318 310 | }; 311 | #endif 312 | /* Tokens. */ 313 | #define IDENTIFIER 258 314 | #define TYPE_NAME 259 315 | #define LITERAL 260 316 | #define STRING_LITERAL 261 317 | #define ELLIPSES 262 318 | #define MUL_ASSIGN 263 319 | #define DIV_ASSIGN 264 320 | #define MOD_ASSIGN 265 321 | #define ADD_ASSIGN 266 322 | #define SUB_ASSIGN 267 323 | #define LEFT_ASSIGN 268 324 | #define RIGHT_ASSIGN 269 325 | #define AND_ASSIGN 270 326 | #define XOR_ASSIGN 271 327 | #define OR_ASSIGN 272 328 | #define EQ_OP 273 329 | #define NE_OP 274 330 | #define PTR_OP 275 331 | #define AND_OP 276 332 | #define OR_OP 277 333 | #define DEC_OP 278 334 | #define INC_OP 279 335 | #define LE_OP 280 336 | #define GE_OP 281 337 | #define LEFT_SHIFT 282 338 | #define RIGHT_SHIFT 283 339 | #define SIZEOF 284 340 | #define TYPEDEF 285 341 | #define EXTERN 286 342 | #define STATIC 287 343 | #define AUTO 288 344 | #define REGISTER 289 345 | #define CONST 290 346 | #define VOLATILE 291 347 | #define VOID 292 348 | #define INLINE 293 349 | #define CHAR 294 350 | #define SHORT 295 351 | #define INT 296 352 | #define LONG 297 353 | #define SIGNED 298 354 | #define UNSIGNED 299 355 | #define FLOAT 300 356 | #define DOUBLE 301 357 | #define BOOL 302 358 | #define STRUCT 303 359 | #define UNION 304 360 | #define ENUM 305 361 | #define CASE 306 362 | #define DEFAULT 307 363 | #define IF 308 364 | #define ELSE 309 365 | #define SWITCH 310 366 | #define WHILE 311 367 | #define DO 312 368 | #define FOR 313 369 | #define GOTO 314 370 | #define CONTINUE 315 371 | #define BREAK 316 372 | #define RETURN 317 373 | #define ASM 318 374 | 375 | 376 | 377 | #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 378 | typedef int YYSTYPE; 379 | # define YYSTYPE_IS_TRIVIAL 1 380 | # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 381 | # define YYSTYPE_IS_DECLARED 1 382 | #endif 383 | 384 | extern YYSTYPE yylval; 385 | 386 | #ifdef YYPARSE_PARAM 387 | #if defined __STDC__ || defined __cplusplus 388 | int yyparse (void *YYPARSE_PARAM); 389 | #else 390 | int yyparse (); 391 | #endif 392 | #else /* ! YYPARSE_PARAM */ 393 | #if defined __STDC__ || defined __cplusplus 394 | int yyparse (void); 395 | #else 396 | int yyparse (); 397 | #endif 398 | #endif /* ! YYPARSE_PARAM */ 399 | 400 | #endif /* !YY_Y_TAB_H */ 401 | 402 | /* Copy the second part of user declarations. */ 403 | 404 | /* Line 353 of yacc.c */ 405 | #line 406 "y.tab.c" 406 | 407 | #ifdef short 408 | # undef short 409 | #endif 410 | 411 | #ifdef YYTYPE_UINT8 412 | typedef YYTYPE_UINT8 yytype_uint8; 413 | #else 414 | typedef unsigned char yytype_uint8; 415 | #endif 416 | 417 | #ifdef YYTYPE_INT8 418 | typedef YYTYPE_INT8 yytype_int8; 419 | #elif (defined __STDC__ || defined __C99__FUNC__ \ 420 | || defined __cplusplus || defined _MSC_VER) 421 | typedef signed char yytype_int8; 422 | #else 423 | typedef short int yytype_int8; 424 | #endif 425 | 426 | #ifdef YYTYPE_UINT16 427 | typedef YYTYPE_UINT16 yytype_uint16; 428 | #else 429 | typedef unsigned short int yytype_uint16; 430 | #endif 431 | 432 | #ifdef YYTYPE_INT16 433 | typedef YYTYPE_INT16 yytype_int16; 434 | #else 435 | typedef short int yytype_int16; 436 | #endif 437 | 438 | #ifndef YYSIZE_T 439 | # ifdef __SIZE_TYPE__ 440 | # define YYSIZE_T __SIZE_TYPE__ 441 | # elif defined size_t 442 | # define YYSIZE_T size_t 443 | # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 444 | || defined __cplusplus || defined _MSC_VER) 445 | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 446 | # define YYSIZE_T size_t 447 | # else 448 | # define YYSIZE_T unsigned int 449 | # endif 450 | #endif 451 | 452 | #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 453 | 454 | #ifndef YY_ 455 | # if defined YYENABLE_NLS && YYENABLE_NLS 456 | # if ENABLE_NLS 457 | # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 458 | # define YY_(msgid) dgettext ("bison-runtime", msgid) 459 | # endif 460 | # endif 461 | # ifndef YY_ 462 | # define YY_(msgid) msgid 463 | # endif 464 | #endif 465 | 466 | /* Suppress unused-variable warnings by "using" E. */ 467 | #if ! defined lint || defined __GNUC__ 468 | # define YYUSE(e) ((void) (e)) 469 | #else 470 | # define YYUSE(e) /* empty */ 471 | #endif 472 | 473 | /* Identity function, used to suppress warnings about constant conditions. */ 474 | #ifndef lint 475 | # define YYID(n) (n) 476 | #else 477 | #if (defined __STDC__ || defined __C99__FUNC__ \ 478 | || defined __cplusplus || defined _MSC_VER) 479 | static int 480 | YYID (int yyi) 481 | #else 482 | static int 483 | YYID (yyi) 484 | int yyi; 485 | #endif 486 | { 487 | return yyi; 488 | } 489 | #endif 490 | 491 | #if ! defined yyoverflow || YYERROR_VERBOSE 492 | 493 | /* The parser invokes alloca or malloc; define the necessary symbols. */ 494 | 495 | # ifdef YYSTACK_USE_ALLOCA 496 | # if YYSTACK_USE_ALLOCA 497 | # ifdef __GNUC__ 498 | # define YYSTACK_ALLOC __builtin_alloca 499 | # elif defined __BUILTIN_VA_ARG_INCR 500 | # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 501 | # elif defined _AIX 502 | # define YYSTACK_ALLOC __alloca 503 | # elif defined _MSC_VER 504 | # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 505 | # define alloca _alloca 506 | # else 507 | # define YYSTACK_ALLOC alloca 508 | # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 509 | || defined __cplusplus || defined _MSC_VER) 510 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 511 | /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 512 | # ifndef EXIT_SUCCESS 513 | # define EXIT_SUCCESS 0 514 | # endif 515 | # endif 516 | # endif 517 | # endif 518 | # endif 519 | 520 | # ifdef YYSTACK_ALLOC 521 | /* Pacify GCC's `empty if-body' warning. */ 522 | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 523 | # ifndef YYSTACK_ALLOC_MAXIMUM 524 | /* The OS might guarantee only one guard page at the bottom of the stack, 525 | and a page size can be as small as 4096 bytes. So we cannot safely 526 | invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 527 | to allow for a few compiler-allocated temporary stack slots. */ 528 | # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 529 | # endif 530 | # else 531 | # define YYSTACK_ALLOC YYMALLOC 532 | # define YYSTACK_FREE YYFREE 533 | # ifndef YYSTACK_ALLOC_MAXIMUM 534 | # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 535 | # endif 536 | # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 537 | && ! ((defined YYMALLOC || defined malloc) \ 538 | && (defined YYFREE || defined free))) 539 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 540 | # ifndef EXIT_SUCCESS 541 | # define EXIT_SUCCESS 0 542 | # endif 543 | # endif 544 | # ifndef YYMALLOC 545 | # define YYMALLOC malloc 546 | # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 547 | || defined __cplusplus || defined _MSC_VER) 548 | void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 549 | # endif 550 | # endif 551 | # ifndef YYFREE 552 | # define YYFREE free 553 | # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \ 554 | || defined __cplusplus || defined _MSC_VER) 555 | void free (void *); /* INFRINGES ON USER NAME SPACE */ 556 | # endif 557 | # endif 558 | # endif 559 | #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 560 | 561 | 562 | #if (! defined yyoverflow \ 563 | && (! defined __cplusplus \ 564 | || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 565 | 566 | /* A type that is properly aligned for any stack member. */ 567 | union yyalloc 568 | { 569 | yytype_int16 yyss_alloc; 570 | YYSTYPE yyvs_alloc; 571 | }; 572 | 573 | /* The size of the maximum gap between one aligned stack and the next. */ 574 | # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 575 | 576 | /* The size of an array large to enough to hold all stacks, each with 577 | N elements. */ 578 | # define YYSTACK_BYTES(N) \ 579 | ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 580 | + YYSTACK_GAP_MAXIMUM) 581 | 582 | # define YYCOPY_NEEDED 1 583 | 584 | /* Relocate STACK from its old location to the new one. The 585 | local variables YYSIZE and YYSTACKSIZE give the old and new number of 586 | elements in the stack, and YYPTR gives the new location of the 587 | stack. Advance YYPTR to a properly aligned location for the next 588 | stack. */ 589 | # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 590 | do \ 591 | { \ 592 | YYSIZE_T yynewbytes; \ 593 | YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 594 | Stack = &yyptr->Stack_alloc; \ 595 | yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 596 | yyptr += yynewbytes / sizeof (*yyptr); \ 597 | } \ 598 | while (YYID (0)) 599 | 600 | #endif 601 | 602 | #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 603 | /* Copy COUNT objects from SRC to DST. The source and destination do 604 | not overlap. */ 605 | # ifndef YYCOPY 606 | # if defined __GNUC__ && 1 < __GNUC__ 607 | # define YYCOPY(Dst, Src, Count) \ 608 | __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 609 | # else 610 | # define YYCOPY(Dst, Src, Count) \ 611 | do \ 612 | { \ 613 | YYSIZE_T yyi; \ 614 | for (yyi = 0; yyi < (Count); yyi++) \ 615 | (Dst)[yyi] = (Src)[yyi]; \ 616 | } \ 617 | while (YYID (0)) 618 | # endif 619 | # endif 620 | #endif /* !YYCOPY_NEEDED */ 621 | 622 | /* YYFINAL -- State number of the termination state. */ 623 | #define YYFINAL 92 624 | /* YYLAST -- Last index in YYTABLE. */ 625 | #define YYLAST 1500 626 | 627 | /* YYNTOKENS -- Number of terminals. */ 628 | #define YYNTOKENS 88 629 | /* YYNNTS -- Number of nonterminals. */ 630 | #define YYNNTS 172 631 | /* YYNRULES -- Number of rules. */ 632 | #define YYNRULES 379 633 | /* YYNRULES -- Number of states. */ 634 | #define YYNSTATES 572 635 | 636 | /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 637 | #define YYUNDEFTOK 2 638 | #define YYMAXUTOK 318 639 | 640 | #define YYTRANSLATE(YYX) \ 641 | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 642 | 643 | /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 644 | static const yytype_uint8 yytranslate[] = 645 | { 646 | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 647 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 648 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 649 | 2, 2, 2, 87, 2, 2, 2, 85, 79, 2, 650 | 73, 74, 75, 82, 65, 83, 70, 84, 2, 2, 651 | 2, 2, 2, 2, 2, 2, 2, 2, 69, 64, 652 | 80, 66, 81, 76, 2, 2, 2, 2, 2, 2, 653 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 654 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 655 | 2, 71, 2, 72, 78, 2, 2, 2, 2, 2, 656 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 657 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 658 | 2, 2, 2, 67, 77, 68, 86, 2, 2, 2, 659 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 660 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 661 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 662 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 663 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 664 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 665 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 666 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 667 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 668 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 669 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 670 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 671 | 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 672 | 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 673 | 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 674 | 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 675 | 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 676 | 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 677 | 55, 56, 57, 58, 59, 60, 61, 62, 63 678 | }; 679 | 680 | #if YYDEBUG 681 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 682 | YYRHS. */ 683 | static const yytype_uint16 yyprhs[] = 684 | { 685 | 0, 0, 3, 4, 6, 8, 11, 13, 15, 17, 686 | 19, 21, 24, 28, 31, 33, 35, 38, 40, 43, 687 | 45, 48, 50, 51, 56, 58, 60, 63, 66, 70, 688 | 73, 75, 79, 80, 82, 86, 89, 91, 95, 99, 689 | 102, 106, 108, 111, 113, 117, 119, 122, 124, 128, 690 | 131, 135, 139, 144, 147, 151, 155, 160, 162, 165, 691 | 167, 170, 173, 177, 179, 183, 185, 187, 189, 193, 692 | 194, 195, 202, 204, 206, 208, 210, 212, 214, 216, 693 | 218, 221, 223, 225, 227, 229, 231, 233, 235, 237, 694 | 239, 241, 243, 245, 247, 250, 253, 255, 258, 261, 695 | 263, 265, 267, 269, 271, 273, 275, 277, 279, 281, 696 | 284, 286, 288, 289, 295, 296, 303, 305, 308, 310, 697 | 314, 316, 320, 322, 325, 327, 329, 331, 333, 334, 698 | 340, 341, 348, 351, 353, 355, 357, 359, 360, 366, 699 | 367, 374, 377, 379, 381, 382, 384, 386, 389, 391, 700 | 394, 397, 399, 400, 405, 406, 412, 413, 419, 421, 701 | 425, 427, 429, 431, 434, 438, 440, 442, 444, 445, 702 | 449, 451, 453, 456, 459, 463, 465, 467, 471, 474, 703 | 479, 480, 486, 488, 489, 491, 493, 495, 499, 501, 704 | 505, 507, 511, 514, 516, 519, 521, 523, 525, 527, 705 | 529, 531, 533, 535, 537, 539, 541, 543, 544, 545, 706 | 551, 552, 554, 556, 559, 561, 563, 565, 567, 575, 707 | 581, 583, 585, 587, 595, 596, 603, 606, 610, 614, 708 | 618, 623, 628, 633, 639, 641, 644, 646, 652, 655, 709 | 658, 661, 664, 669, 671, 673, 675, 681, 684, 687, 710 | 690, 694, 696, 699, 703, 705, 707, 711, 713, 715, 711 | 719, 725, 727, 729, 731, 733, 735, 737, 739, 741, 712 | 743, 745, 747, 749, 755, 760, 762, 766, 768, 772, 713 | 774, 778, 780, 784, 786, 790, 792, 796, 798, 800, 714 | 802, 806, 808, 810, 812, 814, 816, 820, 822, 824, 715 | 826, 830, 832, 834, 836, 840, 842, 844, 846, 848, 716 | 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 717 | 871, 874, 879, 886, 889, 892, 895, 898, 903, 906, 718 | 909, 912, 914, 916, 918, 920, 922, 924, 926, 928, 719 | 930, 934, 938, 942, 947, 951, 956, 959, 962, 967, 720 | 969, 971, 973, 975, 977, 980, 984, 985, 986, 992, 721 | 994, 996, 1000, 1006, 1014, 1024, 1036, 1038, 1041, 1044, 722 | 1045, 1047, 1051, 1059, 1067, 1072, 1073, 1075, 1079, 1084 723 | }; 724 | 725 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 726 | static const yytype_int16 yyrhs[] = 727 | { 728 | 89, 0, -1, -1, 90, -1, 91, -1, 90, 91, 729 | -1, 93, -1, 164, -1, 253, -1, 204, -1, 93, 730 | -1, 92, 93, -1, 94, 96, 64, -1, 94, 64, 731 | -1, 95, -1, 117, -1, 117, 95, -1, 120, -1, 732 | 120, 95, -1, 119, -1, 119, 95, -1, 98, -1, 733 | -1, 96, 65, 97, 98, -1, 99, -1, 109, -1, 734 | 109, 258, -1, 109, 100, -1, 109, 258, 100, -1, 735 | 66, 101, -1, 208, -1, 67, 102, 68, -1, -1, 736 | 103, -1, 102, 65, 103, -1, 102, 65, -1, 101, 737 | -1, 163, 69, 101, -1, 105, 66, 101, -1, 70, 738 | 163, -1, 71, 106, 72, -1, 104, -1, 105, 104, 739 | -1, 251, -1, 251, 7, 251, -1, 110, -1, 110, 740 | 108, -1, 108, -1, 73, 107, 74, -1, 71, 72, 741 | -1, 108, 71, 72, -1, 71, 251, 72, -1, 108, 742 | 71, 251, 72, -1, 73, 74, -1, 108, 73, 74, 743 | -1, 73, 175, 74, -1, 108, 73, 175, 74, -1, 744 | 111, -1, 110, 111, -1, 75, -1, 75, 118, -1, 745 | 75, 110, -1, 75, 118, 110, -1, 112, -1, 73, 746 | 109, 74, -1, 113, -1, 170, -1, 3, -1, 111, 747 | 71, 72, -1, -1, -1, 111, 71, 114, 251, 115, 748 | 72, -1, 3, -1, 33, -1, 31, -1, 34, -1, 749 | 32, -1, 30, -1, 38, -1, 119, -1, 118, 119, 750 | -1, 35, -1, 36, -1, 121, -1, 129, -1, 122, 751 | -1, 123, -1, 125, -1, 139, -1, 126, -1, 145, 752 | -1, 127, -1, 45, -1, 46, -1, 46, 42, -1, 753 | 42, 46, -1, 124, -1, 124, 119, -1, 123, 124, 754 | -1, 43, -1, 44, -1, 39, -1, 40, -1, 41, 755 | -1, 42, -1, 47, -1, 4, -1, 37, -1, 94, 756 | -1, 94, 107, -1, 130, -1, 137, -1, -1, 50, 757 | 67, 131, 133, 68, -1, -1, 50, 138, 67, 132, 758 | 133, 68, -1, 134, -1, 134, 65, -1, 135, -1, 759 | 134, 65, 135, -1, 136, -1, 136, 66, 208, -1, 760 | 3, -1, 50, 138, -1, 3, -1, 4, -1, 140, 761 | -1, 143, -1, -1, 48, 67, 141, 151, 68, -1, 762 | -1, 48, 144, 67, 142, 151, 68, -1, 48, 144, 763 | -1, 3, -1, 4, -1, 146, -1, 149, -1, -1, 764 | 49, 67, 147, 151, 68, -1, -1, 49, 150, 67, 765 | 148, 151, 68, -1, 49, 150, -1, 3, -1, 4, 766 | -1, -1, 152, -1, 153, -1, 152, 153, -1, 64, 767 | -1, 140, 64, -1, 146, 64, -1, 154, -1, -1, 768 | 120, 155, 158, 64, -1, -1, 118, 120, 156, 158, 769 | 64, -1, -1, 120, 118, 157, 158, 64, -1, 159, 770 | -1, 158, 65, 159, -1, 160, -1, 161, -1, 109, 771 | -1, 69, 162, -1, 109, 69, 162, -1, 208, -1, 772 | 3, -1, 4, -1, -1, 166, 165, 179, -1, 167, 773 | -1, 168, -1, 94, 168, -1, 168, 92, -1, 94, 774 | 168, 92, -1, 169, -1, 170, -1, 73, 170, 74, 775 | -1, 110, 170, -1, 110, 73, 170, 74, -1, -1, 776 | 172, 73, 171, 173, 74, -1, 111, -1, -1, 175, 777 | -1, 174, -1, 3, -1, 174, 65, 3, -1, 176, 778 | -1, 176, 65, 7, -1, 177, -1, 176, 65, 177, 779 | -1, 94, 109, -1, 94, -1, 94, 107, -1, 253, 780 | -1, 179, -1, 185, -1, 188, -1, 195, -1, 199, 781 | -1, 200, -1, 201, -1, 202, -1, 203, -1, 204, 782 | -1, 205, -1, -1, -1, 67, 180, 182, 181, 68, 783 | -1, -1, 183, -1, 184, -1, 183, 184, -1, 178, 784 | -1, 93, -1, 187, -1, 186, -1, 53, 73, 206, 785 | 74, 178, 54, 178, -1, 53, 73, 206, 74, 178, 786 | -1, 189, -1, 190, -1, 194, -1, 57, 178, 56, 787 | 73, 206, 74, 64, -1, -1, 58, 191, 73, 192, 788 | 74, 178, -1, 64, 64, -1, 193, 64, 64, -1, 789 | 64, 206, 64, -1, 64, 64, 206, -1, 64, 206, 790 | 64, 206, -1, 193, 64, 64, 206, -1, 193, 64, 791 | 206, 64, -1, 193, 64, 206, 64, 206, -1, 206, 792 | -1, 94, 96, -1, 94, -1, 56, 73, 206, 74, 793 | 178, -1, 196, 69, -1, 198, 69, -1, 197, 69, 794 | -1, 51, 251, -1, 51, 251, 7, 251, -1, 52, 795 | -1, 3, -1, 4, -1, 55, 73, 206, 74, 178, 796 | -1, 61, 64, -1, 60, 64, -1, 206, 64, -1, 797 | 59, 3, 64, -1, 64, -1, 62, 64, -1, 62, 798 | 206, 64, -1, 207, -1, 208, -1, 207, 65, 208, 799 | -1, 210, -1, 259, -1, 226, 209, 208, -1, 226, 800 | 209, 67, 102, 68, -1, 66, -1, 8, -1, 9, 801 | -1, 10, -1, 11, -1, 12, -1, 13, -1, 14, 802 | -1, 15, -1, 16, -1, 17, -1, 211, -1, 211, 803 | 76, 206, 69, 210, -1, 211, 76, 69, 210, -1, 804 | 212, -1, 211, 22, 212, -1, 213, -1, 212, 21, 805 | 213, -1, 214, -1, 213, 77, 214, -1, 215, -1, 806 | 214, 78, 215, -1, 216, -1, 215, 79, 216, -1, 807 | 218, -1, 216, 217, 218, -1, 18, -1, 19, -1, 808 | 220, -1, 218, 219, 220, -1, 80, -1, 25, -1, 809 | 81, -1, 26, -1, 222, -1, 220, 221, 222, -1, 810 | 27, -1, 28, -1, 224, -1, 222, 223, 224, -1, 811 | 82, -1, 83, -1, 226, -1, 224, 225, 226, -1, 812 | 75, -1, 84, -1, 85, -1, 227, -1, 228, -1, 813 | 229, -1, 230, -1, 231, -1, 232, -1, 233, -1, 814 | 234, -1, 235, -1, 236, -1, 237, -1, 79, 226, 815 | -1, 86, 226, -1, 73, 128, 74, 226, -1, 73, 816 | 128, 74, 67, 102, 68, -1, 75, 226, -1, 87, 817 | 226, -1, 23, 226, -1, 24, 226, -1, 29, 73, 818 | 128, 74, -1, 29, 226, -1, 83, 226, -1, 82, 819 | 226, -1, 238, -1, 241, -1, 242, -1, 243, -1, 820 | 244, -1, 245, -1, 246, -1, 239, -1, 240, -1, 821 | 237, 70, 163, -1, 237, 20, 163, -1, 237, 73, 822 | 74, -1, 237, 73, 252, 74, -1, 116, 73, 74, 823 | -1, 116, 73, 252, 74, -1, 237, 23, -1, 237, 824 | 24, -1, 237, 71, 206, 72, -1, 116, -1, 5, 825 | -1, 247, -1, 248, -1, 6, -1, 247, 6, -1, 826 | 73, 206, 74, -1, -1, -1, 73, 249, 179, 250, 827 | 74, -1, 206, -1, 208, -1, 252, 65, 208, -1, 828 | 254, 73, 247, 74, 64, -1, 254, 73, 247, 69, 829 | 255, 74, 64, -1, 254, 73, 247, 69, 255, 69, 830 | 255, 74, 64, -1, 254, 73, 247, 69, 255, 69, 831 | 255, 69, 257, 74, 64, -1, 63, -1, 63, 36, 832 | -1, 36, 63, -1, -1, 256, -1, 255, 65, 256, 833 | -1, 71, 3, 72, 247, 73, 206, 74, -1, 71, 834 | 4, 72, 247, 73, 206, 74, -1, 247, 73, 206, 835 | 74, -1, -1, 247, -1, 257, 65, 247, -1, 63, 836 | 73, 247, 74, -1, 21, 198, -1 837 | }; 838 | 839 | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 840 | static const yytype_uint16 yyrline[] = 841 | { 842 | 0, 166, 166, 168, 172, 173, 177, 179, 181, 182, 843 | 188, 190, 196, 198, 203, 209, 210, 212, 214, 217, 844 | 218, 225, 226, 226, 230, 274, 275, 276, 277, 281, 845 | 285, 286, 289, 291, 292, 293, 297, 298, 299, 303, 846 | 304, 308, 309, 313, 314, 320, 321, 323, 327, 330, 847 | 332, 334, 336, 338, 340, 342, 344, 351, 353, 358, 848 | 359, 361, 363, 368, 369, 373, 374, 378, 385, 387, 849 | 387, 387, 394, 398, 400, 405, 407, 409, 413, 418, 850 | 419, 424, 426, 433, 438, 439, 440, 441, 442, 443, 851 | 444, 445, 449, 450, 451, 453, 458, 459, 461, 466, 852 | 467, 468, 469, 470, 471, 475, 479, 483, 487, 489, 853 | 496, 497, 502, 501, 515, 514, 530, 531, 535, 536, 854 | 541, 543, 548, 552, 557, 558, 564, 565, 570, 569, 855 | 583, 582, 598, 603, 604, 610, 611, 616, 615, 629, 856 | 628, 644, 649, 650, 655, 657, 661, 662, 667, 668, 857 | 671, 674, 679, 678, 683, 682, 687, 686, 693, 695, 858 | 701, 702, 706, 711, 713, 718, 722, 723, 732, 731, 859 | 738, 761, 762, 764, 765, 772, 777, 778, 779, 781, 860 | 787, 786, 797, 806, 808, 809, 813, 815, 821, 822, 861 | 828, 831, 837, 839, 841, 848, 849, 850, 851, 852, 862 | 853, 854, 855, 856, 857, 858, 859, 866, 868, 865, 863 | 872, 874, 878, 879, 883, 884, 891, 892, 896, 900, 864 | 906, 907, 908, 912, 917, 916, 923, 924, 925, 926, 865 | 927, 928, 929, 930, 934, 935, 937, 942, 948, 949, 866 | 950, 954, 955, 959, 963, 964, 970, 976, 980, 984, 867 | 988, 992, 996, 997, 1003, 1009, 1010, 1017, 1018, 1019, 868 | 1020, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 869 | 1033, 1034, 1040, 1041, 1043, 1050, 1051, 1058, 1059, 1066, 870 | 1067, 1074, 1075, 1082, 1083, 1090, 1091, 1096, 1097, 1103, 871 | 1104, 1109, 1110, 1111, 1112, 1118, 1119, 1124, 1125, 1131, 872 | 1132, 1137, 1138, 1144, 1145, 1150, 1151, 1152, 1158, 1159, 873 | 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1172, 874 | 1176, 1181, 1183, 1187, 1191, 1196, 1200, 1204, 1206, 1211, 875 | 1216, 1223, 1224, 1225, 1227, 1228, 1229, 1230, 1234, 1235, 876 | 1239, 1243, 1247, 1248, 1252, 1253, 1257, 1261, 1265, 1269, 877 | 1271, 1272, 1273, 1277, 1278, 1282, 1284, 1284, 1284, 1290, 878 | 1294, 1295, 1303, 1304, 1305, 1306, 1310, 1311, 1312, 1315, 879 | 1317, 1318, 1322, 1323, 1324, 1327, 1329, 1330, 1334, 1340 880 | }; 881 | #endif 882 | 883 | #if YYDEBUG || YYERROR_VERBOSE || 0 884 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 885 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 886 | static const char *const yytname[] = 887 | { 888 | "$end", "error", "$undefined", "IDENTIFIER", "TYPE_NAME", "LITERAL", 889 | "STRING_LITERAL", "ELLIPSES", "MUL_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", 890 | "ADD_ASSIGN", "SUB_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", 891 | "XOR_ASSIGN", "OR_ASSIGN", "EQ_OP", "NE_OP", "PTR_OP", "AND_OP", "OR_OP", 892 | "DEC_OP", "INC_OP", "LE_OP", "GE_OP", "LEFT_SHIFT", "RIGHT_SHIFT", 893 | "SIZEOF", "TYPEDEF", "EXTERN", "STATIC", "AUTO", "REGISTER", "CONST", 894 | "VOLATILE", "VOID", "INLINE", "CHAR", "SHORT", "INT", "LONG", "SIGNED", 895 | "UNSIGNED", "FLOAT", "DOUBLE", "BOOL", "STRUCT", "UNION", "ENUM", "CASE", 896 | "DEFAULT", "IF", "ELSE", "SWITCH", "WHILE", "DO", "FOR", "GOTO", 897 | "CONTINUE", "BREAK", "RETURN", "ASM", "';'", "','", "'='", "'{'", "'}'", 898 | "':'", "'.'", "'['", "']'", "'('", "')'", "'*'", "'?'", "'|'", "'^'", 899 | "'&'", "'<'", "'>'", "'+'", "'-'", "'/'", "'%'", "'~'", "'!'", "$accept", 900 | "file", "program", "top_level_declaration", "declaration_list", 901 | "declaration", "declaration_specifiers", "declaration_specifiers1", 902 | "initialized_declarator_list", "$@1", "initialized_declarator", 903 | "initialized_declarator1", "initializer_part", "initializer", 904 | "struct_initializer_list", "named_initializer", "designator", 905 | "designator_list", "named_initializer_index", "abstract_declarator", 906 | "direct_abstract_declarator", "declarator", "pointer", 907 | "direct_declarator", "simple_declarator", "array_declarator", "$@2", 908 | "$@3", "name", "storage_class_specifier", "type_qualifier_list", 909 | "type_qualifier", "type_specifier", "type_specifier1", 910 | "floating_type_specifier", "integer_type_specifier", 911 | "integer_type_specifier_part", "boolean_type_specifier", "typedef_name", 912 | "void_type_specifier", "type_name", "enumeration_type_specifier", 913 | "enumeration_type_definition", "$@4", "$@5", 914 | "enumeration_definition_list", "enumeration_definition_list1", 915 | "enumeration_constant_definition", "enumeration_constant", 916 | "enumeration_type_reference", "enumeration_tag", 917 | "structure_type_specifier", "structure_type_definition", "$@6", "$@7", 918 | "structure_type_reference", "structure_tag", "union_type_specifier", 919 | "union_type_definition", "$@8", "$@9", "union_type_reference", 920 | "union_tag", "field_list", "field_list1", "field_list2", 921 | "component_declaration", "$@10", "$@11", "$@12", 922 | "component_declarator_list", "component_declarator", "simple_component", 923 | "bit_field", "width", "component_name", "function_definition", "$@13", 924 | "function_specifier", "function_specifier1", "function_declarator", 925 | "function_declarator0", "function_direct_declarator", "$@14", 926 | "function_declarator1", "function_declarator2", "identifier_list", 927 | "parameter_type_list", "parameter_list", "parameter_declaration", 928 | "statement", "compound_statement", "$@15", "$@16", 929 | "compound_statement_body", "block_item_list", "block_item", 930 | "conditional_statement", "if_else_statement", "if_statement", 931 | "iterative_statement", "do_statement", "for_statement", "$@17", 932 | "for_expressions", "for_expression_or_declaration", "while_statement", 933 | "labeled_statement", "case_label", "default_label", "named_label", 934 | "switch_statement", "break_statement", "continue_statement", 935 | "expression_statement", "goto_statement", "null_statement", 936 | "return_statement", "expression", "comma_expression", 937 | "assignment_expression", "assignment_op", "conditional_expression", 938 | "logical_or_expression", "logical_and_expression", 939 | "bitwise_or_expression", "bitwise_xor_expression", 940 | "bitwise_and_expression", "equality_expression", "equality_op", 941 | "relational_expression", "relational_op", "shift_expression", "shift_op", 942 | "additive_expression", "add_op", "multiplicative_expression", "mult_op", 943 | "unary_expression", "address_expression", "bitwise_negation_expression", 944 | "cast_expression", "indirection_expression", 945 | "logical_negation_expression", "predecrement_expression", 946 | "preincrement_expression", "sizeof_expression", "unary_minus_expression", 947 | "unary_plus_expression", "postfix_expression", 948 | "component_selection_expression", "direct_component_selection", 949 | "indirect_component_selection", "function_call", "function_call_direct", 950 | "postdecrement_expression", "postincrement_expression", 951 | "subscript_expression", "primary_expression", "string_literal", 952 | "parenthesized_expression", "$@18", "$@19", "constant_expression", 953 | "expression_list", "asm_statement", "asm_type", "asm_inout_list", 954 | "asm_inout", "asm_clobber_list", "asm_label", "named_label_address", YY_NULL 955 | }; 956 | #endif 957 | 958 | # ifdef YYPRINT 959 | /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 960 | token YYLEX-NUM. */ 961 | static const yytype_uint16 yytoknum[] = 962 | { 963 | 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 964 | 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 965 | 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 966 | 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 967 | 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 968 | 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 969 | 315, 316, 317, 318, 59, 44, 61, 123, 125, 58, 970 | 46, 91, 93, 40, 41, 42, 63, 124, 94, 38, 971 | 60, 62, 43, 45, 47, 37, 126, 33 972 | }; 973 | # endif 974 | 975 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 976 | static const yytype_uint16 yyr1[] = 977 | { 978 | 0, 88, 89, 89, 90, 90, 91, 91, 91, 91, 979 | 92, 92, 93, 93, 94, 95, 95, 95, 95, 95, 980 | 95, 96, 97, 96, 98, 99, 99, 99, 99, 100, 981 | 101, 101, 102, 102, 102, 102, 103, 103, 103, 104, 982 | 104, 105, 105, 106, 106, 107, 107, 107, 108, 108, 983 | 108, 108, 108, 108, 108, 108, 108, 109, 109, 110, 984 | 110, 110, 110, 111, 111, 111, 111, 112, 113, 114, 985 | 115, 113, 116, 117, 117, 117, 117, 117, 117, 118, 986 | 118, 119, 119, 120, 121, 121, 121, 121, 121, 121, 987 | 121, 121, 122, 122, 122, 122, 123, 123, 123, 124, 988 | 124, 124, 124, 124, 124, 125, 126, 127, 128, 128, 989 | 129, 129, 131, 130, 132, 130, 133, 133, 134, 134, 990 | 135, 135, 136, 137, 138, 138, 139, 139, 141, 140, 991 | 142, 140, 143, 144, 144, 145, 145, 147, 146, 148, 992 | 146, 149, 150, 150, 151, 151, 152, 152, 153, 153, 993 | 153, 153, 155, 154, 156, 154, 157, 154, 158, 158, 994 | 159, 159, 160, 161, 161, 162, 163, 163, 165, 164, 995 | 166, 167, 167, 167, 167, 168, 169, 169, 169, 169, 996 | 171, 170, 172, 173, 173, 173, 174, 174, 175, 175, 997 | 176, 176, 177, 177, 177, 178, 178, 178, 178, 178, 998 | 178, 178, 178, 178, 178, 178, 178, 180, 181, 179, 999 | 182, 182, 183, 183, 184, 184, 185, 185, 186, 187, 1000 | 188, 188, 188, 189, 191, 190, 192, 192, 192, 192, 1001 | 192, 192, 192, 192, 193, 193, 193, 194, 195, 195, 1002 | 195, 196, 196, 197, 198, 198, 199, 200, 201, 202, 1003 | 203, 204, 205, 205, 206, 207, 207, 208, 208, 208, 1004 | 208, 209, 209, 209, 209, 209, 209, 209, 209, 209, 1005 | 209, 209, 210, 210, 210, 211, 211, 212, 212, 213, 1006 | 213, 214, 214, 215, 215, 216, 216, 217, 217, 218, 1007 | 218, 219, 219, 219, 219, 220, 220, 221, 221, 222, 1008 | 222, 223, 223, 224, 224, 225, 225, 225, 226, 226, 1009 | 226, 226, 226, 226, 226, 226, 226, 226, 226, 227, 1010 | 228, 229, 229, 230, 231, 232, 233, 234, 234, 235, 1011 | 236, 237, 237, 237, 237, 237, 237, 237, 238, 238, 1012 | 239, 240, 241, 241, 242, 242, 243, 244, 245, 246, 1013 | 246, 246, 246, 247, 247, 248, 249, 250, 248, 251, 1014 | 252, 252, 253, 253, 253, 253, 254, 254, 254, 255, 1015 | 255, 255, 256, 256, 256, 257, 257, 257, 258, 259 1016 | }; 1017 | 1018 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1019 | static const yytype_uint8 yyr2[] = 1020 | { 1021 | 0, 2, 0, 1, 1, 2, 1, 1, 1, 1, 1022 | 1, 2, 3, 2, 1, 1, 2, 1, 2, 1, 1023 | 2, 1, 0, 4, 1, 1, 2, 2, 3, 2, 1024 | 1, 3, 0, 1, 3, 2, 1, 3, 3, 2, 1025 | 3, 1, 2, 1, 3, 1, 2, 1, 3, 2, 1026 | 3, 3, 4, 2, 3, 3, 4, 1, 2, 1, 1027 | 2, 2, 3, 1, 3, 1, 1, 1, 3, 0, 1028 | 0, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1029 | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1030 | 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 1031 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1032 | 1, 1, 0, 5, 0, 6, 1, 2, 1, 3, 1033 | 1, 3, 1, 2, 1, 1, 1, 1, 0, 5, 1034 | 0, 6, 2, 1, 1, 1, 1, 0, 5, 0, 1035 | 6, 2, 1, 1, 0, 1, 1, 2, 1, 2, 1036 | 2, 1, 0, 4, 0, 5, 0, 5, 1, 3, 1037 | 1, 1, 1, 2, 3, 1, 1, 1, 0, 3, 1038 | 1, 1, 2, 2, 3, 1, 1, 3, 2, 4, 1039 | 0, 5, 1, 0, 1, 1, 1, 3, 1, 3, 1040 | 1, 3, 2, 1, 2, 1, 1, 1, 1, 1, 1041 | 1, 1, 1, 1, 1, 1, 1, 0, 0, 5, 1042 | 0, 1, 1, 2, 1, 1, 1, 1, 7, 5, 1043 | 1, 1, 1, 7, 0, 6, 2, 3, 3, 3, 1044 | 4, 4, 4, 5, 1, 2, 1, 5, 2, 2, 1045 | 2, 2, 4, 1, 1, 1, 5, 2, 2, 2, 1046 | 3, 1, 2, 3, 1, 1, 3, 1, 1, 3, 1047 | 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1048 | 1, 1, 1, 5, 4, 1, 3, 1, 3, 1, 1049 | 3, 1, 3, 1, 3, 1, 3, 1, 1, 1, 1050 | 3, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1051 | 3, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1052 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1053 | 2, 4, 6, 2, 2, 2, 2, 4, 2, 2, 1054 | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1055 | 3, 3, 3, 4, 3, 4, 2, 2, 4, 1, 1056 | 1, 1, 1, 1, 2, 3, 0, 0, 5, 1, 1057 | 1, 3, 5, 7, 9, 11, 1, 2, 2, 0, 1058 | 1, 3, 7, 7, 4, 0, 1, 3, 4, 2 1059 | }; 1060 | 1061 | /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. 1062 | Performed when YYTABLE doesn't specify something else to do. Zero 1063 | means the default is an error. */ 1064 | static const yytype_uint16 yydefact[] = 1065 | { 1066 | 2, 67, 106, 77, 74, 76, 73, 75, 81, 82, 1067 | 107, 78, 101, 102, 103, 104, 99, 100, 92, 93, 1068 | 105, 0, 0, 0, 366, 251, 0, 59, 0, 3, 1069 | 4, 6, 0, 14, 0, 182, 63, 65, 15, 19, 1070 | 17, 83, 85, 86, 96, 87, 89, 91, 84, 110, 1071 | 111, 88, 126, 127, 90, 135, 136, 7, 168, 170, 1072 | 171, 175, 176, 0, 9, 8, 0, 368, 95, 94, 1073 | 133, 134, 128, 132, 142, 143, 137, 141, 124, 125, 1074 | 112, 123, 367, 0, 0, 0, 57, 66, 82, 61, 1075 | 60, 79, 1, 5, 13, 0, 21, 24, 25, 0, 1076 | 172, 0, 178, 69, 16, 20, 18, 104, 98, 97, 1077 | 0, 173, 10, 0, 180, 0, 144, 130, 144, 139, 1078 | 0, 114, 66, 64, 58, 177, 62, 80, 12, 22, 1079 | 0, 0, 27, 26, 174, 66, 68, 0, 207, 169, 1080 | 11, 183, 353, 0, 148, 0, 152, 126, 135, 0, 1081 | 145, 146, 151, 144, 0, 144, 122, 0, 116, 118, 1082 | 120, 0, 0, 0, 72, 350, 0, 0, 0, 0, 1083 | 32, 356, 0, 0, 0, 0, 0, 0, 29, 349, 1084 | 30, 257, 272, 275, 277, 279, 281, 283, 285, 289, 1085 | 295, 299, 303, 308, 309, 310, 311, 312, 313, 314, 1086 | 315, 316, 317, 318, 331, 338, 339, 332, 333, 334, 1087 | 335, 336, 337, 351, 352, 258, 28, 179, 359, 254, 1088 | 255, 70, 210, 186, 193, 0, 185, 184, 188, 190, 1089 | 354, 369, 0, 154, 156, 0, 149, 150, 129, 147, 1090 | 0, 138, 0, 113, 117, 0, 0, 23, 0, 244, 1091 | 245, 379, 325, 326, 356, 328, 72, 167, 0, 0, 1092 | 36, 0, 33, 41, 0, 0, 108, 0, 0, 0, 1093 | 323, 319, 330, 329, 320, 324, 0, 0, 0, 0, 1094 | 0, 0, 0, 287, 288, 0, 292, 294, 291, 293, 1095 | 0, 297, 298, 0, 301, 302, 0, 305, 306, 307, 1096 | 0, 262, 263, 264, 265, 266, 267, 268, 269, 270, 1097 | 271, 261, 0, 0, 346, 347, 0, 0, 0, 0, 1098 | 0, 72, 106, 0, 243, 0, 0, 0, 0, 224, 1099 | 0, 0, 0, 0, 215, 214, 196, 208, 211, 212, 1100 | 197, 217, 216, 198, 220, 221, 222, 199, 0, 0, 1101 | 0, 200, 201, 202, 203, 204, 205, 206, 0, 195, 1102 | 0, 0, 194, 47, 192, 45, 181, 0, 0, 0, 1103 | 0, 0, 370, 362, 0, 0, 0, 162, 0, 158, 1104 | 160, 161, 131, 140, 119, 121, 115, 378, 0, 166, 1105 | 39, 0, 43, 35, 31, 0, 42, 0, 0, 109, 1106 | 45, 0, 355, 357, 344, 360, 0, 276, 303, 0, 1107 | 0, 278, 280, 282, 284, 286, 290, 296, 300, 304, 1108 | 32, 259, 341, 340, 0, 342, 0, 256, 71, 241, 1109 | 0, 0, 0, 0, 0, 0, 0, 248, 247, 252, 1110 | 0, 0, 213, 238, 240, 239, 249, 49, 0, 53, 1111 | 0, 0, 0, 0, 46, 187, 189, 191, 0, 0, 1112 | 0, 0, 369, 0, 0, 0, 163, 165, 0, 153, 1113 | 0, 327, 40, 0, 34, 38, 37, 32, 321, 0, 1114 | 0, 345, 274, 0, 0, 348, 343, 0, 0, 0, 1115 | 0, 0, 0, 250, 253, 209, 51, 48, 55, 50, 1116 | 0, 54, 0, 0, 0, 0, 371, 0, 363, 155, 1117 | 157, 164, 159, 44, 0, 358, 361, 273, 260, 242, 1118 | 0, 0, 0, 0, 0, 236, 0, 0, 234, 52, 1119 | 56, 0, 0, 374, 375, 0, 322, 219, 246, 237, 1120 | 0, 226, 0, 235, 0, 0, 0, 0, 376, 0, 1121 | 364, 0, 0, 229, 228, 225, 227, 0, 0, 0, 1122 | 0, 0, 218, 223, 230, 231, 232, 372, 373, 377, 1123 | 365, 233 1124 | }; 1125 | 1126 | /* YYDEFGOTO[NTERM-NUM]. */ 1127 | static const yytype_int16 yydefgoto[] = 1128 | { 1129 | -1, 28, 29, 30, 111, 31, 113, 33, 95, 162, 1130 | 96, 97, 132, 260, 261, 262, 263, 264, 391, 450, 1131 | 363, 84, 85, 86, 36, 37, 137, 320, 179, 38, 1132 | 145, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1133 | 267, 48, 49, 120, 161, 157, 158, 159, 160, 50, 1134 | 81, 51, 52, 116, 153, 53, 73, 54, 55, 118, 1135 | 155, 56, 77, 149, 150, 151, 152, 235, 374, 375, 1136 | 378, 379, 380, 381, 466, 265, 57, 110, 58, 59, 1137 | 60, 61, 122, 141, 63, 225, 226, 451, 228, 229, 1138 | 335, 336, 222, 441, 337, 338, 339, 340, 341, 342, 1139 | 343, 344, 345, 435, 526, 527, 346, 347, 348, 349, 1140 | 350, 351, 352, 353, 354, 355, 356, 357, 358, 219, 1141 | 220, 312, 181, 182, 183, 184, 185, 186, 187, 285, 1142 | 188, 290, 189, 293, 190, 296, 191, 300, 192, 193, 1143 | 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 1144 | 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 1145 | 214, 269, 479, 221, 406, 359, 66, 371, 372, 549, 1146 | 133, 215 1147 | }; 1148 | 1149 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1150 | STATE-NUM. */ 1151 | #define YYPACT_NINF -406 1152 | static const yytype_int16 yypact[] = 1153 | { 1154 | 1192, -406, -406, -406, -406, -406, -406, -406, -406, -1, 1155 | -406, -406, -406, -406, -406, 21, -406, -406, -406, 36, 1156 | -406, 53, 57, 61, 62, -406, 43, 120, 151, 1192, 1157 | -406, -406, 19, -406, 14, 104, -406, -406, 1450, 1450, 1158 | 1450, -406, -406, 386, 126, -406, -406, -406, -406, -406, 1159 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406, 1160 | 1450, -406, 332, 106, -406, -406, 117, -406, -406, -406, 1161 | -406, -406, -406, 129, -406, -406, -406, 165, -406, -406, 1162 | -406, 188, -406, 43, 130, 39, -3, 144, -406, -406, 1163 | 120, -406, -406, -406, -406, 223, -406, -406, 78, 14, 1164 | 1450, 43, 332, 152, -406, -406, -406, -406, -406, -406, 1165 | 200, 1450, -406, 38, -406, 235, 417, -406, 417, -406, 1166 | 248, -406, -406, -406, -3, -406, -406, -406, -406, -406, 1167 | 187, 301, -406, 209, 1450, 205, -406, 1042, -406, -406, 1168 | -406, 1382, -406, 30, -406, 1257, 126, 218, 220, 237, 1169 | 417, -406, -406, 417, 251, 417, -406, 253, 264, -406, 1170 | 273, 248, 43, 235, -406, -406, 287, 1107, 1107, 1132, 1171 | 210, 636, 1107, 1107, 1107, 1107, 1107, 1107, -406, 281, 1172 | -406, -406, 1, 325, 279, 284, 278, 276, 140, 275, 1173 | 244, 103, 300, -406, -406, -406, -406, -406, -406, -406, 1174 | -406, -406, -406, 174, -406, -406, -406, -406, -406, -406, 1175 | -406, -406, -406, 353, -406, -406, -406, -406, -406, 306, 1176 | -406, -406, 466, -406, 137, 299, 313, -406, 314, -406, 1177 | -406, 68, 317, -406, 126, 11, -406, -406, -406, -406, 1178 | 318, -406, 326, -406, 248, 1042, 338, -406, 41, -406, 1179 | -406, -406, -406, -406, 636, -406, 316, -406, 328, 1042, 1180 | -406, 32, -406, -406, 192, 324, 193, 308, 333, 200, 1181 | -406, -406, -406, -406, -406, -406, 85, 1107, 755, 1107, 1182 | 1107, 1107, 1107, -406, -406, 1107, -406, -406, -406, -406, 1183 | 1107, -406, -406, 1107, -406, -406, 1107, -406, -406, -406, 1184 | 1107, -406, -406, -406, -406, -406, -406, -406, -406, -406, 1185 | -406, -406, 777, 328, -406, -406, 328, 1042, 802, 1042, 1186 | 336, 341, 342, 1042, -406, 339, 343, 344, 684, -406, 1187 | 415, 355, 359, 877, -406, -406, -406, -406, 466, -406, 1188 | -406, -406, -406, -406, -406, -406, -406, -406, 362, 363, 1189 | 364, -406, -406, -406, -406, -406, -406, -406, 371, -406, 1190 | 899, 1240, -406, 169, -406, 52, -406, 433, 1403, 330, 1191 | 28, 161, -406, -406, 11, 11, 1042, 368, 272, -406, 1192 | -406, -406, -406, -406, -406, -406, -406, -406, 365, -406, 1193 | -406, 369, 435, 210, -406, 301, -406, 301, 1287, -406, 1194 | 199, 1085, -406, -406, -406, -406, 89, 325, -406, 1107, 1195 | 374, 279, 284, 278, 276, 140, 275, 244, 103, -406, 1196 | 210, -406, -406, -406, 372, -406, 109, -406, -406, 438, 1197 | 1042, 1042, 1042, -1, 384, 375, 383, -406, -406, -406, 1198 | 385, 382, -406, -406, -406, -406, -406, -406, 379, -406, 1199 | 394, 399, 924, 1334, 169, -406, -406, -406, 402, 403, 1200 | 1042, 68, 68, 412, 280, 286, -406, -406, 1042, -406, 1201 | 11, 1085, -406, 1042, -406, -406, -406, 210, -406, 404, 1202 | 1042, -406, -406, 1107, 157, -406, -406, 1042, 405, 406, 1203 | 408, 410, 551, -406, -406, -406, -406, -406, -406, -406, 1204 | 413, -406, 414, 235, 235, 418, -406, 185, -406, -406, 1205 | -406, -406, -406, -406, 184, -406, -406, -406, -406, -406, 1206 | 684, 684, 684, 1042, 995, 43, 446, 420, -406, -406, 1207 | -406, 34, 46, -406, 235, 422, -406, 423, -406, -406, 1208 | 457, 1042, 427, 467, 684, 1020, 1042, 1042, 353, 115, 1209 | -406, 684, 470, -406, 1042, -406, 1042, 471, 462, 463, 1210 | 235, 474, -406, -406, -406, -406, 1042, -406, -406, 353, 1211 | -406, -406 1212 | }; 1213 | 1214 | /* YYPGOTO[NTERM-NUM]. */ 1215 | static const yytype_int16 yypgoto[] = 1216 | { 1217 | -406, -406, -406, 511, 442, -52, 2, 5, 18, -406, 1218 | 388, -406, 411, -124, -405, 153, 283, -406, -406, -170, 1219 | -347, -32, 3, 4, -406, -406, -406, -406, -406, -406, 1220 | -11, 31, 93, -406, -406, -406, 508, -406, -406, -406, 1221 | 304, -406, -406, -406, -406, 398, -406, 319, -406, -406, 1222 | -406, -406, 222, -406, -406, -406, -406, -406, 249, -406, 1223 | -406, -406, -406, 64, -406, 416, -406, -406, -406, -406, 1224 | -22, 90, -406, -406, 94, -163, -406, -406, -406, -406, 1225 | 529, -406, 37, -406, -406, -406, -406, -135, -406, 196, 1226 | -315, -100, -406, -406, -406, -406, 227, -406, -406, -406, 1227 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406, 1228 | 401, -406, -406, -406, -406, -406, 50, -406, -132, -406, 1229 | -119, -406, -398, -406, 291, 290, 293, 289, 294, -406, 1230 | 292, -406, 288, -406, 309, -406, 307, -406, -148, -406, 1231 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406, 1232 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -114, 1233 | -406, -406, -406, -250, 261, 76, -406, 142, 110, -406, 1234 | -406, -406 1235 | }; 1236 | 1237 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1238 | positive, shift that token. If negative, reduce the rule which 1239 | number is the opposite. If YYTABLE_NINF, syntax error. */ 1240 | #define YYTABLE_NINF -246 1241 | static const yytype_int16 yytable[] = 1242 | { 1243 | 98, 143, 32, 34, 35, 218, 227, 178, 112, 392, 1244 | 139, 482, 180, 434, 1, 484, 90, 1, 454, 252, 1245 | 253, 255, 1, 277, 270, 271, 272, 273, 274, 275, 1246 | 89, 32, 34, 35, 230, 99, 230, 62, 35, 268, 1247 | 230, 1, 1, 104, 105, 106, 1, 230, 112, 248, 1248 | 64, 180, 230, 454, 362, 1, 70, 71, 91, 140, 1249 | 74, 75, 67, 87, 78, 79, 62, 68, 103, 62, 1250 | -182, 102, 514, 429, 142, 109, 65, 278, 69, 64, 1251 | 376, 98, 140, 94, 83, 517, 27, 101, 164, 124, 1252 | 165, 142, 26, 126, 27, 390, 399, 393, 82, 231, 1253 | 394, 460, 94, 124, 232, 65, 166, 546, 167, 168, 1254 | 448, 83, 83, 27, 169, 387, 83, 370, 27, 547, 1255 | 72, 127, 268, 360, 76, 361, 385, 218, 80, 408, 1256 | 98, 408, 408, 408, 408, 234, 102, 408, 135, 369, 1257 | 1, 130, 408, 224, 131, 408, 410, 91, 408, 91, 1258 | 422, 92, 419, 423, 480, 8, 88, 405, 171, 404, 1259 | 172, 8, 88, 481, 173, 286, 287, 174, 175, 403, 1260 | 334, 176, 177, 266, 480, 103, 127, 91, 297, 114, 1261 | 560, 91, 154, 486, 91, 424, 91, 298, 299, 561, 1262 | 115, 218, 364, 421, 313, 27, 117, 314, 315, 405, 1263 | 427, 440, 500, 377, 123, 537, 538, 539, 360, 146, 1264 | 361, 146, 27, 256, 257, 165, 142, 240, 125, 242, 1265 | 288, 289, 393, 513, 136, 518, 461, 365, 218, 555, 1266 | 462, 166, 119, 167, 168, 463, 562, 519, 233, 169, 1267 | 452, 142, 453, 146, 316, 317, 146, 318, 146, 393, 1268 | 461, 156, 536, 478, 534, 121, 266, 467, 395, 535, 1269 | 163, 408, 258, 259, 360, 127, 398, 138, 27, 400, 1270 | 360, 475, 398, 476, 180, 131, 180, 170, 180, 217, 1271 | 258, 259, 236, 171, 237, 172, 334, 128, 129, 173, 1272 | 249, 250, 174, 175, 283, 284, 176, 177, 488, 489, 1273 | 490, 180, 291, 292, 164, 238, 165, 142, 301, 302, 1274 | 303, 304, 305, 306, 307, 308, 309, 310, 502, 241, 1275 | 218, 243, 166, 478, 167, 168, 294, 295, 505, 244, 1276 | 169, 389, 257, 458, 459, 408, 469, 470, 147, 245, 1277 | 147, 218, 377, 377, 509, 470, 279, 370, 370, 467, 1278 | 510, 470, 464, 465, 276, 218, 280, 282, 180, 230, 1279 | 528, 516, 281, 224, 365, 148, 311, 148, 170, 124, 1280 | 224, 319, 147, 366, 171, 147, 172, 147, 367, 368, 1281 | 173, 373, 401, 174, 175, -166, 382, 176, 177, 531, 1282 | 532, 540, 542, 397, 383, -66, -66, -66, -66, 148, 1283 | 224, 400, 148, -66, 148, -66, 386, 402, 428, 553, 1284 | -244, -245, 430, 557, 558, 559, 431, 432, 436, 437, 1285 | 548, 2, 564, 438, 565, 12, 13, 14, 107, 16, 1286 | 17, 443, 444, 445, 571, 446, 455, 468, 377, 471, 1287 | 491, 472, 473, 483, 485, 487, 569, 493, 492, 494, 1288 | 495, 496, 8, 88, 10, 224, 12, 13, 14, 15, 1289 | 16, 17, 18, 19, 20, 21, 22, 23, 497, 321, 1290 | 322, 165, 142, 498, 503, 504, 508, 551, 515, 520, 1291 | 521, 144, 522, 523, 545, 529, 550, 166, 530, 167, 1292 | 168, 554, 533, 98, 525, 169, 3, 4, 5, 6, 1293 | 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1294 | 17, 18, 19, 20, 21, 22, 23, 323, 324, 325, 1295 | 544, 326, 327, 328, 329, 330, 331, 332, 333, 24, 1296 | 25, 552, 129, 138, 563, 566, 567, 568, 570, 171, 1297 | 93, 172, 134, 543, 216, 173, 474, 396, 174, 175, 1298 | 247, 108, 176, 177, 164, 2, 165, 142, 388, 246, 1299 | 512, 100, 511, 384, 457, 442, 239, 251, 407, 411, 1300 | 413, 506, 166, 412, 167, 168, 414, 415, 416, 426, 1301 | 169, 3, 4, 5, 6, 7, 8, 88, 10, 11, 1302 | 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 1303 | 22, 23, 417, 418, 507, 0, 0, 0, 0, 0, 1304 | 0, 0, 0, 0, 0, 524, 0, 0, 0, 0, 1305 | 0, 0, 0, 0, 171, 0, 172, 0, 0, 0, 1306 | 173, 0, 0, 174, 175, 0, 0, 176, 177, 164, 1307 | 2, 165, 142, 0, 0, 0, 0, 0, 0, 0, 1308 | 0, 0, 0, 0, 0, 0, 0, 166, 0, 167, 1309 | 168, 0, 0, 0, 0, 169, 3, 4, 5, 6, 1310 | 7, 8, 88, 10, 11, 12, 13, 14, 15, 16, 1311 | 17, 18, 19, 20, 21, 22, 23, 321, 250, 165, 1312 | 142, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1313 | 0, 0, 0, 0, 0, 166, 0, 167, 168, 171, 1314 | 0, 172, 0, 169, 0, 173, 0, 0, 174, 175, 1315 | 433, 0, 176, 177, 0, 0, 0, 0, 0, 0, 1316 | 0, 0, 0, 0, 0, 323, 324, 325, 0, 326, 1317 | 327, 328, 329, 330, 331, 332, 333, 24, 25, 0, 1318 | 0, 138, 0, 0, 0, 0, 0, 171, 164, 172, 1319 | 165, 142, 0, 173, 0, 0, 174, 175, 0, 0, 1320 | 176, 177, 0, 0, 0, 0, 166, 0, 167, 168, 1321 | 164, 0, 165, 142, 169, 0, 0, 0, 0, 0, 1322 | 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 1323 | 167, 168, 0, 0, 0, 164, 169, 165, 142, 0, 1324 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1325 | 0, 0, 0, 166, 409, 167, 168, 0, 171, 0, 1326 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0, 1327 | 0, 176, 177, 0, 420, 0, 0, 0, 0, 0, 1328 | 171, 0, 172, 0, 0, 0, 173, 0, 0, 174, 1329 | 175, 0, 0, 176, 177, 0, 0, 0, 0, 0, 1330 | 0, 0, 0, 0, 0, 171, 425, 172, 0, 0, 1331 | 164, 173, 165, 142, 174, 175, 0, 0, 176, 177, 1332 | 0, 0, 0, 0, 0, 0, 0, 0, 166, 0, 1333 | 167, 168, 164, 0, 165, 142, 169, 0, 0, 0, 1334 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1335 | 166, 0, 167, 168, 0, 0, 0, 164, 169, 165, 1336 | 142, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1337 | 0, 439, 0, 0, 0, 166, 0, 167, 168, 0, 1338 | 171, 0, 172, 169, 0, 0, 173, 0, 0, 174, 1339 | 175, 0, 0, 176, 177, 0, 0, 0, 0, 0, 1340 | 0, 447, 171, 0, 172, 0, 0, 0, 173, 0, 1341 | 0, 174, 175, 0, 0, 176, 177, 0, 0, 0, 1342 | 0, 0, 0, 0, 0, 0, 499, 171, 164, 172, 1343 | 165, 142, 0, 173, 0, 0, 174, 175, 0, 0, 1344 | 176, 177, 0, 0, 0, 0, 166, 0, 167, 168, 1345 | 0, 0, 0, 164, 169, 165, 142, 0, 0, 0, 1346 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1347 | 0, 166, 0, 167, 168, 164, 0, 165, 142, 169, 1348 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, 1349 | 0, 0, 0, 166, 0, 167, 168, 0, 171, 0, 1350 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0, 1351 | 0, 176, 177, 0, 556, 0, 0, 0, 164, 0, 1352 | 165, 142, 0, 171, 0, 172, 0, 0, 0, 173, 1353 | 0, 0, 174, 175, 0, 0, 176, 177, 167, 168, 1354 | 164, 0, 165, 142, 169, 171, 0, 172, 0, 0, 1355 | 0, 173, 0, 0, 174, 175, 0, 0, 176, 177, 1356 | 167, 168, 0, 0, 0, 164, 169, 165, 142, 0, 1357 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1358 | 0, 0, 477, 0, 0, 167, 168, 0, 171, 0, 1359 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0, 1360 | 0, 176, 177, 0, 0, 0, 0, 0, 0, 0, 1361 | 171, 0, 172, 0, 0, 0, 173, 0, 0, 174, 1362 | 175, 0, 0, 176, 177, 1, 2, 0, 0, 0, 1363 | 0, 0, 0, 0, 0, 254, 0, 172, 0, 0, 1364 | 0, 173, 0, 0, 174, 175, 0, 0, 176, 177, 1365 | 0, 0, 3, 4, 5, 6, 7, 8, 9, 10, 1366 | 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1367 | 21, 22, 23, 1, 2, 0, 0, 0, 0, 0, 1368 | 0, 0, 0, 0, 0, 24, 25, 0, 0, 0, 1369 | 0, 2, 0, 0, 0, 26, 0, 27, 0, 0, 1370 | 3, 4, 5, 6, 7, 8, 88, 10, 11, 12, 1371 | 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 1372 | 23, 2, 8, 88, 10, 0, 12, 13, 14, 15, 1373 | 16, 17, 18, 19, 20, 21, 22, 23, 0, 0, 1374 | 0, 360, 0, 361, 449, 27, 0, 3, 4, 5, 1375 | 6, 7, 8, 88, 10, 11, 12, 13, 14, 15, 1376 | 16, 17, 18, 19, 20, 21, 22, 23, 2, 0, 1377 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1378 | 0, 0, 0, 0, 0, 0, 0, 0, 360, 0, 1379 | 398, 449, 27, 0, 3, 4, 5, 6, 7, 8, 1380 | 88, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1381 | 19, 20, 21, 22, 23, 223, 2, 0, 0, 0, 1382 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1383 | 0, 0, 0, 0, 0, 0, 0, 2, 501, 0, 1384 | 456, 0, 3, 4, 5, 6, 7, 8, 88, 10, 1385 | 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1386 | 21, 22, 23, 3, 4, 5, 6, 7, 8, 88, 1387 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1388 | 20, 21, 22, 23, 2, 0, 0, 0, 0, 0, 1389 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1390 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1391 | 3, 4, 5, 6, 7, 8, 88, 10, 11, 12, 1392 | 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 1393 | 23 1394 | }; 1395 | 1396 | #define yypact_value_is_default(yystate) \ 1397 | ((yystate) == (-406)) 1398 | 1399 | #define yytable_value_is_error(yytable_value) \ 1400 | YYID (0) 1401 | 1402 | static const yytype_int16 yycheck[] = 1403 | { 1404 | 32, 115, 0, 0, 0, 137, 141, 131, 60, 259, 1405 | 110, 409, 131, 328, 3, 420, 27, 3, 365, 167, 1406 | 168, 169, 3, 22, 172, 173, 174, 175, 176, 177, 1407 | 27, 29, 29, 29, 6, 32, 6, 0, 34, 171, 1408 | 6, 3, 3, 38, 39, 40, 3, 6, 100, 163, 1409 | 0, 170, 6, 400, 224, 3, 3, 4, 27, 111, 1410 | 3, 4, 63, 26, 3, 4, 29, 46, 71, 32, 1411 | 73, 34, 477, 323, 6, 44, 0, 76, 42, 29, 1412 | 69, 113, 134, 64, 73, 483, 75, 73, 3, 85, 1413 | 5, 6, 73, 90, 75, 258, 266, 65, 36, 69, 1414 | 68, 73, 64, 99, 74, 29, 21, 73, 23, 24, 1415 | 360, 73, 73, 75, 29, 74, 73, 231, 75, 73, 1416 | 67, 90, 254, 71, 67, 73, 245, 259, 67, 277, 1417 | 162, 279, 280, 281, 282, 146, 99, 285, 101, 71, 1418 | 3, 63, 290, 141, 66, 293, 278, 116, 296, 118, 1419 | 313, 0, 300, 316, 65, 35, 36, 276, 73, 74, 1420 | 75, 35, 36, 74, 79, 25, 26, 82, 83, 269, 1421 | 222, 86, 87, 171, 65, 71, 145, 146, 75, 73, 1422 | 65, 150, 118, 74, 153, 317, 155, 84, 85, 74, 1423 | 73, 323, 224, 312, 20, 75, 67, 23, 24, 318, 1424 | 319, 333, 452, 235, 74, 520, 521, 522, 71, 116, 1425 | 73, 118, 75, 3, 4, 5, 6, 153, 74, 155, 1426 | 80, 81, 65, 473, 72, 68, 65, 224, 360, 544, 1427 | 69, 21, 67, 23, 24, 74, 551, 487, 145, 29, 1428 | 71, 6, 73, 150, 70, 71, 153, 73, 155, 65, 1429 | 65, 3, 68, 401, 69, 67, 254, 376, 66, 74, 1430 | 73, 409, 70, 71, 71, 234, 73, 67, 75, 266, 1431 | 71, 395, 73, 397, 393, 66, 395, 67, 397, 74, 1432 | 70, 71, 64, 73, 64, 75, 338, 64, 65, 79, 1433 | 3, 4, 82, 83, 18, 19, 86, 87, 430, 431, 1434 | 432, 420, 27, 28, 3, 68, 5, 6, 8, 9, 1435 | 10, 11, 12, 13, 14, 15, 16, 17, 453, 68, 1436 | 452, 68, 21, 471, 23, 24, 82, 83, 460, 65, 1437 | 29, 3, 4, 3, 4, 483, 64, 65, 116, 66, 1438 | 118, 473, 374, 375, 64, 65, 21, 461, 462, 468, 1439 | 64, 65, 374, 375, 73, 487, 77, 79, 477, 6, 1440 | 492, 480, 78, 361, 361, 116, 66, 118, 67, 365, 1441 | 368, 65, 150, 74, 73, 153, 75, 155, 65, 65, 1442 | 79, 64, 74, 82, 83, 69, 68, 86, 87, 503, 1443 | 504, 523, 524, 69, 68, 63, 64, 65, 66, 150, 1444 | 398, 398, 153, 71, 155, 73, 68, 74, 72, 541, 1445 | 69, 69, 73, 545, 546, 547, 73, 73, 3, 64, 1446 | 534, 4, 554, 64, 556, 39, 40, 41, 42, 43, 1447 | 44, 69, 69, 69, 566, 64, 3, 69, 470, 74, 1448 | 56, 72, 7, 69, 72, 7, 560, 64, 73, 64, 1449 | 68, 72, 35, 36, 37, 453, 39, 40, 41, 42, 1450 | 43, 44, 45, 46, 47, 48, 49, 50, 74, 3, 1451 | 4, 5, 6, 74, 72, 72, 64, 54, 74, 74, 1452 | 74, 64, 74, 73, 64, 72, 64, 21, 74, 23, 1453 | 24, 64, 74, 525, 492, 29, 30, 31, 32, 33, 1454 | 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 1455 | 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 1456 | 74, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1457 | 64, 74, 65, 67, 64, 64, 74, 74, 64, 73, 1458 | 29, 75, 100, 525, 133, 79, 393, 264, 82, 83, 1459 | 162, 43, 86, 87, 3, 4, 5, 6, 254, 161, 1460 | 470, 32, 468, 244, 368, 338, 150, 166, 277, 279, 1461 | 281, 461, 21, 280, 23, 24, 282, 285, 290, 318, 1462 | 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 1463 | 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 1464 | 49, 50, 293, 296, 462, -1, -1, -1, -1, -1, 1465 | -1, -1, -1, -1, -1, 64, -1, -1, -1, -1, 1466 | -1, -1, -1, -1, 73, -1, 75, -1, -1, -1, 1467 | 79, -1, -1, 82, 83, -1, -1, 86, 87, 3, 1468 | 4, 5, 6, -1, -1, -1, -1, -1, -1, -1, 1469 | -1, -1, -1, -1, -1, -1, -1, 21, -1, 23, 1470 | 24, -1, -1, -1, -1, 29, 30, 31, 32, 33, 1471 | 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 1472 | 44, 45, 46, 47, 48, 49, 50, 3, 4, 5, 1473 | 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1474 | -1, -1, -1, -1, -1, 21, -1, 23, 24, 73, 1475 | -1, 75, -1, 29, -1, 79, -1, -1, 82, 83, 1476 | 36, -1, 86, 87, -1, -1, -1, -1, -1, -1, 1477 | -1, -1, -1, -1, -1, 51, 52, 53, -1, 55, 1478 | 56, 57, 58, 59, 60, 61, 62, 63, 64, -1, 1479 | -1, 67, -1, -1, -1, -1, -1, 73, 3, 75, 1480 | 5, 6, -1, 79, -1, -1, 82, 83, -1, -1, 1481 | 86, 87, -1, -1, -1, -1, 21, -1, 23, 24, 1482 | 3, -1, 5, 6, 29, -1, -1, -1, -1, -1, 1483 | -1, -1, -1, -1, -1, -1, -1, -1, 21, -1, 1484 | 23, 24, -1, -1, -1, 3, 29, 5, 6, -1, 1485 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1486 | -1, -1, -1, 21, 69, 23, 24, -1, 73, -1, 1487 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1, 1488 | -1, 86, 87, -1, 67, -1, -1, -1, -1, -1, 1489 | 73, -1, 75, -1, -1, -1, 79, -1, -1, 82, 1490 | 83, -1, -1, 86, 87, -1, -1, -1, -1, -1, 1491 | -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, 1492 | 3, 79, 5, 6, 82, 83, -1, -1, 86, 87, 1493 | -1, -1, -1, -1, -1, -1, -1, -1, 21, -1, 1494 | 23, 24, 3, -1, 5, 6, 29, -1, -1, -1, 1495 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1496 | 21, -1, 23, 24, -1, -1, -1, 3, 29, 5, 1497 | 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1498 | -1, 64, -1, -1, -1, 21, -1, 23, 24, -1, 1499 | 73, -1, 75, 29, -1, -1, 79, -1, -1, 82, 1500 | 83, -1, -1, 86, 87, -1, -1, -1, -1, -1, 1501 | -1, 72, 73, -1, 75, -1, -1, -1, 79, -1, 1502 | -1, 82, 83, -1, -1, 86, 87, -1, -1, -1, 1503 | -1, -1, -1, -1, -1, -1, 72, 73, 3, 75, 1504 | 5, 6, -1, 79, -1, -1, 82, 83, -1, -1, 1505 | 86, 87, -1, -1, -1, -1, 21, -1, 23, 24, 1506 | -1, -1, -1, 3, 29, 5, 6, -1, -1, -1, 1507 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1508 | -1, 21, -1, 23, 24, 3, -1, 5, 6, 29, 1509 | -1, -1, -1, -1, -1, -1, -1, -1, -1, 64, 1510 | -1, -1, -1, 21, -1, 23, 24, -1, 73, -1, 1511 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1, 1512 | -1, 86, 87, -1, 64, -1, -1, -1, 3, -1, 1513 | 5, 6, -1, 73, -1, 75, -1, -1, -1, 79, 1514 | -1, -1, 82, 83, -1, -1, 86, 87, 23, 24, 1515 | 3, -1, 5, 6, 29, 73, -1, 75, -1, -1, 1516 | -1, 79, -1, -1, 82, 83, -1, -1, 86, 87, 1517 | 23, 24, -1, -1, -1, 3, 29, 5, 6, -1, 1518 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1519 | -1, -1, 67, -1, -1, 23, 24, -1, 73, -1, 1520 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1, 1521 | -1, 86, 87, -1, -1, -1, -1, -1, -1, -1, 1522 | 73, -1, 75, -1, -1, -1, 79, -1, -1, 82, 1523 | 83, -1, -1, 86, 87, 3, 4, -1, -1, -1, 1524 | -1, -1, -1, -1, -1, 73, -1, 75, -1, -1, 1525 | -1, 79, -1, -1, 82, 83, -1, -1, 86, 87, 1526 | -1, -1, 30, 31, 32, 33, 34, 35, 36, 37, 1527 | 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1528 | 48, 49, 50, 3, 4, -1, -1, -1, -1, -1, 1529 | -1, -1, -1, -1, -1, 63, 64, -1, -1, -1, 1530 | -1, 4, -1, -1, -1, 73, -1, 75, -1, -1, 1531 | 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1532 | 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1533 | 50, 4, 35, 36, 37, -1, 39, 40, 41, 42, 1534 | 43, 44, 45, 46, 47, 48, 49, 50, -1, -1, 1535 | -1, 71, -1, 73, 74, 75, -1, 30, 31, 32, 1536 | 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 1537 | 43, 44, 45, 46, 47, 48, 49, 50, 4, -1, 1538 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1539 | -1, -1, -1, -1, -1, -1, -1, -1, 71, -1, 1540 | 73, 74, 75, -1, 30, 31, 32, 33, 34, 35, 1541 | 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 1542 | 46, 47, 48, 49, 50, 3, 4, -1, -1, -1, 1543 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1544 | -1, -1, -1, -1, -1, -1, -1, 4, 74, -1, 1545 | 7, -1, 30, 31, 32, 33, 34, 35, 36, 37, 1546 | 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 1547 | 48, 49, 50, 30, 31, 32, 33, 34, 35, 36, 1548 | 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 1549 | 47, 48, 49, 50, 4, -1, -1, -1, -1, -1, 1550 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1551 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1552 | 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1553 | 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1554 | 50 1555 | }; 1556 | 1557 | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1558 | symbol of state STATE-NUM. */ 1559 | static const yytype_uint16 yystos[] = 1560 | { 1561 | 0, 3, 4, 30, 31, 32, 33, 34, 35, 36, 1562 | 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 1563 | 47, 48, 49, 50, 63, 64, 73, 75, 89, 90, 1564 | 91, 93, 94, 95, 110, 111, 112, 113, 117, 119, 1565 | 120, 121, 122, 123, 124, 125, 126, 127, 129, 130, 1566 | 137, 139, 140, 143, 145, 146, 149, 164, 166, 167, 1567 | 168, 169, 170, 172, 204, 253, 254, 63, 46, 42, 1568 | 3, 4, 67, 144, 3, 4, 67, 150, 3, 4, 1569 | 67, 138, 36, 73, 109, 110, 111, 170, 36, 110, 1570 | 118, 119, 0, 91, 64, 96, 98, 99, 109, 110, 1571 | 168, 73, 170, 71, 95, 95, 95, 42, 124, 119, 1572 | 165, 92, 93, 94, 73, 73, 141, 67, 147, 67, 1573 | 131, 67, 170, 74, 111, 74, 110, 119, 64, 65, 1574 | 63, 66, 100, 258, 92, 170, 72, 114, 67, 179, 1575 | 93, 171, 6, 247, 64, 118, 120, 140, 146, 151, 1576 | 152, 153, 154, 142, 151, 148, 3, 133, 134, 135, 1577 | 136, 132, 97, 73, 3, 5, 21, 23, 24, 29, 1578 | 67, 73, 75, 79, 82, 83, 86, 87, 101, 116, 1579 | 208, 210, 211, 212, 213, 214, 215, 216, 218, 220, 1580 | 222, 224, 226, 227, 228, 229, 230, 231, 232, 233, 1581 | 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 1582 | 244, 245, 246, 247, 248, 259, 100, 74, 206, 207, 1583 | 208, 251, 180, 3, 94, 173, 174, 175, 176, 177, 1584 | 6, 69, 74, 120, 118, 155, 64, 64, 68, 153, 1585 | 151, 68, 151, 68, 65, 66, 133, 98, 247, 3, 1586 | 4, 198, 226, 226, 73, 226, 3, 4, 70, 71, 1587 | 101, 102, 103, 104, 105, 163, 94, 128, 206, 249, 1588 | 226, 226, 226, 226, 226, 226, 73, 22, 76, 21, 1589 | 77, 78, 79, 18, 19, 217, 25, 26, 80, 81, 1590 | 219, 27, 28, 221, 82, 83, 223, 75, 84, 85, 1591 | 225, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1592 | 17, 66, 209, 20, 23, 24, 70, 71, 73, 65, 1593 | 115, 3, 4, 51, 52, 53, 55, 56, 57, 58, 1594 | 59, 60, 61, 62, 93, 178, 179, 182, 183, 184, 1595 | 185, 186, 187, 188, 189, 190, 194, 195, 196, 197, 1596 | 198, 199, 200, 201, 202, 203, 204, 205, 206, 253, 1597 | 71, 73, 107, 108, 109, 110, 74, 65, 65, 71, 1598 | 247, 255, 256, 64, 156, 157, 69, 109, 158, 159, 1599 | 160, 161, 68, 68, 135, 208, 68, 74, 128, 3, 1600 | 163, 106, 251, 65, 68, 66, 104, 69, 73, 107, 1601 | 110, 74, 74, 179, 74, 208, 252, 212, 226, 69, 1602 | 206, 213, 214, 215, 216, 218, 220, 222, 224, 226, 1603 | 67, 208, 163, 163, 206, 74, 252, 208, 72, 251, 1604 | 73, 73, 73, 36, 178, 191, 3, 64, 64, 64, 1605 | 206, 181, 184, 69, 69, 69, 64, 72, 251, 74, 1606 | 107, 175, 71, 73, 108, 3, 7, 177, 3, 4, 1607 | 73, 65, 69, 74, 158, 158, 162, 208, 69, 64, 1608 | 65, 74, 72, 7, 103, 101, 101, 67, 226, 250, 1609 | 65, 74, 210, 69, 102, 72, 74, 7, 206, 206, 1610 | 206, 56, 73, 64, 64, 68, 72, 74, 74, 72, 1611 | 251, 74, 175, 72, 72, 206, 256, 255, 64, 64, 1612 | 64, 162, 159, 251, 102, 74, 208, 210, 68, 251, 1613 | 74, 74, 74, 73, 64, 94, 192, 193, 206, 72, 1614 | 74, 247, 247, 74, 69, 74, 68, 178, 178, 178, 1615 | 206, 64, 206, 96, 74, 64, 73, 73, 247, 257, 1616 | 64, 54, 74, 206, 64, 178, 64, 206, 206, 206, 1617 | 65, 74, 178, 64, 206, 206, 64, 74, 74, 247, 1618 | 64, 206 1619 | }; 1620 | 1621 | #define yyerrok (yyerrstatus = 0) 1622 | #define yyclearin (yychar = YYEMPTY) 1623 | #define YYEMPTY (-2) 1624 | #define YYEOF 0 1625 | 1626 | #define YYACCEPT goto yyacceptlab 1627 | #define YYABORT goto yyabortlab 1628 | #define YYERROR goto yyerrorlab 1629 | 1630 | 1631 | /* Like YYERROR except do call yyerror. This remains here temporarily 1632 | to ease the transition to the new meaning of YYERROR, for GCC. 1633 | Once GCC version 2 has supplanted version 1, this can go. However, 1634 | YYFAIL appears to be in use. Nevertheless, it is formally deprecated 1635 | in Bison 2.4.2's NEWS entry, where a plan to phase it out is 1636 | discussed. */ 1637 | 1638 | #define YYFAIL goto yyerrlab 1639 | #if defined YYFAIL 1640 | /* This is here to suppress warnings from the GCC cpp's 1641 | -Wunused-macros. Normally we don't worry about that warning, but 1642 | some users do, and we want to make it easy for users to remove 1643 | YYFAIL uses, which will produce warnings from Bison 2.5. */ 1644 | #endif 1645 | 1646 | #define YYRECOVERING() (!!yyerrstatus) 1647 | 1648 | #define YYBACKUP(Token, Value) \ 1649 | do \ 1650 | if (yychar == YYEMPTY) \ 1651 | { \ 1652 | yychar = (Token); \ 1653 | yylval = (Value); \ 1654 | YYPOPSTACK (yylen); \ 1655 | yystate = *yyssp; \ 1656 | goto yybackup; \ 1657 | } \ 1658 | else \ 1659 | { \ 1660 | yyerror (YY_("syntax error: cannot back up")); \ 1661 | YYERROR; \ 1662 | } \ 1663 | while (YYID (0)) 1664 | 1665 | 1666 | #define YYTERROR 1 1667 | #define YYERRCODE 256 1668 | 1669 | /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1670 | If N is 0, then set CURRENT to the empty location which ends 1671 | the previous symbol: RHS[0] (always defined). */ 1672 | 1673 | #ifndef YYLLOC_DEFAULT 1674 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1675 | do \ 1676 | if (YYID (N)) \ 1677 | { \ 1678 | (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1679 | (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1680 | (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1681 | (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1682 | } \ 1683 | else \ 1684 | { \ 1685 | (Current).first_line = (Current).last_line = \ 1686 | YYRHSLOC (Rhs, 0).last_line; \ 1687 | (Current).first_column = (Current).last_column = \ 1688 | YYRHSLOC (Rhs, 0).last_column; \ 1689 | } \ 1690 | while (YYID (0)) 1691 | #endif 1692 | 1693 | #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1694 | 1695 | 1696 | 1697 | /* This macro is provided for backward compatibility. */ 1698 | 1699 | #ifndef YY_LOCATION_PRINT 1700 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1701 | #endif 1702 | 1703 | 1704 | /* YYLEX -- calling `yylex' with the right arguments. */ 1705 | 1706 | #ifdef YYLEX_PARAM 1707 | # define YYLEX yylex (YYLEX_PARAM) 1708 | #else 1709 | # define YYLEX yylex () 1710 | #endif 1711 | 1712 | /* Enable debugging if requested. */ 1713 | #if YYDEBUG 1714 | 1715 | # ifndef YYFPRINTF 1716 | # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1717 | # define YYFPRINTF fprintf 1718 | # endif 1719 | 1720 | # define YYDPRINTF(Args) \ 1721 | do { \ 1722 | if (yydebug) \ 1723 | YYFPRINTF Args; \ 1724 | } while (YYID (0)) 1725 | 1726 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1727 | do { \ 1728 | if (yydebug) \ 1729 | { \ 1730 | YYFPRINTF (stderr, "%s ", Title); \ 1731 | yy_symbol_print (stderr, \ 1732 | Type, Value); \ 1733 | YYFPRINTF (stderr, "\n"); \ 1734 | } \ 1735 | } while (YYID (0)) 1736 | 1737 | 1738 | /*--------------------------------. 1739 | | Print this symbol on YYOUTPUT. | 1740 | `--------------------------------*/ 1741 | 1742 | /*ARGSUSED*/ 1743 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1744 | || defined __cplusplus || defined _MSC_VER) 1745 | static void 1746 | yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1747 | #else 1748 | static void 1749 | yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1750 | FILE *yyoutput; 1751 | int yytype; 1752 | YYSTYPE const * const yyvaluep; 1753 | #endif 1754 | { 1755 | FILE *yyo = yyoutput; 1756 | YYUSE (yyo); 1757 | if (!yyvaluep) 1758 | return; 1759 | # ifdef YYPRINT 1760 | if (yytype < YYNTOKENS) 1761 | YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1762 | # else 1763 | YYUSE (yyoutput); 1764 | # endif 1765 | switch (yytype) 1766 | { 1767 | default: 1768 | break; 1769 | } 1770 | } 1771 | 1772 | 1773 | /*--------------------------------. 1774 | | Print this symbol on YYOUTPUT. | 1775 | `--------------------------------*/ 1776 | 1777 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1778 | || defined __cplusplus || defined _MSC_VER) 1779 | static void 1780 | yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1781 | #else 1782 | static void 1783 | yy_symbol_print (yyoutput, yytype, yyvaluep) 1784 | FILE *yyoutput; 1785 | int yytype; 1786 | YYSTYPE const * const yyvaluep; 1787 | #endif 1788 | { 1789 | if (yytype < YYNTOKENS) 1790 | YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1791 | else 1792 | YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1793 | 1794 | yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1795 | YYFPRINTF (yyoutput, ")"); 1796 | } 1797 | 1798 | /*------------------------------------------------------------------. 1799 | | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1800 | | TOP (included). | 1801 | `------------------------------------------------------------------*/ 1802 | 1803 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1804 | || defined __cplusplus || defined _MSC_VER) 1805 | static void 1806 | yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1807 | #else 1808 | static void 1809 | yy_stack_print (yybottom, yytop) 1810 | yytype_int16 *yybottom; 1811 | yytype_int16 *yytop; 1812 | #endif 1813 | { 1814 | YYFPRINTF (stderr, "Stack now"); 1815 | for (; yybottom <= yytop; yybottom++) 1816 | { 1817 | int yybot = *yybottom; 1818 | YYFPRINTF (stderr, " %d", yybot); 1819 | } 1820 | YYFPRINTF (stderr, "\n"); 1821 | } 1822 | 1823 | # define YY_STACK_PRINT(Bottom, Top) \ 1824 | do { \ 1825 | if (yydebug) \ 1826 | yy_stack_print ((Bottom), (Top)); \ 1827 | } while (YYID (0)) 1828 | 1829 | 1830 | /*------------------------------------------------. 1831 | | Report that the YYRULE is going to be reduced. | 1832 | `------------------------------------------------*/ 1833 | 1834 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1835 | || defined __cplusplus || defined _MSC_VER) 1836 | static void 1837 | yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1838 | #else 1839 | static void 1840 | yy_reduce_print (yyvsp, yyrule) 1841 | YYSTYPE *yyvsp; 1842 | int yyrule; 1843 | #endif 1844 | { 1845 | int yynrhs = yyr2[yyrule]; 1846 | int yyi; 1847 | unsigned long int yylno = yyrline[yyrule]; 1848 | YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1849 | yyrule - 1, yylno); 1850 | /* The symbols being reduced. */ 1851 | for (yyi = 0; yyi < yynrhs; yyi++) 1852 | { 1853 | YYFPRINTF (stderr, " $%d = ", yyi + 1); 1854 | yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1855 | &(yyvsp[(yyi + 1) - (yynrhs)]) 1856 | ); 1857 | YYFPRINTF (stderr, "\n"); 1858 | } 1859 | } 1860 | 1861 | # define YY_REDUCE_PRINT(Rule) \ 1862 | do { \ 1863 | if (yydebug) \ 1864 | yy_reduce_print (yyvsp, Rule); \ 1865 | } while (YYID (0)) 1866 | 1867 | /* Nonzero means print parse trace. It is left uninitialized so that 1868 | multiple parsers can coexist. */ 1869 | int yydebug; 1870 | #else /* !YYDEBUG */ 1871 | # define YYDPRINTF(Args) 1872 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1873 | # define YY_STACK_PRINT(Bottom, Top) 1874 | # define YY_REDUCE_PRINT(Rule) 1875 | #endif /* !YYDEBUG */ 1876 | 1877 | 1878 | /* YYINITDEPTH -- initial size of the parser's stacks. */ 1879 | #ifndef YYINITDEPTH 1880 | # define YYINITDEPTH 200 1881 | #endif 1882 | 1883 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1884 | if the built-in stack extension method is used). 1885 | 1886 | Do not make this value too large; the results are undefined if 1887 | YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1888 | evaluated with infinite-precision integer arithmetic. */ 1889 | 1890 | #ifndef YYMAXDEPTH 1891 | # define YYMAXDEPTH 10000 1892 | #endif 1893 | 1894 | 1895 | #if YYERROR_VERBOSE 1896 | 1897 | # ifndef yystrlen 1898 | # if defined __GLIBC__ && defined _STRING_H 1899 | # define yystrlen strlen 1900 | # else 1901 | /* Return the length of YYSTR. */ 1902 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1903 | || defined __cplusplus || defined _MSC_VER) 1904 | static YYSIZE_T 1905 | yystrlen (const char *yystr) 1906 | #else 1907 | static YYSIZE_T 1908 | yystrlen (yystr) 1909 | const char *yystr; 1910 | #endif 1911 | { 1912 | YYSIZE_T yylen; 1913 | for (yylen = 0; yystr[yylen]; yylen++) 1914 | continue; 1915 | return yylen; 1916 | } 1917 | # endif 1918 | # endif 1919 | 1920 | # ifndef yystpcpy 1921 | # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1922 | # define yystpcpy stpcpy 1923 | # else 1924 | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1925 | YYDEST. */ 1926 | #if (defined __STDC__ || defined __C99__FUNC__ \ 1927 | || defined __cplusplus || defined _MSC_VER) 1928 | static char * 1929 | yystpcpy (char *yydest, const char *yysrc) 1930 | #else 1931 | static char * 1932 | yystpcpy (yydest, yysrc) 1933 | char *yydest; 1934 | const char *yysrc; 1935 | #endif 1936 | { 1937 | char *yyd = yydest; 1938 | const char *yys = yysrc; 1939 | 1940 | while ((*yyd++ = *yys++) != '\0') 1941 | continue; 1942 | 1943 | return yyd - 1; 1944 | } 1945 | # endif 1946 | # endif 1947 | 1948 | # ifndef yytnamerr 1949 | /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1950 | quotes and backslashes, so that it's suitable for yyerror. The 1951 | heuristic is that double-quoting is unnecessary unless the string 1952 | contains an apostrophe, a comma, or backslash (other than 1953 | backslash-backslash). YYSTR is taken from yytname. If YYRES is 1954 | null, do not copy; instead, return the length of what the result 1955 | would have been. */ 1956 | static YYSIZE_T 1957 | yytnamerr (char *yyres, const char *yystr) 1958 | { 1959 | if (*yystr == '"') 1960 | { 1961 | YYSIZE_T yyn = 0; 1962 | char const *yyp = yystr; 1963 | 1964 | for (;;) 1965 | switch (*++yyp) 1966 | { 1967 | case '\'': 1968 | case ',': 1969 | goto do_not_strip_quotes; 1970 | 1971 | case '\\': 1972 | if (*++yyp != '\\') 1973 | goto do_not_strip_quotes; 1974 | /* Fall through. */ 1975 | default: 1976 | if (yyres) 1977 | yyres[yyn] = *yyp; 1978 | yyn++; 1979 | break; 1980 | 1981 | case '"': 1982 | if (yyres) 1983 | yyres[yyn] = '\0'; 1984 | return yyn; 1985 | } 1986 | do_not_strip_quotes: ; 1987 | } 1988 | 1989 | if (! yyres) 1990 | return yystrlen (yystr); 1991 | 1992 | return yystpcpy (yyres, yystr) - yyres; 1993 | } 1994 | # endif 1995 | 1996 | /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 1997 | about the unexpected token YYTOKEN for the state stack whose top is 1998 | YYSSP. 1999 | 2000 | Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 2001 | not large enough to hold the message. In that case, also set 2002 | *YYMSG_ALLOC to the required number of bytes. Return 2 if the 2003 | required number of bytes is too large to store. */ 2004 | static int 2005 | yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 2006 | yytype_int16 *yyssp, int yytoken) 2007 | { 2008 | YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); 2009 | YYSIZE_T yysize = yysize0; 2010 | YYSIZE_T yysize1; 2011 | enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 2012 | /* Internationalized format string. */ 2013 | const char *yyformat = YY_NULL; 2014 | /* Arguments of yyformat. */ 2015 | char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2016 | /* Number of reported tokens (one for the "unexpected", one per 2017 | "expected"). */ 2018 | int yycount = 0; 2019 | 2020 | /* There are many possibilities here to consider: 2021 | - Assume YYFAIL is not used. It's too flawed to consider. See 2022 | <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> 2023 | for details. YYERROR is fine as it does not invoke this 2024 | function. 2025 | - If this state is a consistent state with a default action, then 2026 | the only way this function was invoked is if the default action 2027 | is an error action. In that case, don't check for expected 2028 | tokens because there are none. 2029 | - The only way there can be no lookahead present (in yychar) is if 2030 | this state is a consistent state with a default action. Thus, 2031 | detecting the absence of a lookahead is sufficient to determine 2032 | that there is no unexpected or expected token to report. In that 2033 | case, just report a simple "syntax error". 2034 | - Don't assume there isn't a lookahead just because this state is a 2035 | consistent state with a default action. There might have been a 2036 | previous inconsistent state, consistent state with a non-default 2037 | action, or user semantic action that manipulated yychar. 2038 | - Of course, the expected token list depends on states to have 2039 | correct lookahead information, and it depends on the parser not 2040 | to perform extra reductions after fetching a lookahead from the 2041 | scanner and before detecting a syntax error. Thus, state merging 2042 | (from LALR or IELR) and default reductions corrupt the expected 2043 | token list. However, the list is correct for canonical LR with 2044 | one exception: it will still contain any token that will not be 2045 | accepted due to an error action in a later state. 2046 | */ 2047 | if (yytoken != YYEMPTY) 2048 | { 2049 | int yyn = yypact[*yyssp]; 2050 | yyarg[yycount++] = yytname[yytoken]; 2051 | if (!yypact_value_is_default (yyn)) 2052 | { 2053 | /* Start YYX at -YYN if negative to avoid negative indexes in 2054 | YYCHECK. In other words, skip the first -YYN actions for 2055 | this state because they are default actions. */ 2056 | int yyxbegin = yyn < 0 ? -yyn : 0; 2057 | /* Stay within bounds of both yycheck and yytname. */ 2058 | int yychecklim = YYLAST - yyn + 1; 2059 | int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2060 | int yyx; 2061 | 2062 | for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2063 | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 2064 | && !yytable_value_is_error (yytable[yyx + yyn])) 2065 | { 2066 | if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2067 | { 2068 | yycount = 1; 2069 | yysize = yysize0; 2070 | break; 2071 | } 2072 | yyarg[yycount++] = yytname[yyx]; 2073 | yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); 2074 | if (! (yysize <= yysize1 2075 | && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 2076 | return 2; 2077 | yysize = yysize1; 2078 | } 2079 | } 2080 | } 2081 | 2082 | switch (yycount) 2083 | { 2084 | # define YYCASE_(N, S) \ 2085 | case N: \ 2086 | yyformat = S; \ 2087 | break 2088 | YYCASE_(0, YY_("syntax error")); 2089 | YYCASE_(1, YY_("syntax error, unexpected %s")); 2090 | YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 2091 | YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 2092 | YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 2093 | YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 2094 | # undef YYCASE_ 2095 | } 2096 | 2097 | yysize1 = yysize + yystrlen (yyformat); 2098 | if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 2099 | return 2; 2100 | yysize = yysize1; 2101 | 2102 | if (*yymsg_alloc < yysize) 2103 | { 2104 | *yymsg_alloc = 2 * yysize; 2105 | if (! (yysize <= *yymsg_alloc 2106 | && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 2107 | *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 2108 | return 1; 2109 | } 2110 | 2111 | /* Avoid sprintf, as that infringes on the user's name space. 2112 | Don't have undefined behavior even if the translation 2113 | produced a string with the wrong number of "%s"s. */ 2114 | { 2115 | char *yyp = *yymsg; 2116 | int yyi = 0; 2117 | while ((*yyp = *yyformat) != '\0') 2118 | if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 2119 | { 2120 | yyp += yytnamerr (yyp, yyarg[yyi++]); 2121 | yyformat += 2; 2122 | } 2123 | else 2124 | { 2125 | yyp++; 2126 | yyformat++; 2127 | } 2128 | } 2129 | return 0; 2130 | } 2131 | #endif /* YYERROR_VERBOSE */ 2132 | 2133 | /*-----------------------------------------------. 2134 | | Release the memory associated to this symbol. | 2135 | `-----------------------------------------------*/ 2136 | 2137 | /*ARGSUSED*/ 2138 | #if (defined __STDC__ || defined __C99__FUNC__ \ 2139 | || defined __cplusplus || defined _MSC_VER) 2140 | static void 2141 | yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 2142 | #else 2143 | static void 2144 | yydestruct (yymsg, yytype, yyvaluep) 2145 | const char *yymsg; 2146 | int yytype; 2147 | YYSTYPE *yyvaluep; 2148 | #endif 2149 | { 2150 | YYUSE (yyvaluep); 2151 | 2152 | if (!yymsg) 2153 | yymsg = "Deleting"; 2154 | YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 2155 | 2156 | switch (yytype) 2157 | { 2158 | 2159 | default: 2160 | break; 2161 | } 2162 | } 2163 | 2164 | 2165 | 2166 | 2167 | /* The lookahead symbol. */ 2168 | int yychar; 2169 | 2170 | /* The semantic value of the lookahead symbol. */ 2171 | YYSTYPE yylval; 2172 | 2173 | /* Number of syntax errors so far. */ 2174 | int yynerrs; 2175 | 2176 | 2177 | /*----------. 2178 | | yyparse. | 2179 | `----------*/ 2180 | 2181 | #ifdef YYPARSE_PARAM 2182 | #if (defined __STDC__ || defined __C99__FUNC__ \ 2183 | || defined __cplusplus || defined _MSC_VER) 2184 | int 2185 | yyparse (void *YYPARSE_PARAM) 2186 | #else 2187 | int 2188 | yyparse (YYPARSE_PARAM) 2189 | void *YYPARSE_PARAM; 2190 | #endif 2191 | #else /* ! YYPARSE_PARAM */ 2192 | #if (defined __STDC__ || defined __C99__FUNC__ \ 2193 | || defined __cplusplus || defined _MSC_VER) 2194 | int 2195 | yyparse (void) 2196 | #else 2197 | int 2198 | yyparse () 2199 | 2200 | #endif 2201 | #endif 2202 | { 2203 | int yystate; 2204 | /* Number of tokens to shift before error messages enabled. */ 2205 | int yyerrstatus; 2206 | 2207 | /* The stacks and their tools: 2208 | `yyss': related to states. 2209 | `yyvs': related to semantic values. 2210 | 2211 | Refer to the stacks through separate pointers, to allow yyoverflow 2212 | to reallocate them elsewhere. */ 2213 | 2214 | /* The state stack. */ 2215 | yytype_int16 yyssa[YYINITDEPTH]; 2216 | yytype_int16 *yyss; 2217 | yytype_int16 *yyssp; 2218 | 2219 | /* The semantic value stack. */ 2220 | YYSTYPE yyvsa[YYINITDEPTH]; 2221 | YYSTYPE *yyvs; 2222 | YYSTYPE *yyvsp; 2223 | 2224 | YYSIZE_T yystacksize; 2225 | 2226 | int yyn; 2227 | int yyresult; 2228 | /* Lookahead token as an internal (translated) token number. */ 2229 | int yytoken; 2230 | /* The variables used to return semantic value and location from the 2231 | action routines. */ 2232 | YYSTYPE yyval; 2233 | 2234 | #if YYERROR_VERBOSE 2235 | /* Buffer for error messages, and its allocated size. */ 2236 | char yymsgbuf[128]; 2237 | char *yymsg = yymsgbuf; 2238 | YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2239 | #endif 2240 | 2241 | #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2242 | 2243 | /* The number of symbols on the RHS of the reduced rule. 2244 | Keep to zero when no symbol should be popped. */ 2245 | int yylen = 0; 2246 | 2247 | yytoken = 0; 2248 | yyss = yyssa; 2249 | yyvs = yyvsa; 2250 | yystacksize = YYINITDEPTH; 2251 | 2252 | YYDPRINTF ((stderr, "Starting parse\n")); 2253 | 2254 | yystate = 0; 2255 | yyerrstatus = 0; 2256 | yynerrs = 0; 2257 | yychar = YYEMPTY; /* Cause a token to be read. */ 2258 | 2259 | /* Initialize stack pointers. 2260 | Waste one element of value and location stack 2261 | so that they stay on the same level as the state stack. 2262 | The wasted elements are never initialized. */ 2263 | yyssp = yyss; 2264 | yyvsp = yyvs; 2265 | goto yysetstate; 2266 | 2267 | /*------------------------------------------------------------. 2268 | | yynewstate -- Push a new state, which is found in yystate. | 2269 | `------------------------------------------------------------*/ 2270 | yynewstate: 2271 | /* In all cases, when you get here, the value and location stacks 2272 | have just been pushed. So pushing a state here evens the stacks. */ 2273 | yyssp++; 2274 | 2275 | yysetstate: 2276 | *yyssp = yystate; 2277 | 2278 | if (yyss + yystacksize - 1 <= yyssp) 2279 | { 2280 | /* Get the current used size of the three stacks, in elements. */ 2281 | YYSIZE_T yysize = yyssp - yyss + 1; 2282 | 2283 | #ifdef yyoverflow 2284 | { 2285 | /* Give user a chance to reallocate the stack. Use copies of 2286 | these so that the &'s don't force the real ones into 2287 | memory. */ 2288 | YYSTYPE *yyvs1 = yyvs; 2289 | yytype_int16 *yyss1 = yyss; 2290 | 2291 | /* Each stack pointer address is followed by the size of the 2292 | data in use in that stack, in bytes. This used to be a 2293 | conditional around just the two extra args, but that might 2294 | be undefined if yyoverflow is a macro. */ 2295 | yyoverflow (YY_("memory exhausted"), 2296 | &yyss1, yysize * sizeof (*yyssp), 2297 | &yyvs1, yysize * sizeof (*yyvsp), 2298 | &yystacksize); 2299 | 2300 | yyss = yyss1; 2301 | yyvs = yyvs1; 2302 | } 2303 | #else /* no yyoverflow */ 2304 | # ifndef YYSTACK_RELOCATE 2305 | goto yyexhaustedlab; 2306 | # else 2307 | /* Extend the stack our own way. */ 2308 | if (YYMAXDEPTH <= yystacksize) 2309 | goto yyexhaustedlab; 2310 | yystacksize *= 2; 2311 | if (YYMAXDEPTH < yystacksize) 2312 | yystacksize = YYMAXDEPTH; 2313 | 2314 | { 2315 | yytype_int16 *yyss1 = yyss; 2316 | union yyalloc *yyptr = 2317 | (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2318 | if (! yyptr) 2319 | goto yyexhaustedlab; 2320 | YYSTACK_RELOCATE (yyss_alloc, yyss); 2321 | YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2322 | # undef YYSTACK_RELOCATE 2323 | if (yyss1 != yyssa) 2324 | YYSTACK_FREE (yyss1); 2325 | } 2326 | # endif 2327 | #endif /* no yyoverflow */ 2328 | 2329 | yyssp = yyss + yysize - 1; 2330 | yyvsp = yyvs + yysize - 1; 2331 | 2332 | YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2333 | (unsigned long int) yystacksize)); 2334 | 2335 | if (yyss + yystacksize - 1 <= yyssp) 2336 | YYABORT; 2337 | } 2338 | 2339 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2340 | 2341 | if (yystate == YYFINAL) 2342 | YYACCEPT; 2343 | 2344 | goto yybackup; 2345 | 2346 | /*-----------. 2347 | | yybackup. | 2348 | `-----------*/ 2349 | yybackup: 2350 | 2351 | /* Do appropriate processing given the current state. Read a 2352 | lookahead token if we need one and don't already have one. */ 2353 | 2354 | /* First try to decide what to do without reference to lookahead token. */ 2355 | yyn = yypact[yystate]; 2356 | if (yypact_value_is_default (yyn)) 2357 | goto yydefault; 2358 | 2359 | /* Not known => get a lookahead token if don't already have one. */ 2360 | 2361 | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 2362 | if (yychar == YYEMPTY) 2363 | { 2364 | YYDPRINTF ((stderr, "Reading a token: ")); 2365 | yychar = YYLEX; 2366 | } 2367 | 2368 | if (yychar <= YYEOF) 2369 | { 2370 | yychar = yytoken = YYEOF; 2371 | YYDPRINTF ((stderr, "Now at end of input.\n")); 2372 | } 2373 | else 2374 | { 2375 | yytoken = YYTRANSLATE (yychar); 2376 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2377 | } 2378 | 2379 | /* If the proper action on seeing token YYTOKEN is to reduce or to 2380 | detect an error, take that action. */ 2381 | yyn += yytoken; 2382 | if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2383 | goto yydefault; 2384 | yyn = yytable[yyn]; 2385 | if (yyn <= 0) 2386 | { 2387 | if (yytable_value_is_error (yyn)) 2388 | goto yyerrlab; 2389 | yyn = -yyn; 2390 | goto yyreduce; 2391 | } 2392 | 2393 | /* Count tokens shifted since error; after three, turn off error 2394 | status. */ 2395 | if (yyerrstatus) 2396 | yyerrstatus--; 2397 | 2398 | /* Shift the lookahead token. */ 2399 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2400 | 2401 | /* Discard the shifted token. */ 2402 | yychar = YYEMPTY; 2403 | 2404 | yystate = yyn; 2405 | *++yyvsp = yylval; 2406 | 2407 | goto yynewstate; 2408 | 2409 | 2410 | /*-----------------------------------------------------------. 2411 | | yydefault -- do the default action for the current state. | 2412 | `-----------------------------------------------------------*/ 2413 | yydefault: 2414 | yyn = yydefact[yystate]; 2415 | if (yyn == 0) 2416 | goto yyerrlab; 2417 | goto yyreduce; 2418 | 2419 | 2420 | /*-----------------------------. 2421 | | yyreduce -- Do a reduction. | 2422 | `-----------------------------*/ 2423 | yyreduce: 2424 | /* yyn is the number of a rule to reduce with. */ 2425 | yylen = yyr2[yyn]; 2426 | 2427 | /* If YYLEN is nonzero, implement the default value of the action: 2428 | `$$ = $1'. 2429 | 2430 | Otherwise, the following line sets YYVAL to garbage. 2431 | This behavior is undocumented and Bison 2432 | users should not rely upon it. Assigning to YYVAL 2433 | unconditionally makes the parser a bit smaller, and it avoids a 2434 | GCC warning that YYVAL may be used uninitialized. */ 2435 | yyval = yyvsp[1-yylen]; 2436 | 2437 | 2438 | YY_REDUCE_PRINT (yyn); 2439 | switch (yyn) 2440 | { 2441 | case 6: 2442 | /* Line 1787 of yacc.c */ 2443 | #line 178 "./parse.y" 2444 | { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); } 2445 | break; 2446 | 2447 | case 7: 2448 | /* Line 1787 of yacc.c */ 2449 | #line 180 "./parse.y" 2450 | { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); } 2451 | break; 2452 | 2453 | case 10: 2454 | /* Line 1787 of yacc.c */ 2455 | #line 189 "./parse.y" 2456 | { scope=0; reset(); common_comment=NULL; in_typedef=0; } 2457 | break; 2458 | 2459 | case 11: 2460 | /* Line 1787 of yacc.c */ 2461 | #line 191 "./parse.y" 2462 | { scope=0; reset(); common_comment=NULL; in_typedef=0; 2463 | (yyval)=(yyvsp[(2) - (2)]); } 2464 | break; 2465 | 2466 | case 12: 2467 | /* Line 1787 of yacc.c */ 2468 | #line 197 "./parse.y" 2469 | { in_type_spec=0; } 2470 | break; 2471 | 2472 | case 13: 2473 | /* Line 1787 of yacc.c */ 2474 | #line 199 "./parse.y" 2475 | { in_type_spec=0; } 2476 | break; 2477 | 2478 | case 14: 2479 | /* Line 1787 of yacc.c */ 2480 | #line 204 "./parse.y" 2481 | { if(!in_structunion && !in_typedef && !in_function && !common_comment) 2482 | {common_comment=CopyString(GetCurrentComment()); SetCurrentComment(common_comment);} } 2483 | break; 2484 | 2485 | case 16: 2486 | /* Line 1787 of yacc.c */ 2487 | #line 211 "./parse.y" 2488 | { if((yyvsp[(1) - (2)])) (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); else (yyval)=(yyvsp[(2) - (2)]); } 2489 | break; 2490 | 2491 | case 17: 2492 | /* Line 1787 of yacc.c */ 2493 | #line 213 "./parse.y" 2494 | { if(!current->type) current->type=(yyvsp[(1) - (1)]); } 2495 | break; 2496 | 2497 | case 18: 2498 | /* Line 1787 of yacc.c */ 2499 | #line 215 "./parse.y" 2500 | { if(!current->type) current->type=(yyvsp[(1) - (2)]); 2501 | (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2502 | break; 2503 | 2504 | case 20: 2505 | /* Line 1787 of yacc.c */ 2506 | #line 219 "./parse.y" 2507 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2508 | break; 2509 | 2510 | case 22: 2511 | /* Line 1787 of yacc.c */ 2512 | #line 226 "./parse.y" 2513 | { in_type_spec=1; } 2514 | break; 2515 | 2516 | case 24: 2517 | /* Line 1787 of yacc.c */ 2518 | #line 231 "./parse.y" 2519 | { 2520 | if((in_function==0 || in_function==3) && !in_funcdef && !in_structunion) 2521 | { 2522 | char* specific_comment=GetCurrentComment(); 2523 | if(!common_comment) SetCurrentComment(specific_comment); else 2524 | if(!specific_comment) SetCurrentComment(common_comment); else 2525 | if(strcmp(common_comment,specific_comment)) SetCurrentComment(ConcatStrings(3,common_comment," ",specific_comment)); else 2526 | SetCurrentComment(common_comment); 2527 | } 2528 | 2529 | if(in_typedef) 2530 | { 2531 | char* vname=strstr((yyvsp[(1) - (1)]),current->name); 2532 | SeenTypedefName(current->name,vname[strlen(current->name)]=='('?-1:1); 2533 | if(!in_header) 2534 | SeenTypedef(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[(1) - (1)]))); 2535 | if(in_function==3) 2536 | DownScope(); 2537 | } 2538 | else if(in_function==2) 2539 | SeenFunctionArg(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[(1) - (1)]))); 2540 | else 2541 | { 2542 | char* vname=strstr((yyvsp[(1) - (1)]),current->name); 2543 | if(vname[strlen(current->name)]!='(' && IsATypeName(current->type)!='f') 2544 | { 2545 | if((in_funcbody==0 || scope&EXTERN_F) && !in_structunion && !(in_header==GLOBAL && scope&EXTERN_H)) 2546 | SeenVariableDefinition(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[(1) - (1)])),SCOPE); 2547 | else 2548 | if(in_funcbody) 2549 | SeenScopeVariable(current->name); 2550 | } 2551 | else 2552 | SeenFunctionProto(current->name,in_funcbody); 2553 | if(in_function==3) 2554 | DownScope(); 2555 | } 2556 | 2557 | if(in_function==3 && !in_structunion) in_function=0; 2558 | } 2559 | break; 2560 | 2561 | case 46: 2562 | /* Line 1787 of yacc.c */ 2563 | #line 322 "./parse.y" 2564 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2565 | break; 2566 | 2567 | case 48: 2568 | /* Line 1787 of yacc.c */ 2569 | #line 328 "./parse.y" 2570 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); 2571 | { int i=0; while((yyvsp[(2) - (3)])[i] && (yyvsp[(2) - (3)])[i]=='*') i++; if(!(yyvsp[(2) - (3)])[i]) in_type_spec=0; } } 2572 | break; 2573 | 2574 | case 49: 2575 | /* Line 1787 of yacc.c */ 2576 | #line 331 "./parse.y" 2577 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2578 | break; 2579 | 2580 | case 50: 2581 | /* Line 1787 of yacc.c */ 2582 | #line 333 "./parse.y" 2583 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2584 | break; 2585 | 2586 | case 51: 2587 | /* Line 1787 of yacc.c */ 2588 | #line 335 "./parse.y" 2589 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2590 | break; 2591 | 2592 | case 52: 2593 | /* Line 1787 of yacc.c */ 2594 | #line 337 "./parse.y" 2595 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (4)]),(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); } 2596 | break; 2597 | 2598 | case 53: 2599 | /* Line 1787 of yacc.c */ 2600 | #line 339 "./parse.y" 2601 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2602 | break; 2603 | 2604 | case 54: 2605 | /* Line 1787 of yacc.c */ 2606 | #line 341 "./parse.y" 2607 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2608 | break; 2609 | 2610 | case 55: 2611 | /* Line 1787 of yacc.c */ 2612 | #line 343 "./parse.y" 2613 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2614 | break; 2615 | 2616 | case 56: 2617 | /* Line 1787 of yacc.c */ 2618 | #line 345 "./parse.y" 2619 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (4)]),(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); } 2620 | break; 2621 | 2622 | case 57: 2623 | /* Line 1787 of yacc.c */ 2624 | #line 352 "./parse.y" 2625 | { in_type_spec=0; } 2626 | break; 2627 | 2628 | case 58: 2629 | /* Line 1787 of yacc.c */ 2630 | #line 354 "./parse.y" 2631 | { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2632 | break; 2633 | 2634 | case 60: 2635 | /* Line 1787 of yacc.c */ 2636 | #line 360 "./parse.y" 2637 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2638 | break; 2639 | 2640 | case 61: 2641 | /* Line 1787 of yacc.c */ 2642 | #line 362 "./parse.y" 2643 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2644 | break; 2645 | 2646 | case 62: 2647 | /* Line 1787 of yacc.c */ 2648 | #line 364 "./parse.y" 2649 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2650 | break; 2651 | 2652 | case 64: 2653 | /* Line 1787 of yacc.c */ 2654 | #line 370 "./parse.y" 2655 | { if((yyvsp[(2) - (3)])[0]=='*' && (yyvsp[(2) - (3)])[1]==' ') { (yyvsp[(2) - (3)])=&(yyvsp[(2) - (3)])[1]; (yyvsp[(2) - (3)])[0]='*'; } 2656 | (yyval)=ConcatStrings(4," ",(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); 2657 | } 2658 | break; 2659 | 2660 | case 67: 2661 | /* Line 1787 of yacc.c */ 2662 | #line 379 "./parse.y" 2663 | { (yyval)=ConcatStrings(2," ",(yyvsp[(1) - (1)])); current->name=(yyvsp[(1) - (1)]); 2664 | if(!current->type) current->type="int"; 2665 | if(in_funcdef==1 && in_function!=3 && !in_structunion) SeenScopeVariable((yyvsp[(1) - (1)])); } 2666 | break; 2667 | 2668 | case 68: 2669 | /* Line 1787 of yacc.c */ 2670 | #line 386 "./parse.y" 2671 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2672 | break; 2673 | 2674 | case 69: 2675 | /* Line 1787 of yacc.c */ 2676 | #line 387 "./parse.y" 2677 | { in_type_spec=0; } 2678 | break; 2679 | 2680 | case 70: 2681 | /* Line 1787 of yacc.c */ 2682 | #line 387 "./parse.y" 2683 | { in_type_spec=1; } 2684 | break; 2685 | 2686 | case 71: 2687 | /* Line 1787 of yacc.c */ 2688 | #line 388 "./parse.y" 2689 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (6)]),(yyvsp[(2) - (6)]),(yyvsp[(4) - (6)]),(yyvsp[(6) - (6)])); } 2690 | break; 2691 | 2692 | case 73: 2693 | /* Line 1787 of yacc.c */ 2694 | #line 399 "./parse.y" 2695 | { (yyval)=NULL; } 2696 | break; 2697 | 2698 | case 74: 2699 | /* Line 1787 of yacc.c */ 2700 | #line 401 "./parse.y" 2701 | { (yyval)=NULL; 2702 | if(in_funcbody) scope|=EXTERN_F; 2703 | else if(in_header) scope|=EXTERN_H; 2704 | else scope|=EXTERNAL; } 2705 | break; 2706 | 2707 | case 75: 2708 | /* Line 1787 of yacc.c */ 2709 | #line 406 "./parse.y" 2710 | { (yyval)=NULL; } 2711 | break; 2712 | 2713 | case 76: 2714 | /* Line 1787 of yacc.c */ 2715 | #line 408 "./parse.y" 2716 | { (yyval)=NULL; scope |= LOCAL; } 2717 | break; 2718 | 2719 | case 77: 2720 | /* Line 1787 of yacc.c */ 2721 | #line 410 "./parse.y" 2722 | { (yyval)=NULL; 2723 | in_typedef=1; if(!in_header) SeenTypedef(NULL,NULL); 2724 | common_comment=CopyString(GetCurrentComment()); } 2725 | break; 2726 | 2727 | case 78: 2728 | /* Line 1787 of yacc.c */ 2729 | #line 414 "./parse.y" 2730 | { (yyval)=NULL; scope |= INLINED; } 2731 | break; 2732 | 2733 | case 80: 2734 | /* Line 1787 of yacc.c */ 2735 | #line 420 "./parse.y" 2736 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2737 | break; 2738 | 2739 | case 81: 2740 | /* Line 1787 of yacc.c */ 2741 | #line 425 "./parse.y" 2742 | { if(!current->type) current->qual=ConcatStrings(3,current->qual,(yyvsp[(1) - (1)])," "); } 2743 | break; 2744 | 2745 | case 82: 2746 | /* Line 1787 of yacc.c */ 2747 | #line 427 "./parse.y" 2748 | { if(!current->type) current->qual=ConcatStrings(3,current->qual,(yyvsp[(1) - (1)])," "); } 2749 | break; 2750 | 2751 | case 83: 2752 | /* Line 1787 of yacc.c */ 2753 | #line 434 "./parse.y" 2754 | { in_type_spec=1; } 2755 | break; 2756 | 2757 | case 94: 2758 | /* Line 1787 of yacc.c */ 2759 | #line 452 "./parse.y" 2760 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2761 | break; 2762 | 2763 | case 95: 2764 | /* Line 1787 of yacc.c */ 2765 | #line 454 "./parse.y" 2766 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2767 | break; 2768 | 2769 | case 97: 2770 | /* Line 1787 of yacc.c */ 2771 | #line 460 "./parse.y" 2772 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2773 | break; 2774 | 2775 | case 98: 2776 | /* Line 1787 of yacc.c */ 2777 | #line 462 "./parse.y" 2778 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2779 | break; 2780 | 2781 | case 108: 2782 | /* Line 1787 of yacc.c */ 2783 | #line 488 "./parse.y" 2784 | { in_type_spec=0; } 2785 | break; 2786 | 2787 | case 109: 2788 | /* Line 1787 of yacc.c */ 2789 | #line 490 "./parse.y" 2790 | { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2791 | break; 2792 | 2793 | case 112: 2794 | /* Line 1787 of yacc.c */ 2795 | #line 502 "./parse.y" 2796 | { push(); 2797 | if(!in_header) 2798 | { 2799 | if(in_structunion) SeenStructUnionComp((yyvsp[(1) - (2)]),in_structunion); 2800 | else SeenStructUnionStart((yyvsp[(1) - (2)])); 2801 | } 2802 | in_structunion++; } 2803 | break; 2804 | 2805 | case 113: 2806 | /* Line 1787 of yacc.c */ 2807 | #line 510 "./parse.y" 2808 | { pop(); in_structunion--; 2809 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[(1) - (5)])," {...}"); 2810 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd(); 2811 | (yyval)=ConcatStrings(5,(yyvsp[(1) - (5)])," ",(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); } 2812 | break; 2813 | 2814 | case 114: 2815 | /* Line 1787 of yacc.c */ 2816 | #line 515 "./parse.y" 2817 | { push(); 2818 | if(!in_header) 2819 | { 2820 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)])),in_structunion); 2821 | else SeenStructUnionStart(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)]))); 2822 | } 2823 | in_structunion++; } 2824 | break; 2825 | 2826 | case 115: 2827 | /* Line 1787 of yacc.c */ 2828 | #line 523 "./parse.y" 2829 | { pop(); in_structunion--; 2830 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])); 2831 | if(!in_header && !in_structunion) SeenStructUnionEnd(); 2832 | (yyval)=ConcatStrings(7,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])," ",(yyvsp[(3) - (6)]),(yyvsp[(5) - (6)]),(yyvsp[(6) - (6)])); } 2833 | break; 2834 | 2835 | case 119: 2836 | /* Line 1787 of yacc.c */ 2837 | #line 537 "./parse.y" 2838 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 2839 | break; 2840 | 2841 | case 120: 2842 | /* Line 1787 of yacc.c */ 2843 | #line 542 "./parse.y" 2844 | { if(!in_header) SeenStructUnionComp((yyvsp[(1) - (1)]),in_structunion); } 2845 | break; 2846 | 2847 | case 121: 2848 | /* Line 1787 of yacc.c */ 2849 | #line 544 "./parse.y" 2850 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); if(!in_header) SeenStructUnionComp((yyvsp[(1) - (3)]),in_structunion); } 2851 | break; 2852 | 2853 | case 123: 2854 | /* Line 1787 of yacc.c */ 2855 | #line 553 "./parse.y" 2856 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2857 | break; 2858 | 2859 | case 128: 2860 | /* Line 1787 of yacc.c */ 2861 | #line 570 "./parse.y" 2862 | { push(); 2863 | if(!in_header) 2864 | { 2865 | if(in_structunion) SeenStructUnionComp((yyvsp[(1) - (2)]),in_structunion); 2866 | else SeenStructUnionStart((yyvsp[(1) - (2)])); 2867 | } 2868 | in_structunion++; } 2869 | break; 2870 | 2871 | case 129: 2872 | /* Line 1787 of yacc.c */ 2873 | #line 578 "./parse.y" 2874 | { pop(); in_structunion--; 2875 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[(1) - (5)])," {...}"); 2876 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd(); 2877 | (yyval)=ConcatStrings(5,(yyvsp[(1) - (5)])," ",(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); } 2878 | break; 2879 | 2880 | case 130: 2881 | /* Line 1787 of yacc.c */ 2882 | #line 583 "./parse.y" 2883 | { push(); 2884 | if(!in_header) 2885 | { 2886 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)])),in_structunion); 2887 | else SeenStructUnionStart(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)]))); 2888 | } 2889 | in_structunion++; } 2890 | break; 2891 | 2892 | case 131: 2893 | /* Line 1787 of yacc.c */ 2894 | #line 591 "./parse.y" 2895 | { pop(); in_structunion--; 2896 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])); 2897 | if(!in_header && !in_structunion) SeenStructUnionEnd(); 2898 | (yyval)=ConcatStrings(7,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])," ",(yyvsp[(3) - (6)]),(yyvsp[(5) - (6)]),(yyvsp[(6) - (6)])); } 2899 | break; 2900 | 2901 | case 132: 2902 | /* Line 1787 of yacc.c */ 2903 | #line 599 "./parse.y" 2904 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2905 | break; 2906 | 2907 | case 137: 2908 | /* Line 1787 of yacc.c */ 2909 | #line 616 "./parse.y" 2910 | { push(); 2911 | if(!in_header) 2912 | { 2913 | if(in_structunion) SeenStructUnionComp((yyvsp[(1) - (2)]),in_structunion); 2914 | else SeenStructUnionStart((yyvsp[(1) - (2)])); 2915 | } 2916 | in_structunion++; } 2917 | break; 2918 | 2919 | case 138: 2920 | /* Line 1787 of yacc.c */ 2921 | #line 624 "./parse.y" 2922 | { pop(); in_structunion--; 2923 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[(1) - (5)])," {...}"); 2924 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd(); 2925 | (yyval)=ConcatStrings(5,(yyvsp[(1) - (5)])," ",(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); } 2926 | break; 2927 | 2928 | case 139: 2929 | /* Line 1787 of yacc.c */ 2930 | #line 629 "./parse.y" 2931 | { push(); 2932 | if(!in_header) 2933 | { 2934 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)])),in_structunion); 2935 | else SeenStructUnionStart(ConcatStrings(3,(yyvsp[(1) - (3)])," ",(yyvsp[(2) - (3)]))); 2936 | } 2937 | in_structunion++; } 2938 | break; 2939 | 2940 | case 140: 2941 | /* Line 1787 of yacc.c */ 2942 | #line 637 "./parse.y" 2943 | { pop(); in_structunion--; 2944 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])); 2945 | if(!in_header && !in_structunion) SeenStructUnionEnd(); 2946 | (yyval)=ConcatStrings(7,(yyvsp[(1) - (6)])," ",(yyvsp[(2) - (6)])," ",(yyvsp[(3) - (6)]),(yyvsp[(5) - (6)]),(yyvsp[(6) - (6)])); } 2947 | break; 2948 | 2949 | case 141: 2950 | /* Line 1787 of yacc.c */ 2951 | #line 645 "./parse.y" 2952 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2953 | break; 2954 | 2955 | case 147: 2956 | /* Line 1787 of yacc.c */ 2957 | #line 663 "./parse.y" 2958 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 2959 | break; 2960 | 2961 | case 149: 2962 | /* Line 1787 of yacc.c */ 2963 | #line 669 "./parse.y" 2964 | { (yyval) = ConcatStrings(3, (yyvsp[(1) - (2)]), " ", (yyvsp[(2) - (2)])); 2965 | if(!in_header) SeenStructUnionComp((yyvsp[(1) - (2)]),in_structunion); } 2966 | break; 2967 | 2968 | case 150: 2969 | /* Line 1787 of yacc.c */ 2970 | #line 672 "./parse.y" 2971 | { (yyval) = ConcatStrings(3, (yyvsp[(1) - (2)]), " ", (yyvsp[(2) - (2)])); 2972 | if(!in_header) SeenStructUnionComp((yyvsp[(1) - (2)]),in_structunion); } 2973 | break; 2974 | 2975 | case 152: 2976 | /* Line 1787 of yacc.c */ 2977 | #line 679 "./parse.y" 2978 | { comp_type=(yyvsp[(1) - (1)]); } 2979 | break; 2980 | 2981 | case 153: 2982 | /* Line 1787 of yacc.c */ 2983 | #line 681 "./parse.y" 2984 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); reset(); in_type_spec=0; } 2985 | break; 2986 | 2987 | case 154: 2988 | /* Line 1787 of yacc.c */ 2989 | #line 683 "./parse.y" 2990 | { comp_type=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 2991 | break; 2992 | 2993 | case 155: 2994 | /* Line 1787 of yacc.c */ 2995 | #line 685 "./parse.y" 2996 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (5)]),(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); reset(); in_type_spec=0; } 2997 | break; 2998 | 2999 | case 156: 3000 | /* Line 1787 of yacc.c */ 3001 | #line 687 "./parse.y" 3002 | { comp_type=ConcatStrings(3,(yyvsp[(1) - (2)])," ",(yyvsp[(2) - (2)])); } 3003 | break; 3004 | 3005 | case 157: 3006 | /* Line 1787 of yacc.c */ 3007 | #line 689 "./parse.y" 3008 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (5)]),(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); reset(); in_type_spec=0; } 3009 | break; 3010 | 3011 | case 158: 3012 | /* Line 1787 of yacc.c */ 3013 | #line 694 "./parse.y" 3014 | { if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,(yyvsp[(1) - (1)])),in_structunion); } 3015 | break; 3016 | 3017 | case 159: 3018 | /* Line 1787 of yacc.c */ 3019 | #line 696 "./parse.y" 3020 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); 3021 | if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,(yyvsp[(3) - (3)])),in_structunion); } 3022 | break; 3023 | 3024 | case 162: 3025 | /* Line 1787 of yacc.c */ 3026 | #line 707 "./parse.y" 3027 | { if(in_function==2 && !in_structunion) { DownScope(); pop(); in_function=0; } } 3028 | break; 3029 | 3030 | case 163: 3031 | /* Line 1787 of yacc.c */ 3032 | #line 712 "./parse.y" 3033 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3034 | break; 3035 | 3036 | case 164: 3037 | /* Line 1787 of yacc.c */ 3038 | #line 714 "./parse.y" 3039 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3040 | break; 3041 | 3042 | case 168: 3043 | /* Line 1787 of yacc.c */ 3044 | #line 732 "./parse.y" 3045 | { pop(); in_funcbody=1; in_function=0; } 3046 | break; 3047 | 3048 | case 169: 3049 | /* Line 1787 of yacc.c */ 3050 | #line 734 "./parse.y" 3051 | { in_funcbody=in_function=0; DownScope(); SeenFunctionDefinition(NULL); } 3052 | break; 3053 | 3054 | case 170: 3055 | /* Line 1787 of yacc.c */ 3056 | #line 739 "./parse.y" 3057 | { char *func_type,*fname=strstr((yyvsp[(1) - (1)]),(current-1)->name),*parenth=strstr((yyvsp[(1) - (1)]),"("); 3058 | if(parenth>fname) 3059 | {parenth[0]=0;func_type=ConcatStrings(3,(current-1)->qual,(current-1)->type,(yyvsp[(1) - (1)]));} 3060 | else 3061 | { 3062 | int open=1; 3063 | char *argbeg=strstr(&parenth[1],"("),*argend; 3064 | argbeg[1]=0; 3065 | for(argend=argbeg+2;*argend;argend++) 3066 | { 3067 | if(*argend=='(') open++; 3068 | if(*argend==')') open--; 3069 | if(!open) break; 3070 | } 3071 | func_type=ConcatStrings(4,(current-1)->qual,(current-1)->type,(yyvsp[(1) - (1)]),argend); 3072 | } 3073 | SeenFunctionDefinition(func_type); 3074 | common_comment=NULL; 3075 | } 3076 | break; 3077 | 3078 | case 172: 3079 | /* Line 1787 of yacc.c */ 3080 | #line 763 "./parse.y" 3081 | { (yyval)=ConcatStrings(3,current->qual,current->type,(yyvsp[(2) - (2)])); } 3082 | break; 3083 | 3084 | case 174: 3085 | /* Line 1787 of yacc.c */ 3086 | #line 766 "./parse.y" 3087 | { (yyval)=ConcatStrings(3,current->qual,current->type,(yyvsp[(2) - (3)])); } 3088 | break; 3089 | 3090 | case 175: 3091 | /* Line 1787 of yacc.c */ 3092 | #line 773 "./parse.y" 3093 | { if(!in_structunion) { push(); in_function=2; } } 3094 | break; 3095 | 3096 | case 178: 3097 | /* Line 1787 of yacc.c */ 3098 | #line 780 "./parse.y" 3099 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3100 | break; 3101 | 3102 | case 179: 3103 | /* Line 1787 of yacc.c */ 3104 | #line 782 "./parse.y" 3105 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (4)]),(yyvsp[(3) - (4)])); } 3106 | break; 3107 | 3108 | case 180: 3109 | /* Line 1787 of yacc.c */ 3110 | #line 787 "./parse.y" 3111 | { if(!in_structunion) 3112 | { push(); if(in_function==0) UpScope(); 3113 | if(in_function==0 && !in_funcdef) in_function=1; if(in_function!=3) in_funcdef++; } } 3114 | break; 3115 | 3116 | case 181: 3117 | /* Line 1787 of yacc.c */ 3118 | #line 791 "./parse.y" 3119 | { if(!in_structunion) 3120 | { pop(); if(in_function!=3) in_funcdef--; if(in_funcdef==0) in_function=3; } 3121 | (yyval)=ConcatStrings(4,(yyvsp[(1) - (5)]),(yyvsp[(2) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); } 3122 | break; 3123 | 3124 | case 182: 3125 | /* Line 1787 of yacc.c */ 3126 | #line 798 "./parse.y" 3127 | { 3128 | if(!in_funcdef && !in_function && !in_funcbody && !in_structunion) SeenFunctionDeclaration(current->name,SCOPE); 3129 | in_type_spec=0; 3130 | } 3131 | break; 3132 | 3133 | case 183: 3134 | /* Line 1787 of yacc.c */ 3135 | #line 806 "./parse.y" 3136 | { if(in_function==1 && in_funcdef==1 && !in_structunion) SeenFunctionArg("void","void"); 3137 | if(in_structunion) (yyval)=NULL; else (yyval)="void"; } 3138 | break; 3139 | 3140 | case 186: 3141 | /* Line 1787 of yacc.c */ 3142 | #line 814 "./parse.y" 3143 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg((yyvsp[(1) - (1)]),NULL); SeenScopeVariable((yyvsp[(1) - (1)])); } } 3144 | break; 3145 | 3146 | case 187: 3147 | /* Line 1787 of yacc.c */ 3148 | #line 816 "./parse.y" 3149 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg((yyvsp[(3) - (3)]),NULL); SeenScopeVariable((yyvsp[(3) - (3)])); } 3150 | (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3151 | break; 3152 | 3153 | case 189: 3154 | /* Line 1787 of yacc.c */ 3155 | #line 823 "./parse.y" 3156 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg((yyvsp[(3) - (3)]),(yyvsp[(3) - (3)])); 3157 | (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3158 | break; 3159 | 3160 | case 190: 3161 | /* Line 1787 of yacc.c */ 3162 | #line 829 "./parse.y" 3163 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(strcmp("void",(yyvsp[(1) - (1)]))?current->name:"void",(yyvsp[(1) - (1)])); 3164 | in_type_spec=0; } 3165 | break; 3166 | 3167 | case 191: 3168 | /* Line 1787 of yacc.c */ 3169 | #line 832 "./parse.y" 3170 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(current->name,(yyvsp[(3) - (3)])); 3171 | in_type_spec=0; (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3172 | break; 3173 | 3174 | case 192: 3175 | /* Line 1787 of yacc.c */ 3176 | #line 838 "./parse.y" 3177 | { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3178 | break; 3179 | 3180 | case 193: 3181 | /* Line 1787 of yacc.c */ 3182 | #line 840 "./parse.y" 3183 | { in_type_spec=0; } 3184 | break; 3185 | 3186 | case 194: 3187 | /* Line 1787 of yacc.c */ 3188 | #line 842 "./parse.y" 3189 | { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3190 | break; 3191 | 3192 | case 207: 3193 | /* Line 1787 of yacc.c */ 3194 | #line 866 "./parse.y" 3195 | { UpScope(); reset(); } 3196 | break; 3197 | 3198 | case 208: 3199 | /* Line 1787 of yacc.c */ 3200 | #line 868 "./parse.y" 3201 | { DownScope(); } 3202 | break; 3203 | 3204 | case 215: 3205 | /* Line 1787 of yacc.c */ 3206 | #line 885 "./parse.y" 3207 | { scope=0; reset(); common_comment=NULL; in_typedef=0; } 3208 | break; 3209 | 3210 | case 224: 3211 | /* Line 1787 of yacc.c */ 3212 | #line 917 "./parse.y" 3213 | { UpScope(); reset(); } 3214 | break; 3215 | 3216 | case 225: 3217 | /* Line 1787 of yacc.c */ 3218 | #line 919 "./parse.y" 3219 | { DownScope(); } 3220 | break; 3221 | 3222 | case 235: 3223 | /* Line 1787 of yacc.c */ 3224 | #line 936 "./parse.y" 3225 | { in_type_spec=0; } 3226 | break; 3227 | 3228 | case 236: 3229 | /* Line 1787 of yacc.c */ 3230 | #line 938 "./parse.y" 3231 | { in_type_spec=0; } 3232 | break; 3233 | 3234 | case 256: 3235 | /* Line 1787 of yacc.c */ 3236 | #line 1011 "./parse.y" 3237 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3238 | break; 3239 | 3240 | case 273: 3241 | /* Line 1787 of yacc.c */ 3242 | #line 1042 "./parse.y" 3243 | { (yyval)=ConcatStrings(5,(yyvsp[(1) - (5)]),(yyvsp[(2) - (5)]),(yyvsp[(3) - (5)]),(yyvsp[(4) - (5)]),(yyvsp[(5) - (5)])); } 3244 | break; 3245 | 3246 | case 274: 3247 | /* Line 1787 of yacc.c */ 3248 | #line 1044 "./parse.y" 3249 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (4)]),(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); } 3250 | break; 3251 | 3252 | case 276: 3253 | /* Line 1787 of yacc.c */ 3254 | #line 1052 "./parse.y" 3255 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3256 | break; 3257 | 3258 | case 278: 3259 | /* Line 1787 of yacc.c */ 3260 | #line 1060 "./parse.y" 3261 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3262 | break; 3263 | 3264 | case 280: 3265 | /* Line 1787 of yacc.c */ 3266 | #line 1068 "./parse.y" 3267 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3268 | break; 3269 | 3270 | case 282: 3271 | /* Line 1787 of yacc.c */ 3272 | #line 1076 "./parse.y" 3273 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3274 | break; 3275 | 3276 | case 284: 3277 | /* Line 1787 of yacc.c */ 3278 | #line 1084 "./parse.y" 3279 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3280 | break; 3281 | 3282 | case 286: 3283 | /* Line 1787 of yacc.c */ 3284 | #line 1092 "./parse.y" 3285 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3286 | break; 3287 | 3288 | case 290: 3289 | /* Line 1787 of yacc.c */ 3290 | #line 1105 "./parse.y" 3291 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3292 | break; 3293 | 3294 | case 296: 3295 | /* Line 1787 of yacc.c */ 3296 | #line 1120 "./parse.y" 3297 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3298 | break; 3299 | 3300 | case 300: 3301 | /* Line 1787 of yacc.c */ 3302 | #line 1133 "./parse.y" 3303 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3304 | break; 3305 | 3306 | case 304: 3307 | /* Line 1787 of yacc.c */ 3308 | #line 1146 "./parse.y" 3309 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3310 | break; 3311 | 3312 | case 320: 3313 | /* Line 1787 of yacc.c */ 3314 | #line 1177 "./parse.y" 3315 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3316 | break; 3317 | 3318 | case 321: 3319 | /* Line 1787 of yacc.c */ 3320 | #line 1182 "./parse.y" 3321 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (4)]),(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); } 3322 | break; 3323 | 3324 | case 324: 3325 | /* Line 1787 of yacc.c */ 3326 | #line 1192 "./parse.y" 3327 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3328 | break; 3329 | 3330 | case 327: 3331 | /* Line 1787 of yacc.c */ 3332 | #line 1205 "./parse.y" 3333 | { (yyval)=ConcatStrings(4,(yyvsp[(1) - (4)]),(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)])); } 3334 | break; 3335 | 3336 | case 328: 3337 | /* Line 1787 of yacc.c */ 3338 | #line 1207 "./parse.y" 3339 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3340 | break; 3341 | 3342 | case 329: 3343 | /* Line 1787 of yacc.c */ 3344 | #line 1212 "./parse.y" 3345 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3346 | break; 3347 | 3348 | case 330: 3349 | /* Line 1787 of yacc.c */ 3350 | #line 1217 "./parse.y" 3351 | { (yyval)=ConcatStrings(2,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)])); } 3352 | break; 3353 | 3354 | case 333: 3355 | /* Line 1787 of yacc.c */ 3356 | #line 1226 "./parse.y" 3357 | { if(!IsAScopeVariable((yyvsp[(1) - (1)]))) SeenFunctionCall((yyvsp[(1) - (1)])); } 3358 | break; 3359 | 3360 | case 349: 3361 | /* Line 1787 of yacc.c */ 3362 | #line 1270 "./parse.y" 3363 | { CheckFunctionVariableRef((yyvsp[(1) - (1)]),in_funcbody); } 3364 | break; 3365 | 3366 | case 355: 3367 | /* Line 1787 of yacc.c */ 3368 | #line 1283 "./parse.y" 3369 | { (yyval)=ConcatStrings(3,(yyvsp[(1) - (3)]),(yyvsp[(2) - (3)]),(yyvsp[(3) - (3)])); } 3370 | break; 3371 | 3372 | case 356: 3373 | /* Line 1787 of yacc.c */ 3374 | #line 1284 "./parse.y" 3375 | { push(); } 3376 | break; 3377 | 3378 | case 357: 3379 | /* Line 1787 of yacc.c */ 3380 | #line 1284 "./parse.y" 3381 | { pop(); } 3382 | break; 3383 | 3384 | 3385 | /* Line 1787 of yacc.c */ 3386 | #line 3387 "y.tab.c" 3387 | default: break; 3388 | } 3389 | /* User semantic actions sometimes alter yychar, and that requires 3390 | that yytoken be updated with the new translation. We take the 3391 | approach of translating immediately before every use of yytoken. 3392 | One alternative is translating here after every semantic action, 3393 | but that translation would be missed if the semantic action invokes 3394 | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3395 | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3396 | incorrect destructor might then be invoked immediately. In the 3397 | case of YYERROR or YYBACKUP, subsequent parser actions might lead 3398 | to an incorrect destructor call or verbose syntax error message 3399 | before the lookahead is translated. */ 3400 | YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 3401 | 3402 | YYPOPSTACK (yylen); 3403 | yylen = 0; 3404 | YY_STACK_PRINT (yyss, yyssp); 3405 | 3406 | *++yyvsp = yyval; 3407 | 3408 | /* Now `shift' the result of the reduction. Determine what state 3409 | that goes to, based on the state we popped back to and the rule 3410 | number reduced by. */ 3411 | 3412 | yyn = yyr1[yyn]; 3413 | 3414 | yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 3415 | if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 3416 | yystate = yytable[yystate]; 3417 | else 3418 | yystate = yydefgoto[yyn - YYNTOKENS]; 3419 | 3420 | goto yynewstate; 3421 | 3422 | 3423 | /*------------------------------------. 3424 | | yyerrlab -- here on detecting error | 3425 | `------------------------------------*/ 3426 | yyerrlab: 3427 | /* Make sure we have latest lookahead translation. See comments at 3428 | user semantic actions for why this is necessary. */ 3429 | yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 3430 | 3431 | /* If not already recovering from an error, report this error. */ 3432 | if (!yyerrstatus) 3433 | { 3434 | ++yynerrs; 3435 | #if ! YYERROR_VERBOSE 3436 | yyerror (YY_("syntax error")); 3437 | #else 3438 | # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 3439 | yyssp, yytoken) 3440 | { 3441 | char const *yymsgp = YY_("syntax error"); 3442 | int yysyntax_error_status; 3443 | yysyntax_error_status = YYSYNTAX_ERROR; 3444 | if (yysyntax_error_status == 0) 3445 | yymsgp = yymsg; 3446 | else if (yysyntax_error_status == 1) 3447 | { 3448 | if (yymsg != yymsgbuf) 3449 | YYSTACK_FREE (yymsg); 3450 | yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 3451 | if (!yymsg) 3452 | { 3453 | yymsg = yymsgbuf; 3454 | yymsg_alloc = sizeof yymsgbuf; 3455 | yysyntax_error_status = 2; 3456 | } 3457 | else 3458 | { 3459 | yysyntax_error_status = YYSYNTAX_ERROR; 3460 | yymsgp = yymsg; 3461 | } 3462 | } 3463 | yyerror (yymsgp); 3464 | if (yysyntax_error_status == 2) 3465 | goto yyexhaustedlab; 3466 | } 3467 | # undef YYSYNTAX_ERROR 3468 | #endif 3469 | } 3470 | 3471 | 3472 | 3473 | if (yyerrstatus == 3) 3474 | { 3475 | /* If just tried and failed to reuse lookahead token after an 3476 | error, discard it. */ 3477 | 3478 | if (yychar <= YYEOF) 3479 | { 3480 | /* Return failure if at end of input. */ 3481 | if (yychar == YYEOF) 3482 | YYABORT; 3483 | } 3484 | else 3485 | { 3486 | yydestruct ("Error: discarding", 3487 | yytoken, &yylval); 3488 | yychar = YYEMPTY; 3489 | } 3490 | } 3491 | 3492 | /* Else will try to reuse lookahead token after shifting the error 3493 | token. */ 3494 | goto yyerrlab1; 3495 | 3496 | 3497 | /*---------------------------------------------------. 3498 | | yyerrorlab -- error raised explicitly by YYERROR. | 3499 | `---------------------------------------------------*/ 3500 | yyerrorlab: 3501 | 3502 | /* Pacify compilers like GCC when the user code never invokes 3503 | YYERROR and the label yyerrorlab therefore never appears in user 3504 | code. */ 3505 | if (/*CONSTCOND*/ 0) 3506 | goto yyerrorlab; 3507 | 3508 | /* Do not reclaim the symbols of the rule which action triggered 3509 | this YYERROR. */ 3510 | YYPOPSTACK (yylen); 3511 | yylen = 0; 3512 | YY_STACK_PRINT (yyss, yyssp); 3513 | yystate = *yyssp; 3514 | goto yyerrlab1; 3515 | 3516 | 3517 | /*-------------------------------------------------------------. 3518 | | yyerrlab1 -- common code for both syntax error and YYERROR. | 3519 | `-------------------------------------------------------------*/ 3520 | yyerrlab1: 3521 | yyerrstatus = 3; /* Each real token shifted decrements this. */ 3522 | 3523 | for (;;) 3524 | { 3525 | yyn = yypact[yystate]; 3526 | if (!yypact_value_is_default (yyn)) 3527 | { 3528 | yyn += YYTERROR; 3529 | if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 3530 | { 3531 | yyn = yytable[yyn]; 3532 | if (0 < yyn) 3533 | break; 3534 | } 3535 | } 3536 | 3537 | /* Pop the current state because it cannot handle the error token. */ 3538 | if (yyssp == yyss) 3539 | YYABORT; 3540 | 3541 | 3542 | yydestruct ("Error: popping", 3543 | yystos[yystate], yyvsp); 3544 | YYPOPSTACK (1); 3545 | yystate = *yyssp; 3546 | YY_STACK_PRINT (yyss, yyssp); 3547 | } 3548 | 3549 | *++yyvsp = yylval; 3550 | 3551 | 3552 | /* Shift the error token. */ 3553 | YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 3554 | 3555 | yystate = yyn; 3556 | goto yynewstate; 3557 | 3558 | 3559 | /*-------------------------------------. 3560 | | yyacceptlab -- YYACCEPT comes here. | 3561 | `-------------------------------------*/ 3562 | yyacceptlab: 3563 | yyresult = 0; 3564 | goto yyreturn; 3565 | 3566 | /*-----------------------------------. 3567 | | yyabortlab -- YYABORT comes here. | 3568 | `-----------------------------------*/ 3569 | yyabortlab: 3570 | yyresult = 1; 3571 | goto yyreturn; 3572 | 3573 | #if !defined yyoverflow || YYERROR_VERBOSE 3574 | /*-------------------------------------------------. 3575 | | yyexhaustedlab -- memory exhaustion comes here. | 3576 | `-------------------------------------------------*/ 3577 | yyexhaustedlab: 3578 | yyerror (YY_("memory exhausted")); 3579 | yyresult = 2; 3580 | /* Fall through. */ 3581 | #endif 3582 | 3583 | yyreturn: 3584 | if (yychar != YYEMPTY) 3585 | { 3586 | /* Make sure we have latest lookahead translation. See comments at 3587 | user semantic actions for why this is necessary. */ 3588 | yytoken = YYTRANSLATE (yychar); 3589 | yydestruct ("Cleanup: discarding lookahead", 3590 | yytoken, &yylval); 3591 | } 3592 | /* Do not reclaim the symbols of the rule which action triggered 3593 | this YYABORT or YYACCEPT. */ 3594 | YYPOPSTACK (yylen); 3595 | YY_STACK_PRINT (yyss, yyssp); 3596 | while (yyssp != yyss) 3597 | { 3598 | yydestruct ("Cleanup: popping", 3599 | yystos[*yyssp], yyvsp); 3600 | YYPOPSTACK (1); 3601 | } 3602 | #ifndef yyoverflow 3603 | if (yyss != yyssa) 3604 | YYSTACK_FREE (yyss); 3605 | #endif 3606 | #if YYERROR_VERBOSE 3607 | if (yymsg != yymsgbuf) 3608 | YYSTACK_FREE (yymsg); 3609 | #endif 3610 | /* Make sure YYID is used. */ 3611 | return YYID (yyresult); 3612 | } 3613 | 3614 | 3615 | /* Line 2048 of yacc.c */ 3616 | #line 1343 "./parse.y" 3617 | 3618 | 3619 | #if YYDEBUG 3620 | 3621 | static int last_yylex[11]; 3622 | static char *last_yylval[11]; 3623 | static int count=0,modcount=0; 3624 | 3625 | #endif /* YYDEBUG */ 3626 | 3627 | 3628 | /*++++++++++++++++++++++++++++++++++++++ 3629 | Stop parsing the current file, due to an error. 3630 | 3631 | char *s The error message to print out. 3632 | ++++++++++++++++++++++++++++++++++++++*/ 3633 | 3634 | static void yyerror( char *s ) 3635 | { 3636 | #if YYDEBUG 3637 | int i; 3638 | #endif 3639 | 3640 | fflush(stdout); 3641 | fprintf(stderr,"%s:%d: cxref: %s\n\n",parse_file,parse_line,s); 3642 | 3643 | #if YYDEBUG 3644 | 3645 | fprintf(stderr,"The previous 10, current and next 10 symbols are:\n"); 3646 | 3647 | for(i=count>10?count-11:0,modcount=i%11;i<count-1;i++,modcount=i%11) 3648 | #ifdef YYBISON 3649 | fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1-count,last_yylex[modcount],yytname[YYTRANSLATE(last_yylex[modcount])],last_yylval[modcount]); 3650 | #else 3651 | fprintf(stderr,"%3d | %3d : %s\n",i+1-count,last_yylex[modcount],last_yylval[modcount]); 3652 | #endif 3653 | 3654 | #ifdef YYBISON 3655 | fprintf(stderr," 0 | %3d : %16s : %s\n",yychar,yytname[YYTRANSLATE(yychar)],yylval); 3656 | #else 3657 | fprintf(stderr," 0 | %3d : %s\n",yychar,yylval); 3658 | #endif 3659 | 3660 | for(i=0;i<10;i++) 3661 | { 3662 | yychar=yylex(); 3663 | if(!yychar) 3664 | {fprintf(stderr,"END OF FILE\n");break;} 3665 | #ifdef YYBISON 3666 | fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1,yychar,yytname[YYTRANSLATE(yychar)],yylval); 3667 | #else 3668 | fprintf(stderr,"%3d | %3d : %s\n",i+1,yychar,yylval); 3669 | #endif 3670 | } 3671 | 3672 | fprintf(stderr,"\n"); 3673 | 3674 | #endif /* YYDEBUG */ 3675 | 3676 | /* Finish off the input. */ 3677 | 3678 | #undef yylex 3679 | 3680 | if(yychar) 3681 | while((yychar=yylex())); 3682 | } 3683 | 3684 | 3685 | /*++++++++++++++++++++++++++++++++++++++ 3686 | Call the lexer, the feedback from the parser to the lexer is applied here. 3687 | 3688 | int cxref_yylex Returns the value from the lexer, modified due to parser feedback. 3689 | ++++++++++++++++++++++++++++++++++++++*/ 3690 | 3691 | static int cxref_yylex(void) 3692 | { 3693 | static int last_yyl=0; 3694 | int yyl=yylex(); 3695 | 3696 | if(yyl==TYPE_NAME) 3697 | if(in_type_spec || (in_structunion && last_yyl=='}') || last_yyl==TYPE_NAME || 3698 | last_yyl==GOTO || 3699 | last_yyl==CHAR || last_yyl==SHORT || last_yyl==INT || last_yyl==LONG || 3700 | last_yyl==SIGNED || last_yyl==UNSIGNED || 3701 | last_yyl==FLOAT || last_yyl==DOUBLE || 3702 | last_yyl==BOOL) 3703 | yyl=IDENTIFIER; 3704 | 3705 | last_yyl=yyl; 3706 | 3707 | #if YYDEBUG 3708 | 3709 | last_yylex [modcount]=yyl; 3710 | last_yylval[modcount]=yylval; 3711 | 3712 | if(yyl) 3713 | { 3714 | count++; 3715 | modcount=count%11; 3716 | } 3717 | else 3718 | { 3719 | count=0; 3720 | modcount=0; 3721 | } 3722 | 3723 | #if YYDEBUG == 2 3724 | 3725 | if(yyl) 3726 | #ifdef YYBISON 3727 | printf("#parse.y# %6d | %16s:%4d | %3d : %16s : %s\n",count,parse_file,parse_line,yyl,yytname[YYTRANSLATE(yyl)],yylval); 3728 | #else 3729 | printf("#parse.y# %6d | %16s:%4d | %3d : %s\n",count,parse_file,parse_line,yyl,yylval); 3730 | #endif /* YYBISON */ 3731 | else 3732 | printf("#parse.y# %6d | %16s:%4d | END OF FILE\n",count,parse_file,parse_line); 3733 | 3734 | fflush(stdout); 3735 | 3736 | #endif /* YYDEBUG==2 */ 3737 | 3738 | #endif /* YYDEBUG */ 3739 | 3740 | return(yyl); 3741 | }