X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7ae1c5929e712976f79c9e13388c4ed69baed9b1..e89a22bfab22e4d2ee73be49dcb66b51f8d0e892:/src/reader.c?ds=sidebyside

diff --git a/src/reader.c b/src/reader.c
index 6c7a9eec..529cebe9 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -34,13 +34,11 @@
 #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;
+  int line;
   bucket *ruleprec;
 }
 symbol_list;
@@ -64,6 +62,19 @@ static int lastprec;
 
 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;
+}
+
 
 
 /*===================\
@@ -121,7 +132,7 @@ read_signed_integer (FILE *stream)
 `--------------------------------------------------------------*/
 
 static char *
-get_type_name (int n, symbol_list * rule)
+get_type_name (int n, symbol_list *rule)
 {
   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 |
-| 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
-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);
@@ -310,11 +323,25 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
     }
   else if (isdigit (c) || c == '-')
     {
-      int n;
+      int n, i;
 
       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;
     }
@@ -539,7 +566,8 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
       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 ('%');
 	}
     }
@@ -695,7 +723,6 @@ token_buffer);
 	}
 
       prev = t;
-
     }
 }
 
@@ -712,6 +739,13 @@ parse_union_decl (void)
 {
   int c;
   int count = 0;
+  const char *prologue = "\
+#ifndef YYSTYPE\n\
+typedef union";
+  const char *epilogue = "\
+ yystype;\n\
+# define YYSTYPE yystype\n\
+#endif\n";
 
   if (typed)
     complain (_("multiple %s declarations"), "%union");
@@ -724,9 +758,9 @@ parse_union_decl (void)
   else
     obstack_1grow (&attrs_obstack, '\n');
 
-  obstack_sgrow (&attrs_obstack, "typedef union");
+  obstack_sgrow (&attrs_obstack, prologue);
   if (defines_flag)
-    obstack_sgrow (&defines_obstack, "typedef union");
+    obstack_sgrow (&defines_obstack, prologue);
 
   c = getc (finput);
 
@@ -761,9 +795,9 @@ parse_union_decl (void)
 	  count--;
 	  if (count <= 0)
 	    {
-	      obstack_sgrow (&attrs_obstack, " YYSTYPE;\n");
+	      obstack_sgrow (&attrs_obstack, epilogue);
 	      if (defines_flag)
-		obstack_sgrow (&defines_obstack, " YYSTYPE;\n");
+		obstack_sgrow (&defines_obstack, epilogue);
 	      /* JF don't choke on trailing semi */
 	      c = skip_white_space ();
 	      if (c != ';')
@@ -821,7 +855,7 @@ parse_thong_decl (void)
   token_t token;
   struct bucket *symbol;
   char *typename = 0;
-  int usrtoknum = 0;
+  int usrtoknum = SUNDEF;
 
   token = lex ();		/* fetch typename or first token */
   if (token == tok_typename)
@@ -937,16 +971,13 @@ parse_dquoted_param (const char *from)
 static void
 read_declarations (void)
 {
-  int c;
-  int tok;
-
   for (;;)
     {
-      c = skip_white_space ();
+      int c = skip_white_space ();
 
       if (c == '%')
 	{
-	  tok = parse_percent_token ();
+	  token_t tok = parse_percent_token ();
 
 	  switch (tok)
 	    {
@@ -1000,6 +1031,13 @@ read_declarations (void)
 	    case tok_noop:
 	      break;
 
+	    case tok_stropt:
+	    case tok_intopt:
+	    case tok_obsolete:
+	      abort ();
+	      break;
+
+	    case tok_illegal:
 	    default:
 	      complain (_("unrecognized: %s"), token_buffer);
 	      skip_to_char ('%');
@@ -1081,7 +1119,7 @@ copy_action (symbol_list *rule, int stack_offset)
 
 	    case '@':
 	      copy_at (finput, &action_obstack,
-		       stack_offset);
+		       rule, stack_offset);
 	      break;
 
 	    case EOF:
@@ -1103,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;}");
 }
 
 /*-------------------------------------------------------------------.
@@ -1175,7 +1219,7 @@ copy_guard (symbol_list *rule, int stack_offset)
 	  break;
 
 	case '@':
-	  copy_at (finput, &guard_obstack, stack_offset);
+	  copy_at (finput, &guard_obstack, rule, stack_offset);
 	  break;
 
 	case EOF:
@@ -1205,20 +1249,6 @@ copy_guard (symbol_list *rule, int stack_offset)
 }
 
 
-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.                                             |
@@ -1361,10 +1391,7 @@ readgram (void)
 	  nrules++;
 	  nitems++;
 
-	  record_rule_line ();
-
-	  p = XCALLOC (symbol_list, 1);
-	  p->sym = lhs;
+	  p = symbol_list_new (lhs);
 
 	  crule1 = p1;
 	  if (p1)
@@ -1426,36 +1453,35 @@ readgram (void)
 	         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.  */
-		  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++;
-		  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;
-		  p->sym = sdummy;
-		  crule1 = XCALLOC (symbol_list, 1);
-		  p->next = crule1;
+		  /* End of the rule. */
+		  crule1 = symbol_list_new (NULL);
 		  crule1->next = crule;
 
+		  p->next = crule1;
+
 		  /* 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;
 
@@ -1465,8 +1491,7 @@ readgram (void)
 	      if (t == tok_identifier)
 		{
 		  nitems++;
-		  p = XCALLOC (symbol_list, 1);
-		  p->sym = symval;
+		  p = symbol_list_new (symval);
 		  p1->next = p;
 		  p1 = p;
 		}
@@ -1480,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  */
-	  p = XCALLOC (symbol_list, 1);
+	  p = symbol_list_new (NULL);
 	  p1->next = p;
 	  p1 = p;
 
@@ -1662,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.                                                           |
@@ -1689,6 +1757,9 @@ token_translations_init (void)
       /* A token string alias? */
       if (bp->user_token_number == SALIAS)
 	continue;
+
+      assert (bp->user_token_number != SUNDEF);
+
       /* A token which translation has already been set? */
       if (token_translations[bp->user_token_number] != 2)
 	complain (_("tokens %s and %s both assigned number %d"),
@@ -1775,7 +1846,7 @@ packsymbols (void)
 
       if (bp->class == token_sym)
 	{
-	  if (bp->user_token_number == 0)
+	  if (bp->user_token_number == SUNDEF)
 	    bp->user_token_number = ++last_user_token_number;
 	  if (bp->user_token_number > max_user_token_number)
 	    max_user_token_number = bp->user_token_number;
@@ -1800,40 +1871,6 @@ packsymbols (void)
     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
-	}
-    }
 }
 
 
@@ -1849,14 +1886,8 @@ packgram (void)
   int ruleno;
   symbol_list *p;
 
-  bucket *ruleprec;
-
   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;
@@ -1864,9 +1895,11 @@ packgram (void)
   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)
@@ -1876,8 +1909,8 @@ packgram (void)
 	     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;
@@ -1887,9 +1920,9 @@ packgram (void)
          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;
@@ -1900,6 +1933,9 @@ packgram (void)
     }
 
   ritem[itemno] = 0;
+
+  if (trace_flag)
+    ritem_print (stderr);
 }
 
 /*-------------------------------------------------------------------.
@@ -1920,8 +1956,6 @@ reader (void)
   nvars = 0;
   nrules = 0;
   nitems = 0;
-  rline_allocated = 10;
-  rline = XCALLOC (short, rline_allocated);
 
   typed = 0;
   lastprec = 0;
@@ -1949,7 +1983,6 @@ reader (void)
   /* Read the declaration section.  Copy %{ ... %} groups to
      TABLE_OBSTACK and FDEFINES file.  Also notice any %token, %left,
      etc. found there.  */
-  obstack_1grow (&table_obstack, '\n');
   obstack_fgrow3 (&table_obstack, "\
 /* %s, made from %s\n\
    by GNU bison %s.  */\n\
@@ -1978,6 +2011,8 @@ reader (void)
   packsymbols ();
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
+  /* Output the headers. */
+  symbols_output ();
 }