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-2020 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 <https://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.
36AC_DEFUN_ONCE([AC_PROG_CC],
37[AC_LANG_PUSH(C)dnl
38AC_ARG_VAR([CC],     [C compiler command])dnl
39AC_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
43m4_ifval([$1],
44      [AC_CHECK_TOOLS(CC, [$1])],
45[AC_CHECK_TOOL(CC, gcc)
46if 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
54fi
55if test -z "$CC"; then
56  AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
57fi
58if test -z "$CC"; then
59  AC_CHECK_TOOLS(CC, cl.exe)
60fi
61if test -z "$CC"; then
62  AC_CHECK_TOOL(CC, clang)
63fi
64])
65
66test -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])
70set X $ac_compile
71ac_compiler=$[2]
72for ac_option in --version -v -V -qversion -version; do
73  m4_ifdef([_AC_DO_LIMIT],[_AC_DO_LIMIT],[_AC_DO])([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
74done
75
76m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
77m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
78_AC_LANG_COMPILER_GNU
79if test $ac_compiler_gnu = yes; then
80  GCC=yes
81else
82  GCC=
83fi
84_AC_PROG_CC_G
85dnl
86dnl Set ac_prog_cc_stdc to the supported C version.
87dnl Also set the documented variable ac_cv_prog_cc_stdc;
88dnl 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])])])
97dnl
98AC_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++
115AC_DEFUN([AC_PROG_CXX],
116[AC_LANG_PUSH(C++)dnl
117AC_ARG_VAR([CXX],      [C++ compiler command])dnl
118AC_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
123if 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
132fi
133# Provide some information about the compiler.
134_AS_ECHO_LOG([checking for _AC_LANG compiler version])
135set X $ac_compile
136ac_compiler=$[2]
137for ac_option in --version -v -V -qversion; do
138  m4_ifdef([_AC_DO_LIMIT],[_AC_DO_LIMIT],[_AC_DO])([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
139done
140
141m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
142m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
143_AC_LANG_COMPILER_GNU
144if test $ac_compiler_gnu = yes; then
145  GXX=yes
146else
147  GXX=
148fi
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])])
157AC_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.
169AC_DEFUN([_AC_C_STD_TRY],
170[AC_MSG_CHECKING([for $CC option to enable ]m4_translit($1, [c], [C])[ features])
171AC_CACHE_VAL(ac_cv_prog_cc_$1,
172[ac_cv_prog_cc_$1=no
173ac_save_CC=$CC
174AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
175for ac_arg in '' $4
176do
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
180done
181rm -f conftest.$ac_ext
182CC=$ac_save_CC
183])# AC_CACHE_VAL
184ac_prog_cc_stdc_options=
185case "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]) ;;
194esac
195AS_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.
201AC_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__))
213static void
214test_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
235static long long int bignum = -9223372036854775807LL;
236static unsigned long long int ubignum = BIG64;
237
238struct incomplete_array
239{
240  int datasize;
241  double data[];
242};
243
244struct named_init {
245  int number;
246  const wchar_t *name;
247  double average;
248};
249
250typedef const char *ccp;
251
252static inline int
253test_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.
264static bool
265test_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.
302AC_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.
350AC_DEFUN([_AC_PROG_CC_C99],
351[_AC_C_STD_TRY([c99],
352[_AC_C_C99_TEST_HEADER],
353[_AC_C_C99_TEST_BODY],
354dnl Try
355dnl GCC		-std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
356dnl IBM XL C	-qlanglvl=extc1x (V12.1; does not pass C11 test)
357dnl IBM XL C	-qlanglvl=extc99
358dnl		(pre-V12.1; unused restrictive mode: -qlanglvl=stdc99)
359dnl HP cc	-AC99
360dnl Intel ICC	-std=c99, -c99 (deprecated)
361dnl IRIX	-c99
362dnl Solaris	-D_STDC_C99=
363dnl		cc's -xc99 option uses linker magic to define the external
364dnl		symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99
365dnl		behavior for C library functions.  This is not wanted here,
366dnl		because it means that a single module compiled with -xc99
367dnl		alters C runtime behavior for the entire program, not for
368dnl		just the module.  Instead, define the (private) symbol
369dnl		_STDC_C99, which suppresses a bogus failure in <stdbool.h>.
370dnl		The resulting compiler passes the test case here, and that's
371dnl		good enough.  For more, please see the thread starting at:
372dnl            https://lists.gnu.org/r/autoconf/2010-12/msg00059.html
373dnl Tru64	-c99
374dnl 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.
387AC_DEFUN([_AC_PROG_CC_C11],
388[_AC_C_STD_TRY([c11],
389[_AC_C_C99_TEST_HEADER[
390// Check _Alignas.
391char _Alignas (double) aligned_as_double;
392char _Alignas (0) no_special_alignment;
393extern char aligned_as_int;
394char _Alignas (0) _Alignas (int) aligned_as_int;
395
396// Check _Alignof.
397enum
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.
406int _Noreturn does_not_return (void) { for (;;) continue; }
407
408// Check _Static_assert.
409struct 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!
419char const utf8_literal[] = u8"happens to be ASCII" "another string";
420
421// Check duplicate typedefs.
422typedef long *long_ptr;
423typedef long int *long_ptr;
424typedef long_ptr long_ptr;
425
426// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
427struct 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]],
443dnl Try
444dnl GCC		-std=gnu11 (unused restrictive mode: -std=c11)
445dnl with extended modes being tried first.
446dnl
447dnl Do not try -qlanglvl=extc1x, because IBM XL C V12.1 (the latest version as
448dnl of September 2012) does not pass the C11 test.  For now, try extc1x when
449dnl compiling the C99 test instead, since it enables _Static_assert and
450dnl _Noreturn, which is a win.  If -qlanglvl=extc11 or -qlanglvl=extc1x passes
451dnl the C11 test in some future version of IBM XL C, we'll add it here,
452dnl 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# <https://lists.gnu.org/r/autoconf/2012-10/msg00048.html>.
462AU_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# --------------
469AU_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# ---------------
476AU_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.
486AC_DEFUN([AC_C_PROTOTYPES],
487[AC_REQUIRE([AC_PROG_CC])dnl
488if 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.])
493fi
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.
506AC_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])
508AC_LANG_PUSH(C++)dnl
509AC_CACHE_VAL(ac_cv_prog_cxx_$1,
510[ac_cv_prog_cxx_$1=no
511ac_save_CXX=$CXX
512AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
513for ac_arg in '' $4
514do
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
518done
519rm -f conftest.$ac_ext
520CXX=$ac_save_CXX
521])# AC_CACHE_VAL
522ac_prog_cxx_stdcxx_options=
523case "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]) ;;
532esac
533AC_LANG_POP(C++)dnl
534AS_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.
540AC_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
556namespace 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.
576AC_DEFUN([_AC_CXX_CXX98_TEST_BODY],
577[[
578
579try {
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}
624std::exit(0);
625]])
626
627# _AC_CXX_CXX11_TEST_HEADER
628# -------------------------
629# A C++ header suitable for testing for CXX11.
630AC_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
640namespace 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.
687AC_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
781AC_DEFUN([_AC_PROG_CXX_CXX98],
782[_AC_CXX_STD_TRY([cxx98],
783[_AC_CXX_CXX98_TEST_HEADER],
784[_AC_CXX_CXX98_TEST_BODY],
785dnl Try
786dnl GCC		-std=gnu++98 (unused restrictive mode: -std=c++98)
787dnl IBM XL C	-qlanglvl=extended
788dnl HP aC++	-AA
789dnl Intel ICC	-std=gnu++98
790dnl Solaris	N/A (default)
791dnl Tru64	N/A (default, but -std gnu could be used)
792dnl 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).
808AC_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],
814dnl Try
815dnl GCC		-std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants]
816dnl IBM XL C	-qlanglvl=extended0x
817dnl		(pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11)
818dnl HP aC++	-AA
819dnl Intel ICC	-std=c++11 -std=c++0x
820dnl Solaris	N/A (no support)
821dnl Tru64	N/A (no support)
822dnl 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
825