From fc5d487de27aa7aa17502008c848d06758223888 Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Thu, 12 Jan 2012 03:14:17 +1000 Subject: Switch to the lemon parser. --- LuaSL/src/btyacc-c.ske | 939 ------------------------------------------------- 1 file changed, 939 deletions(-) delete mode 100644 LuaSL/src/btyacc-c.ske (limited to 'LuaSL/src/btyacc-c.ske') diff --git a/LuaSL/src/btyacc-c.ske b/LuaSL/src/btyacc-c.ske deleted file mode 100644 index 399a25c..0000000 --- a/LuaSL/src/btyacc-c.ske +++ /dev/null @@ -1,939 +0,0 @@ -/* -*- C -*- - - 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. */ - -%% banner -/* -*- C -*- - - @(#)btyaccpar, based on byacc 1.8 (Berkeley), modified for rentrant flex. - -*/ -#define YYBTYACC 1 - -#include -#include -#include - -typedef int Yshort; - -%% tables - -#ifndef _YACC_EXTERN_ -# define _YACC_EXTERN_ "C" -#endif - -extern _YACC_EXTERN_ Yshort yylhs[]; -extern _YACC_EXTERN_ Yshort yylen[]; - -/* idx: current state; entry: non-zero if to reduce regardless of lookahead*/ -extern _YACC_EXTERN_ Yshort yydefred[]; - -extern _YACC_EXTERN_ Yshort yydgoto[]; - -/* idx: current state; entry: non-zero if shifting|reducing possible - in this state - in that case, yycheck[entry + lookahead] indicates - whether to perform the action for this lookahead. */ -extern _YACC_EXTERN_ Yshort yysindex[]; -extern _YACC_EXTERN_ Yshort yyrindex[]; - -/* yycindex idx: current state; entry: non-zero if shift/reduce - conflicts for this state - in that case, yycheck[entry + lookahead] - indicates whether there's a conflict for this lookahead */ -extern _YACC_EXTERN_ Yshort yycindex[]; -extern _YACC_EXTERN_ Yshort yycheck[]; - -extern _YACC_EXTERN_ Yshort yygindex[]; -extern _YACC_EXTERN_ Yshort yytable[]; -extern _YACC_EXTERN_ Yshort yyctable[]; - -#if YYDEBUG -/* idx: token code; entry: spelling of token */ -extern _YACC_EXTERN_ char *yyname[]; - -extern _YACC_EXTERN_ char *yyrule[]; -#endif - -%% header - -/* YYPOSN is user-defined text position type. */ -#ifndef YYPOSN -# define YYPOSN int -#endif - -#ifdef YYREDUCEPOSNFUNC -# define YYCALLREDUCEPOSN(e) \ - if(reduce_posn) { \ - YYREDUCEPOSNFUNC(yyps->pos, &(yyps->psp)[1-yym], &(yyps->vsp)[1-yym],\ - yym, yyps->psp - yyps->ps, yychar, yyposn, e); \ - reduce_posn = 0; \ - } - -# 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 delete. */ -#ifndef YYDELETEVAL -# define YYDELETEVAL(v, t) -#endif - -/* If delete function is not defined by the user, do not delete. */ -#ifndef YYDELETEPOSN -# define YYDELETEPOSN(v, t) -#endif - -#define YYEMPTY (-1) -#define yyclearin (yychar=YYEMPTY) - -#define yyerrok (yyps->errflag=0) - -#ifndef YYSTACKGROWTH -# define YYSTACKGROWTH 32 -#endif - -#ifndef YYDEFSTACKSIZE -# define YYDEFSTACKSIZE 12 -#endif - -#ifdef YYDEBUG -int yydebug = 0; -#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_s { - struct YYParseState_s *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 conflict lexeme in lexical queue */ - unsigned int stacksize; /* current maximum stack size */ - Yshort ctry; /* index in yyctable[] for this conflict */ -}; -typedef struct YYParseState_s YYParseState; - -/* 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; - -/* Base of the lexical position queue */ -static YYPOSN *yylpsns = 0; - -/* Current position 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 *YYPARSE_PARAM); - -static int yyLex1(YYSTYPE *yylval, yyscan_t scanner); -static int yyExpand(); -static void yySCopy(YYSTYPE *to, YYSTYPE *from, int size); -static void yyPCopy(YYPOSN *to, YYPOSN *from, int size); -static void yyMoreStack(YYParseState *yyps); -static YYParseState *yyNewState(int size); -static void yyFreeState(YYParseState *p); - - -%% body - - -/* Parser function. Roughly looks like this: - int yyparse(void *YYPARSE_PARAM) { - yyloop: - if (reduce_possible) goto yyreduce; - read_token; - if (conflict) { - handle_conflict; - goto yyshift; or goto yyreduce; - } - if (shift_possible) { - yyshift: - do_shift; - goto yyloop; - } - if (reduce_possible) goto yyreduce; - - (error handling); - goto yyloop; - - yyreduce: - BIG_CHUNK_OF_RULE_ACTIONS; - goto yyloop; - - (more error handling); - }*/ -int yyparse(void *YYPARSE_PARAM) { - int yym, yyn, yystate, yychar, yynewerrflag; - YYParseState *yyerrctx = 0; - int reduce_posn; - -# if YYDEBUG - char *yys; - - if ((yys = getenv("YYDEBUG"))) { - yyn = *yys; - if (yyn >= '0' && yyn <= '9') - yydebug = yyn - '0'; - } - if (yydebug) { - fputs("btyacc[,]\n", - stderr); - } -# endif - - yyps = yyNewState(YYDEFSTACKSIZE); - yyps->save = 0; - yynerrs = 0; - yyps->errflag = 0; - yychar = (YYEMPTY); - - 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) { - yychar = yyLex1(&yylval, YYLEX_PARAM); - if (yychar < 0) yychar = 0; -# if YYDEBUG - if (yydebug) { - yys = 0; - if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; - if (!yys) yys = "illegal-symbol"; - fprintf(stderr, "btyacc[%3d,%2d%s]: read token %d (%s)", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), yychar, yys); -# ifdef YYDBPR - fputc('<', stderr); - YYDBPR(yylval); - fputc('>', stderr); -# endif - fputc('\n', stderr); - } -# endif - } - - /* Do we have a conflict? */ - yyn = yycindex[yystate]; - if (yyn != 0 && (yyn += yychar) >= 0 - && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { - int ctry; - - if (yypath) { - YYParseState *save; -# if YYDEBUG - if (yydebug) { - fprintf(stderr, "btyacc[%3d,%2d%s]: CONFLICT: following successful " - "trial parse\n", yystate, (int) yydepth, (yytrial ? ",trial" :"")); - } -# endif - /* Switch to the next conflict context */ - save = yypath; - yypath = save->save; - ctry = save->ctry; - if (save->state != yystate) - goto yyabort; - yyFreeState(save); - - } else { - - /* Unresolved conflict - start/continue trial parse */ - YYParseState *save; -# if YYDEBUG - if (yydebug) { - fprintf(stderr, "btyacc[%3d,%2d%s]: CONFLICT. ", - yystate, (int) yydepth, (yytrial ? ",trial" : "")); - if(yyps->save) - fputs("ALREADY in conflict, continuing trial parse.\n", stderr); - else - fputs("starting trial parse.\n", stderr); - } -# endif - 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) - fputs("btyacc[trial]: backtracking 1 token\n", stderr); -# endif - ctry++; - } - save->ctry = ctry; - if (yyps->save == 0) { - /* If this is a first conflict in the stack, start saving lexemes */ - if (!yylexemes) { -# ifdef __cplusplus - yylexemes = new Yshort[YYSTACKGROWTH]; - yylvals = new YYSTYPE[YYSTACKGROWTH]; - yylvlim = yylvals + YYSTACKGROWTH; - yylpsns = new YYPOSN[YYSTACKGROWTH]; - yylplim = yylpsns + YYSTACKGROWTH; -# else - yylexemes = (Yshort*)malloc((YYSTACKGROWTH) * sizeof(Yshort)); - yylvals = (YYSTYPE*)malloc((YYSTACKGROWTH) * sizeof(YYSTYPE)); - yylvlim = yylvals + YYSTACKGROWTH; - yylpsns = (YYPOSN*)malloc((YYSTACKGROWTH) * sizeof(YYPOSN)); - yylplim = yylpsns + YYSTACKGROWTH; -# endif - } - if (yylvp == yylve) { - yylvp = yylve = yylvals; - yylpp = yylpe = yylpsns; - yylexp = yylexemes; - if (yychar >= 0) { - *yylve++ = yylval; - *yylpe++ = yyposn; - *yylexp = yychar; - yychar = YYEMPTY; - } - } - } - if (yychar >= 0) { - yylvp--, yylpp--, yylexp--; - yychar = YYEMPTY; - } - save->lexeme = yylvp - yylvals; - yyps->save = save; - } - - if (yytable[yyn] == ctry) { -# if YYDEBUG - if (yydebug) - fprintf(stderr, "btyacc[%3d,%2d%s]: shifting to state %d\n", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), yyctable[ctry]); -# endif - if (yychar < 0) { - yylvp++; yylpp++; yylexp++; - } - yychar = YYEMPTY; - if (yyps->errflag > 0) --yyps->errflag; - yystate = yyctable[ctry]; - goto yyshift; - } else { - yyn = yyctable[ctry]; - goto yyreduce; - } - } /* End of code dealing with conflicts */ - - - /* Is action a shift? */ - yyn = yysindex[yystate]; - if (yyn != 0 && (yyn += yychar) >= 0 - && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { -# if YYDEBUG - if (yydebug) - fprintf(stderr, "btyacc[%3d,%2d%s]: shifting to state %d\n", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), yytable[yyn]); -# endif - yychar = YYEMPTY; - 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; - } - - /* According to the tables, neither shift nor reduce is OK here - 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) - fprintf(stderr, "btyacc[%3d,%2d%s]: ERROR, " - "CONFLICT BACKTRACKING to state %d, %d tokens\n", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), - 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==0 || yyerrctx->lexemessp - 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 = YYEMPTY; - 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) { - fputs("btyacc[trial]: trial parse FAILED, entering ERROR mode\n", - stderr); - } -# 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 = 0; - } - yynewerrflag = 1; - } - if (yynewerrflag) { -# ifdef YYERROR_DETAILED - yyerror_detailed("parse error", yychar, yylval, yyposn); -# else - yyerror("parse error"); -# endif - } - ++yynerrs; - yyinrecovery: - if (yyps->errflag < 3) { - yyps->errflag = 3; - for (;;) { - if ((yyn = yysindex[*(yyps->ssp)]) - && (yyn += YYERRCODE) >= 0 - && yyn <= YYTABLESIZE - && yycheck[yyn] == YYERRCODE) { -# if YYDEBUG - if (yydebug) - fprintf(stderr, "btyacc[%3d,%2d%s]: ERROR recovery shifts to " - "state %d\n", - *(yyps->ssp), (int) yydepth, (yytrial ? ",trial" : ""), - 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) - fprintf(stderr, - "btyacc[%3d,%2d%s]: ERROR recovery discards this state\n", - *(yyps->ssp), (int) yydepth, (yytrial ? ",trial" : "")); -# endif - if (yyps->ssp <= yyps->ss) { - goto yyabort; - } - if(!yytrial) { - YYDELETEVAL(yyps->vsp[0],1); - YYDELETEPOSN(yyps->psp[0],1); - } - --(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"; - fprintf(stderr, "btyacc[%3d,%2d%s]: ERROR recovery discards token " - "%d (%s)\n", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), yychar, yys); - } -# endif - if(!yytrial) { - YYDELETEVAL(yylval,0); - YYDELETEPOSN(yyposn,0); - } - yychar = (YYEMPTY); - goto yyloop; - } - - /* Reduce the rule */ -yyreduce: - yym = yylen[yyn]; -# if YYDEBUG - if (yydebug) { - fprintf(stderr, "btyacc[%3d,%2d%s]: reducing by rule %d (%s)", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), yyn, yyrule[yyn]); -# ifdef YYDBPR - if (yym) { - int i; - fputc('<', stderr); - for (i=yym; i>0; i--) { - if (i!=yym) printf(", "); - YYDBPR((yyps->vsp)[1-i]); - } - fputc('>', stderr); - } -# endif - fputc('\n', stderr); - } -# endif - if (yyps->ssp + 1 - yym >= yyps->ss + yyps->stacksize) { - yyMoreStack(yyps); - } - -# ifdef _YACC_DEFAULT_ACTION_ - /* "$$ = NULL" default action */ - memset(&yyps->val, 0, sizeof(yyps->val)); -# else - /* RA: bison compatibility: default action is '$$ = $1;' */ - if (yym > 0) yyps->val = (yyps->vsp)[1 - yym]; -# endif - - /* 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 = 1; - - switch (yyn) { - -%% trailer - - default: - break; - } - -# if YYDEBUG && defined(YYDBPR) - if (yydebug) { - fputs("btyacc[trial]: reduced, result is ", stderr); - YYDBPR(yyps->val); - fputc('\n', stderr); - } -# 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) { - fprintf(stderr, - "btyacc[ 0,%2d%s]: reduced, shifting to final state %d\n", - (int) yydepth, (yytrial ? ",trial" : ""), YYFINAL); - } -# endif - yystate = YYFINAL; - *++(yyps->ssp) = YYFINAL; - *++(yyps->vsp) = yyps->val; - yyretlval = yyps->val; /* return value of root non-terminal to yylval */ - *++(yyps->psp) = yyps->pos; - yyretposn = yyps->pos; /* return value of root position to yyposn */ - if (yychar < 0) { - if ((yychar = yyLex1(&yylval, YYLEX_PARAM)) < 0) { - yychar = 0; - } -# if YYDEBUG - if (yydebug) { - yys = 0; - if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; - if (!yys) yys = "illegal-symbol"; - fprintf(stderr, "btyacc[%3d,%2d%s]: read %d (%s)\n", - YYFINAL, (int) yydepth, (yytrial ? ",trial" : ""), 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) - fprintf(stderr, "btyacc[%3d,%2d%s]: reduced, shifting to state %d\n", - *(yyps->ssp), (int) yydepth, (yytrial ? ",trial" : ""), 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) - fprintf(stderr, "btyacc[%3d,%2d%s]: CONFLICT trial successful, " - "backtracking to state %d, %d tokens\n", - yystate, (int) yydepth, (yytrial ? ",trial" : ""), - yypath->state, (int) (yylvp - yylvals - yypath->lexeme)); -# endif - if(yyerrctx) { - yyFreeState(yyerrctx); yyerrctx = 0; - } - yychar = YYEMPTY; - 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: - { - YYSTYPE *pv; - YYPOSN *pp; - - if(yyerrctx) { - yyFreeState(yyerrctx); yyerrctx = 0; - } - - for(pv=yyps->vs; pvvsp; pv++) { - YYDELETEVAL(*pv,2); - } - - for(pp=yyps->ps; pppsp; 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 = 0; - } - while (yyps) { - YYParseState *save = yyps; - yyps = save->save; - yyFreeState(save); - } - while (yypath) { - YYParseState *save = yypath; - yypath = save->save; - yyFreeState(save); - } - return (0); -} - - -/* Call yylex() unless the token has already been read. */ -static int yyLex1(YYSTYPE *yylval, yyscan_t scanner) { - if(yylvp < yylve) { - /* we're currently re-reading tokens */ - *yylval = *yylvp++; - yyposn = *yylpp++; - return *yylexp++; - } else if(yyps->save) { - /* in trial mode; save scanner results for future parse attempts */ - if(yylvp == yylvlim) - yyExpand(); - *yylexp = yylex(yylval, scanner); - *yylvp++ = *yylval; - yylve++; - *yylpp++ = yyposn; - yylpe++; - return *yylexp++; - } else { /* normal operation, no conflict encountered */ - return yylex(yylval, scanner); - } -} - -/* Enlarge lexical value queue */ -static int yyExpand() { - int p = yylvp - yylvals; - int s = yylvlim - yylvals; - s += YYSTACKGROWTH; - { - Yshort *tl = yylexemes; - YYSTYPE *tv = yylvals; - YYPOSN *tp = yylpsns; -# ifdef __cplusplus - 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; -# else - yylvals = (YYSTYPE*)malloc(s * sizeof(YYSTYPE)); - yylpsns = (YYPOSN*)malloc(s * sizeof(YYPOSN)); - yylexemes = (Yshort*)malloc(s * sizeof(Yshort)); - memcpy(yylexemes, tl, (s - YYSTACKGROWTH)*sizeof(Yshort)); - yySCopy(yylvals, tv, s - YYSTACKGROWTH); - yyPCopy(yylpsns, tp, s - YYSTACKGROWTH); - free(tl); - free(tv); - free(tp); -# endif - } - yylvp = yylve = yylvals + p; - yylvlim = yylvals + s; - yylpp = yylpe = yylpsns + p; - yylplim = yylpsns + s; - yylexp = yylexemes + p; - return 0; -} - -static void yySCopy(YYSTYPE *to, YYSTYPE *from, int size) { - int i; - for (i = size-1; i >= 0; i--) { - to[i] = from[i]; - } -} - -static void yyPCopy(YYPOSN *to, YYPOSN *from, int size) { - int i; - for (i = size-1; i >= 0; i--) { - to[i] = from[i]; - } -} - -static void yyMoreStack(YYParseState *yyps) { - int p = yyps->ssp - yyps->ss; - Yshort *tss = yyps->ss; - YYSTYPE *tvs = yyps->vs; - YYPOSN *tps = yyps->ps; - int newSize = yyps->stacksize + YYSTACKGROWTH; - -# ifdef __cplusplus - yyps->ss = new Yshort [newSize]; - yyps->vs = new YYSTYPE[newSize]; - yyps->ps = new YYPOSN [newSize]; - 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; -# else - yyps->ss = (Yshort*) malloc(newSize * sizeof(Yshort)); - yyps->vs = (YYSTYPE*)malloc(newSize * sizeof(YYSTYPE)); - yyps->ps = (YYPOSN*) malloc(newSize * sizeof(YYPOSN)); - memcpy(yyps->ss, tss, yyps->stacksize * sizeof(Yshort)); - yySCopy(yyps->vs, tvs, yyps->stacksize); - yyPCopy(yyps->ps, tps, yyps->stacksize); - yyps->stacksize += YYSTACKGROWTH; - free(tss); - free(tvs); - free(tps); -# endif - yyps->ssp = yyps->ss + p; - yyps->vsp = yyps->vs + p; - yyps->psp = yyps->ps + p; -# if YYDEBUG - if (yydebug) - fprintf(stderr, "btyacc: stack size increased to %d\n", yyps->stacksize); -# endif -} - - -#ifdef __cplusplus - -static 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; -} - -static void yyFreeState(YYParseState *p) { - delete[] p->ss; - delete[] p->vs; - delete[] p->ps; - delete p; -} - -#else /* not __cplusplus */ - -static YYParseState *yyNewState(int size) { - YYParseState *p = (YYParseState*)malloc(sizeof(YYParseState)); - - p->stacksize = size+4; - p->ss = (Yshort*) malloc((size + 4) * sizeof(Yshort)); - p->vs = (YYSTYPE*)malloc((size + 4) * sizeof(YYSTYPE)); - p->ps = (YYPOSN*) malloc((size + 4) * sizeof(YYPOSN)); - memset(&p->vs[0], 0, (size+4)*sizeof(YYSTYPE)); - memset(&p->ps[0], 0, (size+4)*sizeof(YYPOSN)); - return p; -} - -static void yyFreeState(YYParseState *p) { - free(p->ss); - free(p->vs); - free(p->ps); - free(p); -} - -#endif -- cgit v1.1