From 92b16366ddbf8aca3974852048f97e8045e77e1d Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Wed, 5 Dec 2001 09:44:26 +0000 Subject: [PATCH] * src/conflicts.c (err_table): Remove. (resolve_sr_conflict): Adjust. * src/lalr.h (state_t.reduction_table, state_t.shift_table): Rename as... (state_t.reductions, state_t.shifts): this. --- ChangeLog | 9 +++ src/conflicts.c | 143 ++++++++++++++++++++++------------------------ src/conflicts.h | 3 +- src/lalr.c | 22 +++---- src/lalr.h | 5 +- src/output.c | 6 +- src/print.c | 6 +- src/print_graph.c | 4 +- 8 files changed, 99 insertions(+), 99 deletions(-) diff --git a/ChangeLog b/ChangeLog index c7064232..c9a62be7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,12 @@ +2001-12-05 Akim Demaille + + * src/conflicts.c (err_table): Remove. + (resolve_sr_conflict): Adjust. + * src/lalr.h (state_t.reduction_table, state_t.shift_table): + Rename as... + (state_t.reductions, state_t.shifts): this. + + 2001-12-05 Akim Demaille * src/reduce.c (reduce_grammar_tables): No longer disable the diff --git a/src/conflicts.c b/src/conflicts.c index f4b08ede..a9ea208a 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -29,7 +29,6 @@ #include "reader.h" #include "LR0.h" -errs **err_table = NULL; /* -1 stands for not specified. */ int expected_conflicts = -1; static char *conflicts = NULL; @@ -57,7 +56,7 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"), static void flush_shift (int state, int token) { - shifts *shiftp = state_table[state].shift_table; + shifts *shiftp = state_table[state].shifts; int i; for (i = 0; i < shiftp->nshifts; i++) @@ -83,79 +82,73 @@ resolve_sr_conflict (int state, int lookaheadnum) short *errtokens = errp->errs; for (i = 0; i < ntokens; i++) - { - if (BITISSET (LA (lookaheadnum), i) - && BITISSET (lookaheadset, i) - && sprec[i]) - /* Shift-reduce conflict occurs for token number i - and it has a precedence. - The precedence of shifting is that of token i. */ - { - if (sprec[i] < redprec) - { - log_resolution (state, lookaheadnum, i, _("reduce")); - /* flush the shift for this token */ - RESETBIT (lookaheadset, i); - flush_shift (state, i); - } - else if (sprec[i] > redprec) - { - log_resolution (state, lookaheadnum, i, _("shift")); - /* flush the reduce for this token */ - RESETBIT (LA (lookaheadnum), i); - } - else - { - /* Matching precedence levels. - For left association, keep only the reduction. - For right association, keep only the shift. - For nonassociation, keep neither. */ + if (BITISSET (LA (lookaheadnum), i) + && BITISSET (lookaheadset, i) + && sprec[i]) + /* Shift-reduce conflict occurs for token number i + and it has a precedence. + The precedence of shifting is that of token i. */ + { + if (sprec[i] < redprec) + { + log_resolution (state, lookaheadnum, i, _("reduce")); + /* flush the shift for this token */ + RESETBIT (lookaheadset, i); + flush_shift (state, i); + } + else if (sprec[i] > redprec) + { + log_resolution (state, lookaheadnum, i, _("shift")); + /* flush the reduce for this token */ + RESETBIT (LA (lookaheadnum), i); + } + else + { + /* Matching precedence levels. + For left association, keep only the reduction. + For right association, keep only the shift. + For nonassociation, keep neither. */ - switch (sassoc[i]) - { - case right_assoc: - log_resolution (state, lookaheadnum, i, _("shift")); - break; + switch (sassoc[i]) + { + case right_assoc: + log_resolution (state, lookaheadnum, i, _("shift")); + break; - case left_assoc: - log_resolution (state, lookaheadnum, i, _("reduce")); - break; + case left_assoc: + log_resolution (state, lookaheadnum, i, _("reduce")); + break; - case non_assoc: - log_resolution (state, lookaheadnum, i, _("an error")); - break; - } + case non_assoc: + log_resolution (state, lookaheadnum, i, _("an error")); + break; + } + + if (sassoc[i] != right_assoc) + { + /* flush the shift for this token */ + RESETBIT (lookaheadset, i); + flush_shift (state, i); + } + if (sassoc[i] != left_assoc) + { + /* flush the reduce for this token */ + RESETBIT (LA (lookaheadnum), i); + } + if (sassoc[i] == non_assoc) + { + /* Record an explicit error for this token. */ + *errtokens++ = i; + } + } + } - if (sassoc[i] != right_assoc) - { - /* flush the shift for this token */ - RESETBIT (lookaheadset, i); - flush_shift (state, i); - } - if (sassoc[i] != left_assoc) - { - /* flush the reduce for this token */ - RESETBIT (LA (lookaheadnum), i); - } - if (sassoc[i] == non_assoc) - { - /* Record an explicit error for this token. */ - *errtokens++ = i; - } - } - } - } errp->nerrs = errtokens - errp->errs; - if (errp->nerrs) - { - /* Some tokens have been explicitly made errors. Allocate - a permanent errs structure for this state, to record them. */ - i = (char *) errtokens - (char *) errp; - err_table[state] = ERRS_ALLOC (i + 1); - bcopy (errp, err_table[state], i); - } - else - err_table[state] = 0; + /* 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); free (errp); } @@ -172,7 +165,7 @@ set_conflicts (int state) for (i = 0; i < tokensetsize; i++) lookaheadset[i] = 0; - shiftp = state_table[state].shift_table; + shiftp = state_table[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)); @@ -216,8 +209,6 @@ solve_conflicts (void) shiftset = XCALLOC (unsigned, tokensetsize); lookaheadset = XCALLOC (unsigned, tokensetsize); - err_table = XCALLOC (errs *, nstates); - for (i = 0; i < nstates; i++) set_conflicts (i); } @@ -232,7 +223,7 @@ count_sr_conflicts (int state) { int i, k; int src_count = 0; - shifts *shiftp = state_table[state].shift_table; + shifts *shiftp = state_table[state].shifts; if (!shiftp) return 0; @@ -433,7 +424,7 @@ print_reductions (FILE *out, int state) for (i = 0; i < tokensetsize; i++) shiftset[i] = 0; - shiftp = state_table[state].shift_table; + shiftp = state_table[state].shifts; for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) if (!SHIFT_IS_DISABLED (shiftp, i)) { @@ -444,7 +435,7 @@ print_reductions (FILE *out, int state) SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); } - errp = err_table[state]; + errp = state_table[state].errs; if (errp) for (i = 0; i < errp->nerrs; i++) if (errp->errs[i]) diff --git a/src/conflicts.h b/src/conflicts.h index b74cb22c..78bdb18c 100644 --- a/src/conflicts.h +++ b/src/conflicts.h @@ -1,5 +1,5 @@ /* Find and resolve or report look-ahead conflicts for bison, - Copyright 2000 Free Software Foundation, Inc. + Copyright 2000, 2001 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -29,6 +29,5 @@ void print_reductions PARAMS ((FILE*out, int state)); void free_conflicts PARAMS ((void)); /* Were there conflicts? */ -extern errs **err_table; extern int expected_conflicts; #endif /* !CONFLICTS_H_ */ diff --git a/src/lalr.c b/src/lalr.c index 4b1a4d49..09dc7602 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -156,22 +156,22 @@ set_state_table (void) { shifts *sp; for (sp = first_shift; sp; sp = sp->next) - state_table[sp->number].shift_table = sp; + state_table[sp->number].shifts = sp; } { reductions *rp; for (rp = first_reduction; rp; rp = rp->next) - state_table[rp->number].reduction_table = rp; + state_table[rp->number].reductions = rp; } /* Pessimization, but simplification of the code: make sense all the - states have a shift_table, even if reduced to 0 shifts. */ + states have a shifts, even if reduced to 0 shifts. */ { int i; for (i = 0; i < nstates; i++) - if (!state_table[i].shift_table) - state_table[i].shift_table = shifts_new (0); + if (!state_table[i].shifts) + state_table[i].shifts = shifts_new (0); } /* Initializing the lookaheads members. Please note that it must be @@ -183,8 +183,8 @@ set_state_table (void) for (i = 0; i < nstates; i++) { int k; - reductions *rp = state_table[i].reduction_table; - shifts *sp = state_table[i].shift_table; + reductions *rp = state_table[i].reductions; + shifts *sp = state_table[i].shifts; state_table[i].lookaheads = count; @@ -225,7 +225,7 @@ initialize_LA (void) np = LAruleno; for (i = 0; i < nstates; i++) if (!state_table[i].consistent) - if ((rp = state_table[i].reduction_table)) + if ((rp = state_table[i].reductions)) for (j = 0; j < rp->nreds; j++) *np++ = rp->rules[j]; } @@ -340,13 +340,13 @@ initialize_F (void) for (i = 0; i < ngotos; i++) { int stateno = to_state[i]; - shifts *sp = state_table[stateno].shift_table; + shifts *sp = state_table[stateno].shifts; int j; for (j = 0; j < sp->nshifts && SHIFT_IS_SHIFT (sp, j); j++) { int symbol = state_table[sp->shifts[j]].accessing_symbol; - SETBIT (F + i * tokensetsize, symbol); + SETBIT (F (i), symbol); } for (; j < sp->nshifts; j++) @@ -515,7 +515,7 @@ build_relations (void) for (rp = ritem + rule_table[*rulep].rhs; *rp > 0; rp++) { - shifts *sp = state_table[stateno].shift_table; + shifts *sp = state_table[stateno].shifts; int j; for (j = 0; j < sp->nshifts; j++) { diff --git a/src/lalr.h b/src/lalr.h index f9941afa..55e01d8f 100644 --- a/src/lalr.h +++ b/src/lalr.h @@ -78,8 +78,9 @@ typedef struct state_s /* Its accessing symbol. */ short accessing_symbol; - shifts *shift_table; - reductions *reduction_table; + shifts *shifts; + reductions *reductions; + errs *errs; /* Nonzero if no lookahead is needed to decide what to do in state S. */ diff --git a/src/output.c b/src/output.c index fa01bbd8..693a45b1 100644 --- a/src/output.c +++ b/src/output.c @@ -355,7 +355,7 @@ action_row (int state) default_rule = 0; nreds = 0; - redp = state_table[state].reduction_table; + redp = state_table[state].reductions; if (redp) { @@ -382,7 +382,7 @@ action_row (int state) /* Now see which tokens are allowed for shifts in this state. For them, record the shift as the thing to do. So shift is preferred to reduce. */ - shiftp = state_table[state].shift_table; + shiftp = state_table[state].shifts; for (i = 0; i < shiftp->nshifts; i++) { shift_state = shiftp->shifts[i]; @@ -404,7 +404,7 @@ action_row (int state) /* See which tokens are an explicit error in this state (due to %nonassoc). For them, record MINSHORT as the action. */ - errp = err_table[state]; + errp = state_table[state].errs; if (errp) { diff --git a/src/print.c b/src/print.c index 025c179f..93021fa5 100644 --- a/src/print.c +++ b/src/print.c @@ -98,9 +98,9 @@ print_actions (FILE *out, int state) { int i; - shifts *shiftp = state_table[state].shift_table; - reductions *redp = state_table[state].reduction_table; - errs *errp = err_table[state]; + shifts *shiftp = state_table[state].shifts; + reductions *redp = state_table[state].reductions; + errs *errp = state_table[state].errs; if (!shiftp->nshifts && !redp) { diff --git a/src/print_graph.c b/src/print_graph.c index 5a3ba52d..76dc1833 100644 --- a/src/print_graph.c +++ b/src/print_graph.c @@ -85,8 +85,8 @@ print_actions (int state, const char *node_name) { int i; - shifts *shiftp = state_table[state].shift_table; - reductions *redp = state_table[state].reduction_table; + shifts *shiftp = state_table[state].shifts; + reductions *redp = state_table[state].reductions; #if 0 errs *errp = err_table[state]; #endif -- 2.45.2