#include "lalr.h"
#include "nullable.h"
#include "derives.h"
+#include "getargs.h"
/* All the decorated states, indexed by the state number. Warning:
there is a state_TABLE in LR0.c, but it is different and static.
short *LAruleno;
unsigned *LA;
+static int ngotos;
short *goto_map;
short *from_state;
short *to_state;
-extern void berror PARAMS ((const char *));
-
-static int infinity;
-static int ngotos;
-
/* And for the famous F variable, which name is so descriptive that a
comment is hardly needed. <grin>. */
static unsigned *F = NULL;
static short **includes;
static shorts **lookback;
+
+
+/*---------------------------------------------------------------.
+| digraph & traverse. |
+| |
+| The following variables are used as common storage between the |
+| two. |
+`---------------------------------------------------------------*/
+
static short **R;
static short *INDEX;
static short *VERTICES;
static int top;
-
+static int infinity;
static void
traverse (int i)
state_table[i].lookaheads = count;
if (rp
- && (rp->nreds > 1
- || (sp && !ISVAR (state_table[sp->shifts[0]].accessing_symbol))))
+ && (rp->nreds > 1 || (sp && SHIFT_IS_SHIFT (sp, 0))))
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)
+ if (SHIFT_IS_ERROR (sp, k))
{
state_table[i].consistent = 0;
break;
}
-/*------------------------------------------.
-| Return the size of the longest rule RHS. |
-`------------------------------------------*/
-
-static size_t
-maxrhs (void)
-{
- short *itemp;
- int length;
- int max;
-
- length = 0;
- max = 0;
- for (itemp = ritem; *itemp; itemp++)
- {
- if (*itemp > 0)
- {
- length++;
- }
- else
- {
- if (length > max)
- max = length;
- length = 0;
- }
- }
-
- return max;
-}
-
-
static void
initialize_LA (void)
{
ngotos = 0;
for (sp = first_shift; sp; sp = sp->next)
{
- for (i = sp->nshifts - 1; i >= 0; i--)
+ for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
{
symbol = state_table[sp->shifts[i]].accessing_symbol;
- if (ISTOKEN (symbol))
- break;
-
if (ngotos == MAXSHORT)
fatal (_("too many gotos (max %d)"), MAXSHORT);
for (sp = first_shift; sp; sp = sp->next)
{
state1 = sp->number;
- for (i = sp->nshifts - 1; i >= 0; i--)
+ for (i = sp->nshifts - 1; i >= 0 && SHIFT_IS_GOTO (sp, i); --i)
{
state2 = sp->shifts[i];
symbol = state_table[state2].accessing_symbol;
- if (ISTOKEN (symbol))
- break;
-
k = temp_map[symbol]++;
from_state[k] = state1;
to_state[k] = state2;
static void
initialize_F (void)
{
- int i;
- int j;
- short *edge;
- unsigned *rowp;
- short *rp;
- short **reads;
- int nedges;
- int symbol;
- int nwords;
+ short **reads = XCALLOC (short *, ngotos);
+ short *edge = XCALLOC (short, ngotos + 1);
+ int nedges = 0;
- nwords = ngotos * tokensetsize;
- F = XCALLOC (unsigned, nwords);
+ int i;
- reads = XCALLOC (short *, ngotos);
- edge = XCALLOC (short, ngotos + 1);
- nedges = 0;
+ F = XCALLOC (unsigned, ngotos * tokensetsize);
- rowp = F;
for (i = 0; i < ngotos; i++)
{
int stateno = to_state[i];
if (sp)
{
- for (j = 0; j < sp->nshifts; j++)
+ int j;
+ for (j = 0; j < sp->nshifts && SHIFT_IS_SHIFT (sp, j); j++)
{
- symbol = state_table[sp->shifts[j]].accessing_symbol;
- if (ISVAR (symbol))
- break;
- SETBIT (rowp, symbol);
+ int symbol = state_table[sp->shifts[j]].accessing_symbol;
+ SETBIT (F + i * tokensetsize, symbol);
}
for (; j < sp->nshifts; j++)
{
- symbol = state_table[sp->shifts[j]].accessing_symbol;
+ int symbol = state_table[sp->shifts[j]].accessing_symbol;
if (nullable[symbol])
edge[nedges++] = map_goto (stateno, symbol);
}
if (nedges)
{
- reads[i] = rp = XCALLOC (short, nedges + 1);
-
- for (j = 0; j < nedges; j++)
- rp[j] = edge[j];
-
- rp[nedges] = -1;
+ reads[i] = XCALLOC (short, nedges + 1);
+ shortcpy (reads[i], edge, nedges);
+ reads[i][nedges] = -1;
nedges = 0;
}
}
-
- rowp += tokensetsize;
}
digraph (reads);
}
-static short **
-transpose (short **R_arg, int n)
+static void
+matrix_print (FILE *out, short **matrix, int n)
{
- short **new_R;
- short **temp_R;
- short *nedges;
- int i;
+ int i, j;
- nedges = XCALLOC (short, n);
+ for (i = 0; i < n; ++i)
+ {
+ fprintf (out, "%3d: ", i);
+ if (matrix[i])
+ for (j = 0; matrix[i][j] != -1; ++j)
+ fprintf (out, "%3d ", matrix[i][j]);
+ fputc ('\n', out);
+ }
+ fputc ('\n', out);
+}
- for (i = 0; i < n; i++)
+/*-------------------------------------------------------------------.
+| Return the transpose of R_ARG, of size N. Destroy R_ARG, as it is |
+| replaced with the result. |
+| |
+| R_ARG[I] is NULL or a -1 terminated list of numbers. |
+| |
+| RESULT[NUM] is NULL or the -1 terminated list of the I such as NUM |
+| is in R_ARG[I]. |
+`-------------------------------------------------------------------*/
+
+static short **
+transpose (short **R_arg, int n)
+{
+ /* The result. */
+ short **new_R = XCALLOC (short *, n);
+ /* END_R[I] -- next entry of NEW_R[I]. */
+ short **end_R = XCALLOC (short *, n);
+ /* NEDGES[I] -- total size of NEW_R[I]. */
+ short *nedges = XCALLOC (short, n);
+ int i, j;
+
+ if (trace_flag)
{
- short *sp = R_arg[i];
- if (sp)
- {
- while (*sp >= 0)
- nedges[*sp++]++;
- }
+ fputs ("transpose: input\n", stderr);
+ matrix_print (stderr, R_arg, n);
}
- new_R = XCALLOC (short *, n);
- temp_R = XCALLOC (short *, n);
+ /* Count. */
+ for (i = 0; i < n; i++)
+ if (R_arg[i])
+ for (j = 0; R_arg[i][j] >= 0; ++j)
+ ++nedges[R_arg[i][j]];
+ /* Allocate. */
for (i = 0; i < n; i++)
if (nedges[i] > 0)
{
short *sp = XCALLOC (short, nedges[i] + 1);
- new_R[i] = sp;
- temp_R[i] = sp;
sp[nedges[i]] = -1;
+ new_R[i] = sp;
+ end_R[i] = sp;
}
- XFREE (nedges);
+ /* Store. */
+ for (i = 0; i < n; i++)
+ if (R_arg[i])
+ for (j = 0; R_arg[i][j] >= 0; ++j)
+ {
+ *end_R[R_arg[i][j]] = i;
+ ++end_R[R_arg[i][j]];
+ }
+ free (nedges);
+ free (end_R);
+
+ /* Free the input: it is replaced with the result. */
for (i = 0; i < n; i++)
+ XFREE (R_arg[i]);
+ free (R_arg);
+
+ if (trace_flag)
{
- short *sp = R_arg[i];
- if (sp)
- while (*sp >= 0)
- *temp_R[*sp++]++ = i;
+ fputs ("transpose: output\n", stderr);
+ matrix_print (stderr, new_R, n);
}
- XFREE (temp_R);
-
return new_R;
}
static void
build_relations (void)
{
+ short *edge = XCALLOC (short, ngotos + 1);
+ short *states = XCALLOC (short, ritem_longest_rhs () + 1);
int i;
- int j;
- short *rulep;
- short *rp;
- int nedges;
- int done;
- int state1;
- int stateno;
- int symbol1;
- short *edge;
- short *states;
- short **new_includes;
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 = state_table[to_state[i]].accessing_symbol;
+ int nedges = 0;
+ int state1 = from_state[i];
+ int symbol1 = state_table[to_state[i]].accessing_symbol;
+ short *rulep;
for (rulep = derives[symbol1]; *rulep > 0; rulep++)
{
+ int done;
int length = 1;
+ int stateno = state1;
+ short *rp;
states[0] = state1;
- stateno = state1;
for (rp = ritem + rule_table[*rulep].rhs; *rp > 0; rp++)
{
- int symbol2 = *rp;
shifts *sp = state_table[stateno].shift_table;
-
+ int j;
for (j = 0; j < sp->nshifts; j++)
{
stateno = sp->shifts[j];
- if (state_table[stateno].accessing_symbol == symbol2)
+ if (state_table[stateno].accessing_symbol == *rp)
break;
}
if (nedges)
{
+ int j;
includes[i] = XCALLOC (short, nedges + 1);
for (j = 0; j < nedges; j++)
includes[i][j] = edge[j];
}
}
- new_includes = transpose (includes, ngotos);
-
- for (i = 0; i < ngotos; i++)
- XFREE (includes[i]);
- XFREE (includes);
-
- includes = new_includes;
-
XFREE (edge);
XFREE (states);
+
+ includes = transpose (includes, ngotos);
}
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++;
+ int size = LA (i + 1) - LA (i);
+ int j;
+ for (j = 0; j < size; ++j)
+ LA (i)[j] |= F (sp->value)[j];
}
/* Free LOOKBACK. */
projects / bison.git / blobdiff