X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/f16b08196c780556cbf50691e2944960aebc46f6..22b081deb7ab1d0ec7a279e5213fa7fdc2c85207:/src/lalr.c diff --git a/src/lalr.c b/src/lalr.c index 15213422..1ceda002 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -1,7 +1,7 @@ /* Compute lookahead criteria for Bison. - Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005, - 2006, 2007 Free Software Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 2000-2012 Free Software Foundation, + Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -19,8 +19,7 @@ along with this program. If not, see . */ -/* Compute how to make the finite state machine deterministic; find - which rules need lookahead in each state, and which lookahead +/* Find which rules need lookahead in each state, and which lookahead tokens they accept. */ #include @@ -28,7 +27,6 @@ #include #include -#include #include "LR0.h" #include "complain.h" @@ -36,15 +34,17 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" +#include "muscle-tab.h" #include "nullable.h" #include "reader.h" #include "relation.h" #include "symtab.h" goto_number *goto_map; -static goto_number ngotos; +goto_number ngotos; state_number *from_state; state_number *to_state; +bitsetv goto_follows = NULL; /* Linked list of goto numbers. */ typedef struct goto_list @@ -63,17 +63,13 @@ static bitsetv LA = NULL; size_t nLA; -/* And for the famous F variable, which name is so descriptive that a - comment is hardly needed. . */ -static bitsetv F = NULL; - static goto_number **includes; static goto_list **lookback; -static void +void set_goto_map (void) { state_number s; @@ -88,14 +84,14 @@ set_goto_map (void) transitions *sp = states[s]->transitions; int i; for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i) - { - ngotos++; + { + ngotos++; - /* Abort if (ngotos + 1) would overflow. */ - aver (ngotos != GOTO_NUMBER_MAXIMUM); + /* Abort if (ngotos + 1) would overflow. */ + aver (ngotos != GOTO_NUMBER_MAXIMUM); - goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++; - } + goto_map[TRANSITION_SYMBOL (sp, i) - ntokens]++; + } } { @@ -103,8 +99,8 @@ set_goto_map (void) int i; for (i = ntokens; i < nsyms; i++) { - temp_map[i - ntokens] = k; - k += goto_map[i - ntokens]; + temp_map[i - ntokens] = k; + k += goto_map[i - ntokens]; } for (i = ntokens; i < nsyms; i++) @@ -122,23 +118,18 @@ set_goto_map (void) transitions *sp = states[s]->transitions; int i; for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i) - { - goto_number k = temp_map[TRANSITION_SYMBOL (sp, i) - ntokens]++; - from_state[k] = s; - to_state[k] = sp->states[i]->number; - } + { + goto_number k = temp_map[TRANSITION_SYMBOL (sp, i) - ntokens]++; + from_state[k] = s; + to_state[k] = sp->states[i]->number; + } } free (temp_map); } - -/*----------------------------------------------------------. -| Map a state/symbol pair into its numeric representation. | -`----------------------------------------------------------*/ - -static goto_number +goto_number map_goto (state_number s0, symbol_number sym) { goto_number high; @@ -155,11 +146,11 @@ map_goto (state_number s0, symbol_number sym) middle = (low + high) / 2; s = from_state[middle]; if (s == s0) - return middle; + return middle; else if (s < s0) - low = middle + 1; + low = middle + 1; else - high = middle - 1; + high = middle - 1; } } @@ -173,7 +164,7 @@ initialize_F (void) goto_number i; - F = bitsetv_create (ngotos, ntokens, BITSET_FIXED); + goto_follows = bitsetv_create (ngotos, ntokens, BITSET_FIXED); for (i = 0; i < ngotos; i++) { @@ -182,27 +173,27 @@ initialize_F (void) int j; FOR_EACH_SHIFT (sp, j) - bitset_set (F[i], TRANSITION_SYMBOL (sp, j)); + bitset_set (goto_follows[i], TRANSITION_SYMBOL (sp, j)); for (; j < sp->num; j++) - { - symbol_number sym = TRANSITION_SYMBOL (sp, j); - if (nullable[sym - ntokens]) - edge[nedges++] = map_goto (stateno, sym); - } + { + symbol_number sym = TRANSITION_SYMBOL (sp, j); + if (nullable[sym - ntokens]) + edge[nedges++] = map_goto (stateno, sym); + } if (nedges == 0) - reads[i] = NULL; + reads[i] = NULL; else - { - reads[i] = xnmalloc (nedges + 1, sizeof reads[i][0]); - memcpy (reads[i], edge, nedges * sizeof edge[0]); - reads[i][nedges] = END_NODE; - nedges = 0; - } + { + reads[i] = xnmalloc (nedges + 1, sizeof reads[i][0]); + memcpy (reads[i], edge, nedges * sizeof edge[0]); + reads[i][nedges] = END_NODE; + nedges = 0; + } } - relation_digraph (reads, ngotos, &F); + relation_digraph (reads, ngotos, &goto_follows); for (i = 0; i < ngotos; i++) free (reads[i]); @@ -240,53 +231,53 @@ build_relations (void) rule **rulep; for (rulep = derives[symbol1 - ntokens]; *rulep; rulep++) - { - bool done; - int length = 1; - item_number const *rp; - state *s = states[from_state[i]]; - states1[0] = s->number; - - for (rp = (*rulep)->rhs; ! item_number_is_rule_number (*rp); rp++) - { - s = transitions_to (s->transitions, - item_number_as_symbol_number (*rp)); - states1[length++] = s->number; - } - - if (!s->consistent) - add_lookback_edge (s, *rulep, i); - - length--; - done = false; - 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--; - if (ISVAR (*rp)) - { - /* Downcasting from item_number to symbol_number. */ - edge[nedges++] = map_goto (states1[--length], - item_number_as_symbol_number (*rp)); - if (nullable[*rp - ntokens]) - done = false; - } - } - } + { + bool done; + int length = 1; + item_number const *rp; + state *s = states[from_state[i]]; + states1[0] = s->number; + + for (rp = (*rulep)->rhs; ! item_number_is_rule_number (*rp); rp++) + { + s = transitions_to (s->transitions, + item_number_as_symbol_number (*rp)); + states1[length++] = s->number; + } + + if (!s->consistent) + add_lookback_edge (s, *rulep, i); + + length--; + done = false; + while (!done) + { + done = true; + /* Each rhs ends in a rule number, and there is a + sentinel (ritem[-1]=0) before the first rhs, so it is safe to + decrement RP here. */ + rp--; + if (ISVAR (*rp)) + { + /* Downcasting from item_number to symbol_number. */ + edge[nedges++] = map_goto (states1[--length], + item_number_as_symbol_number (*rp)); + if (nullable[*rp - ntokens]) + done = false; + } + } + } if (nedges == 0) - includes[i] = NULL; + includes[i] = NULL; else - { - int j; - includes[i] = xnmalloc (nedges + 1, sizeof includes[i][0]); - for (j = 0; j < nedges; j++) - includes[i][j] = edge[j]; - includes[i][nedges] = END_NODE; - } + { + int j; + includes[i] = xnmalloc (nedges + 1, sizeof includes[i][0]); + for (j = 0; j < nedges; j++) + includes[i][j] = edge[j]; + includes[i][nedges] = END_NODE; + } } free (edge); @@ -302,7 +293,7 @@ compute_FOLLOWS (void) { goto_number i; - relation_digraph (includes, ngotos, &F); + relation_digraph (includes, ngotos, &goto_follows); for (i = 0; i < ngotos; i++) free (includes[i]); @@ -319,14 +310,13 @@ compute_lookahead_tokens (void) for (i = 0; i < nLA; i++) for (sp = lookback[i]; sp; sp = sp->next) - bitset_or (LA[i], LA[i], F[sp->value]); + bitset_or (LA[i], LA[i], goto_follows[sp->value]); /* Free LOOKBACK. */ for (i = 0; i < nLA; i++) LIST_FREE (goto_list, lookback[i]); free (lookback); - bitsetv_free (F); } @@ -336,22 +326,31 @@ compute_lookahead_tokens (void) `----------------------------------------------------*/ static int -state_lookahead_tokens_count (state *s) +state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept) { int n_lookahead_tokens = 0; reductions *rp = s->reductions; transitions *sp = s->transitions; - /* We need a lookahead either to distinguish different - reductions (i.e., there are two or more), or to distinguish a - reduction from a shift. Otherwise, it is straightforward, - and the state is `consistent'. There is no need to check that - transition 0 hasn't been disabled before checking if it is a - shift since transitions are only disabled during conflict - resolution, and that hasn't happened yet. */ + /* Transitions are only disabled during conflict resolution, and that + hasn't happened yet, so there should be no need to check that + transition 0 hasn't been disabled before checking if it is a shift. + However, this check was performed at one time, so we leave it as an + aver. */ aver (sp->num == 0 || !TRANSITION_IS_DISABLED (sp, 0)); + + /* We need a lookahead either to distinguish different reductions + (i.e., there are two or more), or to distinguish a reduction from a + shift. Otherwise, it is straightforward, and the state is + `consistent'. However, do not treat a state with any reductions as + consistent unless it is the accepting state (because there is never + a lookahead token that makes sense there, and so no lookahead token + should be read) if the user has otherwise disabled default + reductions. */ if (rp->num > 1 - || (rp->num == 1 && sp->num && TRANSITION_IS_SHIFT (sp, 0))) + || (rp->num == 1 && sp->num && TRANSITION_IS_SHIFT (sp, 0)) + || (rp->num == 1 && rp->rules[0]->number != 0 + && default_reduction_only_for_accept)) n_lookahead_tokens += rp->num; else s->consistent = 1; @@ -364,33 +363,43 @@ state_lookahead_tokens_count (state *s) | Compute LA, NLA, and the lookahead_tokens members. | `----------------------------------------------------*/ -static void +void initialize_LA (void) { state_number i; bitsetv pLA; + bool default_reduction_only_for_accept; + { + char *default_reductions = + muscle_percent_define_get ("lr.default-reductions"); + default_reduction_only_for_accept = STREQ (default_reductions, "accepting"); + free (default_reductions); + } /* Compute the total number of reductions requiring a lookahead. */ nLA = 0; for (i = 0; i < nstates; i++) - nLA += state_lookahead_tokens_count (states[i]); + nLA += + state_lookahead_tokens_count (states[i], + default_reduction_only_for_accept); /* Avoid having to special case 0. */ if (!nLA) nLA = 1; pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED); - lookback = xcalloc (nLA, sizeof *lookback); /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions require lookahead tokens. */ for (i = 0; i < nstates; i++) { - int count = state_lookahead_tokens_count (states[i]); + int count = + state_lookahead_tokens_count (states[i], + default_reduction_only_for_accept); if (count) - { - states[i]->reductions->lookahead_tokens = pLA; - pLA += count; - } + { + states[i]->reductions->lookahead_tokens = pLA; + pLA += count; + } } } @@ -412,21 +421,21 @@ lookahead_tokens_print (FILE *out) int n_lookahead_tokens = 0; if (reds->lookahead_tokens) - for (k = 0; k < reds->num; ++k) - if (reds->lookahead_tokens[k]) - ++n_lookahead_tokens; + for (k = 0; k < reds->num; ++k) + if (reds->lookahead_tokens[k]) + ++n_lookahead_tokens; fprintf (out, "State %d: %d lookahead tokens\n", - i, n_lookahead_tokens); + i, n_lookahead_tokens); if (reds->lookahead_tokens) - for (j = 0; j < reds->num; ++j) - BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0) - { - fprintf (out, " on %d (%s) -> rule %d\n", - k, symbols[k]->tag, - reds->rules[j]->number); - }; + for (j = 0; j < reds->num; ++j) + BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0) + { + fprintf (out, " on %d (%s) -> rule %d\n", + k, symbols[k]->tag, + reds->rules[j]->number); + }; } fprintf (out, "Lookahead tokens: END\n"); } @@ -437,6 +446,7 @@ lalr (void) initialize_LA (); set_goto_map (); initialize_F (); + lookback = xcalloc (nLA, sizeof *lookback); build_relations (); compute_FOLLOWS (); compute_lookahead_tokens ();