[Automake-commit] [SCM] GNU Automake branch, master, updated. v1.11-1788-g587ff34

[Stefano Lattarini]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Automake".

http://git.sv.gnu.org/gitweb/?p=automake.git;a=commitdiff;h=587ff343ab8d0d7781775eba4e65a4db9d61cc98

The branch, master has been updated
       via  587ff343ab8d0d7781775eba4e65a4db9d61cc98 (commit)
       via  59c4e1c0d6c687d5f46e2393374db8b98c0a8675 (commit)
       via  6f161e0dfd28854195c9ad6c16219a23ca1097e8 (commit)
       via  7700b7035c6ad8cff1c4fd37d61154f3766b9f09 (commit)
       via  a354283eb7d49574b6c4390fb338b78906a446ed (commit)
       via  8de4149eb90140c81e19b375249cba4659c03f6d (commit)
       via  92174b5abeaa235f97cf65783964ec6d50d43a76 (commit)
      from  98763f1508a86d98b8891ae422dc20315b3a3cbb (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 587ff343ab8d0d7781775eba4e65a4db9d61cc98
Merge: 98763f1 59c4e1c
Author: Stefano Lattarini <address@hidden>
Date:   Mon Jan 23 09:57:23 2012 +0100

    Merge branch 'compilers-for-testsuite'
    
    * compilers-for-testsuite:
      readme: how to run the testsuite with cross-compilers
      tests: no need to unset CFLAGS in tests requiring 'gcc' anymore
      test defs: allow compilers to be auto-selected on user's request
      test defs: substitute compilers and flags found at configure time
      test defs: setup `*FLAGS' variables for GNU compilers
      configure: search generic compilers for use in the tests

commit 59c4e1c0d6c687d5f46e2393374db8b98c0a8675
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    readme: how to run the testsuite with cross-compilers
    
    * tests/README: Suggest a better way to run the automake testsuite
    with cross-compilers -- that is, configuring the Automake source
    tree with proper `--build' and `--host' configure option.  And
    yes, specifying both these options (not only `--host') is indeed
    required to avoid spurious failures in corner cases.
    When you call configure with the `--host' option but without the
    `--build' option, configure tries to auto-detect whether you are
    cross-compiling or not, by trying to run a generated executable.
    That test might spuriously "succeed" in some corner cases (e.g.,
    Cygwin is able to run non-Cygwin apps).  In fact, generally, it
    can be the case that a cross-compilation is not detected as a
    cross anymore just because someone has installed an emulator; as
    an example, think of what can happen on a GNU/Linux system that
    is configured (through the use of the binfmt_misc kernel module)
    to execute PE executables (compiled for MS-DOS or Windows) through
    Wine *automatically*.  In conclusion, configure needs to be used
    as recommended in the documentation (i.e., by specifying *both*
    `--host' and `--build' instead of just one of them) to not have
    the build fall into any of a number of weird traps.
    * tests/defs (cross_compiling): Improve comments.
    
    Co-authored-by: Peter Rosin <address@hidden>

commit 6f161e0dfd28854195c9ad6c16219a23ca1097e8
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    tests: no need to unset CFLAGS in tests requiring 'gcc' anymore
    
    * tests/ccnoco.test: Since this test have "gcc" in $required,
    there is no need to manually nullify the CFLAGS variable, since
    now `tests/defs' should automatically re-define that to a value
    appropriate for gcc.
    * tests/ccnoco3.test: Likewise.

commit 7700b7035c6ad8cff1c4fd37d61154f3766b9f09
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    test defs: allow compilers to be auto-selected on user's request
    
    In the recent changes, by pre-setting the required compilers for
    the `configure' scripts launched by the test scripts, we have
    slightly reduced the coverage of autoconf/automake code aimed at
    automatically detecting said compilers.  This commit restore such
    coverage, by allowing the user to instruct the testsuite *not* to
    preset the testsuite compiler(s).
    
    * tests/defs (cc): If $CC is set to the special value "autodetect"
    or "autodetected", don't export the configure-detected CC, CFLAGS
    and CPPFLAGS variables; rather, unset them.
    (c++): Likewise, but for CXX, CXXFLAGS and CPPFLAGS instead.
    (fortran): Likewise, but for FC and FCFLAGS instead.
    (fortran77): Likewise, but for F77 and FFLAGS instead.
    (require_compiler_): New function, to reduce code duplication.

commit a354283eb7d49574b6c4390fb338b78906a446ed
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    test defs: substitute compilers and flags found at configure time
    
    * tests/Makefile.am (do_subst): Also substitute CC, CXX, F77, FC,
    CPPFLAGS, CFLAGS, CXXFLAGS, FCFLAGS and FFLAGS.
    * tests/defs-static.in: Define those variables, allowing for
    overrides from the environment.
    * tests/defs (for tool in $required): Export (subsets of) those
    variables when the stuff in `$required' calls for it.
    Add related explanatory comments.

commit 8de4149eb90140c81e19b375249cba4659c03f6d
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    test defs: setup `*FLAGS' variables for GNU compilers
    
    * configure.ac: Setup some `*FLAGS' variables for use by the
    GNU compilers in our testsuite.  For example, use `GNU_CFLAGS'
    instead of `CFLAGS', and so on for similar variables.  This
    is especially useful in case the compilers found or defined
    at configure time are not the GNU ones.
    * tests/defs-static.in: Initialize those same variables with
    the values set at configure time, but allowing overrides
    from the environment.
    * tests/Makefile.am (do_subst): Process configure-style
    substitutions of those variables (e.g., address@hidden@').
    * tests/defs: When a GNU compiler is required, override the
    corresponding generic `*FLAGS' variable with the GNU-specific
    variant (e.g., redefine `$CFLAGS' to take the value of
    `$GNU_CFLAGS').

commit 92174b5abeaa235f97cf65783964ec6d50d43a76
Author: Stefano Lattarini <address@hidden>
Date:   Wed Dec 28 11:40:20 2011 +0100

    configure: search generic compilers for use in the tests
    
    * configure.ac: Look for "generic" C, C++ and Fortran compilers,
    with the aim of starting to use them in the testsuite (this will
    be done in future changes).  This is more tricky than it seems,
    since we don't want to abort the whole configure script even if
    no one of those compilers is available (after all, they're only
    needed by the testsuite, not to build automake), but currently
    autoconf doesn't offer an easy way to obtain this behaviour.
    We prefer non-GNU compilers to the GNU ones, to ensure better
    coverage "in the wild".

-----------------------------------------------------------------------

Summary of changes:
 configure.ac         |  111 +++++++++++++++++++++++++++++++++++++++++++++++++-
 tests/Makefile.am    |   13 ++++++
 tests/README         |   24 +++++-----
 tests/ccnoco.test    |    4 --
 tests/ccnoco3.test   |    4 --
 tests/defs           |   91 +++++++++++++++++++++++++++++++++-------
 tests/defs-static.in |   18 ++++++++
 7 files changed, 228 insertions(+), 37 deletions(-)

diff --git a/configure.ac b/configure.ac
index ddd6b2b..aea14ad 100644
--- a/configure.ac
+++ b/configure.ac
@@ -38,8 +38,11 @@ AC_SUBST([am_AUTORECONF], ["${AUTORECONF-autoreconf}"])
 AC_SUBST([am_AUTOHEADER], ["${AUTOHEADER-autoheader}"])
 AC_SUBST([am_AUTOUPDATE], ["${AUTOUPDATE-autoupdate}"])
 
+dnl We call AC_PROG_CC in an unusual way, and only for use in our
+dnl testsuite, so also use `no-dependencies' and `no-define' among
+dnl the automake options to avoid bloating and potential problems.
 AM_INIT_AUTOMAKE([1.10a dist-xz filename-length-max=99 color-tests
-                 parallel-tests silent-rules])
+                 parallel-tests silent-rules no-define no-dependencies])
 
 # The API version is the base version.  We must guarantee
 # compatibility for all releases with the same API version.
