Mercurial > minori

comparison m4/m4_ax_cxx_compile_stdcxx.m4 @ 236:4d461ef7d424

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