Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-13 14:23:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

For consistency, use lookahead' instead of look-ahead' or

Browse Source 
`look_ahead'.  Discussed starting at
<http://lists.gnu.org/archive/html/bison-patches/2006-01/msg00049.html>
and then at
<http://lists.gnu.org/archive/html/bison-patches/2006-06/msg00017.html>.
* NEWS: For the next release, note the change to `--report'.
* TODO, doc/bison.1: Update English.
* doc/bison.texinfo: Update English.
(Understanding Your Parser, Bison Options): Document as
`--report=lookahead' rather than `--report=look-ahead'.
* src/conflicts.c: Update English in comments.
(lookahead_set): Rename from look_ahead_set.
(flush_reduce): Rename argument look_ahead_tokens to lookahead_tokens.
(resolve_sr_conflict): Rename local look_ahead_tokens to
lookahead_tokens, and update other uses.
(flush_shift, set_conflicts, conflicts_solve, count_sr_conflicts,
count_rr_conflicts, conflicts_free): Update uses.
* src/getargs.c (report_args): Move "lookahead" before alternate
spellings.
(report_types): Update uses.
(usage): For `--report' usage description, state `lookahead' spelling
rather than `look-ahead'.
* src/getargs.h (report.report_lookahead_tokens): Rename from
report_look_ahead_tokens.
* src/lalr.c: Update English in comments.
(compute_lookahead_tokens): Rename from compute_look_ahead_tokens.
(state_lookahead_tokens_count): Rename from
state_look_ahead_tokens_count.
Rename local n_look_ahead_tokens to n_lookahead_tokens.
(lookahead_tokens_print): Rename from look_ahead_tokens_print.
Rename local n_look_ahead_tokens to n_lookahead_tokens.
Update other uses.
Update English in output.
(add_lookback_edge, initialize_LA, lalr, lalr_free): Update uses.
* src/print.c: Update English in comments.
(lookahead_set): Rename from look_ahead_set.
(print_reduction): Rename argument lookahead_token from
look_ahead_token.
(print_core, state_default_rule, print_reductions, print_results):
Update uses.
* src/print_graph.c: Update English in comments.
(print_core): Update uses.
* src/state.c: Update English in comments.
(reductions_new): Update uses.
(state_rule_lookahead_tokens_print): Rename from
state_rule_look_ahead_tokens_print, and update other uses.
* src/state.h: Update English in comments.
(reductions.lookahead_tokens): Rename from look_ahead_tokens.
(state_rule_lookahead_tokens_print): Rename from
state_rule_look_ahead_tokens_print.
* src/tables.c: Update English in comments.
(conflict_row, action_row): Update uses.
* tests/glr-regression.at
(Incorrect lookahead during deterministic GLR,
Incorrect lookahead during nondeterministic GLR): Rename
print_look_ahead to print_lookahead.
* tests/torture.at: Update English in comments.
(AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR): Rename from
AT_DATA_LOOK_AHEAD_TOKENS_GRAMMAR.
(Many lookahead tokens): Update uses.
* data/glr.c: Update English in comments.
* lalr1.cc: Likewise.
* yacc.c: Likewise.
* src/conflicts.h: Likewise.
* src/lalr.h: Likewise.
* src/main.c: Likewise.
* src/output.c: Likewise.
* src/parse-gram.c: Likewise.
* src/tables.h: Likewise.
* tests/calc.at: Likewise.
This commit is contained in:
Joel E. Denny
2006-06-10 03:02:23 +00:00
parent 3c40d0b52d
commit 742e4900c8
26 changed files with 361 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/conflicts.c
View File

@@ -1,4 +1,4 @@
/* Find and resolve or report look-ahead conflicts for bison,
/* Find and resolve or report lookahead conflicts for bison,
Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
@@ -43,7 +43,7 @@ static char *conflicts;
static struct obstack solved_conflicts_obstack;
static bitset shift_set;
static bitset look_ahead_set;
static bitset lookahead_set;
@@ -147,7 +147,7 @@ flush_shift (state *s, int token)
transitions *trans = s->transitions;
int i;
bitset_reset (look_ahead_set, token);
bitset_reset (lookahead_set, token);
for (i = 0; i < trans->num; i++)
if (!TRANSITION_IS_DISABLED (trans, i)
&& TRANSITION_SYMBOL (trans, i) == token)
@@ -157,14 +157,14 @@ flush_shift (state *s, int token)
/*--------------------------------------------------------------------.
| Turn off the reduce recorded for the specified token for the |
| specified look-ahead. Used when we resolve a shift-reduce conflict |
| specified lookahead. Used when we resolve a shift-reduce conflict |
| in favor of the shift. |
`--------------------------------------------------------------------*/
static void
flush_reduce (bitset look_ahead_tokens, int token)
flush_reduce (bitset lookahead_tokens, int token)
{
bitset_reset (look_ahead_tokens, token);
bitset_reset (lookahead_tokens, token);
}
@@ -174,7 +174,7 @@ flush_reduce (bitset look_ahead_tokens, int token)
| rule has a precedence. A conflict is resolved by modifying the |
| shift or reduce tables so that there is no longer a conflict. |
| |
| RULENO is the number of the look-ahead bitset to consider. |
| RULENO is the number of the lookahead bitset to consider. |
| |
| ERRORS can be used to store discovered explicit errors. |
`------------------------------------------------------------------*/
@@ -187,12 +187,12 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
/* Find the rule to reduce by to get precedence of reduction. */
rule *redrule = reds->rules[ruleno];
int redprec = redrule->prec->prec;
bitset look_ahead_tokens = reds->look_ahead_tokens[ruleno];
bitset lookahead_tokens = reds->lookahead_tokens[ruleno];
int nerrs = 0;
for (i = 0; i < ntokens; i++)
if (bitset_test (look_ahead_tokens, i)
&& bitset_test (look_ahead_set, i)
if (bitset_test (lookahead_tokens, i)
&& bitset_test (lookahead_set, i)
&& symbols[i]->prec)
{
/* Shift-reduce conflict occurs for token number i
@@ -206,7 +206,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
else if (symbols[i]->prec > redprec)
{
log_resolution (redrule, i, shift_resolution);
flush_reduce (look_ahead_tokens, i);
flush_reduce (lookahead_tokens, i);
}
else
/* Matching precedence levels.
@@ -221,7 +221,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
case right_assoc:
log_resolution (redrule, i, right_resolution);
flush_reduce (look_ahead_tokens, i);
flush_reduce (lookahead_tokens, i);
break;
case left_assoc:
@@ -232,7 +232,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
case non_assoc:
log_resolution (redrule, i, nonassoc_resolution);
flush_shift (s, i);
flush_reduce (look_ahead_tokens, i);
flush_reduce (lookahead_tokens, i);
/* Record an explicit error for this token. */
errors[nerrs++] = symbols[i];
break;
@@ -258,7 +258,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
| Solve the S/R conflicts of state S using the |
| precedence/associativity, and flag it inconsistent if it still has |
| conflicts. ERRORS can be used as storage to compute the list of |
| look-ahead tokens on which S raises a syntax error (%nonassoc). |
| lookahead tokens on which S raises a syntax error (%nonassoc). |
`-------------------------------------------------------------------*/
static void
@@ -271,27 +271,27 @@ set_conflicts (state *s, symbol **errors)
if (s->consistent)
return;
bitset_zero (look_ahead_set);
bitset_zero (lookahead_set);
FOR_EACH_SHIFT (trans, i)
bitset_set (look_ahead_set, TRANSITION_SYMBOL (trans, i));
bitset_set (lookahead_set, TRANSITION_SYMBOL (trans, i));
/* Loop over all rules which require look-ahead in this state. First
/* Loop over all rules which require lookahead in this state. First
check for shift-reduce conflict, and try to resolve using
precedence. */
for (i = 0; i < reds->num; ++i)
if (reds->rules[i]->prec && reds->rules[i]->prec->prec
&& !bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
&& !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
resolve_sr_conflict (s, i, errors);
/* Loop over all rules which require look-ahead in this state. Check
/* Loop over all rules which require lookahead in this state. Check
for conflicts not resolved above. */
for (i = 0; i < reds->num; ++i)
{
if (!bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
conflicts[s->number] = 1;
bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);
}
}
@@ -305,12 +305,12 @@ void
conflicts_solve (void)
{
state_number i;
/* List of look-ahead tokens on which we explicitly raise a syntax error. */
/* List of lookahead tokens on which we explicitly raise a syntax error. */
symbol **errors = xnmalloc (ntokens + 1, sizeof *errors);
conflicts = xcalloc (nstates, sizeof *conflicts);
shift_set = bitset_create (ntokens, BITSET_FIXED);
look_ahead_set = bitset_create (ntokens, BITSET_FIXED);
lookahead_set = bitset_create (ntokens, BITSET_FIXED);
obstack_init (&solved_conflicts_obstack);
for (i = 0; i < nstates; i++)
@@ -342,18 +342,18 @@ count_sr_conflicts (state *s)
if (!trans)
return 0;
bitset_zero (look_ahead_set);
bitset_zero (lookahead_set);
bitset_zero (shift_set);
FOR_EACH_SHIFT (trans, i)
bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
for (i = 0; i < reds->num; ++i)
bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);
bitset_and (look_ahead_set, look_ahead_set, shift_set);
bitset_and (lookahead_set, lookahead_set, shift_set);
src_count = bitset_count (look_ahead_set);
src_count = bitset_count (lookahead_set);
return src_count;
}
@@ -378,7 +378,7 @@ count_rr_conflicts (state *s, bool one_per_token)
int count = 0;
int j;
for (j = 0; j < reds->num; ++j)
if (bitset_test (reds->look_ahead_tokens[j], i))
if (bitset_test (reds->lookahead_tokens[j], i))
count++;
if (count >= 2)
@@ -433,7 +433,7 @@ conflicts_output (FILE *out)
/*--------------------------------------------------------.
| Total the number of S/R and R/R conflicts. Unlike the |
| code in conflicts_output, however, count EACH pair of |
| reductions for the same state and look-ahead as one |
| reductions for the same state and lookahead as one |
| conflict. |
`--------------------------------------------------------*/
@@ -530,6 +530,6 @@ conflicts_free (void)
{
free (conflicts);
bitset_free (shift_set);
bitset_free (look_ahead_set);
bitset_free (lookahead_set);
obstack_free (&solved_conflicts_obstack, NULL);
}