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