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

* src/conflicts.c (log_resolution, flush_shift)

Browse Source 
(resolve_sr_conflict, set_conflicts, solve_conflicts)
(count_sr_conflicts, count_rr_conflicts, conflicts_output)
(conflicts_print, print_reductions): Use a state_t instead of an
integer when referring to a state.
As much as possible, depend upon nlookaheads, instead of the
`lookaheadsp' member of the following state (since lookaheads of
successive states are successive, the difference between state n + 1
and n served as the number of lookaheads for state n).
* src/lalr.c (add_lookback_edge): Likewise.
* src/print.c (print_core, print_actions, print_state)
(print_results): Likewise.
* src/print_graph.c (print_core, print_actions, print_state)
(print_graph): Likewise.
* src/conflicts.h: Adjust.
This commit is contained in:
Akim Demaille
2001-12-27 18:05:05 +00:00
parent 1b177bd731
commit 065fbd27af
6 changed files with 100 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@@ -1,3 +1,21 @@
2001-12-27 Akim Demaille <akim@epita.fr>
* src/conflicts.c (log_resolution, flush_shift)
(resolve_sr_conflict, set_conflicts, solve_conflicts)
(count_sr_conflicts, count_rr_conflicts, conflicts_output)
(conflicts_print, print_reductions): Use a state_t instead of an
integer when referring to a state.
As much as possible, depend upon nlookaheads, instead of the
`lookaheadsp' member of the following state (since lookaheads of
successive states are successive, the difference between state n + 1
and n served as the number of lookaheads for state n).
* src/lalr.c (add_lookback_edge): Likewise.
* src/print.c (print_core, print_actions, print_state)
(print_results): Likewise.
* src/print_graph.c (print_core, print_actions, print_state)
(print_graph): Likewise.
* src/conflicts.h: Adjust.
2001-12-27 Akim Demaille <akim@epita.fr>
* src/bison.hairy: Formatting/comment changes.

109
src/conflicts.c
View File

