From 80dac38c5eb3b95412a6c99c9dbe976ac963c01b Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Thu, 27 Dec 2001 18:11:06 +0000 Subject: [PATCH] * src/state.h, src/state.c (reductions_new): New. * src/LR0.c (set_state_table): Let all the states have a `reductions', even if reduced to 0. (save_reductions): Adjust. * src/lalr.c (initialize_LA, initialize_lookaheads): Adjust. * src/print.c (print_reductions, print_actions): Adjust. * src/output.c (action_row): Adjust. --- ChangeLog | 11 +++++++++++ src/LR0.c | 16 ++++++---------- src/lalr.c | 14 ++++++++------ src/output.c | 5 ++--- src/print.c | 8 +++++--- src/state.c | 16 ++++++++++++++++ src/state.h | 5 +---- 7 files changed, 49 insertions(+), 26 deletions(-) diff --git a/ChangeLog b/ChangeLog index c600ff3a..3eb45256 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2001-12-27 Akim Demaille + + * src/state.h, src/state.c (reductions_new): New. + * src/LR0.c (set_state_table): Let all the states have a + `reductions', even if reduced to 0. + (save_reductions): Adjust. + * src/lalr.c (initialize_LA, initialize_lookaheads): Adjust. + * src/print.c (print_reductions, print_actions): Adjust. + * src/output.c (action_row): Adjust. + + 2001-12-27 Akim Demaille * src/state.h, src/state.c (errs_new, errs_dup): New. diff --git a/src/LR0.c b/src/LR0.c index 4f771d21..a9a69655 100644 --- a/src/LR0.c +++ b/src/LR0.c @@ -522,15 +522,8 @@ save_reductions (void) } /* Make a reductions structure and copy the data into it. */ - - if (count) - { - reductions *p = REDUCTIONS_ALLOC (count); - p->nreds = count; - shortcpy (p->rules, redset, count); - - this_state->reductions = p; - } + this_state->reductions = reductions_new (count); + shortcpy (this_state->reductions->rules, redset, count); } @@ -547,11 +540,14 @@ set_state_table (void) for (sp = first_state; sp; sp = sp->next) { /* Pessimization, but simplification of the code: make sure all - the states have a shifts and errs, even if reduced to 0. */ + the states have a shifts, errs, and reductions, even if + reduced to 0. */ if (!sp->shifts) sp->shifts = shifts_new (0); if (!sp->errs) sp->errs = errs_new (0); + if (!sp->reductions) + sp->reductions = reductions_new (0); state_table[sp->number] = sp; } diff --git a/src/lalr.c b/src/lalr.c index 3851350b..db9abfa3 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -137,7 +137,6 @@ initialize_LA (void) int i; int j; short *np; - reductions *rp; /* Avoid having to special case 0. */ if (!nLA) @@ -150,9 +149,8 @@ initialize_LA (void) np = LAruleno; for (i = 0; i < nstates; i++) if (!state_table[i]->consistent) - if ((rp = state_table[i]->reductions)) - for (j = 0; j < rp->nreds; j++) - *np++ = rp->rules[j]; + for (j = 0; j < state_table[i]->reductions->nreds; j++) + *np++ = state_table[i]->reductions->rules[j]; } @@ -525,8 +523,12 @@ initialize_lookaheads (void) reductions *rp = state_table[i]->reductions; shifts *sp = state_table[i]->shifts; - if (rp - && (rp->nreds > 1 || (sp->nshifts && SHIFT_IS_SHIFT (sp, 0)))) + /* We need a lookahead either to distinguish different + reductions (i.e., there are two or more), or to distinguish a + reduction from a shift. Otherwise, it is straightforward, + and the state is `consistent'. */ + if (rp->nreds > 1 + || (rp->nreds == 1 && sp->nshifts && SHIFT_IS_SHIFT (sp, 0))) nlookaheads += rp->nreds; else state_table[i]->consistent = 1; diff --git a/src/output.c b/src/output.c index c424716c..34ff7d36 100644 --- a/src/output.c +++ b/src/output.c @@ -326,7 +326,6 @@ action_row (state_t *state) int i; int default_rule = 0; reductions *redp = state->reductions; - int nreds = redp ? redp->nreds : 0; shifts *shiftp = state->shifts; errs *errp = state->errs; /* set nonzero to inhibit having any default reduction */ @@ -335,7 +334,7 @@ action_row (state_t *state) for (i = 0; i < ntokens; i++) actrow[i] = 0; - if (nreds >= 1) + if (redp->nreds >= 1) { int j; /* loop over all the rules available here which require @@ -384,7 +383,7 @@ action_row (state_t *state) /* Now find the most common reduction and make it the default action for this state. */ - if (nreds >= 1 && !nodefault) + if (redp->nreds >= 1 && !nodefault) { if (state->consistent) default_rule = redp->rules[0]; diff --git a/src/print.c b/src/print.c index b9c518f7..b6c41a85 100644 --- a/src/print.c +++ b/src/print.c @@ -167,6 +167,9 @@ print_reductions (FILE *out, state_t *state) errs *errp = state->errs; int nodefault = 0; + if (redp->nreds == 0) + return; + if (state->consistent) { int rule = redp->rules[0]; @@ -302,7 +305,7 @@ print_actions (FILE *out, state_t *state) reductions *redp = state->reductions; shifts *shiftp = state->shifts; - if (!shiftp->nshifts && !redp) + if (shiftp->nshifts == 0 && redp->nreds == 0) { if (final_state == state->number) fprintf (out, _(" $default\taccept\n")); @@ -313,8 +316,7 @@ print_actions (FILE *out, state_t *state) print_shifts (out, state); print_errs (out, state); - if (redp) - print_reductions (out, state); + print_reductions (out, state); print_gotos (out, state); } diff --git a/src/state.c b/src/state.c index ed4a5082..a1e83f38 100644 --- a/src/state.c +++ b/src/state.c @@ -64,3 +64,19 @@ errs_dup (errs *src) memcpy (res->errs, src->errs, src->nerrs); return res; } + +/*-------------------------------------. +| Create a new array of N reductions. | +`-------------------------------------*/ + +#define REDUCTIONS_ALLOC(Nreductions) \ + (reductions *) xcalloc ((unsigned) (sizeof (reductions) \ + + (Nreductions - 1) * sizeof (short)), 1) + +reductions * +reductions_new (int n) +{ + reductions *res = REDUCTIONS_ALLOC (n); + res->nreds = n; + return res; +} diff --git a/src/state.h b/src/state.h index 14017afe..8cdf4040 100644 --- a/src/state.h +++ b/src/state.h @@ -158,10 +158,7 @@ typedef struct reductions short rules[1]; } reductions; -#define REDUCTIONS_ALLOC(Nreductions) \ - (reductions *) xcalloc ((unsigned) (sizeof (reductions) \ - + (Nreductions - 1) * sizeof (short)), 1) - +reductions *reductions_new PARAMS ((int n)); /*----------. -- 2.49.0