text: /* This file generated automatically using
   * @Id: skel2c,v 1.3 2014/04/06 19:48:04 tom Exp @
   */
  
  /* @Id: btyaccpar.skel,v 1.1 2014/04/02 22:44:41 tom Exp @ */
  
  #include "defs.h"
  
  /*  If the skeleton is changed, the banner should be changed so that	*/
  /*  the altered version can be easily distinguished from the original.	*/
  /*									*/
  /*  The #defines included with the banner are there because they are	*/
  /*  useful in subsequent code.  The macros #defined in the header or	*/
  /*  the body either are not useful outside of semantic actions or	*/
  /*  are conditional.							*/
  
  const char *const banner[] =
  {
      "/* original parser id follows */",
      "/* yysccsid[] = \"@(#)yaccpar	1.9 (Berkeley) 02/21/93\" */",
      "/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */",
      "",
      "#define YYBYACC 1",
      CONCAT1("#define YYMAJOR ", YYMAJOR),
      CONCAT1("#define YYMINOR ", YYMINOR),
  #ifdef YYPATCH
      CONCAT1("#define YYPATCH ", YYPATCH),
  #endif
      "",
      "#define YYEMPTY        (-1)",
      "#define yyclearin      (yychar = YYEMPTY)",
      "#define yyerrok        (yyerrflag = 0)",
      "#define YYRECOVERING() (yyerrflag != 0)",
      "#define YYENOMEM       (-2)",
      "#define YYEOF          0",
      0
  };
  
  const char *const xdecls[] =
  {
      "",
      "extern int YYPARSE_DECL();",
      0
  };
  
  const char *const tables[] =
  {
      "extern const YYINT yylhs[];",
      "extern const YYINT yylen[];",
      "extern const YYINT yydefred[];",
      "extern const YYINT yystos[];",
      "extern const YYINT yydgoto[];",
      "extern const YYINT yysindex[];",
      "extern const YYINT yyrindex[];",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "extern const YYINT yycindex[];",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "extern const YYINT yygindex[];",
      "extern const YYINT yytable[];",
      "extern const YYINT yycheck[];",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "extern const YYINT yyctable[];",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "#if YYDEBUG",
      "extern const char *const yyname[];",
      "extern const char *const yyrule[];",
      "#endif",
      0
  };
  
  const char *const global_vars[] =
  {
      "",
      "int      yydebug;",
      "int      yynerrs;",
      0
  };
  
  const char *const impure_vars[] =
  {
      "",
      "int      yyerrflag;",
      "int      yychar;",
      "YYSTYPE  yyval;",
      "YYSTYPE  yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "YYLTYPE  yyloc; /* position returned by actions */",
      "YYLTYPE  yylloc; /* position from the lexer */",
      "#endif",
      0
  };
  
  const char *const hdr_defs[] =
  {
      "",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "#ifndef YYLLOC_DEFAULT",
      "#define YYLLOC_DEFAULT(loc, rhs, n) \\",
      "do \\",
      "{ \\",
      "    if (n == 0) \\",
      "    { \\",
      "        (loc).first_line   = ((rhs)[-1]).last_line; \\",
      "        (loc).first_column = ((rhs)[-1]).last_column; \\",
      "        (loc).last_line    = ((rhs)[-1]).last_line; \\",
      "        (loc).last_column  = ((rhs)[-1]).last_column; \\",
      "    } \\",
      "    else \\",
      "    { \\",
      "        (loc).first_line   = ((rhs)[ 0 ]).first_line; \\",
      "        (loc).first_column = ((rhs)[ 0 ]).first_column; \\",
      "        (loc).last_line    = ((rhs)[n-1]).last_line; \\",
      "        (loc).last_column  = ((rhs)[n-1]).last_column; \\",
      "    } \\",
      "} while (0)",
      "#endif /* YYLLOC_DEFAULT */",
      "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "#ifndef YYLVQUEUEGROWTH",
      "#define YYLVQUEUEGROWTH 32",
      "#endif",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "/* define the initial stack-sizes */",
      "#ifdef YYSTACKSIZE",
      "#undef YYMAXDEPTH",
      "#define YYMAXDEPTH  YYSTACKSIZE",
      "#else",
      "#ifdef YYMAXDEPTH",
      "#define YYSTACKSIZE YYMAXDEPTH",
      "#else",
      "#define YYSTACKSIZE 10000",
      "#define YYMAXDEPTH  10000",
      "#endif",
      "#endif",
      "",
      "#ifndef YYINITSTACKSIZE",
      "#define YYINITSTACKSIZE 200",
      "#endif",
      "",
      "typedef struct {",
      "    unsigned stacksize;",
      "    short    *s_base;",
      "    short    *s_mark;",
      "    short    *s_last;",
      "    YYSTYPE  *l_base;",
      "    YYSTYPE  *l_mark;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    YYLTYPE  *p_base;",
      "    YYLTYPE  *p_mark;",
      "#endif",
      "} YYSTACKDATA;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "struct YYParseState_s",
      "{",
      "    struct YYParseState_s *save;    /* Previously saved parser state */",
      "    YYSTACKDATA            yystack; /* saved parser stack */",
      "    int                    state;   /* saved parser state */",
      "    int                    errflag; /* saved error recovery status */",
      "    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */",
      "    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */",
      "};",
      "typedef struct YYParseState_s YYParseState;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      0
  };
  
  const char *const hdr_vars[] =
  {
      "/* variables for the parser stack */",
      "static YYSTACKDATA yystack;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "/* Current parser state */",
      "static YYParseState *yyps = 0;",
      "",
      "/* yypath != NULL: do the full parse, starting at *yypath parser state. */",
      "static YYParseState *yypath = 0;",
      "",
      "/* Base of the lexical value queue */",
      "static YYSTYPE *yylvals = 0;",
      "",
      "/* Current position at lexical value queue */",
      "static YYSTYPE *yylvp = 0;",
      "",
      "/* End position of lexical value queue */",
      "static YYSTYPE *yylve = 0;",
      "",
      "/* The last allocated position at the lexical value queue */",
      "static YYSTYPE *yylvlim = 0;",
      "",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "/* Base of the lexical position queue */",
      "static YYLTYPE *yylpsns = 0;",
      "",
      "/* Current position at lexical position queue */",
      "static YYLTYPE *yylpp = 0;",
      "",
      "/* End position of lexical position queue */",
      "static YYLTYPE *yylpe = 0;",
      "",
      "/* The last allocated position at the lexical position queue */",
      "static YYLTYPE *yylplim = 0;",
      "#endif",
      "",
      "/* Current position at lexical token queue */",
      "static short  *yylexp = 0;",
      "",
      "static short  *yylexemes = 0;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      0
  };
  
  const char *const body_vars[] =
  {
      "    int      yyerrflag;",
      "    int      yychar;",
      "    YYSTYPE  yyval;",
      "    YYSTYPE  yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    YYLTYPE  yyloc; /* position returned by actions */",
      "    YYLTYPE  yylloc; /* position from the lexer */",
      "#endif",
      "",
      "    /* variables for the parser stack */",
      "    YYSTACKDATA yystack;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "    /* Current parser state */",
      "    static YYParseState *yyps = 0;",
      "",
      "    /* yypath != NULL: do the full parse, starting at *yypath parser state. */",
      "    static YYParseState *yypath = 0;",
      "",
      "    /* Base of the lexical value queue */",
      "    static YYSTYPE *yylvals = 0;",
      "",
      "    /* Current position at lexical value queue */",
      "    static YYSTYPE *yylvp = 0;",
      "",
      "    /* End position of lexical value queue */",
      "    static YYSTYPE *yylve = 0;",
      "",
      "    /* The last allocated position at the lexical value queue */",
      "    static YYSTYPE *yylvlim = 0;",
      "",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    /* Base of the lexical position queue */",
      "    static YYLTYPE *yylpsns = 0;",
      "",
      "    /* Current position at lexical position queue */",
      "    static YYLTYPE *yylpp = 0;",
      "",
      "    /* End position of lexical position queue */",
      "    static YYLTYPE *yylpe = 0;",
      "",
      "    /* The last allocated position at the lexical position queue */",
      "    static YYLTYPE *yylplim = 0;",
      "#endif",
      "",
      "    /* Current position at lexical token queue */",
      "    static short  *yylexp = 0;",
      "",
      "    static short  *yylexemes = 0;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      0
  };
  
  const char *const body_1[] =
  {
      "",
      "/* For use in generated program */",
      "#define yydepth (int)(yystack.s_mark - yystack.s_base)",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "#define yytrial (yyps->save)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "#if YYDEBUG",
      "#include <stdio.h>         /* needed for printf */",
      "#endif",
      "",
      "#include <stdlib.h>        /* needed for malloc, etc */",
      "#include <string.h>        /* needed for memset */",
      "",
      "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
      "static int yygrowstack(YYSTACKDATA *data)",
      "{",
      "    int i;",
      "    unsigned newsize;",
      "    short *newss;",
      "    YYSTYPE *newvs;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    YYLTYPE *newps;",
      "#endif",
      "",
      "    if ((newsize = data->stacksize) == 0)",
      "        newsize = YYINITSTACKSIZE;",
      "    else if (newsize >= YYMAXDEPTH)",
      "        return YYENOMEM;",
      "    else if ((newsize *= 2) > YYMAXDEPTH)",
      "        newsize = YYMAXDEPTH;",
      "",
      "    i = (int) (data->s_mark - data->s_base);",
      "    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));",
      "    if (newss == 0)",
      "        return YYENOMEM;",
      "",
      "    data->s_base = newss;",
      "    data->s_mark = newss + i;",
      "",
      "    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
      "    if (newvs == 0)",
      "        return YYENOMEM;",
      "",
      "    data->l_base = newvs;",
      "    data->l_mark = newvs + i;",
      "",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));",
      "    if (newps == 0)",
      "        return YYENOMEM;",
      "",
      "    data->p_base = newps;",
      "    data->p_mark = newps + i;",
      "#endif",
      "",
      "    data->stacksize = newsize;",
      "    data->s_last = data->s_base + newsize - 1;",
      "",
      "#if YYDEBUG",
      "    if (yydebug)",
      "        fprintf(stderr, \"%sdebug: stack size increased to %d\\n\", YYPREFIX, newsize);",
      "#endif",
      "    return 0;",
      "}",
      "",
      "#if YYPURE || defined(YY_NO_LEAKS)",
      "static void yyfreestack(YYSTACKDATA *data)",
      "{",
      "    free(data->s_base);",
      "    free(data->l_base);",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    free(data->p_base);",
      "#endif",
      "    memset(data, 0, sizeof(*data));",
      "}",
      "#else",
      "#define yyfreestack(data) /* nothing */",
      "#endif /* YYPURE || defined(YY_NO_LEAKS) */",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "static YYParseState *",
      "yyNewState(unsigned size)",
      "{",
      "    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));",
      "    if (p == NULL) return NULL;",
      "",
      "    p->yystack.stacksize = size;",
      "    if (size == 0)",
      "    {",
      "        p->yystack.s_base = NULL;",
      "        p->yystack.l_base = NULL;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        p->yystack.p_base = NULL;",
      "#endif",
      "        return p;",
      "    }",
      "    p->yystack.s_base    = (short *) malloc(size * sizeof(short));",
      "    if (p->yystack.s_base == NULL) return NULL;",
      "    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));",
      "    if (p->yystack.l_base == NULL) return NULL;",
      "    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));",
      "    if (p->yystack.p_base == NULL) return NULL;",
      "    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));",
      "#endif",
      "",
      "    return p;",
      "}",
      "",
      "static void",
      "yyFreeState(YYParseState *p)",
      "{",
      "    yyfreestack(&p->yystack);",
      "    free(p);",
      "}",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "#define YYABORT  goto yyabort",
      "#define YYREJECT goto yyabort",
      "#define YYACCEPT goto yyaccept",
      "#define YYERROR  goto yyerrlab",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)",
      "#define YYVALID_NESTED do { if (yyps->save && \\",
      "                                yyps->save->save == 0) goto yyvalid; } while(0)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "int",
      "YYPARSE_DECL()",
      "{",
      0
  };
  
  const char *const body_2[] =
  {
      "    int yym, yyn, yystate, yyresult;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    int yynewerrflag;",
      "    YYParseState *yyerrctx = NULL;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */",
      "#endif",
      "#if YYDEBUG",
      "    const char *yys;",
      "",
      "    if ((yys = getenv(\"YYDEBUG\")) != 0)",
      "    {",
      "        yyn = *yys;",
      "        if (yyn >= '0' && yyn <= '9')",
      "            yydebug = yyn - '0';",
      "    }",
      "    if (yydebug)",
      "        fprintf(stderr, \"%sdebug[<# of symbols on state stack>]\\n\", YYPREFIX);",
      "#endif",
      "",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
      "    yyps->save = 0;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    yynerrs = 0;",
      "    yyerrflag = 0;",
      "    yychar = YYEMPTY;",
      "    yystate = 0;",
      "",
      "#if YYPURE",
      "    memset(&yystack, 0, sizeof(yystack));",
      "#endif",
      "",
      "    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
      "    yystack.s_mark = yystack.s_base;",
      "    yystack.l_mark = yystack.l_base;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    yystack.p_mark = yystack.p_base;",
      "#endif",
      "    yystate = 0;",
      "    *yystack.s_mark = 0;",
      "",
      "yyloop:",
      "    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
      "    if (yychar < 0)",
      "    {",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "        do {",
      "        if (yylvp < yylve)",
      "        {",
      "            /* we're currently re-reading tokens */",
      "            yylval = *yylvp++;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            yylloc = *yylpp++;",
      "#endif",
      "            yychar = *yylexp++;",
      "            break;",
      "        }",
      "        if (yyps->save)",
      "        {",
      "            /* in trial mode; save scanner results for future parse attempts */",
      "            if (yylvp == yylvlim)",
      "            {   /* Enlarge lexical value queue */",
      "                size_t p = (size_t) (yylvp - yylvals);",
      "                size_t s = (size_t) (yylvlim - yylvals);",
      "",
      "                s += YYLVQUEUEGROWTH;",
      "                if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;",
      "                if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;",
      "#endif",
      "                yylvp   = yylve = yylvals + p;",
      "                yylvlim = yylvals + s;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                yylpp   = yylpe = yylpsns + p;",
      "                yylplim = yylpsns + s;",
      "#endif",
      "                yylexp  = yylexemes + p;",
      "            }",
      "            *yylexp = (short) YYLEX;",
      "            *yylvp++ = yylval;",
      "            yylve++;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            *yylpp++ = yylloc;",
      "            yylpe++;",
      "#endif",
      "            yychar = *yylexp++;",
      "            break;",
      "        }",
      "        /* normal operation, no conflict encountered */",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "        yychar = YYLEX;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "        } while (0);",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "        if (yychar < 0) yychar = YYEOF;",
      "        /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
      "#if YYDEBUG",
      "        if (yydebug)",
      "        {",
      "            yys = yyname[YYTRANSLATE(yychar)];",
      "            fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\",",
      "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
      "#ifdef YYSTYPE_TOSTRING",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "            if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "                fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
      "#endif",
      "            fputc('\\n', stderr);",
      "        }",
      "#endif",
      "    }",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "    /* Do we have a conflict? */",
      "    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
      "        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
      "    {",
      "        YYINT ctry;",
      "",
      "        if (yypath)",
      "        {",
      "            YYParseState *save;",
      "#if YYDEBUG",
      "            if (yydebug)",
      "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d: following successful trial parse\\n\",",
      "                                YYDEBUGSTR, yydepth, yystate);",
      "#endif",
      "            /* Switch to the next conflict context */",
      "            save = yypath;",
      "            yypath = save->save;",
      "            save->save = NULL;",
      "            ctry = save->ctry;",
      "            if (save->state != yystate) YYABORT;",
      "            yyFreeState(save);",
      "",
      "        }",
      "        else",
      "        {",
      "",
      "            /* Unresolved conflict - start/continue trial parse */",
      "            YYParseState *save;",
      "#if YYDEBUG",
      "            if (yydebug)",
      "            {",
      "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d. \", YYDEBUGSTR, yydepth, yystate);",
      "                if (yyps->save)",
      "                    fputs(\"ALREADY in conflict, continuing trial parse.\\n\", stderr);",
      "                else",
      "                    fputs(\"Starting trial parse.\\n\", stderr);",
      "            }",
      "#endif",
      "            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
      "            if (save == NULL) goto yyenomem;",
      "            save->save            = yyps->save;",
      "            save->state           = yystate;",
      "            save->errflag         = yyerrflag;",
      "            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",
      "            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
      "            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",
      "            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",
      "            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
      "#endif",
      "            ctry                  = yytable[yyn];",
      "            if (yyctable[ctry] == -1)",
      "            {",
      "#if YYDEBUG",
      "                if (yydebug && yychar >= YYEOF)",
      "                    fprintf(stderr, \"%s[%d]: backtracking 1 token\\n\", YYDEBUGSTR, yydepth);",
      "#endif",
      "                ctry++;",
      "            }",
      "            save->ctry = ctry;",
      "            if (yyps->save == NULL)",
      "            {",
      "                /* If this is a first conflict in the stack, start saving lexemes */",
      "                if (!yylexemes)",
      "                {",
      "                    yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));",
      "                    if (yylexemes == NULL) goto yyenomem;",
      "                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));",
      "                    if (yylvals == NULL) goto yyenomem;",
      "                    yylvlim   = yylvals + YYLVQUEUEGROWTH;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));",
      "                    if (yylpsns == NULL) goto yyenomem;",
      "                    yylplim   = yylpsns + YYLVQUEUEGROWTH;",
      "#endif",
      "                }",
      "                if (yylvp == yylve)",
      "                {",
      "                    yylvp  = yylve = yylvals;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                    yylpp  = yylpe = yylpsns;",
      "#endif",
      "                    yylexp = yylexemes;",
      "                    if (yychar >= YYEOF)",
      "                    {",
      "                        *yylve++ = yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                        *yylpe++ = yylloc;",
      "#endif",
      "                        *yylexp  = (short) yychar;",
      "                        yychar   = YYEMPTY;",
      "                    }",
      "                }",
      "            }",
      "            if (yychar >= YYEOF)",
      "            {",
      "                yylvp--;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                yylpp--;",
      "#endif",
      "                yylexp--;",
      "                yychar = YYEMPTY;",
      "            }",
      "            save->lexeme = (int) (yylvp - yylvals);",
      "            yyps->save   = save;",
      "        }",
      "        if (yytable[yyn] == ctry)",
      "        {",
      "#if YYDEBUG",
      "            if (yydebug)",
      "                fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
      "                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);",
      "#endif",
      "            if (yychar < 0)",
      "            {",
      "                yylvp++;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                yylpp++;",
      "#endif",
      "                yylexp++;",
      "            }",
      "            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
      "                goto yyoverflow;",
      "            yystate = yyctable[ctry];",
      "            *++yystack.s_mark = (short) yystate;",
      "            *++yystack.l_mark = yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            *++yystack.p_mark = yylloc;",
      "#endif",
      "            yychar  = YYEMPTY;",
      "            if (yyerrflag > 0) --yyerrflag;",
      "            goto yyloop;",
      "        }",
      "        else",
      "        {",
      "            yyn = yyctable[ctry];",
      "            goto yyreduce;",
      "        }",
      "    } /* End of code dealing with conflicts */",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
      "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
      "    {",
      "#if YYDEBUG",
      "        if (yydebug)",
      "            fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
      "                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);",
      "#endif",
      "        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
      "        yystate = yytable[yyn];",
      "        *++yystack.s_mark = yytable[yyn];",
      "        *++yystack.l_mark = yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        *++yystack.p_mark = yylloc;",
      "#endif",
      "        yychar = YYEMPTY;",
      "        if (yyerrflag > 0)  --yyerrflag;",
      "        goto yyloop;",
      "    }",
      "    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
      "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
      "    {",
      "        yyn = yytable[yyn];",
      "        goto yyreduce;",
      "    }",
      "    if (yyerrflag != 0) goto yyinrecovery;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "    yynewerrflag = 1;",
      "    goto yyerrhandler;",
      "    goto yyerrlab;",
      "",
      "yyerrlab:",
      "    yynewerrflag = 0;",
      "yyerrhandler:",
      "    while (yyps->save)",
      "    {",
      "        int ctry;",
      "        YYParseState *save = yyps->save;",
      "#if YYDEBUG",
      "        if (yydebug)",
      "            fprintf(stderr, \"%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
      "                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,",
      "                    (int)(yylvp - yylvals - yyps->save->lexeme));",
      "#endif",
      "        /* Memorize most forward-looking error state in case it's really an error. */",
      "        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)",
      "        {",
      "            /* Free old saved error context state */",
      "            if (yyerrctx) yyFreeState(yyerrctx);",
      "            /* Create and fill out new saved error context state */",
      "            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
      "            if (yyerrctx == NULL) goto yyenomem;",
      "            yyerrctx->save           = yyps->save;",
      "            yyerrctx->state          = yystate;",
      "            yyerrctx->errflag        = yyerrflag;",
      "            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",
      "            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
      "            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",
      "            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",
      "            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
      "#endif",
      "            yyerrctx->lexeme         = (int) (yylvp - yylvals);",
      "        }",
      "        yylvp          = yylvals   + save->lexeme;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        yylpp          = yylpsns   + save->lexeme;",
      "#endif",
      "        yylexp         = yylexemes + save->lexeme;",
      "        yychar         = YYEMPTY;",
      "        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",
      "        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
      "        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",
      "        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",
      "        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
      "#endif",
      "        ctry           = ++save->ctry;",
      "        yystate        = save->state;",
      "        /* We tried shift, try reduce now */",
      "        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;",
      "        yyps->save     = save->save;",
      "        save->save     = NULL;",
      "        yyFreeState(save);",
      "",
      "        /* Nothing left on the stack -- error */",
      "        if (!yyps->save)",
      "        {",
      "#if YYDEBUG",
      "            if (yydebug)",
      "                fprintf(stderr, \"%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\\n\",",
      "                                YYPREFIX, yydepth);",
      "#endif",
      "            /* Restore state as it was in the most forward-advanced error */",
      "            yylvp          = yylvals   + yyerrctx->lexeme;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            yylpp          = yylpsns   + yyerrctx->lexeme;",
      "#endif",
      "            yylexp         = yylexemes + yyerrctx->lexeme;",
      "            yychar         = yylexp[-1];",
      "            yylval         = yylvp[-1];",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            yylloc         = yylpp[-1];",
      "#endif",
      "            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",
      "            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
      "            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",
      "            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",
      "            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
      "#endif",
      "            yystate        = yyerrctx->state;",
      "            yyFreeState(yyerrctx);",
      "            yyerrctx       = NULL;",
      "        }",
      "        yynewerrflag = 1;",
      "    }",
      "    if (yynewerrflag == 0) goto yyinrecovery;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "    YYERROR_CALL(\"syntax error\");",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */",
      "#endif",
      "",
      "#if !YYBTYACC",
      "    goto yyerrlab;",
      "yyerrlab:",
      "#endif",
      "    ++yynerrs;",
      "",
      "yyinrecovery:",
      "    if (yyerrflag < 3)",
      "    {",
      "        yyerrflag = 3;",
      "        for (;;)",
      "        {",
      "            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&",
      "                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)",
      "            {",
      "#if YYDEBUG",
      "                if (yydebug)",
      "                    fprintf(stderr, \"%s[%d]: state %d, error recovery shifting to state %d\\n\",",
      "                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);",
      "#endif",
      "                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
      "                yystate = yytable[yyn];",
      "                *++yystack.s_mark = yytable[yyn];",
      "                *++yystack.l_mark = yylval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                /* lookahead position is error end position */",
      "                yyerror_loc_range[1] = yylloc;",
      "                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */",
      "                *++yystack.p_mark = yyloc;",
      "#endif",
      "                goto yyloop;",
      "            }",
      "            else",
      "            {",
      "#if YYDEBUG",
      "                if (yydebug)",
      "                    fprintf(stderr, \"%s[%d]: error recovery discarding state %d\\n\",",
      "                                    YYDEBUGSTR, yydepth, *yystack.s_mark);",
      "#endif",
      "                if (yystack.s_mark <= yystack.s_base) goto yyabort;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                /* the current TOS position is the error start position */",
      "                yyerror_loc_range[0] = *yystack.p_mark;",
      "#endif",
      "#if defined(YYDESTRUCT_CALL)",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "                if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                    YYDESTRUCT_CALL(\"error: discarding state\",",
      "                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
      "#else",
      "                    YYDESTRUCT_CALL(\"error: discarding state\",",
      "                                    yystos[*yystack.s_mark], yystack.l_mark);",
      "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
      "#endif /* defined(YYDESTRUCT_CALL) */",
      "                --yystack.s_mark;",
      "                --yystack.l_mark;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                --yystack.p_mark;",
      "#endif",
      "            }",
      "        }",
      "    }",
      "    else",
      "    {",
      "        if (yychar == YYEOF) goto yyabort;",
      "#if YYDEBUG",
      "        if (yydebug)",
      "        {",
      "            yys = yyname[YYTRANSLATE(yychar)];",
      "            fprintf(stderr, \"%s[%d]: state %d, error recovery discarding token %d (%s)\\n\",",
      "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
      "        }",
      "#endif",
      "#if defined(YYDESTRUCT_CALL)",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "        if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
      "#else",
      "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval);",
      "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
      "#endif /* defined(YYDESTRUCT_CALL) */",
      "        yychar = YYEMPTY;",
      "        goto yyloop;",
      "    }",
      "",
      "yyreduce:",
      "    yym = yylen[yyn];",
      "#if YYDEBUG",
      "    if (yydebug)",
      "    {",
      "        fprintf(stderr, \"%s[%d]: state %d, reducing by rule %d (%s)\",",
      "                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);",
      "#ifdef YYSTYPE_TOSTRING",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "        if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "            if (yym > 0)",
      "            {",
      "                int i;",
      "                fputc('<', stderr);",
      "                for (i = yym; i > 0; i--)",
      "                {",
      "                    if (i != yym) fputs(\", \", stderr);",
      "                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],",
      "                                           yystack.l_mark[1-i]), stderr);",
      "                }",
      "                fputc('>', stderr);",
      "            }",
      "#endif",
      "        fputc('\\n', stderr);",
      "    }",
      "#endif",
      "    if (yym > 0)",
      "        yyval = yystack.l_mark[1-yym];",
      "    else",
      "        memset(&yyval, 0, sizeof yyval);",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "",
      "    /* Perform position reduction */",
      "    memset(&yyloc, 0, sizeof(yyloc));",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    {",
      "        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);",
      "        /* just in case YYERROR is invoked within the action, save",
      "           the start of the rhs as the error start position */",
      "        yyerror_loc_range[0] = yystack.p_mark[1-yym];",
      "    }",
      "#endif",
      "",
      "    switch (yyn)",
      "    {",
      0
  };
  
  const char *const trailer[] =
  {
      "    default:",
      "        break;",
      "    }",
      "    yystack.s_mark -= yym;",
      "    yystate = *yystack.s_mark;",
      "    yystack.l_mark -= yym;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    yystack.p_mark -= yym;",
      "#endif",
      "    yym = yylhs[yyn];",
      "    if (yystate == 0 && yym == 0)",
      "    {",
      "#if YYDEBUG",
      "        if (yydebug)",
      "        {",
      "            fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
      "#ifdef YYSTYPE_TOSTRING",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "            if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "                fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
      "#endif",
      "            fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
      "        }",
      "#endif",
      "        yystate = YYFINAL;",
      "        *++yystack.s_mark = YYFINAL;",
      "        *++yystack.l_mark = yyval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        *++yystack.p_mark = yyloc;",
      "#endif",
      "        if (yychar < 0)",
      "        {",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "            do {",
      "            if (yylvp < yylve)",
      "            {",
      "                /* we're currently re-reading tokens */",
      "                yylval = *yylvp++;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                yylloc = *yylpp++;",
      "#endif",
      "                yychar = *yylexp++;",
      "                break;",
      "            }",
      "            if (yyps->save)",
      "            {",
      "                /* in trial mode; save scanner results for future parse attempts */",
      "                if (yylvp == yylvlim)",
      "                {   /* Enlarge lexical value queue */",
      "                    size_t p = (size_t) (yylvp - yylvals);",
      "                    size_t s = (size_t) (yylvlim - yylvals);",
      "",
      "                    s += YYLVQUEUEGROWTH;",
      "                    if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)",
      "                        goto yyenomem;",
      "                    if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)",
      "                        goto yyenomem;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                    if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)",
      "                        goto yyenomem;",
      "#endif",
      "                    yylvp   = yylve = yylvals + p;",
      "                    yylvlim = yylvals + s;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                    yylpp   = yylpe = yylpsns + p;",
      "                    yylplim = yylpsns + s;",
      "#endif",
      "                    yylexp  = yylexemes + p;",
      "                }",
      "                *yylexp = (short) YYLEX;",
      "                *yylvp++ = yylval;",
      "                yylve++;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "                *yylpp++ = yylloc;",
      "                yylpe++;",
      "#endif",
      "                yychar = *yylexp++;",
      "                break;",
      "            }",
      "            /* normal operation, no conflict encountered */",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "            yychar = YYLEX;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "            } while (0);",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "            if (yychar < 0) yychar = YYEOF;",
      "            /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */",
      "#if YYDEBUG",
      "            if (yydebug)",
      "            {",
      "                yys = yyname[YYTRANSLATE(yychar)];",
      "                fprintf(stderr, \"%s[%d]: state %d, reading %d (%s)\\n\",",
      "                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);",
      "            }",
      "#endif",
      "        }",
      "        if (yychar == YYEOF) goto yyaccept;",
      "        goto yyloop;",
      "    }",
      "    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&",
      "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)",
      "        yystate = yytable[yyn];",
      "    else",
      "        yystate = yydgoto[yym];",
      "#if YYDEBUG",
      "    if (yydebug)",
      "    {",
      "        fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
      "#ifdef YYSTYPE_TOSTRING",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "        if (!yytrial)",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "            fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
      "#endif",
      "        fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
      "    }",
      "#endif",
      "    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
      "    *++yystack.s_mark = (short) yystate;",
      "    *++yystack.l_mark = yyval;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    *++yystack.p_mark = yyloc;",
      "#endif",
      "    goto yyloop;",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "",
      "    /* Reduction declares that this path is valid. Set yypath and do a full parse */",
      "yyvalid:",
      "    if (yypath) YYABORT;",
      "    while (yyps->save)",
      "    {",
      "        YYParseState *save = yyps->save;",
      "        yyps->save = save->save;",
      "        save->save = yypath;",
      "        yypath = save;",
      "    }",
      "#if YYDEBUG",
      "    if (yydebug)",
      "        fprintf(stderr, \"%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
      "                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));",
      "#endif",
      "    if (yyerrctx)",
      "    {",
      "        yyFreeState(yyerrctx);",
      "        yyerrctx = NULL;",
      "    }",
      "    yylvp          = yylvals + yypath->lexeme;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    yylpp          = yylpsns + yypath->lexeme;",
      "#endif",
      "    yylexp         = yylexemes + yypath->lexeme;",
      "    yychar         = YYEMPTY;",
      "    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",
      "    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));",
      "    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",
      "    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",
      "    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
      "#endif",
      "    yystate        = yypath->state;",
      "    goto yyloop;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "",
      "yyoverflow:",
      "    YYERROR_CALL(\"yacc stack overflow\");",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    goto yyabort_nomem;",
      "yyenomem:",
      "    YYERROR_CALL(\"memory exhausted\");",
      "yyabort_nomem:",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    yyresult = 2;",
      "    goto yyreturn;",
      "",
      "yyabort:",
      "    yyresult = 1;",
      "    goto yyreturn;",
      "",
      "yyaccept:",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    if (yyps->save) goto yyvalid;",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    yyresult = 0;",
      "",
      "yyreturn:",
      "#if defined(YYDESTRUCT_CALL)",
      "    if (yychar != YYEOF && yychar != YYEMPTY)",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval, &yylloc);",
      "#else",
      "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval);",
      "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
      "",
      "    {",
      "        YYSTYPE *pv;",
      "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
      "        YYLTYPE *pp;",
      "",
      "        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)",
      "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
      "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);",
      "#else",
      "        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)",
      "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
      "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);",
      "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
      "    }",
      "#endif /* defined(YYDESTRUCT_CALL) */",
      "",
  #if defined(YYBTYACC)
      "#if YYBTYACC",
      "    if (yyerrctx)",
      "    {",
      "        yyFreeState(yyerrctx);",
      "        yyerrctx = NULL;",
      "    }",
      "    while (yyps)",
      "    {",
      "        YYParseState *save = yyps;",
      "        yyps = save->save;",
      "        save->save = NULL;",
      "        yyFreeState(save);",
      "    }",
      "    while (yypath)",
      "    {",
      "        YYParseState *save = yypath;",
      "        yypath = save->save;",
      "        save->save = NULL;",
      "        yyFreeState(save);",
      "    }",
      "#endif /* YYBTYACC */",
  #endif			/* defined(YYBTYACC) */
      "    yyfreestack(&yystack);",
      "    return (yyresult);",
      "}",
      0
  };
  
  void
  write_section(FILE * fp, const char *const section[])
  {
      int i;
      const char *s;
  
      for (i = 0; (s = section[i]) != 0; ++i)
      {
  	if (fp == code_file)
  	    ++outline;
  	fprintf(fp, "%s\n", s);
      }
  }
  