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