glr.c: move function declaration earlier

[bison.git] / data / lalr1.java

diff --git a/data/lalr1.java b/data/lalr1.java
index 3d17e46192892107633f31858b395fd67a284b22..02079fd0a2f63efb1578f3bd2081fd6edc9fff71 100644 (file)
--- a/data/lalr1.java
+++ b/data/lalr1.java
@@ -1,6 +1,6 @@
 # Java skeleton for Bison -*- autoconf -*-
 
 # Java skeleton for Bison -*- autoconf -*-
 

-# Copyright (C) 2007, 2008 Free Software Foundation, Inc.
+# Copyright (C) 2007-2012 Free Software Foundation, Inc.

 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -17,15 +17,22 @@
 
 m4_include(b4_pkgdatadir/[java.m4])
 
 
 m4_include(b4_pkgdatadir/[java.m4])
 

-b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
-m4_ifval(m4_defn([b4_symbol_destructors]),
-        [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])],
-        [])
+b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java],
+              [b4_skeleton])])

 
 

-m4_divert_push(0)dnl
-@output(b4_parser_file_name@)@
+# We don't depend on %debug in Java, but pacify warnings about non-used flags.
+b4_parse_trace_if([0], [0])
+
+m4_define([b4_symbol_no_destructor_assert],
+[b4_symbol_if([$1], [has_destructor],
+              [b4_fatal([%s: %s: %%destructor does not make sense in Java],
+                        [b4_skeleton],
+                        [b4_symbol_action_location([$1], [destructor])])])])
+b4_symbol_foreach([b4_symbol_no_destructor_assert])
+
+b4_output_begin([b4_parser_file_name])

 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],