@@ -209,6 +212,112 @@ if test $am_cv_sh_errexit_works = no; then
 fi
 AC_SUBST([sh_errexit_works], [$am_cv_sh_errexit_works])
 
+
+###########################################################################
+
+# Look for C, C++ and fortran compilers to be used in the testsuite.
+
+dnl We don't want to abort our configuration script if no C compiler is
+dnl available, as such a compiler is only required to run part of the
+dnl testsuite, not to build or install Automake.  Ditto for C++, Fortran
+dnl and Fortran 77 compilers.  Unfortunately, autoconf does not offer an
+dnl easy way to obtain this behaviour, so we'll need a few hacks.
+
+dnl We want the body of this macro to expand as a single shell statement,
+dnl thus we wrap it into { ... } brackets.
+AC_DEFUN([_AM_WRAP_MSG_ERROR], [ {
+  AC_MSG_WARN([$1])
+  am__failed=yes
+  break
+} ])
+
+AC_DEFUN([_AM_COMPILER_CAN_FAIL], [
+  m4_pushdef([AC_MSG_FAILURE], m4_defn([_AM_WRAP_MSG_ERROR]))
+  m4_pushdef([AC_MSG_ERROR],   m4_defn([_AM_WRAP_MSG_ERROR]))
+  am__failed=no
+  while :; do
+     $1
+     break
+  done
+  AS_IF([test $am__failed = yes], [$2])
+  # We have to clear these cache variables, so that future checks on
+  # compilers for different languages won't be confused.
+  unset ac_cv_objext ac_cv_exeext
+  # We also need to meddle with the autoconf internals to ensure that
+  # checks to find object and executable extensions will be run anew.
+  # FIXME: In the long run, the better thing to do would be to fix
+  # FIXME: autoconf instead ...
+  m4_undefine([m4_provide(_AC_COMPILER_OBJEXT)])
+  m4_undefine([m4_provide(_AC_COMPILER_EXEEXT)])
+  m4_popdef([AC_MSG_FAILURE])
+  m4_popdef([AC_MSG_ERROR])
+])
+
+# Prefer generic compilers to GNU ones when possible.  This will ensure
+# more testsuite coverage "in the wild".
+# Note that we don't look for the MSVC C/C++ compiler here.  This is
+# deliberate; for more discussion an rationale, see:
+# <http://lists.gnu.org/archive/html/automake-patches/2012-01/msg00130.html>
+
+# C compiler.
+_AM_COMPILER_CAN_FAIL([AC_PROG_CC([cc gcc])], [CC=false])
+AS_IF([test x"$GCC" = x"yes"], [am_CC_is_GNU=yes], [am_CC_is_GNU=no])
+
+# The list of C++ compilers here has been copied, pasted and edited
+# from `lib/autoconf/c.m4:AC_PROG_CXX' in the Autoconf distribution.
+# Keep it in sync, or better again, find out a way to avoid this code
+# duplication.
+_AM_COMPILER_CAN_FAIL([AC_PROG_CXX(dnl
+  [aCC CC FCC KCC RCC xlC_r xlC c++ cxx cc++ gpp g++])],
+  [CXX=false])
+AS_IF([test x"$GXX" = x"yes"], [am_CXX_is_GNU=yes], [am_CXX_is_GNU=no])
+
+# The lists of Fortran compilers here has been copied, pasted and edited
+# from file `lib/autoconf/fortran.m4' in the Autoconf distribution.
+# Keep it in sync, or better again, find out a way to avoid this code
+# duplication.
+
+_AM_COMPILER_CAN_FAIL([AC_PROG_FC(dnl
+  [xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor] dnl
+  [xlf90 f90 pgf90 pghpf epcf90 g95 gfortran])],
+  [FC=false])
+# FIXME this won't work as expected until we can assume autoconf 2.69 :-(
+AS_IF([test x"$GFC" = x"yes"], [am_FC_is_GNU=yes], [am_FC_is_GNU=no])
+
+_AM_COMPILER_CAN_FAIL([AC_PROG_F77(dnl
+  [xlf f77 frt pgf77 cf77 fort77 fl32 af77 g77 gfortran])],
+  [F77=false])
+AS_IF([test x"$G77" = x"yes"], [am_F77_is_GNU=yes], [am_F77_is_GNU=no])
+
+# Some tests will need the GNU compilers.  Searching for them here would
+# be overkill, since our testsuite already handles their search and setup
+# pretty well.  However, in case the compilers detected above at configure
+# time are not the GNU ones, we cannot use the values of CFLAGS, CXXFLAGS,
+# FCFLAGS and FFLAGS detected for them with the GNU compilers too, since
+# it's likely they won't be compatible.  So we allow the user to define
+# variants of this variables for the GNU compilers separately.
+
+test $am_CC_is_GNU = yes && GNU_CFLAGS=${GNU_CFLAGS-$CFLAGS}
+AC_ARG_VAR([GNU_CFLAGS], [GNU C compiler flags])
+
+test $am_CXX_is_GNU = yes && GNU_CXXFLAGS=${GNU_CXXFLAGS-$CXXFLAGS}
+AC_ARG_VAR([GNU_CXXFLAGS], [GNU C++ compiler flags])
+
+test $am_F77_is_GNU = yes && GNU_FCFLAGS=${GNU_FCFLAGS-$FCFLAGS}
+AC_ARG_VAR([GNU_FCFLAGS], [GNU Fortran compiler flags])
+
+test $am_FC_is_GNU = yes && GNU_FFLAGS=${GNU_FFLAGS-$FFLAGS}
+AC_ARG_VAR([GNU_FFLAGS], [GNU Fortran 77 compiler flags])
+
+# If we have been able to find at least a working compiler above, we
+# know what the object and executable extensions for this platform are.
+OBJEXT=${ac_cv_objext-UNKNOWN}
+EXEEXT=${ac_cv_exeext-UNKNOWN}
+AC_SUBST([OBJEXT])
+AC_SUBST([EXEEXT])
+
+###########################################################################
+
 AC_CONFIG_FILES([
   Makefile
   contrib/Makefile
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 0ccbb45..dc16ad5 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -138,6 +138,19 @@ do_subst = sed \
   -e 's|@address@hidden|$(PERL)|g' \
   -e 's|@address@hidden|$(EGREP)|g' \
   -e 's|@address@hidden|$(FGREP)|g' \
+  -e 's|@address@hidden|$(CPPFLAGS)|g' \
+  -e 's|@address@hidden|$(CC)|g' \
+  -e 's|@address@hidden|$(CFLAGS)|g' \
+  -e 's|@address@hidden|$(CXX)|g' \
+  -e 's|@address@hidden|$(CXXFLAGS)|g' \
+  -e 's|@address@hidden|$(F77)|g' \
+  -e 's|@address@hidden|$(FFLAGS)|g' \
+  -e 's|@address@hidden|$(FC)|g' \
+  -e 's|@address@hidden|$(FCFLAGS)|g' \
+  -e 's|@address@hidden|$(GNU_CFLAGS)|g' \
+  -e 's|@address@hidden|$(GNU_CXXFLAGS)|g' \
+  -e 's|@address@hidden|$(GNU_FFLAGS)|g' \
+  -e 's|@address@hidden|$(GNU_FCFLAGS)|g' \
   -e 's|@address@hidden|$(TEX)|g' \
   -e 's|@address@hidden|$(MODIFICATION_DELAY)|g' \
   -e 's|@address@hidden|$(am_AUTOCONF)|g' \
diff --git a/tests/README b/tests/README
index 64e977a..bfd5562 100644
--- a/tests/README
+++ b/tests/README
@@ -29,18 +29,18 @@ Running the tests
     make -k check TESTS="foo.test bar.test"             (GNU make)
     env TESTS="foo.test bar.test" make -e -k check      (non-GNU make)
 
- To run the tests in cross-compilation mode:
-
-    make -k check host_alias="$host_alias"              (GNU make)
-    env host_alias="$host_alias" make -e -k check       (non-GNU make)
-
- Here `$host_alias' should be defined to a proper value different from
- configure-determined `$build_alias', and should refer to a set of
- cross-compilers you have available on your system; for example, if
- on Linux you have a set of MinGW-targeted cross-compilers named
- 'i586-mingw32msvc-cc', 'i586-mingw32msvc-c++', etc., you could use:
-
-   make -k check host_alias='i586-mingw32msvc'
+ To run the tests in cross-compilation mode, you should first configure
+ the automake source tree to a cross-compilation setup.  For example, to
+ run with a Linux-to-MinGW cross compiler, you will need something like
+ this:
+
+   ./configure --host i586-mingw32msvc --build i686-pc-linux-gnu
+
+ To avoid possible spurious error, you really have to *explicitly* specify
+ `--build' in addition to `--host'; the `lib/config.guess' script can help
+ determine the correct value to pass to `--build'.
+ Then you can just run the testsuite in the usual way, and the test cases
+ using a compiler should automatically use a cross-compilation setup.
 
 
 Interpretation
diff --git a/tests/ccnoco.test b/tests/ccnoco.test
index bcd18fc..780ffe6 100755
--- a/tests/ccnoco.test
+++ b/tests/ccnoco.test
@@ -59,10 +59,6 @@ END
 
 chmod +x Mycomp
 
-# Ignore user CFLAGS.
-CFLAGS=
-export CFLAGS
-
 # Make sure the compiler doesn't understand `-c -o'
 CC=`pwd`/Mycomp
 export CC
diff --git a/tests/ccnoco3.test b/tests/ccnoco3.test
index 2a32f6b..82fb320 100755
--- a/tests/ccnoco3.test
+++ b/tests/ccnoco3.test
@@ -59,10 +59,6 @@ END
 
 chmod +x Mycomp
 
-# Ignore user CFLAGS.
-CFLAGS=
-export CFLAGS
-
 $ACLOCAL
 $AUTOCONF
 $AUTOMAKE --copy --add-missing
diff --git a/tests/defs b/tests/defs
index d6bc51e..40842cd 100644
--- a/tests/defs
+++ b/tests/defs
@@ -236,6 +236,13 @@ unset am_funcs_file
 # tests (or portions of them) that requires a native compiler.
 cross_compiling ()
 {
+  # Quoting from the autoconf manual:
+  #   ... [$host_alias and $build both] default to the result of running
+  #   config.guess, unless you specify either --build or --host.  In
+  #   this case, the default becomes the system type you specified.
+  #   If you specify both, *and they're different*, configure enters
+  #   cross compilation mode (so it doesn't run any tests that require
+  #   execution).
   test x"$host_alias" != x && test x"$build_alias" != x"$host_alias"
 }
 
@@ -616,6 +623,56 @@ fetch_tap_driver ()
 # use the perl implementation by default for the moment.
 am_tap_implementation=${am_tap_implementation-shell}
 
+# Usage: require_compiler_ {cc|c++|fortran|fortran77}
+require_compiler_ ()
+{
+  case $# in
+    0) fatal_ "require_compiler_: missing argument";;
+    1) ;;
+    *) fatal_ "require_compiler_: too many arguments";;
+  esac
+  case $1 in
+    cc)
+      am__comp_lang="C"
+      am__comp_var=CC
+      am__comp_flag_vars='CFLAGS CPPFLAGS'
+      ;;
+    c++)
+      am__comp_lang="C++"
+      am__comp_var=CXX
+      am__comp_flag_vars='CXXFLAGS CPPFLAGS'
+      ;;
+    fortran)
+      am__comp_lang="Fortran"
+      am__comp_var=FC
+      am__comp_flag_vars='FCFLAGS'
+      ;;
+    fortran77)
+      am__comp_lang="Fortran 77"
+      am__comp_var=F77
+      am__comp_flag_vars='FFLAGS'
+      ;;
+  esac
+  shift
+  eval "am__comp_prog=\${$am__comp_var}" \
+    || fatal_ "expanding \${$am__comp_var} in require_compiler_"
+  case $am__comp_prog in
+    "")
+      fatal_ "botched configuration: \$$am__comp_var is empty";;
+    false)
+      skip_all_ "no $am__comp_lang compiler available";;
+    autodetect|autodetected)
+      # Let the ./configure commands in the test script try to determine
+      # these automatically.
+      unset $am__comp_var $am__comp_flag_vars;;
+    *)
+      # Pre-set these for the ./configure commands in the test script.
+      export $am__comp_var $am__comp_flag_vars;;
+  esac
+  # Delete private variables.
+  unset am__comp_lang am__comp_prog am__comp_var am__comp_flag_vars
+}
+
 ## ----------------------------------------------------------- ##
 ##  Checks for required tools, and additional setups (if any)  ##
 ##  required by them.                                          ##
@@ -636,14 +693,8 @@ do
   # Check that each required tool is present.
   case $tool in
     :) ;;
-    cc)
-      test "$CC"  = false && skip_all_ "no C compiler available";;
-    c++)
-      test "$CXX" = false && skip_all_ "no C++ compiler available";;
-    fortran)
-      test "$FC"  = false && skip_all_ "no Fortran compiler available";;
-    fortran77)
-      test "$F77" = false && skip_all_ "no Fortran 77 compiler available";;
+    cc|c++|fortran|fortran77)
+      require_compiler_ $tool;;
     xsi-shell)
       require_xsi "$SHELL";;
     xsi-bin-sh)
@@ -663,7 +714,11 @@ do
       ;;
     cl)
       CC=cl
-      export CC
+      # Don't export CFLAGS, as that could have been initialized to only
+      # work with the C compiler detected at configure time.  If the user
+      # wants CFLAGS to also influence `cl', he can still export CFLAGS
+      # in the environment "by hand" before calling the testsuite.
+      export CC CPPFLAGS
       echo "$me: running $CC -?"
       $CC -? || skip_all_ "Microsoft C compiler \`$CC' not available"
       ;;
@@ -699,7 +754,8 @@ do
       # has defined CC in his environment, otherwise ./configure will
       # prefer gcc to other compilers.
       CC=${am__tool_prefix}gcc
