* tests/regression.at, tests/torture.at, tests/calc.at: Adjust to

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index 5cfa424bc7f871949e0d54c1b1b9a31d77d04886..529cebe99efa8849280a59473610b1d824fbe523 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -34,13 +34,11 @@
 #include "reader.h"
 #include "conflicts.h"
 
 #include "reader.h"
 #include "conflicts.h"
 

-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-static int rline_allocated;
-

 typedef struct symbol_list
 {
   struct symbol_list *next;
   bucket *sym;
 typedef struct symbol_list
 {
   struct symbol_list *next;
   bucket *sym;

+  int line;

   bucket *ruleprec;
 }
 symbol_list;
   bucket *ruleprec;
 }
 symbol_list;


@@ -64,6 +62,19 @@ static int lastprec;
 
 static bucket *errtoken;
 static bucket *undeftoken;
 
 static bucket *errtoken;
 static bucket *undeftoken;

+
+
+static symbol_list *
+symbol_list_new (bucket *sym)
+{
+  symbol_list *res = XMALLOC (symbol_list, 1);
+  res->next = NULL;
+  res->sym = sym;
+  res->line = lineno;
+  res->ruleprec = NULL;
+  return res;
+}
+

 \f
 
 /*===================\
 \f
 
 /*===================\


@@ -121,7 +132,7 @@ read_signed_integer (FILE *stream)
 `--------------------------------------------------------------*/
 
 static char *
 `--------------------------------------------------------------*/
 
 static char *

-get_type_name (int n, symbol_list * rule)
+get_type_name (int n, symbol_list *rule)

 {
   int i;
   symbol_list *rp;
 {
   int i;
   symbol_list *rp;


@@ -293,13 +304,15 @@ copy_comment (FILE *fin, struct obstack *oout)
 /*-----------------------------------------------------------------.
 | FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |
 | reference to this location. STACK_OFFSET is the number of values |
 /*-----------------------------------------------------------------.
 | FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |
 | reference to this location. STACK_OFFSET is the number of values |

-| in the current rule so far, which says where to find `$0' with   |
+| in the current rule so far, which says where to find `@0' with   |

 | respect to the top of the stack.                                 |
 `-----------------------------------------------------------------*/
 
 static inline void
 | respect to the top of the stack.                                 |
 `-----------------------------------------------------------------*/
 
 static inline void

-copy_at (FILE *fin, struct obstack *oout, int stack_offset)
+copy_at (FILE *fin, struct obstack *oout,
+        struct symbol_list *rule, int stack_offset)

 {
 {

+  symbol_list *rp;

   int c;
 
   c = getc (fin);
   int c;
 
   c = getc (fin);


@@ -310,11 +323,25 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
     }
   else if (isdigit (c) || c == '-')
     {
     }
   else if (isdigit (c) || c == '-')
     {

-      int n;
+      int n, i;

 
       ungetc (c, fin);
       n = read_signed_integer (fin);
 
 
       ungetc (c, fin);
       n = read_signed_integer (fin);
 

+      rp = rule;
+      i = 0;
+
+      while (i < n)
+       {
+         rp = rp->next;
+         if (rp == NULL)
+           {
+             complain (_("invalid @ value"));
+             return;
+           }
+         i++;
+       }
+

       obstack_fgrow1 (oout, "yylsp[%d]", n - stack_offset);
       locations_flag = 1;
     }
       obstack_fgrow1 (oout, "yylsp[%d]", n - stack_offset);
       locations_flag = 1;
     }


@@ -539,7 +566,8 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
       else
        {
          complain (_("`%s' is invalid in %s"),
       else
        {
          complain (_("`%s' is invalid in %s"),

-                   token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
+                   token_buffer,
+                   (what_is == token_sym) ? "%token" : "%nterm");

          skip_to_char ('%');
        }
     }
          skip_to_char ('%');
        }
     }


