|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
m4_version_prereq([2.70], [], [ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN_ONCE([AC_PROG_CC], |
|
|
[AC_LANG_PUSH(C)dnl |
|
|
AC_ARG_VAR([CC], [C compiler command])dnl |
|
|
AC_ARG_VAR([CFLAGS], [C compiler flags])dnl |
|
|
_AC_ARG_VAR_LDFLAGS()dnl |
|
|
_AC_ARG_VAR_LIBS()dnl |
|
|
_AC_ARG_VAR_CPPFLAGS()dnl |
|
|
m4_ifval([$1], |
|
|
[AC_CHECK_TOOLS(CC, [$1])], |
|
|
[AC_CHECK_TOOL(CC, gcc) |
|
|
if test -z "$CC"; then |
|
|
dnl Here we want: |
|
|
dnl AC_CHECK_TOOL(CC, cc) |
|
|
dnl but without the check for a tool without the prefix. |
|
|
dnl Until the check is removed from there, copy the code: |
|
|
if test -n "$ac_tool_prefix"; then |
|
|
AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc]) |
|
|
fi |
|
|
fi |
|
|
if test -z "$CC"; then |
|
|
AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) |
|
|
fi |
|
|
if test -z "$CC"; then |
|
|
AC_CHECK_TOOLS(CC, cl.exe) |
|
|
fi |
|
|
if test -z "$CC"; then |
|
|
AC_CHECK_TOOL(CC, clang) |
|
|
fi |
|
|
]) |
|
|
|
|
|
test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH]) |
|
|
|
|
|
|
|
|
_AS_ECHO_LOG([checking for _AC_LANG compiler version]) |
|
|
set X $ac_compile |
|
|
ac_compiler=$[2] |
|
|
for ac_option in --version -v -V -qversion -version; do |
|
|
_AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) |
|
|
done |
|
|
|
|
|
m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl |
|
|
m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl |
|
|
_AC_LANG_COMPILER_GNU |
|
|
if test $ac_compiler_gnu = yes; then |
|
|
GCC=yes |
|
|
else |
|
|
GCC= |
|
|
fi |
|
|
_AC_PROG_CC_G |
|
|
dnl |
|
|
dnl Set ac_prog_cc_stdc to the supported C version. |
|
|
dnl Also set the documented variable ac_cv_prog_cc_stdc; |
|
|
dnl its name was chosen when it was cached, but it is no longer cached. |
|
|
_AC_PROG_CC_C11([ac_prog_cc_stdc=c11 |
|
|
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11], |
|
|
[_AC_PROG_CC_C99([ac_prog_cc_stdc=c99 |
|
|
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99], |
|
|
[_AC_PROG_CC_C89([ac_prog_cc_stdc=c89 |
|
|
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89], |
|
|
[ac_prog_cc_stdc=no |
|
|
ac_cv_prog_cc_stdc=no])])]) |
|
|
dnl |
|
|
AC_LANG_POP(C)dnl |
|
|
])# AC_PROG_CC |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([AC_PROG_CXX], |
|
|
[AC_LANG_PUSH(C++)dnl |
|
|
AC_ARG_VAR([CXX], [C++ compiler command])dnl |
|
|
AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl |
|
|
_AC_ARG_VAR_LDFLAGS()dnl |
|
|
_AC_ARG_VAR_LIBS()dnl |
|
|
_AC_ARG_VAR_CPPFLAGS()dnl |
|
|
_AC_ARG_VAR_PRECIOUS([CCC])dnl |
|
|
if test -z "$CXX"; then |
|
|
if test -n "$CCC"; then |
|
|
CXX=$CCC |
|
|
else |
|
|
AC_CHECK_TOOLS(CXX, |
|
|
[m4_default([$1], |
|
|
[g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++])], |
|
|
g++) |
|
|
fi |
|
|
fi |
|
|
|
|
|
_AS_ECHO_LOG([checking for _AC_LANG compiler version]) |
|
|
set X $ac_compile |
|
|
ac_compiler=$[2] |
|
|
for ac_option in --version -v -V -qversion; do |
|
|
_AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) |
|
|
done |
|
|
|
|
|
m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl |
|
|
m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl |
|
|
_AC_LANG_COMPILER_GNU |
|
|
if test $ac_compiler_gnu = yes; then |
|
|
GXX=yes |
|
|
else |
|
|
GXX= |
|
|
fi |
|
|
_AC_PROG_CXX_G |
|
|
_AC_PROG_CXX_CXX11([ac_prog_cxx_stdcxx=cxx11 |
|
|
ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 |
|
|
ac_cv_prog_cxx_cxx98=$ac_cv_prog_cxx_cxx11], |
|
|
[_AC_PROG_CXX_CXX98([ac_prog_cxx_stdcxx=cxx98 |
|
|
ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98], |
|
|
[ac_prog_cxx_stdcxx=no |
|
|
ac_cv_prog_cxx_stdcxx=no])]) |
|
|
AC_LANG_POP(C++)dnl |
|
|
])# AC_PROG_CXX |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_C_STD_TRY], |
|
|
[AC_MSG_CHECKING([for $CC option to enable ]m4_translit($1, [c], [C])[ features]) |
|
|
AC_CACHE_VAL(ac_cv_prog_cc_$1, |
|
|
[ac_cv_prog_cc_$1=no |
|
|
ac_save_CC=$CC |
|
|
AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) |
|
|
for ac_arg in '' $4 |
|
|
do |
|
|
CC="$ac_save_CC $ac_arg" |
|
|
_AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) |
|
|
test "x$ac_cv_prog_cc_$1" != "xno" && break |
|
|
done |
|
|
rm -f conftest.$ac_ext |
|
|
CC=$ac_save_CC |
|
|
])# AC_CACHE_VAL |
|
|
ac_prog_cc_stdc_options= |
|
|
case "x$ac_cv_prog_cc_$1" in |
|
|
x) |
|
|
AC_MSG_RESULT([none needed]) ;; |
|
|
xno) |
|
|
AC_MSG_RESULT([unsupported]) ;; |
|
|
*) |
|
|
ac_prog_cc_stdc_options=" $ac_cv_prog_cc_$1" |
|
|
CC=$CC$ac_prog_cc_stdc_options |
|
|
AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;; |
|
|
esac |
|
|
AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6]) |
|
|
])# _AC_C_STD_TRY |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_C_C99_TEST_HEADER], |
|
|
[[#include <stdarg.h> |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Check varargs macros. These examples are taken from C99 6.10.3.5. |
|
|
|
|
|
|
|
|
|
|
|
static void |
|
|
test_varargs_macros (void) |
|
|
{ |
|
|
int x = 1234; |
|
|
int y = 5678; |
|
|
debug ("Flag"); |
|
|
debug ("X = %d\n", x); |
|
|
showlist (The first, second, and third items.); |
|
|
report (x>y, "x is %d but y is %d", x, y); |
|
|
} |
|
|
|
|
|
// Check long long types. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
your preprocessor is broken; |
|
|
|
|
|
|
|
|
|
|
|
your preprocessor is broken; |
|
|
|
|
|
static long long int bignum = -9223372036854775807LL; |
|
|
static unsigned long long int ubignum = BIG64; |
|
|
|
|
|
struct incomplete_array |
|
|
{ |
|
|
int datasize; |
|
|
double data[]; |
|
|
}; |
|
|
|
|
|
struct named_init { |
|
|
int number; |
|
|
const wchar_t *name; |
|
|
double average; |
|
|
}; |
|
|
|
|
|
typedef const char *ccp; |
|
|
|
|
|
static inline int |
|
|
test_restrict (ccp restrict text) |
|
|
{ |
|
|
// See if C++-style comments work. |
|
|
// Iterate through items via the restricted pointer. |
|
|
// Also check for declarations in for loops. |
|
|
for (unsigned int i = 0; *(text+i) != '\0'; ++i) |
|
|
continue; |
|
|
return 0; |
|
|
} |
|
|
|
|
|
// Check varargs and va_copy. |
|
|
static bool |
|
|
test_varargs (const char *format, ...) |
|
|
{ |
|
|
va_list args; |
|
|
va_start (args, format); |
|
|
va_list args_copy; |
|
|
va_copy (args_copy, args); |
|
|
|
|
|
const char *str = ""; |
|
|
int number = 0; |
|
|
float fnumber = 0; |
|
|
|
|
|
while (*format) |
|
|
{ |
|
|
switch (*format++) |
|
|
{ |
|
|
case 's': // string |
|
|
str = va_arg (args_copy, const char *); |
|
|
break; |
|
|
case 'd': // int |
|
|
number = va_arg (args_copy, int); |
|
|
break; |
|
|
case 'f': // float |
|
|
fnumber = va_arg (args_copy, double); |
|
|
break; |
|
|
default: |
|
|
break; |
|
|
} |
|
|
} |
|
|
va_end (args_copy); |
|
|
va_end (args); |
|
|
|
|
|
return *str && number && fnumber; |
|
|
}]])# _AC_C_C99_TEST_HEADER |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_C_C99_TEST_BODY], |
|
|
[[ |
|
|
// Check bool. |
|
|
_Bool success = false; |
|
|
|
|
|
// Check restrict. |
|
|
if (test_restrict ("String literal") == 0) |
|
|
success = true; |
|
|
char *restrict newvar = "Another string"; |
|
|
|
|
|
// Check varargs. |
|
|
success &= test_varargs ("s, d' f .", "string", 65, 34.234); |
|
|
test_varargs_macros (); |
|
|
|
|
|
// Check flexible array members. |
|
|
struct incomplete_array *ia = |
|
|
malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); |
|
|
ia->datasize = 10; |
|
|
for (int i = 0; i < ia->datasize; ++i) |
|
|
ia->data[i] = i * 1.234; |
|
|
|
|
|
// Check named initializers. |
|
|
struct named_init ni = { |
|
|
.number = 34, |
|
|
.name = L"Test wide string", |
|
|
.average = 543.34343, |
|
|
}; |
|
|
|
|
|
ni.number = 58; |
|
|
|
|
|
int dynamic_array[ni.number]; |
|
|
dynamic_array[ni.number - 1] = 543; |
|
|
|
|
|
// work around unused variable warnings |
|
|
return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' |
|
|
|| dynamic_array[ni.number - 1] != 543); |
|
|
]]) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_PROG_CC_C99], |
|
|
[_AC_C_STD_TRY([c99], |
|
|
[_AC_C_C99_TEST_HEADER], |
|
|
[_AC_C_C99_TEST_BODY], |
|
|
dnl Try |
|
|
dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) |
|
|
dnl IBM XL C -qlanglvl=extc1x (V12.1; does not pass C11 test) |
|
|
dnl IBM XL C -qlanglvl=extc99 |
|
|
dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdc99) |
|
|
dnl HP cc -AC99 |
|
|
dnl Intel ICC -std=c99, -c99 (deprecated) |
|
|
dnl IRIX -c99 |
|
|
dnl Solaris -D_STDC_C99= |
|
|
dnl cc's -xc99 option uses linker magic to define the external |
|
|
dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 |
|
|
dnl behavior for C library functions. This is not wanted here, |
|
|
dnl because it means that a single module compiled with -xc99 |
|
|
dnl alters C runtime behavior for the entire program, not for |
|
|
dnl just the module. Instead, define the (private) symbol |
|
|
dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>. |
|
|
dnl The resulting compiler passes the test case here, and that's |
|
|
dnl good enough. For more, please see the thread starting at: |
|
|
dnl https://lists.gnu.org/r/autoconf/2010-12/msg00059.html |
|
|
dnl Tru64 -c99 |
|
|
dnl with extended modes being tried first. |
|
|
[[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc1x -qlanglvl=extc99]], [$1], [$2])[]dnl |
|
|
])# _AC_PROG_CC_C99 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_PROG_CC_C11], |
|
|
[_AC_C_STD_TRY([c11], |
|
|
[_AC_C_C99_TEST_HEADER[ |
|
|
// Check _Alignas. |
|
|
char _Alignas (double) aligned_as_double; |
|
|
char _Alignas (0) no_special_alignment; |
|
|
extern char aligned_as_int; |
|
|
char _Alignas (0) _Alignas (int) aligned_as_int; |
|
|
|
|
|
// Check _Alignof. |
|
|
enum |
|
|
{ |
|
|
int_alignment = _Alignof (int), |
|
|
int_array_alignment = _Alignof (int[100]), |
|
|
char_alignment = _Alignof (char) |
|
|
}; |
|
|
_Static_assert (0 < -_Alignof (int), "_Alignof is signed"); |
|
|
|
|
|
// Check _Noreturn. |
|
|
int _Noreturn does_not_return (void) { for (;;) continue; } |
|
|
|
|
|
// Check _Static_assert. |
|
|
struct test_static_assert |
|
|
{ |
|
|
int x; |
|
|
_Static_assert (sizeof (int) <= sizeof (long int), |
|
|
"_Static_assert does not work in struct"); |
|
|
long int y; |
|
|
}; |
|
|
|
|
|
// Check UTF-8 literals. |
|
|
|
|
|
char const utf8_literal[] = u8"happens to be ASCII" "another string"; |
|
|
|
|
|
// Check duplicate typedefs. |
|
|
typedef long *long_ptr; |
|
|
typedef long int *long_ptr; |
|
|
typedef long_ptr long_ptr; |
|
|
|
|
|
// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. |
|
|
struct anonymous |
|
|
{ |
|
|
union { |
|
|
struct { int i; int j; }; |
|
|
struct { int k; long int l; } w; |
|
|
}; |
|
|
int m; |
|
|
} v1; |
|
|
]], |
|
|
[_AC_C_C99_TEST_BODY[ |
|
|
v1.i = 2; |
|
|
v1.w.k = 5; |
|
|
_Static_assert ((offsetof (struct anonymous, i) |
|
|
== offsetof (struct anonymous, w.k)), |
|
|
"Anonymous union alignment botch"); |
|
|
]], |
|
|
dnl Try |
|
|
dnl GCC -std=gnu11 (unused restrictive mode: -std=c11) |
|
|
dnl with extended modes being tried first. |
|
|
dnl |
|
|
dnl Do not try -qlanglvl=extc1x, because IBM XL C V12.1 (the latest version as |
|
|
dnl of September 2012) does not pass the C11 test. For now, try extc1x when |
|
|
dnl compiling the C99 test instead, since it enables _Static_assert and |
|
|
dnl _Noreturn, which is a win. If -qlanglvl=extc11 or -qlanglvl=extc1x passes |
|
|
dnl the C11 test in some future version of IBM XL C, we'll add it here, |
|
|
dnl preferably extc11. |
|
|
[[-std=gnu11]], [$1], [$2])[]dnl |
|
|
])# _AC_PROG_CC_C11 |
|
|
|
|
|
|
|
|
# AC_PROG_CC_C89 |
|
|
# -------------- |
|
|
# Do not use AU_ALIAS here and in AC_PROG_CC_C99 and AC_PROG_CC_STDC, |
|
|
# as that'd be incompatible with how Automake redefines AC_PROG_CC. See |
|
|
|
|
|
AU_DEFUN([AC_PROG_CC_C89], |
|
|
[AC_REQUIRE([AC_PROG_CC])], |
|
|
[$0 is obsolete; use AC_PROG_CC] |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
AU_DEFUN([AC_PROG_CC_C99], |
|
|
[AC_REQUIRE([AC_PROG_CC])], |
|
|
[$0 is obsolete; use AC_PROG_CC] |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
AU_DEFUN([AC_PROG_CC_STDC], |
|
|
[AC_REQUIRE([AC_PROG_CC])], |
|
|
[$0 is obsolete; use AC_PROG_CC] |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([AC_C_PROTOTYPES], |
|
|
[AC_REQUIRE([AC_PROG_CC])dnl |
|
|
if test "$ac_prog_cc_stdc" != no; then |
|
|
AC_DEFINE(PROTOTYPES, 1, |
|
|
[Define to 1 if the C compiler supports function prototypes.]) |
|
|
AC_DEFINE(__PROTOTYPES, 1, |
|
|
[Define like PROTOTYPES; this can be used by system headers.]) |
|
|
fi |
|
|
])# AC_C_PROTOTYPES |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_CXX_STD_TRY], |
|
|
[AC_MSG_CHECKING([for $CXX option to enable ]m4_translit(m4_translit($1, [x], [+]), [a-z], [A-Z])[ features]) |
|
|
AC_LANG_PUSH(C++)dnl |
|
|
AC_CACHE_VAL(ac_cv_prog_cxx_$1, |
|
|
[ac_cv_prog_cxx_$1=no |
|
|
ac_save_CXX=$CXX |
|
|
AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) |
|
|
for ac_arg in '' $4 |
|
|
do |
|
|
CXX="$ac_save_CXX $ac_arg" |
|
|
_AC_COMPILE_IFELSE([], [ac_cv_prog_cxx_$1=$ac_arg]) |
|
|
test "x$ac_cv_prog_cxx_$1" != "xno" && break |
|
|
done |
|
|
rm -f conftest.$ac_ext |
|
|
CXX=$ac_save_CXX |
|
|
])# AC_CACHE_VAL |
|
|
ac_prog_cxx_stdcxx_options= |
|
|
case "x$ac_cv_prog_cxx_$1" in |
|
|
x) |
|
|
AC_MSG_RESULT([none needed]) ;; |
|
|
xno) |
|
|
AC_MSG_RESULT([unsupported]) ;; |
|
|
*) |
|
|
ac_prog_cxx_stdcxx_options=" $ac_cv_prog_cxx_$1" |
|
|
CXX=$CXX$ac_prog_cxx_stdcxx_options |
|
|
AC_MSG_RESULT([$ac_cv_prog_cxx_$1]) ;; |
|
|
esac |
|
|
AC_LANG_POP(C++)dnl |
|
|
AS_IF([test "x$ac_cv_prog_cxx_$1" != xno], [$5], [$6]) |
|
|
])# _AC_CXX_STD_TRY |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_CXX_CXX98_TEST_HEADER], |
|
|
[[ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace test { |
|
|
typedef std::vector<std::string> string_vec; |
|
|
typedef std::pair<int,bool> map_value; |
|
|
typedef std::map<std::string,map_value> map_type; |
|
|
typedef std::set<int> set_type; |
|
|
|
|
|
template<typename T> |
|
|
class printer { |
|
|
public: |
|
|
printer(std::ostringstream& os): os(os) {} |
|
|
void operator() (T elem) { os << elem << std::endl; } |
|
|
private: |
|
|
std::ostringstream& os; |
|
|
}; |
|
|
} |
|
|
]])# _AC_CXX_CXX98_TEST_HEADER |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_CXX_CXX98_TEST_BODY], |
|
|
[[ |
|
|
|
|
|
try { |
|
|
// Basic string. |
|
|
std::string teststr("ASCII text"); |
|
|
teststr += " string"; |
|
|
|
|
|
// Simple vector. |
|
|
test::string_vec testvec; |
|
|
testvec.push_back(teststr); |
|
|
testvec.push_back("foo"); |
|
|
testvec.push_back("bar"); |
|
|
if (testvec.size() != 3) { |
|
|
throw std::runtime_error("vector size is not 1"); |
|
|
} |
|
|
|
|
|
// Dump vector into stringstream and obtain string. |
|
|
std::ostringstream os; |
|
|
for (test::string_vec::const_iterator i = testvec.begin(); |
|
|
i != testvec.end(); ++i) { |
|
|
if (i + 1 != testvec.end()) { |
|
|
os << teststr << '\n'; |
|
|
} |
|
|
} |
|
|
// Check algorithms work. |
|
|
std::for_each(testvec.begin(), testvec.end(), test::printer<std::string>(os)); |
|
|
std::string os_out = os.str(); |
|
|
|
|
|
// Test pair and map. |
|
|
test::map_type testmap; |
|
|
testmap.insert(std::make_pair(std::string("key"), |
|
|
std::make_pair(53,false))); |
|
|
|
|
|
// Test set. |
|
|
int values[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; |
|
|
test::set_type testset(values, values + sizeof(values)/sizeof(values[0])); |
|
|
std::list<int> testlist(testset.begin(), testset.end()); |
|
|
std::copy(testset.begin(), testset.end(), std::back_inserter(testlist)); |
|
|
} catch (const std::exception& e) { |
|
|
std::cerr << "Caught exception: " << e.what() << std::endl; |
|
|
|
|
|
// Test fstream |
|
|
std::ofstream of("test.txt"); |
|
|
of << "Test ASCII text\n" << std::flush; |
|
|
of << "N= " << std::hex << std::setw(8) << std::left << 534 << std::endl; |
|
|
of.close(); |
|
|
} |
|
|
std::exit(0); |
|
|
]]) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_CXX_CXX11_TEST_HEADER], |
|
|
[[ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace cxx11test |
|
|
{ |
|
|
typedef std::shared_ptr<std::string> sptr; |
|
|
typedef std::weak_ptr<std::string> wptr; |
|
|
|
|
|
typedef std::tuple<std::string,int,double> tp; |
|
|
typedef std::array<int, 20> int_array; |
|
|
|
|
|
constexpr int get_val() { return 20; } |
|
|
|
|
|
struct testinit |
|
|
{ |
|
|
int i; |
|
|
double d; |
|
|
}; |
|
|
|
|
|
class delegate { |
|
|
public: |
|
|
delegate(int n) : n(n) {} |
|
|
delegate(): delegate(2354) {} |
|
|
|
|
|
virtual int getval() { return this->n; }; |
|
|
protected: |
|
|
int n; |
|
|
}; |
|
|
|
|
|
class overridden : public delegate { |
|
|
public: |
|
|
overridden(int n): delegate(n) {} |
|
|
virtual int getval() override final { return this->n * 2; } |
|
|
}; |
|
|
|
|
|
class nocopy { |
|
|
public: |
|
|
nocopy(int i): i(i) {} |
|
|
nocopy() = default; |
|
|
nocopy(const nocopy&) = delete; |
|
|
nocopy & operator=(const nocopy&) = delete; |
|
|
private: |
|
|
int i; |
|
|
}; |
|
|
} |
|
|
]])# _AC_CXX_CXX11_TEST_HEADER |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_CXX_CXX11_TEST_BODY], |
|
|
[[ |
|
|
{ |
|
|
// Test auto and decltype |
|
|
std::deque<int> d; |
|
|
d.push_front(43); |
|
|
d.push_front(484); |
|
|
d.push_front(3); |
|
|
d.push_front(844); |
|
|
int total = 0; |
|
|
for (auto i = d.begin(); i != d.end(); ++i) { total += *i; } |
|
|
|
|
|
auto a1 = 6538; |
|
|
auto a2 = 48573953.4; |
|
|
auto a3 = "String literal"; |
|
|
|
|
|
decltype(a2) a4 = 34895.034; |
|
|
} |
|
|
{ |
|
|
// Test constexpr |
|
|
short sa[cxx11test::get_val()] = { 0 }; |
|
|
} |
|
|
{ |
|
|
// Test initializer lists |
|
|
cxx11test::testinit il = { 4323, 435234.23544 }; |
|
|
} |
|
|
{ |
|
|
// Test range-based for and lambda |
|
|
cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; |
|
|
for (int &x : array) { x += 23; } |
|
|
std::for_each(array.begin(), array.end(), [](int v1){ std::cout << v1; }); |
|
|
} |
|
|
{ |
|
|
using cxx11test::sptr; |
|
|
using cxx11test::wptr; |
|
|
|
|
|
sptr sp(new std::string("ASCII string")); |
|
|
wptr wp(sp); |
|
|
sptr sp2(wp); |
|
|
} |
|
|
{ |
|
|
cxx11test::tp tuple("test", 54, 45.53434); |
|
|
double d = std::get<2>(tuple); |
|
|
std::string s; |
|
|
int i; |
|
|
std::tie(s,i,d) = tuple; |
|
|
} |
|
|
{ |
|
|
static std::regex filename_regex("^_?([a-z0-9_.]+-)+[a-z0-9]+$"); |
|
|
std::string testmatch("Test if this string matches"); |
|
|
bool match = std::regex_search(testmatch, filename_regex); |
|
|
} |
|
|
{ |
|
|
cxx11test::int_array array = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; |
|
|
cxx11test::int_array::size_type size = array.size(); |
|
|
} |
|
|
{ |
|
|
// Test constructor delegation |
|
|
cxx11test::delegate d1; |
|
|
cxx11test::delegate d2(); |
|
|
cxx11test::delegate d3(45); |
|
|
} |
|
|
{ |
|
|
// Test override and final |
|
|
cxx11test::overridden o1(55464); |
|
|
} |
|
|
{ |
|
|
// Test nullptr |
|
|
char *c = nullptr; |
|
|
} |
|
|
{ |
|
|
// Test template brackets |
|
|
std::vector<std::pair<int,char*>> v1; |
|
|
} |
|
|
{ |
|
|
// Unicode literals |
|
|
char const *utf8 = u8"UTF-8 string \u2500"; |
|
|
char16_t const *utf16 = u"UTF-8 string \u2500"; |
|
|
char32_t const *utf32 = U"UTF-32 string \u2500"; |
|
|
} |
|
|
]]) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_PROG_CXX_CXX98], |
|
|
[_AC_CXX_STD_TRY([cxx98], |
|
|
[_AC_CXX_CXX98_TEST_HEADER], |
|
|
[_AC_CXX_CXX98_TEST_BODY], |
|
|
dnl Try |
|
|
dnl GCC -std=gnu++98 (unused restrictive mode: -std=c++98) |
|
|
dnl IBM XL C -qlanglvl=extended |
|
|
dnl HP aC++ -AA |
|
|
dnl Intel ICC -std=gnu++98 |
|
|
dnl Solaris N/A (default) |
|
|
dnl Tru64 N/A (default, but -std gnu could be used) |
|
|
dnl with extended modes being tried first. |
|
|
[[-std=gnu++98 -std=c++98 -qlanglvl=extended -AA]], [$1], [$2])[]dnl |
|
|
])# _AC_PROG_CXX_CXX98 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
AC_DEFUN([_AC_PROG_CXX_CXX11], |
|
|
[_AC_CXX_STD_TRY([cxx11], |
|
|
[_AC_CXX_CXX11_TEST_HEADER |
|
|
_AC_CXX_CXX98_TEST_HEADER], |
|
|
[_AC_CXX_CXX11_TEST_BODY |
|
|
_AC_CXX_CXX98_TEST_BODY], |
|
|
dnl Try |
|
|
dnl GCC -std=gnu++11 (unused restrictive mode: -std=c++11) [and 0x variants] |
|
|
dnl IBM XL C -qlanglvl=extended0x |
|
|
dnl (pre-V12.1; unused restrictive mode: -qlanglvl=stdcxx11) |
|
|
dnl HP aC++ -AA |
|
|
dnl Intel ICC -std=c++11 -std=c++0x |
|
|
dnl Solaris N/A (no support) |
|
|
dnl Tru64 N/A (no support) |
|
|
dnl with extended modes being tried first. |
|
|
[[-std=gnu++11 -std=c++11 -std=gnu++0x -std=c++0x -qlanglvl=extended0x -AA]], [$1], [$2])[]dnl |
|
|
])# _AC_PROG_CXX_CXX11 |
|
|
|
|
|
|
|
|
])# m4_version_prereq |
|
|
|
