diff options
| -rw-r--r-- | doc/autoconf.texi | 45 | ||||
| -rw-r--r-- | lib/autoconf/c.m4 | 444 | ||||
| -rw-r--r-- | tests/data/ax_prog_cc_for_build_v18.m4 | 139 | ||||
| -rw-r--r-- | tests/data/ax_prog_cxx_for_build_v3.m4 | 110 | ||||
| -rw-r--r-- | tests/data/gnulib_std_gnu11_2020_08_17.m4 | 824 | ||||
| -rw-r--r-- | tests/foreign.at | 215 | ||||
| -rw-r--r-- | tests/local.mk | 7 |
7 files changed, 1384 insertions, 400 deletions
diff --git a/doc/autoconf.texi b/doc/autoconf.texi index db1e0f46..b65d698e 100644 --- a/doc/autoconf.texi +++ b/doc/autoconf.texi @@ -7453,7 +7453,6 @@ makes this invalid. That is why Autoconf stopped issuing @evindex CFLAGS @ovindex CC @ovindex CFLAGS -@caindex prog_cc_stdc Determine a C compiler to use. If the environment variable @code{CC} is set, its value will be taken as @@ -7485,21 +7484,15 @@ default. (It is important to use this construct rather than a normal assignment, so that @code{CFLAGS} can still be overridden by the person building the package. @xref{Preset Output Variables}.) -If necessary, options are added to @code{CC} to enable support for ISO -Standard C features with extensions, preferring the newest C standard -that is supported. Currently the newest standard Autoconf knows how to -detect support for is ISO C 2011. After calling this macro you can -check whether the C compiler has been set to accept Standard C by -inspecting cache variables. If @code{ac_cv_prog_cc_c11} is set to any -value other than @samp{no} (including the empty string), then @code{CC} -can compile code as standard C 2011, and this mode has been enabled. -Otherwise, if @code{ac_cv_prog_cc_c99} is set to any value other than -@samp{no} (including the empty string), then @code{CC} can compile code -as standard C 1999, and this mode has been enabled. Otherwise, if -@code{ac_cv_prog_cc_c89} is set to any value other than @samp{no} -(including the empty string), then @code{CC} can compile code as -standard C 1989, and this mode has been enabled. Finally, if all -three variables are set to @samp{no}, then @code{CC} cannot compile +If necessary, options are added to @code{CC} to enable support for +ISO Standard C features with extensions, preferring the newest edition +of the C standard that is supported. Currently the newest edition +Autoconf knows how to detect support for is ISO C 2011. After calling +this macro you can check whether the C compiler has been set to accept +standard C by inspecting the shell variable @code{ac_prog_cc_stdc}. +Its value will be @samp{c11}, @samp{c99}, or @samp{c89}, respectively, +if the C compiler has been set to use the 2011, 1999, or 1990 edition of +the C standard, and @samp{no} if the compiler does not support compiling standard C at all. The tests for standard conformance are not comprehensive. They test the @@ -7890,17 +7883,15 @@ assignment, so that @code{CXXFLAGS} can still be overridden by the person building the package. @xref{Preset Output Variables}.) If necessary, options are added to @code{CXX} to enable support for -ISO Standard C++ features with extensions. ISO C++ 2011 is preferred -if the compiler supports it. After calling this macro, you can check -whether the C++ compiler has been set to accept standard C++ by -inspecting cache variables. If @code{ac_cv_prog_cxx_cxx11} is set to -any value other than @samp{no} (including the empty string), then -@code{CXX} can compile code as standard C++ 2011, and this mode has -been enabled. Otherwise, if @code{ac_cv_prog_cxx_cxx98} is set to -any value other than @samp{no} (including the empty string), then -@code{CXX} can compile code as standard C++ 1998, and this mode has -been enabled. Finally, if both variables are set to @samp{no}, then -@code{CXX} cannot compile standard C++ at all. +ISO Standard C++ features with extensions, preferring the newest edition +of the C++ standard that is supported. Currently the newest edition +Autoconf knows how to detect support for is ISO C++ 2011. After calling +this macro, you can check whether the C++ compiler has been set to +accept standard C++ by inspecting the shell variable @code{ac_prog_cc_stdc}. +Its value will be @samp{cxx11} or @samp{cxx98}, respectively, +if the C++ compiler has been set to use the 2011 or 1990 edition of the +C++ standard, and @samp{no} if the compiler does not support compiling +standard C++ at all. The tests for standard conformance are not comprehensive. They test the value of @code{__cplusplus} and a representative sample of the diff --git a/lib/autoconf/c.m4 b/lib/autoconf/c.m4 index 14240460..7ad6b4f7 100644 --- a/lib/autoconf/c.m4 +++ b/lib/autoconf/c.m4 @@ -498,19 +498,7 @@ else GCC= fi _AC_PROG_CC_G -dnl -dnl Set ac_prog_cc_stdc to the supported C version. -dnl Also set the documented variable ac_cv_prog_cc_stdc; -dnl its name was chosen when it was cached, but it is no longer cached. -_AC_PROG_CC_C11([ac_prog_cc_stdc=c11 - ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11], - [_AC_PROG_CC_C99([ac_prog_cc_stdc=c99 - ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99], - [_AC_PROG_CC_C89([ac_prog_cc_stdc=c89 - ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89], - [ac_prog_cc_stdc=no - ac_cv_prog_cc_stdc=no])])]) -dnl +_AC_PROG_CC_STDC_EDITION AC_LANG_POP(C)dnl ])# AC_PROG_CC @@ -745,13 +733,7 @@ else GXX= fi _AC_PROG_CXX_G -_AC_PROG_CXX_CXX11([ac_prog_cxx_stdcxx=cxx11 - ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 - ac_cv_prog_cxx_cxx98=$ac_cv_prog_cxx_cxx11], - [_AC_PROG_CXX_CXX98([ac_prog_cxx_stdcxx=cxx98 - ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98], - [ac_prog_cxx_stdcxx=no - ac_cv_prog_cxx_stdcxx=no])]) +_AC_PROG_CXX_STDCXX_EDITION AC_LANG_POP(C++)dnl ])# AC_PROG_CXX @@ -1496,114 +1478,170 @@ main (int argc, char **argv) ]])]) -# _AC_C_STD_TRY(STANDARD, TEST-PROGRAM-HOLDER, OPTION-LIST, -# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) -# -------------------------------------------------------------- -# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') -# by trying to compile the program in the shell variable TEST-PROGRAM-HOLDER. -# Caller is responsible for making sure this variable has been initialized. -# If compilation fails in the default mode, try again with each compiler -# option in the space-separated OPTION-LIST; if one helps, append it to CC. -# If eventually successful, run ACTION-IF-AVAILABLE, else ACTION-IF-UNAVAILABLE. -AC_DEFUN([_AC_C_STD_TRY], +# _AC_C_C89_OPTIONS +# ----------------- +# Whitespace-separated list of options that might put the C compiler +# into a mode conforming to ISO C1990 with extensions. Do not try +# "strictly conforming" modes (e.g. gcc's -std=c90); they break some +# systems' header files. If more than one option is needed, put +# shell quotes around the group. +# +# AIX circa 2003 -qlanglvl=extc89 +# old AIX -qlanglvl=ansi +# Ultrix, OSF/1, Tru64 -std +# HP-UX 10.20 and later -Ae +# HP-UX older versions -Aa -D_HPUX_SOURCE +# SVR4 -Xc -D__EXTENSIONS__ +m4_define([_AC_C_C89_OPTIONS], [ + -qlanglvl=extc89 + -qlanglvl=ansi + -std + -Ae + "-Aa -D_HPUX_SOURCE" + "-Xc -D__EXTENSIONS__" +]) + + +# _AC_C_C99_OPTIONS +# ----------------- +# Whitespace-separated list of options that might put the C compiler +# into a mode conforming to ISO C1999 with extensions. Do not try +# "strictly conforming" modes (e.g. gcc's -std=c99); they break some +# systems' header files. If more than one option is needed, put +# shell quotes around the group. +# +# GCC, Clang -std=gnu99 +# Intel ICC -std=c99, -c99 (deprecated) +# Note: because -std=c99 puts GCC in strictly conforming mode, +# this option must be tested *after* -std=gnu99. +# IRIX -c99 +# Tru64 -c99 +# IBM XL C -qlanglvl=extc1x (V12.1; does not pass C11 test) +# IBM XL C -qlanglvl=extc99 (pre-V12.1) +# HP cc -AC99 +# Solaris -D_STDC_C99= +# Note: acc's -xc99 option uses linker magic to define the external +# symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 +# behavior for C library functions. This is not wanted here, +# because it means that a single module compiled with -xc99 alters +# C runtime behavior for the entire program, not for just the +# module. Instead, define the (private) symbol _STDC_C99, which +# suppresses a bogus failure in <stdbool.h>. The resulting compiler +# passes the test case here, and that's good enough. +# For more, please see the thread starting at: +# https://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html +m4_define([_AC_C_C99_OPTIONS], [ + -std=gnu99 + -std=c99 + -c99 + -qlanglvl=extc1x + -qlanglvl=extc99 + -AC99 + -D_STDC_C99= +]) + + +# _AC_C_C11_OPTIONS +# ----------------- +# Whitespace-separated list of options that might put the C compiler +# into a mode conforming to ISO C2011 with extensions. Do not try +# "strictly conforming" modes (e.g. gcc's -std=c11); they break some +# systems' header files. If more than one option is needed, put +# shell quotes around the group. +# +# GCC, Clang -std=gnu11 +# +# For IBM XL C for AIX V16.1 or later, '-std=gnu11' should work if +# the user configured with CC='xlclang'. Otherwise, do not try +# -qlanglvl=extc1x as xlc with IBM XL C V16.1 (the latest version as +# of August 2020) does not pass the C11 test. Instead, try extc1x when +# compiling the C99 test instead, since it enables _Static_assert and +# _Noreturn, which is a win. +m4_define([_AC_C_C11_OPTIONS], [ + -std=gnu11 +]) + + +# _AC_PROG_CC_STDC_EDITION_TRY(EDITION) +# ------------------------------------- +# Subroutine of _AC_PROG_CC_STDC_EDITION. Not to be called directly. +# +# Check whether the C compiler accepts features of EDITION of the +# C standard. EDITION should be a two-digit year (e.g. 89, 99, 11). +# (FIXME: Switch to four-digit years for futureproofing.) +# This is done by compiling the test program defined by +# _AC_C_C{EDITION}_TEST_PROGRAM, first with no additional +# command-line options, and then with each of the options +# in the space-separated list defined by _AC_C_C{EDITION}_OPTIONS. +# +# If we find a way to make the test program compile, set cache variable +# ac_cv_prog_cc_cEDITION to the options required (if any), and add those +# options to $CC. Set shell variable ac_prog_cc_stdc to `cEDITION', +# and set shell variable ac_cv_prog_cc_stdc to the options required. +# (Neither of these variables is AC_SUBSTed. ac_cv_prog_cc_stdc used +# to be a cache variable and is preserved with this name for backward +# compatibility.) Otherwise, ac_cv_prog_cc_cEDITION is set to `no' +# and the other variables are not changed. +# +# If ac_prog_cc_stdc is already set to a value other than `no', +# the shell code produced by this macro does nothing. This is so +# _AC_PROG_CC_STDC_EDITION can use m4_map to iterate through +# all the editions. +AC_DEFUN([_AC_PROG_CC_STDC_EDITION_TRY], [AC_LANG_ASSERT([C])]dnl -[AC_MSG_CHECKING([for $CC option to enable ]dnl -m4_translit($1, [c], [C])[ features]) -AC_CACHE_VAL([ac_cv_prog_cc_$1], -[ac_cv_prog_cc_$1=no +[AC_REQUIRE([_AC_C_C$1_TEST_PROGRAM])]dnl +[AS_IF([test x$ac_prog_cc_stdc = xno], +[AC_MSG_CHECKING([for $CC option to enable C$1 features]) +AC_CACHE_VAL([ac_cv_prog_cc_c$1], +[ac_cv_prog_cc_c$1=no ac_save_CC=$CC -AC_LANG_CONFTEST([AC_LANG_DEFINES_PROVIDED][$][$2]) -for ac_arg in '' $3 +AC_LANG_CONFTEST([AC_LANG_DEFINES_PROVIDED][$][ac_c_conftest_c$1_program]) +for ac_arg in '' m4_normalize(m4_defn([_AC_C_C$1_OPTIONS])) do CC="$ac_save_CC $ac_arg" - _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) - test "x$ac_cv_prog_cc_$1" != "xno" && break + _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_c$1=$ac_arg]) + test "x$ac_cv_prog_cc_c$1" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC -])# AC_CACHE_VAL -ac_prog_cc_stdc_options= -AS_CASE(["x$ac_cv_prog_cc_$1"], - [x], [AC_MSG_RESULT([none needed])], - [xno], [AC_MSG_RESULT([unsupported])], - [ac_prog_cc_stdc_options=" $ac_cv_prog_cc_$1" - CC="$CC$ac_prog_cc_stdc_options" - AC_MSG_RESULT([$ac_cv_prog_cc_$1])]) -AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$4], [$5]) -])# _AC_C_STD_TRY - - -# _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ---------------------------------------------------------------- -# If the C compiler is not in ANSI C89 (ISO C90) mode by default, try -# to add an option to output variable CC to make it so. +CC=$ac_save_CC]) +AS_IF([test "x$ac_cv_prog_cc_c$1" = xno], + [AC_MSG_RESULT([unsupported])], + [AS_IF([test "x$ac_cv_prog_cc_c$1" = x], + [AC_MSG_RESULT([none needed])], + [AC_MSG_RESULT([$ac_cv_prog_cc_c$1]) + CC="$CC $ac_cv_prog_cc_c$1"]) + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c$1 + ac_prog_cc_stdc=c$1])]) +]) + + +# _AC_PROG_CC_STDC_EDITION +# ------------------------ +# Detect the most recent edition of the ISO C standard that is +# supported by the C compiler. Add command-line options to $CC, if +# necessary, to enable support for this edition. Set the shell +# variable ac_prog_cc_stdc to indicate the edition. +AC_DEFUN([_AC_PROG_CC_STDC_EDITION], +[ac_prog_cc_stdc=no +m4_map([_AC_PROG_CC_STDC_EDITION_TRY], [[11], [99], [89]])]) + + +# _AC_PROG_CC_C89(ACTION-IF-SUPPORTED, ACTION-IF-NOT-SUPPORTED) +# ------------------------------------------------------------- +# Obsolete internal macro. No longer used by Autoconf itself, but +# preserved for backward compatibility with pre-December 2020 versions +# of Gnulib's std-gnu11.m4, which replaced the entire definition of +# AC_PROG_CC *except* for this macro. Can be removed once everyone is +# using Autoconf 2.70 and/or a current std-gnu11.m4. AC_DEFUN([_AC_PROG_CC_C89], -[AC_REQUIRE([_AC_C_C89_TEST_PROGRAM])]dnl -[_AC_C_STD_TRY([c89], [ac_c_conftest_c89_program], -dnl Don't try gcc -ansi; that turns off useful extensions and -dnl breaks some systems' header files. -dnl AIX circa 2003 -qlanglvl=extc89 -dnl old AIX -qlanglvl=ansi -dnl Ultrix, OSF/1, Tru64 -std -dnl HP-UX 10.20 and later -Ae -dnl HP-UX older versions -Aa -D_HPUX_SOURCE -dnl SVR4 -Xc -D__EXTENSIONS__ -[-qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl -])# _AC_PROG_CC_C89 - - -# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ---------------------------------------------------------------- -# If the C compiler is not in ISO C99 mode by default, try to add an -# option to output variable CC to make it so. -AC_DEFUN([_AC_PROG_CC_C99], -[AC_REQUIRE([_AC_C_C99_TEST_PROGRAM])]dnl -[_AC_C_STD_TRY([c99], [ac_c_conftest_c99_program], -dnl Try -dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) -dnl IBM XL C -qlanglvl=extc1x (V12.1; does not pass C11 test) -dnl IBM XL C -qlanglvl=extc99 -dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdc99) -dnl HP cc -AC99 -dnl Intel ICC -std=c99, -c99 (deprecated) -dnl IRIX -c99 -dnl Solaris -D_STDC_C99= -dnl cc's -xc99 option uses linker magic to define the external -dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 -dnl behavior for C library functions. This is not wanted here, -dnl because it means that a single module compiled with -xc99 -dnl alters C runtime behavior for the entire program, not for -dnl just the module. Instead, define the (private) symbol -dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>. -dnl The resulting compiler passes the test case here, and that's -dnl good enough. For more, please see the thread starting at: -dnl https://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html -dnl Tru64 -c99 -dnl with extended modes being tried first. -[[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99]], [$1], [$2])[]dnl -])# _AC_PROG_CC_C99 - - -# _AC_PROG_CC_C11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ---------------------------------------------------------------- -# If the C compiler is not in ISO C11 mode by default, try to add an -# option to output variable CC to make it so. -AC_DEFUN([_AC_PROG_CC_C11], -[AC_REQUIRE([_AC_C_C11_TEST_PROGRAM])]dnl -[_AC_C_STD_TRY([c11], [ac_c_conftest_c11_program], -dnl Try -dnl GCC -std=gnu11 (unused restrictive mode: -std=c11) -dnl with extended modes being tried first. -dnl -dnl For IBM XL C for AIX V16.1 or later, '-std=gnu11' should work if -dnl the user configured with CC='xlclang'. Otherwise, do not try -dnl -qlanglvl=extc1x as xlc with IBM XL C V16.1 (the latest version as -dnl of August 2020) does not pass the C11 test. Instead, try extc1x when -dnl compiling the C99 test instead, since it enables _Static_assert and -dnl _Noreturn, which is a win. -[[-std=gnu11]], [$1], [$2])[]dnl -])# _AC_PROG_CC_C11 +[AC_REQUIRE([_AC_C_C89_TEST_GLOBALS])]dnl +[AC_REQUIRE([_AC_C_C89_TEST_MAIN])]dnl +[_AC_C_STD_TRY([c89], + [$ac_c_conftest_c89_globals], [$ac_c_conftest_c89_main], + m4_quote(m4_normalize(m4_defn([_AC_C_C89_OPTIONS]))), + [$1], + [$2])]) + # AC_PROG_CC_C89 @@ -2633,78 +2671,112 @@ main (int argc, char **argv) " ]])]) +# _AC_CXX_CXX98_OPTIONS +# --------------------- +# Whitespace-separated list of options that might put the C++ compiler +# into a mode conforming to ISO C++ 1998 with extensions. Do not try +# "strictly conforming" modes (e.g. gcc's -std=c++98); they break some +# systems' header files. If more than one option is needed, put +# shell quotes around the group. +# +# GCC -std=gnu++98 +# Intel ICC -std=c++98 +# Note: because -std=c++98 puts GCC in strictly conforming mode, +# this option must be tested *after* -std=gnu++98. +# IBM XL C -qlanglvl=extended +# HP aC++ -AA +# Solaris N/A (default) +# Tru64 N/A (default, but -std gnu could be used) +m4_define([_AC_CXX_CXX98_OPTIONS], [ + -std=gnu++98 + -std=c++98 + -qlanglvl=extended + -AA +]) -# _AC_CXX_STD_TRY(STANDARD, TEST-PROGRAM-HOLDER, OPTION-LIST, -# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) -# ---------------------------------------------------------------- -# Check whether the C++ compiler accepts features of STANDARD (e.g `cxx98', -# `cxx11') by trying to compile the program in the shell variable -# TEST-PROGRAM-HOLDER. Caller is responsible for making sure this variable -# has been initialized. If compilation fails in the default mode, try again -# with each compiler option in the space-separated OPTION-LIST; if one helps, -# append it to CXX. If eventually successful, run ACTION-IF-AVAILABLE, else -# ACTION-IF-UNAVAILABLE. +# _AC_CXX_CXX11_OPTIONS +# --------------------- +# Whitespace-separated list of options that might put the C++ compiler +# into a mode conforming to ISO C++ 2011 with extensions. Do not try +# "strictly conforming" modes (e.g. gcc's -std=c++11); they break some +# systems' header files. If more than one option is needed, put +# shell quotes around the group. +# +# GCC -std=gnu++11, -std=gnu++0x +# Intel ICC -std=c++11, -std=c++0x +# Note: because -std=c++11 puts GCC in strictly conforming mode, +# these options must be tested *after* -std=gnu++11. +# IBM XL C -qlanglvl=extended0x (pre-V12.1) +# HP aC++ -AA +# Solaris N/A (no support) +# Tru64 N/A (no support) +m4_define([_AC_CXX_CXX11_OPTIONS], [ + -std=gnu++11 + -std=gnu++0x + -std=c++11 + -std=c++0x + -qlanglvl=extended0x + -AA +]) -AC_DEFUN([_AC_CXX_STD_TRY], +# _AC_PROG_CXX_STDCXX_EDITION_TRY(EDITION) +# ---------------------------------------- +# Subroutine of _AC_PROG_CXX_STDCXX_EDITION. Not to be called directly. +# +# Check whether the C++ compiler accepts features of EDITION of the +# C++ standard. EDITION should be a two-digit year (e.g. 98, 11). +# (FIXME: Switch to four-digit years for futureproofing.) +# This is done by compiling the test program defined by +# _AC_C_CXX{EDITION}_TEST_PROGRAM, first with no additional +# command-line options, and then with each of the options +# in the space-separated list defined by _AC_C_CXX{EDITION}_OPTIONS. +# +# If we find a way to make the test program compile, set cache variable +# ac_cv_prog_cxx_cxxEDITION to the options required (if any), and add those +# options to $CXX. Set shell variable ac_prog_cxx_stdcxx to `cxxEDITION', +# and set shell variable ac_cv_prog_cxx_stdcxx to the options required. +# (Neither of these variables is AC_SUBSTed. ac_cv_prog_cxx_stdcxx used +# to be a cache variable and is preserved with this name for backward +# compatibility.) Otherwise, ac_cv_prog_cxx_cxxEDITION is set to `no' +# and the other variables are not changed. +# +# If ac_prog_cxx_stdcxx is already set to a value other than `no', +# the shell code produced by this macro does nothing. This is so +# _AC_PROG_CXX_STDCXX_EDITION can use m4_map to iterate through +# all the editions. +AC_DEFUN([_AC_PROG_CXX_STDCXX_EDITION_TRY], [AC_LANG_ASSERT([C++])]dnl -[AC_MSG_CHECKING([for $CXX option to enable ]dnl -m4_translit([$1], [a-wxyz], [A-W+YZ])[ features]) +[AC_REQUIRE([_AC_CXX_CXX$1_TEST_PROGRAM])]dnl +[AS_IF([test x$ac_prog_cxx_stdcxx = xno], +[AC_MSG_CHECKING([for $CXX option to enable C++$1 features]) AC_CACHE_VAL(ac_cv_prog_cxx_$1, [ac_cv_prog_cxx_$1=no ac_save_CXX=$CXX -AC_LANG_CONFTEST([AC_LANG_DEFINES_PROVIDED][$][$2]) -for ac_arg in '' $3 +AC_LANG_CONFTEST([AC_LANG_DEFINES_PROVIDED][$][ac_cxx_conftest_cxx$1_program]) +for ac_arg in '' m4_normalize(m4_defn([_AC_CXX_CXX$1_OPTIONS])) do CXX="$ac_save_CXX $ac_arg" - _AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_$1=$ac_arg]) - test "x$ac_cv_prog_cxx_$1" != "xno" && break + _AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_cxx$1=$ac_arg]) + test "x$ac_cv_prog_cxx_cxx$1" != "xno" && break done rm -f conftest.$ac_ext -CXX=$ac_save_CXX -])# AC_CACHE_VAL -ac_prog_cxx_stdcxx_options= -AS_CASE(["x$ac_cv_prog_cxx_$1"], - [x], [AC_MSG_RESULT([none needed])], - [xno], [AC_MSG_RESULT([unsupported])], - [ac_prog_cxx_stdcxx_options=" $ac_cv_prog_cxx_$1" - CXX=$CXX$ac_prog_cxx_stdcxx_options - AC_MSG_RESULT([$ac_cv_prog_cxx_$1])]) -AS_IF([test "x$ac_cv_prog_cxx_$1" != xno], [$4], [$5]) -])# _AC_CXX_STD_TRY - -# _AC_PROG_CXX_CXX98 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ------------------------------------------------------------------- -# If the C++ compiler is not in ISO C++98 mode by default, try to add -# an option to output variable CXX to make it so. -AC_DEFUN([_AC_PROG_CXX_CXX98], -[AC_REQUIRE([_AC_CXX_CXX98_TEST_PROGRAM])]dnl -[_AC_CXX_STD_TRY([cxx98], [ac_cxx_conftest_cxx98_program], -dnl Try -dnl GCC -std=gnu++98 (unused restrictive mode: -std=c++98) -dnl IBM XL C -qlanglvl=extended -dnl HP aC++ -AA -dnl Intel ICC -std=gnu++98 -dnl Solaris N/A (default) -dnl Tru64 N/A (default, but -std gnu could be used) -dnl with extended modes being tried first. -[[-std=gnu++98 -std=c++98 -qlanglvl=extended -AA]], [$1], [$2])[]dnl -])# _AC_PROG_CXX_CXX98 - -# _AC_PROG_CXX_CXX11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ------------------------------------------------------------------- -# If the C++ compiler is not in ISO CXX11 mode by default, try to add -# an option to output variable CXX to make it so. -AC_DEFUN([_AC_PROG_CXX_CXX11], -[AC_REQUIRE([_AC_CXX_CXX11_TEST_PROGRAM])]dnl -[_AC_CXX_STD_TRY([cxx11], [ac_cxx_conftest_cxx11_program], -dnl Try -dnl GCC -std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants] -dnl IBM XL C -qlanglvl=extended0x -dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11) -dnl HP aC++ -AA -dnl Intel ICC -std=c++11 -std=c++0x -dnl Solaris N/A (no support) -dnl Tru64 N/A (no support) -dnl with extended modes being tried first. -[[-std=gnu++11 -std=c++11 -std=gnu++0x -std=c++0x -qlanglvl=extended0x -AA]], [$1], [$2])[]dnl -])# _AC_PROG_CXX_CXX11 +CXX=$ac_save_CXX]) +AS_IF([test "x$ac_cv_prog_cxx_cxx$1" = xno], + [AC_MSG_RESULT([unsupported])], + [AS_IF([test "x$ac_cv_prog_cxx_cxx$1" = x], + [AC_MSG_RESULT([none needed])], + [AC_MSG_RESULT([$ac_cv_prog_cxx_cxx$1]) + CXX="$CXX $ac_cv_prog_cxx_cxx$1"]) + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx$1 + ac_prog_cxx_stdcxx=cxx$1])]) +]) + +# _AC_PROG_CXX_STDCXX_EDITION +# --------------------------- +# Detect the most recent edition of the ISO C++ standard that is +# supported by the C++ compiler. Add command-line options to $CXX, +# if necessary, to enable support for this edition. Set the shell +# variable ac_prog_cxx_stdcxx to indicate the edition. +AC_DEFUN([_AC_PROG_CXX_STDCXX_EDITION], +[ac_prog_cxx_stdcxx=no +m4_map([_AC_PROG_CXX_STDCXX_EDITION_TRY], [[11], [98]])]) diff --git a/tests/data/ax_prog_cc_for_build_v18.m4 b/tests/data/ax_prog_cc_for_build_v18.m4 new file mode 100644 index 00000000..f7410d74 --- /dev/null +++ b/tests/data/ax_prog_cc_for_build_v18.m4 @@ -0,0 +1,139 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_CC_FOR_BUILD +# +# DESCRIPTION +# +# This macro searches for a C compiler that generates native executables, +# that is a C compiler that surely is not a cross-compiler. This can be +# useful if you have to generate source code at compile-time like for +# example GCC does. +# +# The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything +# needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD). +# The value of these variables can be overridden by the user by specifying +# a compiler with an environment variable (like you do for standard CC). +# +# It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object +# file extensions for the build platform, and GCC_FOR_BUILD to `yes' if +# the compiler we found is GCC. All these variables but GCC_FOR_BUILD are +# substituted in the Makefile. +# +# LICENSE +# +# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 18 + +AU_ALIAS([AC_PROG_CC_FOR_BUILD], [AX_PROG_CC_FOR_BUILD]) +AC_DEFUN([AX_PROG_CC_FOR_BUILD], [dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_CPP])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl + +dnl Use the standard macros, but make them use other variable names +dnl +pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP)dnl +pushdef([ac_cv_prog_cc_c89], ac_cv_build_prog_cc_c89)dnl +pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc)dnl +pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works)dnl +pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross)dnl +pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g)dnl +pushdef([ac_cv_c_compiler_gnu], ac_cv_build_c_compiler_gnu)dnl +pushdef([ac_cv_exeext], ac_cv_build_exeext)dnl +pushdef([ac_cv_objext], ac_cv_build_objext)dnl +pushdef([ac_exeext], ac_build_exeext)dnl +pushdef([ac_objext], ac_build_objext)dnl +pushdef([CC], CC_FOR_BUILD)dnl +pushdef([CPP], CPP_FOR_BUILD)dnl +pushdef([GCC], GCC_FOR_BUILD)dnl +pushdef([CFLAGS], CFLAGS_FOR_BUILD)dnl +pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl +pushdef([EXEEXT], BUILD_EXEEXT)dnl +pushdef([LDFLAGS], LDFLAGS_FOR_BUILD)dnl +pushdef([OBJEXT], BUILD_OBJEXT)dnl +pushdef([host], build)dnl +pushdef([host_alias], build_alias)dnl +pushdef([host_cpu], build_cpu)dnl +pushdef([host_vendor], build_vendor)dnl +pushdef([host_os], build_os)dnl +pushdef([ac_cv_host], ac_cv_build)dnl +pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl +pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl +pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl +pushdef([ac_cv_host_os], ac_cv_build_os)dnl +pushdef([ac_tool_prefix], ac_build_tool_prefix)dnl +pushdef([am_cv_CC_dependencies_compiler_type], am_cv_build_CC_dependencies_compiler_type)dnl +pushdef([am_cv_prog_cc_c_o], am_cv_build_prog_cc_c_o)dnl +pushdef([cross_compiling], cross_compiling_build)dnl + +cross_compiling_build=no + +ac_build_tool_prefix= +AS_IF([test -n "$build"], [ac_build_tool_prefix="$build-"], + [test -n "$build_alias"],[ac_build_tool_prefix="$build_alias-"]) + +AC_LANG_PUSH([C]) +AC_PROG_CC +_AC_COMPILER_EXEEXT +_AC_COMPILER_OBJEXT +AC_PROG_CPP + +dnl Restore the old definitions +dnl +popdef([cross_compiling])dnl +popdef([am_cv_prog_cc_c_o])dnl +popdef([am_cv_CC_dependencies_compiler_type])dnl +popdef([ac_tool_prefix])dnl +popdef([ac_cv_host_os])dnl +popdef([ac_cv_host_vendor])dnl +popdef([ac_cv_host_cpu])dnl +popdef([ac_cv_host_alias])dnl +popdef([ac_cv_host])dnl +popdef([host_os])dnl +popdef([host_vendor])dnl +popdef([host_cpu])dnl +popdef([host_alias])dnl +popdef([host])dnl +popdef([OBJEXT])dnl +popdef([LDFLAGS])dnl +popdef([EXEEXT])dnl +popdef([CPPFLAGS])dnl +popdef([CFLAGS])dnl +popdef([GCC])dnl +popdef([CPP])dnl +popdef([CC])dnl +popdef([ac_objext])dnl +popdef([ac_exeext])dnl +popdef([ac_cv_objext])dnl +popdef([ac_cv_exeext])dnl +popdef([ac_cv_c_compiler_gnu])dnl +popdef([ac_cv_prog_cc_g])dnl +popdef([ac_cv_prog_cc_cross])dnl +popdef([ac_cv_prog_cc_works])dnl +popdef([ac_cv_prog_cc_c89])dnl +popdef([ac_cv_prog_gcc])dnl +popdef([ac_cv_prog_CPP])dnl + +dnl restore global variables ac_ext, ac_cpp, ac_compile, +dnl ac_link, ac_compiler_gnu (dependant on the current +dnl language after popping): +AC_LANG_POP([C]) + +dnl Finally, set Makefile variables +dnl +AC_SUBST(BUILD_EXEEXT)dnl +AC_SUBST(BUILD_OBJEXT)dnl +AC_SUBST([CFLAGS_FOR_BUILD])dnl +AC_SUBST([CPPFLAGS_FOR_BUILD])dnl +AC_SUBST([LDFLAGS_FOR_BUILD])dnl +]) diff --git a/tests/data/ax_prog_cxx_for_build_v3.m4 b/tests/data/ax_prog_cxx_for_build_v3.m4 new file mode 100644 index 00000000..17c19a89 --- /dev/null +++ b/tests/data/ax_prog_cxx_for_build_v3.m4 @@ -0,0 +1,110 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_prog_cxx_for_build.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_CXX_FOR_BUILD +# +# DESCRIPTION +# +# This macro searches for a C++ compiler that generates native +# executables, that is a C++ compiler that surely is not a cross-compiler. +# This can be useful if you have to generate source code at compile-time +# like for example GCC does. +# +# The macro sets the CXX_FOR_BUILD and CXXCPP_FOR_BUILD macros to anything +# needed to compile or link (CXX_FOR_BUILD) and preprocess +# (CXXCPP_FOR_BUILD). The value of these variables can be overridden by +# the user by specifying a compiler with an environment variable (like you +# do for standard CXX). +# +# LICENSE +# +# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org> +# Copyright (c) 2012 Avionic Design GmbH +# +# Based on the AX_PROG_CC_FOR_BUILD macro by Paolo Bonzini. +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 3 + +AU_ALIAS([AC_PROG_CXX_FOR_BUILD], [AX_PROG_CXX_FOR_BUILD]) +AC_DEFUN([AX_PROG_CXX_FOR_BUILD], [dnl +AC_REQUIRE([AX_PROG_CC_FOR_BUILD])dnl +AC_REQUIRE([AC_PROG_CXX])dnl +AC_REQUIRE([AC_PROG_CXXCPP])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl + +dnl Use the standard macros, but make them use other variable names +dnl +pushdef([ac_cv_prog_CXXCPP], ac_cv_build_prog_CXXCPP)dnl +pushdef([ac_cv_prog_gxx], ac_cv_build_prog_gxx)dnl +pushdef([ac_cv_prog_cxx_works], ac_cv_build_prog_cxx_works)dnl +pushdef([ac_cv_prog_cxx_cross], ac_cv_build_prog_cxx_cross)dnl +pushdef([ac_cv_prog_cxx_g], ac_cv_build_prog_cxx_g)dnl +pushdef([CXX], CXX_FOR_BUILD)dnl +pushdef([CXXCPP], CXXCPP_FOR_BUILD)dnl +pushdef([CXXFLAGS], CXXFLAGS_FOR_BUILD)dnl +pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD)dnl +pushdef([CXXCPPFLAGS], CXXCPPFLAGS_FOR_BUILD)dnl +pushdef([host], build)dnl +pushdef([host_alias], build_alias)dnl +pushdef([host_cpu], build_cpu)dnl +pushdef([host_vendor], build_vendor)dnl +pushdef([host_os], build_os)dnl +pushdef([ac_cv_host], ac_cv_build)dnl +pushdef([ac_cv_host_alias], ac_cv_build_alias)dnl +pushdef([ac_cv_host_cpu], ac_cv_build_cpu)dnl +pushdef([ac_cv_host_vendor], ac_cv_build_vendor)dnl +pushdef([ac_cv_host_os], ac_cv_build_os)dnl +pushdef([ac_cxxcpp], ac_build_cxxcpp)dnl +pushdef([ac_compile], ac_build_compile)dnl +pushdef([ac_link], ac_build_link)dnl + +save_cross_compiling=$cross_compiling +save_ac_tool_prefix=$ac_tool_prefix +cross_compiling=no +ac_tool_prefix= + +AC_PROG_CXX +AC_PROG_CXXCPP + +ac_tool_prefix=$save_ac_tool_prefix +cross_compiling=$save_cross_compiling + +dnl Restore the old definitions +dnl +popdef([ac_link])dnl +popdef([ac_compile])dnl +popdef([ac_cxxcpp])dnl +popdef([ac_cv_host_os])dnl +popdef([ac_cv_host_vendor])dnl +popdef([ac_cv_host_cpu])dnl +popdef([ac_cv_host_alias])dnl +popdef([ac_cv_host])dnl +popdef([host_os])dnl +popdef([host_vendor])dnl +popdef([host_cpu])dnl +popdef([host_alias])dnl +popdef([host])dnl +popdef([CXXCPPFLAGS])dnl +popdef([CPPFLAGS])dnl +popdef([CXXFLAGS])dnl +popdef([CXXCPP])dnl +popdef([CXX])dnl +popdef([ac_cv_prog_cxx_g])dnl +popdef([ac_cv_prog_cxx_cross])dnl +popdef([ac_cv_prog_cxx_works])dnl +popdef([ac_cv_prog_gxx])dnl +popdef([ac_cv_prog_CXXCPP])dnl + +dnl Finally, set Makefile variables +dnl +AC_SUBST([CXXFLAGS_FOR_BUILD])dnl +AC_SUBST([CXXCPPFLAGS_FOR_BUILD])dnl +]) diff --git a/tests/data/gnulib_std_gnu11_2020_08_17.m4 b/tests/data/gnulib_std_gnu11_2020_08_17.m4 new file mode 100644 index 00000000..db833d82 --- /dev/null +++ b/tests/data/gnulib_std_gnu11_2020_08_17.m4 @@ -0,0 +1,824 @@ +# Prefer GNU C11 and C++11 to earlier versions. -*- coding: utf-8 -*- + +# This implementation is taken from GNU Autoconf lib/autoconf/c.m4 +# commit 017d5ddd82854911f0119691d91ea8a1438824d6 +# dated Sun Apr 3 13:57:17 2016 -0700 +# This implementation will be obsolete once we can assume Autoconf 2.70 +# or later is installed everywhere a Gnulib program might be developed. + + +# Copyright (C) 2001-2020 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 +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <https://www.gnu.org/licenses/>. + +# Written by David MacKenzie, with help from +# Akim Demaille, Paul Eggert, +# François Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, +# Roland McGrath, Noah Friedman, david d zuhn, and many others. + + +# AC_PROG_CC([COMPILER ...]) +# -------------------------- +# COMPILER ... is a space separated list of C compilers to search for. +# This just gives the user an opportunity to specify an alternative +# search list for the C compiler. +AC_DEFUN_ONCE([AC_PROG_CC], +[AC_LANG_PUSH(C)dnl +AC_ARG_VAR([CC], [C compiler command])dnl +AC_ARG_VAR([CFLAGS], [C compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +m4_ifval([$1], + [AC_CHECK_TOOLS(CC, [$1])], +[AC_CHECK_TOOL(CC, gcc) +if test -z "$CC"; then + dnl Here we want: + dnl AC_CHECK_TOOL(CC, cc) + dnl but without the check for a tool without the prefix. + dnl Until the check is removed from there, copy the code: + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc]) + fi +fi +if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) +fi +if test -z "$CC"; then + AC_CHECK_TOOLS(CC, cl.exe) +fi +if test -z "$CC"; then + AC_CHECK_TOOL(CC, clang) +fi +]) + +test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH]) + +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion -version; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +_AC_PROG_CC_G +dnl +dnl Set ac_prog_cc_stdc to the supported C version. +dnl Also set the documented variable ac_cv_prog_cc_stdc; +dnl its name was chosen when it was cached, but it is no longer cached. +_AC_PROG_CC_C11([ac_prog_cc_stdc=c11 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11], + [_AC_PROG_CC_C99([ac_prog_cc_stdc=c99 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99], + [_AC_PROG_CC_C89([ac_prog_cc_stdc=c89 + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89], + [ac_prog_cc_stdc=no + ac_cv_prog_cc_stdc=no])])]) +dnl +AC_LANG_POP(C)dnl +])# AC_PROG_CC + + + +# AC_PROG_CXX([LIST-OF-COMPILERS]) +# -------------------------------- +# LIST-OF-COMPILERS is a space separated list of C++ compilers to search +# for (if not specified, a default list is used). This just gives the +# user an opportunity to specify an alternative search list for the C++ +# compiler. +# aCC HP-UX C++ compiler much better than `CC', so test before. +# FCC Fujitsu C++ compiler +# KCC KAI C++ compiler +# RCC Rational C++ +# xlC_r AIX C Set++ (with support for reentrant code) +# xlC AIX C Set++ +AC_DEFUN([AC_PROG_CXX], +[AC_LANG_PUSH(C++)dnl +AC_ARG_VAR([CXX], [C++ compiler command])dnl +AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +_AC_ARG_VAR_LIBS()dnl +_AC_ARG_VAR_CPPFLAGS()dnl +_AC_ARG_VAR_PRECIOUS([CCC])dnl +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + AC_CHECK_TOOLS(CXX, + [m4_default([$1], + [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++])], + g++) + fi +fi +# Provide some information about the compiler. +_AS_ECHO_LOG([checking for _AC_LANG compiler version]) +set X $ac_compile +ac_compiler=$[2] +for ac_option in --version -v -V -qversion; do + _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) +done + +m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl +m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl +_AC_LANG_COMPILER_GNU +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +_AC_PROG_CXX_G +_AC_PROG_CXX_CXX11([ac_prog_cxx_stdcxx=cxx11 + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 + ac_cv_prog_cxx_cxx98=$ac_cv_prog_cxx_cxx11], + [_AC_PROG_CXX_CXX98([ac_prog_cxx_stdcxx=cxx98 + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98], + [ac_prog_cxx_stdcxx=no + ac_cv_prog_cxx_stdcxx=no])]) +AC_LANG_POP(C++)dnl +])# AC_PROG_CXX + + +# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, +# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) +# -------------------------------------------------------------- +# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') +# by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails, +# try again with each compiler option in the space-separated OPTION-LIST; if one +# helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE, +# else ACTION-IF-UNAVAILABLE. +AC_DEFUN([_AC_C_STD_TRY], +[AC_MSG_CHECKING([for $CC option to enable ]m4_translit($1, [c], [C])[ features]) +AC_CACHE_VAL(ac_cv_prog_cc_$1, +[ac_cv_prog_cc_$1=no +ac_save_CC=$CC +AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) +for ac_arg in '' $4 +do + CC="$ac_save_CC $ac_arg" + _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) + test "x$ac_cv_prog_cc_$1" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC +])# AC_CACHE_VAL +ac_prog_cc_stdc_options= +case "x$ac_cv_prog_cc_$1" in + x) + AC_MSG_RESULT([none needed]) ;; + xno) + AC_MSG_RESULT([unsupported]) ;; + *) + ac_prog_cc_stdc_options=" $ac_cv_prog_cc_$1" + CC=$CC$ac_prog_cc_stdc_options + AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;; +esac +AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6]) +])# _AC_C_STD_TRY + +# _AC_C_C99_TEST_HEADER +# --------------------- +# A C header suitable for testing for C99. +AC_DEFUN([_AC_C_C99_TEST_HEADER], +[[#include <stdarg.h> +#include <stdbool.h> +#include <stddef.h> +#include <stdlib.h> +#include <wchar.h> +#include <stdio.h> + +// Check varargs macros. These examples are taken from C99 6.10.3.5. +#define debug(...) fprintf (stderr, __VA_ARGS__) +#define showlist(...) puts (#__VA_ARGS__) +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) +static void +test_varargs_macros (void) +{ + int x = 1234; + int y = 5678; + debug ("Flag"); + debug ("X = %d\n", x); + showlist (The first, second, and third items.); + report (x>y, "x is %d but y is %d", x, y); +} + +// Check long long types. +#define BIG64 18446744073709551615ull +#define BIG32 4294967295ul +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) +#if !BIG_OK + your preprocessor is broken; +#endif +#if BIG_OK +#else + your preprocessor is broken; +#endif +static long long int bignum = -9223372036854775807LL; +static unsigned long long int ubignum = BIG64; + +struct incomplete_array +{ + int datasize; + double data[]; +}; + +struct named_init { + int number; + const wchar_t *name; + double average; +}; + +typedef const char *ccp; + +static inline int +test_restrict (ccp restrict text) +{ + // See if C++-style comments work. + // Iterate through items via the restricted pointer. + // Also check for declarations in for loops. + for (unsigned int i = 0; *(text+i) != '\0'; ++i) + continue; + return 0; +} + +// Check varargs and va_copy. +static bool +test_varargs (const char *format, ...) +{ + va_list args; + va_start (args, format); + va_list args_copy; + va_copy (args_copy, args); + + const char *str = ""; + int number = 0; + float fnumber = 0; + + while (*format) + { + switch (*format++) + { + case 's': // string + str = va_arg (args_copy, const char *); + break; + case 'd': // int + number = va_arg (args_copy, int); + break; + case 'f': // float + fnumber = va_arg (args_copy, double); + break; + default: + break; + } + } + va_end (args_copy); + va_end (args); + + return *str && number && fnumber; +}]])# _AC_C_C99_TEST_HEADER + +# _AC_C_C99_TEST_BODY +# ------------------- +# A C body suitable for testing for C99, assuming the corresponding header. +AC_DEFUN([_AC_C_C99_TEST_BODY], +[[ + // Check bool. + _Bool success = false; + + // Check restrict. + if (test_restrict ("String literal") == 0) + success = true; + char *restrict newvar = "Another string"; + + // Check varargs. + success &= test_varargs ("s, d' f .", "string", 65, 34.234); + test_varargs_macros (); + + // Check flexible array members. + struct incomplete_array *ia = + malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); + ia->datasize = 10; + for (int i = 0; i < ia->datasize; ++i) + ia->data[i] = i * 1.234; + + // Check named initializers. + struct named_init ni = { + .number = 34, + .name = L"Test wide string", + .average = 543.34343, + }; + + ni.number = 58; + + int dynamic_array[ni.number]; + dynamic_array[ni.number - 1] = 543; + + // work around unused variable warnings + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' + || dynamic_array[ni.number - 1] != 543); +]]) + +# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ---------------------------------------------------------------- +# If the C compiler is not in ISO C99 mode by default, try to add an +# option to output variable CC to make it so. This macro tries +# various options that select ISO C99 on some system or another. It +# considers the compiler to be in ISO C99 mode if it handles _Bool, +# // comments, flexible array members, inline, long long int, mixed +# code and declarations, named initialization of structs, restrict, +# va_copy, varargs macros, variable declarations in for loops and +# variable length arrays. +AC_DEFUN([_AC_PROG_CC_C99], +[_AC_C_STD_TRY([c99], +[_AC_C_C99_TEST_HEADER], +[_AC_C_C99_TEST_BODY], +dnl Try +dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) +dnl IBM XL C -qlanglvl=extc1x (V12.1; does not pass C11 test) +dnl IBM XL C -qlanglvl=extc99 +dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdc99) +dnl HP cc -AC99 +dnl Intel ICC -std=c99, -c99 (deprecated) +dnl IRIX -c99 +dnl Solaris -D_STDC_C99= +dnl cc's -xc99 option uses linker magic to define the external +dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 +dnl behavior for C library functions. This is not wanted here, +dnl because it means that a single module compiled with -xc99 +dnl alters C runtime behavior for the entire program, not for +dnl just the module. Instead, define the (private) symbol +dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>. +dnl The resulting compiler passes the test case here, and that's +dnl good enough. For more, please see the thread starting at: +dnl https://lists.gnu.org/r/autoconf/2010-12/msg00059.html +dnl Tru64 -c99 +dnl with extended modes being tried first. +[[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99]], [$1], [$2])[]dnl +])# _AC_PROG_CC_C99 + + +# _AC_PROG_CC_C11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ---------------------------------------------------------------- +# If the C compiler is not in ISO C11 mode by default, try to add an +# option to output variable CC to make it so. This macro tries +# various options that select ISO C11 on some system or another. It +# considers the compiler to be in ISO C11 mode if it handles _Alignas, +# _Alignof, _Noreturn, _Static_assert, UTF-8 string literals, +# duplicate typedefs, and anonymous structures and unions. +AC_DEFUN([_AC_PROG_CC_C11], +[_AC_C_STD_TRY([c11], +[_AC_C_C99_TEST_HEADER[ +// Check _Alignas. +char _Alignas (double) aligned_as_double; +char _Alignas (0) no_special_alignment; +extern char aligned_as_int; +char _Alignas (0) _Alignas (int) aligned_as_int; + +// Check _Alignof. +enum +{ + int_alignment = _Alignof (int), + int_array_alignment = _Alignof (int[100]), + char_alignment = _Alignof (char) +}; +_Static_assert (0 < -_Alignof (int), "_Alignof is signed"); + +// Check _Noreturn. +int _Noreturn does_not_return (void) { for (;;) continue; } + +// Check _Static_assert. +struct test_static_assert +{ + int x; + _Static_assert (sizeof (int) <= sizeof (long int), + "_Static_assert does not work in struct"); + long int y; +}; + +// Check UTF-8 literals. +#define u8 syntax error! +char const utf8_literal[] = u8"happens to be ASCII" "another string"; + +// Check duplicate typedefs. +typedef long *long_ptr; +typedef long int *long_ptr; +typedef long_ptr long_ptr; + +// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. +struct anonymous +{ + union { + struct { int i; int j; }; + struct { int k; long int l; } w; + }; + int m; +} v1; +]], +[_AC_C_C99_TEST_BODY[ + v1.i = 2; + v1.w.k = 5; + _Static_assert ((offsetof (struct anonymous, i) + == offsetof (struct anonymous, w.k)), + "Anonymous union alignment botch"); +]], +dnl Try +dnl GCC -std=gnu11 (unused restrictive mode: -std=c11) +dnl with extended modes being tried first. +dnl +dnl Do not try -qlanglvl=extc1x, because IBM XL C V12.1 (the latest version as +dnl of September 2012) does not pass the C11 test. For now, try extc1x when +dnl compiling the C99 test instead, since it enables _Static_assert and +dnl _Noreturn, which is a win. If -qlanglvl=extc11 or -qlanglvl=extc1x passes +dnl the C11 test in some future version of IBM XL C, we'll add it here, +dnl preferably extc11. +[[-std=gnu11]], [$1], [$2])[]dnl +])# _AC_PROG_CC_C11 + + +# AC_PROG_CC_C89 +# -------------- +# Do not use AU_ALIAS here and in AC_PROG_CC_C99 and AC_PROG_CC_STDC, +# as that'd be incompatible with how Automake redefines AC_PROG_CC. See +# <https://lists.gnu.org/r/autoconf/2012-10/msg00048.html>. +AU_DEFUN([AC_PROG_CC_C89], + [AC_REQUIRE([AC_PROG_CC])], + [$0 is obsolete; use AC_PROG_CC] +) + +# AC_PROG_CC_C99 +# -------------- +AU_DEFUN([AC_PROG_CC_C99], + [AC_REQUIRE([AC_PROG_CC])], + [$0 is obsolete; use AC_PROG_CC] +) + +# AC_PROG_CC_STDC +# --------------- +AU_DEFUN([AC_PROG_CC_STDC], + [AC_REQUIRE([AC_PROG_CC])], + [$0 is obsolete; use AC_PROG_CC] +) + + +# AC_C_PROTOTYPES +# --------------- +# Check if the C compiler supports prototypes, included if it needs +# options. +AC_DEFUN([AC_C_PROTOTYPES], +[AC_REQUIRE([AC_PROG_CC])dnl +if test "$ac_prog_cc_stdc" != no; then + AC_DEFINE(PROTOTYPES, 1, + [Define to 1 if the C compiler supports function prototypes.]) + AC_DEFINE(__PROTOTYPES, 1, + [Define like PROTOTYPES; this can be used by system headers.]) +fi +])# AC_C_PROTOTYPES + + +# _AC_CXX_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, +# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) +# ---------------------------------------------------------------- +# Check whether the C++ compiler accepts features of STANDARD (e.g +# `cxx98', `cxx11') by trying to compile a program of TEST-PROLOGUE +# and TEST-BODY. If this fails, try again with each compiler option +# in the space-separated OPTION-LIST; if one helps, append it to CXX. +# If eventually successful, run ACTION-IF-AVAILABLE, else +# ACTION-IF-UNAVAILABLE. +AC_DEFUN([_AC_CXX_STD_TRY], +[AC_MSG_CHECKING([for $CXX option to enable ]m4_translit(m4_translit($1, [x], [+]), [a-z], [A-Z])[ features]) +AC_LANG_PUSH(C++)dnl +AC_CACHE_VAL(ac_cv_prog_cxx_$1, +[ac_cv_prog_cxx_$1=no +ac_save_CXX=$CXX +AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) +for ac_arg in '' $4 +do + CXX="$ac_save_CXX $ac_arg" + _AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_$1=$ac_arg]) + test "x$ac_cv_prog_cxx_$1" != "xno" && break +done +rm -f conftest.$ac_ext +CXX=$ac_save_CXX +])# AC_CACHE_VAL +ac_prog_cxx_stdcxx_options= +case "x$ac_cv_prog_cxx_$1" in + x) + AC_MSG_RESULT([none needed]) ;; + xno) + AC_MSG_RESULT([unsupported]) ;; + *) + ac_prog_cxx_stdcxx_options=" $ac_cv_prog_cxx_$1" + CXX=$CXX$ac_prog_cxx_stdcxx_options + AC_MSG_RESULT([$ac_cv_prog_cxx_$1]) ;; +esac +AC_LANG_POP(C++)dnl +AS_IF([test "x$ac_cv_prog_cxx_$1" != xno], [$5], [$6]) +])# _AC_CXX_STD_TRY + +# _AC_CXX_CXX98_TEST_HEADER +# ------------------------- +# A C++ header suitable for testing for CXX98. +AC_DEFUN([_AC_CXX_CXX98_TEST_HEADER], +[[ +#include <algorithm> +#include <cstdlib> +#include <fstream> +#include <iomanip> +#include <iostream> +#include <list> +#include <map> +#include <set> +#include <sstream> +#include <stdexcept> +#include <string> +#include <utility> +#include <vector> + +namespace test { + typedef std::vector<std::string> string_vec; + typedef std::pair<int,bool> map_value; + typedef std::map<std::string,map_value> map_type; + typedef std::set<int> set_type; + + template<typename T> + class printer { + public: + printer(std::ostringstream& os): os(os) {} + void operator() (T elem) { os << elem << std::endl; } + private: + std::ostringstream& os; + }; +} +]])# _AC_CXX_CXX98_TEST_HEADER + +# _AC_CXX_CXX98_TEST_BODY +# ----------------------- +# A C++ body suitable for testing for CXX98, assuming the corresponding header. +AC_DEFUN([_AC_CXX_CXX98_TEST_BODY], +[[ + +try { + // Basic string. + std::string teststr("ASCII text"); + teststr += " string"; + + // Simple vector. + test::string_vec testvec; + testvec.push_back(teststr); + testvec.push_back("foo"); + testvec.push_back("bar"); + if (testvec.size() != 3) { + throw std::runtime_error("vector size is not 1"); + } + + // Dump vector into stringstream and obtain string. + std::ostringstream os; + for (test::string_vec::const_iterator i = testvec.begin(); + i != testvec.end(); ++i) { + if (i + 1 != testvec.end()) { + os << teststr << '\n'; + } + } + // Check algorithms work. + std::for_each(testvec.begin(), testvec.end(), test::printer<std::string>(os)); + std::string os_out = os.str(); + + // Test pair and map. + test::map_type testmap; + testmap.insert(std::make_pair(std::string("key"), + std::make_pair(53,false))); + + // Test set. + int values[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; + test::set_type testset(values, values + sizeof(values)/sizeof(values[0])); + std::list<int> testlist(testset.begin(), testset.end()); + std::copy(testset.begin(), testset.end(), std::back_inserter(testlist)); +} catch (const std::exception& e) { + std::cerr << "Caught exception: " << e.what() << std::endl; + + // Test fstream + std::ofstream of("test.txt"); + of << "Test ASCII text\n" << std::flush; + of << "N= " << std::hex << std::setw(8) << std::left << 534 << std::endl; + of.close(); +} +std::exit(0); +]]) + +# _AC_CXX_CXX11_TEST_HEADER +# ------------------------- +# A C++ header suitable for testing for CXX11. +AC_DEFUN([_AC_CXX_CXX11_TEST_HEADER], +[[ +#include <deque> +#include <functional> +#include <memory> +#include <tuple> +#include <array> +#include <regex> +#include <iostream> + +namespace cxx11test +{ + typedef std::shared_ptr<std::string> sptr; + typedef std::weak_ptr<std::string> wptr; + + typedef std::tuple<std::string,int,double> tp; + typedef std::array<int, 20> int_array; + + constexpr int get_val() { return 20; } + + struct testinit + { + int i; + double d; + }; + + class delegate { + public: + delegate(int n) : n(n) {} + delegate(): delegate(2354) {} + + virtual int getval() { return this->n; }; + protected: + int n; + }; + + class overridden : public delegate { + public: + overridden(int n): delegate(n) {} + virtual int getval() override final { return this->n * 2; } + }; + + class nocopy { + public: + nocopy(int i): i(i) {} + nocopy() = default; + nocopy(const nocopy&) = delete; + nocopy & operator=(const nocopy&) = delete; + private: + int i; + }; +} +]])# _AC_CXX_CXX11_TEST_HEADER + +# _AC_CXX_CXX11_TEST_BODY +# ----------------------- +# A C++ body suitable for testing for CXX11, assuming the corresponding header. +AC_DEFUN([_AC_CXX_CXX11_TEST_BODY], +[[ +{ + // Test auto and decltype + std::deque<int> d; + d.push_front(43); + d.push_front(484); + d.push_front(3); + d.push_front(844); + int total = 0; + for (auto i = d.begin(); i != d.end(); ++i) { total += *i; } + + auto a1 = 6538; + auto a2 = 48573953.4; + auto a3 = "String literal"; + + decltype(a2) a4 = 34895.034; +} +{ + // Test constexpr + short sa[cxx11test::get_val()] = { 0 }; +} +{ + // Test initializer lists + cxx11test::testinit il = { 4323, 435234.23544 }; +} +{ + // Test range-based for and lambda + cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; + for (int &x : array) { x += 23; } + std::for_each(array.begin(), array.end(), [](int v1){ std::cout << v1; }); +} +{ + using cxx11test::sptr; + using cxx11test::wptr; + + sptr sp(new std::string("ASCII string")); + wptr wp(sp); + sptr sp2(wp); +} +{ + cxx11test::tp tuple("test", 54, 45.53434); + double d = std::get<2>(tuple); + std::string s; + int i; + std::tie(s,i,d) = tuple; +} +{ + static std::regex filename_regex("^_?([a-z0-9_.]+-)+[a-z0-9]+$"); + std::string testmatch("Test if this string matches"); + bool match = std::regex_search(testmatch, filename_regex); +} +{ + cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; + cxx11test::int_array::size_type size = array.size(); +} +{ + // Test constructor delegation + cxx11test::delegate d1; + cxx11test::delegate d2(); + cxx11test::delegate d3(45); +} +{ + // Test override and final + cxx11test::overridden o1(55464); +} +{ + // Test nullptr + char *c = nullptr; +} +{ + // Test template brackets + std::vector<std::pair<int,char*>> v1; +} +{ + // Unicode literals + char const *utf8 = u8"UTF-8 string \u2500"; + char16_t const *utf16 = u"UTF-8 string \u2500"; + char32_t const *utf32 = U"UTF-32 string \u2500"; +} +]]) + +# _AC_PROG_CXX_CXX98 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ------------------------------------------------------------------- + +# If the C++ compiler is not in ISO C++98 mode by default, try to add +# an option to output variable CXX to make it so. This macro tries +# various options that select ISO C++98 on some system or another. It +# considers the compiler to be in ISO C++98 mode if it handles basic +# features of the std namespace including: string, containers (list, +# map, set, vector), streams (fstreams, iostreams, stringstreams, +# iomanip), pair, exceptions and algorithms. + + +AC_DEFUN([_AC_PROG_CXX_CXX98], +[_AC_CXX_STD_TRY([cxx98], +[_AC_CXX_CXX98_TEST_HEADER], +[_AC_CXX_CXX98_TEST_BODY], +dnl Try +dnl GCC -std=gnu++98 (unused restrictive mode: -std=c++98) +dnl IBM XL C -qlanglvl=extended +dnl HP aC++ -AA +dnl Intel ICC -std=gnu++98 +dnl Solaris N/A (default) +dnl Tru64 N/A (default, but -std gnu could be used) +dnl with extended modes being tried first. +[[-std=gnu++98 -std=c++98 -qlanglvl=extended -AA]], [$1], [$2])[]dnl +])# _AC_PROG_CXX_CXX98 + +# _AC_PROG_CXX_CXX11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) +# ------------------------------------------------------------------- +# If the C++ compiler is not in ISO CXX11 mode by default, try to add +# an option to output variable CXX to make it so. This macro tries +# various options that select ISO C++11 on some system or another. It +# considers the compiler to be in ISO C++11 mode if it handles all the +# tests from the C++98 checks, plus the following: Language features +# (auto, constexpr, decltype, default/deleted constructors, delegate +# constructors, final, initializer lists, lambda functions, nullptr, +# override, range-based for loops, template brackets without spaces, +# unicode literals) and library features (array, memory (shared_ptr, +# weak_ptr), regex and tuple types). +AC_DEFUN([_AC_PROG_CXX_CXX11], +[_AC_CXX_STD_TRY([cxx11], +[_AC_CXX_CXX11_TEST_HEADER +_AC_CXX_CXX98_TEST_HEADER], +[_AC_CXX_CXX11_TEST_BODY +_AC_CXX_CXX98_TEST_BODY], +dnl Try +dnl GCC -std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants] +dnl IBM XL C -qlanglvl=extended0x +dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11) +dnl HP aC++ -AA +dnl Intel ICC -std=c++11 -std=c++0x +dnl Solaris N/A (no support) +dnl Tru64 N/A (no support) +dnl with extended modes being tried first. +[[-std=gnu++11 -std=c++11 -std=gnu++0x -std=c++0x -qlanglvl=extended0x -AA]], [$1], [$2])[]dnl +])# _AC_PROG_CXX_CXX11 diff --git a/tests/foreign.at b/tests/foreign.at index f3a53420..50e49efc 100644 --- a/tests/foreign.at +++ b/tests/foreign.at @@ -153,111 +153,8 @@ cp "$abs_top_srcdir/build-aux/install-sh" \ # the second time. Git commit 18c140b50b0619454d4da50d58a318cc257d580a # broke this usage and the breakage went unnoticed for *eight years*. -AT_DATA([aclocal.m4], -[[# ax_prog_cc_for_build.m4 -# serial 18 -# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org> - -AC_DEFUN([AX_PROG_CC_FOR_BUILD], [ -AC_REQUIRE([AC_PROG_CC]) -AC_REQUIRE([AC_PROG_CPP]) -AC_REQUIRE([AC_CANONICAL_BUILD]) - -# Use the standard macros, but make them use other variable names -m4@&t@_pushdef([ac_cv_prog_CPP], ac_cv_build_prog_CPP) -m4@&t@_pushdef([ac_cv_prog_cc_c89], ac_cv_build_prog_cc_c89) -m4@&t@_pushdef([ac_cv_prog_gcc], ac_cv_build_prog_gcc) -m4@&t@_pushdef([ac_cv_prog_cc_works], ac_cv_build_prog_cc_works) -m4@&t@_pushdef([ac_cv_prog_cc_cross], ac_cv_build_prog_cc_cross) -m4@&t@_pushdef([ac_cv_prog_cc_g], ac_cv_build_prog_cc_g) -m4@&t@_pushdef([ac_cv_c_compiler_gnu], ac_cv_build_c_compiler_gnu) -m4@&t@_pushdef([ac_cv_exeext], ac_cv_build_exeext) -m4@&t@_pushdef([ac_cv_objext], ac_cv_build_objext) -m4@&t@_pushdef([ac_exeext], ac_build_exeext) -m4@&t@_pushdef([ac_objext], ac_build_objext) -m4@&t@_pushdef([CC], CC_FOR_BUILD) -m4@&t@_pushdef([CPP], CPP_FOR_BUILD) -m4@&t@_pushdef([GCC], GCC_FOR_BUILD) -m4@&t@_pushdef([CFLAGS], CFLAGS_FOR_BUILD) -m4@&t@_pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD) -m4@&t@_pushdef([EXEEXT], BUILD_EXEEXT) -m4@&t@_pushdef([LDFLAGS], LDFLAGS_FOR_BUILD) -m4@&t@_pushdef([OBJEXT], BUILD_OBJEXT) -m4@&t@_pushdef([host], build) -m4@&t@_pushdef([host_alias], build_alias) -m4@&t@_pushdef([host_cpu], build_cpu) -m4@&t@_pushdef([host_vendor], build_vendor) -m4@&t@_pushdef([host_os], build_os) -m4@&t@_pushdef([ac_cv_host], ac_cv_build) -m4@&t@_pushdef([ac_cv_host_alias], ac_cv_build_alias) -m4@&t@_pushdef([ac_cv_host_cpu], ac_cv_build_cpu) -m4@&t@_pushdef([ac_cv_host_vendor], ac_cv_build_vendor) -m4@&t@_pushdef([ac_cv_host_os], ac_cv_build_os) -m4@&t@_pushdef([ac_tool_prefix], ac_build_tool_prefix) -m4@&t@_pushdef([am_cv_CC_dependencies_compiler_type], am_cv_build_CC_dependencies_compiler_type) -m4@&t@_pushdef([am_cv_prog_cc_c_o], am_cv_build_prog_cc_c_o) -m4@&t@_pushdef([cross_compiling], cross_compiling_build) - -cross_compiling_build=no - -ac_build_tool_prefix= -AS@&t@_IF([test -n "$build"], [ac_build_tool_prefix="$build-"], - [test -n "$build_alias"],[ac_build_tool_prefix="$build_alias-"]) - -AC_LANG_PUSH([C]) -AC_PROG_CC -_AC_COMPILER_EXEEXT -_AC_COMPILER_OBJEXT -AC_PROG_CPP - -# Restore the old definitions -m4@&t@_popdef([cross_compiling]) -m4@&t@_popdef([am_cv_prog_cc_c_o]) -m4@&t@_popdef([am_cv_CC_dependencies_compiler_type]) -m4@&t@_popdef([ac_tool_prefix]) -m4@&t@_popdef([ac_cv_host_os]) -m4@&t@_popdef([ac_cv_host_vendor]) -m4@&t@_popdef([ac_cv_host_cpu]) -m4@&t@_popdef([ac_cv_host_alias]) -m4@&t@_popdef([ac_cv_host]) -m4@&t@_popdef([host_os]) -m4@&t@_popdef([host_vendor]) -m4@&t@_popdef([host_cpu]) -m4@&t@_popdef([host_alias]) -m4@&t@_popdef([host]) -m4@&t@_popdef([OBJEXT]) -m4@&t@_popdef([LDFLAGS]) -m4@&t@_popdef([EXEEXT]) -m4@&t@_popdef([CPPFLAGS]) -m4@&t@_popdef([CFLAGS]) -m4@&t@_popdef([GCC]) -m4@&t@_popdef([CPP]) -m4@&t@_popdef([CC]) -m4@&t@_popdef([ac_objext]) -m4@&t@_popdef([ac_exeext]) -m4@&t@_popdef([ac_cv_objext]) -m4@&t@_popdef([ac_cv_exeext]) -m4@&t@_popdef([ac_cv_c_compiler_gnu]) -m4@&t@_popdef([ac_cv_prog_cc_g]) -m4@&t@_popdef([ac_cv_prog_cc_cross]) -m4@&t@_popdef([ac_cv_prog_cc_works]) -m4@&t@_popdef([ac_cv_prog_cc_c89]) -m4@&t@_popdef([ac_cv_prog_gcc]) -m4@&t@_popdef([ac_cv_prog_CPP]) - -# restore global variables ac_ext, ac_cpp, ac_compile, -# ac_link, ac_compiler_gnu (dependant on the current -# language after popping): -AC_LANG_POP([C]) - -# Finally, set Makefile variables -AC_SUBST(BUILD_EXEEXT) -AC_SUBST(BUILD_OBJEXT) -AC_SUBST([CFLAGS_FOR_BUILD]) -AC_SUBST([CPPFLAGS_FOR_BUILD]) -AC_SUBST([LDFLAGS_FOR_BUILD]) -]) -]]) +cp "$abs_top_srcdir/tests/data/ax_prog_cc_for_build_v18.m4" \ + aclocal.m4 AT_DATA([configure.ac], [[AC_INIT([foo], [1.0]) @@ -290,87 +187,9 @@ cp "$abs_top_srcdir/build-aux/install-sh" \ # the second time. This usage was never broken (unlike with AC_PROG_CC) # but it seems sensible to make sure it doesn't *get* broken. -AT_DATA([aclocal.m4], -[[# ax_prog_cxx_for_build.m4 -# serial 3 -# Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org> -# Copyright (c) 2012 Avionic Design GmbH - -AC_DEFUN([AX_PROG_CXX_FOR_BUILD], [ -AC_LANG_PUSH([C++]) - -AC_REQUIRE([AC_PROG_CXX]) -AC_REQUIRE([AC_PROG_CXXCPP]) -AC_REQUIRE([AC_CANONICAL_HOST]) - -# Use the standard macros, but make them use other variable names -m4@&t@_pushdef([ac_cv_prog_CXXCPP], ac_cv_build_prog_CXXCPP) -m4@&t@_pushdef([ac_cv_prog_gxx], ac_cv_build_prog_gxx) -m4@&t@_pushdef([ac_cv_prog_cxx_works], ac_cv_build_prog_cxx_works) -m4@&t@_pushdef([ac_cv_prog_cxx_cross], ac_cv_build_prog_cxx_cross) -m4@&t@_pushdef([ac_cv_prog_cxx_g], ac_cv_build_prog_cxx_g) -m4@&t@_pushdef([CXX], CXX_FOR_BUILD) -m4@&t@_pushdef([CXXCPP], CXXCPP_FOR_BUILD) -m4@&t@_pushdef([CXXFLAGS], CXXFLAGS_FOR_BUILD) -m4@&t@_pushdef([CPPFLAGS], CPPFLAGS_FOR_BUILD) -m4@&t@_pushdef([CXXCPPFLAGS], CXXCPPFLAGS_FOR_BUILD) -m4@&t@_pushdef([host], build) -m4@&t@_pushdef([host_alias], build_alias) -m4@&t@_pushdef([host_cpu], build_cpu) -m4@&t@_pushdef([host_vendor], build_vendor) -m4@&t@_pushdef([host_os], build_os) -m4@&t@_pushdef([ac_cv_host], ac_cv_build) -m4@&t@_pushdef([ac_cv_host_alias], ac_cv_build_alias) -m4@&t@_pushdef([ac_cv_host_cpu], ac_cv_build_cpu) -m4@&t@_pushdef([ac_cv_host_vendor], ac_cv_build_vendor) -m4@&t@_pushdef([ac_cv_host_os], ac_cv_build_os) -m4@&t@_pushdef([ac_cxxcpp], ac_build_cxxcpp) -m4@&t@_pushdef([ac_compile], ac_build_compile) -m4@&t@_pushdef([ac_link], ac_build_link) - -save_cross_compiling=$cross_compiling -save_ac_tool_prefix=$ac_tool_prefix -cross_compiling=no -ac_tool_prefix= - -AC_PROG_CXX -AC_PROG_CXXCPP - -ac_tool_prefix=$save_ac_tool_prefix -cross_compiling=$save_cross_compiling - -# Restore the old definitions -m4@&t@_popdef([ac_link]) -m4@&t@_popdef([ac_compile]) -m4@&t@_popdef([ac_cxxcpp]) -m4@&t@_popdef([ac_cv_host_os]) -m4@&t@_popdef([ac_cv_host_vendor]) -m4@&t@_popdef([ac_cv_host_cpu]) -m4@&t@_popdef([ac_cv_host_alias]) -m4@&t@_popdef([ac_cv_host]) -m4@&t@_popdef([host_os]) -m4@&t@_popdef([host_vendor]) -m4@&t@_popdef([host_cpu]) -m4@&t@_popdef([host_alias]) -m4@&t@_popdef([host]) -m4@&t@_popdef([CXXCPPFLAGS]) -m4@&t@_popdef([CPPFLAGS]) -m4@&t@_popdef([CXXFLAGS]) -m4@&t@_popdef([CXXCPP]) -m4@&t@_popdef([CXX]) -m4@&t@_popdef([ac_cv_prog_cxx_g]) -m4@&t@_popdef([ac_cv_prog_cxx_cross]) -m4@&t@_popdef([ac_cv_prog_cxx_works]) -m4@&t@_popdef([ac_cv_prog_gxx]) -m4@&t@_popdef([ac_cv_prog_CXXCPP]) - -# Finally, set Makefile variables -AC_SUBST([CXXFLAGS_FOR_BUILD]) -AC_SUBST([CXXCPPFLAGS_FOR_BUILD]) - -AC_LANG_POP([C++]) -]) -]]) +cat "$abs_top_srcdir/tests/data/ax_prog_cc_for_build_v18.m4" \ + "$abs_top_srcdir/tests/data/ax_prog_cxx_for_build_v3.m4" \ + > aclocal.m4 AT_DATA([configure.ac], [[AC_INIT([foo], [1.0]) @@ -391,3 +210,27 @@ AT_CHECK([grep '^CXX = ..*$' Makefile > /dev/null 2>&1]) AT_CHECK([grep '^CXX_FOR_BUILD = ..*$' Makefile > /dev/null 2>&1]) AT_CLEANUP + + +AT_SETUP([gnulib-std-gnu11.m4]) + +# Gnulib's std-gnu11.m4 (last significant change 2016-03-15) overrides +# most but not all of the internal macros used by AC_PROG_CC and AC_PROG_CXX. +# Commit 131d8c69f31dc6fc8dc93abe1096d52d1fe19fd3 changed the calling +# convention of _AC_C_STD_TRY, causing configure scripts that load +# std-gnu11.m4 to have shell syntax errors. + +cp "$abs_top_srcdir/tests/data/gnulib_std_gnu11_2020_08_17.m4" \ + aclocal.m4 + +AT_DATA([configure.ac], +[[AC_INIT([foo], [1.0]) +AC_PROG_CC +AC_PROG_CXX +AC_OUTPUT +]]) + +AT_CHECK_AUTOCONF +AT_CHECK_CONFIGURE + +AT_CLEANUP diff --git a/tests/local.mk b/tests/local.mk index df5551ba..a1efbd1f 100644 --- a/tests/local.mk +++ b/tests/local.mk @@ -120,8 +120,13 @@ TESTSUITE_HAND_AT = \ tests/autoscan.at \ tests/foreign.at +TESTSUITE_EXTRA = \ + tests/data/ax_prog_cc_for_build_v18.m4 \ + tests/data/ax_prog_cxx_for_build_v3.m4 \ + tests/data/gnulib_std_gnu11_2020_08_17.m4 + CLEANFILES += $(TESTSUITE_GENERATED_AT) -EXTRA_DIST += $(TESTSUITE_HAND_AT) +EXTRA_DIST += $(TESTSUITE_HAND_AT) $(TESTSUITE_EXTRA) TESTSUITE_AT = $(TESTSUITE_GENERATED_AT) $(TESTSUITE_HAND_AT) TESTSUITE = tests/testsuite |