-      export CC
+      CFLAGS=$GNU_CFLAGS
+      export CC CFLAGS CPPFLAGS
       echo "$me: running $CC --version"
       $CC --version || skip_all_ "GNU C compiler not available"
       echo "$me: running $CC -v"
@@ -715,7 +771,8 @@ do
       ;;
     g++)
       CXX=${am__tool_prefix}g++
-      export CXX
+      CXXFLAGS=$GNU_CXXFLAGS
+      export CXX CXXFLAGS CPPFLAGS
       echo "$me: running $CXX --version"
       $CXX --version || skip_all_ "GNU C++ compiler not available"
       echo "$me: running $CXX -v"
@@ -723,31 +780,33 @@ do
       ;;
     gfortran)
       FC=${am__tool_prefix}gfortran
-      export FC
+      FCFLAGS=$GNU_FCFLAGS
+      export FC FCFLAGS
       echo "$me: running $FC --version"
       $FC --version || skip_all_ "GNU Fortran compiler not available"
       echo "$me: running $FC -v"
       $FC -v || skip_all_ "botched installation for GNU Fortran compiler"
       case " $required " in
         *\ g77\ *) ;;
-        *) F77=$FC; export F77;;
+        *) F77=$FC FFLAGS=$FCFLAGS; export F77 FFLAGS;;
       esac
       ;;
     g77)
       F77=${am__tool_prefix}g77
