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