tests: rename AT_SKEL_CC_IF/AT_SKEL_JAVA_IF as AT_CXX_IF/AT_JAVA_IF

The previous name is too obscure, and the other macros for C++ use
CXX, not CC.

* tests/local.at (AT_SKEL_CC_IF, AT_SKEL_JAVA_IF): Rename as...
(AT_CXX_IF, AT_JAVA_IF): these.
Adjust callers.

tests/actions.at

@@ -252,15 +252,15 @@ AT_DATA_GRAMMAR([[input.y]],
 ]AT_YYLEX_DECLARE[
 }
 %%
-exp: { ]AT_SKEL_CC_IF([[std::cerr << @$ << '\n']],
+exp: { ]AT_CXX_IF([[std::cerr << @$ << '\n']],
-                      [[LOCATION_PRINT(stderr, @$); fputc ('\n', stderr)]])[; }
+                  [[LOCATION_PRINT(stderr, @$); fputc ('\n', stderr)]])[; }
 %%
 ]AT_YYERROR_DEFINE[
 
 ]AT_YYLEX_PROTOTYPE[
 {]AT_PURE_IF([
   YYUSE(lvalp);
-  YYUSE(llocp);], [AT_SKEL_CC_IF([
+  YYUSE(llocp);], [AT_CXX_IF([
   YYUSE(lvalp);
   YYUSE(llocp);])])[
   return 'x';
@@ -268,7 +268,7 @@ exp: { ]AT_SKEL_CC_IF([[std::cerr << @$ << '\n']],
 
 int
 main (void)
-{]AT_SKEL_CC_IF([[
+{]AT_CXX_IF([[
   yy::parser p;
   p.set_debug_level (!!getenv("YYDEBUG"));
   return p.parse ();]], [[
@@ -369,7 +369,7 @@ main (void)
   loc.]AT_FIRST_COLUMN[ = C1;         \
   loc.]AT_LAST_LINE[ = L2;            \
   loc.]AT_LAST_COLUMN[ = C2;          \
-  ]AT_SKEL_CC_IF([std::cout << loc],
+  ]AT_CXX_IF([std::cout << loc],
                  [LOCATION_PRINT(stdout, loc)])[;\
   putchar ('\n');
 
@@ -1651,7 +1651,7 @@ AT_DATA_GRAMMAR([[input.y]],
 
 # define YYSTYPE sem_type
 
-]AT_SKEL_CC_IF([[
+]AT_CXX_IF([[
 # include <iostream>
   namespace
   {
@@ -1698,7 +1698,7 @@ float: UNTYPED INT
 };
 %%
 ]AT_YYERROR_DEFINE[
-]AT_YYLEX_DEFINE(AT_SKEL_CC_IF([[{yy::parser::token::UNTYPED,
+]AT_YYLEX_DEFINE(AT_CXX_IF([[{yy::parser::token::UNTYPED,
                                  yy::parser::token::INT,
                                   EOF}]],
                                [[{UNTYPED, INT, EOF}]]),

tests/calc.at

@@ -48,7 +48,7 @@ m4_pushdef([AT_CALC_MAIN],
 [#include <assert.h>
 #include <unistd.h>
 
-AT_SKEL_CC_IF([[
+AT_CXX_IF([[
 namespace
 {
   /* A C++ ]AT_NAME_PREFIX[parse that simulates the C signature.  */
@@ -93,7 +93,7 @@ main (int argc, const char **argv)
       return 3;
     }
 
-]AT_SKEL_CC_IF([], [AT_DEBUG_IF([  ]AT_NAME_PREFIX[debug = 1;])])[
+]AT_CXX_IF([], [AT_DEBUG_IF([  ]AT_NAME_PREFIX[debug = 1;])])[
   status = ]AT_NAME_PREFIX[parse (]AT_PARAM_IF([[&result, &count]])[);
   if (fclose (input))
     perror ("fclose");
@@ -206,7 +206,7 @@ read_signed_integer (]AT_YYLEX_FORMALS[)
 AT_DATA_GRAMMAR([calc.y],
 [[/* Infix notation calculator--calc */
 ]$4
-AT_SKEL_CC_IF(
+AT_CXX_IF(
 [%define global_tokens_and_yystype])[
 %code requires
 {
@@ -247,8 +247,8 @@ AT_SKEL_CC_IF(
 {
   semantic_value ival;
 };
-%printer { ]AT_SKEL_CC_IF([[yyo << $$]],
+%printer { ]AT_CXX_IF([[yyo << $$]],
-                          [[fprintf (yyo, "%d", $$)]])[; } <ival>;
+                      [[fprintf (yyo, "%d", $$)]])[; } <ival>;
 
 %code provides
 {
@@ -272,7 +272,7 @@ static int power (int base, int exponent);
 ]AT_YYLEX_DECLARE_EXTERN[
 }
 
-]AT_SKEL_CC_IF([AT_LOCATION_TYPE_IF([[
+]AT_CXX_IF([AT_LOCATION_TYPE_IF([[
 %initial-action
 {
   @$.first.l = @$.first.c = 1;
@@ -333,7 +333,7 @@ power (int base, int exponent)
   return res;
 }
 
-]AT_SKEL_CC_IF(
+]AT_CXX_IF(
 [AT_LOCATION_TYPE_IF([[
 namespace
 {
@@ -354,12 +354,12 @@ namespace
 [AT_CALC_LEX
 AT_CALC_MAIN])])
 
-AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.c]AT_SKEL_CC_IF([[c]])],
+AT_DEFINES_IF([AT_DATA_SOURCE([[calc-lex.]AT_LANG_EXT],
-[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
+[[#include "calc.]AT_LANG_HDR["
 
 ]AT_CALC_LEX])
-AT_DATA_SOURCE([[calc-main.c]AT_SKEL_CC_IF([[c]])],
+AT_DATA_SOURCE([[calc-main.]AT_LANG_EXT],
-[[#include "calc.h]AT_SKEL_CC_IF([[h]])["
+[[#include "calc.]AT_LANG_HDR["
 
 ]AT_CALC_MAIN])
 ])

tests/conflicts.at

@@ -405,17 +405,17 @@ AT_SETUP([[parse.error=verbose and consistent errors: ]$1])
 AT_BISON_OPTION_PUSHDEFS([$1])
 
 m4_pushdef([AT_YYLEX_PROTOTYPE],
-[AT_SKEL_CC_IF([[int yylex (yy::parser::semantic_type *lvalp)]],
+[AT_CXX_IF([[int yylex (yy::parser::semantic_type *lvalp)]],
-               [[int yylex (YYSTYPE *lvalp)]])])
+           [[int yylex (YYSTYPE *lvalp)]])])
 
-AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
+AT_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
-[AT_SKEL_JAVA_IF([[
+[AT_JAVA_IF([[
 
 %code imports {
   import java.io.IOException;
 }]], [[
 
-%code {]AT_SKEL_CC_IF([[
+%code {]AT_CXX_IF([[
   #include <string>]], [[
   #include <assert.h>
   #include <stdio.h>
@@ -424,7 +424,7 @@ AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
   #define USE(Var)
 }
 
-]AT_SKEL_CC_IF([[%defines]], [[%define api.pure]])])[
+]AT_CXX_IF([[%defines]], [[%define api.pure]])])[
 
 ]AT_YACC_IF([[
 %code {
@@ -442,11 +442,11 @@ AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
 
 ]$2[
 
-]AT_SKEL_JAVA_IF([[%code lexer {]], [[%%]])[
+]AT_JAVA_IF([[%code lexer {]], [[%%]])[
 
 /*--------.
 | yylex.  |
-`--------*/]AT_SKEL_JAVA_IF([[
+`--------*/]AT_JAVA_IF([[
 
 public String input = "]$3[";
 public int index = 0;
@@ -469,7 +469,7 @@ public Object getLVal ()
   return *input++;
 }]])[
 ]AT_YYERROR_DEFINE[
-]AT_SKEL_JAVA_IF([[
+]AT_JAVA_IF([[
 };
 
 %%]])[
@@ -486,8 +486,8 @@ m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
                                   $5, [a],  [[, expecting 'a']],
                                   $5, [b],  [[, expecting 'b']])])
 
-AT_SKEL_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]],
+AT_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]],
-                [AT_PARSER_CHECK([[./input]], [[1]]]),
+           [AT_PARSER_CHECK([[./input]], [[1]]]),
 [[]],
 [[syntax error, unexpected ]$4[]AT_EXPECTING[
 ]])

tests/local.at

@@ -145,21 +145,21 @@ m4_pushdef([AT_DEFINES_IF],
 [m4_bmatch([$3], [%defines], [$1], [$2])])
 m4_pushdef([AT_DEBUG_IF],
 [m4_bmatch([$3], [%debug\|%define parse.trace], [$1], [$2])])
-m4_pushdef([AT_SKEL_CC_IF],
+m4_pushdef([AT_CXX_IF],
 [m4_bmatch([$3], [%language "[Cc]\+\+"\|%skeleton "[a-z0-9]+\.cc"], [$1], [$2])])
-m4_pushdef([AT_SKEL_JAVA_IF],
+m4_pushdef([AT_JAVA_IF],
 [m4_bmatch([$3], [%language "[Jj][Aa][Vv][Aa]"\|%skeleton "[a-z0-9]+\.java"], [$1], [$2])])
 # The target language: "c", "c++", or "java".
 m4_pushdef([AT_LANG],
-[AT_SKEL_JAVA_IF([java],
+[AT_JAVA_IF([java],
-                 [AT_SKEL_CC_IF([c++],
+            [AT_CXX_IF([c++],
-                                [c])])])
+                       [c])])])
 m4_pushdef([AT_GLR_IF],
 [m4_bmatch([$3], [%glr-parser\|%skeleton "glr\..*"], [$1], [$2])])
 m4_pushdef([AT_LALR1_CC_IF],
-[AT_SKEL_CC_IF([AT_GLR_IF([$2], [$1])], [$2])])
+[AT_CXX_IF([AT_GLR_IF([$2], [$1])], [$2])])
 m4_pushdef([AT_GLR_CC_IF],
-[AT_SKEL_CC_IF([AT_GLR_IF([$1], [$2])], [$2])])
+[AT_CXX_IF([AT_GLR_IF([$1], [$2])], [$2])])
 # Using yacc.c?
 m4_pushdef([AT_YACC_IF],
 [m4_bmatch([$3], [%language\|%glr-parser\|%skeleton], [$2], [$1])])
@@ -239,13 +239,13 @@ m4_pushdef([AT_YYERROR_SEES_LOC_IF],
 # are using the C++ parsers.
 m4_pushdef([AT_PURE_LEX_IF],
 [AT_PURE_IF([$1],
-            [AT_SKEL_CC_IF([$1], [$2])])])
+            [AT_CXX_IF([$1], [$2])])])
 
 m4_pushdef([AT_YYSTYPE],
-[AT_SKEL_CC_IF([AT_NAMESPACE[::parser::semantic_type]],
+[AT_CXX_IF([AT_NAMESPACE[::parser::semantic_type]],
                [AT_API_PREFIX[STYPE]])])
 m4_pushdef([AT_YYLTYPE],
-[AT_SKEL_CC_IF([AT_NAMESPACE[::parser::location_type]],
+[AT_CXX_IF([AT_NAMESPACE[::parser::location_type]],
                [AT_API_PREFIX[LTYPE]])])
 
 
@@ -274,7 +274,7 @@ AT_PURE_LEX_IF(
 
 # Handle the different types of location components.
 
-AT_SKEL_CC_IF(
+AT_CXX_IF(
   [AT_LOCATION_TYPE_IF(
     [AT_LOC_PUSHDEF([first.l], [first.c], [last.l], [last.c])],
     [AT_LOC_PUSHDEF([begin.line], [begin.column], [end.line], [end.column])])],
@@ -317,9 +317,9 @@ m4_popdef([AT_PARAM_IF])
 m4_popdef([AT_LEXPARAM_IF])
 m4_popdef([AT_YACC_IF])
 m4_popdef([AT_GLR_IF])
-m4_popdef([AT_SKEL_CC_IF])
+m4_popdef([AT_CXX_IF])
 m4_popdef([AT_LANG])
-m4_popdef([AT_SKEL_JAVA_IF])
+m4_popdef([AT_JAVA_IF])
 m4_popdef([AT_GLR_CC_IF])
 m4_popdef([AT_LALR1_CC_IF])
 m4_popdef([AT_DEFINES_IF])
@@ -854,8 +854,8 @@ m4_define([AT_LANG_HDR(c++)],  [hh])
 # Compile OUTPUT.y to OUTPUT.c, OUTPUT.cc, or OUTPUT.java, and then
 # compile it to OUTPUT or OUTPUT.class.  If OTHER is specified, compile
 # OUTPUT-OTHER.c, OUTPUT-OTHER.cc, or OUTPUT-OTHER.java to OUTPUT or
-# OUTPUT.java along with it.  Relies on AT_SKEL_CC_IF and
+# OUTPUT.java along with it.  Relies on AT_CXX_IF and
-# AT_SKEL_JAVA_IF.
+# AT_JAVA_IF.
 m4_define([AT_FULL_COMPILE],
 [AT_BISON_CHECK([-o $1.AT_LANG_EXT $1.y])
  AT_LANG_COMPILE([$1],

tests/regression.at

@@ -1565,7 +1565,7 @@ exp: 'a' { fprintf (stdout, "x: %d, y: %d\n", x, y); };
 ]AT_YYERROR_DEFINE[
 ]AT_YYLEX_DEFINE(["a"])[
 
-]AT_SKEL_CC_IF(
+]AT_CXX_IF(
 [int
 yyparse (int x, int y)
 {

tests/synclines.at

@@ -399,7 +399,7 @@ AT_DATA([\"\\\"\".c],
 [[int main() { return 0; }
 ]])
 
-AT_CHECK([AT_SKEL_CC_IF([$CXX $CXXFLAGS], [$CC $CFLAGS]) $CPPFLAGS \"\\\"\".c -o \"\\\"\" ||
+AT_CHECK([AT_CXX_IF([$CXX $CXXFLAGS], [$CC $CFLAGS]) $CPPFLAGS \"\\\"\".c -o \"\\\"\" ||
           exit 77], [0], [ignore], [ignore])
 
 AT_DATA_GRAMMAR([\"\\\"\".y],
@@ -453,7 +453,7 @@ AT_DATA_GRAMMAR([input.y],
 exp: '0'
 ]])
 AT_BISON_CHECK([--no-lines -o input.AT_LANG_EXT -d input.y])
-AT_CHECK([[grep '#line' ]AT_SKEL_CC_IF([*.cc *.hh], [*.c *.h])], 1)
+AT_CHECK([[grep '#line'] *.AT_LANG_EXT *.AT_LANG_HDR], 1)
 AT_BISON_OPTION_POPDEFS
 
 AT_CLEANUP

tests/types.at

@@ -182,8 +182,8 @@ m4_foreach([b4_skel], [[yacc.c], [glr.c], [lalr1.cc], [glr.cc]],
              };
            }
            %token <up->ival> '1' '2'
-           %printer { ]AT_SKEL_CC_IF([[yyo << $$]],
+           %printer { ]AT_CXX_IF([[yyo << $$]],
-                                     [[fprintf (yyo, "%d", $$)]])[; } <up->ival>
+                                 [[fprintf (yyo, "%d", $$)]])[; } <up->ival>
            ],
           ['1' '2'
            {
@@ -238,10 +238,10 @@ m4_foreach([b4_skel], [[yacc.c], [glr.c], [lalr1.cc], [glr.cc]],
            %define api.value.type union],
           [%token <int> ONE 101;
            %token <float> TWO 102 THREE 103;
-           %printer { ]AT_SKEL_CC_IF([[yyo << $$]],
+           %printer { ]AT_CXX_IF([[yyo << $$]],
-                                     [[fprintf (yyo, "%d", $$)]])[; } <int>
+                                 [[fprintf (yyo, "%d", $$)]])[; } <int>
-           %printer { ]AT_SKEL_CC_IF([[yyo << $$]],
+           %printer { ]AT_CXX_IF([[yyo << $$]],
-                                     [[fprintf (yyo, "%f", $$)]])[; } <float>
+                                 [[fprintf (yyo, "%f", $$)]])[; } <float>
           ],
           [ONE TWO THREE { printf ("%d %2.1f %2.1f\n", $1, $2, $3); }],
           [{ 101, 102, 103, EOF }],