-      export F77
+      FFLAGS=$GNU_FFLAGS
+      export F77 FFLAGS
       echo "$me: running $F77 --version"
       $F77 --version || skip_all_ "GNU Fortran 77 compiler not available"
       echo "$me: running $F77 -v"
       $F77 -v || skip_all_ "botched installation for GNU Fortran 77 compiler"
       case " $required " in
         *\ gfortran\ *) ;;
-        *) FC=$F77; export FC;;
+        *) FC=$F77 FCFLAGS=$FFLAGS; export FC FCFLAGS;;
       esac
       ;;
     icc)
       CC=icc
-      export CC
+      export CC CPPFLAGS # But not CFLAGS (see comments for `cl' above).
       # There is no way to ask *only* the compiler's version.
       # This tool always wants to do something (by default
       # it will try link *nothing* and complain it cannot find
diff --git a/tests/defs-static.in b/tests/defs-static.in
index 2bae9c1..b79e399 100644
--- a/tests/defs-static.in
+++ b/tests/defs-static.in
@@ -194,6 +194,24 @@ AUTORECONF="$AUTORECONF -B /no/such/dir"
 EGREP=${AM_TESTSUITE_EGREP-'@EGREP@'}
 FGREP=${AM_TESTSUITE_FGREP-'@FGREP@'}
 