@@ -1006,10 +1034,10 @@ read_declarations (void)
            case tok_stropt:
            case tok_intopt:
            case tok_obsolete:
            case tok_stropt:
            case tok_intopt:
            case tok_obsolete:

-           case tok_illegal:

              abort ();
              break;
 
              abort ();
              break;
 

+           case tok_illegal:

            default:
              complain (_("unrecognized: %s"), token_buffer);
              skip_to_char ('%');
            default:
              complain (_("unrecognized: %s"), token_buffer);
              skip_to_char ('%');


@@ -1091,7 +1119,7 @@ copy_action (symbol_list *rule, int stack_offset)
 
            case '@':
              copy_at (finput, &action_obstack,
 
            case '@':
              copy_at (finput, &action_obstack,

-                      stack_offset);
+                      rule, stack_offset);

              break;
 
            case EOF:
              break;
 
            case EOF:


@@ -1113,7 +1141,13 @@ copy_action (symbol_list *rule, int stack_offset)
        }
     }
 
        }
     }
 

-  obstack_sgrow (&action_obstack, ";\n    break;}");
+  /* As a Bison extension, add the ending semicolon.  Since some Yacc
+     don't do that, help people using bison as a Yacc finding their
+     missing semicolons.  */
+  if (yacc_flag)
+    obstack_sgrow (&action_obstack, "}\n    break;");
+  else
+    obstack_sgrow (&action_obstack, ";\n    break;}");

 }
 \f
 /*-------------------------------------------------------------------.
 }
 \f
 /*-------------------------------------------------------------------.


@@ -1185,7 +1219,7 @@ copy_guard (symbol_list *rule, int stack_offset)
          break;
 
        case '@':
          break;
 
        case '@':

-         copy_at (finput, &guard_obstack, stack_offset);
+         copy_at (finput, &guard_obstack, rule, stack_offset);

          break;
 
        case EOF:
          break;
 
        case EOF:


@@ -1215,20 +1249,6 @@ copy_guard (symbol_list *rule, int stack_offset)
 }
 \f
 
 }
 \f
 

-static void
-record_rule_line (void)
-{
-  /* Record each rule's source line number in rline table.  */
-
-  if (nrules >= rline_allocated)
-    {
-      rline_allocated = nrules * 2;
-      rline = XREALLOC (rline, short, rline_allocated);
-    }
-  rline[nrules] = lineno;
-}
-
-

 /*-------------------------------------------------------------------.
 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
 | with the user's names.                                             |
 /*-------------------------------------------------------------------.
 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
 | with the user's names.                                             |


@@ -1371,10 +1391,7 @@ readgram (void)
          nrules++;
          nitems++;
 
          nrules++;
          nitems++;
 

-         record_rule_line ();
-
-         p = XCALLOC (symbol_list, 1);
-         p->sym = lhs;
+         p = symbol_list_new (lhs);

 
          crule1 = p1;
          if (p1)
 
          crule1 = p1;
          if (p1)


@@ -1436,36 +1453,35 @@ readgram (void)
                 non-terminal.  */
              if (action_flag)
                {
                 non-terminal.  */
              if (action_flag)
                {

-                 bucket *sdummy;
-

                  /* Since the action was written out with this rule's
                     number, we must give the new rule this number by
                     inserting the new rule before it.  */
 
                  /* Make a dummy nonterminal, a gensym.  */
                  /* Since the action was written out with this rule's
                     number, we must give the new rule this number by
                     inserting the new rule before it.  */
 
                  /* Make a dummy nonterminal, a gensym.  */

-                 sdummy = gensym ();
+                 bucket *sdummy = gensym ();

 
 

-                 /* Make a new rule, whose body is empty,
-                    before the current one, so that the action
-                    just read can belong to it.  */
+                 /* Make a new rule, whose body is empty, before the
+                    current one, so that the action just read can
+                    belong to it.  */

                  nrules++;
                  nitems++;
                  nrules++;
                  nitems++;

-                 record_rule_line ();
-                 p = XCALLOC (symbol_list, 1);
+                 p = symbol_list_new (sdummy);
+                 /* Attach its lineno to that of the host rule. */
+                 p->line = crule->line;

                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;
                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;

-                 p->sym = sdummy;
-                 crule1 = XCALLOC (symbol_list, 1);
-                 p->next = crule1;
+                 /* End of the rule. */
+                 crule1 = symbol_list_new (NULL);

                  crule1->next = crule;
 
                  crule1->next = crule;
 

+                 p->next = crule1;
+

                  /* Insert the dummy generated by that rule into this
                     rule.  */
                  nitems++;
                  /* Insert the dummy generated by that rule into this
                     rule.  */
                  nitems++;

-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = sdummy;
+                 p = symbol_list_new (sdummy);

                  p1->next = p;
                  p1 = p;
 
                  p1->next = p;
                  p1 = p;
 


@@ -1475,8 +1491,7 @@ readgram (void)
              if (t == tok_identifier)
                {
                  nitems++;
              if (t == tok_identifier)
                {
                  nitems++;

-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = symval;
+                 p = symbol_list_new (symval);

                  p1->next = p;
                  p1 = p;
                }
                  p1->next = p;
                  p1 = p;
                }


@@ -1490,7 +1505,7 @@ readgram (void)
            }                   /* end of  read rhs of rule */
 
          /* Put an empty link in the list to mark the end of this rule  */
            }                   /* end of  read rhs of rule */
 
          /* Put an empty link in the list to mark the end of this rule  */

