d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/util/LLgen/src/LLgen.c
George Koehler 8bb395b147 LLgen: use size_t, reduce warnings, other small changes 
Use C89 size_t for sizes from sizeof() or to malloc() or realloc().
Remove obsolete (unsigned) casts.  Sizes were unsigned int in
traditional C but are size_t in C89.

Silence some clang warnings.  Add the second pair of round brackets in
`while ((ff = ff->ff_next))` to silence -Wparentheses.  Change
`if (nc_first(...))/*nothing*/;` to `(void)nc_first(...);` to silence
-Wempty-body.  The code in compute.c nc_first() had the form
`if (x) if (y) s; else t;`.  The old indentation (before 10717cc)
suggests that the "else" belongs to the 2nd "if", so add braces like
`if (x) { if (y) s; else t; }` to silence -Wdangling-else.

Shuffle extern function declarations.  Add missing declaration for
LLparse().  Stop declaring RENAME(); it doesn't exist.  Move some
declarations from main.c to extern.h, so the C compiler may check that
the declarations are compatible with the function definitions.

Assume that standard C89 remove() is available and doesn't need the
UNLINK() wrapper.

In lib/incl, don't need to include <stdio.h> nor <stdlib.h> to use
assert().

Remove alloc.h.  If you don't clean your build, then an outdated
BUILDDIR/obj/util/LLgen/headers/alloc.h will survive but should not
cause harm, because nothing includes it.  Don't need to remove alloc.h
from util/LLgen/distr.sh, because it isn't there.

Run the bootstrap to rebuild LLgen.c, Lpars.c, tokens.c.
2019-10-22 15:32:23 -04:00

1324 lines
24 KiB
C
Raw Blame History

