/* Find and resolve or report look-ahead conflicts for bison,
- Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002
+
+ Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
02111-1307, USA. */
#include "system.h"
-#include "bitset.h"
+
+#include <bitset.h>
+
+#include "LR0.h"
#include "complain.h"
-#include "getargs.h"
-#include "symtab.h"
+#include "conflicts.h"
#include "files.h"
+#include "getargs.h"
#include "gram.h"
-#include "state.h"
#include "lalr.h"
-#include "conflicts.h"
#include "reader.h"
-#include "LR0.h"
+#include "state.h"
+#include "symtab.h"
/* -1 stands for not specified. */
int expected_conflicts = -1;
\f
-enum conflict_resolution_e
+enum conflict_resolution
{
shift_resolution,
reduce_resolution,
`----------------------------------------------------------------*/
static inline void
-log_resolution (rule_t *rule, symbol_number_t token,
- enum conflict_resolution_e resolution)
+log_resolution (rule *r, symbol_number token,
+ enum conflict_resolution resolution)
{
if (report_flag & report_solved_conflicts)
{
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as shift"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
case reduce_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as reduce"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
case nonassoc_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as an error"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
}
case shift_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
" (%s < %s)",
- rule->prec->tag,
+ r->prec->tag,
symbols[token]->tag);
break;
obstack_fgrow2 (&solved_conflicts_obstack,
" (%s < %s)",
symbols[token]->tag,
- rule->prec->tag);
+ r->prec->tag);
break;
case left_resolution:
`------------------------------------------------------------------*/
static void
-flush_shift (state_t *state, int token)
+flush_shift (state *s, int token)
{
- transitions_t *transitions = state->transitions;
+ transitions *trans = s->transitions;
int i;
bitset_reset (lookaheadset, token);
- for (i = 0; i < transitions->num; i++)
- if (!TRANSITION_IS_DISABLED (transitions, i)
- && TRANSITION_SYMBOL (transitions, i) == token)
- TRANSITION_DISABLE (transitions, i);
+ for (i = 0; i < trans->num; i++)
+ if (!TRANSITION_IS_DISABLED (trans, i)
+ && TRANSITION_SYMBOL (trans, i) == token)
+ TRANSITION_DISABLE (trans, i);
}
| |
| LOOKAHEAD is the number of the lookahead bitset to consider. |
| |
-| ERRS can be used to store discovered explicit errors. |
+| ERRORS can be used to store discovered explicit errors. |
`------------------------------------------------------------------*/
static void
-resolve_sr_conflict (state_t *state, int ruleno,
- symbol_t **errs)
+resolve_sr_conflict (state *s, int ruleno, symbol **errors)
{
- symbol_number_t i;
- reductions_t *reds = state->reductions;
+ symbol_number i;
+ reductions *reds = s->reductions;
/* Find the rule to reduce by to get precedence of reduction. */
- rule_t *redrule = reds->rules[ruleno];
+ rule *redrule = reds->rules[ruleno];
int redprec = redrule->prec->prec;
bitset lookaheads = reds->lookaheads[ruleno];
int nerrs = 0;
if (symbols[i]->prec < redprec)
{
log_resolution (redrule, i, reduce_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
}
else if (symbols[i]->prec > redprec)
{
case left_assoc:
log_resolution (redrule, i, left_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
break;
case non_assoc:
log_resolution (redrule, i, nonassoc_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
flush_reduce (lookaheads, i);
/* Record an explicit error for this token. */
- errs[nerrs++] = symbols[i];
+ errors[nerrs++] = symbols[i];
break;
case undef_assoc:
- assert (symbols[i]->assoc != undef_assoc);
- break;
+ abort ();
}
}
- /* Some tokens have been explicitly made errors. Allocate a
- permanent errs structure for this state, to record them. */
- state_errs_set (state, nerrs, errs);
+ if (nerrs)
+ {
+ /* Some tokens have been explicitly made errors. Allocate a
+ permanent errs structure for this state, to record them. */
+ state_errs_set (s, nerrs, errors);
+ }
if (obstack_object_size (&solved_conflicts_obstack))
{
obstack_1grow (&solved_conflicts_obstack, '\0');
- state->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
+ s->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
}
}
/*-------------------------------------------------------------------.
-| Solve the S/R conflicts of STATE using the |
+| Solve the S/R conflicts of state S using the |
| precedence/associativity, and flag it inconsistent if it still has |
-| conflicts. ERRS can be used as storage to compute the list of |
-| lookaheads on which this STATE raises a parse error (%nonassoc). |
+| conflicts. ERRORS can be used as storage to compute the list of |
+| lookaheads on which S raises a syntax error (%nonassoc). |
`-------------------------------------------------------------------*/
static void
-set_conflicts (state_t *state, symbol_t **errs)
+set_conflicts (state *s, symbol **errors)
{
int i;
- transitions_t *transitions = state->transitions;
- reductions_t *reds = state->reductions;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
- if (state->consistent)
+ if (s->consistent)
return;
bitset_zero (lookaheadset);
- FOR_EACH_SHIFT (transitions, i)
- bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (trans, i)
+ bitset_set (lookaheadset, TRANSITION_SYMBOL (trans, i));
/* Loop over all rules which require lookahead in this state. First
check for shift-reduce conflict, and try to resolve using
for (i = 0; i < reds->num; ++i)
if (reds->rules[i]->prec && reds->rules[i]->prec->prec
&& !bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
- {
- resolve_sr_conflict (state, i, errs);
- break;
- }
+ resolve_sr_conflict (s, i, errors);
/* 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->lookaheads[i], lookaheadset))
- conflicts[state->number] = 1;
+ conflicts[s->number] = 1;
bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
}
void
conflicts_solve (void)
{
- state_number_t i;
- /* List of lookaheads on which we explicitly raise a parse error. */
- symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1);
+ state_number i;
+ /* List of lookaheads on which we explicitly raise a syntax error. */
+ symbol **errors = MALLOC (errors, ntokens + 1);
- conflicts = XCALLOC (char, nstates);
+ CALLOC (conflicts, nstates);
shiftset = bitset_create (ntokens, BITSET_FIXED);
lookaheadset = bitset_create (ntokens, BITSET_FIXED);
obstack_init (&solved_conflicts_obstack);
for (i = 0; i < nstates; i++)
{
- set_conflicts (states[i], errs);
+ set_conflicts (states[i], errors);
/* For uniformity of the code, make sure all the states have a valid
`errs' member. */
states[i]->errs = errs_new (0, 0);
}
- free (errs);
+ free (errors);
}
`---------------------------------------------*/
static int
-count_sr_conflicts (state_t *state)
+count_sr_conflicts (state *s)
{
int i;
int src_count = 0;
- transitions_t *transitions = state->transitions;
- reductions_t *reds = state->reductions;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
- if (!transitions)
+ if (!trans)
return 0;
bitset_zero (lookaheadset);
bitset_zero (shiftset);
- FOR_EACH_SHIFT (transitions, i)
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (trans, i)
+ bitset_set (shiftset, TRANSITION_SYMBOL (trans, i));
for (i = 0; i < reds->num; ++i)
bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
+`----------------------------------------------------------------*/
static int
-count_rr_conflicts (state_t *state, int one_per_token)
+count_rr_conflicts (state *s, int one_per_token)
{
int i;
- reductions_t *reds = state->reductions;
+ reductions *reds = s->reductions;
int rrc_count = 0;
for (i = 0; i < ntokens; i++)
}
-/*--------------------------------------------------------------.
-| Return a human readable string which reports shift/reduce and |
-| reduce/reduce conflict numbers (SRC_NUM, RRC_NUM). |
-`--------------------------------------------------------------*/
-
-static const char *
-conflict_report (int src_num, int rrc_num)
-{
- static char res[4096];
- char *cp = res;
-
- if (src_num >= 1)
- {
- sprintf (cp, ngettext ("%d shift/reduce conflict",
- "%d shift/reduce conflicts", src_num), src_num);
- cp += strlen (cp);
- }
-
- if (src_num > 0 && rrc_num > 0)
- {
- sprintf (cp, " %s ", _("and"));
- cp += strlen (cp);
- }
-
- if (rrc_num >= 1)
- {
- sprintf (cp, ngettext ("%d reduce/reduce conflict",
- "%d reduce/reduce conflicts", rrc_num), rrc_num);
- cp += strlen (cp);
- }
-
- *cp++ = '\0';
-
- return res;
-}
-
-
-/*----------------------------------------------------------------.
-| Same as above, but report the number of conflicts a` la POSIX. |
-`----------------------------------------------------------------*/
+/*--------------------------------------------------------.
+| Report the number of conflicts, using the Yacc format. |
+`--------------------------------------------------------*/
static void
-conflict_report_yacc (int src_num, int rrc_num)
+conflict_report (FILE *out, int src_num, int rrc_num)
{
- /* If invoked with `--yacc', use the output format specified by
- POSIX. */
- fprintf (stderr, _("conflicts: "));
- if (src_num > 0)
- fprintf (stderr, _(" %d shift/reduce"), src_num);
- if (src_num > 0 && rrc_num > 0)
- fprintf (stderr, ",");
- if (rrc_num > 0)
- fprintf (stderr, _(" %d reduce/reduce"), rrc_num);
- putc ('\n', stderr);
+ if (src_num && rrc_num)
+ fprintf (out, _("conflicts: %d shift/reduce, %d reduce/reduce\n"),
+ src_num, rrc_num);
+ else if (src_num)
+ fprintf (out, _("conflicts: %d shift/reduce\n"), src_num);
+ else if (rrc_num)
+ fprintf (out, _("conflicts: %d reduce/reduce\n"), rrc_num);
}
conflicts_output (FILE *out)
{
bool printed_sth = false;
- state_number_t i;
+ state_number i;
for (i = 0; i < nstates; i++)
{
- state_t *s = states[i];
+ state *s = states[i];
if (conflicts[i])
{
- fprintf (out, _("State %d contains "), i);
- fprintf (out, "%s.\n",
- conflict_report (count_sr_conflicts (s),
- count_rr_conflicts (s, true)));
+ fprintf (out, _("State %d "), i);
+ conflict_report (out, count_sr_conflicts (s),
+ count_rr_conflicts (s, true));
printed_sth = true;
}
}
int
conflicts_total_count (void)
{
- state_number_t i;
+ state_number i;
int count;
/* Conflicts by state. */
/* Conflicts by state. */
{
- state_number_t i;
+ state_number i;
for (i = 0; i < nstates; i++)
if (conflicts[i])
return;
/* Report the total number of conflicts on STDERR. */
- if (yacc_flag)
- conflict_report_yacc (src_total, rrc_total);
- else
- warn ("%s", conflict_report (src_total, rrc_total));
+ if (! yacc_flag)
+ fprintf (stderr, "%s: ", current_file);
+ conflict_report (stderr, src_total, rrc_total);
- if (expected_conflicts != -1 && !src_ok)
- complain (ngettext ("expected %d shift/reduce conflict",
+ if (expected_conflicts != -1)
+ {
+ if (! src_ok)
+ warn (ngettext ("expected %d shift/reduce conflict",
"expected %d shift/reduce conflicts",
expected_conflicts),
expected_conflicts);
+ if (rrc_total)
+ warn (_("expected 0 reduce/reduce conflicts"));
+ }
}
projects / bison.git / blobdiff