firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-22 20:43:02 +01:00
Code Issues
f0740d2a32
firebird-mirror/extern/btyacc/skeleton.c
dimitr 8332c5ed52 Added btyacc sources.
2006-04-19 09:53:27 +00:00

862 lines
27 KiB
C
Raw Blame History

/*
** This file generated automatically from
*/
#include "defs.h"
/* The banner used here should be replaced with an #ident directive */
/* if the target C compiler supports #ident directives. */
/* */
/* If the skeleton is changed, the banner should be changed so that */
/* the altered version can easily be distinguished from the original. */
char *banner[] =
{
"#line 8 \"btyaccpa.ske\"",
"",
"//",
"// @(#)btyaccpar, based on byacc 1.8 (Berkeley)",
"//",
"#define YYBTYACC 1",
"",
"#include <stdio.h>",
"#include <stdlib.h>",
"#include <string.h>",
"",
"typedef int Yshort;",
"",
0
};
char *tables[] =
{
"#line 21 \"btyaccpa.ske\"",
"",
"#define _C_ \"C\"",
"",
"extern _C_ Yshort yylhs[];",
"extern _C_ Yshort yylen[];",
"extern _C_ Yshort yydefred[];",
"extern _C_ Yshort yydgoto[];",
"extern _C_ Yshort yysindex[];",
"extern _C_ Yshort yyrindex[];",
"extern _C_ Yshort yycindex[];",
"extern _C_ Yshort yygindex[];",
"extern _C_ Yshort yytable[];",
"extern _C_ Yshort yycheck[];",
"extern _C_ Yshort yyctable[];",
"",
"#if YYDEBUG",
"extern _C_ char *yyname[];",
"extern _C_ char *yyrule[];",
"#endif",
"",
0
};
char *header[] =
{
"#line 42 \"btyaccpa.ske\"",
"",
"//",
"// YYPOSN is user-defined text position type.",
"//",
"#ifndef YYPOSN",
"#define YYPOSN int",
"#endif",
"",
"#ifdef YYREDUCEPOSNFUNC",
"#define YYCALLREDUCEPOSN(e) \\",
"\tif(reduce_posn) { \\",
"\t YYREDUCEPOSNFUNC(yyps->pos, &(yyps->psp)[1-yym], &(yyps->vsp)[1-yym], \\",
"\t\t\t yym, yyps->psp - yyps->ps, yychar, yyposn, e); \\",
"\t reduce_posn = 0; \\",
"\t}",
"",
"#ifndef YYCALLREDUCEPOSNARG",
"#define YYCALLREDUCEPOSNARG yyps->val",
"#endif",
"",
"",
"#define YYPOSNARG(n) ((yyps->psp)[1-yym+(n)-1])",
"#define YYPOSNOUT (yyps->pos)",
"#endif",
"",
"// If delete function is not defined by the user, do not deletions.",
"#ifndef YYDELETEVAL",
"#define YYDELETEVAL(v) ",
"#endif",
"",
"// If delete function is not defined by the user, do not deletions.",
"#ifndef YYDELETEPOSN",
"#define YYDELETEPOSN(v) ",
"#endif",
"",
"#define yyclearin (yychar=(-1))",
"",
"#define yyerrok (yyps->errflag=0)",
"",
"#ifndef YYSTACKGROWTH",
"#define YYSTACKGROWTH 16",
"#endif",
"",
"#ifndef YYDEFSTACKSIZE",
"#define YYDEFSTACKSIZE 12",
"#endif",
"",
"#ifdef YYDEBUG",
"int yydebug;",
"#endif",
"",
"int yynerrs;",
"",
"/* These value/posn are taken from the lexer */",
"YYSTYPE yylval;",
"YYPOSN yyposn;",
"",
"/* These value/posn of the root non-terminal are returned to the caller */",
"YYSTYPE yyretlval;",
"YYPOSN yyretposn;",
"",
"#define YYABORT goto yyabort",
"#define YYACCEPT goto yyaccept",
"#define YYERROR goto yyerrlab",
"#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)",
"",
"struct yyparsestate {",
" yyparsestate *save; // Previously saved parser state",
" int state;",
" int errflag;",
" Yshort *ssp; // state stack pointer",
" YYSTYPE *vsp; // value stack pointer",
" YYPOSN *psp; // position stack pointer",
" YYSTYPE val; // value as returned by actions",
" YYPOSN pos; // position as returned by universal action",
" Yshort *ss; // state stack base",
" YYSTYPE *vs; // values stack base",
" YYPOSN *ps; // position stack base",
" int lexeme; // index of the conflict lexeme in the lexical queue",
" unsigned int stacksize; // current maximum stack size",
" Yshort ctry; // index in yyctable[] for this conflict",
"};",
"",
"// 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 posistion 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;",
"",
"// Base of the lexical position queue",
"static YYPOSN *yylpsns=0;",
"",
"// Current posistion at lexical position queue",
"static YYPOSN *yylpp=0;",
"",
"// End position of lexical position queue",
"static YYPOSN *yylpe=0;",
"",
"// The last allocated position at the lexical position queue",
"static YYPOSN *yylplim=0;",
"",
"// Current position at lexical token queue",
"static Yshort *yylexp=0;",
"",
"static Yshort *yylexemes=0;",
"",
"//",
"// For use in generated program",
"//",
"#define yytrial (yyps->save)",
"#define yyvsp (yyps->vsp)",
"#define yyval (yyps->val)",
"#define yydepth (yyps->ssp - yyps->ss)",
"",
"",
"//",
"// Local prototypes.",
"//",
"int yyparse(void);",
"",
"int YYLex1();",
"int yyexpand();",
"void YYSCopy(YYSTYPE *to, YYSTYPE *from, int size);",
"void YYPCopy(YYPOSN *to, YYPOSN *from, int size);",
"void YYMoreStack(yyparsestate *yyps);",
"yyparsestate *YYNewState(int size);",
"void YYFreeState(yyparsestate *p);",
"",
"",
0
};
char *body[] =
{
"#line 186 \"btyaccpa.ske\"",
"",
"",
"//",
"// Parser function",
"//",
"int yyparse() {",
" int yym, yyn, yystate, yychar, yynewerrflag;",
" yyparsestate *yyerrctx = NULL;",
" int reduce_posn;",
"",
"#if YYDEBUG",
" char *yys;",
" ",
" if ((yys = getenv(\"YYDEBUG\"))) {",
" yyn = *yys;",
" if (yyn >= '0' && yyn <= '9')",
" yydebug = yyn - '0'; ",
" }",
"#endif",
" ",
" yyps = YYNewState(YYDEFSTACKSIZE);",
" yyps->save = 0;",
" yynerrs = 0;",
" yyps->errflag = 0;",
" yychar = (-1);",
" ",
" yyps->ssp = yyps->ss;",
" yyps->vsp = yyps->vs;",
" yyps->psp = yyps->ps;",
" *(yyps->ssp) = yystate = 0;",
" ",
"",
" //",
" // Main parsing loop",
" //",
" yyloop:",
" if ((yyn = yydefred[yystate])) {",
" goto yyreduce;",
" }",
"",
" //",
" // Read one token",
" //",
" if (yychar < 0) {",
" if ((yychar = YYLex1()) < 0) yychar = 0;",
"#if YYDEBUG",
" if (yydebug) {",
" yys = 0;",
" if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
" if (!yys) yys = \"illegal-symbol\";",
" printf(\"yydebug[%d,%d]: state %d, reading %d (%s)\", ",
"\t yydepth, (int)yytrial, yystate, yychar, yys);",
"#ifdef YYDBPR",
" printf(\"<\");",
" YYDBPR(yylval);",
" printf(\">\");",
"#endif",
" printf(\"\\n\"); ",
" }",
"#endif",
" }",
"",
" //",
" // Do we have a conflict?",
" //",
" if ((yyn = yycindex[yystate]) &&",
" (yyn += yychar) >= 0 &&",
" yyn <= YYTABLESIZE &&",
" yycheck[yyn] == yychar) {",
" int ctry;",
"",
" if (yypath) {",
"#if YYDEBUG",
" if (yydebug) {",
" printf(\"yydebug[%d,%d]: CONFLICT in state %d: following successful trial parse\\n\", ",
"\t yydepth, (int)yytrial, yystate);",
" }",
"#endif",
" // Switch to the next conflict context",
" yyparsestate *save = yypath;",
" yypath = save->save;",
" ctry = save->ctry;",
" if (save->state != yystate) ",
" goto yyabort;",
" YYFreeState(save); ",
"",
" } else {",
"",
"#if YYDEBUG",
" if (yydebug) {",
" printf(\"yydebug[%d,%d]: CONFLICT in state %d. \", ",
"\t yydepth, (int)yytrial, yystate);",
" if(yyps->save) {",
" printf(\"ALREADY in conflict. Continue trial parse.\");",
" } else {",
" printf(\"Start trial parse.\");",
" }",
" printf(\"\\n\");",
" }",
"#endif",
" yyparsestate *save = YYNewState(yyps->ssp - yyps->ss);",
" save->save = yyps->save;",
" save->state = yystate;",
" save->errflag = yyps->errflag;",
" save->ssp = save->ss + (yyps->ssp - yyps->ss);",
" save->vsp = save->vs + (yyps->vsp - yyps->vs);",
" save->psp = save->ps + (yyps->psp - yyps->ps);",
" memcpy (save->ss, yyps->ss, (yyps->ssp - yyps->ss + 1)*sizeof(Yshort));",
" YYSCopy(save->vs, yyps->vs, (yyps->ssp - yyps->ss + 1));",
" YYPCopy(save->ps, yyps->ps, (yyps->ssp - yyps->ss + 1));",
" ctry = yytable[yyn];",
" if (yyctable[ctry] == -1) {",
"#if YYDEBUG",
" if (yydebug && yychar >= 0)",
" printf(\"yydebug[%d]: backtracking 1 token\\n\", ",
"\t\t (int)yytrial);",
"#endif",
" ctry++; ",
" }",
" save->ctry = ctry;",
" if (!yyps->save) {",
" // If this is a first conflict in the stack, start saving lexemes",
" if (!yylexemes) {",
" yylexemes = new Yshort[YYSTACKGROWTH];",
" yylvals = new YYSTYPE[YYSTACKGROWTH];",
" yylvlim = yylvals + YYSTACKGROWTH; ",
" yylpsns = new YYPOSN[YYSTACKGROWTH];",
" yylplim = yylpsns + YYSTACKGROWTH; ",
" }",
" if (yylvp == yylve) {",
" yylvp = yylve = yylvals;",
"\t yylpp = yylpe = yylpsns;",
" yylexp = yylexemes;",
" if (yychar >= 0) {",
" *yylve++ = yylval;",
" *yylpe++ = yyposn;",
" *yylexp = yychar;",
" yychar = -1; ",
" } ",
" } ",
" }",
" if (yychar >= 0) {",
" yylvp--, yylpp--, yylexp--;",
" yychar = -1; ",
" }",
" save->lexeme = yylvp - yylvals;",
" yyps->save = save; ",
" }",
" if (yytable[yyn] == ctry) {",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: state %d, shifting to state %d\\n\",",
" yydepth, (int)yytrial, yystate, yyctable[ctry]);",
"#endif",
" if (yychar < 0)",
" yylvp++, yylpp++, yylexp++;",
" yychar = -1;",
" if (yyps->errflag > 0) --yyps->errflag;",
" yystate = yyctable[ctry];",
" goto yyshift; ",
" } else {",
" yyn = yyctable[ctry];",
" goto yyreduce; ",
" } ",
" }",
"",
" //",
" // Is action a shift?",
" //",
" if ((yyn = yysindex[yystate]) &&",
" (yyn += yychar) >= 0 &&",
" yyn <= YYTABLESIZE &&",
" yycheck[yyn] == yychar) {",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: state %d, shifting to state %d\\n\",",
" yydepth, (int)yytrial, yystate, yytable[yyn]);",
"#endif",
" yychar = (-1);",
" if (yyps->errflag > 0) --yyps->errflag;",
" yystate = yytable[yyn];",
" yyshift:",
" if (yyps->ssp >= yyps->ss + yyps->stacksize - 1) {",
" YYMoreStack(yyps);",
" }",
" *++(yyps->ssp) = yystate;",
" *++(yyps->vsp) = yylval;",
" *++(yyps->psp) = yyposn;",
" goto yyloop;",
" }",
" if ((yyn = yyrindex[yystate]) &&",
" (yyn += yychar) >= 0 &&",
" yyn <= YYTABLESIZE &&",
" yycheck[yyn] == yychar) {",
" yyn = yytable[yyn];",
" goto yyreduce;",
" }",
"",
" //",
" // Action: error",
" //",
" if (yyps->errflag) goto yyinrecovery;",
" yynewerrflag = 1;",
" goto yyerrhandler;",
"yyerrlab:",
" yynewerrflag = 0;",
"yyerrhandler:",
" while (yyps->save) { ",
" int ctry; ",
" yyparsestate *save = yyps->save;",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
" yydepth, (int)yytrial, yystate, yyps->save->state, 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(yyps->ssp - yyps->ss);",
" yyerrctx->save = yyps->save;",
" yyerrctx->state = yystate;",
" yyerrctx->errflag = yyps->errflag;",
" yyerrctx->ssp = yyerrctx->ss + (yyps->ssp - yyps->ss);",
" yyerrctx->vsp = yyerrctx->vs + (yyps->vsp - yyps->vs);",
" yyerrctx->psp = yyerrctx->ps + (yyps->psp - yyps->ps);",
" memcpy (yyerrctx->ss, yyps->ss, (yyps->ssp - yyps->ss + 1)*sizeof(Yshort));",
" YYSCopy(yyerrctx->vs, yyps->vs, (yyps->ssp - yyps->ss + 1));",
" YYPCopy(yyerrctx->ps, yyps->ps, (yyps->ssp - yyps->ss + 1));",
" yyerrctx->lexeme = yylvp - yylvals;",
" }",
" yylvp = yylvals + save->lexeme;",
" yylpp = yylpsns + save->lexeme;",
" yylexp = yylexemes + save->lexeme;",
" yychar = -1;",
" yyps->ssp = yyps->ss + (save->ssp - save->ss);",
" yyps->vsp = yyps->vs + (save->vsp - save->vs);",
" yyps->psp = yyps->ps + (save->psp - save->ps);",
" memcpy (yyps->ss, save->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
" YYSCopy(yyps->vs, save->vs, yyps->vsp - yyps->vs + 1);",
" YYPCopy(yyps->ps, save->ps, yyps->psp - yyps->ps + 1);",
" ctry = ++save->ctry;",
" yystate = save->state;",
" // We tried shift, try reduce now",
" if ((yyn = yyctable[ctry]) >= 0) {",
" goto yyreduce;",
" }",
" yyps->save = save->save;",
" YYFreeState(save);",
" //",
" // Nothing left on the stack -- error",
" //",
" if (!yyps->save) {",
"#if YYDEBUG",
" if (yydebug) {",
" printf(\"yydebug[%d]: trial parse FAILED, entering ERROR mode\\n\", ",
"\t (int)yytrial);",
" }",
"#endif",
" // Restore state as it was in the most forward-advanced error",
" yylvp = yylvals + yyerrctx->lexeme;",
" yylpp = yylpsns + yyerrctx->lexeme;",
" yylexp = yylexemes + yyerrctx->lexeme;",
" yychar = yylexp[-1];",
" yylval = yylvp[-1];",
" yyposn = yylpp[-1];",
" yyps->ssp = yyps->ss + (yyerrctx->ssp - yyerrctx->ss);",
" yyps->vsp = yyps->vs + (yyerrctx->vsp - yyerrctx->vs);",
" yyps->psp = yyps->ps + (yyerrctx->psp - yyerrctx->ps);",
" memcpy (yyps->ss, yyerrctx->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
" YYSCopy(yyps->vs, yyerrctx->vs, yyps->vsp - yyps->vs + 1);",
" YYPCopy(yyps->ps, yyerrctx->ps, yyps->psp - yyps->ps + 1);",
" yystate = yyerrctx->state;",
" YYFreeState(yyerrctx);",
" yyerrctx = NULL;",
" }",
" yynewerrflag = 1; ",
" }",
" if (yynewerrflag) {",
"#ifdef YYERROR_DETAILED",
" yyerror_detailed(\"syntax error\", yychar, yylval, yyposn);",
"#else",
" yyerror(\"syntax error\");",
"#endif",
" }",
" ++yynerrs;",
" yyinrecovery:",
" if (yyps->errflag < 3) {",
" yyps->errflag = 3;",
" for (;;) {",
" if ((yyn = yysindex[*(yyps->ssp)]) && ",
"\t (yyn += YYERRCODE) >= 0 &&",
" yyn <= YYTABLESIZE && ",
"\t yycheck[yyn] == YYERRCODE) {",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: state %d, ERROR recovery shifts to state %d\\n\",",
" yydepth, (int)yytrial, *(yyps->ssp), yytable[yyn]);",
"#endif",
" /* Use label yyerrlab, so that compiler does not warn */",
" if(yyps->errflag != yyps->errflag) goto yyerrlab;",
" yystate = yytable[yyn];",
" goto yyshift; ",
" } else {",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: ERROR recovery discards state %d\\n\",",
" yydepth, (int)yytrial, *(yyps->ssp));",
"#endif",
" if (yyps->ssp <= yyps->ss) {",
"\t goto yyabort;",
"\t}",
"\tif(!yytrial) {",
"\t YYDELETEVAL(yyps->vsp[0],1);",
"\t YYDELETEPOSN(yyps->psp[0],1);",
"\t}",
" --(yyps->ssp);",
" --(yyps->vsp);",
" --(yyps->psp);",
" }",
" }",
" } else {",
" if (yychar == 0) goto yyabort;",
"#if YYDEBUG",
" if (yydebug) {",
" yys = 0;",
" if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
" if (!yys) yys = \"illegal-symbol\";",
" printf(\"yydebug[%d,%d]: state %d, ERROR recovery discards token %d (%s)\\n\",",
" yydepth, (int)yytrial, yystate, yychar, yys); ",
" }",
"#endif",
" if(!yytrial) {",
" YYDELETEVAL(yylval,0);",
" YYDELETEPOSN(yyposn,0);",
" }",
" yychar = (-1);",
" goto yyloop;",
" }",
"",
" //",
" // Reduce the rule",
" //",
"yyreduce:",
" yym = yylen[yyn];",
"#if YYDEBUG",
" if (yydebug) {",
" printf(\"yydebug[%d,%d]: state %d, reducing by rule %d (%s)\",",
" yydepth, (int)yytrial, yystate, yyn, yyrule[yyn]);",
"#ifdef YYDBPR",
" if (yym) {",
" int i;",
" printf(\"<\");",
" for (i=yym; i>0; i--) {",
" if (i!=yym) printf(\", \");",
" YYDBPR((yyps->vsp)[1-i]);",
" }",
" printf(\">\");",
" }",
"#endif",
" printf(\"\\n\");",
" }",
"#endif",
" if (yyps->ssp + 1 - yym >= yyps->ss + yyps->stacksize) {",
" YYMoreStack(yyps);",
" }",
"",
" /* \"$$ = NULL\" default action */",
" memset(&yyps->val, 0, sizeof(yyps->val));",
"",
" /* default reduced position is NULL -- no position at all.",
" no position will be assigned at trial time and if no position handling is present */",
" memset(&yyps->pos, 0, sizeof(yyps->pos));",
"",
" reduce_posn = TRUE;",
"",
" switch (yyn) {",
"",
0
};
char *trailer[] =
{
"#line 567 \"btyaccpa.ske\"",
"",
" default:",
" break;",
" }",
"",
"#if YYDEBUG && defined(YYDBPR)",
" if (yydebug) {",
" printf(\"yydebug[%d]: after reduction, result is \", yytrial);",
" YYDBPR(yyps->val);",
" printf(\"\\n\");",
" }",
"#endif",
"",
" // Perform user-defined position reduction",
"#ifdef YYREDUCEPOSNFUNC",
" if(!yytrial) {",
" YYCALLREDUCEPOSN(YYREDUCEPOSNFUNCARG);",
" }",
"#endif",
"",
" yyps->ssp -= yym;",
" yystate = *(yyps->ssp);",
" yyps->vsp -= yym;",
" yyps->psp -= yym;",
"",
" yym = yylhs[yyn];",
" if (yystate == 0 && yym == 0) {",
"#if YYDEBUG",
" if (yydebug) {",
" printf(\"yydebug[%d,%d]: after reduction, shifting from state 0 to state %d\\n\", ",
"\t yydepth, (int)yytrial, YYFINAL);",
" }",
"#endif",
" yystate = YYFINAL;",
" *++(yyps->ssp) = YYFINAL;",
" *++(yyps->vsp) = yyps->val;",
" yyretlval = yyps->val;\t// return value of root non-terminal to yylval",
" *++(yyps->psp) = yyps->pos;",
" yyretposn = yyps->pos;\t// return value of root position to yyposn",
" if (yychar < 0) {",
" if ((yychar = YYLex1()) < 0) {",
" yychar = 0;",
" }",
"#if YYDEBUG",
" if (yydebug) {",
" yys = 0;",
" if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
" if (!yys) yys = \"illegal-symbol\";",
" printf(\"yydebug[%d,%d]: state %d, reading %d (%s)\\n\", ",
"\t yydepth, (int)yytrial, YYFINAL, yychar, yys); ",
" }",
"#endif",
" }",
" if (yychar == 0) goto yyaccept;",
" goto yyloop;",
" }",
"",
" if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
" yyn <= YYTABLESIZE && yycheck[yyn] == yystate) {",
" yystate = yytable[yyn];",
" } else {",
" yystate = yydgoto[yym];",
" }",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: after reduction, shifting from state %d to state %d\\n\",",
" yydepth, (int)yytrial, *(yyps->ssp), yystate);",
"#endif",
" if (yyps->ssp >= yyps->ss + yyps->stacksize - 1) {",
" YYMoreStack(yyps);",
" }",
" *++(yyps->ssp) = yystate;",
" *++(yyps->vsp) = yyps->val;",
" *++(yyps->psp) = yyps->pos;",
" goto yyloop;",
"",
"",
" //",
" // Reduction declares that this path is valid.",
" // Set yypath and do a full parse",
" //",
"yyvalid:",
" if (yypath) {",
" goto yyabort;",
" }",
" while (yyps->save) {",
" yyparsestate *save = yyps->save;",
" yyps->save = save->save;",
" save->save = yypath;",
" yypath = save;",
" }",
"#if YYDEBUG",
" if (yydebug)",
" printf(\"yydebug[%d,%d]: CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
" yydepth, (int)yytrial, yypath->state, yylvp - yylvals - yypath->lexeme);",
"#endif",
" if(yyerrctx) {",
" YYFreeState(yyerrctx); yyerrctx = NULL;",
" }",
" yychar = -1;",
" yyps->ssp = yyps->ss + (yypath->ssp - yypath->ss);",
" yyps->vsp = yyps->vs + (yypath->vsp - yypath->vs);",
" yyps->psp = yyps->ps + (yypath->psp - yypath->ps);",
" memcpy (yyps->ss, yypath->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
" YYSCopy(yyps->vs, yypath->vs, yyps->vsp - yyps->vs + 1);",
" YYPCopy(yyps->ps, yypath->ps, yyps->psp - yyps->ps + 1);",
" yylvp = yylvals + yypath->lexeme;",
" yylpp = yylpsns + yypath->lexeme;",
" yylexp = yylexemes + yypath->lexeme;",
" yystate = yypath->state;",
" goto yyloop;",
"",
"",
"yyabort:",
" if(yyerrctx) {",
" YYFreeState(yyerrctx); yyerrctx = NULL;",
" }",
"",
" YYSTYPE *pv;",
" for(pv=yyps->vs; pv<yyps->vsp; pv++) {",
" YYDELETEVAL(*pv,2);",
" }",
"",
" YYPOSN *pp;",
" for(pp=yyps->ps; pp<yyps->psp; pp++) {",
" YYDELETEPOSN(*pp,2);",
" }",
"",
" while (yyps) {",
" yyparsestate *save = yyps;",
" yyps = save->save;",
" YYFreeState(save);",
" }",
" while (yypath) {",
" yyparsestate *save = yypath;",
" yypath = save->save;",
" YYFreeState(save); ",
" }",
" return (1);",
"",
"",
"yyaccept:",
" if (yyps->save) goto yyvalid;",
" if(yyerrctx) {",
" YYFreeState(yyerrctx); yyerrctx = NULL;",
" }",
" while (yyps) {",
" yyparsestate *save = yyps;",
" yyps = save->save;",
" YYFreeState(save);",
" }",
" while (yypath) {",
" yyparsestate *save = yypath;",
" yypath = save->save;",
" YYFreeState(save); ",
" }",
" return (0);",
"}",
"",
"",
"int YYLex1() {",
" if(yylvp<yylve) {",
" yylval = *yylvp++;",
" yyposn = *yylpp++;",
" return *yylexp++;",
" } else {",
" if(yyps->save) {",
" if(yylvp==yylvlim) {",
"\tyyexpand();",
" }",
" *yylexp = yylex();",
" *yylvp++ = yylval;",
" yylve++;",
" *yylpp++ = yyposn;",
" yylpe++;",
" return *yylexp++;",
" } else {",
" return yylex();",
" }",
" }",
"}",
"",
"int yyexpand() {",
" int p = yylvp-yylvals;",
" int s = yylvlim-yylvals;",
" s += YYSTACKGROWTH;",
" { Yshort *tl = yylexemes; ",
" YYSTYPE *tv = yylvals;",
" YYPOSN *tp = yylpsns;",
" yylvals = new YYSTYPE[s];",
" yylpsns = new YYPOSN[s];",
" yylexemes = new Yshort[s];",
" memcpy(yylexemes, tl, (s-YYSTACKGROWTH)*sizeof(Yshort));",
" YYSCopy(yylvals, tv, s-YYSTACKGROWTH);",
" YYPCopy(yylpsns, tp, s-YYSTACKGROWTH);",
" delete[] tl;",
" delete[] tv;",
" delete[] tp;",
" }",
" yylvp = yylve = yylvals + p;",
" yylvlim = yylvals + s;",
" yylpp = yylpe = yylpsns + p;",
" yylplim = yylpsns + s;",
" yylexp = yylexemes + p;",
" return 0;",
"}",
"",
"void YYSCopy(YYSTYPE *to, YYSTYPE *from, int size) {",
" int i; ",
" for (i = size-1; i >= 0; i--) {",
" to[i] = from[i];",
" }",
"}",
"",
"void YYPCopy(YYPOSN *to, YYPOSN *from, int size) {",
" int i; ",
" for (i = size-1; i >= 0; i--) {",
" to[i] = from[i];",
" }",
"}",
"",
"void YYMoreStack(yyparsestate *yyps) {",
" int p = yyps->ssp - yyps->ss; ",
" Yshort *tss = yyps->ss;",
" YYSTYPE *tvs = yyps->vs;",
" YYPOSN *tps = yyps->ps;",
" yyps->ss = new Yshort [yyps->stacksize + YYSTACKGROWTH]; ",
" yyps->vs = new YYSTYPE[yyps->stacksize + YYSTACKGROWTH]; ",
" yyps->ps = new YYPOSN [yyps->stacksize + YYSTACKGROWTH]; ",
" memcpy(yyps->ss, tss, yyps->stacksize * sizeof(Yshort)); ",
" YYSCopy(yyps->vs, tvs, yyps->stacksize); ",
" YYPCopy(yyps->ps, tps, yyps->stacksize); ",
" yyps->stacksize += YYSTACKGROWTH; ",
" delete[] tss;",
" delete[] tvs;",
" delete[] tps;",
" yyps->ssp = yyps->ss + p; ",
" yyps->vsp = yyps->vs + p; ",
" yyps->psp = yyps->ps + p; ",
"}",
"",
"yyparsestate *YYNewState(int size) {",
" yyparsestate *p = new yyparsestate;",
" p->stacksize = size+4;",
" p->ss = new Yshort [size + 4];",
" p->vs = new YYSTYPE[size + 4];",
" p->ps = new YYPOSN [size + 4];",
" memset(&p->vs[0], 0, (size+4)*sizeof(YYSTYPE));",
" memset(&p->ps[0], 0, (size+4)*sizeof(YYPOSN));",
" return p;",
"}",
"",
"void YYFreeState(yyparsestate *p) {",
" delete[] p->ss;",
" delete[] p->vs;",
" delete[] p->ps;",
" delete p;",
"}",
0
};
struct section section_list[] = {
{ "banner", &banner[0] },
{ "tables", &tables[0] },
{ "header", &header[0] },
{ "body", &body[0] },
{ "trailer", &trailer[0] },
{ 0, 0 } };
View Git Blame Copy Permalink