From 0c6b7a6ac8815de7c99e95232c4e69e73875cf7e Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Thu, 16 Apr 2020 06:11:07 +0000 Subject: [PATCH] adopted AX_CXX_COMPILE_STDCXX() for auto-detection of a c++11 capable compiler --- hawk/Makefile.in | 6 +- hawk/aclocal.m4 | 1 + hawk/bin/Makefile.in | 2 + hawk/configure | 684 ++++++++++++++++++++++ hawk/configure.ac | 3 + hawk/lib/Hawk.cpp | 20 +- hawk/lib/Hawk.hpp | 97 ++-- hawk/lib/HawkStd.cpp | 6 +- hawk/lib/HawkStd.hpp | 10 +- hawk/lib/Makefile.in | 2 + hawk/lib/hawk-cfg.h.in | 3 + hawk/m4/ax_cxx_compile_stdcxx.m4 | 951 +++++++++++++++++++++++++++++++ hawk/mod/Makefile.in | 2 + hawk/samples/Makefile.in | 2 + hawk/t/Makefile.in | 2 + hawk/tools/Makefile.in | 2 + 16 files changed, 1725 insertions(+), 68 deletions(-) create mode 100644 hawk/m4/ax_cxx_compile_stdcxx.m4 diff --git a/hawk/Makefile.in b/hawk/Makefile.in index 8775de4b..a6c4c09a 100644 --- a/hawk/Makefile.in +++ b/hawk/Makefile.in @@ -92,6 +92,7 @@ host_triplet = @host@ subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -169,8 +170,8 @@ am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/ac/ar-lib \ $(top_srcdir)/ac/config.sub $(top_srcdir)/ac/install-sh \ $(top_srcdir)/ac/ltmain.sh $(top_srcdir)/ac/missing \ $(top_srcdir)/pkgs/hawk.spec.in ac/ar-lib ac/compile \ - ac/config.guess ac/config.sub ac/install-sh ac/ltmain.sh \ - ac/missing + ac/config.guess ac/config.sub ac/depcomp ac/install-sh \ + ac/ltmain.sh ac/missing DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) @@ -248,6 +249,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/aclocal.m4 b/hawk/aclocal.m4 index ace88feb..31af506d 100644 --- a/hawk/aclocal.m4 +++ b/hawk/aclocal.m4 @@ -1194,6 +1194,7 @@ AC_SUBST([am__untar]) ]) # _AM_PROG_TAR m4_include([m4/ax_check_sign.m4]) +m4_include([m4/ax_cxx_compile_stdcxx.m4]) m4_include([m4/ax_cxx_namespace.m4]) m4_include([m4/ax_lib_mysql.m4]) m4_include([m4/ax_numval.m4]) diff --git a/hawk/bin/Makefile.in b/hawk/bin/Makefile.in index b19fb649..6ef346ec 100644 --- a/hawk/bin/Makefile.in +++ b/hawk/bin/Makefile.in @@ -92,6 +92,7 @@ bin_PROGRAMS = hawk$(EXEEXT) subdir = bin ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -217,6 +218,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/configure b/hawk/configure index cc96e709..4e0f5aa2 100755 --- a/hawk/configure +++ b/hawk/configure @@ -722,6 +722,7 @@ SED LN_S EGREP GREP +HAVE_CXX11 HAVE_CXX am__fastdepCXX_FALSE am__fastdepCXX_TRUE @@ -5805,6 +5806,689 @@ $as_echo "#define HAVE_CXX_NAMESPACE_STD /**/" >>confdefs.h fi + ax_cxx_compile_alternatives="11 0x" ax_cxx_compile_cxx11_required=false + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + ac_success=no + + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh` + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5 +$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; } +if eval \${$cachevar+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_CXX="$CXX" + CXX="$CXX $switch" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +// 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 ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + 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 + + + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + eval $cachevar=yes +else + eval $cachevar=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + CXX="$ac_save_CXX" +fi +eval ac_res=\$$cachevar + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + 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 + + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh` + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5 +$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; } +if eval \${$cachevar+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_CXX="$CXX" + CXX="$CXX $switch" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +// 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 ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + 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 + + + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + eval $cachevar=yes +else + eval $cachevar=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + CXX="$ac_save_CXX" +fi +eval ac_res=\$$cachevar + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + 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_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + if test x$ax_cxx_compile_cxx11_required = xtrue; then + if test x$ac_success = xno; then + as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5 + fi + fi + if test x$ac_success = xno; then + HAVE_CXX11=0 + { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5 +$as_echo "$as_me: No compiler with C++11 support was found" >&6;} + else + HAVE_CXX11=1 + +$as_echo "#define HAVE_CXX11 1" >>confdefs.h + + fi + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } diff --git a/hawk/configure.ac b/hawk/configure.ac index a1d7ef05..24cdbb23 100644 --- a/hawk/configure.ac +++ b/hawk/configure.ac @@ -29,6 +29,9 @@ AC_CHECK_PROG(HAVE_CXX, $CXX, yes, no) dnl check if the C++ compiler supports namespace AX_CXX_NAMESPACE_STD +dnl HAVE_CXX11 +AX_CXX_COMPILE_STDCXX(11, , optional) + dnl determine some key programs AC_PROG_INSTALL AC_PROG_EGREP diff --git a/hawk/lib/Hawk.cpp b/hawk/lib/Hawk.cpp index 7e7106d1..15cd7cb4 100644 --- a/hawk/lib/Hawk.cpp +++ b/hawk/lib/Hawk.cpp @@ -53,22 +53,22 @@ void Mmged::setMmgr (Mmgr* mmgr) ////////////////////////////////////////////////////////////////// -void* Mmgr::alloc_mem (mmgr_t* mmgr, hawk_oow_t n) HAWK_CPP_NOEXCEPT +void* Mmgr::alloc_mem (mmgr_t* mmgr, hawk_oow_t n) HAWK_CXX_NOEXCEPT { return ((Mmgr*)mmgr->ctx)->allocMem (n); } -void* Mmgr::realloc_mem (mmgr_t* mmgr, void* ptr, hawk_oow_t n) HAWK_CPP_NOEXCEPT +void* Mmgr::realloc_mem (mmgr_t* mmgr, void* ptr, hawk_oow_t n) HAWK_CXX_NOEXCEPT { return ((Mmgr*)mmgr->ctx)->reallocMem (ptr, n); } -void Mmgr::free_mem (mmgr_t* mmgr, void* ptr) HAWK_CPP_NOEXCEPT +void Mmgr::free_mem (mmgr_t* mmgr, void* ptr) HAWK_CXX_NOEXCEPT { ((Mmgr*)mmgr->ctx)->freeMem (ptr); } -void* Mmgr::callocate (hawk_oow_t n, bool raise_exception) /*HAWK_CPP_THREXCEPT1(MemoryError)*/ +void* Mmgr::callocate (hawk_oow_t n, bool raise_exception) /*HAWK_CXX_THREXCEPT1(MemoryError)*/ { void* ptr = this->allocate(n, raise_exception); HAWK_MEMSET (ptr, 0, n); @@ -83,7 +83,7 @@ static MmgrStd std_dfl_mmgr; //<-- has an issue for undefined initialization ord #endif Mmgr* Mmgr::dfl_mmgr = &std_dfl_mmgr; //Mmgr* Mmgr::dfl_mmgr = MmgrStd::getInstance(); //<--- has an issue as well -Mmgr* Mmgr::getDFL () HAWK_CPP_NOEXCEPT +Mmgr* Mmgr::getDFL () HAWK_CXX_NOEXCEPT { return Mmgr::dfl_mmgr; } @@ -94,7 +94,7 @@ Mmgr* Mmgr::getDFL () HAWK_CPP_NOEXCEPT // Mmgr::getDFL() resets dfl_mmgr to &std_dfl_mmgr if it's NULL. Mmgr* Mmgr::dfl_mmgr = HAWK_NULL; -Mmgr* Mmgr::getDFL () HAWK_CPP_NOEXCEPT +Mmgr* Mmgr::getDFL () HAWK_CXX_NOEXCEPT { static MmgrStd std_dfl_mmgr; Mmgr* mmgr = Mmgr::dfl_mmgr; @@ -102,7 +102,7 @@ Mmgr* Mmgr::getDFL () HAWK_CPP_NOEXCEPT } #endif -void Mmgr::setDFL (Mmgr* mmgr) HAWK_CPP_NOEXCEPT +void Mmgr::setDFL (Mmgr* mmgr) HAWK_CXX_NOEXCEPT { Mmgr::dfl_mmgr = mmgr; } @@ -2798,12 +2798,12 @@ HAWK_END_NAMESPACE(HAWK) -void* operator new (hawk_oow_t size, HAWK::Mmgr* mmgr) /*HAWK_CPP_THREXCEPT1(HAWK::Mmgr::MemoryError)*/ +void* operator new (hawk_oow_t size, HAWK::Mmgr* mmgr) /*HAWK_CXX_THREXCEPT1(HAWK::Mmgr::MemoryError)*/ { return mmgr->allocate(size); } -#if defined(HAWK_CPP_NO_OPERATOR_DELETE_OVERLOADING) +#if defined(HAWK_CXX_NO_OPERATOR_DELETE_OVERLOADING) void hawk_operator_delete (void* ptr, HAWK::Mmgr* mmgr) #else void operator delete (void* ptr, HAWK::Mmgr* mmgr) @@ -2812,7 +2812,7 @@ void operator delete (void* ptr, HAWK::Mmgr* mmgr) mmgr->dispose (ptr); } -void* operator new (hawk_oow_t size, HAWK::Mmgr* mmgr, void* existing_ptr) /*HAWK_CPP_THREXCEPT1(HAWK::Mmgr::MemoryError)*/ +void* operator new (hawk_oow_t size, HAWK::Mmgr* mmgr, void* existing_ptr) /*HAWK_CXX_THREXCEPT1(HAWK::Mmgr::MemoryError)*/ { // mmgr unused. i put it in the parameter list to make this function // less conflicting with the stock ::operator new() that doesn't allocate. diff --git a/hawk/lib/Hawk.hpp b/hawk/lib/Hawk.hpp index aa64af0e..69219974 100644 --- a/hawk/lib/Hawk.hpp +++ b/hawk/lib/Hawk.hpp @@ -40,6 +40,7 @@ #if defined(HAWK_USE_HTB_FOR_FUNCTION_MAP) # include #else +// this part not supported for now # include # include #endif @@ -52,28 +53,28 @@ HAWK_BEGIN_NAMESPACE(HAWK) ///////////////////////////////// #if (__cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900) // C++11 or later - #define HAWK_LANG_CPP11 1 - #define HAWK_CPP_NOEXCEPT noexcept(true) + #define HAWK_LANG_CXX11 1 + #define HAWK_CXX_NOEXCEPT noexcept(true) - /// The HAWK_CPP_ENABLE_CPP11_MOVE macro enables C++11 move semantics in various classes. - #define HAWK_CPP_ENABLE_CPP11_MOVE 1 + /// The HAWK_CXX_ENABLE_CXX11_MOVE macro enables C++11 move semantics in various classes. + #define HAWK_CXX_ENABLE_CXX11_MOVE 1 - // The HAWK_CPP_CALL_DESTRUCTOR() macro calls a destructor explicitly. - #define HAWK_CPP_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) + // The HAWK_CXX_CALL_DESTRUCTOR() macro calls a destructor explicitly. + #define HAWK_CXX_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) - // The HAWK_CPP_CALL_PLACEMENT_DELETE1() macro calls the global operator delete + // The HAWK_CXX_CALL_PLACEMENT_DELETE1() macro calls the global operator delete // with 1 extra argument given. - #define HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) + #define HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) #elif (__cplusplus >= 199711L) // C++98 - #undef HAWK_LANG_CPP11 - #define HAWK_CPP_NOEXCEPT throw() + #undef HAWK_LANG_CXX11 + #define HAWK_CXX_NOEXCEPT throw() - #define HAWK_CPP_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) - #define HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) + #define HAWK_CXX_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) + #define HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) #else - #undef HAWK_LANG_CPP11 - #define HAWK_CPP_NOEXCEPT + #undef HAWK_LANG_CXX11 + #define HAWK_CXX_NOEXCEPT #if defined(__BORLANDC__) @@ -88,8 +89,8 @@ HAWK_BEGIN_NAMESPACE(HAWK) // // x->Node::~Node (); - #define HAWK_CPP_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->class_name::~class_name()) - #define HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) + #define HAWK_CXX_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->class_name::~class_name()) + #define HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) #elif defined(__WATCOMC__) @@ -97,8 +98,8 @@ HAWK_BEGIN_NAMESPACE(HAWK) // Node* x; x->Node::~Node(). // But it doesn't support operator delete overloading. - #define HAWK_CPP_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) - #define HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, arg1) (::hawk_operator_delete((ptr), (arg1))) + #define HAWK_CXX_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) + #define HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, arg1) (::hawk_operator_delete((ptr), (arg1))) // When the name of a member template specialization appears after . or // -> in a postfix-expression, or after :: in a qualified-id that explic- @@ -120,37 +121,37 @@ HAWK_BEGIN_NAMESPACE(HAWK) // // WATCOM doesn't support this qualifier. - #define HAWK_CPP_NO_OPERATOR_DELETE_OVERLOADING 1 + #define HAWK_CXX_NO_OPERATOR_DELETE_OVERLOADING 1 #else - #define HAWK_CPP_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) - #define HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) + #define HAWK_CXX_CALL_DESTRUCTOR(ptr, class_name) ((ptr)->~class_name()) + #define HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, arg1) (::operator delete((ptr), (arg1))) #endif #endif -#if defined(HAWK_CPP_ENABLE_CPP11_MOVE) +#if defined(HAWK_CXX_ENABLE_CXX11_MOVE) - template struct HAWK_CPP_RMREF { typedef T Type; }; - template struct HAWK_CPP_RMREF { typedef T Type; }; - template struct HAWK_CPP_RMREF { typedef T Type; }; + template struct HAWK_CXX_RMREF { typedef T Type; }; + template struct HAWK_CXX_RMREF { typedef T Type; }; + template struct HAWK_CXX_RMREF { typedef T Type; }; template inline - typename HAWK_CPP_RMREF::Type&& HAWK_CPP_RVREF(T&& v) + typename HAWK_CXX_RMREF::Type&& HAWK_CXX_RVREF(T&& v) { - return (typename HAWK_CPP_RMREF::Type&&)v; + return (typename HAWK_CXX_RMREF::Type&&)v; } #else /* template inline - T& HAWK_CPP_RVREF(T& v) { return (T&)v; } + T& HAWK_CXX_RVREF(T& v) { return (T&)v; } template inline - const T& HAWK_CPP_RVREF(const T& v) { return (const T&)v; } + const T& HAWK_CXX_RVREF(const T& v) { return (const T&)v; } */ - #define HAWK_CPP_RVREF(x) x + #define HAWK_CXX_RVREF(x) x #endif /// The Exception class implements the exception object. @@ -159,7 +160,7 @@ class HAWK_EXPORT Exception public: Exception ( const hawk_ooch_t* name, const hawk_ooch_t* msg, - const hawk_ooch_t* file, hawk_oow_t line) HAWK_CPP_NOEXCEPT: + const hawk_ooch_t* file, hawk_oow_t line) HAWK_CXX_NOEXCEPT: name(name), msg(msg) #if !defined(HAWK_NO_LOCATION_IN_EXCEPTION) , file(file), line(line) @@ -185,7 +186,7 @@ public: { \ public: \ ex_name (const hawk_ooch_t* name, const hawk_ooch_t* msg, \ - const hawk_ooch_t* file, hawk_oow_t line) HAWK_CPP_NOEXCEPT: \ + const hawk_ooch_t* file, hawk_oow_t line) HAWK_CXX_NOEXCEPT: \ HAWK::Exception (name, msg, file, line) {} \ } @@ -203,7 +204,7 @@ public: class HAWK_EXPORT Uncopyable { public: - Uncopyable () HAWK_CPP_NOEXCEPT {} + Uncopyable () HAWK_CXX_NOEXCEPT {} //virtual ~Uncopyable () {} private: @@ -237,7 +238,7 @@ public: /// The Mmgr() function builds a memory manager composed of bridge /// functions connecting itself with it. /// - Mmgr () HAWK_CPP_NOEXCEPT + Mmgr () HAWK_CXX_NOEXCEPT { // NOTE: // the #hawk_mmgr_t interface is not affected by raise_exception @@ -252,7 +253,7 @@ public: /// /// The ~Mmgr() function finalizes a memory manager. /// - virtual ~Mmgr () HAWK_CPP_NOEXCEPT {} + virtual ~Mmgr () HAWK_CXX_NOEXCEPT {} /// /// The allocate() function calls allocMem() for memory @@ -287,7 +288,7 @@ public: /// /// The dispose() function calls freeMem() for memory disposal. /// - void dispose (void* ptr) HAWK_CPP_NOEXCEPT + void dispose (void* ptr) HAWK_CXX_NOEXCEPT { this->freeMem (ptr); } @@ -300,7 +301,7 @@ public: /// virtual void* allocMem ( hawk_oow_t n ///< size of memory chunk to allocate in bytes - ) HAWK_CPP_NOEXCEPT = 0; + ) HAWK_CXX_NOEXCEPT = 0; /// /// The reallocMem() function resizes a chunk of memory previously @@ -311,7 +312,7 @@ public: virtual void* reallocMem ( void* ptr, ///< pointer to memory chunk to resize hawk_oow_t n ///< new size in bytes - ) HAWK_CPP_NOEXCEPT = 0; + ) HAWK_CXX_NOEXCEPT = 0; /// /// The freeMem() function frees a chunk of memory allocated with @@ -319,27 +320,27 @@ public: /// virtual void freeMem ( void* ptr ///< pointer to memory chunk to free - ) HAWK_CPP_NOEXCEPT = 0; + ) HAWK_CXX_NOEXCEPT = 0; protected: /// /// bridge function from the #hawk_mmgr_t type the allocMem() function. /// - static void* alloc_mem (mmgr_t* mmgr, hawk_oow_t n) HAWK_CPP_NOEXCEPT; + static void* alloc_mem (mmgr_t* mmgr, hawk_oow_t n) HAWK_CXX_NOEXCEPT; /// /// bridge function from the #hawk_mmgr_t type the reallocMem() function. /// - static void* realloc_mem (mmgr_t* mmgr, void* ptr, hawk_oow_t n) HAWK_CPP_NOEXCEPT; + static void* realloc_mem (mmgr_t* mmgr, void* ptr, hawk_oow_t n) HAWK_CXX_NOEXCEPT; /// /// bridge function from the #hawk_mmgr_t type the freeMem() function. /// - static void free_mem (mmgr_t* mmgr, void* ptr) HAWK_CPP_NOEXCEPT; + static void free_mem (mmgr_t* mmgr, void* ptr) HAWK_CXX_NOEXCEPT; public: - static Mmgr* getDFL () HAWK_CPP_NOEXCEPT; - static void setDFL (Mmgr* mmgr) HAWK_CPP_NOEXCEPT; + static Mmgr* getDFL () HAWK_CXX_NOEXCEPT; + static void setDFL (Mmgr* mmgr) HAWK_CXX_NOEXCEPT; protected: static Mmgr* dfl_mmgr; @@ -1821,7 +1822,7 @@ HAWK_END_NAMESPACE(HAWK) HAWK_EXPORT void* operator new (hawk_oow_t size, HAWK::Mmgr* mmgr); -#if defined(HAWK_CPP_NO_OPERATOR_DELETE_OVERLOADING) +#if defined(HAWK_CXX_NO_OPERATOR_DELETE_OVERLOADING) HAWK_EXPORT void hawk_operator_delete (void* ptr, HAWK::Mmgr* mmgr); #else HAWK_EXPORT void operator delete (void* ptr, HAWK::Mmgr* mmgr); @@ -1841,10 +1842,10 @@ void* operator new[] (hawk_oow_t size, HAWK::Mmgr* mmgr); void operator delete[] (void* ptr, HAWK::Mmgr* mmgr); #endif -#define HAWK_CPP_DELETE_WITH_MMGR(ptr, class_name, mmgr) \ +#define HAWK_CXX_DELETE_WITH_MMGR(ptr, class_name, mmgr) \ do { \ - HAWK_CPP_CALL_DESTRUCTOR (ptr, class_name); \ - HAWK_CPP_CALL_PLACEMENT_DELETE1(ptr, mmgr); \ + HAWK_CXX_CALL_DESTRUCTOR (ptr, class_name); \ + HAWK_CXX_CALL_PLACEMENT_DELETE1(ptr, mmgr); \ } while(0); #endif diff --git a/hawk/lib/HawkStd.cpp b/hawk/lib/HawkStd.cpp index 989020c7..72050907 100644 --- a/hawk/lib/HawkStd.cpp +++ b/hawk/lib/HawkStd.cpp @@ -54,17 +54,17 @@ HAWK_BEGIN_NAMESPACE(HAWK) ////////////////////////////////////////////////////////////////////////////// // MmgrStd ////////////////////////////////////////////////////////////////////////////// -void* MmgrStd::allocMem (hawk_oow_t n) HAWK_CPP_NOEXCEPT +void* MmgrStd::allocMem (hawk_oow_t n) HAWK_CXX_NOEXCEPT { return ::malloc(n); } -void* MmgrStd::reallocMem (void* ptr, hawk_oow_t n) HAWK_CPP_NOEXCEPT +void* MmgrStd::reallocMem (void* ptr, hawk_oow_t n) HAWK_CXX_NOEXCEPT { return ::realloc(ptr, n); } -void MmgrStd::freeMem (void* ptr) HAWK_CPP_NOEXCEPT +void MmgrStd::freeMem (void* ptr) HAWK_CXX_NOEXCEPT { ::free (ptr); } diff --git a/hawk/lib/HawkStd.hpp b/hawk/lib/HawkStd.hpp index 23853fd2..1e40918d 100644 --- a/hawk/lib/HawkStd.hpp +++ b/hawk/lib/HawkStd.hpp @@ -39,15 +39,15 @@ HAWK_BEGIN_NAMESPACE(HAWK) class HAWK_EXPORT MmgrStd: public Mmgr { public: - MmgrStd () HAWK_CPP_NOEXCEPT: Mmgr () {} + MmgrStd () HAWK_CXX_NOEXCEPT: Mmgr () {} - void* allocMem (hawk_oow_t n) HAWK_CPP_NOEXCEPT; - void* reallocMem (void* ptr, hawk_oow_t n) HAWK_CPP_NOEXCEPT; - void freeMem (void* ptr) HAWK_CPP_NOEXCEPT; + void* allocMem (hawk_oow_t n) HAWK_CXX_NOEXCEPT; + void* reallocMem (void* ptr, hawk_oow_t n) HAWK_CXX_NOEXCEPT; + void freeMem (void* ptr) HAWK_CXX_NOEXCEPT; #if 0 /// The getInstance() function returns the stock instance of the MmgrStd class. - static MmgrStd* getInstance () HAWK_CPP_NOEXCEPT; + static MmgrStd* getInstance () HAWK_CXX_NOEXCEPT; #endif }; diff --git a/hawk/lib/Makefile.in b/hawk/lib/Makefile.in index ab723de5..436d8314 100644 --- a/hawk/lib/Makefile.in +++ b/hawk/lib/Makefile.in @@ -119,6 +119,7 @@ host_triplet = @host@ subdir = lib ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -440,6 +441,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/lib/hawk-cfg.h.in b/hawk/lib/hawk-cfg.h.in index 09ac425f..4900d096 100644 --- a/hawk/lib/hawk-cfg.h.in +++ b/hawk/lib/hawk-cfg.h.in @@ -111,6 +111,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_CRT_EXTERNS_H +/* define if the compiler supports basic C++11 syntax */ +#undef HAVE_CXX11 + /* Define if c++ supports namespace std. */ #undef HAVE_CXX_NAMESPACE_STD diff --git a/hawk/m4/ax_cxx_compile_stdcxx.m4 b/hawk/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 00000000..43087b2e --- /dev/null +++ b/hawk/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,951 @@ +# =========================================================================== +# 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 +# Copyright (c) 2019 Enji Cooper +# +# 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 11 + +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 ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + 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/hawk/mod/Makefile.in b/hawk/mod/Makefile.in index d3f42bd9..633af056 100644 --- a/hawk/mod/Makefile.in +++ b/hawk/mod/Makefile.in @@ -95,6 +95,7 @@ host_triplet = @host@ subdir = mod ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -272,6 +273,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/samples/Makefile.in b/hawk/samples/Makefile.in index 8497cf9b..aac3fa7c 100644 --- a/hawk/samples/Makefile.in +++ b/hawk/samples/Makefile.in @@ -93,6 +93,7 @@ bin_PROGRAMS = $(am__EXEEXT_1) subdir = samples ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -245,6 +246,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/t/Makefile.in b/hawk/t/Makefile.in index ed4a459d..3f7c71ec 100644 --- a/hawk/t/Makefile.in +++ b/hawk/t/Makefile.in @@ -91,6 +91,7 @@ check_PROGRAMS = t-001$(EXEEXT) t-002$(EXEEXT) t-005$(EXEEXT) subdir = t ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -422,6 +423,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@ diff --git a/hawk/tools/Makefile.in b/hawk/tools/Makefile.in index 56432d92..3bcd9676 100644 --- a/hawk/tools/Makefile.in +++ b/hawk/tools/Makefile.in @@ -92,6 +92,7 @@ bin_PROGRAMS = uni-case$(EXEEXT) uni-prop$(EXEEXT) subdir = tools ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ $(top_srcdir)/m4/ax_cxx_namespace.m4 \ $(top_srcdir)/m4/ax_lib_mysql.m4 $(top_srcdir)/m4/ax_numval.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ @@ -223,6 +224,7 @@ FFI_LIBS = @FFI_LIBS@ FGREP = @FGREP@ GREP = @GREP@ HAVE_CXX = @HAVE_CXX@ +HAVE_CXX11 = @HAVE_CXX11@ HAWK_PROJECT_AUTHOR = @HAWK_PROJECT_AUTHOR@ HAWK_PROJECT_URL = @HAWK_PROJECT_URL@ HAWK_SIZEOF_CHAR = @HAWK_SIZEOF_CHAR@