- Copyright (C) 1984, 1986, 1989, 1992, 2000-2006, 2009-2010 Free
+ Copyright (C) 1984, 1986, 1989, 1992, 2000-2006, 2009-2013 Free
Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
static base_number **froms;
static base_number **tos;
static unsigned int **conflict_tos;
static base_number **froms;
static base_number **tos;
static unsigned int **conflict_tos;
static base_number *width;
/* For a given state, N = ACTROW[SYMBOL]:
static base_number *width;
/* For a given state, N = ACTROW[SYMBOL]:
- If N = 0, stands for `run the default action'.
- If N = MIN, stands for `raise a syntax error'.
- If N > 0, stands for `shift SYMBOL and go to n'.
- If N < 0, stands for `reduce -N'. */
+ If N = 0, stands for 'run the default action'.
+ If N = MIN, stands for 'raise a syntax error'.
+ If N > 0, stands for 'shift SYMBOL and go to n'.
+ If N < 0, stands for 'reduce -N'. */
typedef int action_number;
#define ACTION_NUMBER_MINIMUM INT_MIN
static action_number *actrow;
/* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the
typedef int action_number;
#define ACTION_NUMBER_MINIMUM INT_MIN
static action_number *actrow;
/* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the
- new vector number of VECTOR. We skip `empty' vectors (i.e.,
- TALLY[VECTOR] = 0), and call these `entries'. */
+ new vector number of VECTOR. We skip 'empty' vectors (i.e.,
+ TALLY[VECTOR] = 0), and call these 'entries'. */
-/*----------------------------------------------------------------.
-| If TABLE (and CHECK) appear to be small to be addressed at |
-| DESIRED, grow them. Note that TABLE[DESIRED] is to be used, so |
-| the desired size is at least DESIRED + 1. |
-`----------------------------------------------------------------*/
+/*-------------------------------------------------------------------.
+| If TABLE, CONFLICT_TABLE, and CHECK are too small to be addressed |
+| at DESIRED, grow them. TABLE[DESIRED] can be used, so the desired |
+| size is at least DESIRED + 1. |
+`-------------------------------------------------------------------*/
if (trace_flag & trace_resource)
fprintf (stderr, "growing table and check from: %d to %d\n",
if (trace_flag & trace_resource)
fprintf (stderr, "growing table and check from: %d to %d\n",
table = xnrealloc (table, table_size, sizeof *table);
conflict_table = xnrealloc (conflict_table, table_size,
table = xnrealloc (table, table_size, sizeof *table);
conflict_table = xnrealloc (conflict_table, table_size,
check = xnrealloc (check, table_size, sizeof *check);
for (/* Nothing. */; old_size < table_size; ++old_size)
check = xnrealloc (check, table_size, sizeof *check);
for (/* Nothing. */; old_size < table_size; ++old_size)
/*-------------------------------------------------------------------.
| For GLR parsers, for each conflicted token in S, as indicated |
/*-------------------------------------------------------------------.
| For GLR parsers, for each conflicted token in S, as indicated |
-| by non-zero entries in CONFLROW, create a list of possible |
-| reductions that are alternatives to the shift or reduction |
+| by non-zero entries in CONFLROW, create a list of possible |
+| reductions that are alternatives to the shift or reduction |
- conflrow[j] = conflict_list_cnt;
-
- /* Find all reductions for token J, and record all that do not
- match ACTROW[J]. */
- for (i = 0; i < reds->num; i += 1)
- if (bitset_test (reds->lookahead_tokens[i], j)
- && (actrow[j]
- != rule_number_as_item_number (reds->rules[i]->number)))
- {
- aver (0 < conflict_list_free);
- conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1;
- conflict_list_cnt += 1;
- conflict_list_free -= 1;
- }
-
- /* Leave a 0 at the end. */
- aver (0 < conflict_list_free);
- conflict_list[conflict_list_cnt] = 0;
- conflict_list_cnt += 1;
- conflict_list_free -= 1;
+ conflrow[j] = conflict_list_cnt;
+
+ /* Find all reductions for token J, and record all that do not
+ match ACTROW[J]. */
+ for (i = 0; i < reds->num; i += 1)
+ if (bitset_test (reds->lookahead_tokens[i], j)
+ && (actrow[j]
+ != rule_number_as_item_number (reds->rules[i]->number)))
+ {
+ aver (0 < conflict_list_free);
+ conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1;
+ conflict_list_cnt += 1;
+ conflict_list_free -= 1;
+ }
+
+ /* Leave a 0 at the end. */
+ aver (0 < conflict_list_free);
+ conflict_list[conflict_list_cnt] = 0;
+ conflict_list_cnt += 1;
+ conflict_list_free -= 1;
| default action (yydefact) for the state. In addition, ACTROW is |
| filled with what to do for each kind of token, index by symbol |
| number, with zero meaning do the default action. The value |
| default action (yydefact) for the state. In addition, ACTROW is |
| filled with what to do for each kind of token, index by symbol |
| number, with zero meaning do the default action. The value |
-| ACTION_NUMBER_MINIMUM, a very negative number, means this |
-| situation is an error. The parser recognizes this value |
-| specially. |
+| ACTION_NUMBER_MINIMUM, a very negative number, means this |
+| situation is an error. The parser recognizes this value |
+| specially. |
| |
| This is where conflicts are resolved. The loop over lookahead |
| rules considered lower-numbered rules last, and the last rule |
| |
| This is where conflicts are resolved. The loop over lookahead |
| rules considered lower-numbered rules last, and the last rule |
- /* and find each token which the rule finds acceptable
- to come next */
- BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0)
- {
- /* and record this rule as the rule to use if that
- token follows. */
- if (actrow[j] != 0)
- {
- conflicted = true;
- conflrow[j] = 1;
- }
- actrow[j] = rule_number_as_item_number (reds->rules[i]->number);
- }
+ /* and find each token which the rule finds acceptable
+ to come next */
+ BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0)
+ {
+ /* and record this rule as the rule to use if that
+ token follows. */
+ if (actrow[j] != 0)
+ {
+ conflicted = true;
+ conflrow[j] = 1;
+ }
+ actrow[j] = rule_number_as_item_number (reds->rules[i]->number);
+ }
actrow[sym] = state_number_as_int (shift_state->number);
/* Do not use any default reduction if there is a shift for
actrow[sym] = state_number_as_int (shift_state->number);
/* Do not use any default reduction if there is a shift for
- muscle_percent_define_get ("lr.default-reductions");
- if (0 != strcmp (default_reductions, "all") && !s->consistent)
+ muscle_percent_define_get ("lr.default-reduction");
+ if (STRNEQ (default_reductions, "most") && !s->consistent)
- {
- int max = 0;
- for (i = 0; i < reds->num; i++)
- {
- int count = 0;
- rule *r = reds->rules[i];
- symbol_number j;
-
- for (j = 0; j < ntokens; j++)
- if (actrow[j] == rule_number_as_item_number (r->number))
- count++;
-
- if (count > max)
- {
- max = count;
- default_reduction = r;
- }
- }
-
- /* GLR parsers need space for conflict lists, so we can't
- default conflicted entries. For non-conflicted entries
- or as long as we are not building a GLR parser,
- actions that match the default are replaced with zero,
- which means "use the default". */
-
- if (max > 0)
- {
- int j;
- for (j = 0; j < ntokens; j++)
- if (actrow[j]
+ {
+ int max = 0;
+ for (i = 0; i < reds->num; i++)
+ {
+ int count = 0;
+ rule *r = reds->rules[i];
+ symbol_number j;
+
+ for (j = 0; j < ntokens; j++)
+ if (actrow[j] == rule_number_as_item_number (r->number))
+ count++;
+
+ if (count > max)
+ {
+ max = count;
+ default_reduction = r;
+ }
+ }
+
+ /* GLR parsers need space for conflict lists, so we can't
+ default conflicted entries. For non-conflicted entries
+ or as long as we are not building a GLR parser,
+ actions that match the default are replaced with zero,
+ which means "use the default". */
+
+ if (max > 0)
+ {
+ int j;
+ for (j = 0; j < ntokens; j++)
+ if (actrow[j]
- if (count == 0)
- return;
-
- /* Allocate non defaulted actions. */
- froms[s] = sp = sp1 = xnmalloc (count, sizeof *sp1);
- tos[s] = sp2 = xnmalloc (count, sizeof *sp2);
- conflict_tos[s] = sp3 =
- nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL;
-
- /* Store non defaulted actions. */
- for (i = 0; i < ntokens; i++)
- if (actrow[i] != 0)
- {
- *sp1++ = i;
- *sp2++ = actrow[i];
- if (nondeterministic_parser)
- *sp3++ = conflrow[i];
- }
-
- tally[s] = count;
- width[s] = sp1[-1] - sp[0] + 1;
+ if (count)
+ {
+ /* Allocate non defaulted actions. */
+ base_number *sp1 = froms[s] = xnmalloc (count, sizeof *sp1);
+ base_number *sp2 = tos[s] = xnmalloc (count, sizeof *sp2);
+ unsigned int *sp3 = conflict_tos[s] =
+ nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL;
+
+ /* Store non defaulted actions. */
+ for (i = 0; i < ntokens; i++)
+ if (actrow[i] != 0)
+ {
+ *sp1++ = i;
+ *sp2++ = actrow[i];
+ if (nondeterministic_parser)
+ *sp3++ = conflrow[i];
+ }
+
+ tally[s] = count;
+ width[s] = sp1[-1] - froms[s][0] + 1;
+ }
int nconflict = nondeterministic_parser ? conflicts_total_count () : 0;
yydefact = xnmalloc (nstates, sizeof *yydefact);
int nconflict = nondeterministic_parser ? conflicts_total_count () : 0;
yydefact = xnmalloc (nstates, sizeof *yydefact);
- rule *default_reduction = action_row (states[i]);
- yydefact[i] = default_reduction ? default_reduction->number + 1 : 0;
- save_row (i);
-
- /* Now that the parser was computed, we can find which rules are
- really reduced, and which are not because of SR or RR
- conflicts. */
- if (!nondeterministic_parser)
- {
- for (j = 0; j < ntokens; ++j)
- if (actrow[j] < 0 && actrow[j] != ACTION_NUMBER_MINIMUM)
- rules[item_number_as_rule_number (actrow[j])].useful = true;
- if (yydefact[i])
- rules[yydefact[i] - 1].useful = true;
- }
+ rule_number r;
+ for (r = 0; r < nrules; ++r)
+ rules[r].useful = false;
+ {
+ state_number i;
+ for (i = 0; i < nstates; ++i)
+ {
+ rule *default_reduction = action_row (states[i]);
+ yydefact[i] = default_reduction ? default_reduction->number + 1 : 0;
+ save_row (i);
+
+ /* Now that the parser was computed, we can find which rules are
+ really reduced, and which are not because of SR or RR
+ conflicts. */
+ if (!nondeterministic_parser)
+ {
+ symbol_number j;
+ for (j = 0; j < ntokens; ++j)
+ if (actrow[j] < 0 && actrow[j] != ACTION_NUMBER_MINIMUM)
+ rules[item_number_as_rule_number (actrow[j])].useful = true;
+ if (yydefact[i])
+ rules[yydefact[i] - 1].useful = true;
+ }
+ }
+ }
goto_number begin = goto_map[sym - ntokens];
goto_number end = goto_map[sym - ntokens + 1];
/* Number of non default GOTO. */
goto_number begin = goto_map[sym - ntokens];
goto_number end = goto_map[sym - ntokens + 1];
/* Number of non default GOTO. */
- if (count == 0)
- return;
-
- /* Allocate room for non defaulted gotos. */
- froms[symno] = sp = sp1 = xnmalloc (count, sizeof *sp1);
- tos[symno] = sp2 = xnmalloc (count, sizeof *sp2);
-
- /* Store the state numbers of the non defaulted gotos. */
- for (i = begin; i < end; i++)
- if (to_state[i] != default_state)
- {
- *sp1++ = from_state[i];
- *sp2++ = to_state[i];
- }
-
- tally[symno] = count;
- width[symno] = sp1[-1] - sp[0] + 1;
+ if (count)
+ {
+ /* Allocate room for non defaulted gotos. */
+ vector_number symno = symbol_number_to_vector_number (sym);
+ base_number *sp1 = froms[symno] = xnmalloc (count, sizeof *sp1);
+ base_number *sp2 = tos[symno] = xnmalloc (count, sizeof *sp2);
+
+ /* Store the state numbers of the non defaulted gotos. */
+ for (i = begin; i < end; i++)
+ if (to_state[i] != default_state)
+ {
+ *sp1++ = from_state[i];
+ *sp2++ = to_state[i];
+ }
+
+ tally[symno] = count;
+ width[symno] = sp1[-1] - froms[symno][0] + 1;
+ }
-/*-------------------------------------------------------------.
-| Return `the' most common destination GOTO on SYM (a nterm). |
-`-------------------------------------------------------------*/
+/*----------------------------------------------------------------.
+| The default state for SYM: the state which is 'the' most common |
+| GOTO destination on SYM (an nterm). |
+`----------------------------------------------------------------*/
- state_number s;
- goto_number i;
- goto_number m = goto_map[sym - ntokens];
- goto_number n = goto_map[sym - ntokens + 1];
- state_number default_state = -1;
- size_t max = 0;
-
- if (m == n)
- return -1;
-
- for (s = 0; s < nstates; s++)
- state_count[s] = 0;
-
- for (i = m; i < n; i++)
- state_count[to_state[i]]++;
-
- for (s = 0; s < nstates; s++)
- if (state_count[s] > max)
- {
- max = state_count[s];
- default_state = s;
- }
+ goto_number begin = goto_map[sym - ntokens];
+ goto_number end = goto_map[sym - ntokens + 1];
+ state_number res = -1;
+ if (begin != end)
+ {
+ size_t max = 0;
+ goto_number i;
+ state_number s;
+
+ for (s = 0; s < nstates; s++)
+ state_count[s] = 0;
+
+ for (i = begin; i < end; i++)
+ state_count[to_state[i]]++;
+
+ for (s = 0; s < nstates; s++)
+ if (max < state_count[s])
+ {
+ max = state_count[s];
+ res = s;
+ }
+ }
+ return res;
- if (nstates <= i)
- return -1;
-
- t = tally[i];
- w = width[i];
-
- /* If VECTOR has GLR conflicts, return -1 */
- if (conflict_tos[i] != NULL)
- {
- int j;
- for (j = 0; j < t; j += 1)
- if (conflict_tos[i][j] != 0)
- return -1;
- }
-
- for (prev = vector - 1; prev >= 0; prev--)
- vector_number j = order[prev];
- int k;
- int match = 1;
-
- /* Given how ORDER was computed, if the WIDTH or TALLY is
- different, there cannot be a matching state. */
- if (width[j] != w || tally[j] != t)
- return -1;
-
- for (k = 0; match && k < t; k++)
- if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k]
- || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0))
- match = 0;
-
- if (match)
- return j;
+ size_t t = tally[i];
+ int w = width[i];
+ int prev;
+
+ /* If VECTOR has GLR conflicts, return -1 */
+ if (conflict_tos[i] != NULL)
+ {
+ int j;
+ for (j = 0; j < t; j += 1)
+ if (conflict_tos[i][j] != 0)
+ return -1;
+ }
+
+ for (prev = vector - 1; 0 <= prev; prev--)
+ {
+ vector_number j = order[prev];
+ /* Given how ORDER was computed, if the WIDTH or TALLY is
+ different, there cannot be a matching state. */
+ if (width[j] != w || tally[j] != t)
+ return -1;
+ else
+ {
+ bool match = true;
+ int k;
+ for (k = 0; match && k < t; k++)
+ if (tos[j][k] != tos[i][k]
+ || froms[j][k] != froms[i][k]
+ || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0))
+ match = false;
+ if (match)
+ return j;
+ }
+ }
base_number *from = froms[i];
base_number *to = tos[i];
unsigned int *conflict_to = conflict_tos[i];
aver (t != 0);
base_number *from = froms[i];
base_number *to = tos[i];
unsigned int *conflict_to = conflict_tos[i];
aver (t != 0);
-
- aver (j < table_size);
-
- for (k = 0; ok && k < t; k++)
- {
- loc = j + state_number_as_int (from[k]);
- if (table_size <= loc)
- table_grow (loc);
-
- if (table[loc] != 0)
- ok = false;
- }
-
- for (k = 0; ok && k < vector; k++)
- if (pos[k] == j)
- ok = false;
+ aver (res < table_size);
+ {
+ int k;
+ for (k = 0; ok && k < t; k++)
+ {
+ int loc = res + state_number_as_int (from[k]);
+ if (table_size <= loc)
+ table_grow (loc);
+
+ if (table[loc] != 0)
+ ok = false;
+ }
+
+ if (ok)
+ for (k = 0; k < vector; k++)
+ if (pos[k] == res)
+ ok = false;
+ }
- {
- for (k = 0; k < t; k++)
- {
- loc = j + from[k];
- table[loc] = to[k];
- if (nondeterministic_parser && conflict_to != NULL)
- conflict_table[loc] = conflict_to[k];
- check[loc] = from[k];
- }
-
- while (table[lowzero] != 0)
- lowzero++;
-
- if (loc > high)
- high = loc;
-
- aver (BASE_MINIMUM <= j && j <= BASE_MAXIMUM);
- return j;
- }
+ {
+ int loc;
+ int k;
+ for (k = 0; k < t; k++)
+ {
+ loc = res + state_number_as_int (from[k]);
+ table[loc] = to[k];
+ if (nondeterministic_parser && conflict_to != NULL)
+ conflict_table[loc] = conflict_to[k];
+ check[loc] = from[k];
+ }
+
+ while (table[lowzero] != 0)
+ lowzero++;
+
+ if (high < loc)
+ high = loc;
+
+ aver (BASE_MINIMUM <= res && res <= BASE_MAXIMUM);
+ return res;
+ }
- /* A new set of state actions, or a nonterminal. */
- place = pack_vector (i);
+ /* A new set of state actions, or a nonterminal. */
+ place = pack_vector (i);
correlated. In particular the signedness is not taken into
account. But it's not useless. */
verify (sizeof nstates <= sizeof nvectors
correlated. In particular the signedness is not taken into
account. But it's not useless. */
verify (sizeof nstates <= sizeof nvectors
projects / bison.git / blobdiff