Pacify "gcc -Wunused" for the input function from Flex.

[bison.git] / src / scan-code.l

diff --git a/src/scan-code.l b/src/scan-code.l
index 47cde77eac80aca1bafb0c432387e2aa84551e33..235800f8ca56c6e8b441cbe018c667369897600a 100644 (file)
--- a/src/scan-code.l
+++ b/src/scan-code.l
@@ -17,7 +17,7 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 

-%option debug nodefault nounput noyywrap never-interactive
+%option debug nodefault noinput nounput noyywrap never-interactive

 %option prefix="code_" outfile="lex.yy.c"
 
 %{
 %option prefix="code_" outfile="lex.yy.c"
 
 %{


@@ -337,7 +337,7 @@ static unsigned variant_table_size = 0;
 static unsigned variant_count = 0;
 
 static variant *
 static unsigned variant_count = 0;
 
 static variant *

-variant_table_grow ()
+variant_table_grow (void)

 {
   ++variant_count;
   if (variant_count > variant_table_size)
 {
   ++variant_count;
   if (variant_count > variant_table_size)


@@ -350,6 +350,14 @@ variant_table_grow ()
   return &variant_table[variant_count - 1];
 }
 
   return &variant_table[variant_count - 1];
 }
 

+static void
+variant_table_free (void)
+{
+  free (variant_table);
+  variant_table = 0;
+  variant_table_size = variant_count = 0;
+}
+

 static char *
 find_prefix_end (const char *prefix, char *begin, char *end)
 {
 static char *
 find_prefix_end (const char *prefix, char *begin, char *end)
 {


@@ -366,7 +374,7 @@ find_prefix_end (const char *prefix, char *begin, char *end)
 }
 
 static variant *
 }
 
 static variant *

-variant_add (uniqstr id, location loc, unsigned index,
+variant_add (uniqstr id, location id_loc, unsigned symbol_index,

             char *cp, char *cp_end, bool exact_mode)
 {
   char *prefix_end;
             char *cp, char *cp_end, bool exact_mode)
 {
   char *prefix_end;


@@ -377,9 +385,9 @@ variant_add (uniqstr id, location loc, unsigned index,
        (!exact_mode && is_dot_or_dash (*prefix_end))))
     {
       variant *r = variant_table_grow ();
        (!exact_mode && is_dot_or_dash (*prefix_end))))
     {
       variant *r = variant_table_grow ();

-      r->index = index;
+      r->index = symbol_index;

       r->id = id;
       r->id = id;

-      r->loc = loc;
+      r->loc = id_loc;

       r->hidden_by = NULL;
       r->err = 0;
       return r;
       r->hidden_by = NULL;
       r->err = 0;
       return r;


@@ -389,13 +397,13 @@ variant_add (uniqstr id, location loc, unsigned index,
 }
 
 static const char *
 }
 
 static const char *

-get_at_spec(unsigned index)
+get_at_spec(unsigned symbol_index)

 {
   static char at_buf[20];
 {
   static char at_buf[20];

-  if (index == 0)
+  if (symbol_index == 0)

     strcpy (at_buf, "$$");
   else
     strcpy (at_buf, "$$");
   else

-    snprintf (at_buf, sizeof at_buf, "$%u", index);
+    snprintf (at_buf, sizeof at_buf, "$%u", symbol_index);

   return at_buf;
 }
 
   return at_buf;
 }
 


@@ -412,7 +420,7 @@ get_at_spec(unsigned index)
    accesses. */
 static long int
 parse_ref (char *cp, symbol_list *rule, int rule_length,
    accesses. */
 static long int
 parse_ref (char *cp, symbol_list *rule, int rule_length,

-          int midrule_rhs_index, char *text, location loc,
+          int midrule_rhs_index, char *text, location text_loc,

           char dollar_or_at)
 {
   symbol_list *l;
           char dollar_or_at)
 {
   symbol_list *l;


@@ -432,7 +440,8 @@ parse_ref (char *cp, symbol_list *rule, int rule_length,
        return num;
       else
        {
        return num;
       else
        {

-         complain_at (loc, _("integer out of range: %s"), quote (text));
+         complain_at (text_loc, _("integer out of range: %s"),
+                       quote (text));

          return INVALID_REF;
        }
     }
          return INVALID_REF;
        }
     }


@@ -466,23 +475,23 @@ parse_ref (char *cp, symbol_list *rule, int rule_length,
 
   /* Add all relevant variants. */
   {
 
   /* Add all relevant variants. */
   {

-    unsigned index;
+    unsigned symbol_index;

     variant_count = 0;
     variant_count = 0;

-    for (index = 0, l = rule; !symbol_list_null (l); ++index, l = l->next)
+    for (symbol_index = 0, l = rule; !symbol_list_null (l);
+         ++symbol_index, l = l->next)

       {
       {

-       variant *variant;
+       variant *var;

        if (l->content_type != SYMLIST_SYMBOL)
          continue;
 
        if (l->content_type != SYMLIST_SYMBOL)
          continue;
 

-       variant = variant_add (l->content.sym->tag, l->sym_loc, index,
-                              cp, cp_end, exact_mode);
-
-       if (variant && l->named_ref)
-         variant->hidden_by = l->named_ref;
+       var = variant_add (l->content.sym->tag, l->sym_loc,
+                           symbol_index, cp, cp_end, exact_mode);
+       if (var && l->named_ref)
+         var->hidden_by = l->named_ref;

 
        if (l->named_ref)
 
        if (l->named_ref)

-         variant_add (l->named_ref->id, l->named_ref->loc, index,
-                      cp, cp_end, exact_mode);
+         variant_add (l->named_ref->id, l->named_ref->loc,
+                       symbol_index, cp, cp_end, exact_mode);

       }
   }
 
       }
   }
 


@@ -491,77 +500,77 @@ parse_ref (char *cp, symbol_list *rule, int rule_length,
   has_valid = false;
   for (i = 0; i < variant_count; ++i)
     {
   has_valid = false;
   for (i = 0; i < variant_count; ++i)
     {

-      variant *variant = &variant_table[i];
-      unsigned index = variant->index;
+      variant *var = &variant_table[i];
+      unsigned symbol_index = var->index;

 
       /* Check visibility from mid-rule actions. */
       if (midrule_rhs_index != 0
 
       /* Check visibility from mid-rule actions. */
       if (midrule_rhs_index != 0

-         && (index == 0 || midrule_rhs_index < index))
+         && (symbol_index == 0 || midrule_rhs_index < symbol_index))

        {
        {

-         variant->err |= VARIANT_NOT_VISIBLE_FROM_MIDRULE;
+         var->err |= VARIANT_NOT_VISIBLE_FROM_MIDRULE;

          has_error = true;
        }
 
       /* Check correct bracketing. */
          has_error = true;
        }
 
       /* Check correct bracketing. */

-      if (!exact_mode && contains_dot_or_dash (variant->id))
+      if (!exact_mode && contains_dot_or_dash (var->id))

        {
        {

-         variant->err |= VARIANT_BAD_BRACKETING;
+         var->err |= VARIANT_BAD_BRACKETING;

          has_error = true;
        }
 
       /* Check using of hidden symbols. */
          has_error = true;
        }
 
       /* Check using of hidden symbols. */

-      if (variant->hidden_by)
+      if (var->hidden_by)

        {
        {

-         variant->err |= VARIANT_HIDDEN;
+         var->err |= VARIANT_HIDDEN;

          has_error = true;
        }
 
          has_error = true;
        }
 

-      if (!variant->err)
+      if (!var->err)

        has_valid = true;
     }
 
   if (variant_count == 1 && has_valid)
     {
       /* The only "good" case is here. */
        has_valid = true;
     }
 
   if (variant_count == 1 && has_valid)
     {
       /* The only "good" case is here. */

-      unsigned index = variant_table[0].index;
-      if (index == midrule_rhs_index)
+      unsigned symbol_index = variant_table[0].index;
+      if (symbol_index == midrule_rhs_index)

        return LHS_REF;
       else
        return LHS_REF;
       else

-       return index;
+       return symbol_index;

     }
 
   /* Start complaining. */
 
   if (variant_count == 0)
     }
 
   /* Start complaining. */
 
   if (variant_count == 0)

-    complain_at (loc, _("invalid reference: %s, symbol not found"),
+    complain_at (text_loc, _("invalid reference: %s, symbol not found"),

                 quote (text));
   else if (variant_count > 1 && !has_error)
                 quote (text));
   else if (variant_count > 1 && !has_error)

-    complain_at (loc, _("ambiguous reference: %s"),
+    complain_at (text_loc, _("ambiguous reference: %s"),

                 quote (text));
   else if (variant_count > 1 && has_valid && has_error)
                 quote (text));
   else if (variant_count > 1 && has_valid && has_error)

-    complain_at (loc, _("misleading reference: %s"),
+    complain_at (text_loc, _("misleading reference: %s"),

                 quote (text));
   else
                 quote (text));
   else

-    complain_at (loc, _("invalid reference: %s"),
+    complain_at (text_loc, _("invalid reference: %s"),

                 quote (text));
 
   for (i = 0; i < variant_count; ++i)
     {
                 quote (text));
 
   for (i = 0; i < variant_count; ++i)
     {

-      const variant *variant = &variant_table[i];
-      const char *at_spec = get_at_spec (variant->index);
+      const variant *var = &variant_table[i];
+      const char *at_spec = get_at_spec (var->index);

 
 

-      if (variant->err == 0)
-       complain_at (variant->loc, _("  refers to: %c%s at %s"),
-                    dollar_or_at, variant->id, at_spec);
+      if (var->err == 0)
+       complain_at (var->loc, _("  refers to: %c%s at %s"),
+                    dollar_or_at, var->id, at_spec);

       else
        {
          static struct obstack msg_buf;
          const char *tail = exact_mode ? "" :
       else
        {
          static struct obstack msg_buf;
          const char *tail = exact_mode ? "" :

-           cp + strlen (variant->id);
-         const char *id = variant->hidden_by ? variant->hidden_by->id :
-           variant->id;
-         location loc = variant->hidden_by ? variant->hidden_by->loc :
-           variant->loc;
+           cp + strlen (var->id);
+         const char *id = var->hidden_by ? var->hidden_by->id :
+           var->id;
+         location id_loc = var->hidden_by ? var->hidden_by->loc :
+           var->loc;

 
          /* Create the explanation message. */
          obstack_init (&msg_buf);
 
          /* Create the explanation message. */
          obstack_init (&msg_buf);


@@ -573,24 +582,24 @@ parse_ref (char *cp, symbol_list *rule, int rule_length,
            obstack_sgrow (&msg_buf, id);
          obstack_sgrow (&msg_buf, tail);
 
            obstack_sgrow (&msg_buf, id);
          obstack_sgrow (&msg_buf, tail);
 

-         if (variant->err & VARIANT_HIDDEN)
+         if (var->err & VARIANT_HIDDEN)

            {
              obstack_fgrow1 (&msg_buf, ", hiding %c", dollar_or_at);
            {
              obstack_fgrow1 (&msg_buf, ", hiding %c", dollar_or_at);

-             if (contains_dot_or_dash (variant->id))
-               obstack_fgrow1 (&msg_buf, "[%s]", variant->id);
+             if (contains_dot_or_dash (var->id))
+               obstack_fgrow1 (&msg_buf, "[%s]", var->id);

              else
              else

-               obstack_sgrow (&msg_buf, variant->id);
+               obstack_sgrow (&msg_buf, var->id);

              obstack_sgrow (&msg_buf, tail);
            }
 
          obstack_fgrow1 (&msg_buf, " at %s", at_spec);
 
              obstack_sgrow (&msg_buf, tail);
            }
 
          obstack_fgrow1 (&msg_buf, " at %s", at_spec);
 

-         if (variant->err & VARIANT_NOT_VISIBLE_FROM_MIDRULE)
+         if (var->err & VARIANT_NOT_VISIBLE_FROM_MIDRULE)

            obstack_fgrow1 (&msg_buf, ", cannot be accessed from "
                            "mid-rule action at $%d", midrule_rhs_index);
 
          obstack_1grow (&msg_buf, '\0');
            obstack_fgrow1 (&msg_buf, ", cannot be accessed from "
                            "mid-rule action at $%d", midrule_rhs_index);
 
          obstack_1grow (&msg_buf, '\0');

-         complain_at (loc, _("%s"), (char *) obstack_finish (&msg_buf));
+         complain_at (id_loc, _("%s"), (char *) obstack_finish (&msg_buf));

          obstack_free (&msg_buf, 0);
        }
     }
          obstack_free (&msg_buf, 0);
        }
     }


@@ -826,14 +835,14 @@ code_props_symbol_action_init (code_props *self, char const *code,
 void
 code_props_rule_action_init (code_props *self, char const *code,
                              location code_loc, symbol_list *rule,
 void
 code_props_rule_action_init (code_props *self, char const *code,
                              location code_loc, symbol_list *rule,

-                            named_ref *named_ref)
+                            named_ref *name)

 {
   self->kind = CODE_PROPS_RULE_ACTION;
   self->code = code;
   self->location = code_loc;
   self->is_value_used = false;
   self->rule = rule;
 {
   self->kind = CODE_PROPS_RULE_ACTION;
   self->code = code;
   self->location = code_loc;
   self->is_value_used = false;
   self->rule = rule;

-  self->named_ref = named_ref;
+  self->named_ref = name;

 }
 
 void
 }
 
 void


@@ -865,6 +874,8 @@ void
 code_scanner_free (void)
 {
   obstack_free (&obstack_for_string, 0);
 code_scanner_free (void)
 {
   obstack_free (&obstack_for_string, 0);

+  variant_table_free ();
+

   /* Reclaim Flex's buffers.  */
   yylex_destroy ();
 }
   /* Reclaim Flex's buffers.  */
   yylex_destroy ();
 }