m4/ax_cxx_compile_stdcxx.m4

   1 # ===========================================================================
   2 #   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
   3 # ===========================================================================
   4 #
   5 # SYNOPSIS
   6 #
   7 #   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
   8 #
   9 # DESCRIPTION
  10 #
  11 #   Check for baseline language coverage in the compiler for the specified
  12 #   version of the C++ standard.  If necessary, add switches to CXX and
  13 #   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
  14 #   or '14' (for the C++14 standard).
  15 #
  16 #   The second argument, if specified, indicates whether you insist on an
  17 #   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
  18 #   -std=c++11).  If neither is specified, you get whatever works, with
  19 #   preference for an extended mode.
  20 #
  21 #   The third argument, if specified 'mandatory' or if left unspecified,
  22 #   indicates that baseline support for the specified C++ standard is
  23 #   required and that the macro should error out if no mode with that
  24 #   support is found.  If specified 'optional', then configuration proceeds
  25 #   regardless, after defining HAVE_CXX${VERSION} if and only if a
  26 #   supporting mode is found.
  27 #
  28 # LICENSE
  29 #
  30 #   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
  31 #   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
  32 #   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
  33 #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
  34 #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
  35 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
  36 #
  37 #   Copying and distribution of this file, with or without modification, are
  38 #   permitted in any medium without royalty provided the copyright notice
  39 #   and this notice are preserved.  This file is offered as-is, without any
  40 #   warranty.
  41
  42 #serial 4
  43
  44 dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
  45 dnl  (serial version number 13).
  46
  47 AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
  48   m4_if([$1], [11], [],
  49         [$1], [14], [],
  50         [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])],
  51         [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
  52   m4_if([$2], [], [],
  53         [$2], [ext], [],
  54         [$2], [noext], [],
  55         [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
  56   m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
  57         [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
  58         [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
  59         [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
  60   AC_LANG_PUSH([C++])dnl
  61   ac_success=no
  62   AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
  63   ax_cv_cxx_compile_cxx$1,
  64   [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
  65     [ax_cv_cxx_compile_cxx$1=yes],
  66     [ax_cv_cxx_compile_cxx$1=no])])
  67   if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
  68     ac_success=yes
  69   fi
  70
  71   m4_if([$2], [noext], [], [dnl
  72   if test x$ac_success = xno; then
  73     for switch in -std=gnu++$1 -std=gnu++0x; do
  74       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
  75       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
  76                      $cachevar,
  77         [ac_save_CXX="$CXX"
  78          CXX="$CXX $switch"
  79          AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
  80           [eval $cachevar=yes],
  81           [eval $cachevar=no])
  82          CXX="$ac_save_CXX"])
  83       if eval test x\$$cachevar = xyes; then
  84         CXX="$CXX $switch"
  85         if test -n "$CXXCPP" ; then
  86           CXXCPP="$CXXCPP $switch"
  87         fi
  88         ac_success=yes
  89         break
  90       fi
  91     done
  92   fi])
  93
  94   m4_if([$2], [ext], [], [dnl
  95   if test x$ac_success = xno; then
  96     dnl HP's aCC needs +std=c++11 according to:
  97     dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
  98     dnl Cray's crayCC needs "-h std=c++11"
  99     for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do
 100       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
 101       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
 102                      $cachevar,
 103         [ac_save_CXX="$CXX"
 104          CXX="$CXX $switch"
 105          AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
 106           [eval $cachevar=yes],
 107           [eval $cachevar=no])
 108          CXX="$ac_save_CXX"])
 109       if eval test x\$$cachevar = xyes; then
 110         CXX="$CXX $switch"
 111         if test -n "$CXXCPP" ; then
 112           CXXCPP="$CXXCPP $switch"
 113         fi
 114         ac_success=yes
 115         break
 116       fi
 117     done
 118   fi])
 119   AC_LANG_POP([C++])
 120   if test x$ax_cxx_compile_cxx$1_required = xtrue; then
 121     if test x$ac_success = xno; then
 122       AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
 123     fi
 124   fi
 125   if test x$ac_success = xno; then
 126     HAVE_CXX$1=0
 127     AC_MSG_NOTICE([No compiler with C++$1 support was found])
 128   else
 129     HAVE_CXX$1=1
 130     AC_DEFINE(HAVE_CXX$1,1,
 131               [define if the compiler supports basic C++$1 syntax])
 132   fi
 133   AC_SUBST(HAVE_CXX$1)
 134 ])
 135
 136
 137 dnl  Test body for checking C++11 support
 138
 139 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
 140   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 141 )
 142
 143
 144 dnl  Test body for checking C++14 support
 145
 146 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
 147   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 148   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 149 )
 150
 151
 152 dnl  Tests for new features in C++11
 153
 154 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
 155
 156 // If the compiler admits that it is not ready for C++11, why torture it?
 157 // Hopefully, this will speed up the test.
 158
 159 #ifndef __cplusplus
 160
 161 #error "This is not a C++ compiler"
 162
 163 #elif __cplusplus < 201103L
 164
 165 #error "This is not a C++11 compiler"
 166
 167 #else
 168
 169 namespace cxx11
 170 {
 171
 172   namespace test_static_assert
 173   {
 174
 175     template <typename T>
 176     struct check
 177     {
 178       static_assert(sizeof(int) <= sizeof(T), "not big enough");
 179     };
 180
 181   }
 182
 183   namespace test_final_override
 184   {
 185
 186     struct Base
 187     {
 188       virtual void f() {}
 189     };
 190
 191     struct Derived : public Base
 192     {
 193       virtual void f() override {}
 194     };
 195
 196   }
 197
 198   namespace test_double_right_angle_brackets
 199   {
 200
 201     template < typename T >
 202     struct check {};
 203
 204     typedef check<void> single_type;
 205     typedef check<check<void>> double_type;
 206     typedef check<check<check<void>>> triple_type;
 207     typedef check<check<check<check<void>>>> quadruple_type;
 208
 209   }
 210
 211   namespace test_decltype
 212   {
 213
 214     int
 215     f()
 216     {
 217       int a = 1;
 218       decltype(a) b = 2;
 219       return a + b;
 220     }
 221
 222   }
 223
 224   namespace test_type_deduction
 225   {
 226
 227     template < typename T1, typename T2 >
 228     struct is_same
 229     {
 230       static const bool value = false;
 231     };
 232
 233     template < typename T >
 234     struct is_same<T, T>
 235     {
 236       static const bool value = true;
 237     };
 238
 239     template < typename T1, typename T2 >
 240     auto
 241     add(T1 a1, T2 a2) -> decltype(a1 + a2)
 242     {
 243       return a1 + a2;
 244     }
 245
 246     int
 247     test(const int c, volatile int v)
 248     {
 249       static_assert(is_same<int, decltype(0)>::value == true, "");
 250       static_assert(is_same<int, decltype(c)>::value == false, "");
 251       static_assert(is_same<int, decltype(v)>::value == false, "");
 252       auto ac = c;
 253       auto av = v;
 254       auto sumi = ac + av + 'x';
 255       auto sumf = ac + av + 1.0;
 256       static_assert(is_same<int, decltype(ac)>::value == true, "");
 257       static_assert(is_same<int, decltype(av)>::value == true, "");
 258       static_assert(is_same<int, decltype(sumi)>::value == true, "");
 259       static_assert(is_same<int, decltype(sumf)>::value == false, "");
 260       static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
 261       return (sumf > 0.0) ? sumi : add(c, v);
 262     }
 263
 264   }
 265
 266   namespace test_noexcept
 267   {
 268
 269     int f() { return 0; }
 270     int g() noexcept { return 0; }
 271
 272     static_assert(noexcept(f()) == false, "");
 273     static_assert(noexcept(g()) == true, "");
 274
 275   }
 276
 277   namespace test_constexpr
 278   {
 279
 280     template < typename CharT >
 281     unsigned long constexpr
 282     strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
 283     {
 284       return *s ? strlen_c_r(s + 1, acc + 1) : acc;
 285     }
 286
 287     template < typename CharT >
 288     unsigned long constexpr
 289     strlen_c(const CharT *const s) noexcept
 290     {
 291       return strlen_c_r(s, 0UL);
 292     }
 293
 294     static_assert(strlen_c("") == 0UL, "");
 295     static_assert(strlen_c("1") == 1UL, "");
 296     static_assert(strlen_c("example") == 7UL, "");
 297     static_assert(strlen_c("another\0example") == 7UL, "");
 298
 299   }
 300
 301   namespace test_rvalue_references
 302   {
 303
 304     template < int N >
 305     struct answer
 306     {
 307       static constexpr int value = N;
 308     };
 309
 310     answer<1> f(int&)       { return answer<1>(); }
 311     answer<2> f(const int&) { return answer<2>(); }
 312     answer<3> f(int&&)      { return answer<3>(); }
 313
 314     void
 315     test()
 316     {
 317       int i = 0;
 318       const int c = 0;
 319       static_assert(decltype(f(i))::value == 1, "");
 320       static_assert(decltype(f(c))::value == 2, "");
 321       static_assert(decltype(f(0))::value == 3, "");
 322     }
 323
 324   }
 325
 326   namespace test_uniform_initialization
 327   {
 328
 329     struct test
 330     {
 331       static const int zero {};
 332       static const int one {1};
 333     };
 334
 335     static_assert(test::zero == 0, "");
 336     static_assert(test::one == 1, "");
 337
 338   }
 339
 340   namespace test_lambdas
 341   {
 342
 343     void
 344     test1()
 345     {
 346       auto lambda1 = [](){};
 347       auto lambda2 = lambda1;
 348       lambda1();
 349       lambda2();
 350     }
 351
 352     int
 353     test2()
 354     {
 355       auto a = [](int i, int j){ return i + j; }(1, 2);
 356       auto b = []() -> int { return '0'; }();
 357       auto c = [=](){ return a + b; }();
 358       auto d = [&](){ return c; }();
 359       auto e = [a, &b](int x) mutable {
 360         const auto identity = [](int y){ return y; };
 361         for (auto i = 0; i < a; ++i)
 362           a += b--;
 363         return x + identity(a + b);
 364       }(0);
 365       return a + b + c + d + e;
 366     }
 367
 368     int
 369     test3()
 370     {
 371       const auto nullary = [](){ return 0; };
 372       const auto unary = [](int x){ return x; };
 373       using nullary_t = decltype(nullary);
 374       using unary_t = decltype(unary);
 375       const auto higher1st = [](nullary_t f){ return f(); };
 376       const auto higher2nd = [unary](nullary_t f1){
 377         return [unary, f1](unary_t f2){ return f2(unary(f1())); };
 378       };
 379       return higher1st(nullary) + higher2nd(nullary)(unary);
 380     }
 381
 382   }
 383
 384   namespace test_variadic_templates
 385   {
 386
 387     template <int...>
 388     struct sum;
 389
 390     template <int N0, int... N1toN>
 391     struct sum<N0, N1toN...>
 392     {
 393       static constexpr auto value = N0 + sum<N1toN...>::value;
 394     };
 395
 396     template <>
 397     struct sum<>
 398     {
 399       static constexpr auto value = 0;
 400     };
 401
 402     static_assert(sum<>::value == 0, "");
 403     static_assert(sum<1>::value == 1, "");
 404     static_assert(sum<23>::value == 23, "");
 405     static_assert(sum<1, 2>::value == 3, "");
 406     static_assert(sum<5, 5, 11>::value == 21, "");
 407     static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
 408
 409   }
 410
 411   // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
 412   // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
 413   // because of this.
 414   namespace test_template_alias_sfinae
 415   {
 416
 417     struct foo {};
 418
 419     template<typename T>
 420     using member = typename T::member_type;
 421
 422     template<typename T>
 423     void func(...) {}
 424
 425     template<typename T>
 426     void func(member<T>*) {}
 427
 428     void test();
 429
 430     void test() { func<foo>(0); }
 431
 432   }
 433
 434 }  // namespace cxx11
 435
 436 #endif  // __cplusplus >= 201103L
 437
 438 ]])
 439
 440
 441 dnl  Tests for new features in C++14
 442
 443 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
 444
 445 // If the compiler admits that it is not ready for C++14, why torture it?
 446 // Hopefully, this will speed up the test.
 447
 448 #ifndef __cplusplus
 449
 450 #error "This is not a C++ compiler"
 451
 452 #elif __cplusplus < 201402L
 453
 454 #error "This is not a C++14 compiler"
 455
 456 #else
 457
 458 namespace cxx14
 459 {
 460
 461   namespace test_polymorphic_lambdas
 462   {
 463
 464     int
 465     test()
 466     {
 467       const auto lambda = [](auto&&... args){
 468         const auto istiny = [](auto x){
 469           return (sizeof(x) == 1UL) ? 1 : 0;
 470         };
 471         const int aretiny[] = { istiny(args)... };
 472         return aretiny[0];
 473       };
 474       return lambda(1, 1L, 1.0f, '1');
 475     }
 476
 477   }
 478
 479   namespace test_binary_literals
 480   {
 481
 482     constexpr auto ivii = 0b0000000000101010;
 483     static_assert(ivii == 42, "wrong value");
 484
 485   }
 486
 487   namespace test_generalized_constexpr
 488   {
 489
 490     template < typename CharT >
 491     constexpr unsigned long
 492     strlen_c(const CharT *const s) noexcept
 493     {
 494       auto length = 0UL;
 495       for (auto p = s; *p; ++p)
 496         ++length;
 497       return length;
 498     }
 499
 500     static_assert(strlen_c("") == 0UL, "");
 501     static_assert(strlen_c("x") == 1UL, "");
 502     static_assert(strlen_c("test") == 4UL, "");
 503     static_assert(strlen_c("another\0test") == 7UL, "");
 504
 505   }
 506
 507   namespace test_lambda_init_capture
 508   {
 509
 510     int
 511     test()
 512     {
 513       auto x = 0;
 514       const auto lambda1 = [a = x](int b){ return a + b; };
 515       const auto lambda2 = [a = lambda1(x)](){ return a; };
 516       return lambda2();
 517     }
 518
 519   }
 520
 521   namespace test_digit_seperators
 522   {
 523
 524     constexpr auto ten_million = 100'000'000;
 525     static_assert(ten_million == 100000000, "");
 526
 527   }
 528
 529   namespace test_return_type_deduction
 530   {
 531
 532     auto f(int& x) { return x; }
 533     decltype(auto) g(int& x) { return x; }
 534
 535     template < typename T1, typename T2 >
 536     struct is_same
 537     {
 538       static constexpr auto value = false;
 539     };
 540
 541     template < typename T >
 542     struct is_same<T, T>
 543     {
 544       static constexpr auto value = true;
 545     };
 546
 547     int
 548     test()
 549     {
 550       auto x = 0;
 551       static_assert(is_same<int, decltype(f(x))>::value, "");
 552       static_assert(is_same<int&, decltype(g(x))>::value, "");
 553       return x;
 554     }
 555
 556   }
 557
 558 }  // namespace cxx14
 559
 560 #endif  // __cplusplus >= 201402L
 561
 562 ]])