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.