diff --git a/3rd-party/gtest/googletest-release-1.10.0.tar.gz b/3rd-party/gtest/googletest-release-1.10.0.tar.gz deleted file mode 100644 index ab10868..0000000 Binary files a/3rd-party/gtest/googletest-release-1.10.0.tar.gz and /dev/null differ diff --git a/3rd-party/gtest/googletest-release-1.12.1.tar.gz b/3rd-party/gtest/googletest-release-1.12.1.tar.gz new file mode 100644 index 0000000..c5d3249 Binary files /dev/null and b/3rd-party/gtest/googletest-release-1.12.1.tar.gz differ diff --git a/Makefile.in b/Makefile.in index fc7974e..3e3cae1 100644 --- a/Makefile.in +++ b/Makefile.in @@ -4,7 +4,7 @@ MODE ?= Debug # The Directories, Source, Includes, Objects, Binary ROOT := . 3RD_PARTY_DIR := $(ROOT)/3rd-party -GTEST_DIR := googletest-release-1.10.0 +GTEST_DIR := googletest-release-1.12.1 GTEST_CODE := $(GTEST_DIR).tar.gz BUILD_DIR := BUILD_DIR := $(ROOT)/obj/release diff --git a/configure.in b/configure.in index 66464d8..c196b46 100644 --- a/configure.in +++ b/configure.in @@ -13,13 +13,14 @@ AC_PROG_CXX AC_PROG_CC AX_CXX_COMPILE_STDCXX(11,noext,mandatory) AX_CXX_COMPILE_STDCXX(14,noext,mandatory) +AX_CXX_COMPILE_STDCXX(17,noext,mandatory) # Checks for libraries. AC_LANG([C++]) AC_CHECK_HEADERS([ginac/ginac.h],[],[AC_MSG_ERROR([ModelicaCC needs libginac.])],[]) # Checks for header files. -AX_BOOST_BASE(["1.58"],[], AC_MSG_ERROR([ModelicaCC needs boost library.])) +AX_BOOST_BASE(["1.71"],[], AC_MSG_ERROR([ModelicaCC needs boost library.])) AC_FUNC_ALLOCA AC_CHECK_HEADERS([malloc.h stdlib.h string.h unistd.h]) diff --git a/macros/ax_cxx_compile_stdcxx.m4 b/macros/ax_cxx_compile_stdcxx.m4 index 2c18e49..bbadf8b 100644 --- a/macros/ax_cxx_compile_stdcxx.m4 +++ b/macros/ax_cxx_compile_stdcxx.m4 @@ -1,5 +1,5 @@ # =========================================================================== -# http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html # =========================================================================== # # SYNOPSIS @@ -10,8 +10,9 @@ # # 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). +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard), +# '14' (for the C++14 standard), '17' (for the C++17 standard), +# '20' (for the C++20 standard) or '23' (for the C++23 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. @@ -33,21 +34,34 @@ # 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 +# Copyright (c) 2019 Enji Cooper +# Copyright (c) 2020 Jason Merrill +# Copyright (c) 2021 Jörn Heusipp # # 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 4 +# cxx_compile_stdcxx serial 15 dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro dnl (serial version number 13). +dnl Modifications for R: +dnl For C++11 we check that the date on the +dnl __cplusplus macro is not too recent so that a C++14 compiler does not +dnl pass as a C++11, for example. +dnl If e.g. CXX11STD is set, test it first not last. +dnl Add support for C++20 and C++23, with no new tests (nor does ax_cxx_compile_stdcxx.m4) + AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl - m4_if([$1], [11], [], - [$1], [14], [], - [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])], + 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"], + [$1], [20], [ax_cxx_compile_alternatives="20 2a"], + [$1], [23], [ax_cxx_compile_alternatives="23 2b"], [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl m4_if([$2], [], [], [$2], [ext], [], @@ -59,18 +73,25 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) AC_LANG_PUSH([C++])dnl ac_success=no - AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, - ax_cv_cxx_compile_cxx$1, - [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], - [ax_cv_cxx_compile_cxx$1=yes], - [ax_cv_cxx_compile_cxx$1=no])]) - if test x$ax_cv_cxx_compile_cxx$1 = xyes; then - ac_success=yes + switch="" + +dnl If e.g. CXX11STD is set, test it first. Otherwise test default last. + if test "x${CXX$1STD}" != x; then + AC_CACHE_CHECK(whether $CXX supports C++$1 features, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi fi + m4_if([$2], [noext], [], [dnl if test x$ac_success = xno; then - for switch in -std=gnu++$1 -std=gnu++0x; do + 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, @@ -96,39 +117,58 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl 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 switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; 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" + dnl Both omitted here + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +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 - ac_success=yes + done + if test x$ac_success = xyes; then break fi done fi]) + + if test x$ac_success = xno; then + AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi + 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 +dnl HAVE_CXX$1 is currently unused 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]) +dnl AC_DEFINE(HAVE_CXX$1,1, +dnl [define if the compiler supports basic C++$1 syntax]) fi AC_SUBST(HAVE_CXX$1) ]) @@ -136,35 +176,85 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl dnl Test body for checking C++11 support + m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], +dnl R modification to exclude C++14 compilers +#ifndef __cplusplus +# error "This is not a C++ compiler" +#elif __cplusplus < 201103L +# error "This is not a C++11 compiler" +#elif __cplusplus >= 201402L +# error "This is a compiler for C++14 or later" +#else _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +#endif ) dnl Test body for checking C++14 support m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], +dnl R modification to exclude C++17 compilers +#ifndef __cplusplus +# error "This is not a C++ compiler" +#elif __cplusplus < 201402L +# error "This is not a C++14 compiler" +#elif __cplusplus >= 201703L +# error "This is a C++17 or later compiler" +#else _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +#endif ) -dnl Tests for new features in C++11 - -m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ +dnl Test body for checking C++17 support +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], +#ifndef __cplusplus +#error "This is not a C++ compiler" +#elif __cplusplus < 201703L +#error "This is not a C++17 compiler" +#elif __cplusplus >= 202002L +# error "This is a C++20 or later compiler" +#else + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +#endif +) -// If the compiler admits that it is not ready for C++11, why torture it? -// Hopefully, this will speed up the test. +dnl Test body for checking C++20 support: R modification +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20], #ifndef __cplusplus +#error "This is not a C++ compiler" +#elif __cplusplus < 202002L +#error "This is not a C++20 or later compiler" +#else + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +#endif +) +dnl Test body for checking C++23 support: R modification +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_23], +#ifndef __cplusplus #error "This is not a C++ compiler" +dnl Reject if value is that of C++20 or earlier +#elif __cplusplus <= 202002L +#error "This is not a C++23 compiler" +#else + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +#endif +) -#elif __cplusplus < 201103L -#error "This is not a C++11 compiler" +dnl Tests for new features in C++11 -#else +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ namespace cxx11 { @@ -185,11 +275,13 @@ namespace cxx11 struct Base { + virtual ~Base() {} virtual void f() {} }; struct Derived : public Base { + virtual ~Derived() override {} virtual void f() override {} }; @@ -244,7 +336,7 @@ namespace cxx11 } int - test(const int c, volatile int v) + test(const int c, volatile int v) // 'volatile is deprecated in C++20' { static_assert(is_same::value == true, ""); static_assert(is_same::value == false, ""); @@ -390,7 +482,13 @@ namespace cxx11 template struct sum { - static constexpr auto value = N0 + sum::value; + /* + Original test code used the auto keyword instead of declaring + the type of "value" to be int. This causes Oracle Solaris Studio + 12.4 to fail. This is possibly a compiler bug but in any case + current test code works around it by an explicit declaration. + */ + static constexpr int value = N0 + sum::value; }; template <> @@ -433,8 +531,6 @@ namespace cxx11 } // namespace cxx11 -#endif // __cplusplus >= 201103L - ]]) @@ -442,19 +538,6 @@ 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 { @@ -518,7 +601,7 @@ namespace cxx14 } - namespace test_digit_seperators + namespace test_digit_separators { constexpr auto ten_million = 100'000'000; @@ -557,6 +640,371 @@ namespace cxx14 } // namespace cxx14 -#endif // __cplusplus >= 201402L +]]) + + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +#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 ]])