Use ASCII for Sebastien Fricker's name.

[bison.git] / src / tables.c

diff --git a/src/tables.c b/src/tables.c
index c25d74e75f1a41483ef0b2312f2f561d42135348..dc82cd03e5248879ef4473255f8c9fd2b9b436c2 100644 (file)
--- 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,
-   2005 Free Software Foundation, Inc.
+   2005, 2006 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 <config.h>
 #include "system.h"
 
 #include <bitsetv.h>
@@ -173,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                     |
@@ -198,20 +198,18 @@ 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 ();
+             aver (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 ();
+       aver (0 < conflict_list_free);
        conflict_list[conflict_list_cnt] = 0;
        conflict_list_cnt += 1;
        conflict_list_free -= 1;
@@ -221,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       |
@@ -229,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.                  |
 |                                                                   |
@@ -254,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.  */
@@ -412,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.                                       |
@@ -675,16 +673,14 @@ pack_vector (vector_number vector)
   base_number *to = tos[i];
   unsigned int *conflict_to = conflict_tos[i];
 
-  if (!t)
-    abort ();
+  aver (t != 0);
 
   for (j = lowzero - from[0]; ; j++)
     {
       int k;
       bool ok = true;
 
-      if (table_size <= j)
-       abort ();
+      aver (j < table_size);
 
       for (k = 0; ok && k < t; k++)
        {
@@ -717,8 +713,7 @@ pack_vector (vector_number vector)
          if (loc > high)
            high = loc;
 
-         if (! (BASE_MINIMUM <= j && j <= BASE_MAXIMUM))
-           abort ();
+         aver (BASE_MINIMUM <= j && j <= BASE_MAXIMUM);
          return j;
        }
     }
@@ -810,9 +805,8 @@ 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;