lac : 9dae9b1ccf1a918ebe04519c3b8147e84cc16a5f

     1: # Prefer GNU C11 and C++11 to earlier versions.  -*- coding: utf-8 -*-
     2: 
     3: # This implementation is taken from GNU Autoconf lib/autoconf/c.m4
     4: # commit 017d5ddd82854911f0119691d91ea8a1438824d6
     5: # dated Sun Apr 3 13:57:17 2016 -0700
     6: # This implementation will be obsolete once we can assume Autoconf 2.70
     7: # or later is installed everywhere a Gnulib program might be developed.
     8: 
     9: 
    10: # Copyright (C) 2001-2017 Free Software Foundation, Inc.
    11: 
    12: # This program is free software; you can redistribute it and/or modify
    13: # it under the terms of the GNU General Public License as published by
    14: # the Free Software Foundation, either version 3 of the License, or
    15: # (at your option) any later version.
    16: #
    17: # This program is distributed in the hope that it will be useful,
    18: # but WITHOUT ANY WARRANTY; without even the implied warranty of
    19: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    20: # GNU General Public License for more details.
    21: #
    22: # You should have received a copy of the GNU General Public License
    23: # along with this program.  If not, see <http://www.gnu.org/licenses/>.
    24: 
    25: # Written by David MacKenzie, with help from
    26: # Akim Demaille, Paul Eggert,
    27: # Fran├žois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
    28: # Roland McGrath, Noah Friedman, david d zuhn, and many others.
    29: 
    30: 
    31: # AC_PROG_CC([COMPILER ...])
    32: # --------------------------
    33: # COMPILER ... is a space separated list of C compilers to search for.
    34: # This just gives the user an opportunity to specify an alternative
    35: # search list for the C compiler.
    36: AC_DEFUN_ONCE([AC_PROG_CC],
    37: [AC_LANG_PUSH(C)dnl
    38: AC_ARG_VAR([CC],     [C compiler command])dnl
    39: AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
    40: _AC_ARG_VAR_LDFLAGS()dnl
    41: _AC_ARG_VAR_LIBS()dnl
    42: _AC_ARG_VAR_CPPFLAGS()dnl
    43: m4_ifval([$1],
    44:       [AC_CHECK_TOOLS(CC, [$1])],
    45: [AC_CHECK_TOOL(CC, gcc)
    46: if test -z "$CC"; then
    47:   dnl Here we want:
    48:   dnl	AC_CHECK_TOOL(CC, cc)
    49:   dnl but without the check for a tool without the prefix.
    50:   dnl Until the check is removed from there, copy the code:
    51:   if test -n "$ac_tool_prefix"; then
    52:     AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
    53:   fi
    54: fi
    55: if test -z "$CC"; then
    56:   AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
    57: fi
    58: if test -z "$CC"; then
    59:   AC_CHECK_TOOLS(CC, cl.exe)
    60: fi
    61: if test -z "$CC"; then
    62:   AC_CHECK_TOOL(CC, clang)
    63: fi
    64: ])
    65: 
    66: test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
    67: 
    68: # Provide some information about the compiler.
    69: _AS_ECHO_LOG([checking for _AC_LANG compiler version])
    70: set X $ac_compile
    71: ac_compiler=$[2]
    72: for ac_option in --version -v -V -qversion -version; do
    73:   _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
    74: done
    75: 
    76: m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
    77: m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
    78: _AC_LANG_COMPILER_GNU
    79: if test $ac_compiler_gnu = yes; then
    80:   GCC=yes
    81: else
    82:   GCC=
    83: fi
    84: _AC_PROG_CC_G
    85: dnl
    86: dnl Set ac_prog_cc_stdc to the supported C version.
    87: dnl Also set the documented variable ac_cv_prog_cc_stdc;
    88: dnl its name was chosen when it was cached, but it is no longer cached.
    89: _AC_PROG_CC_C11([ac_prog_cc_stdc=c11
    90: 		 ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11],
    91:   [_AC_PROG_CC_C99([ac_prog_cc_stdc=c99
    92: 		    ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
    93:      [_AC_PROG_CC_C89([ac_prog_cc_stdc=c89
    94: 		       ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
    95: 		      [ac_prog_cc_stdc=no
    96: 		       ac_cv_prog_cc_stdc=no])])])
    97: dnl
    98: AC_LANG_POP(C)dnl
    99: ])# AC_PROG_CC
   100: 
   101: 
   102: 
   103: # AC_PROG_CXX([LIST-OF-COMPILERS])
   104: # --------------------------------
   105: # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
   106: # for (if not specified, a default list is used).  This just gives the
   107: # user an opportunity to specify an alternative search list for the C++
   108: # compiler.
   109: # aCC	HP-UX C++ compiler much better than `CC', so test before.
   110: # FCC   Fujitsu C++ compiler
   111: # KCC	KAI C++ compiler
   112: # RCC	Rational C++
   113: # xlC_r	AIX C Set++ (with support for reentrant code)
   114: # xlC	AIX C Set++
   115: AC_DEFUN([AC_PROG_CXX],
   116: [AC_LANG_PUSH(C++)dnl
   117: AC_ARG_VAR([CXX],      [C++ compiler command])dnl
   118: AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
   119: _AC_ARG_VAR_LDFLAGS()dnl
   120: _AC_ARG_VAR_LIBS()dnl
   121: _AC_ARG_VAR_CPPFLAGS()dnl
   122: _AC_ARG_VAR_PRECIOUS([CCC])dnl
   123: if test -z "$CXX"; then
   124:   if test -n "$CCC"; then
   125:     CXX=$CCC
   126:   else
   127:     AC_CHECK_TOOLS(CXX,
   128: 		   [m4_default([$1],
   129: 			       [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++])],
   130: 		   g++)
   131:   fi
   132: fi
   133: # Provide some information about the compiler.
   134: _AS_ECHO_LOG([checking for _AC_LANG compiler version])
   135: set X $ac_compile
   136: ac_compiler=$[2]
   137: for ac_option in --version -v -V -qversion; do
   138:   _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
   139: done
   140: 
   141: m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
   142: m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
   143: _AC_LANG_COMPILER_GNU
   144: if test $ac_compiler_gnu = yes; then
   145:   GXX=yes
   146: else
   147:   GXX=
   148: fi
   149: _AC_PROG_CXX_G
   150: _AC_PROG_CXX_CXX11([ac_prog_cxx_stdcxx=cxx11
   151: 		    ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
   152: 		    ac_cv_prog_cxx_cxx98=$ac_cv_prog_cxx_cxx11],
   153:    [_AC_PROG_CXX_CXX98([ac_prog_cxx_stdcxx=cxx98
   154: 		        ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98],
   155: 		       [ac_prog_cxx_stdcxx=no
   156: 		        ac_cv_prog_cxx_stdcxx=no])])
   157: AC_LANG_POP(C++)dnl
   158: ])# AC_PROG_CXX
   159: 
   160: 
   161: # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
   162: #		ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
   163: # --------------------------------------------------------------
   164: # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
   165: # by trying to compile a program of TEST-PROLOGUE and TEST-BODY.  If this fails,
   166: # try again with each compiler option in the space-separated OPTION-LIST; if one
   167: # helps, append it to CC.  If eventually successful, run ACTION-IF-AVAILABLE,
   168: # else ACTION-IF-UNAVAILABLE.
   169: AC_DEFUN([_AC_C_STD_TRY],
   170: [AC_MSG_CHECKING([for $CC option to enable ]m4_translit($1, [c], [C])[ features])
   171: AC_CACHE_VAL(ac_cv_prog_cc_$1,
   172: [ac_cv_prog_cc_$1=no
   173: ac_save_CC=$CC
   174: AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
   175: for ac_arg in '' $4
   176: do
   177:   CC="$ac_save_CC $ac_arg"
   178:   _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
   179:   test "x$ac_cv_prog_cc_$1" != "xno" && break
   180: done
   181: rm -f conftest.$ac_ext
   182: CC=$ac_save_CC
   183: ])# AC_CACHE_VAL
   184: ac_prog_cc_stdc_options=
   185: case "x$ac_cv_prog_cc_$1" in
   186:   x)
   187:     AC_MSG_RESULT([none needed]) ;;
   188:   xno)
   189:     AC_MSG_RESULT([unsupported]) ;;
   190:   *)
   191:     ac_prog_cc_stdc_options=" $ac_cv_prog_cc_$1"
   192:     CC=$CC$ac_prog_cc_stdc_options
   193:     AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
   194: esac
   195: AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
   196: ])# _AC_C_STD_TRY
   197: 
   198: # _AC_C_C99_TEST_HEADER
   199: # ---------------------
   200: # A C header suitable for testing for C99.
   201: AC_DEFUN([_AC_C_C99_TEST_HEADER],
   202: [[#include <stdarg.h>
   203: #include <stdbool.h>
   204: #include <stddef.h>
   205: #include <stdlib.h>
   206: #include <wchar.h>
   207: #include <stdio.h>
   208: 
   209: // Check varargs macros.  These examples are taken from C99 6.10.3.5.
   210: #define debug(...) fprintf (stderr, __VA_ARGS__)
   211: #define showlist(...) puts (#__VA_ARGS__)
   212: #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
   213: static void
   214: test_varargs_macros (void)
   215: {
   216:   int x = 1234;
   217:   int y = 5678;
   218:   debug ("Flag");
   219:   debug ("X = %d\n", x);
   220:   showlist (The first, second, and third items.);
   221:   report (x>y, "x is %d but y is %d", x, y);
   222: }
   223: 
   224: // Check long long types.
   225: #define BIG64 18446744073709551615ull
   226: #define BIG32 4294967295ul
   227: #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
   228: #if !BIG_OK
   229:   your preprocessor is broken;
   230: #endif
   231: #if BIG_OK
   232: #else
   233:   your preprocessor is broken;
   234: #endif
   235: static long long int bignum = -9223372036854775807LL;
   236: static unsigned long long int ubignum = BIG64;
   237: 
   238: struct incomplete_array
   239: {
   240:   int datasize;
   241:   double data[];
   242: };
   243: 
   244: struct named_init {
   245:   int number;
   246:   const wchar_t *name;
   247:   double average;
   248: };
   249: 
   250: typedef const char *ccp;
   251: 
   252: static inline int
   253: test_restrict (ccp restrict text)
   254: {
   255:   // See if C++-style comments work.
   256:   // Iterate through items via the restricted pointer.
   257:   // Also check for declarations in for loops.
   258:   for (unsigned int i = 0; *(text+i) != '\0'; ++i)
   259:     continue;
   260:   return 0;
   261: }
   262: 
   263: // Check varargs and va_copy.
   264: static bool
   265: test_varargs (const char *format, ...)
   266: {
   267:   va_list args;
   268:   va_start (args, format);
   269:   va_list args_copy;
   270:   va_copy (args_copy, args);
   271: 
   272:   const char *str = "";
   273:   int number = 0;
   274:   float fnumber = 0;
   275: 
   276:   while (*format)
   277:     {
   278:       switch (*format++)
   279: 	{
   280: 	case 's': // string
   281: 	  str = va_arg (args_copy, const char *);
   282: 	  break;
   283: 	case 'd': // int
   284: 	  number = va_arg (args_copy, int);
   285: 	  break;
   286: 	case 'f': // float
   287: 	  fnumber = va_arg (args_copy, double);
   288: 	  break;
   289: 	default:
   290: 	  break;
   291: 	}
   292:     }
   293:   va_end (args_copy);
   294:   va_end (args);
   295: 
   296:   return *str && number && fnumber;
   297: }]])# _AC_C_C99_TEST_HEADER
   298: 
   299: # _AC_C_C99_TEST_BODY
   300: # -------------------
   301: # A C body suitable for testing for C99, assuming the corresponding header.
   302: AC_DEFUN([_AC_C_C99_TEST_BODY],
   303: [[
   304:   // Check bool.
   305:   _Bool success = false;
   306: 
   307:   // Check restrict.
   308:   if (test_restrict ("String literal") == 0)
   309:     success = true;
   310:   char *restrict newvar = "Another string";
   311: 
   312:   // Check varargs.
   313:   success &= test_varargs ("s, d' f .", "string", 65, 34.234);
   314:   test_varargs_macros ();
   315: 
   316:   // Check flexible array members.
   317:   struct incomplete_array *ia =
   318:     malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
   319:   ia->datasize = 10;
   320:   for (int i = 0; i < ia->datasize; ++i)
   321:     ia->data[i] = i * 1.234;
   322: 
   323:   // Check named initializers.
   324:   struct named_init ni = {
   325:     .number = 34,
   326:     .name = L"Test wide string",
   327:     .average = 543.34343,
   328:   };
   329: 
   330:   ni.number = 58;
   331: 
   332:   int dynamic_array[ni.number];
   333:   dynamic_array[ni.number - 1] = 543;
   334: 
   335:   // work around unused variable warnings
   336:   return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
   337: 	  || dynamic_array[ni.number - 1] != 543);
   338: ]])
   339: 
   340: # _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
   341: # ----------------------------------------------------------------
   342: # If the C compiler is not in ISO C99 mode by default, try to add an
   343: # option to output variable CC to make it so.  This macro tries
   344: # various options that select ISO C99 on some system or another.  It
   345: # considers the compiler to be in ISO C99 mode if it handles _Bool,
   346: # // comments, flexible array members, inline, long long int, mixed
   347: # code and declarations, named initialization of structs, restrict,
   348: # va_copy, varargs macros, variable declarations in for loops and
   349: # variable length arrays.
   350: AC_DEFUN([_AC_PROG_CC_C99],
   351: [_AC_C_STD_TRY([c99],
   352: [_AC_C_C99_TEST_HEADER],
   353: [_AC_C_C99_TEST_BODY],
   354: dnl Try
   355: dnl GCC		-std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
   356: dnl IBM XL C	-qlanglvl=extc1x (V12.1; does not pass C11 test)
   357: dnl IBM XL C	-qlanglvl=extc99
   358: dnl		(pre-V12.1; unused restrictive mode: -qlanglvl=stdc99)
   359: dnl HP cc	-AC99
   360: dnl Intel ICC	-std=c99, -c99 (deprecated)
   361: dnl IRIX	-c99
   362: dnl Solaris	-D_STDC_C99=
   363: dnl		cc's -xc99 option uses linker magic to define the external
   364: dnl		symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99
   365: dnl		behavior for C library functions.  This is not wanted here,
   366: dnl		because it means that a single module compiled with -xc99
   367: dnl		alters C runtime behavior for the entire program, not for
   368: dnl		just the module.  Instead, define the (private) symbol
   369: dnl		_STDC_C99, which suppresses a bogus failure in <stdbool.h>.
   370: dnl		The resulting compiler passes the test case here, and that's
   371: dnl		good enough.  For more, please see the thread starting at:
   372: dnl            http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
   373: dnl Tru64	-c99
   374: dnl with extended modes being tried first.
   375: [[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99]], [$1], [$2])[]dnl
   376: ])# _AC_PROG_CC_C99
   377: 
   378: 
   379: # _AC_PROG_CC_C11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
   380: # ----------------------------------------------------------------
   381: # If the C compiler is not in ISO C11 mode by default, try to add an
   382: # option to output variable CC to make it so.  This macro tries
   383: # various options that select ISO C11 on some system or another.  It
   384: # considers the compiler to be in ISO C11 mode if it handles _Alignas,
   385: # _Alignof, _Noreturn, _Static_assert, UTF-8 string literals,
   386: # duplicate typedefs, and anonymous structures and unions.
   387: AC_DEFUN([_AC_PROG_CC_C11],
   388: [_AC_C_STD_TRY([c11],
   389: [_AC_C_C99_TEST_HEADER[
   390: // Check _Alignas.
   391: char _Alignas (double) aligned_as_double;
   392: char _Alignas (0) no_special_alignment;
   393: extern char aligned_as_int;
   394: char _Alignas (0) _Alignas (int) aligned_as_int;
   395: 
   396: // Check _Alignof.
   397: enum
   398: {
   399:   int_alignment = _Alignof (int),
   400:   int_array_alignment = _Alignof (int[100]),
   401:   char_alignment = _Alignof (char)
   402: };
   403: _Static_assert (0 < -_Alignof (int), "_Alignof is signed");
   404: 
   405: // Check _Noreturn.
   406: int _Noreturn does_not_return (void) { for (;;) continue; }
   407: 
   408: // Check _Static_assert.
   409: struct test_static_assert
   410: {
   411:   int x;
   412:   _Static_assert (sizeof (int) <= sizeof (long int),
   413:                   "_Static_assert does not work in struct");
   414:   long int y;
   415: };
   416: 
   417: // Check UTF-8 literals.
   418: #define u8 syntax error!
   419: char const utf8_literal[] = u8"happens to be ASCII" "another string";
   420: 
   421: // Check duplicate typedefs.
   422: typedef long *long_ptr;
   423: typedef long int *long_ptr;
   424: typedef long_ptr long_ptr;
   425: 
   426: // Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
   427: struct anonymous
   428: {
   429:   union {
   430:     struct { int i; int j; };
   431:     struct { int k; long int l; } w;
   432:   };
   433:   int m;
   434: } v1;
   435: ]],
   436: [_AC_C_C99_TEST_BODY[
   437:   v1.i = 2;
   438:   v1.w.k = 5;
   439:   _Static_assert ((offsetof (struct anonymous, i)
   440: 		   == offsetof (struct anonymous, w.k)),
   441: 		  "Anonymous union alignment botch");
   442: ]],
   443: dnl Try
   444: dnl GCC		-std=gnu11 (unused restrictive mode: -std=c11)
   445: dnl with extended modes being tried first.
   446: dnl
   447: dnl Do not try -qlanglvl=extc1x, because IBM XL C V12.1 (the latest version as
   448: dnl of September 2012) does not pass the C11 test.  For now, try extc1x when
   449: dnl compiling the C99 test instead, since it enables _Static_assert and
   450: dnl _Noreturn, which is a win.  If -qlanglvl=extc11 or -qlanglvl=extc1x passes
   451: dnl the C11 test in some future version of IBM XL C, we'll add it here,
   452: dnl preferably extc11.
   453: [[-std=gnu11]], [$1], [$2])[]dnl
   454: ])# _AC_PROG_CC_C11
   455: 
   456: 
   457: # AC_PROG_CC_C89
   458: # --------------
   459: # Do not use AU_ALIAS here and in AC_PROG_CC_C99 and AC_PROG_CC_STDC,
   460: # as that'd be incompatible with how Automake redefines AC_PROG_CC.  See
   461: # <http://lists.gnu.org/archive/html/autoconf/2012-10/msg00048.html>.
   462: AU_DEFUN([AC_PROG_CC_C89],
   463:   [AC_REQUIRE([AC_PROG_CC])],
   464:   [$0 is obsolete; use AC_PROG_CC]
   465: )
   466: 
   467: # AC_PROG_CC_C99
   468: # --------------
   469: AU_DEFUN([AC_PROG_CC_C99],
   470:   [AC_REQUIRE([AC_PROG_CC])],
   471:   [$0 is obsolete; use AC_PROG_CC]
   472: )
   473: 
   474: # AC_PROG_CC_STDC
   475: # ---------------
   476: AU_DEFUN([AC_PROG_CC_STDC],
   477:   [AC_REQUIRE([AC_PROG_CC])],
   478:   [$0 is obsolete; use AC_PROG_CC]
   479: )
   480: 
   481: 
   482: # AC_C_PROTOTYPES
   483: # ---------------
   484: # Check if the C compiler supports prototypes, included if it needs
   485: # options.
   486: AC_DEFUN([AC_C_PROTOTYPES],
   487: [AC_REQUIRE([AC_PROG_CC])dnl
   488: if test "$ac_prog_cc_stdc" != no; then
   489:   AC_DEFINE(PROTOTYPES, 1,
   490: 	    [Define to 1 if the C compiler supports function prototypes.])
   491:   AC_DEFINE(__PROTOTYPES, 1,
   492: 	    [Define like PROTOTYPES; this can be used by system headers.])
   493: fi
   494: ])# AC_C_PROTOTYPES
   495: 
   496: 
   497: # _AC_CXX_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
   498: #		  ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
   499: # ----------------------------------------------------------------
   500: # Check whether the C++ compiler accepts features of STANDARD (e.g
   501: # `cxx98', `cxx11') by trying to compile a program of TEST-PROLOGUE
   502: # and TEST-BODY.  If this fails, try again with each compiler option
   503: # in the space-separated OPTION-LIST; if one helps, append it to CXX.
   504: # If eventually successful, run ACTION-IF-AVAILABLE, else
   505: # ACTION-IF-UNAVAILABLE.
   506: AC_DEFUN([_AC_CXX_STD_TRY],
   507: [AC_MSG_CHECKING([for $CXX option to enable ]m4_translit(m4_translit($1, [x], [+]), [a-z], [A-Z])[ features])
   508: AC_LANG_PUSH(C++)dnl
   509: AC_CACHE_VAL(ac_cv_prog_cxx_$1,
   510: [ac_cv_prog_cxx_$1=no
   511: ac_save_CXX=$CXX
   512: AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
   513: for ac_arg in '' $4
   514: do
   515:   CXX="$ac_save_CXX $ac_arg"
   516:   _AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_$1=$ac_arg])
   517:   test "x$ac_cv_prog_cxx_$1" != "xno" && break
   518: done
   519: rm -f conftest.$ac_ext
   520: CXX=$ac_save_CXX
   521: ])# AC_CACHE_VAL
   522: ac_prog_cxx_stdcxx_options=
   523: case "x$ac_cv_prog_cxx_$1" in
   524:   x)
   525:     AC_MSG_RESULT([none needed]) ;;
   526:   xno)
   527:     AC_MSG_RESULT([unsupported]) ;;
   528:   *)
   529:     ac_prog_cxx_stdcxx_options=" $ac_cv_prog_cxx_$1"
   530:     CXX=$CXX$ac_prog_cxx_stdcxx_options
   531:     AC_MSG_RESULT([$ac_cv_prog_cxx_$1]) ;;
   532: esac
   533: AC_LANG_POP(C++)dnl
   534: AS_IF([test "x$ac_cv_prog_cxx_$1" != xno], [$5], [$6])
   535: ])# _AC_CXX_STD_TRY
   536: 
   537: # _AC_CXX_CXX98_TEST_HEADER
   538: # -------------------------
   539: # A C++ header suitable for testing for CXX98.
   540: AC_DEFUN([_AC_CXX_CXX98_TEST_HEADER],
   541: [[
   542: #include <algorithm>
   543: #include <cstdlib>
   544: #include <fstream>
   545: #include <iomanip>
   546: #include <iostream>
   547: #include <list>
   548: #include <map>
   549: #include <set>
   550: #include <sstream>
   551: #include <stdexcept>
   552: #include <string>
   553: #include <utility>
   554: #include <vector>
   555: 
   556: namespace test {
   557:   typedef std::vector<std::string> string_vec;
   558:   typedef std::pair<int,bool> map_value;
   559:   typedef std::map<std::string,map_value> map_type;
   560:   typedef std::set<int> set_type;
   561: 
   562:   template<typename T>
   563:   class printer {
   564:   public:
   565:     printer(std::ostringstream& os): os(os) {}
   566:     void operator() (T elem) { os << elem << std::endl; }
   567:   private:
   568:     std::ostringstream& os;
   569:   };
   570: }
   571: ]])# _AC_CXX_CXX98_TEST_HEADER
   572: 
   573: # _AC_CXX_CXX98_TEST_BODY
   574: # -----------------------
   575: # A C++ body suitable for testing for CXX98, assuming the corresponding header.
   576: AC_DEFUN([_AC_CXX_CXX98_TEST_BODY],
   577: [[
   578: 
   579: try {
   580:   // Basic string.
   581:   std::string teststr("ASCII text");
   582:   teststr += " string";
   583: 
   584:   // Simple vector.
   585:   test::string_vec testvec;
   586:   testvec.push_back(teststr);
   587:   testvec.push_back("foo");
   588:   testvec.push_back("bar");
   589:   if (testvec.size() != 3) {
   590:     throw std::runtime_error("vector size is not 1");
   591:   }
   592: 
   593:   // Dump vector into stringstream and obtain string.
   594:   std::ostringstream os;
   595:   for (test::string_vec::const_iterator i = testvec.begin();
   596:        i != testvec.end(); ++i) {
   597:     if (i + 1 != testvec.end()) {
   598:       os << teststr << '\n';
   599:     }
   600:   }
   601:   // Check algorithms work.
   602:   std::for_each(testvec.begin(), testvec.end(), test::printer<std::string>(os));
   603:   std::string os_out = os.str();
   604: 
   605:   // Test pair and map.
   606:   test::map_type testmap;
   607:   testmap.insert(std::make_pair(std::string("key"),
   608:                                 std::make_pair(53,false)));
   609: 
   610:   // Test set.
   611:   int values[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
   612:   test::set_type testset(values, values + sizeof(values)/sizeof(values[0]));
   613:   std::list<int> testlist(testset.begin(), testset.end());
   614:   std::copy(testset.begin(), testset.end(), std::back_inserter(testlist));
   615: } catch (const std::exception& e) {
   616:   std::cerr << "Caught exception: " << e.what() << std::endl;
   617: 
   618:   // Test fstream
   619:   std::ofstream of("test.txt");
   620:   of << "Test ASCII text\n" << std::flush;
   621:   of << "N= " << std::hex << std::setw(8) << std::left << 534 << std::endl;
   622:   of.close();
   623: }
   624: std::exit(0);
   625: ]])
   626: 
   627: # _AC_CXX_CXX11_TEST_HEADER
   628: # -------------------------
   629: # A C++ header suitable for testing for CXX11.
   630: AC_DEFUN([_AC_CXX_CXX11_TEST_HEADER],
   631: [[
   632: #include <deque>
   633: #include <functional>
   634: #include <memory>
   635: #include <tuple>
   636: #include <array>
   637: #include <regex>
   638: #include <iostream>
   639: 
   640: namespace cxx11test
   641: {
   642:   typedef std::shared_ptr<std::string> sptr;
   643:   typedef std::weak_ptr<std::string> wptr;
   644: 
   645:   typedef std::tuple<std::string,int,double> tp;
   646:   typedef std::array<int, 20> int_array;
   647: 
   648:   constexpr int get_val() { return 20; }
   649: 
   650:   struct testinit
   651:   {
   652:     int i;
   653:     double d;
   654:   };
   655: 
   656:   class delegate  {
   657:   public:
   658:     delegate(int n) : n(n) {}
   659:     delegate(): delegate(2354) {}
   660: 
   661:     virtual int getval() { return this->n; };
   662:   protected:
   663:     int n;
   664:   };
   665: 
   666:   class overridden : public delegate {
   667:   public:
   668:     overridden(int n): delegate(n) {}
   669:     virtual int getval() override final { return this->n * 2; }
   670:   };
   671: 
   672:   class nocopy {
   673:   public:
   674:     nocopy(int i): i(i) {}
   675:     nocopy() = default;
   676:     nocopy(const nocopy&) = delete;
   677:     nocopy & operator=(const nocopy&) = delete;
   678:   private:
   679:     int i;
   680:   };
   681: }
   682: ]])# _AC_CXX_CXX11_TEST_HEADER
   683: 
   684: # _AC_CXX_CXX11_TEST_BODY
   685: # -----------------------
   686: # A C++ body suitable for testing for CXX11, assuming the corresponding header.
   687: AC_DEFUN([_AC_CXX_CXX11_TEST_BODY],
   688: [[
   689: {
   690:   // Test auto and decltype
   691:   std::deque<int> d;
   692:   d.push_front(43);
   693:   d.push_front(484);
   694:   d.push_front(3);
   695:   d.push_front(844);
   696:   int total = 0;
   697:   for (auto i = d.begin(); i != d.end(); ++i) { total += *i; }
   698: 
   699:   auto a1 = 6538;
   700:   auto a2 = 48573953.4;
   701:   auto a3 = "String literal";
   702: 
   703:   decltype(a2) a4 = 34895.034;
   704: }
   705: {
   706:   // Test constexpr
   707:   short sa[cxx11test::get_val()] = { 0 };
   708: }
   709: {
   710:   // Test initializer lists
   711:   cxx11test::testinit il = { 4323, 435234.23544 };
   712: }
   713: {
   714:   // Test range-based for and lambda
   715:   cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
   716:   for (int &x : array) { x += 23; }
   717:   std::for_each(array.begin(), array.end(), [](int v1){ std::cout << v1; });
   718: }
   719: {
   720:   using cxx11test::sptr;
   721:   using cxx11test::wptr;
   722: 
   723:   sptr sp(new std::string("ASCII string"));
   724:   wptr wp(sp);
   725:   sptr sp2(wp);
   726: }
   727: {
   728:   cxx11test::tp tuple("test", 54, 45.53434);
   729:   double d = std::get<2>(tuple);
   730:   std::string s;
   731:   int i;
   732:   std::tie(s,i,d) = tuple;
   733: }
   734: {
   735:   static std::regex filename_regex("^_?([a-z0-9_.]+-)+[a-z0-9]+$");
   736:   std::string testmatch("Test if this string matches");
   737:   bool match = std::regex_search(testmatch, filename_regex);
   738: }
   739: {
   740:   cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
   741:   cxx11test::int_array::size_type size = array.size();
   742: }
   743: {
   744:   // Test constructor delegation
   745:   cxx11test::delegate d1;
   746:   cxx11test::delegate d2();
   747:   cxx11test::delegate d3(45);
   748: }
   749: {
   750:   // Test override and final
   751:   cxx11test::overridden o1(55464);
   752: }
   753: {
   754:   // Test nullptr
   755:   char *c = nullptr;
   756: }
   757: {
   758:   // Test template brackets
   759:   std::vector<std::pair<int,char*>> v1;
   760: }
   761: {
   762:   // Unicode literals
   763:   char const *utf8 = u8"UTF-8 string \u2500";
   764:   char16_t const *utf16 = u"UTF-8 string \u2500";
   765:   char32_t const *utf32 = U"UTF-32 string \u2500";
   766: }
   767: ]])
   768: 
   769: # _AC_PROG_CXX_CXX98 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
   770: # -------------------------------------------------------------------
   771: 
   772: # If the C++ compiler is not in ISO C++98 mode by default, try to add
   773: # an option to output variable CXX to make it so.  This macro tries
   774: # various options that select ISO C++98 on some system or another.  It
   775: # considers the compiler to be in ISO C++98 mode if it handles basic
   776: # features of the std namespace including: string, containers (list,
   777: # map, set, vector), streams (fstreams, iostreams, stringstreams,
   778: # iomanip), pair, exceptions and algorithms.
   779: 
   780: 
   781: AC_DEFUN([_AC_PROG_CXX_CXX98],
   782: [_AC_CXX_STD_TRY([cxx98],
   783: [_AC_CXX_CXX98_TEST_HEADER],
   784: [_AC_CXX_CXX98_TEST_BODY],
   785: dnl Try
   786: dnl GCC		-std=gnu++98 (unused restrictive mode: -std=c++98)
   787: dnl IBM XL C	-qlanglvl=extended
   788: dnl HP aC++	-AA
   789: dnl Intel ICC	-std=gnu++98
   790: dnl Solaris	N/A (default)
   791: dnl Tru64	N/A (default, but -std gnu could be used)
   792: dnl with extended modes being tried first.
   793: [[-std=gnu++98 -std=c++98 -qlanglvl=extended -AA]], [$1], [$2])[]dnl
   794: ])# _AC_PROG_CXX_CXX98
   795: 
   796: # _AC_PROG_CXX_CXX11 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
   797: # -------------------------------------------------------------------
   798: # If the C++ compiler is not in ISO CXX11 mode by default, try to add
   799: # an option to output variable CXX to make it so.  This macro tries
   800: # various options that select ISO C++11 on some system or another.  It
   801: # considers the compiler to be in ISO C++11 mode if it handles all the
   802: # tests from the C++98 checks, plus the following: Language features
   803: # (auto, constexpr, decltype, default/deleted constructors, delegate
   804: # constructors, final, initializer lists, lambda functions, nullptr,
   805: # override, range-based for loops, template brackets without spaces,
   806: # unicode literals) and library features (array, memory (shared_ptr,
   807: # weak_ptr), regex and tuple types).
   808: AC_DEFUN([_AC_PROG_CXX_CXX11],
   809: [_AC_CXX_STD_TRY([cxx11],
   810: [_AC_CXX_CXX11_TEST_HEADER
   811: _AC_CXX_CXX98_TEST_HEADER],
   812: [_AC_CXX_CXX11_TEST_BODY
   813: _AC_CXX_CXX98_TEST_BODY],
   814: dnl Try
   815: dnl GCC		-std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants]
   816: dnl IBM XL C	-qlanglvl=extended0x
   817: dnl		(pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11)
   818: dnl HP aC++	-AA
   819: dnl Intel ICC	-std=c++11 -std=c++0x
   820: dnl Solaris	N/A (no support)
   821: dnl Tru64	N/A (no support)
   822: dnl with extended modes being tried first.
   823: [[-std=gnu++11 -std=c++11 -std=gnu++0x -std=c++0x -qlanglvl=extended0x -AA]], [$1], [$2])[]dnl
   824: ])# _AC_PROG_CXX_CXX11

Generated by git2html.