1 /* original parser id follows */ 2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5 #define YYBYACC 1 6 #define YYMAJOR 1 7 #define YYMINOR 9 8 #define YYCHECK "yyyymmdd" 9 10 #define YYEMPTY (-1) 11 #define yyclearin (yychar = YYEMPTY) 12 #define yyerrok (yyerrflag = 0) 13 #define YYRECOVERING() (yyerrflag != 0) 14 #define YYENOMEM (-2) 15 #define YYEOF 0 16 #undef YYBTYACC 17 #define YYBTYACC 0 18 #define YYDEBUGSTR YYPREFIX "debug" 19 20 #ifndef yyparse 21 #define yyparse grammar_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex grammar_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror grammar_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar grammar_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval grammar_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval grammar_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug grammar_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs grammar_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag grammar_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs grammar_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen grammar_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred grammar_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos grammar_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto grammar_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex grammar_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex grammar_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex grammar_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable grammar_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck grammar_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname grammar_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule grammar_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex grammar_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable grammar_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "grammar_" 117 118 #define YYPURE 0 119 120 #line 9 "grammar.y" 121 #ifdef YYBISON 122 #include <stdlib.h> 123 #define YYSTYPE_IS_DECLARED 124 #define yyerror yaccError 125 #endif 126 127 #if defined(YYBISON) || !defined(YYBYACC) 128 static void yyerror(const char *s); 129 #endif 130 #line 81 "grammar.y" 131 #include <stdio.h> 132 #include <ctype.h> 133 #include <string.h> 134 135 #define OPT_LINTLIBRARY 1 136 137 #ifndef TRUE 138 #define TRUE (1) 139 #endif 140 141 #ifndef FALSE 142 #define FALSE (0) 143 #endif 144 145 /* #include "cproto.h" */ 146 #define MAX_TEXT_SIZE 1024 147 148 /* Prototype styles */ 149 #if OPT_LINTLIBRARY 150 #define PROTO_ANSI_LLIB -2 /* form ANSI lint-library source */ 151 #define PROTO_LINTLIBRARY -1 /* form lint-library source */ 152 #endif 153 #define PROTO_NONE 0 /* do not output any prototypes */ 154 #define PROTO_TRADITIONAL 1 /* comment out parameters */ 155 #define PROTO_ABSTRACT 2 /* comment out parameter names */ 156 #define PROTO_ANSI 3 /* ANSI C prototype */ 157 158 typedef int PrototypeStyle; 159 160 typedef char boolean; 161 162 extern boolean types_out; 163 extern PrototypeStyle proto_style; 164 165 #define ansiLintLibrary() (proto_style == PROTO_ANSI_LLIB) 166 #define knrLintLibrary() (proto_style == PROTO_LINTLIBRARY) 167 #define lintLibrary() (knrLintLibrary() || ansiLintLibrary()) 168 169 #if OPT_LINTLIBRARY 170 #define FUNC_UNKNOWN -1 /* unspecified */ 171 #else 172 #define FUNC_UNKNOWN 0 /* unspecified (same as FUNC_NONE) */ 173 #endif 174 #define FUNC_NONE 0 /* not a function definition */ 175 #define FUNC_TRADITIONAL 1 /* traditional style */ 176 #define FUNC_ANSI 2 /* ANSI style */ 177 #define FUNC_BOTH 3 /* both styles */ 178 179 typedef int FuncDefStyle; 180 181 /* Source file text */ 182 typedef struct text { 183 char text[MAX_TEXT_SIZE]; /* source text */ 184 long begin; /* offset in temporary file */ 185 } Text; 186 187 /* Declaration specifier flags */ 188 #define DS_NONE 0 /* default */ 189 #define DS_EXTERN 1 /* contains "extern" specifier */ 190 #define DS_STATIC 2 /* contains "static" specifier */ 191 #define DS_CHAR 4 /* contains "char" type specifier */ 192 #define DS_SHORT 8 /* contains "short" type specifier */ 193 #define DS_FLOAT 16 /* contains "float" type specifier */ 194 #define DS_INLINE 32 /* contains "inline" specifier */ 195 #define DS_JUNK 64 /* we're not interested in this declaration */ 196 197 /* This structure stores information about a declaration specifier. */ 198 typedef struct decl_spec { 199 unsigned short flags; /* flags defined above */ 200 char *text; /* source text */ 201 long begin; /* offset in temporary file */ 202 } DeclSpec; 203 204 /* This is a list of function parameters. */ 205 typedef struct _ParameterList { 206 struct parameter *first; /* pointer to first parameter in list */ 207 struct parameter *last; /* pointer to last parameter in list */ 208 long begin_comment; /* begin offset of comment */ 209 long end_comment; /* end offset of comment */ 210 char *comment; /* comment at start of parameter list */ 211 } ParameterList; 212 213 /* This structure stores information about a declarator. */ 214 typedef struct _Declarator { 215 char *name; /* name of variable or function */ 216 char *text; /* source text */ 217 long begin; /* offset in temporary file */ 218 long begin_comment; /* begin offset of comment */ 219 long end_comment; /* end offset of comment */ 220 FuncDefStyle func_def; /* style of function definition */ 221 ParameterList params; /* function parameters */ 222 boolean pointer; /* TRUE if it declares a pointer */ 223 struct _Declarator *head; /* head function declarator */ 224 struct _Declarator *func_stack; /* stack of function declarators */ 225 struct _Declarator *next; /* next declarator in list */ 226 } Declarator; 227 228 /* This structure stores information about a function parameter. */ 229 typedef struct parameter { 230 struct parameter *next; /* next parameter in list */ 231 DeclSpec decl_spec; 232 Declarator *declarator; 233 char *comment; /* comment following the parameter */ 234 } Parameter; 235 236 /* This is a list of declarators. */ 237 typedef struct declarator_list { 238 Declarator *first; /* pointer to first declarator in list */ 239 Declarator *last; /* pointer to last declarator in list */ 240 } DeclaratorList; 241 242 /* #include "symbol.h" */ 243 typedef struct symbol { 244 struct symbol *next; /* next symbol in list */ 245 char *name; /* name of symbol */ 246 char *value; /* value of symbol (for defines) */ 247 short flags; /* symbol attributes */ 248 } Symbol; 249 250 /* parser stack entry type */ 251 typedef union { 252 Text text; 253 DeclSpec decl_spec; 254 Parameter *parameter; 255 ParameterList param_list; 256 Declarator *declarator; 257 DeclaratorList decl_list; 258 } YYSTYPE; 259 260 /* The hash table length should be a prime number. */ 261 #define SYM_MAX_HASH 251 262 263 typedef struct symbol_table { 264 Symbol *bucket[SYM_MAX_HASH]; /* hash buckets */ 265 } SymbolTable; 266 267 extern SymbolTable *new_symbol_table /* Create symbol table */ 268 (void); 269 extern void free_symbol_table /* Destroy symbol table */ 270 (SymbolTable *s); 271 extern Symbol *find_symbol /* Lookup symbol name */ 272 (SymbolTable *s, const char *n); 273 extern Symbol *new_symbol /* Define new symbol */ 274 (SymbolTable *s, const char *n, const char *v, int f); 275 276 /* #include "semantic.h" */ 277 extern void new_decl_spec (DeclSpec *, const char *, long, int); 278 extern void free_decl_spec (DeclSpec *); 279 extern void join_decl_specs (DeclSpec *, DeclSpec *, DeclSpec *); 280 extern void check_untagged (DeclSpec *); 281 extern Declarator *new_declarator (const char *, const char *, long); 282 extern void free_declarator (Declarator *); 283 extern void new_decl_list (DeclaratorList *, Declarator *); 284 extern void free_decl_list (DeclaratorList *); 285 extern void add_decl_list (DeclaratorList *, DeclaratorList *, Declarator *); 286 extern Parameter *new_parameter (DeclSpec *, Declarator *); 287 extern void free_parameter (Parameter *); 288 extern void new_param_list (ParameterList *, Parameter *); 289 extern void free_param_list (ParameterList *); 290 extern void add_param_list (ParameterList *, ParameterList *, Parameter *); 291 extern void new_ident_list (ParameterList *); 292 extern void add_ident_list (ParameterList *, ParameterList *, const char *); 293 extern void set_param_types (ParameterList *, DeclSpec *, DeclaratorList *); 294 extern void gen_declarations (DeclSpec *, DeclaratorList *); 295 extern void gen_prototype (DeclSpec *, Declarator *); 296 extern void gen_func_declarator (Declarator *); 297 extern void gen_func_definition (DeclSpec *, Declarator *); 298 299 extern void init_parser (void); 300 extern void process_file (FILE *infile, char *name); 301 extern char *cur_text (void); 302 extern char *cur_file_name (void); 303 extern char *implied_typedef (void); 304 extern void include_file (char *name, int convert); 305 extern char *supply_parm (int count); 306 extern char *xstrdup (const char *); 307 extern int already_declared (char *name); 308 extern int is_actual_func (Declarator *d); 309 extern int lint_ellipsis (Parameter *p); 310 extern int want_typedef (void); 311 extern void begin_tracking (void); 312 extern void begin_typedef (void); 313 extern void copy_typedef (char *s); 314 extern void ellipsis_varargs (Declarator *d); 315 extern void end_typedef (void); 316 extern void flush_varargs (void); 317 extern void fmt_library (int code); 318 extern void imply_typedef (const char *s); 319 extern void indent (FILE *outf); 320 extern void put_blankline (FILE *outf); 321 extern void put_body (FILE *outf, DeclSpec *decl_spec, Declarator *declarator); 322 extern void put_char (FILE *outf, int c); 323 extern void put_error (void); 324 extern void put_newline (FILE *outf); 325 extern void put_padded (FILE *outf, const char *s); 326 extern void put_string (FILE *outf, const char *s); 327 extern void track_in (void); 328 329 extern boolean file_comments; 330 extern FuncDefStyle func_style; 331 extern char base_file[]; 332 333 extern int yylex (void); 334 335 /* declaration specifier attributes for the typedef statement currently being 336 * scanned 337 */ 338 static int cur_decl_spec_flags; 339 340 /* pointer to parameter list for the current function definition */ 341 static ParameterList *func_params; 342 343 /* A parser semantic action sets this pointer to the current declarator in 344 * a function parameter declaration in order to catch any comments following 345 * the parameter declaration on the same line. If the lexer scans a comment 346 * and <cur_declarator> is not NULL, then the comment is attached to the 347 * declarator. To ignore subsequent comments, the lexer sets this to NULL 348 * after scanning a comment or end of line. 349 */ 350 static Declarator *cur_declarator; 351 352 /* temporary string buffer */ 353 static char buf[MAX_TEXT_SIZE]; 354 355 /* table of typedef names */ 356 static SymbolTable *typedef_names; 357 358 /* table of define names */ 359 static SymbolTable *define_names; 360 361 /* table of type qualifiers */ 362 static SymbolTable *type_qualifiers; 363 364 /* information about the current input file */ 365 typedef struct { 366 char *base_name; /* base input file name */ 367 char *file_name; /* current file name */ 368 FILE *file; /* input file */ 369 unsigned line_num; /* current line number in input file */ 370 FILE *tmp_file; /* temporary file */ 371 long begin_comment; /* tmp file offset after last written ) or ; */ 372 long end_comment; /* tmp file offset after last comment */ 373 boolean convert; /* if TRUE, convert function definitions */ 374 boolean changed; /* TRUE if conversion done in this file */ 375 } IncludeStack; 376 377 static IncludeStack *cur_file; /* current input file */ 378 379 /* #include "yyerror.c" */ 380 381 static int haveAnsiParam (void); 382 383 384 /* Flags to enable us to find if a procedure returns a value. 385 */ 386 static int return_val; /* nonzero on BRACES iff return-expression found */ 387 388 static const char * 389 dft_decl_spec (void) 390 { 391 return (lintLibrary() && !return_val) ? "void" : "int"; 392 } 393 394 static int 395 haveAnsiParam (void) 396 { 397 Parameter *p; 398 if (func_params != 0) { 399 for (p = func_params->first; p != 0; p = p->next) { 400 if (p->declarator->func_def == FUNC_ANSI) { 401 return TRUE; 402 } 403 } 404 } 405 return FALSE; 406 } 407 #line 408 "grammar.tab.c" 408 409 /* compatibility with bison */ 410 #ifdef YYPARSE_PARAM 411 /* compatibility with FreeBSD */ 412 # ifdef YYPARSE_PARAM_TYPE 413 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 414 # else 415 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 416 # endif 417 #else 418 # define YYPARSE_DECL() yyparse(void) 419 #endif 420 421 /* Parameters sent to lex. */ 422 #ifdef YYLEX_PARAM 423 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 424 # define YYLEX yylex(YYLEX_PARAM) 425 #else 426 # define YYLEX_DECL() yylex(void) 427 # define YYLEX yylex() 428 #endif 429 430 /* Parameters sent to yyerror. */ 431 #ifndef YYERROR_DECL 432 #define YYERROR_DECL() yyerror(const char *s) 433 #endif 434 #ifndef YYERROR_CALL 435 #define YYERROR_CALL(msg) yyerror(msg) 436 #endif 437 438 extern int YYPARSE_DECL(); 439 440 #define T_IDENTIFIER 257 441 #define T_TYPEDEF_NAME 258 442 #define T_DEFINE_NAME 259 443 #define T_AUTO 260 444 #define T_EXTERN 261 445 #define T_REGISTER 262 446 #define T_STATIC 263 447 #define T_TYPEDEF 264 448 #define T_INLINE 265 449 #define T_EXTENSION 266 450 #define T_CHAR 267 451 #define T_DOUBLE 268 452 #define T_FLOAT 269 453 #define T_INT 270 454 #define T_VOID 271 455 #define T_LONG 272 456 #define T_SHORT 273 457 #define T_SIGNED 274 458 #define T_UNSIGNED 275 459 #define T_ENUM 276 460 #define T_STRUCT 277 461 #define T_UNION 278 462 #define T_Bool 279 463 #define T_Complex 280 464 #define T_Imaginary 281 465 #define T_TYPE_QUALIFIER 282 466 #define T_BRACKETS 283 467 #define T_LBRACE 284 468 #define T_MATCHRBRACE 285 469 #define T_ELLIPSIS 286 470 #define T_INITIALIZER 287 471 #define T_STRING_LITERAL 288 472 #define T_ASM 289 473 #define T_ASMARG 290 474 #define T_VA_DCL 291 475 #define YYERRCODE 256 476 typedef short YYINT; 477 static const YYINT grammar_lhs[] = { -1, 478 0, 0, 26, 26, 27, 27, 27, 27, 27, 27, 479 27, 31, 30, 30, 28, 28, 34, 28, 32, 32, 480 33, 33, 35, 35, 37, 38, 29, 39, 29, 36, 481 36, 36, 40, 40, 1, 1, 2, 2, 2, 3, 482 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 483 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 484 5, 5, 6, 6, 6, 19, 19, 8, 8, 9, 485 41, 9, 7, 7, 7, 25, 23, 23, 10, 10, 486 11, 11, 11, 11, 11, 20, 20, 21, 21, 22, 487 22, 14, 14, 15, 15, 16, 16, 16, 17, 17, 488 18, 18, 24, 24, 12, 12, 12, 13, 13, 13, 489 13, 13, 13, 13, 490 }; 491 static const YYINT grammar_len[] = { 2, 492 0, 1, 1, 2, 1, 1, 1, 1, 3, 2, 493 2, 2, 3, 3, 2, 3, 0, 5, 2, 1, 494 0, 1, 1, 3, 0, 0, 7, 0, 5, 0, 495 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 497 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 498 1, 1, 3, 2, 2, 1, 1, 1, 3, 1, 499 0, 4, 3, 2, 2, 1, 1, 1, 2, 1, 500 1, 3, 2, 4, 4, 2, 3, 0, 1, 1, 501 2, 1, 3, 1, 3, 2, 2, 1, 0, 1, 502 1, 3, 1, 2, 1, 2, 1, 3, 2, 1, 503 4, 3, 3, 2, 504 }; 505 static const YYINT grammar_defred[] = { 0, 506 0, 0, 0, 0, 77, 0, 62, 40, 0, 42, 507 43, 20, 44, 0, 46, 47, 48, 49, 54, 50, 508 51, 52, 53, 76, 66, 67, 55, 56, 57, 61, 509 0, 7, 0, 0, 35, 37, 38, 39, 59, 60, 510 28, 0, 0, 0, 103, 81, 0, 0, 3, 5, 511 6, 8, 0, 10, 11, 78, 0, 90, 0, 0, 512 104, 0, 19, 0, 41, 45, 15, 36, 0, 68, 513 0, 0, 0, 83, 0, 0, 64, 0, 0, 74, 514 4, 58, 0, 82, 87, 91, 0, 14, 13, 9, 515 16, 0, 71, 0, 31, 33, 0, 0, 0, 0, 516 0, 94, 0, 0, 101, 12, 63, 73, 0, 0, 517 69, 0, 0, 0, 34, 0, 110, 96, 97, 0, 518 0, 84, 0, 85, 0, 23, 0, 0, 72, 26, 519 29, 114, 0, 0, 0, 109, 0, 93, 95, 102, 520 18, 0, 0, 108, 113, 112, 0, 24, 27, 111, 521 }; 522 static const YYINT grammar_stos[] = { 0, 523 256, 40, 42, 38, 257, 258, 259, 260, 261, 262, 524 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 525 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 526 289, 59, 293, 294, 295, 296, 297, 298, 299, 300, 527 303, 304, 312, 313, 316, 317, 318, 319, 320, 321, 528 322, 323, 325, 285, 59, 258, 303, 298, 314, 315, 529 316, 288, 264, 290, 261, 266, 59, 295, 301, 302, 530 303, 332, 40, 283, 284, 316, 324, 304, 316, 324, 531 320, 258, 294, 41, 313, 298, 294, 321, 324, 59, 532 59, 44, 61, 330, 291, 321, 329, 333, 294, 307, 533 308, 309, 310, 311, 316, 285, 324, 324, 327, 303, 534 302, 334, 329, 284, 321, 40, 283, 303, 305, 306, 535 313, 41, 44, 41, 44, 303, 326, 328, 287, 284, 536 285, 41, 305, 307, 40, 283, 306, 286, 309, 316, 537 59, 44, 331, 41, 41, 41, 307, 303, 285, 41, 538 }; 539 static const YYINT grammar_dgoto[] = { 33, 540 87, 35, 36, 37, 38, 39, 40, 69, 70, 41, 541 42, 119, 120, 100, 101, 102, 103, 104, 43, 44, 542 59, 60, 45, 46, 47, 48, 49, 50, 51, 52, 543 77, 53, 127, 109, 128, 97, 94, 143, 72, 98, 544 112, 545 }; 546 static const YYINT grammar_sindex[] = { -2, 547 -3, 27, -239, -177, 0, 0, 0, 0, -274, 0, 548 0, 0, 0, -246, 0, 0, 0, 0, 0, 0, 549 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 550 -266, 0, 0, 455, 0, 0, 0, 0, 0, 0, 551 0, -35, -245, 128, 0, 0, -245, -2, 0, 0, 552 0, 0, 642, 0, 0, 0, -15, 0, -12, -239, 553 0, 590, 0, -27, 0, 0, 0, 0, -10, 0, 554 -11, 534, -72, 0, -237, -232, 0, -35, -232, 0, 555 0, 0, 642, 0, 0, 0, 455, 0, 0, 0, 556 0, 27, 0, 534, 0, 0, -222, 617, 209, 34, 557 39, 0, 44, 42, 0, 0, 0, 0, 27, -11, 558 0, -200, -196, -195, 0, 174, 0, 0, 0, -33, 559 243, 0, 561, 0, -177, 0, 33, 49, 0, 0, 560 0, 0, 53, 55, 417, 0, -33, 0, 0, 0, 561 0, 27, -188, 0, 0, 0, 57, 0, 0, 0, 562 }; 563 static const YYINT grammar_rindex[] = { 99, 564 0, 0, 275, 0, 0, -38, 0, 0, 481, 0, 565 0, 0, 0, 509, 0, 0, 0, 0, 0, 0, 566 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 567 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 568 0, 30, 0, 0, 0, 0, 0, 101, 0, 0, 569 0, 0, 0, 0, 0, 0, 0, 0, 343, 309, 570 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 571 98, -182, 62, 0, 0, 133, 0, 64, 379, 0, 572 0, 0, -5, 0, 0, 0, 0, 0, 0, 0, 573 0, 0, 0, -182, 0, 0, 0, -180, -19, 0, 574 65, 0, 0, 68, 0, 0, 0, 0, 51, 9, 575 0, 0, 0, 0, 0, 0, 0, 0, 0, -13, 576 19, 0, 0, 0, 0, 0, 0, 52, 0, 0, 577 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 578 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 579 }; 580 #if YYBTYACC 581 static const YYINT grammar_cindex[] = { 0, 582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 583 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 587 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 590 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 593 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 594 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 595 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 596 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 597 }; 598 #endif 599 static const YYINT grammar_gindex[] = { 0, 600 11, -17, 0, 0, 13, 0, 0, 0, 20, 8, 601 -43, -1, -8, -89, 0, -9, 0, 0, 0, -44, 602 0, 0, 4, 0, 0, 0, 70, -53, 0, 0, 603 -18, 0, 0, 0, 0, 22, 0, 0, 0, 0, 604 0, 605 }; 606 #define YYTABLESIZE 924 607 static const YYINT grammar_table[] = { 58, 608 78, 58, 58, 58, 73, 58, 135, 61, 88, 57, 609 34, 5, 56, 62, 85, 58, 68, 63, 96, 7, 610 58, 98, 78, 64, 98, 84, 134, 107, 80, 3, 611 107, 90, 17, 92, 17, 4, 17, 2, 75, 3, 612 96, 71, 30, 89, 115, 147, 76, 106, 91, 93, 613 79, 75, 70, 17, 121, 55, 32, 107, 34, 105, 614 108, 114, 105, 83, 4, 68, 2, 70, 3, 68, 615 80, 121, 86, 80, 122, 106, 105, 78, 106, 5, 616 56, 68, 123, 99, 124, 125, 129, 130, 80, 131, 617 80, 141, 142, 144, 110, 145, 149, 150, 1, 110, 618 2, 30, 99, 32, 79, 92, 118, 79, 100, 21, 619 22, 111, 137, 139, 133, 113, 126, 81, 0, 0, 620 0, 0, 79, 57, 79, 0, 99, 0, 140, 0, 621 0, 0, 0, 99, 0, 0, 0, 0, 0, 0, 622 0, 70, 0, 0, 0, 99, 0, 0, 0, 148, 623 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 624 0, 0, 0, 0, 0, 4, 0, 2, 0, 0, 625 65, 0, 65, 65, 65, 0, 65, 0, 0, 0, 626 0, 0, 0, 0, 5, 6, 7, 8, 65, 10, 627 11, 65, 13, 66, 15, 16, 17, 18, 19, 20, 628 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 629 0, 4, 0, 116, 132, 3, 0, 0, 58, 58, 630 58, 58, 58, 58, 58, 78, 58, 58, 58, 58, 631 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 632 58, 58, 58, 58, 58, 78, 4, 74, 116, 136, 633 3, 17, 78, 1, 5, 6, 7, 8, 9, 10, 634 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 635 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 636 4, 54, 116, 5, 56, 0, 31, 80, 80, 80, 637 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 638 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 639 80, 80, 88, 80, 88, 88, 88, 0, 88, 0, 640 80, 79, 79, 79, 79, 79, 79, 79, 79, 79, 641 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 642 79, 79, 79, 79, 79, 79, 89, 79, 89, 89, 643 89, 0, 89, 0, 79, 25, 25, 25, 25, 25, 644 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 645 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 646 86, 25, 86, 86, 5, 56, 86, 0, 25, 65, 647 65, 65, 65, 65, 65, 65, 0, 65, 65, 65, 648 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 649 65, 65, 65, 65, 65, 65, 75, 0, 75, 75, 650 75, 0, 75, 0, 0, 0, 0, 0, 0, 0, 651 5, 6, 7, 8, 65, 10, 11, 75, 13, 66, 652 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 653 25, 26, 27, 28, 29, 30, 117, 146, 0, 0, 654 0, 0, 0, 0, 0, 5, 6, 7, 8, 65, 655 10, 11, 0, 13, 66, 15, 16, 17, 18, 19, 656 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 657 30, 117, 4, 0, 2, 0, 3, 0, 0, 5, 658 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 659 0, 0, 0, 67, 0, 0, 0, 0, 41, 0, 660 41, 0, 41, 0, 0, 117, 0, 0, 0, 0, 661 0, 88, 88, 0, 0, 0, 0, 0, 0, 41, 662 0, 0, 0, 0, 0, 0, 45, 0, 45, 0, 663 45, 0, 0, 0, 0, 0, 0, 88, 0, 0, 664 0, 0, 0, 0, 0, 89, 89, 45, 0, 0, 665 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 666 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 667 0, 89, 0, 0, 0, 0, 0, 0, 0, 86, 668 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 669 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 670 0, 0, 0, 0, 0, 86, 0, 0, 0, 0, 671 0, 0, 0, 0, 0, 75, 75, 75, 75, 75, 672 75, 75, 0, 75, 75, 75, 75, 75, 75, 75, 673 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 674 75, 75, 0, 0, 0, 0, 0, 0, 0, 0, 675 0, 0, 0, 0, 82, 7, 8, 65, 10, 11, 676 0, 13, 66, 15, 16, 17, 18, 19, 20, 21, 677 22, 23, 24, 25, 26, 27, 28, 29, 30, 0, 678 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 679 0, 5, 6, 7, 8, 65, 10, 11, 0, 13, 680 66, 15, 16, 17, 18, 19, 20, 21, 22, 23, 681 24, 25, 26, 27, 28, 29, 30, 41, 41, 41, 682 41, 41, 41, 41, 0, 41, 41, 41, 41, 41, 683 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 684 41, 41, 41, 0, 0, 45, 45, 45, 45, 45, 685 45, 45, 0, 45, 45, 45, 45, 45, 45, 45, 686 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 687 45, 82, 7, 8, 65, 10, 11, 12, 13, 14, 688 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 689 25, 26, 27, 28, 29, 30, 0, 0, 82, 7, 690 8, 65, 10, 11, 95, 13, 66, 15, 16, 17, 691 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 692 28, 29, 30, 0, 0, 0, 138, 82, 7, 8, 693 65, 10, 11, 12, 13, 14, 15, 16, 17, 18, 694 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 695 29, 30, 0, 75, 82, 7, 8, 65, 10, 11, 696 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 697 22, 23, 24, 25, 26, 27, 28, 29, 30, 82, 698 7, 8, 65, 10, 11, 0, 13, 66, 15, 16, 699 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 700 27, 28, 29, 30, 701 }; 702 static const YYINT grammar_check[] = { 38, 703 44, 40, 41, 42, 40, 44, 40, 4, 62, 2, 704 0, 257, 258, 288, 59, 3, 34, 264, 72, 259, 705 59, 41, 61, 290, 44, 41, 116, 41, 47, 42, 706 44, 59, 38, 44, 40, 38, 42, 40, 284, 42, 707 94, 34, 282, 62, 98, 135, 43, 285, 59, 61, 708 47, 284, 44, 59, 99, 59, 59, 76, 48, 41, 709 79, 284, 44, 53, 38, 83, 40, 59, 42, 87, 710 41, 116, 60, 44, 41, 41, 73, 121, 44, 257, 711 258, 99, 44, 73, 41, 44, 287, 284, 59, 285, 712 61, 59, 44, 41, 87, 41, 285, 41, 0, 92, 713 0, 284, 41, 284, 41, 41, 99, 44, 41, 59, 714 59, 92, 121, 123, 116, 94, 109, 48, -1, -1, 715 -1, -1, 59, 116, 61, -1, 116, -1, 125, -1, 716 -1, -1, -1, 123, -1, -1, -1, -1, -1, -1, 717 -1, 44, -1, -1, -1, 135, -1, -1, -1, 142, 718 -1, -1, -1, -1, -1, -1, 59, -1, -1, -1, 719 -1, -1, -1, -1, -1, 38, -1, 40, -1, -1, 720 38, -1, 40, 41, 42, -1, 44, -1, -1, -1, 721 -1, -1, -1, -1, 257, 258, 259, 260, 261, 262, 722 263, 59, 265, 266, 267, 268, 269, 270, 271, 272, 723 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 724 -1, 38, -1, 40, 41, 42, -1, -1, 257, 258, 725 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 726 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 727 279, 280, 281, 282, 283, 284, 38, 283, 40, 283, 728 42, 257, 291, 256, 257, 258, 259, 260, 261, 262, 729 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 730 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 731 38, 285, 40, 257, 258, -1, 289, 258, 259, 260, 732 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 733 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 734 281, 282, 38, 284, 40, 41, 42, -1, 44, -1, 735 291, 258, 259, 260, 261, 262, 263, 264, 265, 266, 736 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 737 277, 278, 279, 280, 281, 282, 38, 284, 40, 41, 738 42, -1, 44, -1, 291, 258, 259, 260, 261, 262, 739 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 740 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 741 38, 284, 40, 41, 257, 258, 44, -1, 291, 257, 742 258, 259, 260, 261, 262, 263, -1, 265, 266, 267, 743 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 744 278, 279, 280, 281, 282, 283, 38, -1, 40, 41, 745 42, -1, 44, -1, -1, -1, -1, -1, -1, -1, 746 257, 258, 259, 260, 261, 262, 263, 59, 265, 266, 747 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 748 277, 278, 279, 280, 281, 282, 283, 41, -1, -1, 749 -1, -1, -1, -1, -1, 257, 258, 259, 260, 261, 750 262, 263, -1, 265, 266, 267, 268, 269, 270, 271, 751 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 752 282, 283, 38, -1, 40, -1, 42, -1, -1, 257, 753 258, -1, -1, -1, -1, -1, -1, -1, -1, -1, 754 -1, -1, -1, 59, -1, -1, -1, -1, 38, -1, 755 40, -1, 42, -1, -1, 283, -1, -1, -1, -1, 756 -1, 257, 258, -1, -1, -1, -1, -1, -1, 59, 757 -1, -1, -1, -1, -1, -1, 38, -1, 40, -1, 758 42, -1, -1, -1, -1, -1, -1, 283, -1, -1, 759 -1, -1, -1, -1, -1, 257, 258, 59, -1, -1, 760 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 761 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 762 -1, 283, -1, -1, -1, -1, -1, -1, -1, 257, 763 258, -1, -1, -1, -1, -1, -1, -1, -1, -1, 764 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 765 -1, -1, -1, -1, -1, 283, -1, -1, -1, -1, 766 -1, -1, -1, -1, -1, 257, 258, 259, 260, 261, 767 262, 263, -1, 265, 266, 267, 268, 269, 270, 271, 768 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 769 282, 283, -1, -1, -1, -1, -1, -1, -1, -1, 770 -1, -1, -1, -1, 258, 259, 260, 261, 262, 263, 771 -1, 265, 266, 267, 268, 269, 270, 271, 272, 273, 772 274, 275, 276, 277, 278, 279, 280, 281, 282, -1, 773 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 774 -1, 257, 258, 259, 260, 261, 262, 263, -1, 265, 775 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 776 276, 277, 278, 279, 280, 281, 282, 257, 258, 259, 777 260, 261, 262, 263, -1, 265, 266, 267, 268, 269, 778 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 779 280, 281, 282, -1, -1, 257, 258, 259, 260, 261, 780 262, 263, -1, 265, 266, 267, 268, 269, 270, 271, 781 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 782 282, 258, 259, 260, 261, 262, 263, 264, 265, 266, 783 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 784 277, 278, 279, 280, 281, 282, -1, -1, 258, 259, 785 260, 261, 262, 263, 291, 265, 266, 267, 268, 269, 786 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 787 280, 281, 282, -1, -1, -1, 286, 258, 259, 260, 788 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 789 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 790 281, 282, -1, 284, 258, 259, 260, 261, 262, 263, 791 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 792 274, 275, 276, 277, 278, 279, 280, 281, 282, 258, 793 259, 260, 261, 262, 263, -1, 265, 266, 267, 268, 794 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 795 279, 280, 281, 282, 796 }; 797 #if YYBTYACC 798 static const YYINT grammar_ctable[] = { -1, 799 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 800 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 803 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 804 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 806 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 809 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 810 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 811 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 812 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 813 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 814 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 815 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 816 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 818 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 819 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 820 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 821 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 822 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 823 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 824 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 825 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 828 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 830 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 831 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 832 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 834 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 837 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 838 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 839 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 840 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 841 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 842 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 843 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 844 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 845 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 846 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 847 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 848 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 849 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 850 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 851 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 852 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 853 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 854 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 855 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 856 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 857 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 858 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 859 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 860 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 861 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 862 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 863 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 864 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 865 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 866 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 867 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 868 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 869 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 870 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 871 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 872 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 874 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 875 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 876 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 877 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 878 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 879 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 880 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 881 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 882 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 883 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 884 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 885 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 886 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 887 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 888 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 889 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 890 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 891 -1, -1, -1, 892 }; 893 #endif 894 #define YYFINAL 33 895 #ifndef YYDEBUG 896 #define YYDEBUG 0 897 #endif 898 #define YYMAXTOKEN 291 899 #define YYUNDFTOKEN 335 900 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 901 #if YYDEBUG 902 static const char *const grammar_name[] = { 903 904 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 905 0,"'&'",0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,"'='",0, 906 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 907 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 908 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 909 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 910 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error", 911 "T_IDENTIFIER","T_TYPEDEF_NAME","T_DEFINE_NAME","T_AUTO","T_EXTERN", 912 "T_REGISTER","T_STATIC","T_TYPEDEF","T_INLINE","T_EXTENSION","T_CHAR", 913 "T_DOUBLE","T_FLOAT","T_INT","T_VOID","T_LONG","T_SHORT","T_SIGNED", 914 "T_UNSIGNED","T_ENUM","T_STRUCT","T_UNION","T_Bool","T_Complex","T_Imaginary", 915 "T_TYPE_QUALIFIER","T_BRACKETS","T_LBRACE","T_MATCHRBRACE","T_ELLIPSIS", 916 "T_INITIALIZER","T_STRING_LITERAL","T_ASM","T_ASMARG","T_VA_DCL","$accept", 917 "program","decl_specifiers","decl_specifier","storage_class","type_specifier", 918 "type_qualifier","struct_or_union_specifier","enum_specifier", 919 "init_declarator_list","init_declarator","declarator","direct_declarator", 920 "abs_declarator","direct_abs_declarator","parameter_type_list","parameter_list", 921 "parameter_declaration","opt_identifier_list","identifier_list", 922 "struct_or_union","pointer","opt_type_qualifiers","type_qualifier_list", 923 "any_id","identifier_or_ref","enumeration","translation_unit", 924 "external_declaration","declaration","function_definition", 925 "linkage_specification","braces","any_typedef","opt_declarator_list","$$1", 926 "declarator_list","opt_declaration_list","$$2","$$3","$$4","declaration_list", 927 "$$5","illegal-symbol", 928 }; 929 static const char *const grammar_rule[] = { 930 "$accept : program", 931 "program :", 932 "program : translation_unit", 933 "translation_unit : external_declaration", 934 "translation_unit : translation_unit external_declaration", 935 "external_declaration : declaration", 936 "external_declaration : function_definition", 937 "external_declaration : ';'", 938 "external_declaration : linkage_specification", 939 "external_declaration : T_ASM T_ASMARG ';'", 940 "external_declaration : error T_MATCHRBRACE", 941 "external_declaration : error ';'", 942 "braces : T_LBRACE T_MATCHRBRACE", 943 "linkage_specification : T_EXTERN T_STRING_LITERAL braces", 944 "linkage_specification : T_EXTERN T_STRING_LITERAL declaration", 945 "declaration : decl_specifiers ';'", 946 "declaration : decl_specifiers init_declarator_list ';'", 947 "$$1 :", 948 "declaration : any_typedef decl_specifiers $$1 opt_declarator_list ';'", 949 "any_typedef : T_EXTENSION T_TYPEDEF", 950 "any_typedef : T_TYPEDEF", 951 "opt_declarator_list :", 952 "opt_declarator_list : declarator_list", 953 "declarator_list : declarator", 954 "declarator_list : declarator_list ',' declarator", 955 "$$2 :", 956 "$$3 :", 957 "function_definition : decl_specifiers declarator $$2 opt_declaration_list T_LBRACE $$3 T_MATCHRBRACE", 958 "$$4 :", 959 "function_definition : declarator $$4 opt_declaration_list T_LBRACE T_MATCHRBRACE", 960 "opt_declaration_list :", 961 "opt_declaration_list : T_VA_DCL", 962 "opt_declaration_list : declaration_list", 963 "declaration_list : declaration", 964 "declaration_list : declaration_list declaration", 965 "decl_specifiers : decl_specifier", 966 "decl_specifiers : decl_specifiers decl_specifier", 967 "decl_specifier : storage_class", 968 "decl_specifier : type_specifier", 969 "decl_specifier : type_qualifier", 970 "storage_class : T_AUTO", 971 "storage_class : T_EXTERN", 972 "storage_class : T_REGISTER", 973 "storage_class : T_STATIC", 974 "storage_class : T_INLINE", 975 "storage_class : T_EXTENSION", 976 "type_specifier : T_CHAR", 977 "type_specifier : T_DOUBLE", 978 "type_specifier : T_FLOAT", 979 "type_specifier : T_INT", 980 "type_specifier : T_LONG", 981 "type_specifier : T_SHORT", 982 "type_specifier : T_SIGNED", 983 "type_specifier : T_UNSIGNED", 984 "type_specifier : T_VOID", 985 "type_specifier : T_Bool", 986 "type_specifier : T_Complex", 987 "type_specifier : T_Imaginary", 988 "type_specifier : T_TYPEDEF_NAME", 989 "type_specifier : struct_or_union_specifier", 990 "type_specifier : enum_specifier", 991 "type_qualifier : T_TYPE_QUALIFIER", 992 "type_qualifier : T_DEFINE_NAME", 993 "struct_or_union_specifier : struct_or_union any_id braces", 994 "struct_or_union_specifier : struct_or_union braces", 995 "struct_or_union_specifier : struct_or_union any_id", 996 "struct_or_union : T_STRUCT", 997 "struct_or_union : T_UNION", 998 "init_declarator_list : init_declarator", 999 "init_declarator_list : init_declarator_list ',' init_declarator", 1000 "init_declarator : declarator", 1001 "$$5 :", 1002 "init_declarator : declarator '=' $$5 T_INITIALIZER", 1003 "enum_specifier : enumeration any_id braces", 1004 "enum_specifier : enumeration braces", 1005 "enum_specifier : enumeration any_id", 1006 "enumeration : T_ENUM", 1007 "any_id : T_IDENTIFIER", 1008 "any_id : T_TYPEDEF_NAME", 1009 "declarator : pointer direct_declarator", 1010 "declarator : direct_declarator", 1011 "direct_declarator : identifier_or_ref", 1012 "direct_declarator : '(' declarator ')'", 1013 "direct_declarator : direct_declarator T_BRACKETS", 1014 "direct_declarator : direct_declarator '(' parameter_type_list ')'", 1015 "direct_declarator : direct_declarator '(' opt_identifier_list ')'", 1016 "pointer : '*' opt_type_qualifiers", 1017 "pointer : '*' opt_type_qualifiers pointer", 1018 "opt_type_qualifiers :", 1019 "opt_type_qualifiers : type_qualifier_list", 1020 "type_qualifier_list : type_qualifier", 1021 "type_qualifier_list : type_qualifier_list type_qualifier", 1022 "parameter_type_list : parameter_list", 1023 "parameter_type_list : parameter_list ',' T_ELLIPSIS", 1024 "parameter_list : parameter_declaration", 1025 "parameter_list : parameter_list ',' parameter_declaration", 1026 "parameter_declaration : decl_specifiers declarator", 1027 "parameter_declaration : decl_specifiers abs_declarator", 1028 "parameter_declaration : decl_specifiers", 1029 "opt_identifier_list :", 1030 "opt_identifier_list : identifier_list", 1031 "identifier_list : any_id", 1032 "identifier_list : identifier_list ',' any_id", 1033 "identifier_or_ref : any_id", 1034 "identifier_or_ref : '&' any_id", 1035 "abs_declarator : pointer", 1036 "abs_declarator : pointer direct_abs_declarator", 1037 "abs_declarator : direct_abs_declarator", 1038 "direct_abs_declarator : '(' abs_declarator ')'", 1039 "direct_abs_declarator : direct_abs_declarator T_BRACKETS", 1040 "direct_abs_declarator : T_BRACKETS", 1041 "direct_abs_declarator : direct_abs_declarator '(' parameter_type_list ')'", 1042 "direct_abs_declarator : direct_abs_declarator '(' ')'", 1043 "direct_abs_declarator : '(' parameter_type_list ')'", 1044 "direct_abs_declarator : '(' ')'", 1045 1046 }; 1047 #endif 1048 1049 int yydebug; 1050 int yynerrs; 1051 1052 int yyerrflag; 1053 int yychar; 1054 YYSTYPE yyval; 1055 YYSTYPE yylval; 1056 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1057 YYLTYPE yyloc; /* position returned by actions */ 1058 YYLTYPE yylloc; /* position from the lexer */ 1059 #endif 1060 1061 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1062 #ifndef YYLLOC_DEFAULT 1063 #define YYLLOC_DEFAULT(loc, rhs, n) \ 1064 do \ 1065 { \ 1066 if (n == 0) \ 1067 { \ 1068 (loc).first_line = ((rhs)[-1]).last_line; \ 1069 (loc).first_column = ((rhs)[-1]).last_column; \ 1070 (loc).last_line = ((rhs)[-1]).last_line; \ 1071 (loc).last_column = ((rhs)[-1]).last_column; \ 1072 } \ 1073 else \ 1074 { \ 1075 (loc).first_line = ((rhs)[ 0 ]).first_line; \ 1076 (loc).first_column = ((rhs)[ 0 ]).first_column; \ 1077 (loc).last_line = ((rhs)[n-1]).last_line; \ 1078 (loc).last_column = ((rhs)[n-1]).last_column; \ 1079 } \ 1080 } while (0) 1081 #endif /* YYLLOC_DEFAULT */ 1082 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1083 #if YYBTYACC 1084 1085 #ifndef YYLVQUEUEGROWTH 1086 #define YYLVQUEUEGROWTH 32 1087 #endif 1088 #endif /* YYBTYACC */ 1089 1090 /* define the initial stack-sizes */ 1091 #ifdef YYSTACKSIZE 1092 #undef YYMAXDEPTH 1093 #define YYMAXDEPTH YYSTACKSIZE 1094 #else 1095 #ifdef YYMAXDEPTH 1096 #define YYSTACKSIZE YYMAXDEPTH 1097 #else 1098 #define YYSTACKSIZE 10000 1099 #define YYMAXDEPTH 10000 1100 #endif 1101 #endif 1102 1103 #ifndef YYINITSTACKSIZE 1104 #define YYINITSTACKSIZE 200 1105 #endif 1106 1107 typedef struct { 1108 unsigned stacksize; 1109 YYINT *s_base; 1110 YYINT *s_mark; 1111 YYINT *s_last; 1112 YYSTYPE *l_base; 1113 YYSTYPE *l_mark; 1114 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1115 YYLTYPE *p_base; 1116 YYLTYPE *p_mark; 1117 #endif 1118 } YYSTACKDATA; 1119 #if YYBTYACC 1120 1121 struct YYParseState_s 1122 { 1123 struct YYParseState_s *save; /* Previously saved parser state */ 1124 YYSTACKDATA yystack; /* saved parser stack */ 1125 int state; /* saved parser state */ 1126 int errflag; /* saved error recovery status */ 1127 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 1128 YYINT ctry; /* saved index in yyctable[] for this conflict */ 1129 }; 1130 typedef struct YYParseState_s YYParseState; 1131 #endif /* YYBTYACC */ 1132 /* variables for the parser stack */ 1133 static YYSTACKDATA yystack; 1134 #if YYBTYACC 1135 1136 /* Current parser state */ 1137 static YYParseState *yyps = 0; 1138 1139 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 1140 static YYParseState *yypath = 0; 1141 1142 /* Base of the lexical value queue */ 1143 static YYSTYPE *yylvals = 0; 1144 1145 /* Current position at lexical value queue */ 1146 static YYSTYPE *yylvp = 0; 1147 1148 /* End position of lexical value queue */ 1149 static YYSTYPE *yylve = 0; 1150 1151 /* The last allocated position at the lexical value queue */ 1152 static YYSTYPE *yylvlim = 0; 1153 1154 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1155 /* Base of the lexical position queue */ 1156 static YYLTYPE *yylpsns = 0; 1157 1158 /* Current position at lexical position queue */ 1159 static YYLTYPE *yylpp = 0; 1160 1161 /* End position of lexical position queue */ 1162 static YYLTYPE *yylpe = 0; 1163 1164 /* The last allocated position at the lexical position queue */ 1165 static YYLTYPE *yylplim = 0; 1166 #endif 1167 1168 /* Current position at lexical token queue */ 1169 static short *yylexp = 0; 1170 1171 static short *yylexemes = 0; 1172 #endif /* YYBTYACC */ 1173 #line 1014 "grammar.y" 1174 1175 /* lex.yy.c */ 1176 #define BEGIN yy_start = 1 + 2 * 1177 1178 #define CPP1 1 1179 #define INIT1 2 1180 #define INIT2 3 1181 #define CURLY 4 1182 #define LEXYACC 5 1183 #define ASM 6 1184 #define CPP_INLINE 7 1185 1186 extern char *yytext; 1187 extern FILE *yyin, *yyout; 1188 1189 static int curly; /* number of curly brace nesting levels */ 1190 static int ly_count; /* number of occurances of %% */ 1191 static int inc_depth; /* include nesting level */ 1192 static SymbolTable *included_files; /* files already included */ 1193 static int yy_start = 0; /* start state number */ 1194 1195 #define grammar_error(s) yaccError(s) 1196 1197 static void 1198 yaccError (const char *msg) 1199 { 1200 func_params = NULL; 1201 put_error(); /* tell what line we're on, and what file */ 1202 fprintf(stderr, "%s at token '%s'\n", msg, yytext); 1203 } 1204 1205 /* Initialize the table of type qualifier keywords recognized by the lexical 1206 * analyzer. 1207 */ 1208 void 1209 init_parser (void) 1210 { 1211 static const char *keywords[] = { 1212 "const", 1213 "restrict", 1214 "volatile", 1215 "interrupt", 1216 #ifdef vms 1217 "noshare", 1218 "readonly", 1219 #endif 1220 #if defined(MSDOS) || defined(OS2) 1221 "__cdecl", 1222 "__export", 1223 "__far", 1224 "__fastcall", 1225 "__fortran", 1226 "__huge", 1227 "__inline", 1228 "__interrupt", 1229 "__loadds", 1230 "__near", 1231 "__pascal", 1232 "__saveregs", 1233 "__segment", 1234 "__stdcall", 1235 "__syscall", 1236 "_cdecl", 1237 "_cs", 1238 "_ds", 1239 "_es", 1240 "_export", 1241 "_far", 1242 "_fastcall", 1243 "_fortran", 1244 "_huge", 1245 "_interrupt", 1246 "_loadds", 1247 "_near", 1248 "_pascal", 1249 "_saveregs", 1250 "_seg", 1251 "_segment", 1252 "_ss", 1253 "cdecl", 1254 "far", 1255 "huge", 1256 "near", 1257 "pascal", 1258 #ifdef OS2 1259 "__far16", 1260 #endif 1261 #endif 1262 #ifdef __GNUC__ 1263 /* gcc aliases */ 1264 "__builtin_va_arg", 1265 "__builtin_va_list", 1266 "__const", 1267 "__const__", 1268 "__inline", 1269 "__inline__", 1270 "__restrict", 1271 "__restrict__", 1272 "__volatile", 1273 "__volatile__", 1274 #endif 1275 }; 1276 unsigned i; 1277 1278 /* Initialize type qualifier table. */ 1279 type_qualifiers = new_symbol_table(); 1280 for (i = 0; i < sizeof(keywords)/sizeof(keywords[0]); ++i) { 1281 new_symbol(type_qualifiers, keywords[i], NULL, DS_NONE); 1282 } 1283 } 1284 1285 /* Process the C source file. Write function prototypes to the standard 1286 * output. Convert function definitions and write the converted source 1287 * code to a temporary file. 1288 */ 1289 void 1290 process_file (FILE *infile, char *name) 1291 { 1292 char *s; 1293 1294 if (strlen(name) > 2) { 1295 s = name + strlen(name) - 2; 1296 if (*s == '.') { 1297 ++s; 1298 if (*s == 'l' || *s == 'y') 1299 BEGIN LEXYACC; 1300 #if defined(MSDOS) || defined(OS2) 1301 if (*s == 'L' || *s == 'Y') 1302 BEGIN LEXYACC; 1303 #endif 1304 } 1305 } 1306 1307 included_files = new_symbol_table(); 1308 typedef_names = new_symbol_table(); 1309 define_names = new_symbol_table(); 1310 inc_depth = -1; 1311 curly = 0; 1312 ly_count = 0; 1313 func_params = NULL; 1314 yyin = infile; 1315 include_file(strcpy(base_file, name), func_style != FUNC_NONE); 1316 if (file_comments) { 1317 #if OPT_LINTLIBRARY 1318 if (lintLibrary()) { 1319 put_blankline(stdout); 1320 begin_tracking(); 1321 } 1322 #endif 1323 put_string(stdout, "/* "); 1324 put_string(stdout, cur_file_name()); 1325 put_string(stdout, " */\n"); 1326 } 1327 yyparse(); 1328 free_symbol_table(define_names); 1329 free_symbol_table(typedef_names); 1330 free_symbol_table(included_files); 1331 } 1332 1333 #ifdef NO_LEAKS 1334 void 1335 free_parser(void) 1336 { 1337 free_symbol_table (type_qualifiers); 1338 #ifdef FLEX_SCANNER 1339 if (yy_current_buffer != 0) 1340 yy_delete_buffer(yy_current_buffer); 1341 #endif 1342 } 1343 #endif 1344 #line 1345 "grammar.tab.c" 1345 1346 /* For use in generated program */ 1347 #define yydepth (int)(yystack.s_mark - yystack.s_base) 1348 #if YYBTYACC 1349 #define yytrial (yyps->save) 1350 #endif /* YYBTYACC */ 1351 1352 #if YYDEBUG 1353 #include <stdio.h> /* needed for printf */ 1354 #endif 1355 1356 #include <stdlib.h> /* needed for malloc, etc */ 1357 #include <string.h> /* needed for memset */ 1358 1359 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 1360 static int yygrowstack(YYSTACKDATA *data) 1361 { 1362 int i; 1363 unsigned newsize; 1364 YYINT *newss; 1365 YYSTYPE *newvs; 1366 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1367 YYLTYPE *newps; 1368 #endif 1369 1370 if ((newsize = data->stacksize) == 0) 1371 newsize = YYINITSTACKSIZE; 1372 else if (newsize >= YYMAXDEPTH) 1373 return YYENOMEM; 1374 else if ((newsize *= 2) > YYMAXDEPTH) 1375 newsize = YYMAXDEPTH; 1376 1377 i = (int) (data->s_mark - data->s_base); 1378 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 1379 if (newss == 0) 1380 return YYENOMEM; 1381 1382 data->s_base = newss; 1383 data->s_mark = newss + i; 1384 1385 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 1386 if (newvs == 0) 1387 return YYENOMEM; 1388 1389 data->l_base = newvs; 1390 data->l_mark = newvs + i; 1391 1392 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1393 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 1394 if (newps == 0) 1395 return YYENOMEM; 1396 1397 data->p_base = newps; 1398 data->p_mark = newps + i; 1399 #endif 1400 1401 data->stacksize = newsize; 1402 data->s_last = data->s_base + newsize - 1; 1403 1404 #if YYDEBUG 1405 if (yydebug) 1406 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 1407 #endif 1408 return 0; 1409 } 1410 1411 #if YYPURE || defined(YY_NO_LEAKS) 1412 static void yyfreestack(YYSTACKDATA *data) 1413 { 1414 free(data->s_base); 1415 free(data->l_base); 1416 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1417 free(data->p_base); 1418 #endif 1419 memset(data, 0, sizeof(*data)); 1420 } 1421 #else 1422 #define yyfreestack(data) /* nothing */ 1423 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 1424 #if YYBTYACC 1425 1426 static YYParseState * 1427 yyNewState(unsigned size) 1428 { 1429 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 1430 if (p == NULL) return NULL; 1431 1432 p->yystack.stacksize = size; 1433 if (size == 0) 1434 { 1435 p->yystack.s_base = NULL; 1436 p->yystack.l_base = NULL; 1437 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1438 p->yystack.p_base = NULL; 1439 #endif 1440 return p; 1441 } 1442 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 1443 if (p->yystack.s_base == NULL) return NULL; 1444 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 1445 if (p->yystack.l_base == NULL) return NULL; 1446 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 1447 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1448 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 1449 if (p->yystack.p_base == NULL) return NULL; 1450 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 1451 #endif 1452 1453 return p; 1454 } 1455 1456 static void 1457 yyFreeState(YYParseState *p) 1458 { 1459 yyfreestack(&p->yystack); 1460 free(p); 1461 } 1462 #endif /* YYBTYACC */ 1463 1464 #define YYABORT goto yyabort 1465 #define YYREJECT goto yyabort 1466 #define YYACCEPT goto yyaccept 1467 #define YYERROR goto yyerrlab 1468 #if YYBTYACC 1469 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 1470 #define YYVALID_NESTED do { if (yyps->save && \ 1471 yyps->save->save == 0) goto yyvalid; } while(0) 1472 #endif /* YYBTYACC */ 1473 1474 int 1475 YYPARSE_DECL() 1476 { 1477 int yym, yyn, yystate, yyresult; 1478 #if YYBTYACC 1479 int yynewerrflag; 1480 YYParseState *yyerrctx = NULL; 1481 #endif /* YYBTYACC */ 1482 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1483 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 1484 #endif 1485 #if YYDEBUG 1486 const char *yys; 1487 1488 if ((yys = getenv("YYDEBUG")) != 0) 1489 { 1490 yyn = *yys; 1491 if (yyn >= '0' && yyn <= '9') 1492 yydebug = yyn - '0'; 1493 } 1494 if (yydebug) 1495 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 1496 #endif 1497 1498 #if YYBTYACC 1499 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 1500 yyps->save = 0; 1501 #endif /* YYBTYACC */ 1502 yym = 0; 1503 yyn = 0; 1504 yynerrs = 0; 1505 yyerrflag = 0; 1506 yychar = YYEMPTY; 1507 yystate = 0; 1508 1509 #if YYPURE 1510 memset(&yystack, 0, sizeof(yystack)); 1511 #endif 1512 1513 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1514 yystack.s_mark = yystack.s_base; 1515 yystack.l_mark = yystack.l_base; 1516 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1517 yystack.p_mark = yystack.p_base; 1518 #endif 1519 yystate = 0; 1520 *yystack.s_mark = 0; 1521 1522 yyloop: 1523 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 1524 if (yychar < 0) 1525 { 1526 #if YYBTYACC 1527 do { 1528 if (yylvp < yylve) 1529 { 1530 /* we're currently re-reading tokens */ 1531 yylval = *yylvp++; 1532 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1533 yylloc = *yylpp++; 1534 #endif 1535 yychar = *yylexp++; 1536 break; 1537 } 1538 if (yyps->save) 1539 { 1540 /* in trial mode; save scanner results for future parse attempts */ 1541 if (yylvp == yylvlim) 1542 { /* Enlarge lexical value queue */ 1543 size_t p = (size_t) (yylvp - yylvals); 1544 size_t s = (size_t) (yylvlim - yylvals); 1545 1546 s += YYLVQUEUEGROWTH; 1547 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 1548 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 1549 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1550 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 1551 #endif 1552 yylvp = yylve = yylvals + p; 1553 yylvlim = yylvals + s; 1554 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1555 yylpp = yylpe = yylpsns + p; 1556 yylplim = yylpsns + s; 1557 #endif 1558 yylexp = yylexemes + p; 1559 } 1560 *yylexp = (short) YYLEX; 1561 *yylvp++ = yylval; 1562 yylve++; 1563 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1564 *yylpp++ = yylloc; 1565 yylpe++; 1566 #endif 1567 yychar = *yylexp++; 1568 break; 1569 } 1570 /* normal operation, no conflict encountered */ 1571 #endif /* YYBTYACC */ 1572 yychar = YYLEX; 1573 #if YYBTYACC 1574 } while (0); 1575 #endif /* YYBTYACC */ 1576 if (yychar < 0) yychar = YYEOF; 1577 #if YYDEBUG 1578 if (yydebug) 1579 { 1580 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1581 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 1582 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1583 #ifdef YYSTYPE_TOSTRING 1584 #if YYBTYACC 1585 if (!yytrial) 1586 #endif /* YYBTYACC */ 1587 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 1588 #endif 1589 fputc('\n', stderr); 1590 } 1591 #endif 1592 } 1593 #if YYBTYACC 1594 1595 /* Do we have a conflict? */ 1596 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1597 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1598 { 1599 YYINT ctry; 1600 1601 if (yypath) 1602 { 1603 YYParseState *save; 1604 #if YYDEBUG 1605 if (yydebug) 1606 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 1607 YYDEBUGSTR, yydepth, yystate); 1608 #endif 1609 /* Switch to the next conflict context */ 1610 save = yypath; 1611 yypath = save->save; 1612 save->save = NULL; 1613 ctry = save->ctry; 1614 if (save->state != yystate) YYABORT; 1615 yyFreeState(save); 1616 1617 } 1618 else 1619 { 1620 1621 /* Unresolved conflict - start/continue trial parse */ 1622 YYParseState *save; 1623 #if YYDEBUG 1624 if (yydebug) 1625 { 1626 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 1627 if (yyps->save) 1628 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 1629 else 1630 fputs("Starting trial parse.\n", stderr); 1631 } 1632 #endif 1633 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1634 if (save == NULL) goto yyenomem; 1635 save->save = yyps->save; 1636 save->state = yystate; 1637 save->errflag = yyerrflag; 1638 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 1639 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1640 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 1641 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1642 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1643 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 1644 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1645 #endif 1646 ctry = yytable[yyn]; 1647 if (yyctable[ctry] == -1) 1648 { 1649 #if YYDEBUG 1650 if (yydebug && yychar >= YYEOF) 1651 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 1652 #endif 1653 ctry++; 1654 } 1655 save->ctry = ctry; 1656 if (yyps->save == NULL) 1657 { 1658 /* If this is a first conflict in the stack, start saving lexemes */ 1659 if (!yylexemes) 1660 { 1661 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 1662 if (yylexemes == NULL) goto yyenomem; 1663 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 1664 if (yylvals == NULL) goto yyenomem; 1665 yylvlim = yylvals + YYLVQUEUEGROWTH; 1666 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1667 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 1668 if (yylpsns == NULL) goto yyenomem; 1669 yylplim = yylpsns + YYLVQUEUEGROWTH; 1670 #endif 1671 } 1672 if (yylvp == yylve) 1673 { 1674 yylvp = yylve = yylvals; 1675 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1676 yylpp = yylpe = yylpsns; 1677 #endif 1678 yylexp = yylexemes; 1679 if (yychar >= YYEOF) 1680 { 1681 *yylve++ = yylval; 1682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1683 *yylpe++ = yylloc; 1684 #endif 1685 *yylexp = (short) yychar; 1686 yychar = YYEMPTY; 1687 } 1688 } 1689 } 1690 if (yychar >= YYEOF) 1691 { 1692 yylvp--; 1693 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1694 yylpp--; 1695 #endif 1696 yylexp--; 1697 yychar = YYEMPTY; 1698 } 1699 save->lexeme = (int) (yylvp - yylvals); 1700 yyps->save = save; 1701 } 1702 if (yytable[yyn] == ctry) 1703 { 1704 #if YYDEBUG 1705 if (yydebug) 1706 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1707 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 1708 #endif 1709 if (yychar < 0) 1710 { 1711 yylvp++; 1712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1713 yylpp++; 1714 #endif 1715 yylexp++; 1716 } 1717 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 1718 goto yyoverflow; 1719 yystate = yyctable[ctry]; 1720 *++yystack.s_mark = (YYINT) yystate; 1721 *++yystack.l_mark = yylval; 1722 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1723 *++yystack.p_mark = yylloc; 1724 #endif 1725 yychar = YYEMPTY; 1726 if (yyerrflag > 0) --yyerrflag; 1727 goto yyloop; 1728 } 1729 else 1730 { 1731 yyn = yyctable[ctry]; 1732 goto yyreduce; 1733 } 1734 } /* End of code dealing with conflicts */ 1735 #endif /* YYBTYACC */ 1736 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1737 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1738 { 1739 #if YYDEBUG 1740 if (yydebug) 1741 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1742 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 1743 #endif 1744 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1745 yystate = yytable[yyn]; 1746 *++yystack.s_mark = yytable[yyn]; 1747 *++yystack.l_mark = yylval; 1748 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1749 *++yystack.p_mark = yylloc; 1750 #endif 1751 yychar = YYEMPTY; 1752 if (yyerrflag > 0) --yyerrflag; 1753 goto yyloop; 1754 } 1755 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1756 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1757 { 1758 yyn = yytable[yyn]; 1759 goto yyreduce; 1760 } 1761 if (yyerrflag != 0) goto yyinrecovery; 1762 #if YYBTYACC 1763 1764 yynewerrflag = 1; 1765 goto yyerrhandler; 1766 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1767 1768 yyerrlab: 1769 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 1770 * before looking for error recovery */ 1771 yystack.s_mark -= yym; 1772 yystate = *yystack.s_mark; 1773 yystack.l_mark -= yym; 1774 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1775 yystack.p_mark -= yym; 1776 #endif 1777 1778 yynewerrflag = 0; 1779 yyerrhandler: 1780 while (yyps->save) 1781 { 1782 int ctry; 1783 YYParseState *save = yyps->save; 1784 #if YYDEBUG 1785 if (yydebug) 1786 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1787 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1788 (int)(yylvp - yylvals - yyps->save->lexeme)); 1789 #endif 1790 /* Memorize most forward-looking error state in case it's really an error. */ 1791 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1792 { 1793 /* Free old saved error context state */ 1794 if (yyerrctx) yyFreeState(yyerrctx); 1795 /* Create and fill out new saved error context state */ 1796 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1797 if (yyerrctx == NULL) goto yyenomem; 1798 yyerrctx->save = yyps->save; 1799 yyerrctx->state = yystate; 1800 yyerrctx->errflag = yyerrflag; 1801 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1802 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1803 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1804 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1805 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1806 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1807 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1808 #endif 1809 yyerrctx->lexeme = (int) (yylvp - yylvals); 1810 } 1811 yylvp = yylvals + save->lexeme; 1812 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1813 yylpp = yylpsns + save->lexeme; 1814 #endif 1815 yylexp = yylexemes + save->lexeme; 1816 yychar = YYEMPTY; 1817 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1818 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1819 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1820 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1821 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1822 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1823 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1824 #endif 1825 ctry = ++save->ctry; 1826 yystate = save->state; 1827 /* We tried shift, try reduce now */ 1828 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1829 yyps->save = save->save; 1830 save->save = NULL; 1831 yyFreeState(save); 1832 1833 /* Nothing left on the stack -- error */ 1834 if (!yyps->save) 1835 { 1836 #if YYDEBUG 1837 if (yydebug) 1838 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1839 YYPREFIX, yydepth); 1840 #endif 1841 /* Restore state as it was in the most forward-advanced error */ 1842 yylvp = yylvals + yyerrctx->lexeme; 1843 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1844 yylpp = yylpsns + yyerrctx->lexeme; 1845 #endif 1846 yylexp = yylexemes + yyerrctx->lexeme; 1847 yychar = yylexp[-1]; 1848 yylval = yylvp[-1]; 1849 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1850 yylloc = yylpp[-1]; 1851 #endif 1852 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1853 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1854 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1855 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1857 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1858 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1859 #endif 1860 yystate = yyerrctx->state; 1861 yyFreeState(yyerrctx); 1862 yyerrctx = NULL; 1863 } 1864 yynewerrflag = 1; 1865 } 1866 if (yynewerrflag == 0) goto yyinrecovery; 1867 #endif /* YYBTYACC */ 1868 1869 YYERROR_CALL("syntax error"); 1870 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1871 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1872 #endif 1873 1874 #if !YYBTYACC 1875 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1876 yyerrlab: 1877 #endif 1878 ++yynerrs; 1879 1880 yyinrecovery: 1881 if (yyerrflag < 3) 1882 { 1883 yyerrflag = 3; 1884 for (;;) 1885 { 1886 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1887 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1888 { 1889 #if YYDEBUG 1890 if (yydebug) 1891 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1892 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1893 #endif 1894 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1895 yystate = yytable[yyn]; 1896 *++yystack.s_mark = yytable[yyn]; 1897 *++yystack.l_mark = yylval; 1898 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1899 /* lookahead position is error end position */ 1900 yyerror_loc_range[1] = yylloc; 1901 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1902 *++yystack.p_mark = yyloc; 1903 #endif 1904 goto yyloop; 1905 } 1906 else 1907 { 1908 #if YYDEBUG 1909 if (yydebug) 1910 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1911 YYDEBUGSTR, yydepth, *yystack.s_mark); 1912 #endif 1913 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1914 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1915 /* the current TOS position is the error start position */ 1916 yyerror_loc_range[0] = *yystack.p_mark; 1917 #endif 1918 #if defined(YYDESTRUCT_CALL) 1919 #if YYBTYACC 1920 if (!yytrial) 1921 #endif /* YYBTYACC */ 1922 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1923 YYDESTRUCT_CALL("error: discarding state", 1924 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1925 #else 1926 YYDESTRUCT_CALL("error: discarding state", 1927 yystos[*yystack.s_mark], yystack.l_mark); 1928 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1929 #endif /* defined(YYDESTRUCT_CALL) */ 1930 --yystack.s_mark; 1931 --yystack.l_mark; 1932 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1933 --yystack.p_mark; 1934 #endif 1935 } 1936 } 1937 } 1938 else 1939 { 1940 if (yychar == YYEOF) goto yyabort; 1941 #if YYDEBUG 1942 if (yydebug) 1943 { 1944 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1945 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1946 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1947 } 1948 #endif 1949 #if defined(YYDESTRUCT_CALL) 1950 #if YYBTYACC 1951 if (!yytrial) 1952 #endif /* YYBTYACC */ 1953 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1954 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1955 #else 1956 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1957 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1958 #endif /* defined(YYDESTRUCT_CALL) */ 1959 yychar = YYEMPTY; 1960 goto yyloop; 1961 } 1962 1963 yyreduce: 1964 yym = yylen[yyn]; 1965 #if YYDEBUG 1966 if (yydebug) 1967 { 1968 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1969 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1970 #ifdef YYSTYPE_TOSTRING 1971 #if YYBTYACC 1972 if (!yytrial) 1973 #endif /* YYBTYACC */ 1974 if (yym > 0) 1975 { 1976 int i; 1977 fputc('<', stderr); 1978 for (i = yym; i > 0; i--) 1979 { 1980 if (i != yym) fputs(", ", stderr); 1981 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1982 yystack.l_mark[1-i]), stderr); 1983 } 1984 fputc('>', stderr); 1985 } 1986 #endif 1987 fputc('\n', stderr); 1988 } 1989 #endif 1990 if (yym > 0) 1991 yyval = yystack.l_mark[1-yym]; 1992 else 1993 memset(&yyval, 0, sizeof yyval); 1994 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1995 1996 /* Perform position reduction */ 1997 memset(&yyloc, 0, sizeof(yyloc)); 1998 #if YYBTYACC 1999 if (!yytrial) 2000 #endif /* YYBTYACC */ 2001 { 2002 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 2003 /* just in case YYERROR is invoked within the action, save 2004 the start of the rhs as the error start position */ 2005 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 2006 } 2007 #endif 2008 2009 switch (yyn) 2010 { 2011 case 10: 2012 #line 377 "grammar.y" 2013 { 2014 yyerrok; 2015 } 2016 break; 2017 case 11: 2018 #line 381 "grammar.y" 2019 { 2020 yyerrok; 2021 } 2022 break; 2023 case 13: 2024 #line 392 "grammar.y" 2025 { 2026 /* Provide an empty action here so bison will not complain about 2027 * incompatible types in the default action it normally would 2028 * have generated. 2029 */ 2030 } 2031 break; 2032 case 14: 2033 #line 399 "grammar.y" 2034 { 2035 /* empty */ 2036 } 2037 break; 2038 case 15: 2039 #line 406 "grammar.y" 2040 { 2041 #if OPT_LINTLIBRARY 2042 if (types_out && want_typedef()) { 2043 gen_declarations(&yystack.l_mark[-1].decl_spec, (DeclaratorList *)0); 2044 flush_varargs(); 2045 } 2046 #endif 2047 free_decl_spec(&yystack.l_mark[-1].decl_spec); 2048 end_typedef(); 2049 } 2050 break; 2051 case 16: 2052 #line 417 "grammar.y" 2053 { 2054 if (func_params != NULL) { 2055 set_param_types(func_params, &yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list); 2056 } else { 2057 gen_declarations(&yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list); 2058 #if OPT_LINTLIBRARY 2059 flush_varargs(); 2060 #endif 2061 free_decl_list(&yystack.l_mark[-1].decl_list); 2062 } 2063 free_decl_spec(&yystack.l_mark[-2].decl_spec); 2064 end_typedef(); 2065 } 2066 break; 2067 case 17: 2068 #line 431 "grammar.y" 2069 { 2070 cur_decl_spec_flags = yystack.l_mark[0].decl_spec.flags; 2071 free_decl_spec(&yystack.l_mark[0].decl_spec); 2072 } 2073 break; 2074 case 18: 2075 #line 436 "grammar.y" 2076 { 2077 end_typedef(); 2078 } 2079 break; 2080 case 19: 2081 #line 443 "grammar.y" 2082 { 2083 begin_typedef(); 2084 } 2085 break; 2086 case 20: 2087 #line 447 "grammar.y" 2088 { 2089 begin_typedef(); 2090 } 2091 break; 2092 case 23: 2093 #line 459 "grammar.y" 2094 { 2095 int flags = cur_decl_spec_flags; 2096 2097 /* If the typedef is a pointer type, then reset the short type 2098 * flags so it does not get promoted. 2099 */ 2100 if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0) 2101 flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT); 2102 new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags); 2103 free_declarator(yystack.l_mark[0].declarator); 2104 } 2105 break; 2106 case 24: 2107 #line 471 "grammar.y" 2108 { 2109 int flags = cur_decl_spec_flags; 2110 2111 if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0) 2112 flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT); 2113 new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags); 2114 free_declarator(yystack.l_mark[0].declarator); 2115 } 2116 break; 2117 case 25: 2118 #line 483 "grammar.y" 2119 { 2120 check_untagged(&yystack.l_mark[-1].decl_spec); 2121 if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) { 2122 yyerror("syntax error"); 2123 YYERROR; 2124 } 2125 func_params = &(yystack.l_mark[0].declarator->head->params); 2126 func_params->begin_comment = cur_file->begin_comment; 2127 func_params->end_comment = cur_file->end_comment; 2128 } 2129 break; 2130 case 26: 2131 #line 494 "grammar.y" 2132 { 2133 /* If we're converting to K&R and we've got a nominally K&R 2134 * function which has a parameter which is ANSI (i.e., a prototyped 2135 * function pointer), then we must override the deciphered value of 2136 * 'func_def' so that the parameter will be converted. 2137 */ 2138 if (func_style == FUNC_TRADITIONAL 2139 && haveAnsiParam() 2140 && yystack.l_mark[-3].declarator->head->func_def == func_style) { 2141 yystack.l_mark[-3].declarator->head->func_def = FUNC_BOTH; 2142 } 2143 2144 func_params = NULL; 2145 2146 if (cur_file->convert) 2147 gen_func_definition(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator); 2148 gen_prototype(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator); 2149 #if OPT_LINTLIBRARY 2150 flush_varargs(); 2151 #endif 2152 free_decl_spec(&yystack.l_mark[-4].decl_spec); 2153 free_declarator(yystack.l_mark[-3].declarator); 2154 } 2155 break; 2156 case 28: 2157 #line 519 "grammar.y" 2158 { 2159 if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) { 2160 yyerror("syntax error"); 2161 YYERROR; 2162 } 2163 func_params = &(yystack.l_mark[0].declarator->head->params); 2164 func_params->begin_comment = cur_file->begin_comment; 2165 func_params->end_comment = cur_file->end_comment; 2166 } 2167 break; 2168 case 29: 2169 #line 529 "grammar.y" 2170 { 2171 DeclSpec decl_spec; 2172 2173 func_params = NULL; 2174 2175 new_decl_spec(&decl_spec, dft_decl_spec(), yystack.l_mark[-4].declarator->begin, DS_NONE); 2176 if (cur_file->convert) 2177 gen_func_definition(&decl_spec, yystack.l_mark[-4].declarator); 2178 gen_prototype(&decl_spec, yystack.l_mark[-4].declarator); 2179 #if OPT_LINTLIBRARY 2180 flush_varargs(); 2181 #endif 2182 free_decl_spec(&decl_spec); 2183 free_declarator(yystack.l_mark[-4].declarator); 2184 } 2185 break; 2186 case 36: 2187 #line 560 "grammar.y" 2188 { 2189 join_decl_specs(&yyval.decl_spec, &yystack.l_mark[-1].decl_spec, &yystack.l_mark[0].decl_spec); 2190 free(yystack.l_mark[-1].decl_spec.text); 2191 free(yystack.l_mark[0].decl_spec.text); 2192 } 2193 break; 2194 case 40: 2195 #line 575 "grammar.y" 2196 { 2197 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2198 } 2199 break; 2200 case 41: 2201 #line 579 "grammar.y" 2202 { 2203 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_EXTERN); 2204 } 2205 break; 2206 case 42: 2207 #line 583 "grammar.y" 2208 { 2209 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2210 } 2211 break; 2212 case 43: 2213 #line 587 "grammar.y" 2214 { 2215 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_STATIC); 2216 } 2217 break; 2218 case 44: 2219 #line 591 "grammar.y" 2220 { 2221 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_INLINE); 2222 } 2223 break; 2224 case 45: 2225 #line 595 "grammar.y" 2226 { 2227 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_JUNK); 2228 } 2229 break; 2230 case 46: 2231 #line 602 "grammar.y" 2232 { 2233 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR); 2234 } 2235 break; 2236 case 47: 2237 #line 606 "grammar.y" 2238 { 2239 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2240 } 2241 break; 2242 case 48: 2243 #line 610 "grammar.y" 2244 { 2245 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_FLOAT); 2246 } 2247 break; 2248 case 49: 2249 #line 614 "grammar.y" 2250 { 2251 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2252 } 2253 break; 2254 case 50: 2255 #line 618 "grammar.y" 2256 { 2257 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2258 } 2259 break; 2260 case 51: 2261 #line 622 "grammar.y" 2262 { 2263 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_SHORT); 2264 } 2265 break; 2266 case 52: 2267 #line 626 "grammar.y" 2268 { 2269 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2270 } 2271 break; 2272 case 53: 2273 #line 630 "grammar.y" 2274 { 2275 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2276 } 2277 break; 2278 case 54: 2279 #line 634 "grammar.y" 2280 { 2281 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2282 } 2283 break; 2284 case 55: 2285 #line 638 "grammar.y" 2286 { 2287 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR); 2288 } 2289 break; 2290 case 56: 2291 #line 642 "grammar.y" 2292 { 2293 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2294 } 2295 break; 2296 case 57: 2297 #line 646 "grammar.y" 2298 { 2299 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2300 } 2301 break; 2302 case 58: 2303 #line 650 "grammar.y" 2304 { 2305 Symbol *s; 2306 s = find_symbol(typedef_names, yystack.l_mark[0].text.text); 2307 if (s != NULL) 2308 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags); 2309 } 2310 break; 2311 case 61: 2312 #line 662 "grammar.y" 2313 { 2314 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE); 2315 } 2316 break; 2317 case 62: 2318 #line 666 "grammar.y" 2319 { 2320 /* This rule allows the <pointer> nonterminal to scan #define 2321 * names as if they were type modifiers. 2322 */ 2323 Symbol *s; 2324 s = find_symbol(define_names, yystack.l_mark[0].text.text); 2325 if (s != NULL) 2326 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags); 2327 } 2328 break; 2329 case 63: 2330 #line 679 "grammar.y" 2331 { 2332 char *s; 2333 if ((s = implied_typedef()) == 0) 2334 (void)sprintf(s = buf, "%s %s", yystack.l_mark[-2].text.text, yystack.l_mark[-1].text.text); 2335 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE); 2336 } 2337 break; 2338 case 64: 2339 #line 686 "grammar.y" 2340 { 2341 char *s; 2342 if ((s = implied_typedef()) == 0) 2343 (void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text); 2344 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE); 2345 } 2346 break; 2347 case 65: 2348 #line 693 "grammar.y" 2349 { 2350 (void)sprintf(buf, "%s %s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text); 2351 new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE); 2352 } 2353 break; 2354 case 66: 2355 #line 701 "grammar.y" 2356 { 2357 imply_typedef(yyval.text.text); 2358 } 2359 break; 2360 case 67: 2361 #line 705 "grammar.y" 2362 { 2363 imply_typedef(yyval.text.text); 2364 } 2365 break; 2366 case 68: 2367 #line 712 "grammar.y" 2368 { 2369 new_decl_list(&yyval.decl_list, yystack.l_mark[0].declarator); 2370 } 2371 break; 2372 case 69: 2373 #line 716 "grammar.y" 2374 { 2375 add_decl_list(&yyval.decl_list, &yystack.l_mark[-2].decl_list, yystack.l_mark[0].declarator); 2376 } 2377 break; 2378 case 70: 2379 #line 723 "grammar.y" 2380 { 2381 if (yystack.l_mark[0].declarator->func_def != FUNC_NONE && func_params == NULL && 2382 func_style == FUNC_TRADITIONAL && cur_file->convert) { 2383 gen_func_declarator(yystack.l_mark[0].declarator); 2384 fputs(cur_text(), cur_file->tmp_file); 2385 } 2386 cur_declarator = yyval.declarator; 2387 } 2388 break; 2389 case 71: 2390 #line 732 "grammar.y" 2391 { 2392 if (yystack.l_mark[-1].declarator->func_def != FUNC_NONE && func_params == NULL && 2393 func_style == FUNC_TRADITIONAL && cur_file->convert) { 2394 gen_func_declarator(yystack.l_mark[-1].declarator); 2395 fputs(" =", cur_file->tmp_file); 2396 } 2397 } 2398 break; 2399 case 73: 2400 #line 744 "grammar.y" 2401 { 2402 char *s; 2403 if ((s = implied_typedef()) == 0) 2404 (void)sprintf(s = buf, "enum %s", yystack.l_mark[-1].text.text); 2405 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE); 2406 } 2407 break; 2408 case 74: 2409 #line 751 "grammar.y" 2410 { 2411 char *s; 2412 if ((s = implied_typedef()) == 0) 2413 (void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text); 2414 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE); 2415 } 2416 break; 2417 case 75: 2418 #line 758 "grammar.y" 2419 { 2420 (void)sprintf(buf, "enum %s", yystack.l_mark[0].text.text); 2421 new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE); 2422 } 2423 break; 2424 case 76: 2425 #line 766 "grammar.y" 2426 { 2427 imply_typedef("enum"); 2428 yyval.text = yystack.l_mark[0].text; 2429 } 2430 break; 2431 case 79: 2432 #line 779 "grammar.y" 2433 { 2434 yyval.declarator = yystack.l_mark[0].declarator; 2435 (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text); 2436 free(yyval.declarator->text); 2437 yyval.declarator->text = xstrdup(buf); 2438 yyval.declarator->begin = yystack.l_mark[-1].text.begin; 2439 yyval.declarator->pointer = TRUE; 2440 } 2441 break; 2442 case 81: 2443 #line 792 "grammar.y" 2444 { 2445 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin); 2446 } 2447 break; 2448 case 82: 2449 #line 796 "grammar.y" 2450 { 2451 yyval.declarator = yystack.l_mark[-1].declarator; 2452 (void)sprintf(buf, "(%s)", yyval.declarator->text); 2453 free(yyval.declarator->text); 2454 yyval.declarator->text = xstrdup(buf); 2455 yyval.declarator->begin = yystack.l_mark[-2].text.begin; 2456 } 2457 break; 2458 case 83: 2459 #line 804 "grammar.y" 2460 { 2461 yyval.declarator = yystack.l_mark[-1].declarator; 2462 (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text); 2463 free(yyval.declarator->text); 2464 yyval.declarator->text = xstrdup(buf); 2465 } 2466 break; 2467 case 84: 2468 #line 811 "grammar.y" 2469 { 2470 yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin); 2471 yyval.declarator->params = yystack.l_mark[-1].param_list; 2472 yyval.declarator->func_stack = yystack.l_mark[-3].declarator; 2473 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head; 2474 yyval.declarator->func_def = FUNC_ANSI; 2475 } 2476 break; 2477 case 85: 2478 #line 819 "grammar.y" 2479 { 2480 yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin); 2481 yyval.declarator->params = yystack.l_mark[-1].param_list; 2482 yyval.declarator->func_stack = yystack.l_mark[-3].declarator; 2483 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head; 2484 yyval.declarator->func_def = FUNC_TRADITIONAL; 2485 } 2486 break; 2487 case 86: 2488 #line 830 "grammar.y" 2489 { 2490 (void)sprintf(yyval.text.text, "*%s", yystack.l_mark[0].text.text); 2491 yyval.text.begin = yystack.l_mark[-1].text.begin; 2492 } 2493 break; 2494 case 87: 2495 #line 835 "grammar.y" 2496 { 2497 (void)sprintf(yyval.text.text, "*%s%s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text); 2498 yyval.text.begin = yystack.l_mark[-2].text.begin; 2499 } 2500 break; 2501 case 88: 2502 #line 843 "grammar.y" 2503 { 2504 strcpy(yyval.text.text, ""); 2505 yyval.text.begin = 0L; 2506 } 2507 break; 2508 case 90: 2509 #line 852 "grammar.y" 2510 { 2511 (void)sprintf(yyval.text.text, "%s ", yystack.l_mark[0].decl_spec.text); 2512 yyval.text.begin = yystack.l_mark[0].decl_spec.begin; 2513 free(yystack.l_mark[0].decl_spec.text); 2514 } 2515 break; 2516 case 91: 2517 #line 858 "grammar.y" 2518 { 2519 (void)sprintf(yyval.text.text, "%s%s ", yystack.l_mark[-1].text.text, yystack.l_mark[0].decl_spec.text); 2520 yyval.text.begin = yystack.l_mark[-1].text.begin; 2521 free(yystack.l_mark[0].decl_spec.text); 2522 } 2523 break; 2524 case 93: 2525 #line 868 "grammar.y" 2526 { 2527 add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, "..."); 2528 } 2529 break; 2530 case 94: 2531 #line 875 "grammar.y" 2532 { 2533 new_param_list(&yyval.param_list, yystack.l_mark[0].parameter); 2534 } 2535 break; 2536 case 95: 2537 #line 879 "grammar.y" 2538 { 2539 add_param_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].parameter); 2540 } 2541 break; 2542 case 96: 2543 #line 886 "grammar.y" 2544 { 2545 check_untagged(&yystack.l_mark[-1].decl_spec); 2546 yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator); 2547 } 2548 break; 2549 case 97: 2550 #line 891 "grammar.y" 2551 { 2552 check_untagged(&yystack.l_mark[-1].decl_spec); 2553 yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator); 2554 } 2555 break; 2556 case 98: 2557 #line 896 "grammar.y" 2558 { 2559 check_untagged(&yystack.l_mark[0].decl_spec); 2560 yyval.parameter = new_parameter(&yystack.l_mark[0].decl_spec, (Declarator *)0); 2561 } 2562 break; 2563 case 99: 2564 #line 904 "grammar.y" 2565 { 2566 new_ident_list(&yyval.param_list); 2567 } 2568 break; 2569 case 101: 2570 #line 912 "grammar.y" 2571 { 2572 new_ident_list(&yyval.param_list); 2573 add_ident_list(&yyval.param_list, &yyval.param_list, yystack.l_mark[0].text.text); 2574 } 2575 break; 2576 case 102: 2577 #line 917 "grammar.y" 2578 { 2579 add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].text.text); 2580 } 2581 break; 2582 case 103: 2583 #line 924 "grammar.y" 2584 { 2585 yyval.text = yystack.l_mark[0].text; 2586 } 2587 break; 2588 case 104: 2589 #line 928 "grammar.y" 2590 { 2591 #if OPT_LINTLIBRARY 2592 if (lintLibrary()) { /* Lint doesn't grok C++ ref variables */ 2593 yyval.text = yystack.l_mark[0].text; 2594 } else 2595 #endif 2596 (void)sprintf(yyval.text.text, "&%s", yystack.l_mark[0].text.text); 2597 yyval.text.begin = yystack.l_mark[-1].text.begin; 2598 } 2599 break; 2600 case 105: 2601 #line 941 "grammar.y" 2602 { 2603 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin); 2604 } 2605 break; 2606 case 106: 2607 #line 945 "grammar.y" 2608 { 2609 yyval.declarator = yystack.l_mark[0].declarator; 2610 (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text); 2611 free(yyval.declarator->text); 2612 yyval.declarator->text = xstrdup(buf); 2613 yyval.declarator->begin = yystack.l_mark[-1].text.begin; 2614 } 2615 break; 2616 case 108: 2617 #line 957 "grammar.y" 2618 { 2619 yyval.declarator = yystack.l_mark[-1].declarator; 2620 (void)sprintf(buf, "(%s)", yyval.declarator->text); 2621 free(yyval.declarator->text); 2622 yyval.declarator->text = xstrdup(buf); 2623 yyval.declarator->begin = yystack.l_mark[-2].text.begin; 2624 } 2625 break; 2626 case 109: 2627 #line 965 "grammar.y" 2628 { 2629 yyval.declarator = yystack.l_mark[-1].declarator; 2630 (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text); 2631 free(yyval.declarator->text); 2632 yyval.declarator->text = xstrdup(buf); 2633 } 2634 break; 2635 case 110: 2636 #line 972 "grammar.y" 2637 { 2638 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin); 2639 } 2640 break; 2641 case 111: 2642 #line 976 "grammar.y" 2643 { 2644 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-3].declarator->begin); 2645 yyval.declarator->params = yystack.l_mark[-1].param_list; 2646 yyval.declarator->func_stack = yystack.l_mark[-3].declarator; 2647 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head; 2648 yyval.declarator->func_def = FUNC_ANSI; 2649 } 2650 break; 2651 case 112: 2652 #line 984 "grammar.y" 2653 { 2654 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].declarator->begin); 2655 yyval.declarator->func_stack = yystack.l_mark[-2].declarator; 2656 yyval.declarator->head = (yystack.l_mark[-2].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-2].declarator->head; 2657 yyval.declarator->func_def = FUNC_ANSI; 2658 } 2659 break; 2660 case 113: 2661 #line 991 "grammar.y" 2662 { 2663 Declarator *d; 2664 2665 d = new_declarator("", "", yystack.l_mark[-2].text.begin); 2666 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].text.begin); 2667 yyval.declarator->params = yystack.l_mark[-1].param_list; 2668 yyval.declarator->func_stack = d; 2669 yyval.declarator->head = yyval.declarator; 2670 yyval.declarator->func_def = FUNC_ANSI; 2671 } 2672 break; 2673 case 114: 2674 #line 1002 "grammar.y" 2675 { 2676 Declarator *d; 2677 2678 d = new_declarator("", "", yystack.l_mark[-1].text.begin); 2679 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-1].text.begin); 2680 yyval.declarator->func_stack = d; 2681 yyval.declarator->head = yyval.declarator; 2682 yyval.declarator->func_def = FUNC_ANSI; 2683 } 2684 break; 2685 #line 2686 "grammar.tab.c" 2686 default: 2687 break; 2688 } 2689 yystack.s_mark -= yym; 2690 yystate = *yystack.s_mark; 2691 yystack.l_mark -= yym; 2692 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2693 yystack.p_mark -= yym; 2694 #endif 2695 yym = yylhs[yyn]; 2696 if (yystate == 0 && yym == 0) 2697 { 2698 #if YYDEBUG 2699 if (yydebug) 2700 { 2701 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2702 #ifdef YYSTYPE_TOSTRING 2703 #if YYBTYACC 2704 if (!yytrial) 2705 #endif /* YYBTYACC */ 2706 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 2707 #endif 2708 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 2709 } 2710 #endif 2711 yystate = YYFINAL; 2712 *++yystack.s_mark = YYFINAL; 2713 *++yystack.l_mark = yyval; 2714 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2715 *++yystack.p_mark = yyloc; 2716 #endif 2717 if (yychar < 0) 2718 { 2719 #if YYBTYACC 2720 do { 2721 if (yylvp < yylve) 2722 { 2723 /* we're currently re-reading tokens */ 2724 yylval = *yylvp++; 2725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2726 yylloc = *yylpp++; 2727 #endif 2728 yychar = *yylexp++; 2729 break; 2730 } 2731 if (yyps->save) 2732 { 2733 /* in trial mode; save scanner results for future parse attempts */ 2734 if (yylvp == yylvlim) 2735 { /* Enlarge lexical value queue */ 2736 size_t p = (size_t) (yylvp - yylvals); 2737 size_t s = (size_t) (yylvlim - yylvals); 2738 2739 s += YYLVQUEUEGROWTH; 2740 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 2741 goto yyenomem; 2742 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 2743 goto yyenomem; 2744 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2745 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 2746 goto yyenomem; 2747 #endif 2748 yylvp = yylve = yylvals + p; 2749 yylvlim = yylvals + s; 2750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2751 yylpp = yylpe = yylpsns + p; 2752 yylplim = yylpsns + s; 2753 #endif 2754 yylexp = yylexemes + p; 2755 } 2756 *yylexp = (short) YYLEX; 2757 *yylvp++ = yylval; 2758 yylve++; 2759 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2760 *yylpp++ = yylloc; 2761 yylpe++; 2762 #endif 2763 yychar = *yylexp++; 2764 break; 2765 } 2766 /* normal operation, no conflict encountered */ 2767 #endif /* YYBTYACC */ 2768 yychar = YYLEX; 2769 #if YYBTYACC 2770 } while (0); 2771 #endif /* YYBTYACC */ 2772 if (yychar < 0) yychar = YYEOF; 2773 #if YYDEBUG 2774 if (yydebug) 2775 { 2776 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 2777 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 2778 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 2779 } 2780 #endif 2781 } 2782 if (yychar == YYEOF) goto yyaccept; 2783 goto yyloop; 2784 } 2785 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 2786 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 2787 yystate = yytable[yyn]; 2788 else 2789 yystate = yydgoto[yym]; 2790 #if YYDEBUG 2791 if (yydebug) 2792 { 2793 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2794 #ifdef YYSTYPE_TOSTRING 2795 #if YYBTYACC 2796 if (!yytrial) 2797 #endif /* YYBTYACC */ 2798 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 2799 #endif 2800 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 2801 } 2802 #endif 2803 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 2804 *++yystack.s_mark = (YYINT) yystate; 2805 *++yystack.l_mark = yyval; 2806 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2807 *++yystack.p_mark = yyloc; 2808 #endif 2809 goto yyloop; 2810 #if YYBTYACC 2811 2812 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 2813 yyvalid: 2814 if (yypath) YYABORT; 2815 while (yyps->save) 2816 { 2817 YYParseState *save = yyps->save; 2818 yyps->save = save->save; 2819 save->save = yypath; 2820 yypath = save; 2821 } 2822 #if YYDEBUG 2823 if (yydebug) 2824 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 2825 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 2826 #endif 2827 if (yyerrctx) 2828 { 2829 yyFreeState(yyerrctx); 2830 yyerrctx = NULL; 2831 } 2832 yylvp = yylvals + yypath->lexeme; 2833 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2834 yylpp = yylpsns + yypath->lexeme; 2835 #endif 2836 yylexp = yylexemes + yypath->lexeme; 2837 yychar = YYEMPTY; 2838 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 2839 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2840 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 2841 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2842 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2843 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 2844 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2845 #endif 2846 yystate = yypath->state; 2847 goto yyloop; 2848 #endif /* YYBTYACC */ 2849 2850 yyoverflow: 2851 YYERROR_CALL("yacc stack overflow"); 2852 #if YYBTYACC 2853 goto yyabort_nomem; 2854 yyenomem: 2855 YYERROR_CALL("memory exhausted"); 2856 yyabort_nomem: 2857 #endif /* YYBTYACC */ 2858 yyresult = 2; 2859 goto yyreturn; 2860 2861 yyabort: 2862 yyresult = 1; 2863 goto yyreturn; 2864 2865 yyaccept: 2866 #if YYBTYACC 2867 if (yyps->save) goto yyvalid; 2868 #endif /* YYBTYACC */ 2869 yyresult = 0; 2870 2871 yyreturn: 2872 #if defined(YYDESTRUCT_CALL) 2873 if (yychar != YYEOF && yychar != YYEMPTY) 2874 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2875 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 2876 #else 2877 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 2878 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2879 2880 { 2881 YYSTYPE *pv; 2882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2883 YYLTYPE *pp; 2884 2885 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 2886 YYDESTRUCT_CALL("cleanup: discarding state", 2887 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 2888 #else 2889 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 2890 YYDESTRUCT_CALL("cleanup: discarding state", 2891 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 2892 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2893 } 2894 #endif /* defined(YYDESTRUCT_CALL) */ 2895 2896 #if YYBTYACC 2897 if (yyerrctx) 2898 { 2899 yyFreeState(yyerrctx); 2900 yyerrctx = NULL; 2901 } 2902 while (yyps) 2903 { 2904 YYParseState *save = yyps; 2905 yyps = save->save; 2906 save->save = NULL; 2907 yyFreeState(save); 2908 } 2909 while (yypath) 2910 { 2911 YYParseState *save = yypath; 2912 yypath = save->save; 2913 save->save = NULL; 2914 yyFreeState(save); 2915 } 2916 #endif /* YYBTYACC */ 2917 yyfreestack(&yystack); 2918 return (yyresult); 2919 } 2920