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 1 18 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug") 19 20 #ifndef yyparse 21 #define yyparse destroy1_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex destroy1_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror destroy1_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar destroy1_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval destroy1_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval destroy1_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug destroy1_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs destroy1_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag destroy1_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs destroy1_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen destroy1_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred destroy1_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos destroy1_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto destroy1_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex destroy1_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex destroy1_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex destroy1_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable destroy1_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck destroy1_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname destroy1_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule destroy1_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex destroy1_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable destroy1_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "destroy1_" 117 118 #define YYPURE 0 119 120 #line 4 "btyacc_destroy1.y" 121 #include <stdlib.h> 122 123 typedef enum {cGLOBAL, cLOCAL} class; 124 typedef enum {tREAL, tINTEGER} type; 125 typedef char * name; 126 127 struct symbol { class c; type t; name id; }; 128 typedef struct symbol symbol; 129 130 struct namelist { symbol *s; struct namelist *next; }; 131 typedef struct namelist namelist; 132 133 struct parser_param { 134 int *rtrn; 135 symbol ss; 136 }; 137 138 extern symbol *mksymbol(type t, class c, name id); 139 140 #ifdef YYBISON 141 #define YYLEX_DECL() yylex(void) 142 #define YYERROR_DECL() yyerror(const char *s) 143 #endif 144 #ifdef YYSTYPE 145 #undef YYSTYPE_IS_DECLARED 146 #define YYSTYPE_IS_DECLARED 1 147 #endif 148 #ifndef YYSTYPE_IS_DECLARED 149 #define YYSTYPE_IS_DECLARED 1 150 #line 50 "btyacc_destroy1.y" 151 typedef union 152 { 153 class cval; 154 type tval; 155 namelist * nlist; 156 name id; 157 } YYSTYPE; 158 #endif /* !YYSTYPE_IS_DECLARED */ 159 #line 160 "btyacc_destroy1.tab.c" 160 161 /* compatibility with bison */ 162 #ifdef YYPARSE_PARAM 163 /* compatibility with FreeBSD */ 164 # ifdef YYPARSE_PARAM_TYPE 165 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 166 # else 167 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 168 # endif 169 #else 170 # define YYPARSE_DECL() yyparse(struct parser_param *param, int flag) 171 #endif 172 173 /* Parameters sent to lex. */ 174 #ifdef YYLEX_PARAM 175 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 176 # define YYLEX yylex(YYLEX_PARAM) 177 #else 178 # define YYLEX_DECL() yylex(void) 179 # define YYLEX yylex() 180 #endif 181 182 /* Parameters sent to yyerror. */ 183 #ifndef YYERROR_DECL 184 #define YYERROR_DECL() yyerror(struct parser_param *param, int flag, const char *s) 185 #endif 186 #ifndef YYERROR_CALL 187 #define YYERROR_CALL(msg) yyerror(param, flag, msg) 188 #endif 189 190 #ifndef YYDESTRUCT_DECL 191 #define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param, int flag) 192 #endif 193 #ifndef YYDESTRUCT_CALL 194 #define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param, flag) 195 #endif 196 197 extern int YYPARSE_DECL(); 198 199 #define GLOBAL 257 200 #define LOCAL 258 201 #define REAL 259 202 #define INTEGER 260 203 #define NAME 261 204 #define YYERRCODE 256 205 typedef short YYINT; 206 static const YYINT destroy1_lhs[] = { -1, 207 0, 0, 2, 2, 3, 3, 4, 4, 1, 208 }; 209 static const YYINT destroy1_len[] = { 2, 210 8, 5, 1, 1, 1, 1, 2, 1, 6, 211 }; 212 static const YYINT destroy1_defred[] = { 0, 213 3, 4, 5, 6, 0, 0, 0, 0, 8, 0, 214 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 215 0, 0, 0, 0, 9, 1, 216 }; 217 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 218 static const YYINT destroy1_stos[] = { 0, 219 257, 258, 259, 260, 263, 265, 266, 266, 261, 264, 220 267, 267, 40, 261, 40, 40, 265, 258, 265, 41, 221 44, 44, 266, 266, 41, 41, 222 }; 223 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 224 static const YYINT destroy1_dgoto[] = { 5, 225 10, 6, 7, 11, 226 }; 227 static const YYINT destroy1_sindex[] = { -254, 228 0, 0, 0, 0, 0, -251, -248, -248, 0, -26, 229 -40, -39, -246, 0, -243, -246, -25, -24, -23, 0, 230 -251, -251, -22, -19, 0, 0, 231 }; 232 static const YYINT destroy1_rindex[] = { 0, 233 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 235 0, 0, 0, 0, 0, 0, 236 }; 237 #if YYBTYACC 238 static const YYINT destroy1_cindex[] = { 0, 239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241 0, 0, 0, 0, 0, 0, 242 }; 243 #endif 244 static const YYINT destroy1_gindex[] = { 0, 245 0, -6, -4, 15, 246 }; 247 #define YYTABLESIZE 222 248 static const YYINT destroy1_table[] = { 15, 249 16, 8, 1, 2, 3, 4, 17, 3, 4, 19, 250 1, 2, 9, 13, 18, 20, 23, 24, 25, 21, 251 22, 26, 12, 0, 0, 0, 0, 0, 0, 0, 252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 261 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 262 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 270 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271 14, 14, 272 }; 273 static const YYINT destroy1_check[] = { 40, 274 40, 6, 257, 258, 259, 260, 13, 259, 260, 16, 275 257, 258, 261, 40, 258, 41, 21, 22, 41, 44, 276 44, 41, 8, -1, -1, -1, -1, -1, -1, -1, 277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 296 261, 261, 297 }; 298 #if YYBTYACC 299 static const YYINT destroy1_ctable[] = { -1, 300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 312 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 314 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 315 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 322 -1, 323 }; 324 #endif 325 #define YYFINAL 5 326 #ifndef YYDEBUG 327 #define YYDEBUG 0 328 #endif 329 #define YYMAXTOKEN 261 330 #define YYUNDFTOKEN 268 331 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 332 #if YYDEBUG 333 static const char *const destroy1_name[] = { 334 335 "$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, 336 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, 337 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, 338 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, 339 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, 340 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, 341 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","GLOBAL","LOCAL", 342 "REAL","INTEGER","NAME","$accept","declaration","locnamelist","class","type", 343 "namelist","illegal-symbol", 344 }; 345 static const char *const destroy1_rule[] = { 346 "$accept : declaration", 347 "declaration : class type namelist '(' class ',' type ')'", 348 "declaration : type locnamelist '(' class ')'", 349 "class : GLOBAL", 350 "class : LOCAL", 351 "type : REAL", 352 "type : INTEGER", 353 "namelist : namelist NAME", 354 "namelist : NAME", 355 "locnamelist : namelist '(' LOCAL ',' type ')'", 356 357 }; 358 #endif 359 360 int yydebug; 361 int yynerrs; 362 363 int yyerrflag; 364 int yychar; 365 YYSTYPE yyval; 366 YYSTYPE yylval; 367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 368 YYLTYPE yyloc; /* position returned by actions */ 369 YYLTYPE yylloc; /* position from the lexer */ 370 #endif 371 372 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 373 #ifndef YYLLOC_DEFAULT 374 #define YYLLOC_DEFAULT(loc, rhs, n) \ 375 do \ 376 { \ 377 if (n == 0) \ 378 { \ 379 (loc).first_line = ((rhs)[-1]).last_line; \ 380 (loc).first_column = ((rhs)[-1]).last_column; \ 381 (loc).last_line = ((rhs)[-1]).last_line; \ 382 (loc).last_column = ((rhs)[-1]).last_column; \ 383 } \ 384 else \ 385 { \ 386 (loc).first_line = ((rhs)[ 0 ]).first_line; \ 387 (loc).first_column = ((rhs)[ 0 ]).first_column; \ 388 (loc).last_line = ((rhs)[n-1]).last_line; \ 389 (loc).last_column = ((rhs)[n-1]).last_column; \ 390 } \ 391 } while (0) 392 #endif /* YYLLOC_DEFAULT */ 393 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 394 #if YYBTYACC 395 396 #ifndef YYLVQUEUEGROWTH 397 #define YYLVQUEUEGROWTH 32 398 #endif 399 #endif /* YYBTYACC */ 400 401 /* define the initial stack-sizes */ 402 #ifdef YYSTACKSIZE 403 #undef YYMAXDEPTH 404 #define YYMAXDEPTH YYSTACKSIZE 405 #else 406 #ifdef YYMAXDEPTH 407 #define YYSTACKSIZE YYMAXDEPTH 408 #else 409 #define YYSTACKSIZE 10000 410 #define YYMAXDEPTH 10000 411 #endif 412 #endif 413 414 #ifndef YYINITSTACKSIZE 415 #define YYINITSTACKSIZE 200 416 #endif 417 418 typedef struct { 419 unsigned stacksize; 420 YYINT *s_base; 421 YYINT *s_mark; 422 YYINT *s_last; 423 YYSTYPE *l_base; 424 YYSTYPE *l_mark; 425 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 426 YYLTYPE *p_base; 427 YYLTYPE *p_mark; 428 #endif 429 } YYSTACKDATA; 430 #if YYBTYACC 431 432 struct YYParseState_s 433 { 434 struct YYParseState_s *save; /* Previously saved parser state */ 435 YYSTACKDATA yystack; /* saved parser stack */ 436 int state; /* saved parser state */ 437 int errflag; /* saved error recovery status */ 438 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 439 YYINT ctry; /* saved index in yyctable[] for this conflict */ 440 }; 441 typedef struct YYParseState_s YYParseState; 442 #endif /* YYBTYACC */ 443 /* variables for the parser stack */ 444 static YYSTACKDATA yystack; 445 #if YYBTYACC 446 447 /* Current parser state */ 448 static YYParseState *yyps = 0; 449 450 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 451 static YYParseState *yypath = 0; 452 453 /* Base of the lexical value queue */ 454 static YYSTYPE *yylvals = 0; 455 456 /* Current position at lexical value queue */ 457 static YYSTYPE *yylvp = 0; 458 459 /* End position of lexical value queue */ 460 static YYSTYPE *yylve = 0; 461 462 /* The last allocated position at the lexical value queue */ 463 static YYSTYPE *yylvlim = 0; 464 465 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 466 /* Base of the lexical position queue */ 467 static YYLTYPE *yylpsns = 0; 468 469 /* Current position at lexical position queue */ 470 static YYLTYPE *yylpp = 0; 471 472 /* End position of lexical position queue */ 473 static YYLTYPE *yylpe = 0; 474 475 /* The last allocated position at the lexical position queue */ 476 static YYLTYPE *yylplim = 0; 477 #endif 478 479 /* Current position at lexical token queue */ 480 static YYINT *yylexp = 0; 481 482 static YYINT *yylexemes = 0; 483 #endif /* YYBTYACC */ 484 #line 89 "btyacc_destroy1.y" 485 486 extern int YYLEX_DECL(); 487 extern void YYERROR_DECL(); 488 #line 489 "btyacc_destroy1.tab.c" 489 490 /* Release memory associated with symbol. */ 491 #if ! defined YYDESTRUCT_IS_DECLARED 492 static void 493 YYDESTRUCT_DECL() 494 { 495 switch (psymb) 496 { 497 case 263: 498 #line 41 "btyacc_destroy1.y" 499 { 500 namelist *p = (*val).nlist; 501 while (p != NULL) 502 { namelist *pp = p; 503 p = p->next; 504 free(pp->s); free(pp); 505 } 506 } 507 break; 508 #line 509 "btyacc_destroy1.tab.c" 509 } 510 } 511 #define YYDESTRUCT_IS_DECLARED 1 512 #endif 513 514 /* For use in generated program */ 515 #define yydepth (int)(yystack.s_mark - yystack.s_base) 516 #if YYBTYACC 517 #define yytrial (yyps->save) 518 #endif /* YYBTYACC */ 519 520 #if YYDEBUG 521 #include <stdio.h> /* needed for printf */ 522 #endif 523 524 #include <stdlib.h> /* needed for malloc, etc */ 525 #include <string.h> /* needed for memset */ 526 527 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 528 static int yygrowstack(YYSTACKDATA *data) 529 { 530 int i; 531 unsigned newsize; 532 YYINT *newss; 533 YYSTYPE *newvs; 534 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 535 YYLTYPE *newps; 536 #endif 537 538 if ((newsize = data->stacksize) == 0) 539 newsize = YYINITSTACKSIZE; 540 else if (newsize >= YYMAXDEPTH) 541 return YYENOMEM; 542 else if ((newsize *= 2) > YYMAXDEPTH) 543 newsize = YYMAXDEPTH; 544 545 i = (int) (data->s_mark - data->s_base); 546 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 547 if (newss == 0) 548 return YYENOMEM; 549 550 data->s_base = newss; 551 data->s_mark = newss + i; 552 553 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 554 if (newvs == 0) 555 return YYENOMEM; 556 557 data->l_base = newvs; 558 data->l_mark = newvs + i; 559 560 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 561 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 562 if (newps == 0) 563 return YYENOMEM; 564 565 data->p_base = newps; 566 data->p_mark = newps + i; 567 #endif 568 569 data->stacksize = newsize; 570 data->s_last = data->s_base + newsize - 1; 571 572 #if YYDEBUG 573 if (yydebug) 574 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 575 #endif 576 return 0; 577 } 578 579 #if YYPURE || defined(YY_NO_LEAKS) 580 static void yyfreestack(YYSTACKDATA *data) 581 { 582 free(data->s_base); 583 free(data->l_base); 584 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 585 free(data->p_base); 586 #endif 587 memset(data, 0, sizeof(*data)); 588 } 589 #else 590 #define yyfreestack(data) /* nothing */ 591 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 592 #if YYBTYACC 593 594 static YYParseState * 595 yyNewState(unsigned size) 596 { 597 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 598 if (p == NULL) return NULL; 599 600 p->yystack.stacksize = size; 601 if (size == 0) 602 { 603 p->yystack.s_base = NULL; 604 p->yystack.l_base = NULL; 605 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 606 p->yystack.p_base = NULL; 607 #endif 608 return p; 609 } 610 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 611 if (p->yystack.s_base == NULL) return NULL; 612 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 613 if (p->yystack.l_base == NULL) return NULL; 614 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 615 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 616 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 617 if (p->yystack.p_base == NULL) return NULL; 618 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 619 #endif 620 621 return p; 622 } 623 624 static void 625 yyFreeState(YYParseState *p) 626 { 627 yyfreestack(&p->yystack); 628 free(p); 629 } 630 #endif /* YYBTYACC */ 631 632 #define YYABORT goto yyabort 633 #define YYREJECT goto yyabort 634 #define YYACCEPT goto yyaccept 635 #define YYERROR goto yyerrlab 636 #if YYBTYACC 637 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 638 #define YYVALID_NESTED do { if (yyps->save && \ 639 yyps->save->save == 0) goto yyvalid; } while(0) 640 #endif /* YYBTYACC */ 641 642 int 643 YYPARSE_DECL() 644 { 645 int yym, yyn, yystate, yyresult; 646 #if YYBTYACC 647 int yynewerrflag; 648 YYParseState *yyerrctx = NULL; 649 #endif /* YYBTYACC */ 650 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 651 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 652 #endif 653 #if YYDEBUG 654 const char *yys; 655 656 if ((yys = getenv("YYDEBUG")) != 0) 657 { 658 yyn = *yys; 659 if (yyn >= '0' && yyn <= '9') 660 yydebug = yyn - '0'; 661 } 662 if (yydebug) 663 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 664 #endif 665 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 666 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 667 #endif 668 669 #if YYBTYACC 670 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 671 yyps->save = 0; 672 #endif /* YYBTYACC */ 673 yym = 0; 674 yyn = 0; 675 yynerrs = 0; 676 yyerrflag = 0; 677 yychar = YYEMPTY; 678 yystate = 0; 679 680 #if YYPURE 681 memset(&yystack, 0, sizeof(yystack)); 682 #endif 683 684 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 685 yystack.s_mark = yystack.s_base; 686 yystack.l_mark = yystack.l_base; 687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 688 yystack.p_mark = yystack.p_base; 689 #endif 690 yystate = 0; 691 *yystack.s_mark = 0; 692 693 yyloop: 694 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 695 if (yychar < 0) 696 { 697 #if YYBTYACC 698 do { 699 if (yylvp < yylve) 700 { 701 /* we're currently re-reading tokens */ 702 yylval = *yylvp++; 703 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 704 yylloc = *yylpp++; 705 #endif 706 yychar = *yylexp++; 707 break; 708 } 709 if (yyps->save) 710 { 711 /* in trial mode; save scanner results for future parse attempts */ 712 if (yylvp == yylvlim) 713 { /* Enlarge lexical value queue */ 714 size_t p = (size_t) (yylvp - yylvals); 715 size_t s = (size_t) (yylvlim - yylvals); 716 717 s += YYLVQUEUEGROWTH; 718 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 719 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 720 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 721 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 722 #endif 723 yylvp = yylve = yylvals + p; 724 yylvlim = yylvals + s; 725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 726 yylpp = yylpe = yylpsns + p; 727 yylplim = yylpsns + s; 728 #endif 729 yylexp = yylexemes + p; 730 } 731 *yylexp = (YYINT) YYLEX; 732 *yylvp++ = yylval; 733 yylve++; 734 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 735 *yylpp++ = yylloc; 736 yylpe++; 737 #endif 738 yychar = *yylexp++; 739 break; 740 } 741 /* normal operation, no conflict encountered */ 742 #endif /* YYBTYACC */ 743 yychar = YYLEX; 744 #if YYBTYACC 745 } while (0); 746 #endif /* YYBTYACC */ 747 if (yychar < 0) yychar = YYEOF; 748 #if YYDEBUG 749 if (yydebug) 750 { 751 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 752 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 753 YYDEBUGSTR, yydepth, yystate, yychar, yys); 754 #ifdef YYSTYPE_TOSTRING 755 #if YYBTYACC 756 if (!yytrial) 757 #endif /* YYBTYACC */ 758 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 759 #endif 760 fputc('\n', stderr); 761 } 762 #endif 763 } 764 #if YYBTYACC 765 766 /* Do we have a conflict? */ 767 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 768 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 769 { 770 YYINT ctry; 771 772 if (yypath) 773 { 774 YYParseState *save; 775 #if YYDEBUG 776 if (yydebug) 777 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 778 YYDEBUGSTR, yydepth, yystate); 779 #endif 780 /* Switch to the next conflict context */ 781 save = yypath; 782 yypath = save->save; 783 save->save = NULL; 784 ctry = save->ctry; 785 if (save->state != yystate) YYABORT; 786 yyFreeState(save); 787 788 } 789 else 790 { 791 792 /* Unresolved conflict - start/continue trial parse */ 793 YYParseState *save; 794 #if YYDEBUG 795 if (yydebug) 796 { 797 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 798 if (yyps->save) 799 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 800 else 801 fputs("Starting trial parse.\n", stderr); 802 } 803 #endif 804 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 805 if (save == NULL) goto yyenomem; 806 save->save = yyps->save; 807 save->state = yystate; 808 save->errflag = yyerrflag; 809 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 810 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 811 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 812 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 813 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 814 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 815 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 816 #endif 817 ctry = yytable[yyn]; 818 if (yyctable[ctry] == -1) 819 { 820 #if YYDEBUG 821 if (yydebug && yychar >= YYEOF) 822 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 823 #endif 824 ctry++; 825 } 826 save->ctry = ctry; 827 if (yyps->save == NULL) 828 { 829 /* If this is a first conflict in the stack, start saving lexemes */ 830 if (!yylexemes) 831 { 832 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 833 if (yylexemes == NULL) goto yyenomem; 834 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 835 if (yylvals == NULL) goto yyenomem; 836 yylvlim = yylvals + YYLVQUEUEGROWTH; 837 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 838 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 839 if (yylpsns == NULL) goto yyenomem; 840 yylplim = yylpsns + YYLVQUEUEGROWTH; 841 #endif 842 } 843 if (yylvp == yylve) 844 { 845 yylvp = yylve = yylvals; 846 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 847 yylpp = yylpe = yylpsns; 848 #endif 849 yylexp = yylexemes; 850 if (yychar >= YYEOF) 851 { 852 *yylve++ = yylval; 853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 854 *yylpe++ = yylloc; 855 #endif 856 *yylexp = (YYINT) yychar; 857 yychar = YYEMPTY; 858 } 859 } 860 } 861 if (yychar >= YYEOF) 862 { 863 yylvp--; 864 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 865 yylpp--; 866 #endif 867 yylexp--; 868 yychar = YYEMPTY; 869 } 870 save->lexeme = (int) (yylvp - yylvals); 871 yyps->save = save; 872 } 873 if (yytable[yyn] == ctry) 874 { 875 #if YYDEBUG 876 if (yydebug) 877 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 878 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 879 #endif 880 if (yychar < 0) 881 { 882 yylvp++; 883 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 884 yylpp++; 885 #endif 886 yylexp++; 887 } 888 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 889 goto yyoverflow; 890 yystate = yyctable[ctry]; 891 *++yystack.s_mark = (YYINT) yystate; 892 *++yystack.l_mark = yylval; 893 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 *++yystack.p_mark = yylloc; 895 #endif 896 yychar = YYEMPTY; 897 if (yyerrflag > 0) --yyerrflag; 898 goto yyloop; 899 } 900 else 901 { 902 yyn = yyctable[ctry]; 903 goto yyreduce; 904 } 905 } /* End of code dealing with conflicts */ 906 #endif /* YYBTYACC */ 907 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 908 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 909 { 910 #if YYDEBUG 911 if (yydebug) 912 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 913 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 914 #endif 915 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 916 yystate = yytable[yyn]; 917 *++yystack.s_mark = yytable[yyn]; 918 *++yystack.l_mark = yylval; 919 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 920 *++yystack.p_mark = yylloc; 921 #endif 922 yychar = YYEMPTY; 923 if (yyerrflag > 0) --yyerrflag; 924 goto yyloop; 925 } 926 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 927 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 928 { 929 yyn = yytable[yyn]; 930 goto yyreduce; 931 } 932 if (yyerrflag != 0) goto yyinrecovery; 933 #if YYBTYACC 934 935 yynewerrflag = 1; 936 goto yyerrhandler; 937 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 938 939 yyerrlab: 940 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 941 * before looking for error recovery */ 942 yystack.s_mark -= yym; 943 yystate = *yystack.s_mark; 944 yystack.l_mark -= yym; 945 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 946 yystack.p_mark -= yym; 947 #endif 948 949 yynewerrflag = 0; 950 yyerrhandler: 951 while (yyps->save) 952 { 953 int ctry; 954 YYParseState *save = yyps->save; 955 #if YYDEBUG 956 if (yydebug) 957 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 958 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 959 (int)(yylvp - yylvals - yyps->save->lexeme)); 960 #endif 961 /* Memorize most forward-looking error state in case it's really an error. */ 962 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 963 { 964 /* Free old saved error context state */ 965 if (yyerrctx) yyFreeState(yyerrctx); 966 /* Create and fill out new saved error context state */ 967 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 968 if (yyerrctx == NULL) goto yyenomem; 969 yyerrctx->save = yyps->save; 970 yyerrctx->state = yystate; 971 yyerrctx->errflag = yyerrflag; 972 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 973 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 974 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 975 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 976 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 977 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 978 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 979 #endif 980 yyerrctx->lexeme = (int) (yylvp - yylvals); 981 } 982 yylvp = yylvals + save->lexeme; 983 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 984 yylpp = yylpsns + save->lexeme; 985 #endif 986 yylexp = yylexemes + save->lexeme; 987 yychar = YYEMPTY; 988 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 989 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 990 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 991 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 993 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 994 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 995 #endif 996 ctry = ++save->ctry; 997 yystate = save->state; 998 /* We tried shift, try reduce now */ 999 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1000 yyps->save = save->save; 1001 save->save = NULL; 1002 yyFreeState(save); 1003 1004 /* Nothing left on the stack -- error */ 1005 if (!yyps->save) 1006 { 1007 #if YYDEBUG 1008 if (yydebug) 1009 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1010 YYPREFIX, yydepth); 1011 #endif 1012 /* Restore state as it was in the most forward-advanced error */ 1013 yylvp = yylvals + yyerrctx->lexeme; 1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1015 yylpp = yylpsns + yyerrctx->lexeme; 1016 #endif 1017 yylexp = yylexemes + yyerrctx->lexeme; 1018 yychar = yylexp[-1]; 1019 yylval = yylvp[-1]; 1020 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1021 yylloc = yylpp[-1]; 1022 #endif 1023 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1024 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1025 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1026 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1027 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1028 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1029 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1030 #endif 1031 yystate = yyerrctx->state; 1032 yyFreeState(yyerrctx); 1033 yyerrctx = NULL; 1034 } 1035 yynewerrflag = 1; 1036 } 1037 if (yynewerrflag == 0) goto yyinrecovery; 1038 #endif /* YYBTYACC */ 1039 1040 YYERROR_CALL("syntax error"); 1041 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1042 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1043 #endif 1044 1045 #if !YYBTYACC 1046 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1047 yyerrlab: 1048 #endif 1049 ++yynerrs; 1050 1051 yyinrecovery: 1052 if (yyerrflag < 3) 1053 { 1054 yyerrflag = 3; 1055 for (;;) 1056 { 1057 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1058 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1059 { 1060 #if YYDEBUG 1061 if (yydebug) 1062 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1063 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1064 #endif 1065 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1066 yystate = yytable[yyn]; 1067 *++yystack.s_mark = yytable[yyn]; 1068 *++yystack.l_mark = yylval; 1069 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1070 /* lookahead position is error end position */ 1071 yyerror_loc_range[1] = yylloc; 1072 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1073 *++yystack.p_mark = yyloc; 1074 #endif 1075 goto yyloop; 1076 } 1077 else 1078 { 1079 #if YYDEBUG 1080 if (yydebug) 1081 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1082 YYDEBUGSTR, yydepth, *yystack.s_mark); 1083 #endif 1084 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1086 /* the current TOS position is the error start position */ 1087 yyerror_loc_range[0] = *yystack.p_mark; 1088 #endif 1089 #if defined(YYDESTRUCT_CALL) 1090 #if YYBTYACC 1091 if (!yytrial) 1092 #endif /* YYBTYACC */ 1093 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1094 YYDESTRUCT_CALL("error: discarding state", 1095 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1096 #else 1097 YYDESTRUCT_CALL("error: discarding state", 1098 yystos[*yystack.s_mark], yystack.l_mark); 1099 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1100 #endif /* defined(YYDESTRUCT_CALL) */ 1101 --yystack.s_mark; 1102 --yystack.l_mark; 1103 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1104 --yystack.p_mark; 1105 #endif 1106 } 1107 } 1108 } 1109 else 1110 { 1111 if (yychar == YYEOF) goto yyabort; 1112 #if YYDEBUG 1113 if (yydebug) 1114 { 1115 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1116 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1117 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1118 } 1119 #endif 1120 #if defined(YYDESTRUCT_CALL) 1121 #if YYBTYACC 1122 if (!yytrial) 1123 #endif /* YYBTYACC */ 1124 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1125 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1126 #else 1127 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1128 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1129 #endif /* defined(YYDESTRUCT_CALL) */ 1130 yychar = YYEMPTY; 1131 goto yyloop; 1132 } 1133 1134 yyreduce: 1135 yym = yylen[yyn]; 1136 #if YYDEBUG 1137 if (yydebug) 1138 { 1139 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1140 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1141 #ifdef YYSTYPE_TOSTRING 1142 #if YYBTYACC 1143 if (!yytrial) 1144 #endif /* YYBTYACC */ 1145 if (yym > 0) 1146 { 1147 int i; 1148 fputc('<', stderr); 1149 for (i = yym; i > 0; i--) 1150 { 1151 if (i != yym) fputs(", ", stderr); 1152 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1153 yystack.l_mark[1-i]), stderr); 1154 } 1155 fputc('>', stderr); 1156 } 1157 #endif 1158 fputc('\n', stderr); 1159 } 1160 #endif 1161 if (yym > 0) 1162 yyval = yystack.l_mark[1-yym]; 1163 else 1164 memset(&yyval, 0, sizeof yyval); 1165 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1166 1167 /* Perform position reduction */ 1168 memset(&yyloc, 0, sizeof(yyloc)); 1169 #if YYBTYACC 1170 if (!yytrial) 1171 #endif /* YYBTYACC */ 1172 { 1173 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1174 /* just in case YYERROR is invoked within the action, save 1175 the start of the rhs as the error start position */ 1176 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1177 } 1178 #endif 1179 1180 switch (yyn) 1181 { 1182 case 1: 1183 if (!yytrial) 1184 #line 62 "btyacc_destroy1.y" 1185 { yyval.nlist = yystack.l_mark[-5].nlist; } 1186 break; 1187 case 2: 1188 if (!yytrial) 1189 #line 64 "btyacc_destroy1.y" 1190 { yyval.nlist = yystack.l_mark[-3].nlist; } 1191 break; 1192 case 3: 1193 if (!yytrial) 1194 #line 67 "btyacc_destroy1.y" 1195 { yyval.cval = cGLOBAL; } 1196 break; 1197 case 4: 1198 if (!yytrial) 1199 #line 68 "btyacc_destroy1.y" 1200 { yyval.cval = cLOCAL; } 1201 break; 1202 case 5: 1203 if (!yytrial) 1204 #line 71 "btyacc_destroy1.y" 1205 { yyval.tval = tREAL; } 1206 break; 1207 case 6: 1208 if (!yytrial) 1209 #line 72 "btyacc_destroy1.y" 1210 { yyval.tval = tINTEGER; } 1211 break; 1212 case 7: 1213 if (!yytrial) 1214 #line 76 "btyacc_destroy1.y" 1215 { yyval.nlist->s = mksymbol(yystack.l_mark[-2].tval, yystack.l_mark[-2].cval, yystack.l_mark[0].id); 1216 yyval.nlist->next = yystack.l_mark[-1].nlist; 1217 } 1218 break; 1219 case 8: 1220 if (!yytrial) 1221 #line 80 "btyacc_destroy1.y" 1222 { yyval.nlist->s = mksymbol(0, 0, yystack.l_mark[0].id); 1223 yyval.nlist->next = NULL; 1224 } 1225 break; 1226 case 9: 1227 if (!yytrial) 1228 #line 86 "btyacc_destroy1.y" 1229 { yyval.nlist = yystack.l_mark[-5].nlist; } 1230 break; 1231 #line 1232 "btyacc_destroy1.tab.c" 1232 default: 1233 break; 1234 } 1235 yystack.s_mark -= yym; 1236 yystate = *yystack.s_mark; 1237 yystack.l_mark -= yym; 1238 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1239 yystack.p_mark -= yym; 1240 #endif 1241 yym = yylhs[yyn]; 1242 if (yystate == 0 && yym == 0) 1243 { 1244 #if YYDEBUG 1245 if (yydebug) 1246 { 1247 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1248 #ifdef YYSTYPE_TOSTRING 1249 #if YYBTYACC 1250 if (!yytrial) 1251 #endif /* YYBTYACC */ 1252 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1253 #endif 1254 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1255 } 1256 #endif 1257 yystate = YYFINAL; 1258 *++yystack.s_mark = YYFINAL; 1259 *++yystack.l_mark = yyval; 1260 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1261 *++yystack.p_mark = yyloc; 1262 #endif 1263 if (yychar < 0) 1264 { 1265 #if YYBTYACC 1266 do { 1267 if (yylvp < yylve) 1268 { 1269 /* we're currently re-reading tokens */ 1270 yylval = *yylvp++; 1271 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1272 yylloc = *yylpp++; 1273 #endif 1274 yychar = *yylexp++; 1275 break; 1276 } 1277 if (yyps->save) 1278 { 1279 /* in trial mode; save scanner results for future parse attempts */ 1280 if (yylvp == yylvlim) 1281 { /* Enlarge lexical value queue */ 1282 size_t p = (size_t) (yylvp - yylvals); 1283 size_t s = (size_t) (yylvlim - yylvals); 1284 1285 s += YYLVQUEUEGROWTH; 1286 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1287 goto yyenomem; 1288 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1289 goto yyenomem; 1290 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1291 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1292 goto yyenomem; 1293 #endif 1294 yylvp = yylve = yylvals + p; 1295 yylvlim = yylvals + s; 1296 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1297 yylpp = yylpe = yylpsns + p; 1298 yylplim = yylpsns + s; 1299 #endif 1300 yylexp = yylexemes + p; 1301 } 1302 *yylexp = (YYINT) YYLEX; 1303 *yylvp++ = yylval; 1304 yylve++; 1305 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1306 *yylpp++ = yylloc; 1307 yylpe++; 1308 #endif 1309 yychar = *yylexp++; 1310 break; 1311 } 1312 /* normal operation, no conflict encountered */ 1313 #endif /* YYBTYACC */ 1314 yychar = YYLEX; 1315 #if YYBTYACC 1316 } while (0); 1317 #endif /* YYBTYACC */ 1318 if (yychar < 0) yychar = YYEOF; 1319 #if YYDEBUG 1320 if (yydebug) 1321 { 1322 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1323 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1324 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1325 } 1326 #endif 1327 } 1328 if (yychar == YYEOF) goto yyaccept; 1329 goto yyloop; 1330 } 1331 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1332 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1333 yystate = yytable[yyn]; 1334 else 1335 yystate = yydgoto[yym]; 1336 #if YYDEBUG 1337 if (yydebug) 1338 { 1339 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1340 #ifdef YYSTYPE_TOSTRING 1341 #if YYBTYACC 1342 if (!yytrial) 1343 #endif /* YYBTYACC */ 1344 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1345 #endif 1346 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1347 } 1348 #endif 1349 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1350 *++yystack.s_mark = (YYINT) yystate; 1351 *++yystack.l_mark = yyval; 1352 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1353 *++yystack.p_mark = yyloc; 1354 #endif 1355 goto yyloop; 1356 #if YYBTYACC 1357 1358 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1359 yyvalid: 1360 if (yypath) YYABORT; 1361 while (yyps->save) 1362 { 1363 YYParseState *save = yyps->save; 1364 yyps->save = save->save; 1365 save->save = yypath; 1366 yypath = save; 1367 } 1368 #if YYDEBUG 1369 if (yydebug) 1370 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1371 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1372 #endif 1373 if (yyerrctx) 1374 { 1375 yyFreeState(yyerrctx); 1376 yyerrctx = NULL; 1377 } 1378 yylvp = yylvals + yypath->lexeme; 1379 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1380 yylpp = yylpsns + yypath->lexeme; 1381 #endif 1382 yylexp = yylexemes + yypath->lexeme; 1383 yychar = YYEMPTY; 1384 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1385 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1386 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1387 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1388 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1389 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1390 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1391 #endif 1392 yystate = yypath->state; 1393 goto yyloop; 1394 #endif /* YYBTYACC */ 1395 1396 yyoverflow: 1397 YYERROR_CALL("yacc stack overflow"); 1398 #if YYBTYACC 1399 goto yyabort_nomem; 1400 yyenomem: 1401 YYERROR_CALL("memory exhausted"); 1402 yyabort_nomem: 1403 #endif /* YYBTYACC */ 1404 yyresult = 2; 1405 goto yyreturn; 1406 1407 yyabort: 1408 yyresult = 1; 1409 goto yyreturn; 1410 1411 yyaccept: 1412 #if YYBTYACC 1413 if (yyps->save) goto yyvalid; 1414 #endif /* YYBTYACC */ 1415 yyresult = 0; 1416 1417 yyreturn: 1418 #if defined(YYDESTRUCT_CALL) 1419 if (yychar != YYEOF && yychar != YYEMPTY) 1420 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1421 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1422 #else 1423 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1424 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1425 1426 { 1427 YYSTYPE *pv; 1428 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1429 YYLTYPE *pp; 1430 1431 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1432 YYDESTRUCT_CALL("cleanup: discarding state", 1433 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1434 #else 1435 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1436 YYDESTRUCT_CALL("cleanup: discarding state", 1437 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1438 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1439 } 1440 #endif /* defined(YYDESTRUCT_CALL) */ 1441 1442 #if YYBTYACC 1443 if (yyerrctx) 1444 { 1445 yyFreeState(yyerrctx); 1446 yyerrctx = NULL; 1447 } 1448 while (yyps) 1449 { 1450 YYParseState *save = yyps; 1451 yyps = save->save; 1452 save->save = NULL; 1453 yyFreeState(save); 1454 } 1455 while (yypath) 1456 { 1457 YYParseState *save = yypath; 1458 yypath = save->save; 1459 save->save = NULL; 1460 yyFreeState(save); 1461 } 1462 #endif /* YYBTYACC */ 1463 yyfreestack(&yystack); 1464 return (yyresult); 1465 } 1466