contrib/byacc/btyaccpar.c

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