* src/parse-gram.y (rules_or_grammar_declaration): Add an error

[bison.git] / src / gram.c

diff --git a/src/gram.c b/src/gram.c
index 6368051c686e01259ddbe4a80d7799a44fe8514e..51aa94844dbd39dcb3a7c56510bc7416b2df8090 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -1,5 +1,5 @@
 /* Allocate input grammar variables for bison,
 /* Allocate input grammar variables for bison,

-   Copyright 1984, 1986, 1989, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 2001, 2002 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -20,37 +20,103 @@
 
 
 #include "system.h"
 
 
 #include "system.h"

+#include "quotearg.h"
+#include "symtab.h"

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

+#include "reduce.h"

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

-/* comments for these variables are in gram.h  */
+/* Comments for these variables are in gram.h.  */

 
 

-int nitems;
-int nrules;
-int nsyms;
-int ntokens;
-int nvars;
+item_number_t *ritem = NULL;
+unsigned int nritems = 0;

 
 

-short *ritem = NULL;
-int nritems;
+rule_t *rules = NULL;
+rule_number_t nrules = 0;

 
 

-rule_t *rule_table = NULL;
-short *rprec = NULL;
-short *rprecsym = NULL;
-short *sprec = NULL;
-short *rassoc = NULL;
-short *sassoc = NULL;
-short *token_translations = NULL;
+symbol_t **symbols = NULL;
+int nsyms = 0;
+int ntokens = 1;
+int nvars = 0;

 
 

-int start_symbol;
+symbol_number_t *token_translations = NULL;

 
 

-int max_user_token_number;
+int max_user_token_number = 256;

 
 

-int semantic_parser;
+int glr_parser = 0;
+int pure_parser = 0;

 
 

-int pure_parser;

 
 

