From 862c35457d2cb95124d802d5dbeddb4815dc08c1 Mon Sep 17 00:00:00 2001 From: Alexey Neyman Date: Sat, 2 Mar 2019 15:45:37 -0800 Subject: Fix build of glibc 2.29 on systems with obsolete host programs - Force building make as a companion tool if host make is older than 4.0 (CentOS 7 currently has 3.82) - Disable 2.29 as a choice if host python is older than 3.4 (CentOS 7 has 2.6 unless python from EPEL is installed) - Python2 emits its version information to STDERR. Ugh. While there, also use the detected host Python for GDB configuration. Signed-off-by: Alexey Neyman --- configure.ac | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) (limited to 'configure.ac') diff --git a/configure.ac b/configure.ac index dddbd27e..bea1817a 100644 --- a/configure.ac +++ b/configure.ac @@ -182,6 +182,13 @@ CTNG_PROG_VERSION_REQ_ANY([MAKE], [^GNU Make (3\.8[1-9]|3\.9[0-9]|[4-9]\.)], [make_3_81_or_newer]) +CTNG_PROG_VERSION_REQ_ANY([MAKE], + [GNU make >= 4.0], + [make], + [gmake make], + [^GNU Make [4-9]\.], + [make_4_0_or_newer]) + # Check other companion tools that we may or may not build. CTNG_PROG_VERSION_REQ_ANY([LIBTOOL], [GNU libtool >= 2.4], @@ -225,6 +232,21 @@ CTNG_PROG_VERSION([M4], [\(GNU M4\) ([2-9]\.|1\.[5-9]|1\.[1-4][0-9]|1\.4\.[2-9][0-9]|1\.4\.1[2-9])], [gnu_m4_1_4_12_or_newer]) +CTNG_PROG_VERSION([PYTHON], + [Python], + [python], + [python37 python3.7 python36 python3.6 python35 python3.5 python34 python3.4 python33 python3.3 python32 python3.2 python31 python3.1 python3 python27 python2.7 python26 python2.6 python2 python], + [^Python [23]\.], + [python]) + +CTNG_PROG_VERSION([PYTHON], + [Python >= 3.4], + [python], + [python37 python3.7 python36 python3.6 python35 python3.5 python34 python3.4 python3 python], + [^Python 3\.([4-9]|[1-9][0-9]+)\.], + [python_3_4_or_newer]) + + AC_SUBST([kconfig_options]) AC_CHECK_PROGS([dtc], [dtc]) -- cgit v1.2.3 From b3cce054ef381502af4f58105604081bf431ac9e Mon Sep 17 00:00:00 2001 From: Alexey Neyman Date: Mon, 4 Mar 2019 00:22:02 -0800 Subject: Meet our new companion tool, bison Which is here courtesy of CentOS6, which only has bison 2.4 - while new glibc requires 2.7. Signed-off-by: Alexey Neyman --- config/comp_tools/bison.in | 1 + config/configure.in.in | 3 ++ config/libc/glibc.in | 14 +++++++ configure.ac | 7 +++- packages/bison/3.0.5/chksum | 8 ++++ packages/bison/3.0.5/version.desc | 0 packages/bison/3.1/chksum | 8 ++++ packages/bison/3.1/version.desc | 0 packages/bison/3.2.4/chksum | 8 ++++ packages/bison/3.2.4/version.desc | 0 packages/bison/3.3.2/chksum | 8 ++++ packages/bison/3.3.2/version.desc | 0 packages/bison/package.desc | 6 +++ scripts/build/companion_tools/510-bison.sh | 66 ++++++++++++++++++++++++++++++ scripts/crosstool-NG.sh | 3 +- 15 files changed, 130 insertions(+), 2 deletions(-) create mode 100644 config/comp_tools/bison.in create mode 100644 packages/bison/3.0.5/chksum create mode 100644 packages/bison/3.0.5/version.desc create mode 100644 packages/bison/3.1/chksum create mode 100644 packages/bison/3.1/version.desc create mode 100644 packages/bison/3.2.4/chksum create mode 100644 packages/bison/3.2.4/version.desc create mode 100644 packages/bison/3.3.2/chksum create mode 100644 packages/bison/3.3.2/version.desc create mode 100644 packages/bison/package.desc create mode 100644 scripts/build/companion_tools/510-bison.sh (limited to 'configure.ac') diff --git a/config/comp_tools/bison.in b/config/comp_tools/bison.in new file mode 100644 index 00000000..b0dc9e17 --- /dev/null +++ b/config/comp_tools/bison.in @@ -0,0 +1 @@ +# GNU bison diff --git a/config/configure.in.in b/config/configure.in.in index c8df5a35..27e9f168 100644 --- a/config/configure.in.in +++ b/config/configure.in.in @@ -39,6 +39,9 @@ config CONFIGURE_has_gnu_m4_1_4_12_or_newer config CONFIGURE_has_python_3_4_or_newer @KCONFIG_python_3_4_or_newer@ +config CONFIGURE_has_bison_2_7_or_newer + @KCONFIG_bison_2_7_or_newer@ + config CONFIGURE_has_python @KCONFIG_python@ diff --git a/config/libc/glibc.in b/config/libc/glibc.in index e27a4f68..4138707f 100644 --- a/config/libc/glibc.in +++ b/config/libc/glibc.in @@ -35,6 +35,20 @@ config GLIBC_DEP_BINUTILS select BINUTILS_REQUIRE_2_25_or_later if GLIBC_2_26_or_later select BINUTILS_REQUIRE_older_than_2_30 if GLIBC_older_than_2_26 && ARCH_ARM && ARCH_64 +# Glibc 2.29 requires GCC5+ or, for ppc64le, GCC6.2+. We only support the latest +# release on GCC6 branch, so just assume it is newer than 6.2 +config GLIBC_DEP_GCC + def_bool y + select GCC_REQUIRE_5_or_later if GLIBC_2_29_or_later + select GCC_REQUIRE_6_or_later if GLIBC_2_29_or_later && ARCH_POWERPC && ARCH_64 && ARCH_LE + +# Glibc 2.29 requires bison 2.7 or later. All versions in ct-ng satisfy that +# version requirement. +config GLIBC_DEP_BISON + def_bool y + depends on GLIBC_2_29_or_later && !CONFIGURE_has_bison_2_7_or_newer + select COMP_TOOLS_BISON + # Glibc 2.29 now requires Python 3.4 or later, and make 4.0 or later. Ensure # we build 'make' as a companion tool if host's make isn't new enough. config GLIBC_DEP_PYTHON diff --git a/configure.ac b/configure.ac index bea1817a..566b0248 100644 --- a/configure.ac +++ b/configure.ac @@ -113,7 +113,6 @@ AC_PROG_RANLIB CTNG_PATH_TOOL_REQ([OBJCOPY], [gobjcopy objcopy], [objcopy]) CTNG_PATH_TOOL_REQ([OBJDUMP], [gobjdump objdump], [objdump]) CTNG_PATH_TOOL_REQ([READELF], [greadelf readelf], [readelf]) -CTNG_PATH_TOOL_REQ([BISON], [bison], [bison]) CTNG_CHECK_PROGS_REQ([flex], [flex]) CTNG_CHECK_PROGS_REQ([makeinfo], [makeinfo]) @@ -246,6 +245,12 @@ CTNG_PROG_VERSION([PYTHON], [^Python 3\.([4-9]|[1-9][0-9]+)\.], [python_3_4_or_newer]) +CTNG_PROG_VERSION([BISON], + [bison >= 2.7], + [bison], + [bison], + [\(GNU Bison\) (2\.[7-9]|2\.[1-9][0-9]|[3-9]\.)], + [bison_2_7_or_newer]) AC_SUBST([kconfig_options]) diff --git a/packages/bison/3.0.5/chksum b/packages/bison/3.0.5/chksum new file mode 100644 index 00000000..e3c010d3 --- /dev/null +++ b/packages/bison/3.0.5/chksum @@ -0,0 +1,8 @@ +md5 bison-3.0.5.tar.xz 3e54f20988ecd1b62044e25481e5f06b +sha1 bison-3.0.5.tar.xz 45e904d04d88c821df95833c4be4414ce5a47a4b +sha256 bison-3.0.5.tar.xz 075cef2e814642e30e10e8155e93022e4a91ca38a65aa1d5467d4e969f97f338 +sha512 bison-3.0.5.tar.xz 00b448db8abe91b07e32ff5273c6617bc1350d806f92073a9472f4c2f0de5d22c152795674171b74f2eb9eff8d36f8173b82dacb215601bb071ae39404d4a8a2 +md5 bison-3.0.5.tar.gz 41ad57813157b61bfa47e33067a9d6f0 +sha1 bison-3.0.5.tar.gz 326135383c6ef4439781f5817475948b28501dbc +sha256 bison-3.0.5.tar.gz cd399d2bee33afa712bac4b1f4434e20379e9b4099bce47189e09a7675a2d566 +sha512 bison-3.0.5.tar.gz 2087f5ced90518a93416c0c2d914f0ddbb55fb87af94becf03c7097f5d2365a05a3c287241018e86883d8a8bc3519dd7f175606edde96a30b3a54ca0b8a84642 diff --git a/packages/bison/3.0.5/version.desc b/packages/bison/3.0.5/version.desc new file mode 100644 index 00000000..e69de29b diff --git a/packages/bison/3.1/chksum b/packages/bison/3.1/chksum new file mode 100644 index 00000000..9ae47fb9 --- /dev/null +++ b/packages/bison/3.1/chksum @@ -0,0 +1,8 @@ +md5 bison-3.1.tar.xz db7e431785ad96870bfa570a15cab079 +sha1 bison-3.1.tar.xz 84e5b016fa76f6cd4246131b1ca11a0f926e7922 +sha256 bison-3.1.tar.xz 7c2464ad6cb7b513b2c350a092d919327e1f63d12ff024836acbb504475da5c6 +sha512 bison-3.1.tar.xz 2a8e217ffb55ed5b1fcc989377ac348a066e62b8a4b0b0da40c3c7202f3ea487b2aab6a704a10b48d2d17673be0e22f6ff1be91fc05c4e0a57969b42a59d0152 +md5 bison-3.1.tar.gz ba1f1c7d286adc79339c0f1d0f696963 +sha1 bison-3.1.tar.gz 6d42cbe38023a3020df498f1c22dc46439ee08b3 +sha256 bison-3.1.tar.gz a7cb36b55316eeec626865c03d2a44210617a17c7d393ee63d8553e0649ee946 +sha512 bison-3.1.tar.gz 5864bcc211bf326d7bde27a0f2603385e1796d475e607ac8904e360ef50c8e069033cc3701eb010e8077eec7f265276e0921dcae8beb9c1779b42ef598e59908 diff --git a/packages/bison/3.1/version.desc b/packages/bison/3.1/version.desc new file mode 100644 index 00000000..e69de29b diff --git a/packages/bison/3.2.4/chksum b/packages/bison/3.2.4/chksum new file mode 100644 index 00000000..9bb466f5 --- /dev/null +++ b/packages/bison/3.2.4/chksum @@ -0,0 +1,8 @@ +md5 bison-3.2.4.tar.xz 4c8cec0ca8b637d46f24902d032b9296 +sha1 bison-3.2.4.tar.xz 950c7fa571677828eab963126b93a4ed9d496b74 +sha256 bison-3.2.4.tar.xz 523d44419f4df68286503740c95c7b3400b748d7d8b797209195ee5d67f05634 +sha512 bison-3.2.4.tar.xz 652b54fdee969bbc17eeb04d05d65f143e8e0e1b46ac2574e3a76687b9bd916c9a0c97658b4f8357958d64e87fe2a6a2a98a6c312970f0e74fb4445962e9daae +md5 bison-3.2.4.tar.gz eeecdf612b423097ea9182979ca3e093 +sha1 bison-3.2.4.tar.gz 5e10f5d5036907f9d58232372754bce58af651c2 +sha256 bison-3.2.4.tar.gz cb673e2298d34b5e46ba7df0641afa734da1457ce47de491863407a587eec79a +sha512 bison-3.2.4.tar.gz 2670a5aa0d4e9a9433b4b132e11b0af42da8500fdd085fdf7c11033418baf4b0d5d6ca9e56d701c9b406c33231f2d0979a72c15f2ecdade34bc01fa31a690ce0 diff --git a/packages/bison/3.2.4/version.desc b/packages/bison/3.2.4/version.desc new file mode 100644 index 00000000..e69de29b diff --git a/packages/bison/3.3.2/chksum b/packages/bison/3.3.2/chksum new file mode 100644 index 00000000..23fc9370 --- /dev/null +++ b/packages/bison/3.3.2/chksum @@ -0,0 +1,8 @@ +md5 bison-3.3.2.tar.xz c9b552dee234b2f6b66e56b27e5234c9 +sha1 bison-3.3.2.tar.xz 6a09cd588f7a0f985839fc8cecdc80da948f7de7 +sha256 bison-3.3.2.tar.xz 039ee45b61d95e5003e7e8376f9080001b4066ff357bde271b7faace53b9d804 +sha512 bison-3.3.2.tar.xz 63c67291ea1bd00f4412fc589ffb891ede3e2577253016a9a185e00fb2d702371f3862486639a8f52f8a887f340a639575ff3b7ba93c152170cbfd8c9585c1dc +md5 bison-3.3.2.tar.gz a2d208a01a72eb98c2d7e3a2ec2bc51e +sha1 bison-3.3.2.tar.gz 364991dad2ae8e255564fdcb6f77e8da608243d5 +sha256 bison-3.3.2.tar.gz 0fda1d034185397430eb7b0c9e140fb37e02fbfc53b90252fa5575e382b6dbd1 +sha512 bison-3.3.2.tar.gz 42cc3de5a1f349eb8677869f85ea44c8590d3c59ba2488bab04f1575c840c25f80bfb3b5650dfa9cbad530238c1e5efb9b683571fe2e87346e1b01a392a3508b diff --git a/packages/bison/3.3.2/version.desc b/packages/bison/3.3.2/version.desc new file mode 100644 index 00000000..e69de29b diff --git a/packages/bison/package.desc b/packages/bison/package.desc new file mode 100644 index 00000000..b4c6cbce --- /dev/null +++ b/packages/bison/package.desc @@ -0,0 +1,6 @@ +repository='git https://git.savannah.gnu.org/git/bison.git' +bootstrap='./bootstrap' +mirrors='$(CT_Mirrors GNU bison)' +relevantpattern='*.*|.' +archive_formats='.tar.xz .tar.gz' +signature_format='packed/.sig' diff --git a/scripts/build/companion_tools/510-bison.sh b/scripts/build/companion_tools/510-bison.sh new file mode 100644 index 00000000..9379ea82 --- /dev/null +++ b/scripts/build/companion_tools/510-bison.sh @@ -0,0 +1,66 @@ +# Build script for bison + +do_companion_tools_bison_get() +{ + CT_Fetch BISON +} + +do_companion_tools_bison_extract() +{ + CT_ExtractPatch BISON +} + +do_companion_tools_bison_for_build() +{ + CT_DoStep INFO "Installing bison for build" + CT_mkdir_pushd "${CT_BUILD_DIR}/build-bison-build" + do_bison_backend \ + host=${CT_BUILD} \ + prefix="${CT_BUILD_COMPTOOLS_DIR}" \ + cflags="${CT_CFLAGS_FOR_BUILD}" \ + ldflags="${CT_LDFLAGS_FOR_BUILD}" + CT_Popd + CT_EndStep +} + +do_companion_tools_bison_for_host() +{ + CT_DoStep INFO "Installing bison for host" + CT_mkdir_pushd "${CT_BUILD_DIR}/build-bison-host" + do_bison_backend \ + host=${CT_HOST} \ + prefix="${CT_PREFIX_DIR}" \ + cflags="${CT_CFLAGS_FOR_HOST}" \ + ldflags="${CT_LDFLAGS_FOR_HOST}" + CT_Popd + CT_EndStep +} + +do_bison_backend() +{ + local host + local prefix + local cflags + local ldflags + local -a extra_config + + for arg in "$@"; do + eval "${arg// /\\ }" + done + + CT_DoLog EXTRA "Configuring bison" + CT_DoExecLog CFG \ + CFLAGS="${cflags}" \ + LDFLAGS="${ldflags}" \ + ${CONFIG_SHELL} \ + "${CT_SRC_DIR}/bison/configure" \ + --host="${host}" \ + --prefix="${prefix}" \ + "${extra_config[@]}" + + CT_DoLog EXTRA "Building bison" + CT_DoExecLog ALL make + + CT_DoLog EXTRA "Installing bison" + CT_DoExecLog ALL make install +} diff --git a/scripts/crosstool-NG.sh b/scripts/crosstool-NG.sh index 2e60f200..db15b890 100644 --- a/scripts/crosstool-NG.sh +++ b/scripts/crosstool-NG.sh @@ -458,6 +458,7 @@ if [ -z "${CT_RESTART}" ]; then fi # Not all tools are available for all platforms, but some are required. + # TBD do we need these as shell wrappers? exec is slow on Cygwin, and this makes exec twice for each compiler/linker run if [ -n "${where}" ]; then CT_DoLog DEBUG " '${!v}-${tool}' -> '${where}'" printf "#${BANG}${CT_CONFIG_SHELL}\nexec '${where}' \"\${@}\"\n" >"${CT_BUILDTOOLS_PREFIX_DIR}/bin/${!v}-${tool}" @@ -468,7 +469,7 @@ if [ -z "${CT_RESTART}" ]; then ar|as|gcc|ld|nm|objcopy|objdump|ranlib) CT_Abort "Missing: '${t}${tool}${!s}' or '${t}${tool}' or '${tool}' : either needed!" ;; - # Some are conditionnally required + # Some are conditionally required # Add them in alphabetical (C locale) ordering g++) # g++ (needed for companion lib), only needed for HOST -- cgit v1.2.3 From 4ddad7b34f37f87e33e833f75a071c3775adc8cd Mon Sep 17 00:00:00 2001 From: Alexey Neyman Date: Tue, 5 Mar 2019 00:48:31 -0800 Subject: CentOS6 cannot use newer GDB releases ... unless one retrofits it with a decent compiler instead of stock GCC 4.4. While here, sync up the ax_*.m4 with autoconf-archive. Signed-off-by: Alexey Neyman --- config/configure.in.in | 3 + config/debug/gdb.in | 8 + configure.ac | 3 + m4/ax_cxx_compile_stdcxx.m4 | 948 ++++++++++++++++++++++++++++++++++++++++++ m4/ax_with_curses_extra.m4 | 3 - m4/ctng_set_kconfig_option.m4 | 2 +- 6 files changed, 963 insertions(+), 4 deletions(-) create mode 100644 m4/ax_cxx_compile_stdcxx.m4 (limited to 'configure.ac') diff --git a/config/configure.in.in b/config/configure.in.in index 27e9f168..e0420191 100644 --- a/config/configure.in.in +++ b/config/configure.in.in @@ -3,6 +3,9 @@ config CONFIGURE_has_static_link @KCONFIG_static_link@ +config CONFIGURE_has_cxx11 + @KCONFIG_has_cxx11@ + config CONFIGURE_has_lzip @KCONFIG_lzip@ diff --git a/config/debug/gdb.in b/config/debug/gdb.in index a9fab104..f5f7578b 100644 --- a/config/debug/gdb.in +++ b/config/debug/gdb.in @@ -24,3 +24,11 @@ config GDB_INSTALL_GDBINIT config GDB_HAS_DISABLE_CXX_BUILD def_bool y depends on GDB_7_12_or_later && !GDB_8_0_or_later + +# GDB 8.0 requires not just any C++, but recent enough to support C++11. +# Yes, in 2019 there are still LTS systems still lacking such support. +# I am looking at you, CentOS 6: no cookie for you, use an older GDB. +config GDB_DEP_CXX11 + def_bool y + depends on !CONFIGURE_has_cxx11 + select GDB_REQUIRE_older_than_8_0 diff --git a/configure.ac b/configure.ac index 566b0248..ae4a0274 100644 --- a/configure.ac +++ b/configure.ac @@ -97,6 +97,9 @@ AC_PROG_YACC AS_IF([test -z "$CC" -o -z "$CXX"], [AC_MSG_ERROR([no suitable compiler found])]) +AX_CXX_COMPILE_STDCXX([11],, [optional]) +CTNG_SET_KCONFIG_OPTION([has_cxx11], [${HAVE_CXX11}]) + # Check to see if the compiler can link statically AC_MSG_CHECKING([if $CC can static link]) echo "int main() {}" | ${CC} -static -o /dev/null -xc - > /dev/null 2>&1 diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 00000000..9e9eaeda --- /dev/null +++ b/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,948 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik +# Copyright (c) 2012 Zack Weinberg +# Copyright (c) 2013 Roy Stogner +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov +# Copyright (c) 2015 Paul Norman +# Copyright (c) 2015 Moritz Klammler +# Copyright (c) 2016, 2018 Krzesimir Nowak +# +# 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 10 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], + [$1], [14], [ax_cxx_compile_alternatives="14 1y"], + [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + if test x$ac_success = xyes; then + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +) + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual void f() {} + }; + + struct Derived : public Base + { + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check single_type; + typedef check> double_type; + typedef check>> triple_type; + typedef check>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template + struct sum; + + template + struct sum + { + static constexpr auto value = N0 + sum::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template + using member = typename T::member_type; + + template + void func(...) {} + + template + void func(member*) {} + + void test(); + + void test() { func(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same::value, ""); + static_assert(is_same::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) + + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +// If the compiler admits that it is not ready for C++17, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201703L + +#error "This is not a C++17 compiler" + +#else + +#include +#include +#include + +namespace cxx17 +{ + + namespace test_constexpr_lambdas + { + + constexpr int foo = [](){return 42;}(); + + } + + namespace test::nested_namespace::definitions + { + + } + + namespace test_fold_expression + { + + template + int multiply(Args... args) + { + return (args * ... * 1); + } + + template + bool all(Args... args) + { + return (args && ...); + } + + } + + namespace test_extended_static_assert + { + + static_assert (true); + + } + + namespace test_auto_brace_init_list + { + + auto foo = {5}; + auto bar {5}; + + static_assert(std::is_same, decltype(foo)>::value); + static_assert(std::is_same::value); + } + + namespace test_typename_in_template_template_parameter + { + + template typename X> struct D; + + } + + namespace test_fallthrough_nodiscard_maybe_unused_attributes + { + + int f1() + { + return 42; + } + + [[nodiscard]] int f2() + { + [[maybe_unused]] auto unused = f1(); + + switch (f1()) + { + case 17: + f1(); + [[fallthrough]]; + case 42: + f1(); + } + return f1(); + } + + } + + namespace test_extended_aggregate_initialization + { + + struct base1 + { + int b1, b2 = 42; + }; + + struct base2 + { + base2() { + b3 = 42; + } + int b3; + }; + + struct derived : base1, base2 + { + int d; + }; + + derived d1 {{1, 2}, {}, 4}; // full initialization + derived d2 {{}, {}, 4}; // value-initialized bases + + } + + namespace test_general_range_based_for_loop + { + + struct iter + { + int i; + + int& operator* () + { + return i; + } + + const int& operator* () const + { + return i; + } + + iter& operator++() + { + ++i; + return *this; + } + }; + + struct sentinel + { + int i; + }; + + bool operator== (const iter& i, const sentinel& s) + { + return i.i == s.i; + } + + bool operator!= (const iter& i, const sentinel& s) + { + return !(i == s); + } + + struct range + { + iter begin() const + { + return {0}; + } + + sentinel end() const + { + return {5}; + } + }; + + void f() + { + range r {}; + + for (auto i : r) + { + [[maybe_unused]] auto v = i; + } + } + + } + + namespace test_lambda_capture_asterisk_this_by_value + { + + struct t + { + int i; + int foo() + { + return [*this]() + { + return i; + }(); + } + }; + + } + + namespace test_enum_class_construction + { + + enum class byte : unsigned char + {}; + + byte foo {42}; + + } + + namespace test_constexpr_if + { + + template + int f () + { + if constexpr(cond) + { + return 13; + } + else + { + return 42; + } + } + + } + + namespace test_selection_statement_with_initializer + { + + int f() + { + return 13; + } + + int f2() + { + if (auto i = f(); i > 0) + { + return 3; + } + + switch (auto i = f(); i + 4) + { + case 17: + return 2; + + default: + return 1; + } + } + + } + + namespace test_template_argument_deduction_for_class_templates + { + + template + struct pair + { + pair (T1 p1, T2 p2) + : m1 {p1}, + m2 {p2} + {} + + T1 m1; + T2 m2; + }; + + void f() + { + [[maybe_unused]] auto p = pair{13, 42u}; + } + + } + + namespace test_non_type_auto_template_parameters + { + + template + struct B + {}; + + B<5> b1; + B<'a'> b2; + + } + + namespace test_structured_bindings + { + + int arr[2] = { 1, 2 }; + std::pair pr = { 1, 2 }; + + auto f1() -> int(&)[2] + { + return arr; + } + + auto f2() -> std::pair& + { + return pr; + } + + struct S + { + int x1 : 2; + volatile double y1; + }; + + S f3() + { + return {}; + } + + auto [ x1, y1 ] = f1(); + auto& [ xr1, yr1 ] = f1(); + auto [ x2, y2 ] = f2(); + auto& [ xr2, yr2 ] = f2(); + const auto [ x3, y3 ] = f3(); + + } + + namespace test_exception_spec_type_system + { + + struct Good {}; + struct Bad {}; + + void g1() noexcept; + void g2(); + + template + Bad + f(T*, T*); + + template + Good + f(T1*, T2*); + + static_assert (std::is_same_v); + + } + + namespace test_inline_variables + { + + template void f(T) + {} + + template inline T g(T) + { + return T{}; + } + + template<> inline void f<>(int) + {} + + template<> int g<>(int) + { + return 5; + } + + } + +} // namespace cxx17 + +#endif // __cplusplus < 201703L + +]]) diff --git a/m4/ax_with_curses_extra.m4 b/m4/ax_with_curses_extra.m4 index c620a441..7056d685 100644 --- a/m4/ax_with_curses_extra.m4 +++ b/m4/ax_with_curses_extra.m4 @@ -212,9 +212,6 @@ AC_DEFUN([_AX_WITH_CURSES_EXTRA], [ ], [ AS_IF([test "x$ax_cv_curses_which" = xncursesw], [ _AX_WITH_CURSES_CHECKEXTRA([$1], [$2], [$3], [ncursesw/$4], [$5]) - AS_IF([test x$[]ax_cv_[]m4_tolower($1) != "xyes"], [ - _AX_WITH_CURSES_CHECKEXTRA([$1], [$2], [$3], [$4], [$6]) - ]) ], [test "x$ax_cv_curses_which" = xncurses], [ _AX_WITH_CURSES_CHECKEXTRA([$1], [$2], [$3], [$4], [$6]) AS_IF([test x$[]ax_cv_[]m4_tolower($1) != "xyes"], [ diff --git a/m4/ctng_set_kconfig_option.m4 b/m4/ctng_set_kconfig_option.m4 index 2c2968c3..f4837017 100644 --- a/m4/ctng_set_kconfig_option.m4 +++ b/m4/ctng_set_kconfig_option.m4 @@ -1,7 +1,7 @@ # Set the kconfig option. AC_DEFUN([CTNG_SET_KCONFIG_OPTION], [AS_IF( - [test -n "$$1" -o "$2" = "y"], + [test -n "$$1" -o "$2" = "y" -o "$2" = "1" ], [AC_SUBST([KCONFIG_$1], ["def_bool y"])], [AC_SUBST([KCONFIG_$1], ["bool"])]) ]) -- cgit v1.2.3