From: Akim Demaille Date: Sat, 15 Jun 2002 18:23:50 +0000 (+0000) Subject: * src/state.h (state_t): Replace the `lookaheadsp' member, a X-Git-Tag: BISON-1_49b~168 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/c02634922181a18cd6f2d430901a7747ea17b12b * src/state.h (state_t): Replace the `lookaheadsp' member, a short, with `lookaheads' (bitsetv), `lookaheads_rule' (rule_t**). Adjust all dependencies. * src/lalr.c (initialize_lookaheads): Split into... (states_lookaheads_count, states_lookaheads_initialize): these. (lalr): Adjust. --- diff --git a/ChangeLog b/ChangeLog index ab0b47da..ec64bd63 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,13 @@ +2002-06-15 Akim Demaille + + * src/state.h (state_t): Replace the `lookaheadsp' member, a + short, with `lookaheads' (bitsetv), `lookaheads_rule' (rule_t**). + Adjust all dependencies. + * src/lalr.c (initialize_lookaheads): Split into... + (states_lookaheads_count, states_lookaheads_initialize): these. + (lalr): Adjust. + + 2002-06-15 Akim Demaille * src/gram.h, src/gram.c (grammar_rules_partial_print): New, eved diff --git a/src/conflicts.c b/src/conflicts.c index a7f4646e..2cf6ce28 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -256,11 +256,11 @@ set_conflicts (state_t *state) check for shift-reduce conflict, and try to resolve using precedence */ for (i = 0; i < state->nlookaheads; ++i) - if (LArule[state->lookaheadsp + i]->prec - && LArule[state->lookaheadsp + i]->prec->prec - && !bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + if (state->lookaheads_rule[i]->prec + && state->lookaheads_rule[i]->prec->prec + && !bitset_disjoint_p (state->lookaheads[i], lookaheadset)) { - resolve_sr_conflict (state, state->lookaheadsp + i); + resolve_sr_conflict (state, (state->lookaheads - LA) + i); break; } @@ -268,10 +268,10 @@ set_conflicts (state_t *state) for conflicts not resolved above. */ for (i = 0; i < state->nlookaheads; ++i) { - if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset)) + if (!bitset_disjoint_p (state->lookaheads[i], lookaheadset)) conflicts[state->number] = 1; - bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); + bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]); } } @@ -312,7 +312,7 @@ count_sr_conflicts (state_t *state) bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); for (i = 0; i < state->nlookaheads; ++i) - bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]); + bitset_or (lookaheadset, lookaheadset, state->lookaheads[i]); bitset_and (lookaheadset, lookaheadset, shiftset); @@ -340,7 +340,7 @@ count_rr_conflicts (state_t *state) int count = 0; int j; for (j = 0; j < state->nlookaheads; ++j) - if (bitset_test (LA[state->lookaheadsp + j], i)) + if (bitset_test (state->lookaheads[j], i)) count++; if (count >= 2) diff --git a/src/lalr.c b/src/lalr.c index dfc06bc9..6d7b34ff 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -298,15 +298,15 @@ add_lookback_edge (state_t *state, int ruleno, int gotono) shorts *sp; for (i = 0; i < state->nlookaheads; ++i) - if (LArule[state->lookaheadsp + i]->number == ruleno) + if (state->lookaheads_rule[i]->number == ruleno) break; - assert (LArule[state->lookaheadsp + i]->number == ruleno); + assert (state->lookaheads_rule[i]->number == ruleno); sp = XCALLOC (shorts, 1); - sp->next = lookback[state->lookaheadsp + i]; + sp->next = lookback[(state->lookaheads - LA) + i]; sp->value = gotono; - lookback[state->lookaheadsp + i] = sp; + lookback[(state->lookaheads - LA) + i] = sp; } @@ -506,15 +506,18 @@ compute_lookaheads (void) } -/*--------------------------------------. -| Initializing the lookaheads members. | -`--------------------------------------*/ +/*-------------------------------------------------------------. +| Count the number of lookaheads required for each state | +| (NLOOKAHEADS member). Compute the total number of LA, NLA. | +`-------------------------------------------------------------*/ static void -initialize_lookaheads (void) +states_lookaheads_count (void) { size_t i; nLA = 0; + + /* Count */ for (i = 0; i < nstates; i++) { int k; @@ -540,12 +543,34 @@ initialize_lookaheads (void) } states[i]->nlookaheads = nlookaheads; - states[i]->lookaheadsp = nLA; nLA += nlookaheads; } } +/*--------------------------------------. +| Initializing the lookaheads members. | +`--------------------------------------*/ + +static void +states_lookaheads_initialize (void) +{ + size_t i; + bitsetv pLA = LA; + rule_t **pLArule = LArule; + + /* Count the number of lookaheads required for each state + (NLOOKAHEADS member). */ + for (i = 0; i < nstates; i++) + { + states[i]->lookaheads = pLA; + states[i]->lookaheads_rule = pLArule; + pLA += states[i]->nlookaheads; + pLArule += states[i]->nlookaheads; + } +} + + /*---------------------------------------. | Output the lookaheads for each state. | `---------------------------------------*/ @@ -563,10 +588,10 @@ lookaheads_print (FILE *out) for (j = 0; j < states[i]->nlookaheads; ++j) for (k = 0; k < ntokens; ++k) - if (bitset_test (LA[states[i]->lookaheadsp + j], k)) + if (bitset_test (states[i]->lookaheads[j], k)) fprintf (out, " on %d (%s) -> rule %d\n", k, symbol_tag_get (symbols[k]), - LArule[states[i]->lookaheadsp + j]->number - 1); + states[i]->lookaheads_rule[j]->number - 1); } fprintf (out, "Lookaheads: END\n"); } @@ -574,8 +599,9 @@ lookaheads_print (FILE *out) void lalr (void) { - initialize_lookaheads (); + states_lookaheads_count (); initialize_LA (); + states_lookaheads_initialize (); set_goto_map (); initialize_F (); build_relations (); diff --git a/src/output.c b/src/output.c index 7ee3214c..350d7ed8 100644 --- a/src/output.c +++ b/src/output.c @@ -380,8 +380,8 @@ action_row (state_t *state) for (j = 0; j < ntokens; j++) /* and record this rule as the rule to use if that token follows. */ - if (bitset_test (LA[state->lookaheadsp + i], j)) - actrow[j] = -LArule[state->lookaheadsp + i]->number; + if (bitset_test (state->lookaheads[i], j)) + actrow[j] = -state->lookaheads_rule[i]->number; } /* Now see which tokens are allowed for shifts in this state. For @@ -428,7 +428,7 @@ action_row (state_t *state) for (i = 0; i < state->nlookaheads; i++) { int count = 0; - int rule = -LArule[state->lookaheadsp + i]->number; + int rule = -state->lookaheads_rule[i]->number; int j; for (j = 0; j < ntokens; j++) diff --git a/src/print.c b/src/print.c index 280ac8d8..027f3fe3 100644 --- a/src/print.c +++ b/src/print.c @@ -99,16 +99,16 @@ print_core (FILE *out, state_t *state) /* Look for lookaheads corresponding to this rule. */ for (j = 0; j < state->nlookaheads; ++j) for (k = 0; k < ntokens; ++k) - if (bitset_test (LA[state->lookaheadsp + j], k) - && LArule[state->lookaheadsp + j]->number == rule) + if (bitset_test (state->lookaheads[j], k) + && state->lookaheads_rule[j]->number == rule) nlookaheads++; if (nlookaheads) { fprintf (out, " ["); for (j = 0; j < state->nlookaheads; ++j) for (k = 0; k < ntokens; ++k) - if (bitset_test (LA[state->lookaheadsp + j], k) - && LArule[state->lookaheadsp + j]->number == rule) + if (bitset_test (state->lookaheads[j], k) + && state->lookaheads_rule[j]->number == rule) fprintf (out, "%s%s", symbol_tag_get (symbols[k]), --nlookaheads ? ", " : ""); @@ -225,9 +225,9 @@ print_reductions (FILE *out, state_t *state) if (state->nlookaheads == 1 && !nodefault) { - rule_t *default_rule = LArule[state->lookaheadsp]; + rule_t *default_rule = state->lookaheads_rule[0]; - bitset_and (lookaheadset, LA[state->lookaheadsp], shiftset); + bitset_and (lookaheadset, state->lookaheads[0], shiftset); for (i = 0; i < ntokens; i++) if (bitset_test (lookaheadset, i)) @@ -252,7 +252,7 @@ print_reductions (FILE *out, state_t *state) int count = 0; int j; - bitset_andn (lookaheadset, LA[state->lookaheadsp + i], shiftset); + bitset_andn (lookaheadset, state->lookaheads[i], shiftset); for (j = 0; j < ntokens; j++) if (bitset_test (lookaheadset, j)) @@ -261,8 +261,8 @@ print_reductions (FILE *out, state_t *state) if (count > cmax) { cmax = count; - default_LA = state->lookaheadsp + i; - default_rule = LArule[state->lookaheadsp + i]; + default_LA = i; + default_rule = state->lookaheads_rule[i]; } bitset_or (shiftset, shiftset, lookaheadset); @@ -281,16 +281,16 @@ print_reductions (FILE *out, state_t *state) int count = bitset_test (shiftset, i); for (j = 0; j < state->nlookaheads; ++j) - if (bitset_test (LA[state->lookaheadsp + j], i)) + if (bitset_test (state->lookaheads[j], i)) { if (count == 0) { - if (state->lookaheadsp + j != default_LA) + if (j != default_LA) fprintf (out, _(" %-4s\treduce using rule %d (%s)\n"), symbol_tag_get (symbols[i]), - LArule[state->lookaheadsp + j]->number - 1, - symbol_tag_get_n (LArule[state->lookaheadsp + j]->lhs, 1)); + state->lookaheads_rule[j]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1)); else defaulted = 1; @@ -302,14 +302,14 @@ print_reductions (FILE *out, state_t *state) fprintf (out, _(" %-4s\treduce using rule %d (%s)\n"), symbol_tag_get (symbols[i]), - LArule[default_LA]->number - 1, - symbol_tag_get_n (LArule[default_LA]->lhs, 1)); + state->lookaheads_rule[default_LA]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[default_LA]->lhs, 1)); defaulted = 0; fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), symbol_tag_get (symbols[i]), - LArule[state->lookaheadsp + j]->number - 1, - symbol_tag_get_n (LArule[state->lookaheadsp + j]->lhs, 1)); + state->lookaheads_rule[j]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1)); } } } diff --git a/src/print_graph.c b/src/print_graph.c index 49acaa7e..e0aa0c31 100644 --- a/src/print_graph.c +++ b/src/print_graph.c @@ -93,16 +93,16 @@ print_core (struct obstack *oout, state_t *state) /* Look for lookaheads corresponding to this rule. */ for (j = 0; j < state->nlookaheads; ++j) for (k = 0; k < ntokens; ++k) - if (bitset_test (LA[state->lookaheadsp + j], k) - && LArule[state->lookaheadsp + j]->number == rule) + if (bitset_test (state->lookaheads[j], k) + && state->lookaheads_rule[j]->number == rule) nlookaheads++; if (nlookaheads) { obstack_sgrow (oout, " ["); for (j = 0; j < state->nlookaheads; ++j) for (k = 0; k < ntokens; ++k) - if (bitset_test (LA[state->lookaheadsp + j], k) - && LArule[state->lookaheadsp + j]->number == rule) + if (bitset_test (state->lookaheads[j], k) + && state->lookaheads_rule[j]->number == rule) obstack_fgrow2 (oout, "%s%s", symbol_tag_get (symbols[k]), --nlookaheads ? ", " : ""); diff --git a/src/state.h b/src/state.h index 95b716d8..7f578bdc 100644 --- a/src/state.h +++ b/src/state.h @@ -88,6 +88,7 @@ #ifndef STATE_H_ # define STATE_H_ +# include "bitsetv.h" /*---------. | Shifts. | @@ -180,9 +181,9 @@ typedef struct state_s char consistent; /* Used in LALR, not LR(0). */ - /* Pseudo pointer into LA. */ - short lookaheadsp; int nlookaheads; + bitsetv lookaheads; + rule_t **lookaheads_rule; /* If some conflicts were solved thanks to precedence/associativity, a human readable description of the resolution. */