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