X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/03c07b039448552b5ac6c51076b88c2f15b0307f..bfdcc3a0b273c116e01d289ce52d400f22e4da14:/src/lalr.c?ds=inline diff --git a/src/lalr.c b/src/lalr.c index 9f5d43f3..98661544 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, 2008, 2009 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,16 +34,17 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" -#include "muscle_tab.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 @@ -64,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; @@ -134,12 +129,7 @@ set_goto_map (void) } - -/*----------------------------------------------------------. -| 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; @@ -174,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++) { @@ -183,7 +173,7 @@ 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++) { @@ -203,7 +193,7 @@ initialize_F (void) } } - relation_digraph (reads, ngotos, &F); + relation_digraph (reads, ngotos, &goto_follows); for (i = 0; i < ngotos; i++) free (reads[i]); @@ -264,7 +254,7 @@ build_relations (void) { done = true; /* Each rhs ends in a rule number, and there is a - sentinel before the first rhs, so it is safe to + sentinel (ritem[-1]=0) before the first rhs, so it is safe to decrement RP here. */ rp--; if (ISVAR (*rp)) @@ -303,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]); @@ -320,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); } @@ -337,7 +326,7 @@ compute_lookahead_tokens (void) `----------------------------------------------------*/ static int -state_lookahead_tokens_count (state *s, bool default_rule_only_for_accept) +state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept) { int n_lookahead_tokens = 0; reductions *rp = s->reductions; @@ -353,14 +342,15 @@ state_lookahead_tokens_count (state *s, bool default_rule_only_for_accept) /* 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, for states that have any rules, treat only - the accepting state as consistent (since 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 rules. */ + `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 && rp->rules[0]->number != 0 - && default_rule_only_for_accept)) + && default_reduction_only_for_accept)) n_lookahead_tokens += rp->num; else s->consistent = 1; @@ -373,36 +363,39 @@ state_lookahead_tokens_count (state *s, bool default_rule_only_for_accept) | Compute LA, NLA, and the lookahead_tokens members. | `----------------------------------------------------*/ -static void +void initialize_LA (void) { state_number i; bitsetv pLA; - bool default_rule_only_for_accept; + bool default_reduction_only_for_accept; { - char *default_rules = muscle_percent_define_get ("lr.default_rules"); - default_rule_only_for_accept = 0 == strcmp (default_rules, "accepting"); - free (default_rules); + char *default_reductions = + muscle_percent_define_get ("lr.default-reductions"); + default_reduction_only_for_accept = + 0 == strcmp (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], default_rule_only_for_accept); + 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], default_rule_only_for_accept); + state_lookahead_tokens_count (states[i], + default_reduction_only_for_accept); if (count) { states[i]->reductions->lookahead_tokens = pLA; @@ -454,6 +447,7 @@ lalr (void) initialize_LA (); set_goto_map (); initialize_F (); + lookback = xcalloc (nLA, sizeof *lookback); build_relations (); compute_FOLLOWS (); compute_lookahead_tokens ();