/* Compute look-ahead criteria for Bison.
- Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004
- Free Software Foundation, Inc.
+ Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2006 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
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. */
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* Compute how to make the finite state machine deterministic; find
which rules need look-ahead in each state, and which look-ahead
tokens they accept. */
+#include <config.h>
#include "system.h"
#include <bitset.h>
state_number s;
goto_number *temp_map;
- CALLOC (goto_map, nvars + 1);
- CALLOC (temp_map, nvars + 1);
+ goto_map = xcalloc (nvars + 1, sizeof *goto_map);
+ temp_map = xnmalloc (nvars + 1, sizeof *temp_map);
ngotos = 0;
for (s = 0; s < nstates; ++s)
for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
{
ngotos++;
- if (! ngotos)
- abort ();
+
+ /* Abort if (ngotos + 1) would overflow. */
+ assert (ngotos != GOTO_NUMBER_MAXIMUM);
+
goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
}
}
{
- int k = 0;
+ goto_number k = 0;
int i;
for (i = ntokens; i < nsyms; i++)
{
temp_map[nsyms - ntokens] = ngotos;
}
- CALLOC (from_state, ngotos);
- CALLOC (to_state, ngotos);
+ from_state = xcalloc (ngotos, sizeof *from_state);
+ to_state = xcalloc (ngotos, sizeof *to_state);
for (s = 0; s < nstates; ++s)
{
int i;
for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
{
- int k = temp_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
+ goto_number k = temp_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
from_state[k] = s;
to_state[k] = sp->states[i]->number;
}
| Map a state/symbol pair into its numeric representation. |
`----------------------------------------------------------*/
-static int
+static goto_number
map_goto (state_number s0, symbol_number sym)
{
- int high;
- int low;
- int middle;
+ goto_number high;
+ goto_number low;
+ goto_number middle;
state_number s;
low = goto_map[sym - ntokens];
for (;;)
{
- if (high < low)
- abort ();
+ assert (low <= high);
middle = (low + high) / 2;
s = from_state[middle];
if (s == s0)
static void
initialize_F (void)
{
- goto_number **reads = CALLOC (reads, ngotos);
- goto_number *edge = CALLOC (edge, ngotos + 1);
- int nedges = 0;
+ goto_number **reads = xnmalloc (ngotos, sizeof *reads);
+ goto_number *edge = xnmalloc (ngotos + 1, sizeof *edge);
+ goto_number nedges = 0;
- int i;
+ goto_number i;
F = bitsetv_create (ngotos, ntokens, BITSET_FIXED);
edge[nedges++] = map_goto (stateno, sym);
}
- if (nedges)
+ if (nedges == 0)
+ reads[i] = NULL;
+ else
{
- CALLOC (reads[i], nedges + 1);
- memcpy (reads[i], edge, nedges * sizeof (edge[0]));
- reads[i][nedges] = -1;
+ reads[i] = xnmalloc (nedges + 1, sizeof reads[i][0]);
+ memcpy (reads[i], edge, nedges * sizeof edge[0]);
+ reads[i][nedges] = END_NODE;
nedges = 0;
}
}
static void
-add_lookback_edge (state *s, rule *r, int gotono)
+add_lookback_edge (state *s, rule *r, goto_number gotono)
{
int ri = state_reduction_find (s, r);
- goto_list *sp = MALLOC (sp, 1);
+ goto_list *sp = xmalloc (sizeof *sp);
sp->next = lookback[(s->reductions->look_ahead_tokens - LA) + ri];
sp->value = gotono;
lookback[(s->reductions->look_ahead_tokens - LA) + ri] = sp;
static void
build_relations (void)
{
- goto_number *edge = CALLOC (edge, ngotos + 1);
- state_number *states1 = CALLOC (states1, ritem_longest_rhs () + 1);
- int i;
+ goto_number *edge = xnmalloc (ngotos + 1, sizeof *edge);
+ state_number *states1 = xnmalloc (ritem_longest_rhs () + 1, sizeof *states1);
+ goto_number i;
- CALLOC (includes, ngotos);
+ includes = xnmalloc (ngotos, sizeof *includes);
for (i = 0; i < ngotos; i++)
{
{
bool done;
int length = 1;
- item_number *rp;
+ item_number const *rp;
state *s = states[from_state[i]];
states1[0] = s->number;
- for (rp = (*rulep)->rhs; *rp >= 0; rp++)
+ for (rp = (*rulep)->rhs; ! item_number_is_rule_number (*rp); rp++)
{
s = transitions_to (s->transitions,
item_number_as_symbol_number (*rp));
while (!done)
{
done = true;
+ /* Each rhs ends in an item number, and there is a
+ sentinel before the first rhs, so it is safe to
+ decrement RP here. */
rp--;
- /* JF added rp>=ritem && I hope to god its right! */
- if (rp >= ritem && ISVAR (*rp))
+ if (ISVAR (*rp))
{
/* Downcasting from item_number to symbol_number. */
edge[nedges++] = map_goto (states1[--length],
}
}
- if (nedges)
+ if (nedges == 0)
+ includes[i] = NULL;
+ else
{
int j;
- CALLOC (includes[i], nedges + 1);
+ includes[i] = xnmalloc (nedges + 1, sizeof includes[i][0]);
for (j = 0; j < nedges; j++)
includes[i][j] = edge[j];
- includes[i][nedges] = -1;
+ includes[i][nedges] = END_NODE;
}
}
static void
compute_FOLLOWS (void)
{
- int i;
+ goto_number i;
relation_digraph (includes, ngotos, &F);
nLA = 1;
pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
- CALLOC (lookback, nLA);
+ lookback = xcalloc (nLA, sizeof *lookback);
/* Initialize the members LOOK_AHEAD_TOKENS for each state whose reductions
require look-ahead tokens. */
projects / bison.git / blobdiff