X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/afbb696d1936dd21929ce156868b7c5ebd88b544..742e4900c8b05c8c1f56985288141c890f1e9c73:/src/tables.c diff --git a/src/tables.c b/src/tables.c index d39e2d8a..000d027c 100644 --- a/src/tables.c +++ b/src/tables.c @@ -1,7 +1,7 @@ /* Output the generated parsing program for Bison. - Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004, + 2005 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -17,10 +17,10 @@ You should have received a copy of the GNU General Public License along with Bison; see the file COPYING. If not, write to the Free - Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ - + Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. */ +#include #include "system.h" #include @@ -42,13 +42,15 @@ Of course vector_number_t ought to be wide enough to contain state_number and symbol_number. */ -typedef short int vector_number; +typedef int vector_number; +#if 0 /* Not currently used. */ static inline vector_number state_number_to_vector_number (state_number s) { return s; } +#endif static inline vector_number symbol_number_to_vector_number (symbol_number sym) @@ -81,11 +83,11 @@ int nvectors; #define BASE_MAXIMUM INT_MAX #define BASE_MINIMUM INT_MIN -static base_number **froms = NULL; -static base_number **tos = NULL; -static unsigned int **conflict_tos = NULL; -static short int *tally = NULL; -static base_number *width = NULL; +static base_number **froms; +static base_number **tos; +static unsigned int **conflict_tos; +static int *tally; +static base_number *width; /* For a given state, N = ACTROW[SYMBOL]: @@ -94,15 +96,15 @@ static base_number *width = NULL; If N = MIN, stands for `raise a syntax error'. If N > 0, stands for `shift SYMBOL and go to n'. If N < 0, stands for `reduce -N'. */ -typedef short int action_number; -#define ACTION_NUMBER_MINIMUM SHRT_MIN +typedef int action_number; +#define ACTION_NUMBER_MINIMUM INT_MIN -static action_number *actrow = NULL; +static action_number *actrow; /* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the new vector number of VECTOR. We skip `empty' vectors (i.e., TALLY[VECTOR] = 0), and call these `entries'. */ -static vector_number *order = NULL; +static vector_number *order; static int nentries; base_number *base = NULL; @@ -112,9 +114,9 @@ base_number *base = NULL; base_number base_ninf = 0; static base_number *pos = NULL; -static unsigned int *conflrow = NULL; -unsigned int *conflict_table = NULL; -unsigned int *conflict_list = NULL; +static unsigned int *conflrow; +unsigned int *conflict_table; +unsigned int *conflict_list; int conflict_list_cnt; static int conflict_list_free; @@ -122,8 +124,8 @@ static int conflict_list_free; with more or less the original hard-coded value (which was SHRT_MAX). */ static int table_size = 32768; -base_number *table = NULL; -base_number *check = NULL; +base_number *table; +base_number *check; /* The value used in TABLE to denote explicit syntax errors (%nonassoc), a negative infinite. First defaults to ACTION_NUMBER_MININUM, but in order to keep small tables, renumbered as TABLE_ERROR, which @@ -153,13 +155,15 @@ table_grow (int desired) fprintf (stderr, "growing table and check from: %d to %d\n", old_size, table_size); - REALLOC (table, table_size); - REALLOC (check, table_size); - REALLOC (conflict_table, table_size); + table = xnrealloc (table, table_size, sizeof *table); + conflict_table = xnrealloc (conflict_table, table_size, + sizeof *conflict_table); + check = xnrealloc (check, table_size, sizeof *check); for (/* Nothing. */; old_size < table_size; ++old_size) { table[old_size] = 0; + conflict_table[old_size] = 0; check[old_size] = -1; } } @@ -169,7 +173,7 @@ table_grow (int desired) /*-------------------------------------------------------------------. | For GLR parsers, for each conflicted token in S, as indicated | -| by non-zero entries in CONFLROW, create a list of possible | +| by non-zero entries in CONFLROW, create a list of possible | | reductions that are alternatives to the shift or reduction | | currently recorded for that token in S. Store the alternative | | reductions followed by a 0 in CONFLICT_LIST, updating | @@ -194,20 +198,19 @@ conflict_row (state *s) /* Find all reductions for token J, and record all that do not match ACTROW[J]. */ for (i = 0; i < reds->num; i += 1) - if (bitset_test (reds->look_ahead_tokens[i], j) + if (bitset_test (reds->lookahead_tokens[i], j) && (actrow[j] != rule_number_as_item_number (reds->rules[i]->number))) { - if (conflict_list_free <= 0) - abort (); + assert (0 < conflict_list_free); conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1; conflict_list_cnt += 1; conflict_list_free -= 1; } /* Leave a 0 at the end. */ - if (conflict_list_free <= 0) - abort (); + assert (0 < conflict_list_free); + conflict_list[conflict_list_cnt] = 0; conflict_list_cnt += 1; conflict_list_free -= 1; } @@ -216,7 +219,7 @@ conflict_row (state *s) /*------------------------------------------------------------------. | Decide what to do for each type of token if seen as the | -| look-ahead in specified state. The value returned is used as the | +| lookahead in specified state. The value returned is used as the | | default action (yydefact) for the state. In addition, ACTROW is | | filled with what to do for each kind of token, index by symbol | | number, with zero meaning do the default action. The value | @@ -224,7 +227,7 @@ conflict_row (state *s) | situation is an error. The parser recognizes this value | | specially. | | | -| This is where conflicts are resolved. The loop over look-ahead | +| This is where conflicts are resolved. The loop over lookahead | | rules considered lower-numbered rules last, and the last rule | | considered that likes a token gets to handle it. | | | @@ -249,17 +252,17 @@ action_row (state *s) for (i = 0; i < ntokens; i++) actrow[i] = conflrow[i] = 0; - if (reds->look_ahead_tokens) + if (reds->lookahead_tokens) { int j; bitset_iterator biter; /* loop over all the rules available here which require - look-ahead (in reverse order to give precedence to the first + lookahead (in reverse order to give precedence to the first rule) */ for (i = reds->num - 1; i >= 0; --i) /* and find each token which the rule finds acceptable to come next */ - BITSET_FOR_EACH (biter, reds->look_ahead_tokens[i], j, 0) + BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0) { /* and record this rule as the rule to use if that token follows. */ @@ -373,7 +376,7 @@ save_row (state_number s) base_number *sp; base_number *sp1; base_number *sp2; - unsigned int *sp3 IF_LINT (= NULL); + unsigned int *sp3; /* Number of non default actions in S. */ count = 0; @@ -385,9 +388,10 @@ save_row (state_number s) return; /* Allocate non defaulted actions. */ - froms[s] = sp = CALLOC (sp1, count); - tos[s] = CALLOC (sp2, count); - conflict_tos[s] = nondeterministic_parser ? CALLOC (sp3, count) : NULL; + froms[s] = sp = sp1 = xnmalloc (count, sizeof *sp1); + tos[s] = sp2 = xnmalloc (count, sizeof *sp2); + conflict_tos[s] = sp3 = + nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL; /* Store non defaulted actions. */ for (i = 0; i < ntokens; i++) @@ -406,7 +410,7 @@ save_row (state_number s) /*------------------------------------------------------------------. | Figure out the actions for the specified state, indexed by | -| look-ahead token type. | +| lookahead token type. | | | | The YYDEFACT table is output now. The detailed info is saved for | | putting into YYTABLE later. | @@ -421,12 +425,12 @@ token_actions (void) int nconflict = nondeterministic_parser ? conflicts_total_count () : 0; - CALLOC (yydefact, nstates); + yydefact = xnmalloc (nstates, sizeof *yydefact); - CALLOC (actrow, ntokens); - CALLOC (conflrow, ntokens); + actrow = xnmalloc (ntokens, sizeof *actrow); + conflrow = xnmalloc (ntokens, sizeof *conflrow); - CALLOC (conflict_list, 1 + 2 * nconflict); + conflict_list = xnmalloc (1 + 2 * nconflict, sizeof *conflict_list); conflict_list_free = 2 * nconflict; conflict_list_cnt = 1; @@ -471,7 +475,7 @@ token_actions (void) static void save_column (symbol_number sym, state_number default_state) { - int i; + goto_number i; base_number *sp; base_number *sp1; base_number *sp2; @@ -491,8 +495,8 @@ save_column (symbol_number sym, state_number default_state) return; /* Allocate room for non defaulted gotos. */ - froms[symno] = sp = CALLOC (sp1, count); - tos[symno] = CALLOC (sp2, count); + froms[symno] = sp = sp1 = xnmalloc (count, sizeof *sp1); + tos[symno] = sp2 = xnmalloc (count, sizeof *sp2); /* Store the state numbers of the non defaulted gotos. */ for (i = begin; i < end; i++) @@ -512,14 +516,14 @@ save_column (symbol_number sym, state_number default_state) `-------------------------------------------------------------*/ static state_number -default_goto (symbol_number sym, short int state_count[]) +default_goto (symbol_number sym, size_t state_count[]) { state_number s; - int i; + goto_number i; goto_number m = goto_map[sym - ntokens]; goto_number n = goto_map[sym - ntokens + 1]; state_number default_state = -1; - int max = 0; + size_t max = 0; if (m == n) return -1; @@ -554,8 +558,8 @@ static void goto_actions (void) { symbol_number i; - short int *state_count = CALLOC (state_count, nstates); - MALLOC (yydefgoto, nvars); + size_t *state_count = xnmalloc (nstates, sizeof *state_count); + yydefgoto = xnmalloc (nvars, sizeof *yydefgoto); /* For a given nterm I, STATE_COUNT[S] is the number of times there is a GOTO to S on I. */ @@ -669,16 +673,14 @@ pack_vector (vector_number vector) base_number *to = tos[i]; unsigned int *conflict_to = conflict_tos[i]; - if (!t) - abort (); + assert (t); for (j = lowzero - from[0]; ; j++) { int k; bool ok = true; - if (table_size <= j) - abort (); + assert (j < table_size); for (k = 0; ok && k < t; k++) { @@ -711,8 +713,7 @@ pack_vector (vector_number vector) if (loc > high) high = loc; - if (! (BASE_MINIMUM <= j && j <= BASE_MAXIMUM)) - abort (); + assert (BASE_MINIMUM <= j && j <= BASE_MAXIMUM); return j; } } @@ -751,11 +752,11 @@ pack_table (void) { int i; - CALLOC (base, nvectors); - CALLOC (pos, nentries); - CALLOC (table, table_size); - CALLOC (conflict_table, table_size); - CALLOC (check, table_size); + base = xnmalloc (nvectors, sizeof *base); + pos = xnmalloc (nentries, sizeof *pos); + table = xcalloc (table_size, sizeof *table); + conflict_table = xcalloc (table_size, sizeof *conflict_table); + check = xnmalloc (table_size, sizeof *check); lowzero = 0; high = 0; @@ -804,17 +805,16 @@ tables_generate (void) /* This is a poor way to make sure the sizes are properly correlated. In particular the signedness is not taken into account. But it's not useless. */ - verify (sizes_are_properly_correlated, - (sizeof nstates <= sizeof nvectors - && sizeof nvars <= sizeof nvectors)); + verify (sizeof nstates <= sizeof nvectors + && sizeof nvars <= sizeof nvectors); nvectors = state_number_as_int (nstates) + nvars; - CALLOC (froms, nvectors); - CALLOC (tos, nvectors); - CALLOC (conflict_tos, nvectors); - CALLOC (tally, nvectors); - CALLOC (width, nvectors); + froms = xcalloc (nvectors, sizeof *froms); + tos = xcalloc (nvectors, sizeof *tos); + conflict_tos = xcalloc (nvectors, sizeof *conflict_tos); + tally = xcalloc (nvectors, sizeof *tally); + width = xnmalloc (nvectors, sizeof *width); token_actions (); @@ -823,7 +823,7 @@ tables_generate (void) free (from_state); free (to_state); - CALLOC (order, nvectors); + order = xcalloc (nvectors, sizeof *order); sort_actions (); pack_table (); free (order);