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