From: Akim Demaille Date: Thu, 27 Dec 2001 18:05:05 +0000 (+0000) Subject: * src/conflicts.c (log_resolution, flush_shift) X-Git-Tag: before-m4-back-end~99 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/065fbd27af96e4aa82b5f3354870b0dcfee72ce8 * 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. --- diff --git a/ChangeLog b/ChangeLog index 0ec19e16..5a6c1b19 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,21 @@ +2001-12-27 Akim Demaille + + * 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 * src/bison.hairy: Formatting/comment changes. diff --git a/src/conflicts.c b/src/conflicts.c index bb2daecb..0bec85c7 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -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]); } } } diff --git a/src/conflicts.h b/src/conflicts.h index 78bdb18c..cf04c0e9 100644 --- a/src/conflicts.h +++ b/src/conflicts.h @@ -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? */ diff --git a/src/lalr.c b/src/lalr.c index df0865ed..0eb32411 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -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; } diff --git a/src/print.c b/src/print.c index d7d04eab..e28e9dc1 100644 --- a/src/print.c +++ b/src/print.c @@ -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 (); diff --git a/src/print_graph.c b/src/print_graph.c index d187480c..f64cb8aa 100644 --- a/src/print_graph.c +++ b/src/print_graph.c @@ -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. */