-         p = XCALLOC (symbol_list, 1);
+         p = symbol_list_new (NULL);

          p1->next = p;
          p1 = p;
 
          p1->next = p;
          p1 = p;
 


@@ -1672,6 +1687,49 @@ output_token_defines (struct obstack *oout)
 }
 
 
 }
 
 

+/*--------------------.
+| Output the header.  |
+`--------------------*/
+
+static void
+symbols_output (void)
+{
+  if (defines_flag)
+    {
+      output_token_defines (&defines_obstack);
+
+      if (!pure_parser)
+       {
+         if (spec_name_prefix)
+           obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
+                           spec_name_prefix);
+         else
+           obstack_sgrow (&defines_obstack,
+                                "\nextern YYSTYPE yylval;\n");
+       }
+
+      if (semantic_parser)
+       {
+         int i;
+
+         for (i = ntokens; i < nsyms; i++)
+           {
+             /* don't make these for dummy nonterminals made by gensym.  */
+             if (*tags[i] != '@')
+               obstack_fgrow2 (&defines_obstack,
+                               "# define\tNT%s\t%d\n", tags[i], i);
+           }
+#if 0
+         /* `fdefines' is now a temporary file, so we need to copy its
+            contents in `done', so we can't close it here.  */
+         fclose (fdefines);
+         fdefines = NULL;
+#endif
+       }
+    }
+}
+
+

 /*------------------------------------------------------------------.
 | Set TOKEN_TRANSLATIONS.  Check that no two symbols share the same |
 | number.                                                           |
 /*------------------------------------------------------------------.
 | Set TOKEN_TRANSLATIONS.  Check that no two symbols share the same |
 | number.                                                           |


@@ -1813,40 +1871,6 @@ packsymbols (void)
     fatal (_("the start symbol %s is a token"), startval->tag);
 
   start_symbol = startval->value;
     fatal (_("the start symbol %s is a token"), startval->tag);
 
   start_symbol = startval->value;

-
-  if (defines_flag)
-    {
-      output_token_defines (&defines_obstack);
-
-      if (!pure_parser)
-       {
-         if (spec_name_prefix)
-           obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
-                           spec_name_prefix);
-         else
-           obstack_sgrow (&defines_obstack,
-                                "\nextern YYSTYPE yylval;\n");
-       }
-
-      if (semantic_parser)
-       {
-         int i;
-
-         for (i = ntokens; i < nsyms; i++)
-           {
-             /* don't make these for dummy nonterminals made by gensym.  */
-             if (*tags[i] != '@')
-               obstack_fgrow2 (&defines_obstack,
-                               "# define\tNT%s\t%d\n", tags[i], i);
-           }
-#if 0
-         /* `fdefines' is now a temporary file, so we need to copy its
-            contents in `done', so we can't close it here.  */
-         fclose (fdefines);
-         fdefines = NULL;
-#endif
-       }
-    }

 }
 
 
 }
 
 


