summaryrefslogtreecommitdiffstats
path: root/contrib/byacc/btyaccpar.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/byacc/btyaccpar.c')
-rw-r--r--contrib/byacc/btyaccpar.c1246
1 files changed, 1246 insertions, 0 deletions
diff --git a/contrib/byacc/btyaccpar.c b/contrib/byacc/btyaccpar.c
new file mode 100644
index 0000000..f9c6216
--- /dev/null
+++ b/contrib/byacc/btyaccpar.c
@@ -0,0 +1,1246 @@
+/* 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 on 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 */",
+ " int p = yylvp - yylvals;",
+ " int s = 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, (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, (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, (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 = 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, (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, (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, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
+ "#endif",
+ " yyerrctx->lexeme = 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, (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, (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, (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, (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, (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, (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 */",
+ " int p = yylvp - yylvals;",
+ " int s = 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, (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, (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, (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);
+ }
+}
OpenPOWER on IntegriCloud