1285 lines
47 KiB
C
1285 lines
47 KiB
C
/* This file generated automatically using
|
|
* @Id: skel2c,v 1.4 2016/06/07 00:26:09 tom Exp @
|
|
*/
|
|
|
|
/* @Id: btyaccpar.skel,v 1.10 2018/05/25 01:03:46 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 || defined(yytname)",
|
|
"extern const char *const yyname[];",
|
|
"#endif",
|
|
"#if YYDEBUG",
|
|
"extern const char *const yyrule[];",
|
|
"#endif",
|
|
0
|
|
};
|
|
|
|
const char *const global_vars[] =
|
|
{
|
|
"",
|
|
"#if YYDEBUG",
|
|
"int yydebug;",
|
|
"#endif",
|
|
0
|
|
};
|
|
|
|
const char *const impure_vars[] =
|
|
{
|
|
"",
|
|
"int yyerrflag;",
|
|
"int yychar;",
|
|
"YYSTYPE yyval;",
|
|
"YYSTYPE yylval;",
|
|
"int yynerrs;",
|
|
"",
|
|
"#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 = YYRHSLOC(rhs, 0).last_line; \\",
|
|
" (loc).first_column = YYRHSLOC(rhs, 0).last_column; \\",
|
|
" (loc).last_line = YYRHSLOC(rhs, 0).last_line; \\",
|
|
" (loc).last_column = YYRHSLOC(rhs, 0).last_column; \\",
|
|
" } \\",
|
|
" else \\",
|
|
" { \\",
|
|
" (loc).first_line = YYRHSLOC(rhs, 1).first_line; \\",
|
|
" (loc).first_column = YYRHSLOC(rhs, 1).first_column; \\",
|
|
" (loc).last_line = YYRHSLOC(rhs, n).last_line; \\",
|
|
" (loc).last_column = YYRHSLOC(rhs, n).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;",
|
|
" YYINT *s_base;",
|
|
" YYINT *s_mark;",
|
|
" YYINT *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 YYINT *yylexp = 0;",
|
|
"",
|
|
"static YYINT *yylexemes = 0;",
|
|
"#endif /* YYBTYACC */",
|
|
#endif /* defined(YYBTYACC) */
|
|
0
|
|
};
|
|
|
|
const char *const body_vars[] =
|
|
{
|
|
" int yyerrflag;",
|
|
" int yychar;",
|
|
" YYSTYPE yyval;",
|
|
" YYSTYPE yylval;",
|
|
" int yynerrs;",
|
|
"",
|
|
"#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 YYINT *yylexp = 0;",
|
|
"",
|
|
" static YYINT *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;",
|
|
" YYINT *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 = (YYINT *)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 = (YYINT *) malloc(size * sizeof(YYINT));",
|
|
" 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[3]; /* position of error start/end (0 unused) */",
|
|
"#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(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
|
" memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));",
|
|
"#endif",
|
|
"",
|
|
0
|
|
};
|
|
|
|
const char *const init_vars[] =
|
|
{
|
|
" yyerrflag = 0;",
|
|
" yychar = 0;",
|
|
" memset(&yyval, 0, sizeof(yyval));",
|
|
" memset(&yylval, 0, sizeof(yylval));",
|
|
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
|
" memset(&yyloc, 0, sizeof(yyloc));",
|
|
" memset(&yylloc, 0, sizeof(yylloc));",
|
|
"#endif",
|
|
"",
|
|
0
|
|
};
|
|
|
|
const char *const body_3[] =
|
|
{
|
|
#if defined(YYBTYACC)
|
|
"#if YYBTYACC",
|
|
" yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
|
|
" yyps->save = 0;",
|
|
"#endif /* YYBTYACC */",
|
|
#endif /* defined(YYBTYACC) */
|
|
" yym = 0;",
|
|
" yyn = 0;",
|
|
" 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 = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == 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 = (YYINT) 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 YYDEBUG",
|
|
" if (yydebug)",
|
|
" {",
|
|
" if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
|
|
" 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(YYINT));",
|
|
" 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 = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));",
|
|
" 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 = (YYINT) 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 = (YYINT) 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; /* redundant goto avoids 'unused label' warning */",
|
|
"",
|
|
"yyerrlab:",
|
|
" /* explicit YYERROR from an action -- pop the rhs of the rule reduced",
|
|
" * before looking for error recovery */",
|
|
" yystack.s_mark -= yym;",
|
|
" yystate = *yystack.s_mark;",
|
|
" yystack.l_mark -= yym;",
|
|
"#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
|
|
" yystack.p_mark -= yym;",
|
|
"#endif",
|
|
"",
|
|
" 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(YYINT));",
|
|
" 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(YYINT));",
|
|
" 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(YYINT));",
|
|
" 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[1] = yylloc; /* lookahead position is error start position */",
|
|
"#endif",
|
|
"",
|
|
"#if !YYBTYACC",
|
|
" goto yyerrlab; /* redundant goto avoids 'unused label' warning */",
|
|
"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[2] = 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[1] = *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)",
|
|
" {",
|
|
" if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
|
|
" 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[-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[1] = 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 = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == 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 = (YYINT) 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 YYDEBUG",
|
|
" if (yydebug)",
|
|
" {",
|
|
" if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
|
|
" fprintf(stderr, \"%s[%d]: state %d, reading token %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 = (YYINT) 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(YYINT));",
|
|
" 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);
|
|
}
|
|
}
|