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