source: trunk/m4/ax_cxx_compile_stdcxx.m4 @ 4216

Last change on this file since 4216 was 4216, checked in by Peter, 5 months ago

update to autoconf-archive-2022.09.03

  • Property svn:eol-style set to native
File size: 20.6 KB
Line 
1# ===========================================================================
2#  https://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', '14', '17', or '20' for
14#   the respective C++ standard version.
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 no added switch, and then 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#   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
37#   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
38#   Copyright (c) 2020 Jason Merrill <jason@redhat.com>
39#   Copyright (c) 2021 Jörn Heusipp <osmanx@problemloesungsmaschine.de>
40#
41#   Copying and distribution of this file, with or without modification, are
42#   permitted in any medium without royalty provided the copyright notice
43#   and this notice are preserved.  This file is offered as-is, without any
44#   warranty.
45
46#serial 15
47
48dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
49dnl  (serial version number 13).
50
51AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
52  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
53        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
54        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
55        [$1], [20], [ax_cxx_compile_alternatives="20"],
56        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
57  m4_if([$2], [], [],
58        [$2], [ext], [],
59        [$2], [noext], [],
60        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
61  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
62        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
63        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
64        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
65  AC_LANG_PUSH([C++])dnl
66  ac_success=no
67
68  m4_if([$2], [], [dnl
69    AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
70       ax_cv_cxx_compile_cxx$1,
71      [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
72        [ax_cv_cxx_compile_cxx$1=yes],
73        [ax_cv_cxx_compile_cxx$1=no])])
74    if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
75      ac_success=yes
76    fi])
77
78  m4_if([$2], [noext], [], [dnl
79  if test x$ac_success = xno; then
80    for alternative in ${ax_cxx_compile_alternatives}; do
81      switch="-std=gnu++${alternative}"
82      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
83      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
84                     $cachevar,
85        [ac_save_CXX="$CXX"
86         CXX="$CXX $switch"
87         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
88          [eval $cachevar=yes],
89          [eval $cachevar=no])
90         CXX="$ac_save_CXX"])
91      if eval test x\$$cachevar = xyes; then
92        CXX="$CXX $switch"
93        if test -n "$CXXCPP" ; then
94          CXXCPP="$CXXCPP $switch"
95        fi
96        ac_success=yes
97        break
98      fi
99    done
100  fi])
101
102  m4_if([$2], [ext], [], [dnl
103  if test x$ac_success = xno; then
104    dnl HP's aCC needs +std=c++11 according to:
105    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
106    dnl Cray's crayCC needs "-h std=c++11"
107    for alternative in ${ax_cxx_compile_alternatives}; do
108      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
109        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
110        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
111                       $cachevar,
112          [ac_save_CXX="$CXX"
113           CXX="$CXX $switch"
114           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
115            [eval $cachevar=yes],
116            [eval $cachevar=no])
117           CXX="$ac_save_CXX"])
118        if eval test x\$$cachevar = xyes; then
119          CXX="$CXX $switch"
120          if test -n "$CXXCPP" ; then
121            CXXCPP="$CXXCPP $switch"
122          fi
123          ac_success=yes
124          break
125        fi
126      done
127      if test x$ac_success = xyes; then
128        break
129      fi
130    done
131  fi])
132  AC_LANG_POP([C++])
133  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
134    if test x$ac_success = xno; then
135      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
136    fi
137  fi
138  if test x$ac_success = xno; then
139    HAVE_CXX$1=0
140    AC_MSG_NOTICE([No compiler with C++$1 support was found])
141  else
142    HAVE_CXX$1=1
143    AC_DEFINE(HAVE_CXX$1,1,
144              [define if the compiler supports basic C++$1 syntax])
145  fi
146  AC_SUBST(HAVE_CXX$1)
147])
148
149
150dnl  Test body for checking C++11 support
151
152m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
153  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
154)
155
156dnl  Test body for checking C++14 support
157
158m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
159  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
160  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
161)
162
163dnl  Test body for checking C++17 support
164
165m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
166  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
167  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
168  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
169)
170
171dnl  Test body for checking C++20 support
172
173m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20],
174  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
175  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
176  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
177  _AX_CXX_COMPILE_STDCXX_testbody_new_in_20
178)
179
180
181dnl  Tests for new features in C++11
182
183m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
184
185// If the compiler admits that it is not ready for C++11, why torture it?
186// Hopefully, this will speed up the test.
187
188#ifndef __cplusplus
189
190#error "This is not a C++ compiler"
191
192// MSVC always sets __cplusplus to 199711L in older versions; newer versions
193// only set it correctly if /Zc:__cplusplus is specified as well as a
194// /std:c++NN switch:
195// https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
196#elif __cplusplus < 201103L && !defined _MSC_VER
197
198#error "This is not a C++11 compiler"
199
200#else
201
202namespace cxx11
203{
204
205  namespace test_static_assert
206  {
207
208    template <typename T>
209    struct check
210    {
211      static_assert(sizeof(int) <= sizeof(T), "not big enough");
212    };
213
214  }
215
216  namespace test_final_override
217  {
218
219    struct Base
220    {
221      virtual ~Base() {}
222      virtual void f() {}
223    };
224
225    struct Derived : public Base
226    {
227      virtual ~Derived() override {}
228      virtual void f() override {}
229    };
230
231  }
232
233  namespace test_double_right_angle_brackets
234  {
235
236    template < typename T >
237    struct check {};
238
239    typedef check<void> single_type;
240    typedef check<check<void>> double_type;
241    typedef check<check<check<void>>> triple_type;
242    typedef check<check<check<check<void>>>> quadruple_type;
243
244  }
245
246  namespace test_decltype
247  {
248
249    int
250    f()
251    {
252      int a = 1;
253      decltype(a) b = 2;
254      return a + b;
255    }
256
257  }
258
259  namespace test_type_deduction
260  {
261
262    template < typename T1, typename T2 >
263    struct is_same
264    {
265      static const bool value = false;
266    };
267
268    template < typename T >
269    struct is_same<T, T>
270    {
271      static const bool value = true;
272    };
273
274    template < typename T1, typename T2 >
275    auto
276    add(T1 a1, T2 a2) -> decltype(a1 + a2)
277    {
278      return a1 + a2;
279    }
280
281    int
282    test(const int c, volatile int v)
283    {
284      static_assert(is_same<int, decltype(0)>::value == true, "");
285      static_assert(is_same<int, decltype(c)>::value == false, "");
286      static_assert(is_same<int, decltype(v)>::value == false, "");
287      auto ac = c;
288      auto av = v;
289      auto sumi = ac + av + 'x';
290      auto sumf = ac + av + 1.0;
291      static_assert(is_same<int, decltype(ac)>::value == true, "");
292      static_assert(is_same<int, decltype(av)>::value == true, "");
293      static_assert(is_same<int, decltype(sumi)>::value == true, "");
294      static_assert(is_same<int, decltype(sumf)>::value == false, "");
295      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
296      return (sumf > 0.0) ? sumi : add(c, v);
297    }
298
299  }
300
301  namespace test_noexcept
302  {
303
304    int f() { return 0; }
305    int g() noexcept { return 0; }
306
307    static_assert(noexcept(f()) == false, "");
308    static_assert(noexcept(g()) == true, "");
309
310  }
311
312  namespace test_constexpr
313  {
314
315    template < typename CharT >
316    unsigned long constexpr
317    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
318    {
319      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
320    }
321
322    template < typename CharT >
323    unsigned long constexpr
324    strlen_c(const CharT *const s) noexcept
325    {
326      return strlen_c_r(s, 0UL);
327    }
328
329    static_assert(strlen_c("") == 0UL, "");
330    static_assert(strlen_c("1") == 1UL, "");
331    static_assert(strlen_c("example") == 7UL, "");
332    static_assert(strlen_c("another\0example") == 7UL, "");
333
334  }
335
336  namespace test_rvalue_references
337  {
338
339    template < int N >
340    struct answer
341    {
342      static constexpr int value = N;
343    };
344
345    answer<1> f(int&)       { return answer<1>(); }
346    answer<2> f(const int&) { return answer<2>(); }
347    answer<3> f(int&&)      { return answer<3>(); }
348
349    void
350    test()
351    {
352      int i = 0;
353      const int c = 0;
354      static_assert(decltype(f(i))::value == 1, "");
355      static_assert(decltype(f(c))::value == 2, "");
356      static_assert(decltype(f(0))::value == 3, "");
357    }
358
359  }
360
361  namespace test_uniform_initialization
362  {
363
364    struct test
365    {
366      static const int zero {};
367      static const int one {1};
368    };
369
370    static_assert(test::zero == 0, "");
371    static_assert(test::one == 1, "");
372
373  }
374
375  namespace test_lambdas
376  {
377
378    void
379    test1()
380    {
381      auto lambda1 = [](){};
382      auto lambda2 = lambda1;
383      lambda1();
384      lambda2();
385    }
386
387    int
388    test2()
389    {
390      auto a = [](int i, int j){ return i + j; }(1, 2);
391      auto b = []() -> int { return '0'; }();
392      auto c = [=](){ return a + b; }();
393      auto d = [&](){ return c; }();
394      auto e = [a, &b](int x) mutable {
395        const auto identity = [](int y){ return y; };
396        for (auto i = 0; i < a; ++i)
397          a += b--;
398        return x + identity(a + b);
399      }(0);
400      return a + b + c + d + e;
401    }
402
403    int
404    test3()
405    {
406      const auto nullary = [](){ return 0; };
407      const auto unary = [](int x){ return x; };
408      using nullary_t = decltype(nullary);
409      using unary_t = decltype(unary);
410      const auto higher1st = [](nullary_t f){ return f(); };
411      const auto higher2nd = [unary](nullary_t f1){
412        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
413      };
414      return higher1st(nullary) + higher2nd(nullary)(unary);
415    }
416
417  }
418
419  namespace test_variadic_templates
420  {
421
422    template <int...>
423    struct sum;
424
425    template <int N0, int... N1toN>
426    struct sum<N0, N1toN...>
427    {
428      static constexpr auto value = N0 + sum<N1toN...>::value;
429    };
430
431    template <>
432    struct sum<>
433    {
434      static constexpr auto value = 0;
435    };
436
437    static_assert(sum<>::value == 0, "");
438    static_assert(sum<1>::value == 1, "");
439    static_assert(sum<23>::value == 23, "");
440    static_assert(sum<1, 2>::value == 3, "");
441    static_assert(sum<5, 5, 11>::value == 21, "");
442    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
443
444  }
445
446  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
447  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
448  // because of this.
449  namespace test_template_alias_sfinae
450  {
451
452    struct foo {};
453
454    template<typename T>
455    using member = typename T::member_type;
456
457    template<typename T>
458    void func(...) {}
459
460    template<typename T>
461    void func(member<T>*) {}
462
463    void test();
464
465    void test() { func<foo>(0); }
466
467  }
468
469}  // namespace cxx11
470
471#endif  // __cplusplus >= 201103L
472
473]])
474
475
476dnl  Tests for new features in C++14
477
478m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
479
480// If the compiler admits that it is not ready for C++14, why torture it?
481// Hopefully, this will speed up the test.
482
483#ifndef __cplusplus
484
485#error "This is not a C++ compiler"
486
487#elif __cplusplus < 201402L && !defined _MSC_VER
488
489#error "This is not a C++14 compiler"
490
491#else
492
493namespace cxx14
494{
495
496  namespace test_polymorphic_lambdas
497  {
498
499    int
500    test()
501    {
502      const auto lambda = [](auto&&... args){
503        const auto istiny = [](auto x){
504          return (sizeof(x) == 1UL) ? 1 : 0;
505        };
506        const int aretiny[] = { istiny(args)... };
507        return aretiny[0];
508      };
509      return lambda(1, 1L, 1.0f, '1');
510    }
511
512  }
513
514  namespace test_binary_literals
515  {
516
517    constexpr auto ivii = 0b0000000000101010;
518    static_assert(ivii == 42, "wrong value");
519
520  }
521
522  namespace test_generalized_constexpr
523  {
524
525    template < typename CharT >
526    constexpr unsigned long
527    strlen_c(const CharT *const s) noexcept
528    {
529      auto length = 0UL;
530      for (auto p = s; *p; ++p)
531        ++length;
532      return length;
533    }
534
535    static_assert(strlen_c("") == 0UL, "");
536    static_assert(strlen_c("x") == 1UL, "");
537    static_assert(strlen_c("test") == 4UL, "");
538    static_assert(strlen_c("another\0test") == 7UL, "");
539
540  }
541
542  namespace test_lambda_init_capture
543  {
544
545    int
546    test()
547    {
548      auto x = 0;
549      const auto lambda1 = [a = x](int b){ return a + b; };
550      const auto lambda2 = [a = lambda1(x)](){ return a; };
551      return lambda2();
552    }
553
554  }
555
556  namespace test_digit_separators
557  {
558
559    constexpr auto ten_million = 100'000'000;
560    static_assert(ten_million == 100000000, "");
561
562  }
563
564  namespace test_return_type_deduction
565  {
566
567    auto f(int& x) { return x; }
568    decltype(auto) g(int& x) { return x; }
569
570    template < typename T1, typename T2 >
571    struct is_same
572    {
573      static constexpr auto value = false;
574    };
575
576    template < typename T >
577    struct is_same<T, T>
578    {
579      static constexpr auto value = true;
580    };
581
582    int
583    test()
584    {
585      auto x = 0;
586      static_assert(is_same<int, decltype(f(x))>::value, "");
587      static_assert(is_same<int&, decltype(g(x))>::value, "");
588      return x;
589    }
590
591  }
592
593}  // namespace cxx14
594
595#endif  // __cplusplus >= 201402L
596
597]])
598
599
600dnl  Tests for new features in C++17
601
602m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
603
604// If the compiler admits that it is not ready for C++17, why torture it?
605// Hopefully, this will speed up the test.
606
607#ifndef __cplusplus
608
609#error "This is not a C++ compiler"
610
611#elif __cplusplus < 201703L && !defined _MSC_VER
612
613#error "This is not a C++17 compiler"
614
615#else
616
617#include <initializer_list>
618#include <utility>
619#include <type_traits>
620
621namespace cxx17
622{
623
624  namespace test_constexpr_lambdas
625  {
626
627    constexpr int foo = [](){return 42;}();
628
629  }
630
631  namespace test::nested_namespace::definitions
632  {
633
634  }
635
636  namespace test_fold_expression
637  {
638
639    template<typename... Args>
640    int multiply(Args... args)
641    {
642      return (args * ... * 1);
643    }
644
645    template<typename... Args>
646    bool all(Args... args)
647    {
648      return (args && ...);
649    }
650
651  }
652
653  namespace test_extended_static_assert
654  {
655
656    static_assert (true);
657
658  }
659
660  namespace test_auto_brace_init_list
661  {
662
663    auto foo = {5};
664    auto bar {5};
665
666    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
667    static_assert(std::is_same<int, decltype(bar)>::value);
668  }
669
670  namespace test_typename_in_template_template_parameter
671  {
672
673    template<template<typename> typename X> struct D;
674
675  }
676
677  namespace test_fallthrough_nodiscard_maybe_unused_attributes
678  {
679
680    int f1()
681    {
682      return 42;
683    }
684
685    [[nodiscard]] int f2()
686    {
687      [[maybe_unused]] auto unused = f1();
688
689      switch (f1())
690      {
691      case 17:
692        f1();
693        [[fallthrough]];
694      case 42:
695        f1();
696      }
697      return f1();
698    }
699
700  }
701
702  namespace test_extended_aggregate_initialization
703  {
704
705    struct base1
706    {
707      int b1, b2 = 42;
708    };
709
710    struct base2
711    {
712      base2() {
713        b3 = 42;
714      }
715      int b3;
716    };
717
718    struct derived : base1, base2
719    {
720        int d;
721    };
722
723    derived d1 {{1, 2}, {}, 4};  // full initialization
724    derived d2 {{}, {}, 4};      // value-initialized bases
725
726  }
727
728  namespace test_general_range_based_for_loop
729  {
730
731    struct iter
732    {
733      int i;
734
735      int& operator* ()
736      {
737        return i;
738      }
739
740      const int& operator* () const
741      {
742        return i;
743      }
744
745      iter& operator++()
746      {
747        ++i;
748        return *this;
749      }
750    };
751
752    struct sentinel
753    {
754      int i;
755    };
756
757    bool operator== (const iter& i, const sentinel& s)
758    {
759      return i.i == s.i;
760    }
761
762    bool operator!= (const iter& i, const sentinel& s)
763    {
764      return !(i == s);
765    }
766
767    struct range
768    {
769      iter begin() const
770      {
771        return {0};
772      }
773
774      sentinel end() const
775      {
776        return {5};
777      }
778    };
779
780    void f()
781    {
782      range r {};
783
784      for (auto i : r)
785      {
786        [[maybe_unused]] auto v = i;
787      }
788    }
789
790  }
791
792  namespace test_lambda_capture_asterisk_this_by_value
793  {
794
795    struct t
796    {
797      int i;
798      int foo()
799      {
800        return [*this]()
801        {
802          return i;
803        }();
804      }
805    };
806
807  }
808
809  namespace test_enum_class_construction
810  {
811
812    enum class byte : unsigned char
813    {};
814
815    byte foo {42};
816
817  }
818
819  namespace test_constexpr_if
820  {
821
822    template <bool cond>
823    int f ()
824    {
825      if constexpr(cond)
826      {
827        return 13;
828      }
829      else
830      {
831        return 42;
832      }
833    }
834
835  }
836
837  namespace test_selection_statement_with_initializer
838  {
839
840    int f()
841    {
842      return 13;
843    }
844
845    int f2()
846    {
847      if (auto i = f(); i > 0)
848      {
849        return 3;
850      }
851
852      switch (auto i = f(); i + 4)
853      {
854      case 17:
855        return 2;
856
857      default:
858        return 1;
859      }
860    }
861
862  }
863
864  namespace test_template_argument_deduction_for_class_templates
865  {
866
867    template <typename T1, typename T2>
868    struct pair
869    {
870      pair (T1 p1, T2 p2)
871        : m1 {p1},
872          m2 {p2}
873      {}
874
875      T1 m1;
876      T2 m2;
877    };
878
879    void f()
880    {
881      [[maybe_unused]] auto p = pair{13, 42u};
882    }
883
884  }
885
886  namespace test_non_type_auto_template_parameters
887  {
888
889    template <auto n>
890    struct B
891    {};
892
893    B<5> b1;
894    B<'a'> b2;
895
896  }
897
898  namespace test_structured_bindings
899  {
900
901    int arr[2] = { 1, 2 };
902    std::pair<int, int> pr = { 1, 2 };
903
904    auto f1() -> int(&)[2]
905    {
906      return arr;
907    }
908
909    auto f2() -> std::pair<int, int>&
910    {
911      return pr;
912    }
913
914    struct S
915    {
916      int x1 : 2;
917      volatile double y1;
918    };
919
920    S f3()
921    {
922      return {};
923    }
924
925    auto [ x1, y1 ] = f1();
926    auto& [ xr1, yr1 ] = f1();
927    auto [ x2, y2 ] = f2();
928    auto& [ xr2, yr2 ] = f2();
929    const auto [ x3, y3 ] = f3();
930
931  }
932
933  namespace test_exception_spec_type_system
934  {
935
936    struct Good {};
937    struct Bad {};
938
939    void g1() noexcept;
940    void g2();
941
942    template<typename T>
943    Bad
944    f(T*, T*);
945
946    template<typename T1, typename T2>
947    Good
948    f(T1*, T2*);
949
950    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
951
952  }
953
954  namespace test_inline_variables
955  {
956
957    template<class T> void f(T)
958    {}
959
960    template<class T> inline T g(T)
961    {
962      return T{};
963    }
964
965    template<> inline void f<>(int)
966    {}
967
968    template<> int g<>(int)
969    {
970      return 5;
971    }
972
973  }
974
975}  // namespace cxx17
976
977#endif  // __cplusplus < 201703L && !defined _MSC_VER
978
979]])
980
981
982dnl  Tests for new features in C++20
983
984m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_20], [[
985
986#ifndef __cplusplus
987
988#error "This is not a C++ compiler"
989
990#elif __cplusplus < 202002L && !defined _MSC_VER
991
992#error "This is not a C++20 compiler"
993
994#else
995
996#include <version>
997
998namespace cxx20
999{
1000
1001// As C++20 supports feature test macros in the standard, there is no
1002// immediate need to actually test for feature availability on the
1003// Autoconf side.
1004
1005}  // namespace cxx20
1006
1007#endif  // __cplusplus < 202002L && !defined _MSC_VER
1008
1009]])
Note: See TracBrowser for help on using the repository browser.