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