/* LLgen generated code from source LLgen.g */
#include "Lpars.h"
#define LL_LEXI scanner
#define LLNOFIRSTS
#define LL_LEXI scanner
/* $Id$ */
#ifdef LL_DEBUG
#include <assert.h>
#define LL_assert(x) assert(x)
#else
#define LL_assert(x) /* nothing */
#endif
extern int LLsymb;
#define LL_SAFE(x) /* Nothing */
#define LL_SSCANDONE(x) if (LLsymb != x) LLsafeerror(x)
#define LL_SCANDONE(x) if (LLsymb != x) LLerror(x)
#define LL_NOSCANDONE(x) LLscan(x)
#ifdef LL_FASTER
#define LLscan(x) if ((LLsymb = LL_LEXI()) != x) LLerror(x)
#endif
extern unsigned int LLscnt[];
extern unsigned int LLtcnt[];
extern int LLcsymb;
#if LL_NON_CORR
extern int LLstartsymb;
#endif
#define LLsdecr(d) {LL_assert(LLscnt[d] > 0); LLscnt[d]--;}
#define LLtdecr(d) {LL_assert(LLtcnt[d] > 0); LLtcnt[d]--;}
#define LLsincr(d) LLscnt[d]++
#define LLtincr(d) LLtcnt[d]++
extern int LL_LEXI(void);
extern void LLread(void);
extern int LLskip(void);
extern int LLnext(int);
extern void LLerror(int);
extern void LLsafeerror(int);
extern void LLnewlevel(unsigned int *);
extern void LLoldlevel(unsigned int *);
#ifndef LL_FASTER
extern void LLscan(int);
#endif
#ifndef LLNOFIRSTS
extern int LLfirst(int, int);
#endif
#if LL_NON_CORR
extern void LLnc_recover(void);
#endif
# line 20 "LLgen.g"
#include <stdlib.h>
#include <string.h>
#include "types.h"
#include "io.h"
#include "extern.h"
#include "assert.h"
#include "cclass.h"
# ifndef NORCSID
static string rcsid = "$Id$";
# endif
p_mem alloc(), ralloc();
string store();
p_gram search();
long ftell();
static int acount; /* count #of global actions */
static p_term t_list;
static int t_cnt;
static p_gram alt_table;
static int n_alts;
static int max_alts;
#define ALTINCR 32
static p_gram rule_table;
static int n_rules;
static int max_rules;
#define RULEINCR 32
/* Here are defined : */
STATIC void newnorder(int index);
STATIC void newtorder(int index);
STATIC void mkalt(p_gram prod, int condition,int lc,register p_gram res);
STATIC void mkterm(p_gram prod, int flags,int lc,register p_gram result);
STATIC p_gram copyrule(register p_gram p,int length);
/* and of course LLparse() */
STATIC void newnorder(int index) {
static int porder;
if (norder != -1) {
nonterms[porder].n_next = index;
}
else norder = index;
porder = index;
nonterms[porder].n_next = -1;
}
STATIC void newtorder(int index) {
static int porder;
if (torder != -1) {
tokens[porder].t_next = index;
}
else torder = index;
porder = index;
tokens[porder].t_next = -1;
}
void p_init(void)
{
alt_table = (p_gram )alloc(ALTINCR*sizeof(t_gram));
n_alts = 0;
max_alts = ALTINCR;
rule_table = (p_gram )alloc(RULEINCR*sizeof(t_gram));
n_rules = 0;
max_rules = RULEINCR;
}
static void LL1_def(void);
static void LL2_rule(void);
static void LL3_listel(void);
static void LL4_firsts(void);
static void LL5_productions(
# line 244 "LLgen.g"
p_gram *p) ;
static void LL6_simpleproduction(
# line 330 "LLgen.g"
p_gram *p ,register int *conflres) ;
static void LL7_elem(
# line 478 "LLgen.g"
register p_gram pres) ;
static void LL8_repeats(
# line 600 "LLgen.g"
int *kind ,int *cnt) ;
static void LL9_number(
# line 617 "LLgen.g"
int *t) ;
void
LL0_spec(
void
) {
LLsincr(0);
# line 94 "LLgen.g"
{ acount = 0; p_init(); }
for (;;) {
goto L_1;
L_1 : {switch(LLcsymb) {
case /* EOFILE */ 0 : ;
break;
default:{int LL_1=LLnext(0);
;if (!LL_1) {
break;
}
else if (LL_1 & 1) goto L_1;}
case /* C_IDENT */ 2 : ;
case /* C_ACTION */ 7 : ;
case /* C_TOKEN */ 8 : ;
case /* C_START */ 9 : ;
case /* C_FIRST */ 13 : ;
case /* C_LEXICAL */ 14 : ;
case /* C_PREFIX */ 15 : ;
case /* C_ONERROR */ 16 : ;
LL1_def();
LLread();
continue;
}
}
LLsdecr(0);
break;
}
# line 96 "LLgen.g"
{ /*
* Put an endmarker in temporary file
*/
putc('\0', fact);
putc('\0', fact);
free((p_mem) rule_table);
free((p_mem) alt_table);
}
}
static
void
LL1_def(
void
) {
# line 106 "LLgen.g"
register string p;
switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
LL2_rule();
break;
case /* C_TOKEN */ 8 : ;
LLtincr(23);
LLtincr(24);
LL_SAFE(C_TOKEN);
LL3_listel();
LLread();
for (;;) {
goto L_4;
L_4 : {switch(LLcsymb) {
case /* ';' */ 24 : ;
break;
default:{int LL_2=LLnext(44);
;if (!LL_2) {
break;
}
else if (LL_2 & 1) goto L_4;}
case /* ',' */ 23 : ;
LL_SAFE(',');
LL3_listel();
LLread();
continue;
}
}
LLtdecr(23);
break;
}
LLtdecr(24);
LL_SSCANDONE(';');
break;
case /* C_START */ 9 : ;
LLtincr(23);
LLtincr(2);
LLtincr(24);
LL_SAFE(C_START);
LL_NOSCANDONE(C_IDENT);
# line 116 "LLgen.g"
{ p = store(lextoken.t_string); }
LLtdecr(23);
LL_NOSCANDONE(',');
LLtdecr(2);
LL_NOSCANDONE(C_IDENT);
# line 121 "LLgen.g"
{ /*
* Put the declaration in the list
* of start symbols
*/
register p_gram temp;
register p_start ff;
temp = search(NONTERM,lextoken.t_string,BOTH);
ff = (p_start) alloc(sizeof(t_start));
ff->ff_nont = g_getcont(temp);
ff->ff_name = p;
ff->ff_next = start;
start = ff;
while ((ff = ff->ff_next)) {
if (! strcmp(p, ff->ff_name)) {
error(linecount, "\"%s\" already used in a %%start", p);
break;
}
}
}
LLtdecr(24);
LL_NOSCANDONE(';');
break;
case /* C_LEXICAL */ 14 : ;
LLtincr(24);
LL_SAFE(C_LEXICAL);
LL_NOSCANDONE(C_IDENT);
# line 147 "LLgen.g"
{ if (!lexical) {
lexical = store(lextoken.t_string);
}
else error(linecount,"Duplicate %%lexical", NULL);
}
LLtdecr(24);
LL_NOSCANDONE(';');
break;
case /* C_PREFIX */ 15 : ;
LLtincr(24);
LL_SAFE(C_PREFIX);
LL_NOSCANDONE(C_IDENT);
# line 157 "LLgen.g"
{ if (!prefix) {
prefix = store(lextoken.t_string);
if (strlen(prefix) > 6) {
error(linecount,
"%%prefix too long",NULL);
prefix[6] = 0;
}
}
else error(linecount,"Duplicate %%prefix", NULL);
}
LLtdecr(24);
LL_NOSCANDONE(';');
break;
case /* C_ONERROR */ 16 : ;
LLtincr(24);
LL_SAFE(C_ONERROR);
LL_NOSCANDONE(C_IDENT);
# line 169 "LLgen.g"
{
#ifdef NON_CORRECTING
if (non_corr) {
warning(linecount, "%%onerror conflicts with -n option", NULL);
}
else
#endif
if (! onerror) {
onerror = store(lextoken.t_string);
}
else error(linecount,"Duplicate %%onerror", NULL);
}
LLtdecr(24);
LL_NOSCANDONE(';');
break;
default:
LL_SSCANDONE(C_ACTION);
# line 182 "LLgen.g"
{ acount++; }
break;
case /* C_FIRST */ 13 : ;
LL4_firsts();
break;
}
}
static
void
LL3_listel(
void
) {
LL_NOSCANDONE(C_IDENT);
# line 192 "LLgen.g"
{ p_gram temp = search(TERMINAL,lextoken.t_string,ENTERING);
newtorder(g_getcont(temp));
tokens[g_getcont(temp)].t_lineno = linecount;
}
}
static
void
LL2_rule(
void
) {
# line 198 "LLgen.g"
register p_nont p;
p_gram rr;
register p_gram temp;
LLtincr(6);
LLtincr(7);
LLtincr(25);
LLsincr(1);
LLtincr(24);
LL_SAFE(C_IDENT);
# line 205 "LLgen.g"
{ temp = search(NONTERM,lextoken.t_string,BOTH);
p = &nonterms[g_getcont(temp)];
if (p->n_rule) {
error(linecount,
"Nonterminal %s already defined", lextoken.t_string);
}
/*
* Remember the order in which the nonterminals
* were defined. Code must be generated in that
* order to keep track with the actions on the
* temporary file
*/
newnorder(p - nonterms);
p->n_count = acount;
acount = 0;
p->n_lineno = linecount;
p->n_off = ftell(fact);
}
LLread();
goto L_1;
L_1 : {switch(LLcsymb) {
case /* C_ACTION */ 7 : ;
case /* ':' */ 25 : ;
LLtdecr(6);
break;
default:{int LL_3=LLnext(262);
;if (!LL_3) {
LLtdecr(6);
break;
}
else if (LL_3 & 1) goto L_1;}
case /* C_PARAMS */ 6 : ;
LLtdecr(6);
LL_SAFE(C_PARAMS);
# line 223 "LLgen.g"
{ if (lextoken.t_num > 0) {
p->n_flags |= PARAMS;
if (lextoken.t_num > 15) {
error(linecount,"Too many parameters", NULL);
}
else setntparams(p,lextoken.t_num);
}
}
LLread();
}
}
goto L_2;
L_2 : {switch(LLcsymb) {
case /* ':' */ 25 : ;
LLtdecr(7);
break;
default:{int LL_4=LLnext(263);
;if (!LL_4) {
LLtdecr(7);
break;
}
else if (LL_4 & 1) goto L_2;}
case /* C_ACTION */ 7 : ;
LLtdecr(7);
LL_SAFE(C_ACTION);
# line 232 "LLgen.g"
{ p->n_flags |= LOCALS; }
LLread();
}
}
LLtdecr(25);
LL_SCANDONE(':');
# line 234 "LLgen.g"
{ in_production = 1; }
LLread();
LLsdecr(1);
LL5_productions(
# line 235 "LLgen.g"
&rr);
LLtdecr(24);
LL_SCANDONE(';');
# line 236 "LLgen.g"
{ in_production = 0; }
# line 241 "LLgen.g"
{ nonterms[g_getcont(temp)].n_rule = rr;}
}
static
void
LL5_productions(
# line 244 "LLgen.g"
p_gram *p)
{
# line 248 "LLgen.g"
p_gram prod;
int conflres = 0;
int t = 0;
int haddefault = 0;
int altcnt = 0;
int o_lc, n_lc;
LLtincr(26);
# line 255 "LLgen.g"
{ o_lc = linecount; }
LL6_simpleproduction(
# line 256 "LLgen.g"
p,&conflres);
# line 257 "LLgen.g"
{ if (conflres & DEF) haddefault = 1; }
goto L_2; /* so that the label is used for certain */
L_2: ;
switch(LLcsymb) {
case /* '|' */ 26 : ;
LLtdecr(26);
LLsincr(1);
LLsdecr(1);
LLtincr(26);
for (;;) {
LL_SAFE('|');
# line 259 "LLgen.g"
{ n_lc = linecount; }
LLread();
LL6_simpleproduction(
# line 260 "LLgen.g"
&prod,&t);
# line 261 "LLgen.g"
{ if (n_alts >= max_alts-2) {
alt_table = (p_gram ) ralloc(
(p_mem) alt_table,
(max_alts+=ALTINCR)*sizeof(t_gram));
}
if (t & DEF) {
if (haddefault) {
error(n_lc,
"More than one %%default in alternation", NULL);
}
haddefault = 1;
}
mkalt(*p,conflres,o_lc,&alt_table[n_alts++]);
altcnt++;
o_lc = n_lc;
conflres = t;
t = 0;
*p = prod;
}
goto L_4;
L_4 : {switch(LLcsymb) {
case /* ';' */ 24 : ;
case /* ']' */ 28 : ;
break;
default:{int LL_5=LLnext(124);
;if (!LL_5) {
break;
}
else if (LL_5 & 1) goto L_4;}
case /* '|' */ 26 : ;
continue;
}
}
LLtdecr(26);
break;
}
# line 280 "LLgen.g"
{ if (conflres & (COND|PREFERING|AVOIDING)) {
error(n_lc,
"Resolver on last alternative not allowed", NULL);
}
mkalt(*p,conflres,n_lc,&alt_table[n_alts++]);
altcnt++;
g_settype((&alt_table[n_alts]),EORULE);
*p = copyrule(&alt_table[n_alts-altcnt],altcnt+1);
}
break;
case /* ';' */ 24 : ;
case /* ']' */ 28 : ;
goto L_3;
L_3: ;
LLtdecr(26);
# line 290 "LLgen.g"
{ if (conflres & (COND|PREFERING|AVOIDING)) {
error(o_lc,
"No alternation conflict resolver allowed here", NULL);
}
/*
if (conflres & DEF) {
error(o_lc,
"No %%default allowed here", NULL);
}
*/
}
break;
default: if (LLskip()) goto L_2;
goto L_3;
}
# line 302 "LLgen.g"
{ n_alts -= altcnt; }
}
# line 304 "LLgen.g"
STATIC void mkalt(p_gram prod, int condition,int lc,register p_gram res)
{
/*
* Create an alternation and initialise it.
*/
register p_link l;
static p_link list;
static int cnt;
if (! cnt) {
cnt = 50;
list = (p_link) alloc(50 * sizeof(t_link));
}
cnt--;
l = list++;
l->l_rule = prod;
l->l_flag = condition;
g_setlink(res,l);
g_settype(res,ALTERNATION);
res->g_lineno = lc;
nalts++;
}
static
void
LL6_simpleproduction(
# line 330 "LLgen.g"
p_gram *p ,register int *conflres)
{
# line 331 "LLgen.g"
t_gram elem;
int elmcnt = 0;
int cnt, kind;
int termdeleted = 0;
LLtincr(19);
LLsincr(2);
LLtincr(22);
LLsincr(3);
goto L_1;
L_1 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_IF */ 10 : ;
case /* C_AVOID */ 17 : ;
case /* C_PREFER */ 18 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* C_ILLEGAL */ 22 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLtdecr(19);
break;
default:{int LL_6=LLnext(275);
;if (!LL_6) {
LLtdecr(19);
break;
}
else if (LL_6 & 1) goto L_1;}
case /* C_DEFAULT */ 19 : ;
LLtdecr(19);
LL_SAFE(C_DEFAULT);
# line 336 "LLgen.g"
{ *conflres |= DEF; }
LLread();
}
}
goto L_2;
L_2 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* C_ILLEGAL */ 22 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLsdecr(2);
break;
default:{int LL_7=LLnext(-8);
;if (!LL_7) {
LLsdecr(2);
break;
}
else if (LL_7 & 1) goto L_2;}
case /* C_IF */ 10 : ;
case /* C_AVOID */ 17 : ;
case /* C_PREFER */ 18 : ;
LLsdecr(2);
switch(LLcsymb) {
case /* C_IF */ 10 : ;
LL_SAFE(C_IF);
LL_NOSCANDONE(C_EXPR);
# line 342 "LLgen.g"
{ *conflres |= COND; }
break;
default:
LL_SAFE(C_PREFER);
# line 343 "LLgen.g"
{ *conflres |= PREFERING; }
break;
case /* C_AVOID */ 17 : ;
LL_SAFE(C_AVOID);
# line 344 "LLgen.g"
{ *conflres |= AVOIDING; }
break;
}
LLread();
}
}
goto L_6;
L_6 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLtdecr(22);
break;
default:{int LL_8=LLnext(278);
;if (!LL_8) {
LLtdecr(22);
break;
}
else if (LL_8 & 1) goto L_6;}
case /* C_ILLEGAL */ 22 : ;
LLtdecr(22);
LL_SAFE(C_ILLEGAL);
# line 346 "LLgen.g"
{
#ifdef NON_CORRECTING
if (n_rules >= max_rules-2) {
rule_table = (p_gram) ralloc(
(p_mem) rule_table,
(max_rules+=RULEINCR)*sizeof(t_gram));
}
elmcnt++;
rule_table[n_rules++] =
*search(TERMINAL, "LLILLEGAL", BOTH);
if (*conflres & DEF) {
error(linecount, "%%illegal not allowed in %%default rule", NULL);
}
#endif
}
LLread();
}
}
for (;;) {
goto L_7;
L_7 : {switch(LLcsymb) {
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* ']' */ 28 : ;
break;
default:{int LL_9=LLnext(-12);
;if (!LL_9) {
break;
}
else if (LL_9 & 1) goto L_7;}
case /* C_IDENT */ 2 : ;
case /* C_NUMBER */ 3 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* '[' */ 27 : ;
case /* '?' */ 29 : ;
case /* '*' */ 30 : ;
case /* '+' */ 31 : ;
LLsincr(4);
LL7_elem(
# line 362 "LLgen.g"
&elem);
# line 363 "LLgen.g"
{ if (n_rules >= max_rules-2) {
rule_table = (p_gram) ralloc(
(p_mem) rule_table,
(max_rules+=RULEINCR)*sizeof(t_gram));
}
kind = FIXED;
cnt = 0;
}
goto L_9; /* so that the label is used for certain */
L_9: ;
switch(LLcsymb) {
case /* C_NUMBER */ 3 : ;
case /* '?' */ 29 : ;
case /* '*' */ 30 : ;
case /* '+' */ 31 : ;
LLsdecr(4);
LL8_repeats(
# line 371 "LLgen.g"
&kind, &cnt);
# line 372 "LLgen.g"
{ if (g_gettype(&elem) != TERM) {
rule_table[n_rules] = elem;
g_settype((&rule_table[n_rules+1]),EORULE);
mkterm(copyrule(&rule_table[n_rules],2),
0,
elem.g_lineno,
&elem);
}
}
break;
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
goto L_10;
L_10: ;
LLsdecr(4);
# line 382 "LLgen.g"
{ if (g_gettype(&elem) == TERM) {
register p_term q = g_getterm(&elem);
if (! (q->t_flags & RESOLVER) &&
g_gettype(q->t_rule) != ALTERNATION &&
g_gettype(q->t_rule) != EORULE) {
while (g_gettype(q->t_rule) != EORULE) {
rule_table[n_rules++] = *q->t_rule++;
elmcnt++;
if (n_rules >= max_rules-2) {
rule_table = (p_gram) ralloc(
(p_mem) rule_table,
(max_rules+=RULEINCR)*sizeof(t_gram));
}
}
elem = *--(q->t_rule);
n_rules--;
elmcnt--;
if (q == t_list - 1) {
t_list--;
nterms--;
t_cnt++;
}
termdeleted = 1;
}
}
}
break;
default: if (LLskip()) goto L_9;
goto L_10;
}
# line 409 "LLgen.g"
{ if (!termdeleted && g_gettype(&elem) == TERM) {
register p_term q;
q = g_getterm(&elem);
r_setkind(q,kind);
r_setnum(q,cnt);
if ((q->t_flags & RESOLVER) &&
(kind == PLUS || kind == FIXED)) {
error(linecount,
"%%while not allowed in this term", NULL);
}
/*
* A persistent fixed term is the same
* as a non-persistent fixed term.
* Should we complain?
if ((q->t_flags & PERSISTENT) &&
kind == FIXED) {
error(linecount,
"Illegal %%persistent", NULL);
}
*/
}
termdeleted = 0;
elmcnt++;
rule_table[n_rules++] = elem;
}
continue;
}
}
LLsdecr(3);
break;
}
# line 435 "LLgen.g"
{ register p_term q;
g_settype((&rule_table[n_rules]),EORULE);
*p = 0;
n_rules -= elmcnt;
if (g_gettype(&rule_table[n_rules]) == TERM &&
elmcnt == 1) {
q = g_getterm(&rule_table[n_rules]);
if (r_getkind(q) == FIXED &&
r_getnum(q) == 0) {
*p = q->t_rule;
}
}
if (!*p) *p = copyrule(&rule_table[n_rules],
elmcnt+1);
}
}
# line 452 "LLgen.g"
STATIC void mkterm(p_gram prod, int flags,int lc,register p_gram result)
{
/*
* Create a term, initialise it and return
* a grammar element containing it
*/
register p_term q;
if (! t_cnt) {
t_cnt = 50;
t_list = (p_term) alloc(50 * sizeof(t_term));
}
t_cnt--;
q = t_list++;
q->t_rule = prod;
q->t_contains = 0;
q->t_flags = flags;
g_settype(result,TERM);
g_setterm(result,q);
result->g_lineno = lc;
nterms++;
}
static
void
LL7_elem(
# line 478 "LLgen.g"
register p_gram pres)
{
# line 479 "LLgen.g"
register int t = 0;
p_gram p1;
int ln;
p_gram pe;
#ifdef NON_CORRECTING
int erroneous = 0;
#endif
switch(LLcsymb) {
case /* '[' */ 27 : ;
LLtincr(11);
LLtincr(12);
LLsincr(1);
LLtincr(28);
LL_SAFE('[');
# line 487 "LLgen.g"
{ ln = linecount; }
LLread();
goto L_4;
L_4 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_IF */ 10 : ;
case /* C_PERSISTENT */ 12 : ;
case /* C_AVOID */ 17 : ;
case /* C_PREFER */ 18 : ;
case /* C_DEFAULT */ 19 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* C_ILLEGAL */ 22 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLtdecr(11);
break;
default:{int LL_10=LLnext(267);
;if (!LL_10) {
LLtdecr(11);
break;
}
else if (LL_10 & 1) goto L_4;}
case /* C_WHILE */ 11 : ;
LLtdecr(11);
LL_SAFE(C_WHILE);
LL_NOSCANDONE(C_EXPR);
# line 488 "LLgen.g"
{ t |= RESOLVER; }
LLread();
}
}
goto L_5;
L_5 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_IF */ 10 : ;
case /* C_AVOID */ 17 : ;
case /* C_PREFER */ 18 : ;
case /* C_DEFAULT */ 19 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* C_ILLEGAL */ 22 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLtdecr(12);
break;
default:{int LL_11=LLnext(268);
;if (!LL_11) {
LLtdecr(12);
break;
}
else if (LL_11 & 1) goto L_5;}
case /* C_PERSISTENT */ 12 : ;
LLtdecr(12);
LL_SAFE(C_PERSISTENT);
# line 490 "LLgen.g"
{ t |= PERSISTENT; }
LLread();
}
}
LLsdecr(1);
LL5_productions(
# line 492 "LLgen.g"
&p1);
LLtdecr(28);
LL_SCANDONE(']');
# line 493 "LLgen.g"
{
mkterm(p1,t,ln,pres);
}
LLread();
break;
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ERRONEOUS */ 21 : ;
LLsincr(5);
goto L_6;
L_6 : {switch(LLcsymb) {
default:
break;
case /* C_ERRONEOUS */ 21 : ;
LL_SAFE(C_ERRONEOUS);
# line 497 "LLgen.g"
{
#ifdef NON_CORRECTING
erroneous = 1;
#endif
}
LLread();
}
}
goto L_8; /* so that the label is used for certain */
L_8: ;
switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
goto L_9;
L_9: ;
LLsdecr(5);
LLtincr(6);
LL_SSCANDONE(C_IDENT);
# line 505 "LLgen.g"
{ pe = search(UNKNOWN,lextoken.t_string,BOTH);
*pres = *pe;
#ifdef NON_CORRECTING
if (erroneous) {
if (g_gettype(pres) != TERMINAL){
warning(linecount,
"Erroneous only allowed on terminal", NULL);
erroneous = 0;
}
else
pres->g_erroneous = 1;
}
#endif
}
LLread();
goto L_10;
L_10 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_NUMBER */ 3 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
case /* '?' */ 29 : ;
case /* '*' */ 30 : ;
case /* '+' */ 31 : ;
LLtdecr(6);
break;
default:{int LL_12=LLnext(262);
;if (!LL_12) {
LLtdecr(6);
break;
}
else if (LL_12 & 1) goto L_10;}
case /* C_PARAMS */ 6 : ;
LLtdecr(6);
LL_SAFE(C_PARAMS);
# line 520 "LLgen.g"
{ if (lextoken.t_num > 15) {
error(linecount,"Too many parameters", NULL);
} else g_setnpar(pres,lextoken.t_num);
if (g_gettype(pres) == TERMINAL) {
error(linecount,
"Terminal with parameters", NULL);
}
}
LLread();
}
}
break;
default: if (LLskip()) goto L_8;
goto L_9;
case /* C_LITERAL */ 4 : ;
LLsdecr(5);
LL_SAFE(C_LITERAL);
# line 529 "LLgen.g"
{ pe = search(LITERAL,lextoken.t_string,BOTH);
*pres = *pe;
#ifdef NON_CORRECTING
if (erroneous)
pres->g_erroneous = 1;
#endif
}
LLread();
break;
}
break;
default:
LLtincr(7);
# line 537 "LLgen.g"
{ g_settype(pres,ACTION);
pres->g_lineno = linecount;
#ifdef NON_CORRECTING
g_setsubparse(pres, (p_start) 0);
#endif
}
goto L_11;
L_11 : {switch(LLcsymb) {
default:
break;
case /* C_SUBSTART */ 20 : ;
LLtincr(23);
LLtincr(24);
LL_SAFE(C_SUBSTART);
# line 546 "LLgen.g"
{
#ifdef NON_CORRECTING
nsubstarts++;
#endif
}
LL_NOSCANDONE(C_IDENT);
# line 553 "LLgen.g"
{
#ifdef NON_CORRECTING
register p_gram temp;
register p_start subp;
temp = search(NONTERM,lextoken.t_string,BOTH);
subp = (p_start) alloc (sizeof(t_start));
subp->ff_nont = g_getcont(temp);
subp->ff_name = (string) 0;
subp->ff_next = (p_start) 0;
g_setsubparse(pres, subp);
#endif
}
LLread();
for (;;) {
goto L_12;
L_12 : {switch(LLcsymb) {
case /* ';' */ 24 : ;
break;
default:{int LL_13=LLnext(44);
;if (!LL_13) {
break;
}
else if (LL_13 & 1) goto L_12;}
case /* ',' */ 23 : ;
LL_SAFE(',');
LL_NOSCANDONE(C_IDENT);
# line 569 "LLgen.g"
{
#ifdef NON_CORRECTING
register p_gram temp;
register p_start ff;
temp = search(NONTERM,lextoken.t_string,BOTH);
ff = g_getsubparse(pres);
while (ff) {
if (ff->ff_nont == g_getcont(temp)) {
warning(linecount, "\"%s\" used twice in %%substart", lextoken.t_string);
break;
}
ff = ff->ff_next;
}
ff = (p_start) alloc(sizeof(t_start));
ff->ff_nont = g_getcont(temp);
ff->ff_name = (string) 0;
ff->ff_next = g_getsubparse(pres);
g_setsubparse(pres, ff);
#endif
}
LLread();
continue;
}
}
LLtdecr(23);
break;
}
LLtdecr(24);
LL_SSCANDONE(';');
LLread();
}
}
LLtdecr(7);
LL_SCANDONE(C_ACTION);
LLread();
break;
}
}
static
void
LL8_repeats(
# line 600 "LLgen.g"
int *kind ,int *cnt)
{
# line 600 "LLgen.g"
int t1 = 0;
switch(LLcsymb) {
default:
LL_SAFE('?');
# line 602 "LLgen.g"
{ *kind = OPT; }
LLread();
break;
case /* '*' */ 30 : ;
case /* '+' */ 31 : ;
LLtincr(3);
switch(LLcsymb) {
default:
LL_SAFE('*');
# line 603 "LLgen.g"
{ *kind = STAR; }
break;
case /* '+' */ 31 : ;
LL_SAFE('+');
# line 604 "LLgen.g"
{ *kind = PLUS; }
break;
}
LLread();
goto L_7;
L_7 : {switch(LLcsymb) {
case /* C_IDENT */ 2 : ;
case /* C_LITERAL */ 4 : ;
case /* C_ACTION */ 7 : ;
case /* C_SUBSTART */ 20 : ;
case /* C_ERRONEOUS */ 21 : ;
case /* ';' */ 24 : ;
case /* '|' */ 26 : ;
case /* '[' */ 27 : ;
case /* ']' */ 28 : ;
LLtdecr(3);
break;
default:{int LL_14=LLnext(259);
;if (!LL_14) {
LLtdecr(3);
break;
}
else if (LL_14 & 1) goto L_7;}
case /* C_NUMBER */ 3 : ;
LLtdecr(3);
LL9_number(
# line 606 "LLgen.g"
&t1);
LLread();
}
}
# line 607 "LLgen.g"
{ if (t1 == 1) {
t1 = 0;
if (*kind == STAR) *kind = OPT;
if (*kind == PLUS) *kind = FIXED;
}
}
break;
case /* C_NUMBER */ 3 : ;
LL9_number(
# line 613 "LLgen.g"
&t1);
LLread();
break;
}
# line 614 "LLgen.g"
{ *cnt = t1; }
}
static
void
LL9_number(
# line 617 "LLgen.g"
int *t)
{
LL_SAFE(C_NUMBER);
# line 619 "LLgen.g"
{ *t = lextoken.t_num;
if (*t <= 0 || *t >= 8192) {
error(linecount,"Illegal number", NULL);
}
}
}
static
void
LL4_firsts(
void
) {
# line 626 "LLgen.g"
register string p;
LLtincr(23);
LLtincr(2);
LLtincr(24);
LL_SAFE(C_FIRST);
LL_NOSCANDONE(C_IDENT);
# line 628 "LLgen.g"
{ p = store(lextoken.t_string); }
LLtdecr(23);
LL_NOSCANDONE(',');
LLtdecr(2);
LL_NOSCANDONE(C_IDENT);
LLtdecr(24);
LL_NOSCANDONE(';');
# line 630 "LLgen.g"
{ /*
* Store this %first in the list belonging
* to this input file
*/
p_gram temp;
register p_first ff;
temp = search(NONTERM,lextoken.t_string,BOTH);
ff = (p_first) alloc(sizeof(t_first));
ff->ff_nont = g_getcont(temp);
ff->ff_name = p;
ff->ff_next = pfile->f_firsts;
pfile->f_firsts = ff;
}
}
# line 645 "LLgen.g"
STATIC p_gram copyrule(register p_gram p,int length)
{
/*
* Returns a pointer to a grammar rule that was created in
* p. The space pointed to by p can now be reused
*/
register p_gram t;
p_gram rule;
t = (p_gram) alloc(length * sizeof(t_gram));
rule = t;
while (length--) {
*t++ = *p++;
}
return rule;
}
Reference in a new issue View git blame Copy permalink