-int error_token_number;
+/*----------------------------------------------------------------.
+| Print this RULE's number and lhs on OUT.  If a PREVIOUS_LHS was |
+| already displayed (by a previous call for another rule), avoid  |
+| useless repetitions.                                            |
+`----------------------------------------------------------------*/
+
+void
+rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
+{
+  fprintf (out, "  %3d ", rule->number - 1);
+  if (previous_lhs != rule->lhs)
+    {
+      fprintf (out, "%s:", rule->lhs->tag);
+    }
+  else
+    {
+      int n;
+      for (n = strlen (previous_lhs->tag); n > 0; --n)
+       fputc (' ', out);
+      fputc ('|', out);
+    }
+}
+
+
+/*--------------------------------------.
+| Return the number of symbols in RHS.  |
+`--------------------------------------*/
+
+int
+rule_rhs_length (rule_t *rule)
+{
+  int res = 0;
+  item_number_t *rhsp;
+  for (rhsp = rule->rhs; *rhsp >= 0; ++rhsp)
+    ++res;
+  return res;
+}
+
+
+/*-------------------------------.
+| Print this RULE's RHS on OUT.  |
+`-------------------------------*/
+
+void
+rule_rhs_print (rule_t *rule, FILE *out)
+{
+  if (*rule->rhs >= 0)
+    {
+      item_number_t *r;
+      for (r = rule->rhs; *r >= 0; r++)
+       fprintf (out, " %s", symbols[*r]->tag);
+      fputc ('\n', out);
+    }
+  else
+    {
+      fprintf (out, " /* %s */\n", _("empty"));
+    }
+}
+
+
+/*-------------------------.
+| Print this RULE on OUT.  |
+`-------------------------*/
+
+void
+rule_print (rule_t *rule, FILE *out)
+{
+  fprintf (out, "%s:", rule->lhs->tag);
+  rule_rhs_print (rule, out);
+}

 
 
 /*------------------------.
 
 
 /*------------------------.


@@ -60,13 +126,13 @@ int error_token_number;
 void
 ritem_print (FILE *out)
 {
 void
 ritem_print (FILE *out)
 {

-  int i;
+  unsigned int i;

   fputs ("RITEM\n", out);
   for (i = 0; i < nritems; ++i)
     if (ritem[i] >= 0)
   fputs ("RITEM\n", out);
   for (i = 0; i < nritems; ++i)
     if (ritem[i] >= 0)

-      fprintf (out, "  %s", tags[ritem[i]]);
+      fprintf (out, "  %s", symbols[ritem[i]]->tag);

     else
     else

-      fprintf (out, "  (rule %d)\n", -ritem[i]);
+      fprintf (out, "  (rule %d)\n", -ritem[i] - 1);

   fputs ("\n\n", out);
 }
 
   fputs ("\n\n", out);
 }
 


@@ -78,23 +144,131 @@ ritem_print (FILE *out)
 size_t
 ritem_longest_rhs (void)
 {
 size_t
 ritem_longest_rhs (void)
 {

-  int length;
-  int max;
-  int i;
+  int max = 0;
+  rule_number_t r;

 
 

-  length = 0;
-  max = 0;
-  for (i = 0; i < nritems; ++i)
-    if (ritem[i] >= 0)
+  for (r = 1; r < nrules + 1; ++r)
+    {
+      int length = rule_rhs_length (&rules[r]);
+      if (length > max)
+       max = length;
+    }
+
+  return max;
+}
+
+
+/*----------------------------------------------------------------.
+| Print the grammar's rules numbers from BEGIN (inclusive) to END |
+| (exclusive) on OUT under TITLE.                                 |
+`----------------------------------------------------------------*/
+
+void
+grammar_rules_partial_print (FILE *out, const char *title,
+                            rule_number_t begin, rule_number_t end)
+{
+  int r;
+  symbol_t *previous_lhs = NULL;
+
+  /* rule # : LHS -> RHS */
+  fprintf (out, "%s\n\n", title);
+  for (r = begin; r < end; r++)
+    {
+      if (previous_lhs && previous_lhs != rules[r].lhs)
+       fputc ('\n', out);
+      rule_lhs_print (&rules[r], previous_lhs, out);
+      rule_rhs_print (&rules[r], out);
+      previous_lhs = rules[r].lhs;
+    }
+  fputs ("\n\n", out);
+}
+
+
+/*------------------------------------------.
+| Print the grammar's useful rules on OUT.  |
+`------------------------------------------*/
+
+void
+grammar_rules_print (FILE *out)
+{
+  grammar_rules_partial_print (out, _("Grammar"), 1, nrules + 1);
+}
+
+
+/*-------------------.
+| Dump the grammar.  |
+`-------------------*/
+
+void
+grammar_dump (FILE *out, const char *title)
+{
+  fprintf (out, "%s\n\n", title);
+  fprintf (out,
+          "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
+          ntokens, nvars, nsyms, nrules, nritems);
+
+
+  fprintf (out, "Variables\n---------\n\n");
+  {
+    symbol_number_t i;
+    fprintf (out, "Value  Sprec  Sassoc  Tag\n");
+
+    for (i = ntokens; i < nsyms; i++)
+      fprintf (out, "%5d  %5d   %5d  %s\n",
+              i,
+              symbols[i]->prec, symbols[i]->assoc,
+              symbols[i]->tag);
+    fprintf (out, "\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");
+    for (i = 1; i < nrules + nuseless_productions + 1; i++)

       {
       {

-       length++;
+       rule_t *rule = &rules[i];
+       item_number_t *r = NULL;
+       int rhs_count = 0;
+       /* Find the last RHS index in ritems. */
+       for (r = rule->rhs; *r >= 0; ++r)
+         ++rhs_count;
+       fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
+                i - 1,
+                rule->prec ? rule->prec->prec : 0,
+                rule->prec ? rule->prec->assoc : 0,
+                rule->useful,
+                rule->rhs - ritem,
+                rule->rhs - ritem + rhs_count - 1,
+                rule->lhs->number);
+       /* Dumped the RHS. */
+       for (r = rule->rhs; *r >= 0; r++)
+         fprintf (out, " %3d", *r);
+       fprintf (out, "  [%d]\n", -(*r) - 1);

       }
       }

-    else
+  }
+  fprintf (out, "\n\n");
+
+  fprintf (out, "Rules interpreted\n-----------------\n\n");
+  {
+    rule_number_t r;
+    for (r = 1; r < nrules + nuseless_productions + 1; r++)

       {
       {

-       if (length > max)
-         max = length;
-       length = 0;
+       fprintf (out, "%-5d  ", r);
+       rule_print (&rules[r], out);

       }
       }

+  }
+  fprintf (out, "\n\n");
+}

 
 

-  return max;
+
+void
+grammar_free (void)
+{
+  XFREE (ritem);
+  free (rules + 1);
+  XFREE (token_translations);
+  /* Free the symbol table data structure.  */
+  symbols_free ();
+  free_merger_functions ();

 }
 }