Do not let the scan-skel token buffer grow unboundedly in the usual case.

[bison.git] / src / gram.c

diff --git a/src/gram.c b/src/gram.c
index 57e900a19862ae46bda013e29c9f1840bc8c4280..cf5a946db983e698269f6f2fa1aaa1800ecbc3ad 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -1,4 +1,5 @@
-/* Allocate input grammar variables for bison,
+/* Allocate input grammar variables for Bison.
+

    Copyright (C) 1984, 1986, 1989, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Copyright (C) 1984, 1986, 1989, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -20,26 +21,28 @@
 
 
 #include "system.h"
 
 
 #include "system.h"

-#include "quotearg.h"
-#include "symtab.h"
+
+#include <quotearg.h>
+

 #include "gram.h"
 #include "gram.h"

-#include "reduce.h"

 #include "reader.h"
 #include "reader.h"

+#include "reduce.h"
+#include "symtab.h"

 
 /* Comments for these variables are in gram.h.  */
 
 
 /* Comments for these variables are in gram.h.  */
 

-item_number_t *ritem = NULL;
+item_number *ritem = NULL;

 unsigned int nritems = 0;
 
 unsigned int nritems = 0;
 

-rule_t *rules = NULL;
-rule_number_t nrules = 0;
+rule *rules = NULL;
+rule_number nrules = 0;

 
 

-symbol_t **symbols = NULL;
+symbol **symbols = NULL;

 int nsyms = 0;
 int ntokens = 1;
 int nvars = 0;
 
 int nsyms = 0;
 int ntokens = 1;
 int nvars = 0;
 

-symbol_number_t *token_translations = NULL;
+symbol_number *token_translations = NULL;

 
 int max_user_token_number = 256;
 
 
 int max_user_token_number = 256;
 


@@ -52,7 +55,7 @@ int pure_parser = 0;
 `--------------------------------------------------------------*/
 
 bool
 `--------------------------------------------------------------*/
 
 bool

-rule_useful_p (rule_t *r)
+rule_useful_p (rule *r)

 {
   return r->number < nrules;
 }
 {
   return r->number < nrules;
 }


@@ -63,7 +66,7 @@ rule_useful_p (rule_t *r)
 `-------------------------------------------------------------*/
 
 bool
 `-------------------------------------------------------------*/
 
 bool

-rule_useless_p (rule_t *r)
+rule_useless_p (rule *r)

 {
   return r->number >= nrules;
 }
 {
   return r->number >= nrules;
 }


@@ -75,7 +78,7 @@ rule_useless_p (rule_t *r)
 `--------------------------------------------------------------------*/
 
 bool
 `--------------------------------------------------------------------*/
 
 bool

-rule_never_reduced_p (rule_t *r)
+rule_never_reduced_p (rule *r)

 {
   return !r->useful && r->number < nrules;
 }
 {
   return !r->useful && r->number < nrules;
 }


@@ -88,12 +91,12 @@ rule_never_reduced_p (rule_t *r)
 `----------------------------------------------------------------*/
 
 void
 `----------------------------------------------------------------*/
 
 void

-rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
+rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out)

 {
 {

-  fprintf (out, "  %3d ", rule->number);
-  if (previous_lhs != rule->lhs)
+  fprintf (out, "  %3d ", r->number);
+  if (previous_lhs != r->lhs)

     {
     {

-      fprintf (out, "%s:", rule->lhs->tag);
+      fprintf (out, "%s:", r->lhs->tag);

     }
   else
     {
     }
   else
     {


@@ -110,28 +113,28 @@ rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
 `--------------------------------------*/
 
 int
 `--------------------------------------*/
 
 int

-rule_rhs_length (rule_t *rule)
+rule_rhs_length (rule *r)

 {
   int res = 0;
 {
   int res = 0;

-  item_number_t *rhsp;
-  for (rhsp = rule->rhs; *rhsp >= 0; ++rhsp)
+  item_number *rhsp;
+  for (rhsp = r->rhs; *rhsp >= 0; ++rhsp)

     ++res;
   return res;
 }
 
 
 /*-------------------------------.
     ++res;
   return res;
 }
 
 
 /*-------------------------------.

-| Print this RULE's RHS on OUT.  |
+| Print this rule's RHS on OUT.  |

 `-------------------------------*/
 
 void
 `-------------------------------*/
 
 void

-rule_rhs_print (rule_t *rule, FILE *out)
+rule_rhs_print (rule *r, FILE *out)

 {
 {

-  if (*rule->rhs >= 0)
+  if (*r->rhs >= 0)

     {
     {

-      item_number_t *r;
-      for (r = rule->rhs; *r >= 0; r++)
-       fprintf (out, " %s", symbols[*r]->tag);
+      item_number *rp;
+      for (rp = r->rhs; *rp >= 0; rp++)
+       fprintf (out, " %s", symbols[*rp]->tag);

       fputc ('\n', out);
     }
   else
       fputc ('\n', out);
     }
   else


@@ -142,14 +145,14 @@ rule_rhs_print (rule_t *rule, FILE *out)
 
 
 /*-------------------------.
 
 
 /*-------------------------.

-| Print this RULE on OUT.  |
+| Print this rule on OUT.  |

 `-------------------------*/
 
 void
 `-------------------------*/
 
 void

-rule_print (rule_t *rule, FILE *out)
+rule_print (rule *r, FILE *out)

 {
 {

-  fprintf (out, "%s:", rule->lhs->tag);
-  rule_rhs_print (rule, out);
+  fprintf (out, "%s:", r->lhs->tag);
+  rule_rhs_print (r, out);

 }
 
 
 }
 
 


@@ -179,7 +182,7 @@ size_t
 ritem_longest_rhs (void)
 {
   int max = 0;
 ritem_longest_rhs (void)
 {
   int max = 0;

-  rule_number_t r;
+  rule_number r;

 
   for (r = 0; r < nrules; ++r)
     {
 
   for (r = 0; r < nrules; ++r)
     {


@@ -198,11 +201,11 @@ ritem_longest_rhs (void)
 
 void
 grammar_rules_partial_print (FILE *out, const char *title,
 
 void
 grammar_rules_partial_print (FILE *out, const char *title,

-                            rule_filter_t filter)
+                            rule_filter filter)

 {
   int r;
 {
   int r;

-  bool first = TRUE;
-  symbol_t *previous_lhs = NULL;
+  bool first = true;
+  symbol *previous_lhs = NULL;

 
   /* rule # : LHS -> RHS */
   for (r = 0; r < nrules + nuseless_productions; r++)
 
   /* rule # : LHS -> RHS */
   for (r = 0; r < nrules + nuseless_productions; r++)


@@ -213,7 +216,7 @@ grammar_rules_partial_print (FILE *out, const char *title,
        fprintf (out, "%s\n\n", title);
       else if (previous_lhs && previous_lhs != rules[r].lhs)
        fputc ('\n', out);
        fprintf (out, "%s\n\n", title);
       else if (previous_lhs && previous_lhs != rules[r].lhs)
        fputc ('\n', out);

-      first = FALSE;
+      first = false;

       rule_lhs_print (&rules[r], previous_lhs, out);
       rule_rhs_print (&rules[r], out);
       previous_lhs = rules[r].lhs;
       rule_lhs_print (&rules[r], previous_lhs, out);
       rule_rhs_print (&rules[r], out);
       previous_lhs = rules[r].lhs;


@@ -247,10 +250,10 @@ grammar_dump (FILE *out, const char *title)
           ntokens, nvars, nsyms, nrules, nritems);
 
 
           ntokens, nvars, nsyms, nrules, nritems);
 
 

-  fprintf (out, _("Variables\n---------\n\n"));
+  fprintf (out, "Variables\n---------\n\n");

   {
   {

-    symbol_number_t i;
-    fprintf (out, _("Value  Sprec  Sassoc  Tag\n"));
+    symbol_number i;
+    fprintf (out, "Value  Sprec  Sassoc  Tag\n");

 
     for (i = ntokens; i < nsyms; i++)
       fprintf (out, "%5d  %5d   %5d  %s\n",
 
     for (i = ntokens; i < nsyms; i++)
       fprintf (out, "%5d  %5d   %5d  %s\n",


@@ -260,38 +263,38 @@ grammar_dump (FILE *out, const char *title)
     fprintf (out, "\n\n");
   }
 
     fprintf (out, "\n\n");
   }
 

-  fprintf (out, _("Rules\n-----\n\n"));
+  fprintf (out, "Rules\n-----\n\n");

   {
   {

-    rule_number_t i;
-    fprintf (out, _("Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"));
+    rule_number i;
+    fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");

     for (i = 0; i < nrules + nuseless_productions; i++)
       {
     for (i = 0; i < nrules + nuseless_productions; i++)
       {

-       rule_t *rule = &rules[i];
-       item_number_t *r = NULL;
-       unsigned int rhs_itemno = rule->rhs - ritem;
+       rule *rule_i = &rules[i];
+       item_number *r = NULL;
+       unsigned int rhs_itemno = rule_i->rhs - ritem;

        unsigned int rhs_count = 0;
        /* Find the last RHS index in ritems. */
        unsigned int rhs_count = 0;
        /* Find the last RHS index in ritems. */

-       for (r = rule->rhs; *r >= 0; ++r)
+       for (r = rule_i->rhs; *r >= 0; ++r)

          ++rhs_count;
        fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u)   %2d ->",
                 i,
          ++rhs_count;
        fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u)   %2d ->",
                 i,

-                rule->prec ? rule->prec->prec : 0,
-                rule->prec ? rule->prec->assoc : 0,
-                rule->useful,
+                rule_i->prec ? rule_i->prec->prec : 0,
+                rule_i->prec ? rule_i->prec->assoc : 0,
+                rule_i->useful,

                 rhs_itemno,
                 rhs_itemno + rhs_count - 1,
                 rhs_itemno,
                 rhs_itemno + rhs_count - 1,

-                rule->lhs->number);
+                rule_i->lhs->number);

        /* Dumped the RHS. */
        /* Dumped the RHS. */

-       for (r = rule->rhs; *r >= 0; r++)
+       for (r = rule_i->rhs; *r >= 0; r++)

          fprintf (out, " %3d", *r);
        fprintf (out, "  [%d]\n", item_number_as_rule_number (*r));
       }
   }
   fprintf (out, "\n\n");
 
          fprintf (out, " %3d", *r);
        fprintf (out, "  [%d]\n", item_number_as_rule_number (*r));
       }
   }
   fprintf (out, "\n\n");
 

-  fprintf (out, _("Rules interpreted\n-----------------\n\n"));
+  fprintf (out, "Rules interpreted\n-----------------\n\n");

   {
   {

-    rule_number_t r;
+    rule_number r;

     for (r = 0; r < nrules + nuseless_productions; r++)
       {
        fprintf (out, "%-5d  ", r);
     for (r = 0; r < nrules + nuseless_productions; r++)
       {
        fprintf (out, "%-5d  ", r);


@@ -312,11 +315,11 @@ grammar_dump (FILE *out, const char *title)
 void
 grammar_rules_never_reduced_report (const char *message)
 {
 void
 grammar_rules_never_reduced_report (const char *message)
 {

-  rule_number_t r;
+  rule_number r;

   for (r = 0; r < nrules ; ++r)
     if (!rules[r].useful)
       {
   for (r = 0; r < nrules ; ++r)
     if (!rules[r].useful)
       {

-       LOCATION_PRINT (stderr, rules[r].location);
+       location_print (stderr, rules[r].location);

        fprintf (stderr, ": %s: %s: ",
                 _("warning"), message);
        rule_print (&rules[r], stderr);
        fprintf (stderr, ": %s: %s: ",
                 _("warning"), message);
        rule_print (&rules[r], stderr);