@@ -1862,14 +1886,8 @@ packgram (void)
   int ruleno;
   symbol_list *p;
 
   int ruleno;
   symbol_list *p;
 

-  bucket *ruleprec;
-

   ritem = XCALLOC (short, nitems + 1);
   ritem = XCALLOC (short, nitems + 1);

-  rlhs = XCALLOC (short, nrules) - 1;
-  rrhs = XCALLOC (short, nrules) - 1;
-  rprec = XCALLOC (short, nrules) - 1;
-  rprecsym = XCALLOC (short, nrules) - 1;
-  rassoc = XCALLOC (short, nrules) - 1;
+  rule_table = XCALLOC (rule_t, nrules) - 1;

 
   itemno = 0;
   ruleno = 1;
 
   itemno = 0;
   ruleno = 1;


@@ -1877,9 +1895,11 @@ packgram (void)
   p = grammar;
   while (p)
     {
   p = grammar;
   while (p)
     {

-      rlhs[ruleno] = p->sym->value;
-      rrhs[ruleno] = itemno;
-      ruleprec = p->ruleprec;
+      bucket *ruleprec = p->ruleprec;
+      rule_table[ruleno].lhs = p->sym->value;
+      rule_table[ruleno].rhs = itemno;
+      rule_table[ruleno].line = p->line;
+      rule_table[ruleno].useful = TRUE;

 
       p = p->next;
       while (p && p->sym)
 
       p = p->next;
       while (p && p->sym)


@@ -1889,8 +1909,8 @@ packgram (void)
             of the last token in it.  */
          if (p->sym->class == token_sym)
            {
             of the last token in it.  */
          if (p->sym->class == token_sym)
            {

-             rprec[ruleno] = p->sym->prec;
-             rassoc[ruleno] = p->sym->assoc;
+             rule_table[ruleno].prec = p->sym->prec;
+             rule_table[ruleno].assoc = p->sym->assoc;

            }
          if (p)
            p = p->next;
            }
          if (p)
            p = p->next;


@@ -1900,9 +1920,9 @@ packgram (void)
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {

-         rprec[ruleno] = ruleprec->prec;
-         rassoc[ruleno] = ruleprec->assoc;
-         rprecsym[ruleno] = ruleprec->value;
+         rule_table[ruleno].prec = ruleprec->prec;
+         rule_table[ruleno].assoc = ruleprec->assoc;
+         rule_table[ruleno].precsym = ruleprec->value;

        }
 
       ritem[itemno++] = -ruleno;
        }
 
       ritem[itemno++] = -ruleno;


@@ -1913,6 +1933,9 @@ packgram (void)
     }
 
   ritem[itemno] = 0;
     }
 
   ritem[itemno] = 0;

+
+  if (trace_flag)
+    ritem_print (stderr);

 }
 \f
 /*-------------------------------------------------------------------.
 }
 \f
 /*-------------------------------------------------------------------.


@@ -1933,8 +1956,6 @@ reader (void)
   nvars = 0;
   nrules = 0;
   nitems = 0;
   nvars = 0;
   nrules = 0;
   nitems = 0;

-  rline_allocated = 10;
-  rline = XCALLOC (short, rline_allocated);

 
   typed = 0;
   lastprec = 0;
 
   typed = 0;
   lastprec = 0;


@@ -1990,6 +2011,8 @@ reader (void)
   packsymbols ();
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
   packsymbols ();
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();

+  /* Output the headers. */
+  symbols_output ();

 }
 
 
 }