(_AT_TEST_GLR_CXXTYPES): Do not include <assert.h>.

[bison.git] / src / tables.c

diff --git a/src/tables.c b/src/tables.c
index 0b4fd275f0caac1c841eeff81b7e8b0f84b190fa..0ebcd2a18e35496125f679ac16f720a461af39ae 100644 (file)
--- a/src/tables.c
+++ b/src/tables.c
@@ -1,4 +1,4 @@
-/* Output the generated parsing program for bison,
+/* Output the generated parsing program for Bison.
    Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
@@ -33,9 +33,9 @@
 #include "conflicts.h"
 #include "tables.h"
 
-/* Several tables will be indexed both by state and nonterminal
-   numbers.  We call `vector' such a thing (= either a state or a
-   symbol number.
+/* Several tables are indexed both by state and nonterminal numbers.
+   We call such an index a `vector'; i.e., a vector is either a state
+   or a nonterminal number.
 
    Of course vector_number_t ought to be wide enough to contain
    state_number_t and symbol_number_t.  */
@@ -82,7 +82,7 @@ static base_t *width = NULL;
 /* For a given state, N = ACTROW[SYMBOL]:
 
    If N = 0, stands for `run the default action'.
-   If N = MIN, stands for `raise a parse error'.
+   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_t;
@@ -116,7 +116,7 @@ static int conflict_list_free;
 static size_t table_size = 32768;
 base_t *table = NULL;
 base_t *check = NULL;
-/* The value used in TABLE to denote explicit parse errors
+/* The value used in TABLE to denote explicit syntax errors
    (%nonassoc), a negative infinite.  First defaults to ACTION_MIN,
    but in order to keep small tables, renumbered as TABLE_ERROR, which
    is the smallest (non error) value minus 1.  */
@@ -190,14 +190,16 @@ conflict_row (state_t *state)
              && (actrow[j]
                  != rule_number_as_item_number (reds->rules[i]->number)))
            {
-             assert (conflict_list_free > 0);
+             if (conflict_list_free <= 0)
+               abort ();
              conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1;
              conflict_list_cnt += 1;
              conflict_list_free -= 1;
            }
 
        /* Leave a 0 at the end.  */
-       assert (conflict_list_free > 0);
+       if (conflict_list_free <= 0)
+         abort ();
        conflict_list_cnt += 1;
        conflict_list_free -= 1;
       }
@@ -418,7 +420,7 @@ token_actions (void)
   /* Find the rules which are reduced.  */
   if (!glr_parser)
     for (r = 0; r < nrules; ++r)
-      rules[r].useful = FALSE;
+      rules[r].useful = false;
 
   for (i = 0; i < nstates; ++i)
     {
@@ -433,9 +435,9 @@ token_actions (void)
        {
          for (j = 0; j < ntokens; ++j)
            if (actrow[j] < 0 && actrow[j] != ACTION_MIN)
-             rules[item_number_as_rule_number (actrow[j])].useful = TRUE;
+             rules[item_number_as_rule_number (actrow[j])].useful = true;
          if (yydefact[i])
-           rules[yydefact[i] - 1].useful = TRUE;
+           rules[yydefact[i] - 1].useful = true;
        }
     }
 
@@ -610,6 +612,15 @@ matching_state (vector_number_t vector)
   t = tally[i];
   w = width[i];
 
+  /* If VECTOR has GLR conflicts, return -1 */
+  if (conflict_tos[i] != NULL)
+    {
+      int j;
+      for (j = 0; j < t; j += 1)
+       if (conflict_tos[i][j] != 0)
+         return -1;
+    }
+
   for (prev = vector - 1; prev >= 0; prev--)
     {
       vector_number_t j = order[prev];
@@ -622,7 +633,8 @@ matching_state (vector_number_t vector)
        return -1;
 
       for (k = 0; match && k < t; k++)
-       if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
+       if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k]
+           || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0))
          match = 0;
 
       if (match)
@@ -644,13 +656,17 @@ pack_vector (vector_number_t vector)
   base_t *to = tos[i];
   unsigned int *conflict_to = conflict_tos[i];
 
-  assert (t);
+  if (! t)
+    abort ();
 
-  for (j = lowzero - from[0]; j < (int) table_size; j++)
+  for (j = lowzero - from[0]; ; j++)
     {
       int k;
       int ok = 1;
 
+      if ((int) table_size <= j)
+       abort ();
+
       for (k = 0; ok && k < t; k++)
        {
          loc = j + state_number_as_int (from[k]);
@@ -682,14 +698,11 @@ pack_vector (vector_number_t vector)
          if (loc > high)
            high = loc;
 
-         if (j < BASE_MIN || BASE_MAX < j)
-           fatal ("base_t too small to hold %d\n", j);
+         if (! (BASE_MIN <= j && j <= BASE_MAX))
+           abort ();
          return j;
        }
     }
-#define pack_vector_succeeded 0
-  assert (pack_vector_succeeded);
-  return 0;
 }
 
 
@@ -775,11 +788,12 @@ tables_generate (void)
 {
   int i;
 
-  /* That's a poor way to make sure the sizes are properly corelated,
-     in particular the signedness is not taking into account, but it's
-     not useless.  */
-  assert (sizeof (nvectors) >= sizeof (nstates));
-  assert (sizeof (nvectors) >= sizeof (nvars));
+  /* 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));
 
   nvectors = state_number_as_int (nstates) + nvars;
 
@@ -792,9 +806,9 @@ tables_generate (void)
   token_actions ();
 
   goto_actions ();
-  XFREE (goto_map + ntokens);
-  XFREE (from_state);
-  XFREE (to_state);
+  free (goto_map + ntokens);
+  free (from_state);
+  free (to_state);
 
   order = XCALLOC (vector_number_t, nvectors);
   sort_actions ();
@@ -806,8 +820,8 @@ tables_generate (void)
 
   for (i = 0; i < nvectors; i++)
     {
-      XFREE (froms[i]);
-      XFREE (tos[i]);
+      free (froms[i]);
+      free (tos[i]);
       XFREE (conflict_tos[i]);
     }