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.6 2017/04/30 23:40:34 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     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 454     "    memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));",
 455     "#endif",
 456     "",
 457     0
 458 };
 459
 460 const char *const init_vars[] =
 461 {
 462     "    yyerrflag = 0;",
 463     "    yychar = 0;",
 464     "    memset(&yyval,  0, sizeof(yyval));",
 465     "    memset(&yylval, 0, sizeof(yylval));",
 466     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 467     "    memset(&yyloc,  0, sizeof(yyloc));",
 468     "    memset(&yylloc, 0, sizeof(yylloc));",
 469     "#endif",
 470     "",
 471     0
 472 };
 473
 474 const char *const body_3[] =
 475 {
 476 #if defined(YYBTYACC)
 477     "#if YYBTYACC",
 478     "    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
 479     "    yyps->save = 0;",
 480     "#endif /* YYBTYACC */",
 481 #endif                  /* defined(YYBTYACC) */
 482     "    yym = 0;",
 483     "    yyn = 0;",
 484     "    yynerrs = 0;",
 485     "    yyerrflag = 0;",
 486     "    yychar = YYEMPTY;",
 487     "    yystate = 0;",
 488     "",
 489     "#if YYPURE",
 490     "    memset(&yystack, 0, sizeof(yystack));",
 491     "#endif",
 492     "",
 493     "    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
 494     "    yystack.s_mark = yystack.s_base;",
 495     "    yystack.l_mark = yystack.l_base;",
 496     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 497     "    yystack.p_mark = yystack.p_base;",
 498     "#endif",
 499     "    yystate = 0;",
 500     "    *yystack.s_mark = 0;",
 501     "",
 502     "yyloop:",
 503     "    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
 504     "    if (yychar < 0)",
 505     "    {",
 506 #if defined(YYBTYACC)
 507     "#if YYBTYACC",
 508     "        do {",
 509     "        if (yylvp < yylve)",
 510     "        {",
 511     "            /* we're currently re-reading tokens */",
 512     "            yylval = *yylvp++;",
 513     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 514     "            yylloc = *yylpp++;",
 515     "#endif",
 516     "            yychar = *yylexp++;",
 517     "            break;",
 518     "        }",
 519     "        if (yyps->save)",
 520     "        {",
 521     "            /* in trial mode; save scanner results for future parse attempts */",
 522     "            if (yylvp == yylvlim)",
 523     "            {   /* Enlarge lexical value queue */",
 524     "                size_t p = (size_t) (yylvp - yylvals);",
 525     "                size_t s = (size_t) (yylvlim - yylvals);",
 526     "",
 527     "                s += YYLVQUEUEGROWTH;",
 528     "                if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;",
 529     "                if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;",
 530     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 531     "                if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;",
 532     "#endif",
 533     "                yylvp   = yylve = yylvals + p;",
 534     "                yylvlim = yylvals + s;",
 535     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 536     "                yylpp   = yylpe = yylpsns + p;",
 537     "                yylplim = yylpsns + s;",
 538     "#endif",
 539     "                yylexp  = yylexemes + p;",
 540     "            }",
 541     "            *yylexp = (YYINT) YYLEX;",
 542     "            *yylvp++ = yylval;",
 543     "            yylve++;",
 544     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 545     "            *yylpp++ = yylloc;",
 546     "            yylpe++;",
 547     "#endif",
 548     "            yychar = *yylexp++;",
 549     "            break;",
 550     "        }",
 551     "        /* normal operation, no conflict encountered */",
 552     "#endif /* YYBTYACC */",
 553 #endif                  /* defined(YYBTYACC) */
 554     "        yychar = YYLEX;",
 555 #if defined(YYBTYACC)
 556     "#if YYBTYACC",
 557     "        } while (0);",
 558     "#endif /* YYBTYACC */",
 559 #endif                  /* defined(YYBTYACC) */
 560     "        if (yychar < 0) yychar = YYEOF;",
 561     "#if YYDEBUG",
 562     "        if (yydebug)",
 563     "        {",
 564     "            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
 565     "            fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\",",
 566     "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
 567     "#ifdef YYSTYPE_TOSTRING",
 568 #if defined(YYBTYACC)
 569     "#if YYBTYACC",
 570     "            if (!yytrial)",
 571     "#endif /* YYBTYACC */",
 572 #endif                  /* defined(YYBTYACC) */
 573     "                fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
 574     "#endif",
 575     "            fputc('\\n', stderr);",
 576     "        }",
 577     "#endif",
 578     "    }",
 579 #if defined(YYBTYACC)
 580     "#if YYBTYACC",
 581     "",
 582     "    /* Do we have a conflict? */",
 583     "    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
 584     "        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
 585     "    {",
 586     "        YYINT ctry;",
 587     "",
 588     "        if (yypath)",
 589     "        {",
 590     "            YYParseState *save;",
 591     "#if YYDEBUG",
 592     "            if (yydebug)",
 593     "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d: following successful trial parse\\n\",",
 594     "                                YYDEBUGSTR, yydepth, yystate);",
 595     "#endif",
 596     "            /* Switch to the next conflict context */",
 597     "            save = yypath;",
 598     "            yypath = save->save;",
 599     "            save->save = NULL;",
 600     "            ctry = save->ctry;",
 601     "            if (save->state != yystate) YYABORT;",
 602     "            yyFreeState(save);",
 603     "",
 604     "        }",
 605     "        else",
 606     "        {",
 607     "",
 608     "            /* Unresolved conflict - start/continue trial parse */",
 609     "            YYParseState *save;",
 610     "#if YYDEBUG",
 611     "            if (yydebug)",
 612     "            {",
 613     "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d. \", YYDEBUGSTR, yydepth, yystate);",
 614     "                if (yyps->save)",
 615     "                    fputs(\"ALREADY in conflict, continuing trial parse.\\n\", stderr);",
 616     "                else",
 617     "                    fputs(\"Starting trial parse.\\n\", stderr);",
 618     "            }",
 619     "#endif",
 620     "            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
 621     "            if (save == NULL) goto yyenomem;",
 622     "            save->save            = yyps->save;",
 623     "            save->state           = yystate;",
 624     "            save->errflag         = yyerrflag;",
 625     "            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",
 626     "            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
 627     "            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",
 628     "            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
 629     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 630     "            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",
 631     "            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
 632     "#endif",
 633     "            ctry                  = yytable[yyn];",
 634     "            if (yyctable[ctry] == -1)",
 635     "            {",
 636     "#if YYDEBUG",
 637     "                if (yydebug && yychar >= YYEOF)",
 638     "                    fprintf(stderr, \"%s[%d]: backtracking 1 token\\n\", YYDEBUGSTR, yydepth);",
 639     "#endif",
 640     "                ctry++;",
 641     "            }",
 642     "            save->ctry = ctry;",
 643     "            if (yyps->save == NULL)",
 644     "            {",
 645     "                /* If this is a first conflict in the stack, start saving lexemes */",
 646     "                if (!yylexemes)",
 647     "                {",
 648     "                    yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));",
 649     "                    if (yylexemes == NULL) goto yyenomem;",
 650     "                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));",
 651     "                    if (yylvals == NULL) goto yyenomem;",
 652     "                    yylvlim   = yylvals + YYLVQUEUEGROWTH;",
 653     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 654     "                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));",
 655     "                    if (yylpsns == NULL) goto yyenomem;",
 656     "                    yylplim   = yylpsns + YYLVQUEUEGROWTH;",
 657     "#endif",
 658     "                }",
 659     "                if (yylvp == yylve)",
 660     "                {",
 661     "                    yylvp  = yylve = yylvals;",
 662     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 663     "                    yylpp  = yylpe = yylpsns;",
 664     "#endif",
 665     "                    yylexp = yylexemes;",
 666     "                    if (yychar >= YYEOF)",
 667     "                    {",
 668     "                        *yylve++ = yylval;",
 669     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 670     "                        *yylpe++ = yylloc;",
 671     "#endif",
 672     "                        *yylexp  = (YYINT) yychar;",
 673     "                        yychar   = YYEMPTY;",
 674     "                    }",
 675     "                }",
 676     "            }",
 677     "            if (yychar >= YYEOF)",
 678     "            {",
 679     "                yylvp--;",
 680     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 681     "                yylpp--;",
 682     "#endif",
 683     "                yylexp--;",
 684     "                yychar = YYEMPTY;",
 685     "            }",
 686     "            save->lexeme = (int) (yylvp - yylvals);",
 687     "            yyps->save   = save;",
 688     "        }",
 689     "        if (yytable[yyn] == ctry)",
 690     "        {",
 691     "#if YYDEBUG",
 692     "            if (yydebug)",
 693     "                fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
 694     "                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);",
 695     "#endif",
 696     "            if (yychar < 0)",
 697     "            {",
 698     "                yylvp++;",
 699     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 700     "                yylpp++;",
 701     "#endif",
 702     "                yylexp++;",
 703     "            }",
 704     "            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
 705     "                goto yyoverflow;",
 706     "            yystate = yyctable[ctry];",
 707     "            *++yystack.s_mark = (YYINT) yystate;",
 708     "            *++yystack.l_mark = yylval;",
 709     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 710     "            *++yystack.p_mark = yylloc;",
 711     "#endif",
 712     "            yychar  = YYEMPTY;",
 713     "            if (yyerrflag > 0) --yyerrflag;",
 714     "            goto yyloop;",
 715     "        }",
 716     "        else",
 717     "        {",
 718     "            yyn = yyctable[ctry];",
 719     "            goto yyreduce;",
 720     "        }",
 721     "    } /* End of code dealing with conflicts */",
 722     "#endif /* YYBTYACC */",
 723 #endif                  /* defined(YYBTYACC) */
 724     "    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
 725     "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
 726     "    {",
 727     "#if YYDEBUG",
 728     "        if (yydebug)",
 729     "            fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
 730     "                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);",
 731     "#endif",
 732     "        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
 733     "        yystate = yytable[yyn];",
 734     "        *++yystack.s_mark = yytable[yyn];",
 735     "        *++yystack.l_mark = yylval;",
 736     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 737     "        *++yystack.p_mark = yylloc;",
 738     "#endif",
 739     "        yychar = YYEMPTY;",
 740     "        if (yyerrflag > 0)  --yyerrflag;",
 741     "        goto yyloop;",
 742     "    }",
 743     "    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
 744     "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
 745     "    {",
 746     "        yyn = yytable[yyn];",
 747     "        goto yyreduce;",
 748     "    }",
 749     "    if (yyerrflag != 0) goto yyinrecovery;",
 750 #if defined(YYBTYACC)
 751     "#if YYBTYACC",
 752     "",
 753     "    yynewerrflag = 1;",
 754     "    goto yyerrhandler;",
 755     "    goto yyerrlab; /* redundant goto avoids 'unused label' warning */",
 756     "",
 757     "yyerrlab:",
 758     "    /* explicit YYERROR from an action -- pop the rhs of the rule reduced",
 759     "     * before looking for error recovery */",
 760     "    yystack.s_mark -= yym;",
 761     "    yystate = *yystack.s_mark;",
 762     "    yystack.l_mark -= yym;",
 763     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 764     "    yystack.p_mark -= yym;",
 765     "#endif",
 766     "",
 767     "    yynewerrflag = 0;",
 768     "yyerrhandler:",
 769     "    while (yyps->save)",
 770     "    {",
 771     "        int ctry;",
 772     "        YYParseState *save = yyps->save;",
 773     "#if YYDEBUG",
 774     "        if (yydebug)",
 775     "            fprintf(stderr, \"%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
 776     "                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,",
 777     "                    (int)(yylvp - yylvals - yyps->save->lexeme));",
 778     "#endif",
 779     "        /* Memorize most forward-looking error state in case it's really an error. */",
 780     "        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)",
 781     "        {",
 782     "            /* Free old saved error context state */",
 783     "            if (yyerrctx) yyFreeState(yyerrctx);",
 784     "            /* Create and fill out new saved error context state */",
 785     "            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
 786     "            if (yyerrctx == NULL) goto yyenomem;",
 787     "            yyerrctx->save           = yyps->save;",
 788     "            yyerrctx->state          = yystate;",
 789     "            yyerrctx->errflag        = yyerrflag;",
 790     "            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",
 791     "            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
 792     "            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",
 793     "            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
 794     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 795     "            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",
 796     "            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
 797     "#endif",
 798     "            yyerrctx->lexeme         = (int) (yylvp - yylvals);",
 799     "        }",
 800     "        yylvp          = yylvals   + save->lexeme;",
 801     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 802     "        yylpp          = yylpsns   + save->lexeme;",
 803     "#endif",
 804     "        yylexp         = yylexemes + save->lexeme;",
 805     "        yychar         = YYEMPTY;",
 806     "        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",
 807     "        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
 808     "        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",
 809     "        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
 810     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 811     "        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",
 812     "        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
 813     "#endif",
 814     "        ctry           = ++save->ctry;",
 815     "        yystate        = save->state;",
 816     "        /* We tried shift, try reduce now */",
 817     "        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;",
 818     "        yyps->save     = save->save;",
 819     "        save->save     = NULL;",
 820     "        yyFreeState(save);",
 821     "",
 822     "        /* Nothing left on the stack -- error */",
 823     "        if (!yyps->save)",
 824     "        {",
 825     "#if YYDEBUG",
 826     "            if (yydebug)",
 827     "                fprintf(stderr, \"%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\\n\",",
 828     "                                YYPREFIX, yydepth);",
 829     "#endif",
 830     "            /* Restore state as it was in the most forward-advanced error */",
 831     "            yylvp          = yylvals   + yyerrctx->lexeme;",
 832     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 833     "            yylpp          = yylpsns   + yyerrctx->lexeme;",
 834     "#endif",
 835     "            yylexp         = yylexemes + yyerrctx->lexeme;",
 836     "            yychar         = yylexp[-1];",
 837     "            yylval         = yylvp[-1];",
 838     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 839     "            yylloc         = yylpp[-1];",
 840     "#endif",
 841     "            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",
 842     "            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
 843     "            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",
 844     "            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
 845     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 846     "            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",
 847     "            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
 848     "#endif",
 849     "            yystate        = yyerrctx->state;",
 850     "            yyFreeState(yyerrctx);",
 851     "            yyerrctx       = NULL;",
 852     "        }",
 853     "        yynewerrflag = 1;",
 854     "    }",
 855     "    if (yynewerrflag == 0) goto yyinrecovery;",
 856     "#endif /* YYBTYACC */",
 857 #endif                  /* defined(YYBTYACC) */
 858     "",
 859     "    YYERROR_CALL(\"syntax error\");",
 860     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 861     "    yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */",
 862     "#endif",
 863     "",
 864     "#if !YYBTYACC",
 865     "    goto yyerrlab; /* redundant goto avoids 'unused label' warning */",
 866     "yyerrlab:",
 867     "#endif",
 868     "    ++yynerrs;",
 869     "",
 870     "yyinrecovery:",
 871     "    if (yyerrflag < 3)",
 872     "    {",
 873     "        yyerrflag = 3;",
 874     "        for (;;)",
 875     "        {",
 876     "            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&",
 877     "                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)",
 878     "            {",
 879     "#if YYDEBUG",
 880     "                if (yydebug)",
 881     "                    fprintf(stderr, \"%s[%d]: state %d, error recovery shifting to state %d\\n\",",
 882     "                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);",
 883     "#endif",
 884     "                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
 885     "                yystate = yytable[yyn];",
 886     "                *++yystack.s_mark = yytable[yyn];",
 887     "                *++yystack.l_mark = yylval;",
 888     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 889     "                /* lookahead position is error end position */",
 890     "                yyerror_loc_range[1] = yylloc;",
 891     "                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */",
 892     "                *++yystack.p_mark = yyloc;",
 893     "#endif",
 894     "                goto yyloop;",
 895     "            }",
 896     "            else",
 897     "            {",
 898     "#if YYDEBUG",
 899     "                if (yydebug)",
 900     "                    fprintf(stderr, \"%s[%d]: error recovery discarding state %d\\n\",",
 901     "                                    YYDEBUGSTR, yydepth, *yystack.s_mark);",
 902     "#endif",
 903     "                if (yystack.s_mark <= yystack.s_base) goto yyabort;",
 904     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 905     "                /* the current TOS position is the error start position */",
 906     "                yyerror_loc_range[0] = *yystack.p_mark;",
 907     "#endif",
 908     "#if defined(YYDESTRUCT_CALL)",
 909 #if defined(YYBTYACC)
 910     "#if YYBTYACC",
 911     "                if (!yytrial)",
 912     "#endif /* YYBTYACC */",
 913 #endif                  /* defined(YYBTYACC) */
 914     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 915     "                    YYDESTRUCT_CALL(\"error: discarding state\",",
 916     "                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
 917     "#else",
 918     "                    YYDESTRUCT_CALL(\"error: discarding state\",",
 919     "                                    yystos[*yystack.s_mark], yystack.l_mark);",
 920     "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
 921     "#endif /* defined(YYDESTRUCT_CALL) */",
 922     "                --yystack.s_mark;",
 923     "                --yystack.l_mark;",
 924     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 925     "                --yystack.p_mark;",
 926     "#endif",
 927     "            }",
 928     "        }",
 929     "    }",
 930     "    else",
 931     "    {",
 932     "        if (yychar == YYEOF) goto yyabort;",
 933     "#if YYDEBUG",
 934     "        if (yydebug)",
 935     "        {",
 936     "            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
 937     "            fprintf(stderr, \"%s[%d]: state %d, error recovery discarding token %d (%s)\\n\",",
 938     "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
 939     "        }",
 940     "#endif",
 941     "#if defined(YYDESTRUCT_CALL)",
 942 #if defined(YYBTYACC)
 943     "#if YYBTYACC",
 944     "        if (!yytrial)",
 945     "#endif /* YYBTYACC */",
 946 #endif                  /* defined(YYBTYACC) */
 947     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 948     "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
 949     "#else",
 950     "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval);",
 951     "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
 952     "#endif /* defined(YYDESTRUCT_CALL) */",
 953     "        yychar = YYEMPTY;",
 954     "        goto yyloop;",
 955     "    }",
 956     "",
 957     "yyreduce:",
 958     "    yym = yylen[yyn];",
 959     "#if YYDEBUG",
 960     "    if (yydebug)",
 961     "    {",
 962     "        fprintf(stderr, \"%s[%d]: state %d, reducing by rule %d (%s)\",",
 963     "                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);",
 964     "#ifdef YYSTYPE_TOSTRING",
 965 #if defined(YYBTYACC)
 966     "#if YYBTYACC",
 967     "        if (!yytrial)",
 968     "#endif /* YYBTYACC */",
 969 #endif                  /* defined(YYBTYACC) */
 970     "            if (yym > 0)",
 971     "            {",
 972     "                int i;",
 973     "                fputc('<', stderr);",
 974     "                for (i = yym; i > 0; i--)",
 975     "                {",
 976     "                    if (i != yym) fputs(\", \", stderr);",
 977     "                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],",
 978     "                                           yystack.l_mark[1-i]), stderr);",
 979     "                }",
 980     "                fputc('>', stderr);",
 981     "            }",
 982     "#endif",
 983     "        fputc('\\n', stderr);",
 984     "    }",
 985     "#endif",
 986     "    if (yym > 0)",
 987     "        yyval = yystack.l_mark[1-yym];",
 988     "    else",
 989     "        memset(&yyval, 0, sizeof yyval);",
 990     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
 991     "",
 992     "    /* Perform position reduction */",
 993     "    memset(&yyloc, 0, sizeof(yyloc));",
 994 #if defined(YYBTYACC)
 995     "#if YYBTYACC",
 996     "    if (!yytrial)",
 997     "#endif /* YYBTYACC */",
 998 #endif                  /* defined(YYBTYACC) */
 999     "    {",
1000     "        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
1001     "        /* just in case YYERROR is invoked within the action, save",
1002     "           the start of the rhs as the error start position */",
1003     "        yyerror_loc_range[0] = yystack.p_mark[1-yym];",
1004     "    }",
1005     "#endif",
1006     "",
1007     "    switch (yyn)",
1008     "    {",
1009     0
1010 };
1011
1012 const char *const trailer[] =
1013 {
1014     "    default:",
1015     "        break;",
1016     "    }",
1017     "    yystack.s_mark -= yym;",
1018     "    yystate = *yystack.s_mark;",
1019     "    yystack.l_mark -= yym;",
1020     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1021     "    yystack.p_mark -= yym;",
1022     "#endif",
1023     "    yym = yylhs[yyn];",
1024     "    if (yystate == 0 && yym == 0)",
1025     "    {",
1026     "#if YYDEBUG",
1027     "        if (yydebug)",
1028     "        {",
1029     "            fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
1030     "#ifdef YYSTYPE_TOSTRING",
1031 #if defined(YYBTYACC)
1032     "#if YYBTYACC",
1033     "            if (!yytrial)",
1034     "#endif /* YYBTYACC */",
1035 #endif                  /* defined(YYBTYACC) */
1036     "                fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
1037     "#endif",
1038     "            fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
1039     "        }",
1040     "#endif",
1041     "        yystate = YYFINAL;",
1042     "        *++yystack.s_mark = YYFINAL;",
1043     "        *++yystack.l_mark = yyval;",
1044     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1045     "        *++yystack.p_mark = yyloc;",
1046     "#endif",
1047     "        if (yychar < 0)",
1048     "        {",
1049 #if defined(YYBTYACC)
1050     "#if YYBTYACC",
1051     "            do {",
1052     "            if (yylvp < yylve)",
1053     "            {",
1054     "                /* we're currently re-reading tokens */",
1055     "                yylval = *yylvp++;",
1056     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1057     "                yylloc = *yylpp++;",
1058     "#endif",
1059     "                yychar = *yylexp++;",
1060     "                break;",
1061     "            }",
1062     "            if (yyps->save)",
1063     "            {",
1064     "                /* in trial mode; save scanner results for future parse attempts */",
1065     "                if (yylvp == yylvlim)",
1066     "                {   /* Enlarge lexical value queue */",
1067     "                    size_t p = (size_t) (yylvp - yylvals);",
1068     "                    size_t s = (size_t) (yylvlim - yylvals);",
1069     "",
1070     "                    s += YYLVQUEUEGROWTH;",
1071     "                    if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)",
1072     "                        goto yyenomem;",
1073     "                    if ((yylvals   = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)",
1074     "                        goto yyenomem;",
1075     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1076     "                    if ((yylpsns   = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)",
1077     "                        goto yyenomem;",
1078     "#endif",
1079     "                    yylvp   = yylve = yylvals + p;",
1080     "                    yylvlim = yylvals + s;",
1081     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1082     "                    yylpp   = yylpe = yylpsns + p;",
1083     "                    yylplim = yylpsns + s;",
1084     "#endif",
1085     "                    yylexp  = yylexemes + p;",
1086     "                }",
1087     "                *yylexp = (YYINT) YYLEX;",
1088     "                *yylvp++ = yylval;",
1089     "                yylve++;",
1090     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1091     "                *yylpp++ = yylloc;",
1092     "                yylpe++;",
1093     "#endif",
1094     "                yychar = *yylexp++;",
1095     "                break;",
1096     "            }",
1097     "            /* normal operation, no conflict encountered */",
1098     "#endif /* YYBTYACC */",
1099 #endif                  /* defined(YYBTYACC) */
1100     "            yychar = YYLEX;",
1101 #if defined(YYBTYACC)
1102     "#if YYBTYACC",
1103     "            } while (0);",
1104     "#endif /* YYBTYACC */",
1105 #endif                  /* defined(YYBTYACC) */
1106     "            if (yychar < 0) yychar = YYEOF;",
1107     "#if YYDEBUG",
1108     "            if (yydebug)",
1109     "            {",
1110     "                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
1111     "                fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\\n\",",
1112     "                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);",
1113     "            }",
1114     "#endif",
1115     "        }",
1116     "        if (yychar == YYEOF) goto yyaccept;",
1117     "        goto yyloop;",
1118     "    }",
1119     "    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&",
1120     "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)",
1121     "        yystate = yytable[yyn];",
1122     "    else",
1123     "        yystate = yydgoto[yym];",
1124     "#if YYDEBUG",
1125     "    if (yydebug)",
1126     "    {",
1127     "        fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
1128     "#ifdef YYSTYPE_TOSTRING",
1129 #if defined(YYBTYACC)
1130     "#if YYBTYACC",
1131     "        if (!yytrial)",
1132     "#endif /* YYBTYACC */",
1133 #endif                  /* defined(YYBTYACC) */
1134     "            fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
1135     "#endif",
1136     "        fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
1137     "    }",
1138     "#endif",
1139     "    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
1140     "    *++yystack.s_mark = (YYINT) yystate;",
1141     "    *++yystack.l_mark = yyval;",
1142     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1143     "    *++yystack.p_mark = yyloc;",
1144     "#endif",
1145     "    goto yyloop;",
1146 #if defined(YYBTYACC)
1147     "#if YYBTYACC",
1148     "",
1149     "    /* Reduction declares that this path is valid. Set yypath and do a full parse */",
1150     "yyvalid:",
1151     "    if (yypath) YYABORT;",
1152     "    while (yyps->save)",
1153     "    {",
1154     "        YYParseState *save = yyps->save;",
1155     "        yyps->save = save->save;",
1156     "        save->save = yypath;",
1157     "        yypath = save;",
1158     "    }",
1159     "#if YYDEBUG",
1160     "    if (yydebug)",
1161     "        fprintf(stderr, \"%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
1162     "                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));",
1163     "#endif",
1164     "    if (yyerrctx)",
1165     "    {",
1166     "        yyFreeState(yyerrctx);",
1167     "        yyerrctx = NULL;",
1168     "    }",
1169     "    yylvp          = yylvals + yypath->lexeme;",
1170     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1171     "    yylpp          = yylpsns + yypath->lexeme;",
1172     "#endif",
1173     "    yylexp         = yylexemes + yypath->lexeme;",
1174     "    yychar         = YYEMPTY;",
1175     "    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",
1176     "    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
1177     "    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",
1178     "    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
1179     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1180     "    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",
1181     "    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
1182     "#endif",
1183     "    yystate        = yypath->state;",
1184     "    goto yyloop;",
1185     "#endif /* YYBTYACC */",
1186 #endif                  /* defined(YYBTYACC) */
1187     "",
1188     "yyoverflow:",
1189     "    YYERROR_CALL(\"yacc stack overflow\");",
1190 #if defined(YYBTYACC)
1191     "#if YYBTYACC",
1192     "    goto yyabort_nomem;",
1193     "yyenomem:",
1194     "    YYERROR_CALL(\"memory exhausted\");",
1195     "yyabort_nomem:",
1196     "#endif /* YYBTYACC */",
1197 #endif                  /* defined(YYBTYACC) */
1198     "    yyresult = 2;",
1199     "    goto yyreturn;",
1200     "",
1201     "yyabort:",
1202     "    yyresult = 1;",
1203     "    goto yyreturn;",
1204     "",
1205     "yyaccept:",
1206 #if defined(YYBTYACC)
1207     "#if YYBTYACC",
1208     "    if (yyps->save) goto yyvalid;",
1209     "#endif /* YYBTYACC */",
1210 #endif                  /* defined(YYBTYACC) */
1211     "    yyresult = 0;",
1212     "",
1213     "yyreturn:",
1214     "#if defined(YYDESTRUCT_CALL)",
1215     "    if (yychar != YYEOF && yychar != YYEMPTY)",
1216     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1217     "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval, &yylloc);",
1218     "#else",
1219     "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval);",
1220     "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1221     "",
1222     "    {",
1223     "        YYSTYPE *pv;",
1224     "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
1225     "        YYLTYPE *pp;",
1226     "",
1227     "        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)",
1228     "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1229     "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);",
1230     "#else",
1231     "        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)",
1232     "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
1233     "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);",
1234     "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
1235     "    }",
1236     "#endif /* defined(YYDESTRUCT_CALL) */",
1237     "",
1238 #if defined(YYBTYACC)
1239     "#if YYBTYACC",
1240     "    if (yyerrctx)",
1241     "    {",
1242     "        yyFreeState(yyerrctx);",
1243     "        yyerrctx = NULL;",
1244     "    }",
1245     "    while (yyps)",
1246     "    {",
1247     "        YYParseState *save = yyps;",
1248     "        yyps = save->save;",
1249     "        save->save = NULL;",
1250     "        yyFreeState(save);",
1251     "    }",
1252     "    while (yypath)",
1253     "    {",
1254     "        YYParseState *save = yypath;",
1255     "        yypath = save->save;",
1256     "        save->save = NULL;",
1257     "        yyFreeState(save);",
1258     "    }",
1259     "#endif /* YYBTYACC */",
1260 #endif                  /* defined(YYBTYACC) */
1261     "    yyfreestack(&yystack);",
1262     "    return (yyresult);",
1263     "}",
1264     0
1265 };
1266
1267 void
1268 write_section(FILE * fp, const char *const section[])
1269 {
1270     int i;
1271     const char *s;
1272
1273     for (i = 0; (s = section[i]) != 0; ++i)
1274     {
1275         if (fp == code_file)
1276             ++outline;
1277         fprintf(fp, "%s\n", s);
1278     }
1279 }