/* Compute look-ahead criteria for bison,
- Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+ Copyright 1984, 1986, 1989, 2000, 2001 Free Software Foundation, Inc.
-This file is part of Bison, the GNU Compiler Compiler.
+ This file is part of Bison, the GNU Compiler Compiler.
-Bison is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+ Bison is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
-Bison is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ Bison is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with Bison; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with Bison; see the file COPYING. If not, write to
+ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
/* Compute how to make the finite state machine deterministic; find
which rules need lookahead in each state, and which lookahead
- tokens they accept. */
+ tokens they accept. */
#include "system.h"
#include "types.h"
-#include "state.h"
-#include "alloc.h"
+#include "LR0.h"
#include "gram.h"
#include "complain.h"
#include "lalr.h"
#include "nullable.h"
+#include "derives.h"
-extern short **derives;
+/* All the decorated states, indexed by the state number. Warning:
+ there is a state_TABLE in LR0.c, but it is different and static.
+ */
+state_t *state_table = NULL;
int tokensetsize;
-short *lookaheads;
short *LAruleno;
unsigned *LA;
-short *accessing_symbol;
-char *consistent;
-core **state_table;
-shifts **shift_table;
-reductions **reduction_table;
+
short *goto_map;
short *from_state;
short *to_state;
extern void berror PARAMS ((const char *));
static int infinity;
-static int maxrhs;
static int ngotos;
-static unsigned *F;
+
+/* And for the famous F variable, which named is so descriptive that a
+ comment is hardly needed. <grin>. */
+static unsigned *F = NULL;
+#define F(Rule) (F + (Rule) * tokensetsize)
+
static short **includes;
static shorts **lookback;
static short **R;
VERTICES[++top] = i;
INDEX[i] = height = top;
- base = F + i * tokensetsize;
- fp3 = base + tokensetsize;
+ base = F (i);
+ fp3 = F (i + 1);
rp = R[i];
if (rp)
INDEX[i] = INDEX[j];
fp1 = base;
- fp2 = F + j * tokensetsize;
+ fp2 = F (j);
while (fp1 < fp3)
*fp1++ |= *fp2++;
break;
fp1 = base;
- fp2 = F + j * tokensetsize;
+ fp2 = F (j);
while (fp1 < fp3)
*fp2++ = *fp1++;
int i;
infinity = ngotos + 2;
- INDEX = NEW2 (ngotos + 1, short);
- VERTICES = NEW2 (ngotos + 1, short);
+ INDEX = XCALLOC (short, ngotos + 1);
+ VERTICES = XCALLOC (short, ngotos + 1);
top = 0;
R = relation;
INDEX[i] = 0;
for (i = 0; i < ngotos; i++)
- {
- if (INDEX[i] == 0 && R[i])
- traverse (i);
- }
+ if (INDEX[i] == 0 && R[i])
+ traverse (i);
- FREE (INDEX);
- FREE (VERTICES);
+ XFREE (INDEX);
+ XFREE (VERTICES);
}
-static void
-set_state_table (void)
-{
- core *sp;
-
- state_table = NEW2 (nstates, core *);
-
- for (sp = first_state; sp; sp = sp->next)
- state_table[sp->number] = sp;
-}
+/*--------------------.
+| Build STATE_TABLE. |
+`--------------------*/
static void
-set_accessing_symbol (void)
-{
- core *sp;
-
- accessing_symbol = NEW2 (nstates, short);
-
- for (sp = first_state; sp; sp = sp->next)
- accessing_symbol[sp->number] = sp->accessing_symbol;
-}
-
-
-static void
-set_shift_table (void)
-{
- shifts *sp;
-
- shift_table = NEW2 (nstates, shifts *);
-
- for (sp = first_shift; sp; sp = sp->next)
- shift_table[sp->number] = sp;
-}
-
-
-static void
-set_reduction_table (void)
+set_state_table (void)
{
- reductions *rp;
-
- reduction_table = NEW2 (nstates, reductions *);
-
- for (rp = first_reduction; rp; rp = rp->next)
- reduction_table[rp->number] = rp;
+ /* NSTATES + 1 because lookahead for the pseudo state number NSTATES
+ might be used (see conflicts.c). It is too opaque for me to
+ provide a probably less hacky implementation. --akim */
+ state_table = XCALLOC (state_t, nstates + 1);
+
+ {
+ core *sp;
+ for (sp = first_state; sp; sp = sp->next)
+ {
+ state_table[sp->number].state = sp;
+ state_table[sp->number].accessing_symbol = sp->accessing_symbol;
+ }
+ }
+
+ {
+ shifts *sp;
+ for (sp = first_shift; sp; sp = sp->next)
+ state_table[sp->number].shift_table = sp;
+ }
+
+ {
+ reductions *rp;
+ for (rp = first_reduction; rp; rp = rp->next)
+ state_table[rp->number].reduction_table = rp;
+ }
+
+ /* Initializing the lookaheads members. Please note that it must be
+ performed after having set some of the other members which are
+ used below. Change with extreme caution. */
+ {
+ int i;
+ int count = 0;
+ for (i = 0; i < nstates; i++)
+ {
+ int k;
+ reductions *rp = state_table[i].reduction_table;
+ shifts *sp = state_table[i].shift_table;
+
+ state_table[i].lookaheads = count;
+
+ if (rp
+ && (rp->nreds > 1
+ || (sp && !ISVAR (state_table[sp->shifts[0]].accessing_symbol))))
+ count += rp->nreds;
+ else
+ state_table[i].consistent = 1;
+
+ if (sp)
+ for (k = 0; k < sp->nshifts; k++)
+ if (state_table[sp->shifts[k]].accessing_symbol
+ == error_token_number)
+ {
+ state_table[i].consistent = 0;
+ break;
+ }
+ }
+ state_table[nstates].lookaheads = count;
+ }
}
-static void
-set_maxrhs (void)
+/* Return the size of the longest ride hand side of the rules. */
+static size_t
+maxrhs (void)
{
short *itemp;
int length;
}
}
- maxrhs = max;
+ return max;
}
{
int i;
int j;
- int count;
- reductions *rp;
- shifts *sp;
short *np;
+ reductions *rp;
- consistent = NEW2 (nstates, char);
- lookaheads = NEW2 (nstates + 1, short);
-
- count = 0;
- for (i = 0; i < nstates; i++)
- {
- int k;
-
- lookaheads[i] = count;
+ size_t nLA = state_table[nstates].lookaheads;
+ if (!nLA)
+ nLA = 1;
- rp = reduction_table[i];
- sp = shift_table[i];
- if (rp && (rp->nreds > 1
- || (sp && !ISVAR (accessing_symbol[sp->shifts[0]]))))
- count += rp->nreds;
- else
- consistent[i] = 1;
-
- if (sp)
- for (k = 0; k < sp->nshifts; k++)
- {
- if (accessing_symbol[sp->shifts[k]] == error_token_number)
- {
- consistent[i] = 0;
- break;
- }
- }
- }
-
- lookaheads[nstates] = count;
-
- if (count == 0)
- {
- LA = NEW2 (1 * tokensetsize, unsigned);
- LAruleno = NEW2 (1, short);
- lookback = NEW2 (1, shorts *);
- }
- else
- {
- LA = NEW2 (count * tokensetsize, unsigned);
- LAruleno = NEW2 (count, short);
- lookback = NEW2 (count, shorts *);
- }
+ LA = XCALLOC (unsigned, nLA * tokensetsize);
+ LAruleno = XCALLOC (short, nLA);
+ lookback = XCALLOC (shorts *, nLA);
np = LAruleno;
for (i = 0; i < nstates; i++)
- {
- if (!consistent[i])
- {
- if ((rp = reduction_table[i]))
- for (j = 0; j < rp->nreds; j++)
- *np++ = rp->rules[j];
- }
- }
+ if (!state_table[i].consistent)
+ if ((rp = state_table[i].reduction_table))
+ for (j = 0; j < rp->nreds; j++)
+ *np++ = rp->rules[j];
}
int state2;
int state1;
- goto_map = NEW2 (nvars + 1, short) - ntokens;
- temp_map = NEW2 (nvars + 1, short) - ntokens;
+ goto_map = XCALLOC (short, nvars + 1) - ntokens;
+ temp_map = XCALLOC (short, nvars + 1) - ntokens;
ngotos = 0;
for (sp = first_shift; sp; sp = sp->next)
{
for (i = sp->nshifts - 1; i >= 0; i--)
{
- symbol = accessing_symbol[sp->shifts[i]];
+ symbol = state_table[sp->shifts[i]].accessing_symbol;
if (ISTOKEN (symbol))
break;
goto_map[nsyms] = ngotos;
temp_map[nsyms] = ngotos;
- from_state = NEW2 (ngotos, short);
- to_state = NEW2 (ngotos, short);
+ from_state = XCALLOC (short, ngotos);
+ to_state = XCALLOC (short, ngotos);
for (sp = first_shift; sp; sp = sp->next)
{
for (i = sp->nshifts - 1; i >= 0; i--)
{
state2 = sp->shifts[i];
- symbol = accessing_symbol[state2];
+ symbol = state_table[state2].accessing_symbol;
if (ISTOKEN (symbol))
break;
}
}
- FREE (temp_map + ntokens);
+ XFREE (temp_map + ntokens);
}
-/* Map_goto maps a state/symbol pair into its numeric representation. */
+/*----------------------------------------------------------.
+| Map a state/symbol pair into its numeric representation. |
+`----------------------------------------------------------*/
static int
map_goto (int state, int symbol)
high = middle - 1;
}
- berror ("map_goto");
-/* NOTREACHED */
+ assert (0);
+ /* NOTREACHED */
return 0;
}
int nwords;
nwords = ngotos * tokensetsize;
- F = NEW2 (nwords, unsigned);
+ F = XCALLOC (unsigned, nwords);
- reads = NEW2 (ngotos, short *);
- edge = NEW2 (ngotos + 1, short);
+ reads = XCALLOC (short *, ngotos);
+ edge = XCALLOC (short, ngotos + 1);
nedges = 0;
rowp = F;
for (i = 0; i < ngotos; i++)
{
stateno = to_state[i];
- sp = shift_table[stateno];
+ sp = state_table[stateno].shift_table;
if (sp)
{
for (j = 0; j < k; j++)
{
- symbol = accessing_symbol[sp->shifts[j]];
+ symbol = state_table[sp->shifts[j]].accessing_symbol;
if (ISVAR (symbol))
break;
SETBIT (rowp, symbol);
for (; j < k; j++)
{
- symbol = accessing_symbol[sp->shifts[j]];
+ symbol = state_table[sp->shifts[j]].accessing_symbol;
if (nullable[symbol])
edge[nedges++] = map_goto (stateno, symbol);
}
if (nedges)
{
- reads[i] = rp = NEW2 (nedges + 1, short);
+ reads[i] = rp = XCALLOC (short, nedges + 1);
for (j = 0; j < nedges; j++)
rp[j] = edge[j];
digraph (reads);
for (i = 0; i < ngotos; i++)
- {
- if (reads[i])
- FREE (reads[i]);
- }
+ XFREE (reads[i]);
- FREE (reads);
- FREE (edge);
+ XFREE (reads);
+ XFREE (edge);
}
int found;
shorts *sp;
- i = lookaheads[stateno];
- k = lookaheads[stateno + 1];
+ i = state_table[stateno].lookaheads;
+ k = state_table[stateno + 1].lookaheads;
found = 0;
while (!found && i < k)
{
i++;
}
- if (found == 0)
- berror ("add_lookback_edge");
+ assert (found);
- sp = NEW (shorts);
+ sp = XCALLOC (shorts, 1);
sp->next = lookback[i];
sp->value = gotono;
lookback[i] = sp;
int i;
int k;
- nedges = NEW2 (n, short);
+ nedges = XCALLOC (short, n);
for (i = 0; i < n; i++)
{
}
}
- new_R = NEW2 (n, short *);
- temp_R = NEW2 (n, short *);
+ new_R = XCALLOC (short *, n);
+ temp_R = XCALLOC (short *, n);
for (i = 0; i < n; i++)
{
k = nedges[i];
if (k > 0)
{
- sp = NEW2 (k + 1, short);
+ sp = XCALLOC (short, k + 1);
new_R[i] = sp;
temp_R[i] = sp;
sp[k] = -1;
}
}
- FREE (nedges);
+ XFREE (nedges);
for (i = 0; i < n; i++)
{
}
}
- FREE (temp_R);
+ XFREE (temp_R);
return new_R;
}
short *states;
short **new_includes;
- includes = NEW2 (ngotos, short *);
- edge = NEW2 (ngotos + 1, short);
- states = NEW2 (maxrhs + 1, short);
+ includes = XCALLOC (short *, ngotos);
+ edge = XCALLOC (short, ngotos + 1);
+ states = XCALLOC (short, maxrhs () + 1);
for (i = 0; i < ngotos; i++)
{
nedges = 0;
state1 = from_state[i];
- symbol1 = accessing_symbol[to_state[i]];
+ symbol1 = state_table[to_state[i]].accessing_symbol;
for (rulep = derives[symbol1]; *rulep > 0; rulep++)
{
states[0] = state1;
stateno = state1;
- for (rp = ritem + rrhs[*rulep]; *rp > 0; rp++)
+ for (rp = ritem + rule_table[*rulep].rhs; *rp > 0; rp++)
{
symbol2 = *rp;
- sp = shift_table[stateno];
+ sp = state_table[stateno].shift_table;
k = sp->nshifts;
for (j = 0; j < k; j++)
{
stateno = sp->shifts[j];
- if (accessing_symbol[stateno] == symbol2)
+ if (state_table[stateno].accessing_symbol == symbol2)
break;
}
states[length++] = stateno;
}
- if (!consistent[stateno])
+ if (!state_table[stateno].consistent)
add_lookback_edge (stateno, *rulep, i);
length--;
if (nedges)
{
- includes[i] = shortp = NEW2 (nedges + 1, short);
+ includes[i] = shortp = XCALLOC (short, nedges + 1);
for (j = 0; j < nedges; j++)
shortp[j] = edge[j];
shortp[nedges] = -1;
for (i = 0; i < ngotos; i++)
if (includes[i])
- FREE (includes[i]);
+ XFREE (includes[i]);
- FREE (includes);
+ XFREE (includes);
includes = new_includes;
- FREE (edge);
- FREE (states);
+ XFREE (edge);
+ XFREE (states);
}
digraph (includes);
for (i = 0; i < ngotos; i++)
- {
- if (includes[i])
- FREE (includes[i]);
- }
+ XFREE (includes[i]);
- FREE (includes);
+ XFREE (includes);
}
compute_lookaheads (void)
{
int i;
- int n;
- unsigned *fp1;
- unsigned *fp2;
- unsigned *fp3;
shorts *sp;
- unsigned *rowp;
- shorts *sptmp; /* JF */
-
- rowp = LA;
- n = lookaheads[nstates];
- for (i = 0; i < n; i++)
- {
- fp3 = rowp + tokensetsize;
- for (sp = lookback[i]; sp; sp = sp->next)
- {
- fp1 = rowp;
- fp2 = F + tokensetsize * sp->value;
- while (fp1 < fp3)
- *fp1++ |= *fp2++;
- }
-
- rowp = fp3;
- }
-
- for (i = 0; i < n; i++)
- {
- /* JF removed ref to freed storage */
- for (sp = lookback[i]; sp; sp = sptmp)
- {
- sptmp = sp->next;
- FREE (sp);
- }
- }
- FREE (lookback);
- FREE (F);
+ for (i = 0; i < state_table[nstates].lookaheads; i++)
+ for (sp = lookback[i]; sp; sp = sp->next)
+ {
+ unsigned *fp1 = LA (i);
+ unsigned *fp2 = F (sp->value);
+ while (fp1 < LA (i + 1))
+ *fp1++ |= *fp2++;
+ }
+
+ /* Free LOOKBACK. */
+ for (i = 0; i < state_table[nstates].lookaheads; i++)
+ LIST_FREE (shorts, lookback[i]);
+
+ XFREE (lookback);
+ XFREE (F);
}
tokensetsize = WORDSIZE (ntokens);
set_state_table ();
- set_accessing_symbol ();
- set_shift_table ();
- set_reduction_table ();
- set_maxrhs ();
initialize_LA ();
set_goto_map ();
initialize_F ();
projects / bison.git / blobdiff