* src/output.c (table_size, table_grow): New.

(MAXTABLE): Remove, replace uses with table_size.
(pack_vector): Instead of dying when the table is too big, grow it.

diff --git a/ChangeLog b/ChangeLog
index 9fd58758d54a5cd0d51da9246a855143e4538d74..7295212955e26e34ec1305af66cbfcbb508693db 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2002-04-22  Akim Demaille  <akim@epita.fr>
+
+       * src/output.c (table_size, table_grow): New.
+       (MAXTABLE): Remove, replace uses with table_size.
+       (pack_vector): Instead of dying when the table is too big, grow it.
+

 2002-04-22  Akim Demaille  <akim@epita.fr>
 
        * data/bison.simple (yyr1): Its type is that of a token number.
 2002-04-22  Akim Demaille  <akim@epita.fr>
 
        * data/bison.simple (yyr1): Its type is that of a token number.

diff --git a/NEWS b/NEWS
index 23d628ea525f5d5aa21ac953d186ed9b8c9af297..e02a9797407164ab69362c1e5a83c4fb2a04ae5c 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -19,7 +19,7 @@ Changes in version 1.49a:
 
 * Large grammars
   Are now supported (large token numbers, large grammar size (= sum of
 
 * Large grammars
   Are now supported (large token numbers, large grammar size (= sum of

-  the LHS and RHS lengths).
+  the LHS and RHS lengths), large LALR tables).

 
 * The initial rule is explicit.
   Bison used to play hacks with the initial rule, which the user does
 
 * The initial rule is explicit.
   Bison used to play hacks with the initial rule, which the user does

diff --git a/src/output.c b/src/output.c
index ef7e6716de7154569995e56dac849b794b6bfd7a..f8cb5350eff96bb1fbf1c178f39c76528a2de410 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -122,6 +122,11 @@ static short *state_count = NULL;
 static short *order = NULL;
 static short *base = NULL;
 static short *pos = NULL;
 static short *order = NULL;
 static short *base = NULL;
 static short *pos = NULL;

+
+/* TABLE_SIZE is the allocated size of both TABLE and CHECK.
+   We start with the original hard-coded value: SHRT_MAX
+   (yes, not USHRT_MAX). */
+static size_t table_size = SHRT_MAX;

 static short *table = NULL;
 static short *check = NULL;
 static int lowzero;
 static short *table = NULL;
 static short *check = NULL;
 static int lowzero;


@@ -133,6 +138,35 @@ static struct obstack format_obstack;
 int error_verbose = 0;
 
 
 int error_verbose = 0;
 
 

+/*----------------------------------------------------------------.
+| If TABLE (and CHECK) appear to be small to be addressed at      |
+| DESIRED, grow them.  Note that TABLE[DESIRED] is to be used, so |
+| the desired size is at least DESIRED + 1.                       |
+`----------------------------------------------------------------*/
+
+static void
+table_grow (size_t desired)
+{
+  size_t old_size = table_size;
+
+  while (table_size <= desired)
+    table_size *= 2;
+
+  if (trace_flag)
+    fprintf (stderr, "growing table and check from: %d to %d\n",
+            old_size, table_size);
+
+  table = XREALLOC (table, short, table_size);
+  check = XREALLOC (check, short, table_size);
+
+  for (/* Nothing. */; old_size < table_size; ++old_size)
+    {
+      table[old_size] = 0;
+      check[old_size] = -1;
+    }
+}
+
+

 /*------------------------------------------------------------------.
 | Create a function NAME which Format the FIRST and then            |
 | TABLE_DATA[BEGIN..END[ (of TYPE) into OOUT, and return the number |
 /*------------------------------------------------------------------.
 | Create a function NAME which Format the FIRST and then            |
 | TABLE_DATA[BEGIN..END[ (of TYPE) into OOUT, and return the number |


@@ -768,8 +802,6 @@ matching_state (int vector)
   return -1;
 }
 
   return -1;
 }
 

-/* FIXME: For the time being, best approximation... */
-#define MAXTABLE SHRT_MAX

 
 static int
 pack_vector (int vector)
 
 static int
 pack_vector (int vector)


@@ -783,7 +815,7 @@ pack_vector (int vector)
 
   assert (t);
 
 
   assert (t);
 

-  for (j = lowzero - from[0]; j < MAXTABLE; j++)
+  for (j = lowzero - from[0]; j < (int) table_size; j++)

     {
       int k;
       int ok = 1;
     {
       int k;
       int ok = 1;


@@ -791,8 +823,8 @@ pack_vector (int vector)
       for (k = 0; ok && k < t; k++)
        {
          loc = j + from[k];
       for (k = 0; ok && k < t; k++)
        {
          loc = j + from[k];

-         if (loc > MAXTABLE)
-           fatal (_("maximum table size (%d) exceeded"), MAXTABLE);
+         if (loc > (int) table_size)
+           table_grow (loc);

 
          if (table[loc] != 0)
            ok = 0;
 
          if (table[loc] != 0)
            ok = 0;


@@ -835,8 +867,8 @@ pack_table (void)
 
   base = XCALLOC (short, nvectors);
   pos = XCALLOC (short, nentries);
 
   base = XCALLOC (short, nvectors);
   pos = XCALLOC (short, nentries);

-  table = XCALLOC (short, MAXTABLE);
-  check = XCALLOC (short, MAXTABLE);
+  table = XCALLOC (short, table_size);
+  check = XCALLOC (short, table_size);

 
   lowzero = 0;
   high = 0;
 
   lowzero = 0;
   high = 0;


@@ -844,7 +876,7 @@ pack_table (void)
   for (i = 0; i < nvectors; i++)
     base[i] = SHRT_MIN;
 
   for (i = 0; i < nvectors; i++)
     base[i] = SHRT_MIN;
 

-  for (i = 0; i < MAXTABLE; i++)
+  for (i = 0; i < (int) table_size; i++)

     check[i] = -1;
 
   for (i = 0; i < nentries; i++)
     check[i] = -1;
 
   for (i = 0; i < nentries; i++)