+# Compilers and their flags.  These can point to non-GNU compilers (and
+# on non-Linux and non-BSD systems, they probably will).
+CC=${AM_TESTSUITE_CC-${CC-'@CC@'}}
+CXX=${AM_TESTSUITE_CXX-${CXX-'@CXX@'}}
+F77=${AM_TESTSUITE_F77-${F77-'@F77@'}}
+FC=${AM_TESTSUITE_FC-${FC-'@FC@'}}
+CFLAGS=${AM_TESTSUITE_CFLAGS-${CFLAGS-'@CFLAGS@'}}
+CXXFLAGS=${AM_TESTSUITE_CXXFLAGS-${CXXFLAGS-'@CXXFLAGS@'}}
+FCFLAGS=${AM_TESTSUITE_FCFLAGS-${FCFLAGS-'@FCFLAGS@'}}
+FFLAGS=${AM_TESTSUITE_FFLAGS-${FFLAGS-'@FFLAGS@'}}
+CPPFLAGS=${AM_TESTSUITE_CPPFLAGS-${CPPFLAGS-'@CPPFLAGS@'}}
+
+# Flags for the GNU compilers.
+GNU_FFLAGS=${AM_TESTSUITE_GNU_FFLAGS-${GNU_FFLAGS-'@GNU_FFLAGS@'}}
+GNU_FCFLAGS=${AM_TESTSUITE_GNU_FCFLAGS-${GNU_FCFLAGS-'@GNU_FCFLAGS@'}}
+GNU_CXXFLAGS=${AM_TESTSUITE_GNU_CXXFLAGS-${GNU_CXXFLAGS-'@GNU_CXXFLAGS@'}}
+GNU_CFLAGS=${AM_TESTSUITE_GNU_CFLAGS-${GNU_CFLAGS-'@GNU_CFLAGS@'}}
+
 # No all versions of Tex support `--version', so we use a configure
 # check to decide if tex is available.  This decision is embodied in
 # this variable.


hooks/post-receive
-- 
GNU Automake