/* * Some grammar independent code. * This file is copied into Lpars.c. */ static char *rcsid = "$Header$"; #define LLSTSIZ 1024 static short LLstack[LLSTSIZ]; /* Recovery stack */ short * LLptr; /* ptr in it */ #define LLmax (&LLstack[LLSTSIZ-1]) /* if beyond this, overflow */ int LLscd; /* lookahead done or not? */ int LLb,LLi; int LLsymb; int LLcsymb; static int LLlevel; static short * LLbase; static struct LLsaved { int LLs_i, LLs_b, LLs_s, LLs_c, LLs_t; short *LLs_p, *LLs_x; } LLsaved[LL_MAX]; /* In this file are defined: */ extern LLcheck(); extern LLscan(); extern LLpush(); extern LLlpush(); extern int LLpop(); extern int LLsskip(); static LLerror(); extern LLnewlevel(); extern LLoldlevel(); LLcheck() { register c; /* * The symbol to be checked is on the stack. */ if (!LLscd) { if ((c = LL_LEXI()) <= 0) c = EOFILE; LLsymb = c; } else LLscd = 0; if (LLsymb == *--LLptr) return; /* * If we come here, an error has been detected. * LLpop will try and recover */ LLptr++; while (LLindex[LLsymb] < 0) { LLerror(0); if ((LLsymb = LL_LEXI()) <= 0) LLsymb = EOFILE; } LLcsymb = LLindex[LLsymb]; LLb = LLbyte[LLcsymb]; LLi = LLcsymb>>3; LLscd = 1; if (!LLpop()) LLerror(*LLptr); LLscd = 0; } LLscan(t) { /* * Check if the next symbol is equal to the parameter */ if (!LLscd) { if ((LLsymb = LL_LEXI()) <= 0) LLsymb = EOFILE; } else LLscd = 0; if (LLsymb == t) return; /* * If we come here, an error has been detected */ LLpush(t); LLscd = 1; while (LLindex[LLsymb] < 0) { LLerror(0); if ((LLsymb = LL_LEXI()) <= 0) LLsymb = EOFILE; } LLcsymb = LLindex[LLsymb]; LLb = LLbyte[LLcsymb]; LLi = LLcsymb>>3; if (!LLpop()) LLerror(t); LLscd = 0; } LLpush(t) { if (LLptr == LLmax) { LLerror(-1); } *LLptr++ = t; } LLlpush(d) { register i; register short *p; p = &LLlists[d]; i = *p++; while(i--) { if (LLptr == LLmax) { LLerror(-1); } *LLptr++ = *p++; } } LLsskip() { /* * Error recovery, and not only that! * Skip symbols until one is found that is on the stack. * Return 1 if it is on top of the stack */ register short *t; register i; for (;;) { if (!LLscd) { lab: if ((i = LL_LEXI()) <= 0) i = EOFILE; LLsymb = i; if ((i = LLindex[i]) < 0) { LLerror(0); goto lab; /* * Ugly, but we want speed * on possibly correct symbols !! * So, no breaks out of "for (;;)" */ } LLcsymb = i; LLb = LLbyte[i]; LLi = (i>>3); LLscd = 1; } t = LLptr-1; i = *t; if (!((i<=0 && LLsets[LLi-i]&LLb)||i==LLsymb)) { while (--t >= LLbase) { /* * If the element on the stack is negative, * its opposite is an index in the setarray, * otherwise it is a terminal symbol */ i = *t; if ((i<=0&&LLsets[LLi-i]&LLb)||i==LLsymb){ break; } } if (t >= LLbase) break; LLerror(0); LLscd = 0; } else { return 1; } } return t == LLptr - 1; } LLpop() { register i; i = LLsskip(); LLptr--; return i; } static LLerror(d) { LLmessage(d); if (d < 0) exit(1); } LLnewlevel() { register struct LLsaved *p; if (!LLlevel++) { LLptr = LLstack; LLbase = LLstack; LLpush(EOFILE); } else { if (LLlevel > LL_MAX) LLerror(-1); p = &LLsaved[LLlevel - 2]; p->LLs_p = LLptr; p->LLs_i = LLi; p->LLs_b = LLb; p->LLs_s = LLsymb; p->LLs_t = LLcsymb; p->LLs_c = LLscd; p->LLs_x = LLbase; LLbase = LLptr; LLpush(EOFILE); } } LLoldlevel() { register struct LLsaved *p; LLcheck(); if (--LLlevel) { p = &LLsaved[LLlevel-1]; LLptr = p->LLs_p; LLi = p->LLs_i; LLb = p->LLs_b; LLsymb = p->LLs_s; LLcsymb = p->LLs_t; LLbase = p->LLs_x; LLscd = p->LLs_c; } }