On Sun, Dec 20, 2020 at 12:09 PM Zack Weinberg <zackw@xxxxxxxxx> wrote:
> I'm not happy about needing to kludge backward compatibility with the
> older std-gnu11.m4 into autoconf 2.70.1 but I'm going to do it.
As of commit 2d0f19d84ddb13412382674fd48e6fc5c2875d0e, Autoconf
*trunk* should now be backward compatible with the older std-gnu11.m4.
I verified that I can regenerate bison 3.7.4's configure script with
that version of Autoconf, making no other changes to the bison release
tarball, and then configure, build, and test bison with no errors.
The patch is somewhat invasive, though. The full text is attached,
and before I merge it to the 2.70 branch, I'd appreciate any extra
testing and/or code review anyone cares to give it.
zw
From 2d0f19d84ddb13412382674fd48e6fc5c2875d0e Mon Sep 17 00:00:00 2001
From: Zack Weinberg <zackw@xxxxxxxxx>
Date: Mon, 21 Dec 2020 14:04:22 -0500
Subject: [PATCH] Restore compatibility with older std-gnu11.m4.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Gnulib’s std-gnu11.m4 backports C11 and C++11 detection to autoconf
2.69. It does this by replacing the definitions of AC_PROC_CC and
AC_PROG_CXX and most of their subroutines. In particular, it replaces
the definitions of _AC_PROG_CC_C11, _AC_PROG_CC_C99, and _AC_C_STD_TRY,
but it does *not* replace the definition of _AC_PROG_CC_C89.
Autoconf commit 131d8c69f31dc6fc8dc93abe1096d52d1fe19fd3 changed the
calling convention of _AC_C_STD_TRY, and changed the internal
definitions of _AC_PROG_CC_C{11,99,89} to match. If std-gnu11.m4 is
in use, our _AC_PROG_CC_C89 calls their _AC_C_STD_TRY with the new
calling convention, and this produces a syntactically invalid
configure script. (This is is fortunate: it could easily have been a
runtime malfunction that only manifested with compilers that only
implement C89, and then we might not have noticed the problem for
years.)
Gnulib commit a3b3fc85e3e632374811b27cb2111e50fa177e36 makes
std-gnu11.m4 do nothing when used with autoconf >=2.70, but older
versions of the file will circulate for years to come, so this patch
works around the problem in autoconf. It does this by renaming all of
the internal macros involved with C and C++ standard edition
detection, *except* _AC_PROG_CC_C89. AC_PROG_CC now calls
_AC_PROG_CC_STDC_EDITION, which loops over all supported editions
calling _AC_PROG_CC_STDC_EDITION_TRY, which uses the data provided by
the existing _AC_C_C${edition}_TEST_PROGRAM macros and a new set of
macros called _AC_C_C${edition}_OPTIONS to perform the test for that
edition of the standard. Similarly, AC_PROG_CXX calls
_AC_PROG_CXX_STDCXX_EDITION, which loops calling
_AC_PROG_CXX_STDCXX_EDITION_TRY, which uses data from
_AC_CXX_CXX${edition}_TEST_PROGRAM and _AC_CXX_CXX${edition}_OPTIONS.
_AC_PROG_CC_C89 is the only macro from the old set that we still
define, and its definition is reverted to what std-gnu11.m4 expects it
to be. Nothing in Autoconf proper uses it anymore.
foreign.at grows a test to verify that the compatibility stub version
of _AC_PROG_CC_C89 does its job. Since this is now the third test
involving an embedded copy of a third-party macro, I broke them all
out of foreign.at to separate files in test/data/.
In addition to fixing the breakage, this patch should make it easier
to extend C / C++ standard edition detection in the future, by getting
rid of the if-else chains in AC_PROG_CC/CXX and by disentangling the
lists of command-line options to test from the logic.
I also changed the manual to suggest people refer to the variables
‘ac_prog_cc_stdc’ and ‘ac_prog_cxx_stdcxx’ to learn which edition
of the C and C++ standards are selected; these are much easier to
work with than the ac_cv_prog_cc_cNN cache variables.
* lib/autoconf/c.m4 (_AC_C_STD_TRY, _AC_PROG_CC_C99, _AC_PROG_CC_C11)
(_AC_CXX_STD_TRY, _AC_PROG_CXX_CXX98, _AC_PROG_CXX_CXX11): Remove macro.
(_AC_C_C89_OPTIONS, _AC_C_C99_OPTIONS, _AC_C_C11_OPTIONS)
(_AC_PROG_CC_STDC_EDITION, _AC_PROG_CC_STDC_EDITION_TRY)
(_AC_CXX_CXX98_OPTIONS, _AC_CXX_CXX11_OPTIONS)
(_AC_PROG_CXX_STDCXX_EDITION, _AC_PROG_CXX_STDCXX_EDITION_TRY): New macros.
(_AC_PROG_CC_C89): Convert to compatibility stub for std-gnu11.m4.
(AC_PROG_CC): Use _AC_PROG_CC_STDC_EDITION.
(AC_PROG_CXX): Use _AC_PROG_CXX_STDCXX_EDITION.
* 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: New files.
* tests/foreign.at (AX_PROG_CC_FOR_BUILD, AX_PROG_CXX_FOR_BUILD):
Remove embedded copy of ax_prog_cc_for_build_v18.m4,
ax_prog_cxx_for_build_v3.m4 respectively.
(gnulib-std-gnu11.m4): New test.
* tests/local.mk: Distribute tests/data/*.m4.
* doc/autoconf.texi (AC_PROG_CC, AC_PROG_CXX): Document use of
ac_prog_cc_stdc / ac_prog_cxx_stdcxx, respectively, to tell which
edition of the C / C++ standards are selected, instead of looking
through a series of cache variables with awkward definitions.
---
doc/autoconf.texi | 45 +-
lib/autoconf/c.m4 | 436 +++++++-----
tests/data/ax_prog_cc_for_build_v18.m4 | 139 ++++
tests/data/ax_prog_cxx_for_build_v3.m4 | 110 +++
tests/data/gnulib_std_gnu11_2020_08_17.m4 | 824 ++++++++++++++++++++++
tests/foreign.at | 215 +-----
tests/local.mk | 7 +-
7 files changed, 1380 insertions(+), 396 deletions(-)
create mode 100644 tests/data/ax_prog_cc_for_build_v18.m4
create mode 100644 tests/data/ax_prog_cxx_for_build_v3.m4
create mode 100644 tests/data/gnulib_std_gnu11_2020_08_17.m4
diff --git a/doc/autoconf.texi b/doc/autoconf.texi
index 5e17280e..b1bd8be6 100644
--- a/doc/autoconf.texi
+++ b/doc/autoconf.texi
@@ -7453,7 +7453,6 @@ C Compiler
@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 @@ C Compiler
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 @@ C++ Compiler
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,115 +1478,171 @@ 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
+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_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.
+# _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_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_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_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
+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_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
+# _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@xxxxxxx>
+#
+# 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@xxxxxxx>
+# 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@xxxxxxx>
-
-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@xxxxxxx>
-# 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
--
2.29.2