@@ -38,13 +38,13 @@ static unsigned *lookaheadset = NULL;
static inline void
log_resolution (int state, int LAno, int token, char *resolution)
log_resolution (state_t *state, int LAno, int token, char *resolution)
{
if (verbose_flag)
obstack_fgrow4 (&output_obstack,
_("\
Conflict in state %d between rule %d and token %s resolved as %s.\n"),
state, LAruleno[LAno], tags[token], resolution);
state->number, LAruleno[LAno], tags[token], resolution);
}
@@ -55,9 +55,9 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"),
`------------------------------------------------------------------*/
static void
flush_shift (int state, int token)
flush_shift (state_t *state, int token)
{
shifts *shiftp = state_table[state]->shifts;
shifts *shiftp = state->shifts;
int i;
RESETBIT (lookaheadset, token);
@@ -88,7 +88,7 @@ flush_reduce (int lookahead, int token)
`------------------------------------------------------------------*/
static void
resolve_sr_conflict (int state, int lookahead)
resolve_sr_conflict (state_t *state, int lookahead)
{
int i;
/* find the rule to reduce by to get precedence of reduction */
@@ -146,25 +146,25 @@ resolve_sr_conflict (int state, int lookahead)
/* Some tokens have been explicitly made errors. Allocate a
permanent errs structure for this state, to record them. */
i = (char *) errtokens - (char *) errp;
state_table[state]->errs = ERRS_ALLOC (i + 1);
memcpy (state_table[state]->errs, errp, i);
state->errs = ERRS_ALLOC (i + 1);
memcpy (state->errs, errp, i);
free (errp);
}
static void
set_conflicts (int state)
set_conflicts (state_t *state)
{
int i, j;
shifts *shiftp;
if (state_table[state]->consistent)
if (state->consistent)
return;
for (i = 0; i < tokensetsize; i++)
lookaheadset[i] = 0;
shiftp = state_table[state]->shifts;
shiftp = state->shifts;
for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
if (!SHIFT_IS_DISABLED (shiftp, i))
SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
@@ -172,30 +172,26 @@ set_conflicts (int state)
/* Loop over all rules which require lookahead in this state. First
check for shift-reduce conflict, and try to resolve using
precedence */
for (i = state_table[state]->lookaheadsp;
i < state_table[state + 1]->lookaheadsp;
++i)
if (rule_table[LAruleno[i]].prec)
for (i = 0; i < state->nlookaheads; ++i)
if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
for (j = 0; j < tokensetsize; ++j)
if (LA (i)[j] & lookaheadset[j])
if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
{
resolve_sr_conflict (state, i);
resolve_sr_conflict (state, state->lookaheadsp + i);
break;
}
/* Loop over all rules which require lookahead in this state. Check
for conflicts not resolved above. */
for (i = state_table[state]->lookaheadsp;
i < state_table[state + 1]->lookaheadsp;
++i)
for (i = 0; i < state->nlookaheads; ++i)
{
for (j = 0; j < tokensetsize; ++j)
if (LA (i)[j] & lookaheadset[j])
conflicts[state] = 1;
if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
conflicts[state->number] = 1;
for (j = 0; j < tokensetsize; ++j)
lookaheadset[j] |= LA (i)[j];
lookaheadset[j] |= LA (state->lookaheadsp + i)[j];
}
}
@@ -209,7 +205,7 @@ solve_conflicts (void)
lookaheadset = XCALLOC (unsigned, tokensetsize);
for (i = 0; i < nstates; i++)
set_conflicts (i);
set_conflicts (state_table[i]);
}
@@ -218,11 +214,11 @@ solve_conflicts (void)
`---------------------------------------------*/
static int
count_sr_conflicts (int state)
count_sr_conflicts (state_t *state)
{
int i, k;
int src_count = 0;
shifts *shiftp = state_table[state]->shifts;
shifts *shiftp = state->shifts;
if (!shiftp)
return 0;
@@ -237,11 +233,9 @@ count_sr_conflicts (int state)
if (!SHIFT_IS_DISABLED (shiftp, i))
SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
for (i = state_table[state]->lookaheadsp;
i < state_table[state + 1]->lookaheadsp;
++i)
for (i = 0; i < state->nlookaheads; ++i)
for (k = 0; k < tokensetsize; ++k)
lookaheadset[k] |= LA (i)[k];
lookaheadset[k] |= LA (state->lookaheadsp + i)[k];
for (k = 0; k < tokensetsize; ++k)
lookaheadset[k] &= shiftset[k];
@@ -259,23 +253,20 @@ count_sr_conflicts (int state)
`----------------------------------------------*/
static int
count_rr_conflicts (int state)
count_rr_conflicts (state_t *state)
{
int i;
int rrc_count = 0;
int m = state_table[state]->lookaheadsp;
int n = state_table[state + 1]->lookaheadsp;
if (n - m < 2)
if (state->nlookaheads < 2)
return 0;
for (i = 0; i < ntokens; i++)
{
int count = 0;
int j;
for (j = m; j < n; j++)
if (BITISSET (LA (m), j))
for (j = 0; j < state->nlookaheads; ++j)
if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
count++;
if (count >= 2)
@@ -337,8 +328,8 @@ conflicts_output (FILE *out)
if (conflicts[i])
{
fprintf (out, _("State %d contains "), i);
fputs (conflict_report (count_sr_conflicts (i),
count_rr_conflicts (i)), out);
fputs (conflict_report (count_sr_conflicts (state_table[i]),
count_rr_conflicts (state_table[i])), out);
printed_sth = TRUE;
}
if (printed_sth)
@@ -367,8 +358,8 @@ conflicts_print (void)
for (i = 0; i < nstates; i++)
if (conflicts[i])
{
src_total += count_sr_conflicts (i);
rrc_total += count_rr_conflicts (i);
src_total += count_sr_conflicts (state_table[i]);
rrc_total += count_rr_conflicts (state_table[i]);
}
src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
@@ -410,13 +401,11 @@ conflicts_print (void)
void
print_reductions (FILE *out, int state)
print_reductions (FILE *out, state_t *state)
{
int i;
int m = state_table[state]->lookaheadsp;
int n = state_table[state + 1]->lookaheadsp;
shifts *shiftp = state_table[state]->shifts;
errs *errp = state_table[state]->errs;
shifts *shiftp = state->shifts;
errs *errp = state->errs;
int nodefault = 0;
for (i = 0; i < tokensetsize; i++)
@@ -437,13 +426,13 @@ print_reductions (FILE *out, int state)
if (errp->errs[i])
SETBIT (shiftset, errp->errs[i]);
if (n - m == 1 && !nodefault)
if (state->nlookaheads == 1 && !nodefault)
{
int k;
int default_rule = LAruleno[m];
int default_rule = LAruleno[state->lookaheadsp];
for (k = 0; k < tokensetsize; ++k)
lookaheadset[k] = LA (m)[k] & shiftset[k];
lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k];
for (i = 0; i < ntokens; i++)
if (BITISSET (lookaheadset, i))
@@ -454,20 +443,20 @@ print_reductions (FILE *out, int state)
fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"),
default_rule, tags[rule_table[default_rule].lhs]);
}
else if (n - m >= 1)
else if (state->nlookaheads >= 1)
{
int cmax = 0;
int default_LA = -1;
int default_rule = 0;
if (!nodefault)
for (i = m; i < n; i++)
for (i = 0; i < state->nlookaheads; ++i)
{
int count = 0;
int j, k;
for (k = 0; k < tokensetsize; ++k)
lookaheadset[k] = LA (i)[k] & ~shiftset[k];
lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k];
for (j = 0; j < ntokens; j++)
if (BITISSET (lookaheadset, j))
@@ -476,8 +465,8 @@ print_reductions (FILE *out, int state)
if (count > cmax)
{
cmax = count;
default_LA = i;
default_rule = LAruleno[i];
default_LA = state->lookaheadsp + i;
default_rule = LAruleno[state->lookaheadsp + i];
}
for (k = 0; k < tokensetsize; ++k)
@@ -497,18 +486,18 @@ print_reductions (FILE *out, int state)
int defaulted = 0;
int count = BITISSET (shiftset, i);
for (j = m; j < n; j++)
for (j = 0; j < state->nlookaheads; ++j)
{
if (BITISSET (LA (j), i))
if (BITISSET (LA (state->lookaheadsp + j), i))
{
if (count == 0)
{
if (j != default_LA)
if (state->lookaheadsp + j != default_LA)
fprintf (out,
_(" %-4s\treduce using rule %d (%s)\n"),
tags[i],
LAruleno[j],
tags[rule_table[LAruleno[j]].lhs]);
LAruleno[state->lookaheadsp + j],
tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
else
defaulted = 1;
@@ -526,8 +515,8 @@ print_reductions (FILE *out, int state)
fprintf (out,
_(" %-4s\t[reduce using rule %d (%s)]\n"),
tags[i],
LAruleno[j],
tags[rule_table[LAruleno[j]].lhs]);
LAruleno[state->lookaheadsp + j],
tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
}
}
}

2
src/conflicts.h
View File

@@ -25,7 +25,7 @@
void solve_conflicts PARAMS ((void));
void conflicts_print PARAMS ((void));
void conflicts_output PARAMS ((FILE *out));
void print_reductions PARAMS ((FILE*out, int state));
void print_reductions PARAMS ((FILE*out, state_t *state));
void free_conflicts PARAMS ((void));
/* Were there conflicts? */

21
src/lalr.c
View File

@@ -310,27 +310,18 @@ static void
add_lookback_edge (int stateno, int ruleno, int gotono)
{
int i;
int k;
int found;
shorts *sp;
i = state_table[stateno]->lookaheadsp;
k = state_table[stateno + 1]->lookaheadsp;
found = 0;
while (!found && i < k)
{
if (LAruleno[i] == ruleno)
found = 1;
else
i++;
}
for (i = 0; i < state_table[stateno]->nlookaheads; ++i)
if (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno)
break;
assert (found);
assert (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno);
sp = XCALLOC (shorts, 1);
sp->next = lookback[i];
sp->next = lookback[state_table[stateno]->lookaheadsp + i];
sp->value = gotono;
lookback[i] = sp;
lookback[state_table[stateno]->lookaheadsp + i] = sp;
}

24
src/print.c
View File

@@ -46,11 +46,11 @@ print_token (int extnum, int token)
`--------------------------------*/
static void
print_core (FILE *out, int state)
print_core (FILE *out, state_t *state)
{
int i;
short *sitems = state_table[state]->items;
int snitems = state_table[state]->nitems;
short *sitems = state->items;
int snitems = state->nitems;
/* New experimental feature: if TRACE_FLAGS output all the items of
a state, not only its kernel. */
@@ -94,17 +94,17 @@ print_core (FILE *out, int state)
}
static void
print_actions (FILE *out, int state)
print_actions (FILE *out, state_t *state)
{
int i;
shifts *shiftp = state_table[state]->shifts;
reductions *redp = state_table[state]->reductions;
errs *errp = state_table[state]->errs;
shifts *shiftp = state->shifts;
reductions *redp = state->reductions;
errs *errp = state->errs;
if (!shiftp->nshifts && !redp)
{
if (final_state == state)
if (final_state == state->number)
fprintf (out, _(" $default\taccept\n"));
else
fprintf (out, _(" NO ACTIONS\n"));
@@ -140,7 +140,7 @@ print_actions (FILE *out, int state)
fputc ('\n', out);
}
if (state_table[state]->consistent && redp)
if (state->consistent && redp)
{
int rule = redp->rules[0];
int symbol = rule_table[rule].lhs;
@@ -168,9 +168,9 @@ print_actions (FILE *out, int state)
}
static void
print_state (FILE *out, int state)
print_state (FILE *out, state_t *state)
{
fprintf (out, _("state %d"), state);
fprintf (out, _("state %d"), state->number);
fputs ("\n\n", out);
print_core (out, state);
print_actions (out, state);
@@ -331,7 +331,7 @@ print_results (void)
if (trace_flag)
new_closure (nitems);
for (i = 0; i < nstates; i++)
print_state (out, i);
print_state (out, state_table[i]);
if (trace_flag)
free_closure ();

28
src/print_graph.c
View File

@@ -38,18 +38,18 @@ static FILE *fgraph = NULL;
/* This part will construct the label of nodes. */
static void
print_core (int state, struct obstack *node_obstack)
print_core (state_t *state, struct obstack *node_obstack)
{
int i;
short *sitems = state_table[state]->items;
int snitems = state_table[state]->nitems;
short *sitems = state->items;
int snitems = state->nitems;
/* Output all the items of a state, not only its kernel. */
closure (sitems, snitems);
sitems = itemset;
snitems = nitemset;
obstack_fgrow1 (node_obstack, "%2d: ", state);
obstack_fgrow1 (node_obstack, "%2d: ", state->number);
for (i = 0; i < snitems; i++)
{
short *sp;
@@ -65,7 +65,7 @@ print_core (int state, struct obstack *node_obstack)
if (i)
obstack_sgrow (node_obstack, "\n ");
obstack_fgrow1 (node_obstack, " %s -> ",
obstack_fgrow1 (node_obstack, " %s -> ",
tags[rule_table[rule].lhs]);
for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
@@ -85,14 +85,14 @@ print_core (int state, struct obstack *node_obstack)
`---------------------------------------------------------------*/
static void
print_actions (int state, const char *node_name)
print_actions (state_t *state, const char *node_name)
{
int i;
shifts *shiftp = state_table[state]->shifts;
reductions *redp = state_table[state]->reductions;
shifts *shiftp = state->shifts;
reductions *redp = state->reductions;
#if 0
errs *errp = state_table[state]->errs;
errs *errp = state->errs;
#endif
static char buff[10];
@@ -117,7 +117,7 @@ print_actions (int state, const char *node_name)
new_edge (&edge);
if (state > state1)
if (state->number > state1)
edge.type = back_edge;
open_edge (&edge, fgraph);
/* The edge source is the current node. */
@@ -155,7 +155,7 @@ print_actions (int state, const char *node_name)
obstack_1grow (node_obstack, '\n');
}
if (state_table[state]->consistent && redp)
if (state->consistent && redp)
{
rule = redp->rules[0];
symbol = rule_table[rule].lhs;
@@ -176,7 +176,7 @@ print_actions (int state, const char *node_name)
`-------------------------------------------------------------*/
static void
print_state (int state)
print_state (state_t *state)
{
static char name[10];
struct obstack node_obstack;
@@ -185,7 +185,7 @@ print_state (int state)
/* The labels of the nodes are their the items. */
obstack_init (&node_obstack);
new_node (&node);
sprintf (name, "%d", state);
sprintf (name, "%d", state->number);
node.title = name;
print_core (state, &node_obstack);
obstack_1grow (&node_obstack, '\0');
@@ -235,7 +235,7 @@ print_graph (void)
/* Output nodes and edges. */
new_closure (nitems);
for (i = 0; i < nstates; i++)
print_state (i);
print_state (state_table[i]);
free_closure ();
/* Close graph. */