(symbol_destructors_output, symbol_printers_output):

[bison.git] / src / tables.c

diff --git a/src/tables.c b/src/tables.c
index 80f47e21ba7d75ec95b691c0dc4513c825488aa7..50dd4535161e200fea1ad87fdb84b17eac8f78d5 100644 (file)
--- a/src/tables.c
+++ b/src/tables.c
@@ -1,6 +1,6 @@
 /* Output the generated parsing program for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
@@ -42,7 +42,7 @@
 
    Of course vector_number_t ought to be wide enough to contain
    state_number and symbol_number.  */
-typedef short vector_number;
+typedef short int vector_number;
 
 static inline vector_number
 state_number_to_vector_number (state_number s)
@@ -84,7 +84,7 @@ int nvectors;
 static base_number **froms = NULL;
 static base_number **tos = NULL;
 static unsigned int **conflict_tos = NULL;
-static short *tally = NULL;
+static short int *tally = NULL;
 static base_number *width = NULL;
 
 
@@ -94,7 +94,7 @@ 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 action_number;
+typedef short int action_number;
 #define ACTION_NUMBER_MINIMUM SHRT_MIN
 
 static action_number *actrow = NULL;
@@ -194,7 +194,7 @@ 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->lookaheads[i], j)
+         if (bitset_test (reds->look_ahead_tokens[i], j)
              && (actrow[j]
                  != rule_number_as_item_number (reds->rules[i]->number)))
            {
@@ -215,8 +215,8 @@ conflict_row (state *s)
 
 
 /*------------------------------------------------------------------.
-| Decide what to do for each type of token if seen as the lookahead |
-| token in specified state.  The value returned is used as the      |
+| 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 |
 | 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 +224,7 @@ conflict_row (state *s)
 | situation is an error.  The parser recognizes this value         |
 | specially.                                                       |
 |                                                                   |
-| This is where conflicts are resolved.  The loop over lookahead    |
+| This is where conflicts are resolved.  The loop over look-ahead   |
 | rules considered lower-numbered rules last, and the last rule     |
 | considered that likes a token gets to handle it.                  |
 |                                                                   |
@@ -243,28 +243,31 @@ action_row (state *s)
   transitions *trans = s->transitions;
   errs *errp = s->errs;
   /* Set to nonzero to inhibit having any default reduction.  */
-  int nodefault = 0;
-  int conflicted = 0;
+  bool nodefault = false;
+  bool conflicted = false;
 
   for (i = 0; i < ntokens; i++)
     actrow[i] = conflrow[i] = 0;
 
-  if (reds->lookaheads)
+  if (reds->look_ahead_tokens)
     {
       int j;
       bitset_iterator biter;
       /* loop over all the rules available here which require
-        lookahead (in reverse order to give precedence to the first
+        look-ahead (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->lookaheads[i], j, 0)
+       BITSET_FOR_EACH (biter, reds->look_ahead_tokens[i], j, 0)
        {
          /* and record this rule as the rule to use if that
             token follows.  */
          if (actrow[j] != 0)
-           conflicted = conflrow[j] = 1;
+           {
+             conflicted = true;
+             conflrow[j] = 1;
+           }
          actrow[j] = rule_number_as_item_number (reds->rules[i]->number);
        }
     }
@@ -278,13 +281,16 @@ action_row (state *s)
       state *shift_state = trans->states[i];
 
       if (actrow[sym] != 0)
-       conflicted = conflrow[sym] = 1;
+       {
+         conflicted = true;
+         conflrow[sym] = 1;
+       }
       actrow[sym] = state_number_as_int (shift_state->number);
 
       /* Do not use any default reduction if there is a shift for
         error */
       if (sym == errtoken->number)
-       nodefault = 1;
+       nodefault = true;
     }
 
   /* See which tokens are an explicit error in this state (due to
@@ -400,7 +406,7 @@ save_row (state_number s)
 
 /*------------------------------------------------------------------.
 | Figure out the actions for the specified state, indexed by        |
-| lookahead token type.                                             |
+| look-ahead token type.                                            |
 |                                                                   |
 | The YYDEFACT table is output now.  The detailed info is saved for |
 | putting into YYTABLE later.                                       |
@@ -506,7 +512,7 @@ save_column (symbol_number sym, state_number default_state)
 `-------------------------------------------------------------*/
 
 static state_number
-default_goto (symbol_number sym, short state_count[])
+default_goto (symbol_number sym, short int state_count[])
 {
   state_number s;
   int i;
@@ -548,7 +554,7 @@ static void
 goto_actions (void)
 {
   symbol_number i;
-  short *state_count = CALLOC (state_count, nstates);
+  short int *state_count = CALLOC (state_count, nstates);
   MALLOC (yydefgoto, nvars);
 
   /* For a given nterm I, STATE_COUNT[S] is the number of times there
@@ -669,7 +675,7 @@ pack_vector (vector_number vector)
   for (j = lowzero - from[0]; ; j++)
     {
       int k;
-      int ok = 1;
+      bool ok = true;
 
       if (table_size <= j)
        abort ();
@@ -681,12 +687,12 @@ pack_vector (vector_number vector)
            table_grow (loc);
 
          if (table[loc] != 0)
-           ok = 0;
+           ok = false;
        }
 
       for (k = 0; ok && k < vector; k++)
        if (pos[k] == j)
-         ok = 0;
+         ok = false;
 
       if (ok)
        {