Fix testsuite for ./configure --enable-gcc-warnings:

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index 5084618ffb4a5ba465db4dce995620e32ea84574..e48afaf037e8cbb0e0d7eb81361c6ccc4e6b5683 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -22,7 +22,6 @@
 
 #include <config.h>
 #include "system.h"
-#include <assert.h>
 
 #include <quotearg.h>
 
@@ -148,7 +147,7 @@ record_merge_function_type (int merger, uniqstr type, location declaration_loc)
        merge_function != NULL && merger_find != merger;
        merge_function = merge_function->next)
     merger_find += 1;
-  assert (merge_function != NULL && merger_find == merger);
+  aver (merge_function != NULL && merger_find == merger);
   if (merge_function->type != NULL && !UNIQSTR_EQ (merge_function->type, type))
     {
       complain_at (declaration_loc,
@@ -196,7 +195,7 @@ static symbol_list *grammar_end = NULL;
 static void
 grammar_symbol_append (symbol *sym, location loc)
 {
-  symbol_list *p = symbol_list_new (sym, loc);
+  symbol_list *p = symbol_list_sym_new (sym, loc);
 
   if (grammar_end)
     grammar_end->next = p;
@@ -225,13 +224,6 @@ static symbol_list *previous_rule_end = NULL;
 void
 grammar_current_rule_begin (symbol *lhs, location loc)
 {
-  if (!start_flag)
-    {
-      startsymbol = lhs;
-      startsymbol_location = loc;
-      start_flag = true;
-    }
-
   /* Start a new rule and record its lhs.  */
   ++nrules;
   previous_rule_end = grammar_end;
@@ -259,7 +251,7 @@ grammar_current_rule_begin (symbol *lhs, location loc)
 static bool
 symbol_should_be_used (symbol_list const *s)
 {
-  return (symbol_destructor_get (s->sym)
+  return (symbol_destructor_get (s->content.sym)
          || (s->midrule && s->midrule->used));
 }
 
@@ -278,13 +270,13 @@ grammar_rule_check (const symbol_list *r)
 
      Don't worry about the default action if $$ is untyped, since $$'s
      value can't be used.  */
-  if (!r->action && r->sym->type_name)
+  if (!r->action && r->content.sym->type_name)
     {
-      symbol *first_rhs = r->next->sym;
+      symbol *first_rhs = r->next->content.sym;
       /* If $$ is being set in default way, report if any type mismatch.  */
       if (first_rhs)
        {
-         char const *lhs_type = r->sym->type_name;
+         char const *lhs_type = r->content.sym->type_name;
          const char *rhs_type =
            first_rhs->type_name ? first_rhs->type_name : "";
          if (!UNIQSTR_EQ (lhs_type, rhs_type))
@@ -302,7 +294,7 @@ grammar_rule_check (const symbol_list *r)
   {
     symbol_list const *l = r;
     int n = 0;
-    for (; l && l->sym; l = l->next, ++n)
+    for (; l && l->content.sym; l = l->next, ++n)
       if (! (l->used
             || !symbol_should_be_used (l)
             /* The default action, $$ = $1, `uses' both.  */
@@ -348,7 +340,7 @@ grammar_midrule_action (void)
      action.  Create the MIDRULE.  */
   location dummy_location = current_rule->action_location;
   symbol *dummy = dummy_symbol_get (dummy_location);
-  symbol_list *midrule = symbol_list_new (dummy, dummy_location);
+  symbol_list *midrule = symbol_list_sym_new (dummy, dummy_location);
 
   /* Make a new rule, whose body is empty, before the current one, so
      that the action just read can belong to it.  */
@@ -369,7 +361,7 @@ grammar_midrule_action (void)
     grammar = midrule;
 
   /* End the dummy's rule.  */
-  midrule->next = symbol_list_new (NULL, dummy_location);
+  midrule->next = symbol_list_sym_new (NULL, dummy_location);
   midrule->next->next = current_rule;
 
   previous_rule_end = midrule->next;
@@ -468,11 +460,11 @@ packgram (void)
     {
       int rule_length = 0;
       symbol *ruleprec = p->ruleprec;
-      record_merge_function_type (p->merger, p->sym->type_name,
+      record_merge_function_type (p->merger, p->content.sym->type_name,
                                  p->merger_declaration_location);
       rules[ruleno].user_number = ruleno;
       rules[ruleno].number = ruleno;
-      rules[ruleno].lhs = p->sym;
+      rules[ruleno].lhs = p->content.sym;
       rules[ruleno].rhs = ritem + itemno;
       rules[ruleno].prec = NULL;
       rules[ruleno].dprec = p->dprec;
@@ -494,7 +486,7 @@ packgram (void)
       if (p != grammar)
        grammar_rule_check (p);
 
-      for (p = p->next; p && p->sym; p = p->next)
+      for (p = p->next; p && p->content.sym; p = p->next)
        {
          ++rule_length;
 
@@ -505,11 +497,12 @@ packgram (void)
 
          /* item_number = symbol_number.
             But the former needs to contain more: negative rule numbers. */
-         ritem[itemno++] = symbol_number_as_item_number (p->sym->number);
+         ritem[itemno++] =
+            symbol_number_as_item_number (p->content.sym->number);
          /* A rule gets by default the precedence and associativity
             of its last token.  */
-         if (p->sym->class == token_sym && default_prec)
-           rules[ruleno].prec = p->sym;
+         if (p->content.sym->class == token_sym && default_prec)
+           rules[ruleno].prec = p->content.sym;
        }
 
       /* If this rule has a %prec,
@@ -521,15 +514,15 @@ packgram (void)
        }
       /* An item ends by the rule number (negated).  */
       ritem[itemno++] = rule_number_as_item_number (ruleno);
-      assert (itemno < ITEM_NUMBER_MAX);
+      aver (itemno < ITEM_NUMBER_MAX);
       ++ruleno;
-      assert (ruleno < RULE_NUMBER_MAX);
+      aver (ruleno < RULE_NUMBER_MAX);
 
       if (p)
        p = p->next;
     }
 
-  assert (itemno == nritems);
+  aver (itemno == nritems);
 
   if (trace_flag & trace_sets)
     ritem_print (stderr);
@@ -607,23 +600,41 @@ check_and_convert_grammar (void)
       endtoken->user_token_number = 0;
     }
 
+  /* Find the start symbol if no %start.  */
+  if (!start_flag)
+    {
+      symbol_list *node;
+      for (node = grammar;
+           node != NULL && symbol_is_dummy (node->content.sym);
+           node = node->next)
+        {
+          for (node = node->next;
+               node != NULL && node->content.sym != NULL;
+               node = node->next)
+            ;
+        }
+      aver (node != NULL);
+      grammar_start_symbol_set (node->content.sym,
+                                node->content.sym->location);
+    }
+
   /* Insert the initial rule, whose line is that of the first rule
      (not that of the start symbol):
 
      accept: %start EOF.  */
   {
-    symbol_list *p = symbol_list_new (accept, empty_location);
+    symbol_list *p = symbol_list_sym_new (accept, empty_location);
     p->location = grammar->location;
-    p->next = symbol_list_new (startsymbol, empty_location);
-    p->next->next = symbol_list_new (endtoken, empty_location);
-    p->next->next->next = symbol_list_new (NULL, empty_location);
+    p->next = symbol_list_sym_new (startsymbol, empty_location);
+    p->next->next = symbol_list_sym_new (endtoken, empty_location);
+    p->next->next->next = symbol_list_sym_new (NULL, empty_location);
     p->next->next->next->next = grammar;
     nrules += 1;
     nritems += 3;
     grammar = p;
   }
 
-  assert (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars);
+  aver (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars);
 
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */