From f004bf6ac4bdfe0b7dcd554eac8c8899512f9475 Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Mon, 19 Nov 2001 10:08:20 +0000 Subject: [PATCH] * src/lalr.h (lookaheads): Removed array, which contents is now member of... (state_t): this structure. * src/output.c, src/lalr.c, src/print_graph.c, src/conflicts.c: Adjust. --- ChangeLog | 8 ++++++++ src/conflicts.c | 18 +++++++++--------- src/lalr.c | 24 +++++++++++------------- src/lalr.h | 8 ++++---- src/output.c | 5 ++--- 5 files changed, 34 insertions(+), 29 deletions(-) diff --git a/ChangeLog b/ChangeLog index 4663bec0..3f2dcdbb 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,11 @@ +2001-11-19 Akim Demaille + + * src/lalr.h (lookaheads): Removed array, which contents is now + member of... + (state_t): this structure. + * src/output.c, src/lalr.c, src/print_graph.c, src/conflicts.c: + Adjust. + 2001-11-19 Akim Demaille * src/lalr.h (consistent): Removed array, which contents is now diff --git a/src/conflicts.c b/src/conflicts.c index 60a5edec..77520ade 100644 --- a/src/conflicts.c +++ b/src/conflicts.c @@ -210,13 +210,13 @@ set_conflicts (int state) } } - k = lookaheads[state + 1]; + k = state_table[state + 1].lookaheads; fp4 = lookaheadset + tokensetsize; /* Loop over all rules which require lookahead in this state. First check for shift-reduce conflict, and try to resolve using precedence */ - for (i = lookaheads[state]; i < k; i++) + for (i = state_table[state].lookaheads; i < k; i++) if (rprec[LAruleno[i]]) { fp1 = LA + i * tokensetsize; @@ -236,7 +236,7 @@ set_conflicts (int state) /* Loop over all rules which require lookahead in this state. Check for conflicts not resolved above. */ - for (i = lookaheads[state]; i < k; i++) + for (i = state_table[state].lookaheads; i < k; i++) { fp1 = LA + i * tokensetsize; fp2 = fp1; @@ -309,10 +309,10 @@ count_sr_conflicts (int state) SETBIT (shiftset, symbol); } - k = lookaheads[state + 1]; + k = state_table[state + 1].lookaheads; fp3 = lookaheadset + tokensetsize; - for (i = lookaheads[state]; i < k; i++) + for (i = state_table[state].lookaheads; i < k; i++) { fp1 = LA + i * tokensetsize; fp2 = lookaheadset; @@ -359,8 +359,8 @@ count_rr_conflicts (int state) int rrc_count = 0; - int m = lookaheads[state]; - int n = lookaheads[state + 1]; + int m = state_table[state].lookaheads; + int n = state_table[state + 1].lookaheads; if (n - m < 2) return 0; @@ -565,8 +565,8 @@ print_reductions (FILE *out, int state) } } - m = lookaheads[state]; - n = lookaheads[state + 1]; + m = state_table[state].lookaheads; + n = state_table[state + 1].lookaheads; if (n - m == 1 && !nodefault) { diff --git a/src/lalr.c b/src/lalr.c index d4795b57..9d11c42d 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -38,7 +38,6 @@ state_t *state_table = NULL; int tokensetsize; -short *lookaheads; short *LAruleno; unsigned *LA; @@ -145,7 +144,10 @@ digraph (short **relation) static void set_state_table (void) { - state_table = XCALLOC (state_t, nstates); + /* NSTATES + 1 because lookahead for the pseudo state number NSTATES + might be used (see conflicts.c). It is too opaque for me to + provide a probably less hacky implementation. --akim */ + state_table = XCALLOC (state_t, nstates + 1); { core *sp; @@ -202,19 +204,16 @@ initialize_LA (void) { int i; int j; - int count; + int count = 0; reductions *rp; shifts *sp; short *np; - lookaheads = XCALLOC (short, nstates + 1); - - count = 0; for (i = 0; i < nstates; i++) { int k; - lookaheads[i] = count; + state_table[i].lookaheads = count; rp = state_table[i].reduction_table; sp = state_table[i].shift_table; @@ -235,7 +234,7 @@ initialize_LA (void) } } - lookaheads[nstates] = count; + state_table[nstates].lookaheads = count; if (count == 0) { @@ -450,8 +449,8 @@ add_lookback_edge (int stateno, int ruleno, int gotono) int found; shorts *sp; - i = lookaheads[stateno]; - k = lookaheads[stateno + 1]; + i = state_table[stateno].lookaheads; + k = state_table[stateno + 1].lookaheads; found = 0; while (!found && i < k) { @@ -653,8 +652,7 @@ compute_lookaheads (void) shorts *sptmp; /* JF */ rowp = LA; - n = lookaheads[nstates]; - for (i = 0; i < n; i++) + for (i = 0; i < state_table[nstates].lookaheads; i++) { fp3 = rowp + tokensetsize; for (sp = lookback[i]; sp; sp = sp->next) @@ -668,7 +666,7 @@ compute_lookaheads (void) rowp = fp3; } - for (i = 0; i < n; i++) + for (i = 0; i < state_table[nstates].lookaheads; i++) { /* JF removed ref to freed storage */ for (sp = lookback[i]; sp; sp = sptmp) diff --git a/src/lalr.h b/src/lalr.h index c2444883..00137154 100644 --- a/src/lalr.h +++ b/src/lalr.h @@ -83,6 +83,8 @@ typedef struct state_s /* Nonzero if no lookahead is needed to decide what to do in state S. */ char consistent; + + short lookaheads; } state_t; /* All the decorated states, indexed by the state number. Warning: @@ -91,9 +93,7 @@ typedef struct state_s extern state_t *state_table; extern int tokensetsize; -extern short *lookaheads; - - - +/* The number of lookaheads. */ +extern size_t nlookaheads; #endif /* !LALR_H_ */ diff --git a/src/output.c b/src/output.c index 8abbd5d2..3a7f0817 100644 --- a/src/output.c +++ b/src/output.c @@ -348,8 +348,8 @@ action_row (int state) { /* loop over all the rules available here which require lookahead */ - m = lookaheads[state]; - n = lookaheads[state + 1]; + m = state_table[state].lookaheads; + n = state_table[state + 1].lookaheads; for (i = n - 1; i >= m; i--) { @@ -928,7 +928,6 @@ output_actions (void) token_actions (); free_shifts (); free_reductions (); - XFREE (lookaheads); XFREE (LA); XFREE (LAruleno); -- 2.45.2