sdcc/aclocal.m4

   1 # generated automatically by aclocal 1.16.5 -*- Autoconf -*-
   2
   3 # Copyright (C) 1996-2021 Free Software Foundation, Inc.
   4
   5 # This file is free software; the Free Software Foundation
   6 # gives unlimited permission to copy and/or distribute it,
   7 # with or without modifications, as long as this notice is preserved.
   8
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
  11 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  12 # PARTICULAR PURPOSE.
  13
  14 m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
  15 # ===========================================================================
  16 #  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
  17 # ===========================================================================
  18 #
  19 # SYNOPSIS
  20 #
  21 #   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
  22 #
  23 # DESCRIPTION
  24 #
  25 #   Check for baseline language coverage in the compiler for the specified
  26 #   version of the C++ standard.  If necessary, add switches to CXX and
  27 #   CXXCPP to enable support.  VERSION may be '11', '14', '17', or '20' for
  28 #   the respective C++ standard version.
  29 #
  30 #   The second argument, if specified, indicates whether you insist on an
  31 #   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
  32 #   -std=c++11).  If neither is specified, you get whatever works, with
  33 #   preference for no added switch, and then for an extended mode.
  34 #
  35 #   The third argument, if specified 'mandatory' or if left unspecified,
  36 #   indicates that baseline support for the specified C++ standard is
  37 #   required and that the macro should error out if no mode with that
  38 #   support is found.  If specified 'optional', then configuration proceeds
  39 #   regardless, after defining HAVE_CXX${VERSION} if and only if a
  40 #   supporting mode is found.
  41 #
  42 # LICENSE
  43 #
  44 #   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
  45 #   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
  46 #   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
  47 #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
  48 #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
  49 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
  50 #   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
  51 #   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
  52 #   Copyright (c) 2020 Jason Merrill <jason@redhat.com>
  53 #   Copyright (c) 2021 Jörn Heusipp <osmanx@problemloesungsmaschine.de>
  54 #
  55 #   Copying and distribution of this file, with or without modification, are
  56 #   permitted in any medium without royalty provided the copyright notice
  57 #   and this notice are preserved.  This file is offered as-is, without any
  58 #   warranty.
  59
  60 #serial 15
  61
  62 dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
  63 dnl  (serial version number 13).
  64
  65 AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
  66   m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
  67         [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
  68         [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
  69         [$1], [20], [ax_cxx_compile_alternatives="20"],
  70         [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
  71   m4_if([$2], [], [],
  72         [$2], [ext], [],
  73         [$2], [noext], [],
  74         [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
  75   m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
  76         [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
  77         [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
  78         [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
  79   AC_LANG_PUSH([C++])dnl
  80   ac_success=no
  81
  82   m4_if([$2], [], [dnl
  83     AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
  84                    ax_cv_cxx_compile_cxx$1,
  85       [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
  86         [ax_cv_cxx_compile_cxx$1=yes],
  87         [ax_cv_cxx_compile_cxx$1=no])])
  88     if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
  89       ac_success=yes
  90     fi])
  91
  92   m4_if([$2], [noext], [], [dnl
  93   if test x$ac_success = xno; then
  94     for alternative in ${ax_cxx_compile_alternatives}; do
  95       switch="-std=gnu++${alternative}"
  96       cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
  97       AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
  98                      $cachevar,
  99         [ac_save_CXX="$CXX"
 100          CXX="$CXX $switch"
 101          AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
 102           [eval $cachevar=yes],
 103           [eval $cachevar=no])
 104          CXX="$ac_save_CXX"])
 105       if eval test x\$$cachevar = xyes; then
 106         CXX="$CXX $switch"
 107         if test -n "$CXXCPP" ; then
 108           CXXCPP="$CXXCPP $switch"
 109         fi
 110         ac_success=yes
 111         break
 112       fi
 113     done
 114   fi])
 115
 116   m4_if([$2], [ext], [], [dnl
 117   if test x$ac_success = xno; then
 118     dnl HP's aCC needs +std=c++11 according to:
 119     dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
 120     dnl Cray's crayCC needs "-h std=c++11"
 121     for alternative in ${ax_cxx_compile_alternatives}; do
 122       for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
 123         cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
 124         AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
 125                        $cachevar,
 126           [ac_save_CXX="$CXX"
 127            CXX="$CXX $switch"
 128            AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
 129             [eval $cachevar=yes],
 130             [eval $cachevar=no])
 131            CXX="$ac_save_CXX"])
 132         if eval test x\$$cachevar = xyes; then
 133           CXX="$CXX $switch"
 134           if test -n "$CXXCPP" ; then
 135             CXXCPP="$CXXCPP $switch"
 136           fi
 137           ac_success=yes
 138           break
 139         fi
 140       done
 141       if test x$ac_success = xyes; then
 142         break
 143       fi
 144     done
 145   fi])
 146   AC_LANG_POP([C++])
 147   if test x$ax_cxx_compile_cxx$1_required = xtrue; then
 148     if test x$ac_success = xno; then
 149       AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
 150     fi
 151   fi
 152   if test x$ac_success = xno; then
 153     HAVE_CXX$1=0
 154     AC_MSG_NOTICE([No compiler with C++$1 support was found])
 155   else
 156     HAVE_CXX$1=1
 157     AC_DEFINE(HAVE_CXX$1,1,
 158               [define if the compiler supports basic C++$1 syntax])
 159   fi
 160   AC_SUBST(HAVE_CXX$1)
 161 ])
 162
 163
 164 dnl  Test body for checking C++11 support
 165
 166 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
 167   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 168 )
 169
 170 dnl  Test body for checking C++14 support
 171
 172 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
 173   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 174   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 175 )
 176
 177 dnl  Test body for checking C++17 support
 178
 179 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
 180   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 181   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 182   _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
 183 )
 184
 185 dnl  Test body for checking C++20 support
 186
 187 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20],
 188   _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
 189   _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
 190   _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
 191   _AX_CXX_COMPILE_STDCXX_testbody_new_in_20
 192 )
 193
 194
 195 dnl  Tests for new features in C++11
 196
 197 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
 198
 199 // If the compiler admits that it is not ready for C++11, why torture it?
 200 // Hopefully, this will speed up the test.
 201
 202 #ifndef __cplusplus
 203
 204 #error "This is not a C++ compiler"
 205
 206 // MSVC always sets __cplusplus to 199711L in older versions; newer versions
 207 // only set it correctly if /Zc:__cplusplus is specified as well as a
 208 // /std:c++NN switch:
 209 // https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
 210 #elif __cplusplus < 201103L && !defined _MSC_VER
 211
 212 #error "This is not a C++11 compiler"
 213
 214 #else
 215
 216 namespace cxx11
 217 {
 218
 219   namespace test_static_assert
 220   {
 221
 222     template <typename T>
 223     struct check
 224     {
 225       static_assert(sizeof(int) <= sizeof(T), "not big enough");
 226     };
 227
 228   }
 229
 230   namespace test_final_override
 231   {
 232
 233     struct Base
 234     {
 235       virtual ~Base() {}
 236       virtual void f() {}
 237     };
 238
 239     struct Derived : public Base
 240     {
 241       virtual ~Derived() override {}
 242       virtual void f() override {}
 243     };
 244
 245   }
 246
 247   namespace test_double_right_angle_brackets
 248   {
 249
 250     template < typename T >
 251     struct check {};
 252
 253     typedef check<void> single_type;
 254     typedef check<check<void>> double_type;
 255     typedef check<check<check<void>>> triple_type;
 256     typedef check<check<check<check<void>>>> quadruple_type;
 257
 258   }
 259
 260   namespace test_decltype
 261   {
 262
 263     int
 264     f()
 265     {
 266       int a = 1;
 267       decltype(a) b = 2;
 268       return a + b;
 269     }
 270
 271   }
 272
 273   namespace test_type_deduction
 274   {
 275
 276     template < typename T1, typename T2 >
 277     struct is_same
 278     {
 279       static const bool value = false;
 280     };
 281
 282     template < typename T >
 283     struct is_same<T, T>
 284     {
 285       static const bool value = true;
 286     };
 287
 288     template < typename T1, typename T2 >
 289     auto
 290     add(T1 a1, T2 a2) -> decltype(a1 + a2)
 291     {
 292       return a1 + a2;
 293     }
 294
 295     int
 296     test(const int c, volatile int v)
 297     {
 298       static_assert(is_same<int, decltype(0)>::value == true, "");
 299       static_assert(is_same<int, decltype(c)>::value == false, "");
 300       static_assert(is_same<int, decltype(v)>::value == false, "");
 301       auto ac = c;
 302       auto av = v;
 303       auto sumi = ac + av + 'x';
 304       auto sumf = ac + av + 1.0;
 305       static_assert(is_same<int, decltype(ac)>::value == true, "");
 306       static_assert(is_same<int, decltype(av)>::value == true, "");
 307       static_assert(is_same<int, decltype(sumi)>::value == true, "");
 308       static_assert(is_same<int, decltype(sumf)>::value == false, "");
 309       static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
 310       return (sumf > 0.0) ? sumi : add(c, v);
 311     }
 312
 313   }
 314
 315   namespace test_noexcept
 316   {
 317
 318     int f() { return 0; }
 319     int g() noexcept { return 0; }
 320
 321     static_assert(noexcept(f()) == false, "");
 322     static_assert(noexcept(g()) == true, "");
 323
 324   }
 325
 326   namespace test_constexpr
 327   {
 328
 329     template < typename CharT >
 330     unsigned long constexpr
 331     strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
 332     {
 333       return *s ? strlen_c_r(s + 1, acc + 1) : acc;
 334     }
 335
 336     template < typename CharT >
 337     unsigned long constexpr
 338     strlen_c(const CharT *const s) noexcept
 339     {
 340       return strlen_c_r(s, 0UL);
 341     }
 342
 343     static_assert(strlen_c("") == 0UL, "");
 344     static_assert(strlen_c("1") == 1UL, "");
 345     static_assert(strlen_c("example") == 7UL, "");
 346     static_assert(strlen_c("another\0example") == 7UL, "");
 347
 348   }
 349
 350   namespace test_rvalue_references
 351   {
 352
 353     template < int N >
 354     struct answer
 355     {
 356       static constexpr int value = N;
 357     };
 358
 359     answer<1> f(int&)       { return answer<1>(); }
 360     answer<2> f(const int&) { return answer<2>(); }
 361     answer<3> f(int&&)      { return answer<3>(); }
 362
 363     void
 364     test()
 365     {
 366       int i = 0;
 367       const int c = 0;
 368       static_assert(decltype(f(i))::value == 1, "");
 369       static_assert(decltype(f(c))::value == 2, "");
 370       static_assert(decltype(f(0))::value == 3, "");
 371     }
 372
 373   }
 374
 375   namespace test_uniform_initialization
 376   {
 377
 378     struct test
 379     {
 380       static const int zero {};
 381       static const int one {1};
 382     };
 383
 384     static_assert(test::zero == 0, "");
 385     static_assert(test::one == 1, "");
 386
 387   }
 388
 389   namespace test_lambdas
 390   {
 391
 392     void
 393     test1()
 394     {
 395       auto lambda1 = [](){};
 396       auto lambda2 = lambda1;
 397       lambda1();
 398       lambda2();
 399     }
 400
 401     int
 402     test2()
 403     {
 404       auto a = [](int i, int j){ return i + j; }(1, 2);
 405       auto b = []() -> int { return '0'; }();
 406       auto c = [=](){ return a + b; }();
 407       auto d = [&](){ return c; }();
 408       auto e = [a, &b](int x) mutable {
 409         const auto identity = [](int y){ return y; };
 410         for (auto i = 0; i < a; ++i)
 411           a += b--;
 412         return x + identity(a + b);
 413       }(0);
 414       return a + b + c + d + e;
 415     }
 416
 417     int
 418     test3()
 419     {
 420       const auto nullary = [](){ return 0; };
 421       const auto unary = [](int x){ return x; };
 422       using nullary_t = decltype(nullary);
 423       using unary_t = decltype(unary);
 424       const auto higher1st = [](nullary_t f){ return f(); };
 425       const auto higher2nd = [unary](nullary_t f1){
 426         return [unary, f1](unary_t f2){ return f2(unary(f1())); };
 427       };
 428       return higher1st(nullary) + higher2nd(nullary)(unary);
 429     }
 430
 431   }
 432
 433   namespace test_variadic_templates
 434   {
 435
 436     template <int...>
 437     struct sum;
 438
 439     template <int N0, int... N1toN>
 440     struct sum<N0, N1toN...>
 441     {
 442       static constexpr auto value = N0 + sum<N1toN...>::value;
 443     };
 444
 445     template <>
 446     struct sum<>
 447     {
 448       static constexpr auto value = 0;
 449     };
 450
 451     static_assert(sum<>::value == 0, "");
 452     static_assert(sum<1>::value == 1, "");
 453     static_assert(sum<23>::value == 23, "");
 454     static_assert(sum<1, 2>::value == 3, "");
 455     static_assert(sum<5, 5, 11>::value == 21, "");
 456     static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
 457
 458   }
 459
 460   // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
 461   // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
 462   // because of this.
 463   namespace test_template_alias_sfinae
 464   {
 465
 466     struct foo {};
 467
 468     template<typename T>
 469     using member = typename T::member_type;
 470
 471     template<typename T>
 472     void func(...) {}
 473
 474     template<typename T>
 475     void func(member<T>*) {}
 476
 477     void test();
 478
 479     void test() { func<foo>(0); }
 480
 481   }
 482
 483 }  // namespace cxx11
 484
 485 #endif  // __cplusplus >= 201103L
 486
 487 ]])
 488
 489
 490 dnl  Tests for new features in C++14
 491
 492 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
 493
 494 // If the compiler admits that it is not ready for C++14, why torture it?
 495 // Hopefully, this will speed up the test.
 496
 497 #ifndef __cplusplus
 498
 499 #error "This is not a C++ compiler"
 500
 501 #elif __cplusplus < 201402L && !defined _MSC_VER
 502
 503 #error "This is not a C++14 compiler"
 504
 505 #else
 506
 507 namespace cxx14
 508 {
 509
 510   namespace test_polymorphic_lambdas
 511   {
 512
 513     int
 514     test()
 515     {
 516       const auto lambda = [](auto&&... args){
 517         const auto istiny = [](auto x){
 518           return (sizeof(x) == 1UL) ? 1 : 0;
 519         };
 520         const int aretiny[] = { istiny(args)... };
 521         return aretiny[0];
 522       };
 523       return lambda(1, 1L, 1.0f, '1');
 524     }
 525
 526   }
 527
 528   namespace test_binary_literals
 529   {
 530
 531     constexpr auto ivii = 0b0000000000101010;
 532     static_assert(ivii == 42, "wrong value");
 533
 534   }
 535
 536   namespace test_generalized_constexpr
 537   {
 538
 539     template < typename CharT >
 540     constexpr unsigned long
 541     strlen_c(const CharT *const s) noexcept
 542     {
 543       auto length = 0UL;
 544       for (auto p = s; *p; ++p)
 545         ++length;
 546       return length;
 547     }
 548
 549     static_assert(strlen_c("") == 0UL, "");
 550     static_assert(strlen_c("x") == 1UL, "");
 551     static_assert(strlen_c("test") == 4UL, "");
 552     static_assert(strlen_c("another\0test") == 7UL, "");
 553
 554   }
 555
 556   namespace test_lambda_init_capture
 557   {
 558
 559     int
 560     test()
 561     {
 562       auto x = 0;
 563       const auto lambda1 = [a = x](int b){ return a + b; };
 564       const auto lambda2 = [a = lambda1(x)](){ return a; };
 565       return lambda2();
 566     }
 567
 568   }
 569
 570   namespace test_digit_separators
 571   {
 572
 573     constexpr auto ten_million = 100'000'000;
 574     static_assert(ten_million == 100000000, "");
 575
 576   }
 577
 578   namespace test_return_type_deduction
 579   {
 580
 581     auto f(int& x) { return x; }
 582     decltype(auto) g(int& x) { return x; }
 583
 584     template < typename T1, typename T2 >
 585     struct is_same
 586     {
 587       static constexpr auto value = false;
 588     };
 589
 590     template < typename T >
 591     struct is_same<T, T>
 592     {
 593       static constexpr auto value = true;
 594     };
 595
 596     int
 597     test()
 598     {
 599       auto x = 0;
 600       static_assert(is_same<int, decltype(f(x))>::value, "");
 601       static_assert(is_same<int&, decltype(g(x))>::value, "");
 602       return x;
 603     }
 604
 605   }
 606
 607 }  // namespace cxx14
 608
 609 #endif  // __cplusplus >= 201402L
 610
 611 ]])
 612
 613
 614 dnl  Tests for new features in C++17
 615
 616 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
 617
 618 // If the compiler admits that it is not ready for C++17, why torture it?
 619 // Hopefully, this will speed up the test.
 620
 621 #ifndef __cplusplus
 622
 623 #error "This is not a C++ compiler"
 624
 625 #elif __cplusplus < 201703L && !defined _MSC_VER
 626
 627 #error "This is not a C++17 compiler"
 628
 629 #else
 630
 631 #include <initializer_list>
 632 #include <utility>
 633 #include <type_traits>
 634
 635 namespace cxx17
 636 {
 637
 638   namespace test_constexpr_lambdas
 639   {
 640
 641     constexpr int foo = [](){return 42;}();
 642
 643   }
 644
 645   namespace test::nested_namespace::definitions
 646   {
 647
 648   }
 649
 650   namespace test_fold_expression
 651   {
 652
 653     template<typename... Args>
 654     int multiply(Args... args)
 655     {
 656       return (args * ... * 1);
 657     }
 658
 659     template<typename... Args>
 660     bool all(Args... args)
 661     {
 662       return (args && ...);
 663     }
 664
 665   }
 666
 667   namespace test_extended_static_assert
 668   {
 669
 670     static_assert (true);
 671
 672   }
 673
 674   namespace test_auto_brace_init_list
 675   {
 676
 677     auto foo = {5};
 678     auto bar {5};
 679
 680     static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
 681     static_assert(std::is_same<int, decltype(bar)>::value);
 682   }
 683
 684   namespace test_typename_in_template_template_parameter
 685   {
 686
 687     template<template<typename> typename X> struct D;
 688
 689   }
 690
 691   namespace test_fallthrough_nodiscard_maybe_unused_attributes
 692   {
 693
 694     int f1()
 695     {
 696       return 42;
 697     }
 698
 699     [[nodiscard]] int f2()
 700     {
 701       [[maybe_unused]] auto unused = f1();
 702
 703       switch (f1())
 704       {
 705       case 17:
 706         f1();
 707         [[fallthrough]];
 708       case 42:
 709         f1();
 710       }
 711       return f1();
 712     }
 713
 714   }
 715
 716   namespace test_extended_aggregate_initialization
 717   {
 718
 719     struct base1
 720     {
 721       int b1, b2 = 42;
 722     };
 723
 724     struct base2
 725     {
 726       base2() {
 727         b3 = 42;
 728       }
 729       int b3;
 730     };
 731
 732     struct derived : base1, base2
 733     {
 734         int d;
 735     };
 736
 737     derived d1 {{1, 2}, {}, 4};  // full initialization
 738     derived d2 {{}, {}, 4};      // value-initialized bases
 739
 740   }
 741
 742   namespace test_general_range_based_for_loop
 743   {
 744
 745     struct iter
 746     {
 747       int i;
 748
 749       int& operator* ()
 750       {
 751         return i;
 752       }
 753
 754       const int& operator* () const
 755       {
 756         return i;
 757       }
 758
 759       iter& operator++()
 760       {
 761         ++i;
 762         return *this;
 763       }
 764     };
 765
 766     struct sentinel
 767     {
 768       int i;
 769     };
 770
 771     bool operator== (const iter& i, const sentinel& s)
 772     {
 773       return i.i == s.i;
 774     }
 775
 776     bool operator!= (const iter& i, const sentinel& s)
 777     {
 778       return !(i == s);
 779     }
 780
 781     struct range
 782     {
 783       iter begin() const
 784       {
 785         return {0};
 786       }
 787
 788       sentinel end() const
 789       {
 790         return {5};
 791       }
 792     };
 793
 794     void f()
 795     {
 796       range r {};
 797
 798       for (auto i : r)
 799       {
 800         [[maybe_unused]] auto v = i;
 801       }
 802     }
 803
 804   }
 805
 806   namespace test_lambda_capture_asterisk_this_by_value
 807   {
 808
 809     struct t
 810     {
 811       int i;
 812       int foo()
 813       {
 814         return [*this]()
 815         {
 816           return i;
 817         }();
 818       }
 819     };
 820
 821   }
 822
 823   namespace test_enum_class_construction
 824   {
 825
 826     enum class byte : unsigned char
 827     {};
 828
 829     byte foo {42};
 830
 831   }
 832
 833   namespace test_constexpr_if
 834   {
 835
 836     template <bool cond>
 837     int f ()
 838     {
 839       if constexpr(cond)
 840       {
 841         return 13;
 842       }
 843       else
 844       {
 845         return 42;
 846       }
 847     }
 848
 849   }
 850
 851   namespace test_selection_statement_with_initializer
 852   {
 853
 854     int f()
 855     {
 856       return 13;
 857     }
 858
 859     int f2()
 860     {
 861       if (auto i = f(); i > 0)
 862       {
 863         return 3;
 864       }
 865
 866       switch (auto i = f(); i + 4)
 867       {
 868       case 17:
 869         return 2;
 870
 871       default:
 872         return 1;
 873       }
 874     }
 875
 876   }
 877
 878   namespace test_template_argument_deduction_for_class_templates
 879   {
 880
 881     template <typename T1, typename T2>
 882     struct pair
 883     {
 884       pair (T1 p1, T2 p2)
 885         : m1 {p1},
 886           m2 {p2}
 887       {}
 888
 889       T1 m1;
 890       T2 m2;
 891     };
 892
 893     void f()
 894     {
 895       [[maybe_unused]] auto p = pair{13, 42u};
 896     }
 897
 898   }
 899
 900   namespace test_non_type_auto_template_parameters
 901   {
 902
 903     template <auto n>
 904     struct B
 905     {};
 906
 907     B<5> b1;
 908     B<'a'> b2;
 909
 910   }
 911
 912   namespace test_structured_bindings
 913   {
 914
 915     int arr[2] = { 1, 2 };
 916     std::pair<int, int> pr = { 1, 2 };
 917
 918     auto f1() -> int(&)[2]
 919     {
 920       return arr;
 921     }
 922
 923     auto f2() -> std::pair<int, int>&
 924     {
 925       return pr;
 926     }
 927
 928     struct S
 929     {
 930       int x1 : 2;
 931       volatile double y1;
 932     };
 933
 934     S f3()
 935     {
 936       return {};
 937     }
 938
 939     auto [ x1, y1 ] = f1();
 940     auto& [ xr1, yr1 ] = f1();
 941     auto [ x2, y2 ] = f2();
 942     auto& [ xr2, yr2 ] = f2();
 943     const auto [ x3, y3 ] = f3();
 944
 945   }
 946
 947   namespace test_exception_spec_type_system
 948   {
 949
 950     struct Good {};
 951     struct Bad {};
 952
 953     void g1() noexcept;
 954     void g2();
 955
 956     template<typename T>
 957     Bad
 958     f(T*, T*);
 959
 960     template<typename T1, typename T2>
 961     Good
 962     f(T1*, T2*);
 963
 964     static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
 965
 966   }
 967
 968   namespace test_inline_variables
 969   {
 970
 971     template<class T> void f(T)
 972     {}
 973
 974     template<class T> inline T g(T)
 975     {
 976       return T{};
 977     }
 978
 979     template<> inline void f<>(int)
 980     {}
 981
 982     template<> int g<>(int)
 983     {
 984       return 5;
 985     }
 986
 987   }
 988
 989 }  // namespace cxx17
 990
 991 #endif  // __cplusplus < 201703L && !defined _MSC_VER
 992
 993 ]])
 994
 995
 996 dnl  Tests for new features in C++20
 997
 998 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_20], [[
 999
1000 #ifndef __cplusplus
1001
1002 #error "This is not a C++ compiler"
1003
1004 #elif __cplusplus < 202002L && !defined _MSC_VER
1005
1006 #error "This is not a C++20 compiler"
1007
1008 #else
1009
1010 #include <version>
1011
1012 namespace cxx20
1013 {
1014
1015 // As C++20 supports feature test macros in the standard, there is no
1016 // immediate need to actually test for feature availability on the
1017 // Autoconf side.
1018
1019 }  // namespace cxx20
1020
1021 #endif  // __cplusplus < 202002L && !defined _MSC_VER
1022
1023 ]])
1024
1025 # =============================================================================
1026 #  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
1027 # =============================================================================
1028 #
1029 # SYNOPSIS
1030 #
1031 #   AX_CXX_COMPILE_STDCXX_11([ext|noext], [mandatory|optional])
1032 #
1033 # DESCRIPTION
1034 #
1035 #   Check for baseline language coverage in the compiler for the C++11
1036 #   standard; if necessary, add switches to CXX and CXXCPP to enable
1037 #   support.
1038 #
1039 #   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
1040 #   macro with the version set to C++11.  The two optional arguments are
1041 #   forwarded literally as the second and third argument respectively.
1042 #   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
1043 #   more information.  If you want to use this macro, you also need to
1044 #   download the ax_cxx_compile_stdcxx.m4 file.
1045 #
1046 # LICENSE
1047 #
1048 #   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
1049 #   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
1050 #   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
1051 #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
1052 #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
1053 #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
1054 #
1055 #   Copying and distribution of this file, with or without modification, are
1056 #   permitted in any medium without royalty provided the copyright notice
1057 #   and this notice are preserved. This file is offered as-is, without any
1058 #   warranty.
1059
1060 #serial 18
1061
1062 AX_REQUIRE_DEFINED([AX_CXX_COMPILE_STDCXX])
1063 AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [AX_CXX_COMPILE_STDCXX([11], [$1], [$2])])
1064
1065 # Copyright (C) 1999-2021 Free Software Foundation, Inc.
1066 #
1067 # This file is free software; the Free Software Foundation
1068 # gives unlimited permission to copy and/or distribute it,
1069 # with or without modifications, as long as this notice is preserved.
1070
1071
1072 # AM_PATH_PYTHON([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1073 # ---------------------------------------------------------------------------
1074 # Adds support for distributing Python modules and packages.  To
1075 # install modules, copy them to $(pythondir), using the python_PYTHON
1076 # automake variable.  To install a package with the same name as the
1077 # automake package, install to $(pkgpythondir), or use the
1078 # pkgpython_PYTHON automake variable.
1079 #
1080 # The variables $(pyexecdir) and $(pkgpyexecdir) are provided as
1081 # locations to install python extension modules (shared libraries).
1082 # Another macro is required to find the appropriate flags to compile
1083 # extension modules.
1084 #
1085 # If your package is configured with a different prefix to python,
1086 # users will have to add the install directory to the PYTHONPATH
1087 # environment variable, or create a .pth file (see the python
1088 # documentation for details).
1089 #
1090 # If the MINIMUM-VERSION argument is passed, AM_PATH_PYTHON will
1091 # cause an error if the version of python installed on the system
1092 # doesn't meet the requirement.  MINIMUM-VERSION should consist of
1093 # numbers and dots only.
1094 AC_DEFUN([AM_PATH_PYTHON],
1095  [
1096   dnl Find a Python interpreter.  Python versions prior to 2.0 are not
1097   dnl supported. (2.0 was released on October 16, 2000).
1098   m4_define_default([_AM_PYTHON_INTERPRETER_LIST],
1099 [python python2 python3 dnl
1100  python3.11 python3.10 dnl
1101  python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 dnl
1102  python3.2 python3.1 python3.0 dnl
1103  python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 dnl
1104  python2.0])
1105
1106   AC_ARG_VAR([PYTHON], [the Python interpreter])
1107
1108   m4_if([$1],[],[
1109     dnl No version check is needed.
1110     # Find any Python interpreter.
1111     if test -z "$PYTHON"; then
1112       AC_PATH_PROGS([PYTHON], _AM_PYTHON_INTERPRETER_LIST, :)
1113     fi
1114     am_display_PYTHON=python
1115   ], [
1116     dnl A version check is needed.
1117     if test -n "$PYTHON"; then
1118       # If the user set $PYTHON, use it and don't search something else.
1119       AC_MSG_CHECKING([whether $PYTHON version is >= $1])
1120       AM_PYTHON_CHECK_VERSION([$PYTHON], [$1],
1121                               [AC_MSG_RESULT([yes])],
1122                               [AC_MSG_RESULT([no])
1123                                AC_MSG_ERROR([Python interpreter is too old])])
1124       am_display_PYTHON=$PYTHON
1125     else
1126       # Otherwise, try each interpreter until we find one that satisfies
1127       # VERSION.
1128       AC_CACHE_CHECK([for a Python interpreter with version >= $1],
1129         [am_cv_pathless_PYTHON],[
1130         for am_cv_pathless_PYTHON in _AM_PYTHON_INTERPRETER_LIST none; do
1131           test "$am_cv_pathless_PYTHON" = none && break
1132           AM_PYTHON_CHECK_VERSION([$am_cv_pathless_PYTHON], [$1], [break])
1133         done])
1134       # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
1135       if test "$am_cv_pathless_PYTHON" = none; then
1136         PYTHON=:
1137       else
1138         AC_PATH_PROG([PYTHON], [$am_cv_pathless_PYTHON])
1139       fi
1140       am_display_PYTHON=$am_cv_pathless_PYTHON
1141     fi
1142   ])
1143
1144   if test "$PYTHON" = :; then
1145     dnl Run any user-specified action, or abort.
1146     m4_default([$3], [AC_MSG_ERROR([no suitable Python interpreter found])])
1147   else
1148
1149   dnl Query Python for its version number.  Although site.py simply uses
1150   dnl sys.version[:3], printing that failed with Python 3.10, since the
1151   dnl trailing zero was eliminated. So now we output just the major
1152   dnl and minor version numbers, as numbers. Apparently the tertiary
1153   dnl version is not of interest.
1154   dnl
1155   AC_CACHE_CHECK([for $am_display_PYTHON version], [am_cv_python_version],
1156     [am_cv_python_version=`$PYTHON -c "import sys; print ('%u.%u' % sys.version_info[[:2]])"`])
1157   AC_SUBST([PYTHON_VERSION], [$am_cv_python_version])
1158
1159   dnl At times, e.g., when building shared libraries, you may want
1160   dnl to know which OS platform Python thinks this is.
1161   dnl
1162   AC_CACHE_CHECK([for $am_display_PYTHON platform], [am_cv_python_platform],
1163     [am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`])
1164   AC_SUBST([PYTHON_PLATFORM], [$am_cv_python_platform])
1165
1166   dnl emacs-page
1167   dnl If --with-python-sys-prefix is given, use the values of sys.prefix
1168   dnl and sys.exec_prefix for the corresponding values of PYTHON_PREFIX
1169   dnl and PYTHON_EXEC_PREFIX. Otherwise, use the GNU ${prefix} and
1170   dnl ${exec_prefix} variables.
1171   dnl
1172   dnl The two are made distinct variables so they can be overridden if
1173   dnl need be, although general consensus is that you shouldn't need
1174   dnl this separation.
1175   dnl
1176   dnl Also allow directly setting the prefixes via configure options,
1177   dnl overriding any default.
1178   dnl
1179   if test "x$prefix" = xNONE; then
1180     am__usable_prefix=$ac_default_prefix
1181   else
1182     am__usable_prefix=$prefix
1183   fi
1184
1185   # Allow user to request using sys.* values from Python,
1186   # instead of the GNU $prefix values.
1187   AC_ARG_WITH([python-sys-prefix],
1188   [AS_HELP_STRING([--with-python-sys-prefix],
1189                   [use Python's sys.prefix and sys.exec_prefix values])],
1190   [am_use_python_sys=:],
1191   [am_use_python_sys=false])
1192
1193   # Allow user to override whatever the default Python prefix is.
1194   AC_ARG_WITH([python_prefix],
1195   [AS_HELP_STRING([--with-python_prefix],
1196                   [override the default PYTHON_PREFIX])],
1197   [am_python_prefix_subst=$withval
1198    am_cv_python_prefix=$withval
1199    AC_MSG_CHECKING([for explicit $am_display_PYTHON prefix])
1200    AC_MSG_RESULT([$am_cv_python_prefix])],
1201   [
1202    if $am_use_python_sys; then
1203      # using python sys.prefix value, not GNU
1204      AC_CACHE_CHECK([for python default $am_display_PYTHON prefix],
1205      [am_cv_python_prefix],
1206      [am_cv_python_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.prefix)"`])
1207
1208      dnl If sys.prefix is a subdir of $prefix, replace the literal value of
1209      dnl $prefix with a variable reference so it can be overridden.
1210      case $am_cv_python_prefix in
1211      $am__usable_prefix*)
1212        am__strip_prefix=`echo "$am__usable_prefix" | sed 's|.|.|g'`
1213        am_python_prefix_subst=`echo "$am_cv_python_prefix" | sed "s,^$am__strip_prefix,\\${prefix},"`
1214        ;;
1215      *)
1216        am_python_prefix_subst=$am_cv_python_prefix
1217        ;;
1218      esac
1219    else # using GNU prefix value, not python sys.prefix
1220      am_python_prefix_subst='${prefix}'
1221      am_python_prefix=$am_python_prefix_subst
1222      AC_MSG_CHECKING([for GNU default $am_display_PYTHON prefix])
1223      AC_MSG_RESULT([$am_python_prefix])
1224    fi])
1225   # Substituting python_prefix_subst value.
1226   AC_SUBST([PYTHON_PREFIX], [$am_python_prefix_subst])
1227
1228   # emacs-page Now do it all over again for Python exec_prefix, but with yet
1229   # another conditional: fall back to regular prefix if that was specified.
1230   AC_ARG_WITH([python_exec_prefix],
1231   [AS_HELP_STRING([--with-python_exec_prefix],
1232                   [override the default PYTHON_EXEC_PREFIX])],
1233   [am_python_exec_prefix_subst=$withval
1234    am_cv_python_exec_prefix=$withval
1235    AC_MSG_CHECKING([for explicit $am_display_PYTHON exec_prefix])
1236    AC_MSG_RESULT([$am_cv_python_exec_prefix])],
1237   [
1238    # no explicit --with-python_exec_prefix, but if
1239    # --with-python_prefix was given, use its value for python_exec_prefix too.
1240    AS_IF([test -n "$with_python_prefix"],
1241    [am_python_exec_prefix_subst=$with_python_prefix
1242     am_cv_python_exec_prefix=$with_python_prefix
1243     AC_MSG_CHECKING([for python_prefix-given $am_display_PYTHON exec_prefix])
1244     AC_MSG_RESULT([$am_cv_python_exec_prefix])],
1245    [
1246     # Set am__usable_exec_prefix whether using GNU or Python values,
1247     # since we use that variable for pyexecdir.
1248     if test "x$exec_prefix" = xNONE; then
1249       am__usable_exec_prefix=$am__usable_prefix
1250     else
1251       am__usable_exec_prefix=$exec_prefix
1252     fi
1253     #
1254     if $am_use_python_sys; then # using python sys.exec_prefix, not GNU
1255       AC_CACHE_CHECK([for python default $am_display_PYTHON exec_prefix],
1256       [am_cv_python_exec_prefix],
1257       [am_cv_python_exec_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)"`])
1258       dnl If sys.exec_prefix is a subdir of $exec_prefix, replace the
1259       dnl literal value of $exec_prefix with a variable reference so it can
1260       dnl be overridden.
1261       case $am_cv_python_exec_prefix in
1262       $am__usable_exec_prefix*)
1263         am__strip_prefix=`echo "$am__usable_exec_prefix" | sed 's|.|.|g'`
1264         am_python_exec_prefix_subst=`echo "$am_cv_python_exec_prefix" | sed "s,^$am__strip_prefix,\\${exec_prefix},"`
1265         ;;
1266       *)
1267         am_python_exec_prefix_subst=$am_cv_python_exec_prefix
1268         ;;
1269      esac
1270    else # using GNU $exec_prefix, not python sys.exec_prefix
1271      am_python_exec_prefix_subst='${exec_prefix}'
1272      am_python_exec_prefix=$am_python_exec_prefix_subst
1273      AC_MSG_CHECKING([for GNU default $am_display_PYTHON exec_prefix])
1274      AC_MSG_RESULT([$am_python_exec_prefix])
1275    fi])])
1276   # Substituting python_exec_prefix_subst.
1277   AC_SUBST([PYTHON_EXEC_PREFIX], [$am_python_exec_prefix_subst])
1278
1279   # Factor out some code duplication into this shell variable.
1280   am_python_setup_sysconfig="\
1281 import sys
1282 # Prefer sysconfig over distutils.sysconfig, for better compatibility
1283 # with python 3.x.  See automake bug#10227.
1284 try:
1285     import sysconfig
1286 except ImportError:
1287     can_use_sysconfig = 0
1288 else:
1289     can_use_sysconfig = 1
1290 # Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
1291 # <https://github.com/pypa/virtualenv/issues/118>
1292 try:
1293     from platform import python_implementation
1294     if python_implementation() == 'CPython' and sys.version[[:3]] == '2.7':
1295         can_use_sysconfig = 0
1296 except ImportError:
1297     pass"
1298
1299   dnl emacs-page Set up 4 directories:
1300
1301   dnl 1. pythondir: where to install python scripts.  This is the
1302   dnl    site-packages directory, not the python standard library
1303   dnl    directory like in previous automake betas.  This behavior
1304   dnl    is more consistent with lispdir.m4 for example.
1305   dnl Query distutils for this directory.
1306   dnl
1307   AC_CACHE_CHECK([for $am_display_PYTHON script directory (pythondir)],
1308   [am_cv_python_pythondir],
1309   [if test "x$am_cv_python_prefix" = x; then
1310      am_py_prefix=$am__usable_prefix
1311    else
1312      am_py_prefix=$am_cv_python_prefix
1313    fi
1314    am_cv_python_pythondir=`$PYTHON -c "
1315 $am_python_setup_sysconfig
1316 if can_use_sysconfig:
1317   if hasattr(sysconfig, 'get_default_scheme'):
1318     scheme = sysconfig.get_default_scheme()
1319   else:
1320     scheme = sysconfig._get_default_scheme()
1321   if scheme == 'posix_local':
1322     # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
1323     scheme = 'posix_prefix'
1324   sitedir = sysconfig.get_path('purelib', scheme, vars={'base':'$am_py_prefix'})
1325 else:
1326   from distutils import sysconfig
1327   sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
1328 sys.stdout.write(sitedir)"`
1329    #
1330    case $am_cv_python_pythondir in
1331    $am_py_prefix*)
1332      am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
1333      am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,\\${PYTHON_PREFIX},"`
1334      ;;
1335    *)
1336      case $am_py_prefix in
1337        /usr|/System*) ;;
1338        *) am_cv_python_pythondir="\${PYTHON_PREFIX}/lib/python$PYTHON_VERSION/site-packages"
1339           ;;
1340      esac
1341      ;;
1342    esac
1343   ])
1344   AC_SUBST([pythondir], [$am_cv_python_pythondir])
1345
1346   dnl 2. pkgpythondir: $PACKAGE directory under pythondir.  Was
1347   dnl    PYTHON_SITE_PACKAGE in previous betas, but this naming is
1348   dnl    more consistent with the rest of automake.
1349   dnl
1350   AC_SUBST([pkgpythondir], [\${pythondir}/$PACKAGE])
1351
1352   dnl 3. pyexecdir: directory for installing python extension modules
1353   dnl    (shared libraries).
1354   dnl Query distutils for this directory.
1355   dnl
1356   AC_CACHE_CHECK([for $am_display_PYTHON extension module directory (pyexecdir)],
1357   [am_cv_python_pyexecdir],
1358   [if test "x$am_cv_python_exec_prefix" = x; then
1359      am_py_exec_prefix=$am__usable_exec_prefix
1360    else
1361      am_py_exec_prefix=$am_cv_python_exec_prefix
1362    fi
1363    am_cv_python_pyexecdir=`$PYTHON -c "
1364 $am_python_setup_sysconfig
1365 if can_use_sysconfig:
1366   if hasattr(sysconfig, 'get_default_scheme'):
1367     scheme = sysconfig.get_default_scheme()
1368   else:
1369     scheme = sysconfig._get_default_scheme()
1370   if scheme == 'posix_local':
1371     # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
1372     scheme = 'posix_prefix'
1373   sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase':'$am_py_exec_prefix'})
1374 else:
1375   from distutils import sysconfig
1376   sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_exec_prefix')
1377 sys.stdout.write(sitedir)"`
1378    #
1379    case $am_cv_python_pyexecdir in
1380    $am_py_exec_prefix*)
1381      am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
1382      am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,\\${PYTHON_EXEC_PREFIX},"`
1383      ;;
1384    *)
1385      case $am_py_exec_prefix in
1386        /usr|/System*) ;;
1387        *) am_cv_python_pyexecdir="\${PYTHON_EXEC_PREFIX}/lib/python$PYTHON_VERSION/site-packages"
1388           ;;
1389      esac
1390      ;;
1391    esac
1392   ])
1393   AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir])
1394
1395   dnl 4. pkgpyexecdir: $(pyexecdir)/$(PACKAGE)
1396   dnl
1397   AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE])
1398
1399   dnl Run any user-specified action.
1400   $2
1401   fi
1402 ])
1403
1404
1405 # AM_PYTHON_CHECK_VERSION(PROG, VERSION, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
1406 # ---------------------------------------------------------------------------
1407 # Run ACTION-IF-TRUE if the Python interpreter PROG has version >= VERSION.
1408 # Run ACTION-IF-FALSE otherwise.
1409 # This test uses sys.hexversion instead of the string equivalent (first
1410 # word of sys.version), in order to cope with versions such as 2.2c1.
1411 # This supports Python 2.0 or higher. (2.0 was released on October 16, 2000).
1412 AC_DEFUN([AM_PYTHON_CHECK_VERSION],
1413  [prog="import sys
1414 # split strings by '.' and convert to numeric.  Append some zeros
1415 # because we need at least 4 digits for the hex conversion.
1416 # map returns an iterator in Python 3.0 and a list in 2.x
1417 minver = list(map(int, '$2'.split('.'))) + [[0, 0, 0]]
1418 minverhex = 0
1419 # xrange is not present in Python 3.0 and range returns an iterator
1420 for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[[i]]
1421 sys.exit(sys.hexversion < minverhex)"
1422   AS_IF([AM_RUN_LOG([$1 -c "$prog"])], [$3], [$4])])
1423
1424 # Copyright (C) 2001-2021 Free Software Foundation, Inc.
1425 #
1426 # This file is free software; the Free Software Foundation
1427 # gives unlimited permission to copy and/or distribute it,
1428 # with or without modifications, as long as this notice is preserved.
1429
1430 # AM_RUN_LOG(COMMAND)
1431 # -------------------
1432 # Run COMMAND, save the exit status in ac_status, and log it.
1433 # (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
1434 AC_DEFUN([AM_RUN_LOG],
1435 [{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
1436    ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
1437    ac_status=$?
1438    echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
1439    (exit $ac_status); }])
1440