-  [2007, 2008])
+             [2007-2012])

 
 b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
 ])[/* First part of user declarations.  */
 
 b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
 ])[/* First part of user declarations.  */


@@ -112,7 +119,7 @@ b4_locations_if([[
   private ]b4_location_type[ yylloc (YYStack rhs, int n)
   {
     if (n > 0)
   private ]b4_location_type[ yylloc (YYStack rhs, int n)
   {
     if (n > 0)

-      return new ]b4_location_type[ (rhs.locationAt (1).begin, rhs.locationAt (n).end);
+      return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end);

     else
       return new ]b4_location_type[ (rhs.locationAt (0).end);
   }]])[
     else
       return new ]b4_location_type[ (rhs.locationAt (0).end);
   }]])[


@@ -125,7 +132,7 @@ b4_locations_if([[
     /** Token returned by the scanner to signal the end of its input.  */
     public static final int EOF = 0;
 
     /** Token returned by the scanner to signal the end of its input.  */
     public static final int EOF = 0;
 

-]b4_token_enums(b4_tokens)[
+]b4_token_enums[

 
     ]b4_locations_if([[/**
      * Method to retrieve the beginning position of the last scanned token.
 
     ]b4_locations_if([[/**
      * Method to retrieve the beginning position of the last scanned token.


@@ -289,14 +296,14 @@ b4_lexer_if([[
     }
 
     public final void pop () {
     }
 
     public final void pop () {

-      height--;
+      pop (1);

     }
 
     public final void pop (int num) {
       // Avoid memory leaks... garbage collection is a white lie!
       if (num > 0) {
     }
 
     public final void pop (int num) {
       // Avoid memory leaks... garbage collection is a white lie!
       if (num > 0) {

-        java.util.Arrays.fill (valueStack, height - num + 1, height, null);
-        ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height, null);]])[
+        java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
+        ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[

       }
       height -= num;
     }
       }
       height -= num;
     }


@@ -318,7 +325,7 @@ b4_lexer_if([[
     {
       out.print ("Stack now");
 
     {
       out.print ("Stack now");
 

-      for (int i = 0; i < height; i++)
+      for (int i = 0; i <= height; i++)

         {
           out.print (' ');
           out.print (stateStack[i]);
         {
           out.print (' ');
           out.print (stateStack[i]);


@@ -342,11 +349,9 @@ b4_lexer_if([[
    * printing an error message.  */
   public static final int YYERROR = 2;
 
    * printing an error message.  */
   public static final int YYERROR = 2;
 

-  /**
-   * Returned by a Bison action in order to print an error message and start
-   * error recovery.  */
-  public static final int YYFAIL = 3;
-
+  // Internal return codes that are not supported for user semantic
+  // actions.
+  private static final int YYERRLAB = 3;

   private static final int YYNEWSTATE = 4;
   private static final int YYDEFAULT = 5;
   private static final int YYREDUCE = 6;
   private static final int YYNEWSTATE = 4;
   private static final int YYDEFAULT = 5;
   private static final int YYREDUCE = 6;


@@ -492,18 +497,14 @@ b4_lexer_if([[
     /// Semantic value of the lookahead.
     b4_yystype[ yylval = null;
 
     /// Semantic value of the lookahead.
     b4_yystype[ yylval = null;
 

-    int yyresult;
-

     yycdebug ("Starting parse\n");
     yyerrstatus_ = 0;
 
 ]m4_ifdef([b4_initial_action], [
     yycdebug ("Starting parse\n");
     yyerrstatus_ = 0;
 
 ]m4_ifdef([b4_initial_action], [

-m4_pushdef([b4_at_dollar],     [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
+b4_dollar_pushdef([yylval], [], [yylloc])dnl

     /* User initialization code.  */
     b4_user_initial_action
     /* User initialization code.  */
     b4_user_initial_action

-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_popdef])[]dnl

 
   [  /* Initialize the stack.  */
     yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
 
   [  /* Initialize the stack.  */
     yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);


@@ -525,7 +526,7 @@ m4_popdef([b4_at_dollar])])dnl
 
         /* Take a decision.  First try without lookahead.  */
         yyn = yypact_[yystate];
 
         /* Take a decision.  First try without lookahead.  */
         yyn = yypact_[yystate];

-        if (yyn == yypact_ninf_)
+        if (yy_pact_value_is_default_ (yyn))

           {
             label = YYDEFAULT;
             break;
           {
             label = YYDEFAULT;
             break;


@@ -564,8 +565,8 @@ m4_popdef([b4_at_dollar])])dnl
         /* <= 0 means reduce or error.  */
         else if ((yyn = yytable_[yyn]) <= 0)
           {
         /* <= 0 means reduce or error.  */
         else if ((yyn = yytable_[yyn]) <= 0)
           {

-            if (yyn == 0 || yyn == yytable_ninf_)
-              label = YYFAIL;
+            if (yy_table_value_is_error_ (yyn))
+              label = YYERRLAB;

             else
               {
                 yyn = -yyn;
             else
               {
                 yyn = -yyn;


@@ -599,7 +600,7 @@ m4_popdef([b4_at_dollar])])dnl
       case YYDEFAULT:
         yyn = yydefact_[yystate];
         if (yyn == 0)
       case YYDEFAULT:
         yyn = yydefact_[yystate];
         if (yyn == 0)

-          label = YYFAIL;
+          label = YYERRLAB;

         else
           label = YYREDUCE;
         break;
         else
           label = YYREDUCE;
         break;


@@ -616,11 +617,13 @@ m4_popdef([b4_at_dollar])])dnl
       /*------------------------------------.
       | yyerrlab -- here on detecting error |
       `------------------------------------*/
       /*------------------------------------.
       | yyerrlab -- here on detecting error |
       `------------------------------------*/

-      case YYFAIL:
+      case YYERRLAB:

         /* If not already recovering from an error, report this error.  */
         if (yyerrstatus_ == 0)
           {
             ++yynerrs_;
         /* If not already recovering from an error, report this error.  */
         if (yyerrstatus_ == 0)
           {
             ++yynerrs_;

+            if (yychar == yyempty_)
+              yytoken = yyempty_;

             yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
           }
 
             yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
           }
 


@@ -668,7 +671,7 @@ m4_popdef([b4_at_dollar])])dnl
         for (;;)
           {
             yyn = yypact_[yystate];
         for (;;)
           {
             yyn = yypact_[yystate];

-            if (yyn != yypact_ninf_)
+            if (!yy_pact_value_is_default_ (yyn))

               {
                 yyn += yyterror_;
                 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
               {
                 yyn += yyterror_;
                 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)


@@ -680,7 +683,7 @@ m4_popdef([b4_at_dollar])])dnl
               }
 
             /* Pop the current state because it cannot handle the error token.  */
               }
 
             /* Pop the current state because it cannot handle the error token.  */

-            if (yystack.height == 1)
+            if (yystack.height == 0)

               return false;
 
             ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
               return false;
 
             ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[


@@ -721,89 +724,106 @@ m4_popdef([b4_at_dollar])])dnl
   {]b4_error_verbose_if([[
     if (yyErrorVerbose)
       {
   {]b4_error_verbose_if([[
     if (yyErrorVerbose)
       {

-        int yyn = yypact_[yystate];
-        if (yypact_ninf_ < yyn && yyn <= yylast_)
+        /* There are many possibilities here to consider:
+           - If this state is a consistent state with a default action,
+             then the only way this function was invoked is if the
+             default action is an error action.  In that case, don't
+             check for expected tokens because there are none.
+           - The only way there can be no lookahead present (in tok) is
+             if this state is a consistent state with a default action.
+             Thus, detecting the absence of a lookahead is sufficient to
+             determine that there is no unexpected or expected token to
+             report.  In that case, just report a simple "syntax error".
+           - Don't assume there isn't a lookahead just because this
+             state is a consistent state with a default action.  There
+             might have been a previous inconsistent state, consistent
+             state with a non-default action, or user semantic action
+             that manipulated yychar.  (However, yychar is currently out
+             of scope during semantic actions.)
+           - Of course, the expected token list depends on states to
+             have correct lookahead information, and it depends on the
+             parser not to perform extra reductions after fetching a
+             lookahead from the scanner and before detecting a syntax
+             error.  Thus, state merging (from LALR or IELR) and default
+             reductions corrupt the expected token list.  However, the
+             list is correct for canonical LR with one exception: it
+             will still contain any token that will not be accepted due
+             to an error action in a later state.
+        */
+        if (tok != yyempty_)

           {
           {

-            StringBuffer res;
-
-            /* Start YYX at -YYN if negative to avoid negative indexes in
-               YYCHECK.  */
-            int yyxbegin = yyn < 0 ? -yyn : 0;
-
-            /* Stay within bounds of both yycheck and yytname.  */
-            int yychecklim = yylast_ - yyn + 1;
-            int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
-            int count = 0;
-            for (int x = yyxbegin; x < yyxend; ++x)
-              if (yycheck_[x + yyn] == x && x != yyterror_)
-                ++count;
-

             // FIXME: This method of building the message is not compatible
             // with internationalization.
             // FIXME: This method of building the message is not compatible
             // with internationalization.

-            res = new StringBuffer ("syntax error, unexpected ");
+            StringBuffer res =
+              new StringBuffer ("syntax error, unexpected ");

             res.append (yytnamerr_ (yytname_[tok]));
             res.append (yytnamerr_ (yytname_[tok]));

-            if (count < 5)
+            int yyn = yypact_[yystate];
+            if (!yy_pact_value_is_default_ (yyn))

               {
               {

-                count = 0;
+                /* Start YYX at -YYN if negative to avoid negative
+                   indexes in YYCHECK.  In other words, skip the first
+                   -YYN actions for this state because they are default
+                   actions.  */
+                int yyxbegin = yyn < 0 ? -yyn : 0;
+                /* Stay within bounds of both yycheck and yytname.  */
+                int yychecklim = yylast_ - yyn + 1;
+                int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
+                int count = 0;

                 for (int x = yyxbegin; x < yyxend; ++x)
                 for (int x = yyxbegin; x < yyxend; ++x)

-                  if (yycheck_[x + yyn] == x && x != yyterror_)
-                    {
-                      res.append (count++ == 0 ? ", expecting " : " or ");
-                      res.append (yytnamerr_ (yytname_[x]));
-                    }
+                  if (yycheck_[x + yyn] == x && x != yyterror_
+                      && !yy_table_value_is_error_ (yytable_[x + yyn]))
+                    ++count;
+                if (count < 5)
+                  {
+                    count = 0;
+                    for (int x = yyxbegin; x < yyxend; ++x)
+                      if (yycheck_[x + yyn] == x && x != yyterror_
+                          && !yy_table_value_is_error_ (yytable_[x + yyn]))
+                        {
+                          res.append (count++ == 0 ? ", expecting " : " or ");
+                          res.append (yytnamerr_ (yytname_[x]));
+                        }
+                  }

               }
               }

-        return res.toString ();
+            return res.toString ();

           }
       }
 ]])[
     return "syntax error";
   }
 
           }
       }
 ]])[
     return "syntax error";
   }
 

-  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-     STATE-NUM.  */
-  private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
-  ]b4_integral_parser_table([yypact_], [b4_pact])[
-
-  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
-     doesn't specify something else to do.  Zero means the default is an
-     error.  */
-  ]b4_integral_parser_table([yydefact_], [b4_defact])[
-
-  /* YYPGOTO[NTERM-NUM].  */
-  ]b4_integral_parser_table([yypgoto_], [b4_pgoto])[
+  /**
+   * Whether the given <code>yypact_</code> value indicates a defaulted state.
+   * @@param yyvalue   the value to check
+   */
+  private static boolean yy_pact_value_is_default_ (int yyvalue)
+  {
+    return yyvalue == yypact_ninf_;
+  }

 
 

-  /* YYDEFGOTO[NTERM-NUM].  */
-  ]b4_integral_parser_table([yydefgoto_], [b4_defgoto])[
+  /**
+   * Whether the given <code>yytable_</code> value indicates a syntax error.
+   * @@param yyvalue   the value to check
+   */
+  private static boolean yy_table_value_is_error_ (int yyvalue)
+  {
+    return yyvalue == yytable_ninf_;
+  }

 
 

-  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-     positive, shift that token.  If negative, reduce the rule which
-     number is the opposite.  If zero, do what YYDEFACT says.  */
+  private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;

   private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
   private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;

-  ]b4_integral_parser_table([yytable_], [b4_table])[
-
-  /* YYCHECK.  */
-  ]b4_integral_parser_table([yycheck_], [b4_check])[
-
-  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
-     symbol of state STATE-NUM.  */
-  ]b4_integral_parser_table([yystos_], [b4_stos])[
-
-  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
-     to YYLEX-NUM.  */
-  ]b4_integral_parser_table([yytoken_number_], [b4_toknum])[
-
-  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-  ]b4_integral_parser_table([yyr1_], [b4_r1])[

 
 

-  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-  ]b4_integral_parser_table([yyr2_], [b4_r2])[
+  ]b4_parser_tables_define[
+  ]b4_integral_parser_table_define([token_number], [b4_toknum],
+     [TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
+     to YYLEX-NUM.])[

 
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
      First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
 
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
      First, the terminals, then, starting at \a yyntokens_, nonterminals.  */

-  ]b4_typed_parser_table([String], [yytname_], [b4_tname])[
+  ]b4_typed_parser_table_define([String], [tname], [b4_tname])[

 
 

-  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-  ]b4_integral_parser_table([yyrline_], [b4_rline])[
+  ]b4_integral_parser_table_define([rline], [b4_rline],
+  [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[

 
   // Report on the debug stream that the rule yyrule is going to be reduced.
   private void yy_reduce_print (int yyrule, YYStack yystack)
 
   // Report on the debug stream that the rule yyrule is going to be reduced.
   private void yy_reduce_print (int yyrule, YYStack yystack)


@@ -820,13 +840,13 @@ m4_popdef([b4_at_dollar])])dnl
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       yy_symbol_print ("   $" + (yyi + 1) + " =",
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       yy_symbol_print ("   $" + (yyi + 1) + " =",

-                       yystos_[yystack.stateAt(yyi + 1 - yynrhs)],
+                       yystos_[yystack.stateAt(yynrhs - (yyi + 1))],

                        ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
                        b4_rhs_location(yynrhs, yyi + 1)])[);
   }
 
   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
                        ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
                        b4_rhs_location(yynrhs, yyi + 1)])[);
   }
 
   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

-  ]b4_integral_parser_table([yytranslate_table_], [b4_translate])[
+  ]b4_integral_parser_table_define([translate_table], [b4_translate])[

 
   private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
   {
 
   private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
   {


@@ -852,5 +872,5 @@ b4_percent_code_get[]dnl
 
 }
 
 
 }
 

-b4_epilogue
-m4_divert_pop(0)dnl
+b4_epilogue[]dnl
+b4_output_end()