java: provide Context with a more OO interface

* data/skeletons/lalr1.java (yyexpectedTokens)
(yysyntaxErrorArguments): Make them methods of Context.
(Context.yysymbolName): New.
* tests/local.at: Adjust.

TODO

@@ -18,6 +18,14 @@ We should be able to redefine EOF like we do in C.
 ** Java: calc.at
 Stop hard-coding "Calc".  Adjust local.at (look for FIXME).
 
+** Java: _
+We must not use _ in Java, it is becoming a keyword in Java 9.
+
+examples/java/calc/Calc.java:998: warning: '_' used as an identifier
+  "$end", "error", "$undefined", _("end of line"), _("number"), "'='",
+                                 ^
+  (use of '_' as an identifier might not be supported in releases after Java SE 8)
+
 ** doc
 I feel it's ugly to use the GNU style to declare functions in the doc.  It
 generates tons of white space in the page, and may contribute to bad page

data/skeletons/lalr1.java

@@ -866,80 +866,83 @@ b4_dollar_popdef[]dnl
     public int yytoken;]b4_locations_if([[
     public ]b4_location_type[ yylocation;]])[
     public static final int yyntokens = ]b4_parser_class[.yyntokens_;
-  };
 
-  /* Put in YYARG at most YYARGN of the expected tokens given the
-     current YYCTX, and return the number of tokens stored in YYARG.  If
-     YYARG is null, return the number of expected tokens (guaranteed to
-     be less than YYNTOKENS_).  */
-  static int
-  yyexpectedTokens (Context yyctx,
-                    int yyarg[], int yyoffset, int yyargn)
-  {
-    int yycount = yyoffset;
-    int yyn = yypact_[yyctx.yystack.stateAt (0)];
-    if (!yyPactValueIsDefault (yyn))
-      {
-        /* 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_;
-        for (int x = yyxbegin; x < yyxend; ++x)
-          if (yycheck_[x + yyn] == x && x != yy_error_token_
-              && !yyTableValueIsError (yytable_[x + yyn]))
-            {
-              if (yyarg == null)
-                yycount += 1;
-              else if (yycount == yyargn)
-                return 0; // FIXME: this is incorrect.
-              else
-                yyarg[yycount++] = x;
-            }
-      }
-    return yycount - yyoffset;
-  }
+    /* Put in YYARG at most YYARGN of the expected tokens given the
+       current YYCTX, and return the number of tokens stored in YYARG.  If
+       YYARG is null, return the number of expected tokens (guaranteed to
+       be less than YYNTOKENS).  */
+    int yyexpectedTokens (int yyarg[], int yyoffset, int yyargn)
+    {
+      int yycount = yyoffset;
+      int yyn = yypact_[this.yystack.stateAt (0)];
+      if (!yyPactValueIsDefault (yyn))
+        {
+          /* 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;
+          for (int x = yyxbegin; x < yyxend; ++x)
+            if (yycheck_[x + yyn] == x && x != yy_error_token_
+                && !yyTableValueIsError (yytable_[x + yyn]))
+              {
+                if (yyarg == null)
+                  yycount += 1;
+                else if (yycount == yyargn)
+                  return 0; // FIXME: this is incorrect.
+                else
+                  yyarg[yycount++] = x;
+              }
+        }
+      return yycount - yyoffset;
+    }
 
-  static int
-  yysyntaxErrorArguments (Context yyctx,
-                          int[] yyarg, int yyargn)
-  {
-    /* 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.
-    */
-    int yycount = 0;
-    if (yyctx.yytoken != yyempty_)
-      {
-        yyarg[yycount++] = yyctx.yytoken;
-        yycount += yyexpectedTokens (yyctx, yyarg, 1, yyargn);
-      }
-    return yycount;
+    /* The user-facing name of the symbol whose (internal) number is
+       YYSYMBOL.  No bounds checking.  */
+    static String yysymbolName (int yysymbol)
+    {
+      return ]b4_parser_class[.yysymbolName (yysymbol);
+    }
+
+    int yysyntaxErrorArguments (int[] yyarg, int yyargn)
+    {
+      /* 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.
+      */
+      int yycount = 0;
+      if (this.yytoken != yyempty_)
+        {
+          yyarg[yycount++] = this.yytoken;
+          yycount += this.yyexpectedTokens (yyarg, 1, yyargn);
+        }
+      return yycount;
+    }
   }
 
  /**
@@ -954,7 +957,7 @@ b4_dollar_popdef[]dnl
       {
         final int argmax = 5;
         int[] yyarg = new int[argmax];
-        int yycount = yysyntaxErrorArguments (yyctx, yyarg, argmax);
+        int yycount = yyctx.yysyntaxErrorArguments (yyarg, argmax);
         String[] yystr = new String[yycount];
         for (int yyi = 0; yyi < yycount; ++yyi)
           yystr[yyi] = yysymbolName (yyarg[yyi]);

examples/java/calc/Calc.y

@@ -110,13 +110,13 @@ class CalcLexer implements Calc.Lexer {
   {
     final int ARGMAX = 10;
     int[] arg = new int[ARGMAX];
-    int n = Calc.yysyntaxErrorArguments (ctx, arg, ARGMAX);
+    int n = ctx.yysyntaxErrorArguments (arg, ARGMAX);
     System.err.print (ctx.yylocation + ": syntax error");
     for (int i = 1; i < n; ++i)
       System.err.print ((i == 1 ? ": expected " : " or ")
-                        + Calc.yysymbolName (arg[i]));
+                        + ctx.yysymbolName (arg[i]));
     if (n != 0)
-      System.err.print (" before " + Calc.yysymbolName (arg[0]));
+      System.err.print (" before " + ctx.yysymbolName (arg[0]));
     System.err.println ("");
   }
 

tests/local.at

@@ -934,14 +934,14 @@ m4_define([AT_YYERROR_DEFINE(java)],
   public void yyreportSyntaxError (Calc.Context ctx)
   {
     int[] arg = new int[ctx.yyntokens];
-    int n = Calc.yysyntaxErrorArguments (ctx, arg, ctx.yyntokens);
+    int n = ctx.yysyntaxErrorArguments (arg, ctx.yyntokens);
     System.err.print (]AT_LOCATION_IF([[ctx.yylocation + ": "]]
-                      + )["syntax error on token @<:@" + Calc.yysymbolName(arg[0]) + "@:>@");
+                      + )["syntax error on token @<:@" + ctx.yysymbolName (arg[0]) + "@:>@");
     if (1 < n)
       {
         System.err.print (" (expected:");
         for (int i = 1; i < n; ++i)
-          System.err.print (" @<:@" + Calc.yysymbolName (arg[i]) + "@:>@");
+          System.err.print (" @<:@" + ctx.yysymbolName (arg[i]) + "@:>@");
         System.err.print (")");
       }
     System.err.println ("");