| # AC_GNU_SOURCE |
| # -------------- |
| AC_DEFUN([AC_GNU_SOURCE], |
| [AH_VERBATIM([_GNU_SOURCE], |
| [/* Enable GNU extensions on systems that have them. */ |
| #ifndef _GNU_SOURCE |
| # undef _GNU_SOURCE |
| #endif])dnl |
| AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl |
| AC_BEFORE([$0], [AC_RUN_IFELSE])dnl |
| AC_DEFINE([_GNU_SOURCE]) |
| ]) |
| |
| # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, |
| # ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) |
| # -------------------------------------------------------------- |
| # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') |
| # by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails, |
| # try again with each compiler option in the space-separated OPTION-LIST; if one |
| # helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE, |
| # else ACTION-IF-UNAVAILABLE. |
| AC_DEFUN([_AC_C_STD_TRY], |
| [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C])) |
| 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 |
| case "x$ac_cv_prog_cc_$1" in |
| x) |
| AC_MSG_RESULT([none needed]) ;; |
| xno) |
| AC_MSG_RESULT([unsupported]) ;; |
| *) |
| CC="$CC $ac_cv_prog_cc_$1" |
| 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_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) |
| # ---------------------------------------------------------------- |
| # If the C compiler is not in ISO C99 mode by default, try to add an |
| # option to output variable CC to make it so. This macro tries |
| # various options that select ISO C99 on some system or another. It |
| # considers the compiler to be in ISO C99 mode if it handles mixed |
| # code and declarations, _Bool, inline and restrict. |
| AC_DEFUN([_AC_PROG_CC_C99], |
| [_AC_C_STD_TRY([c99], |
| [[#include <stdarg.h> |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <wchar.h> |
| #include <stdio.h> |
| |
| 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 work. |
| static void |
| 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; |
| float fnumber; |
| |
| 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 = (float) va_arg(args_copy, double); |
| break; |
| default: |
| break; |
| } |
| } |
| va_end(args_copy); |
| va_end(args); |
| } |
| ]], |
| [[ |
| // Check bool and long long datatypes. |
| _Bool success = false; |
| long long int bignum = -1234567890LL; |
| unsigned long long int ubignum = 1234567890uLL; |
| |
| // Check restrict. |
| if (test_restrict("String literal") != 0) |
| success = true; |
| char *restrict newvar = "Another string"; |
| |
| // Check varargs. |
| test_varargs("s, d' f .", "string", 65, 34.234); |
| |
| // Check incomplete arrays work. |
| 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] = (double) i * 1.234; |
| |
| // Check named initialisers. |
| struct named_init ni = { |
| .number = 34, |
| .name = L"Test wide string", |
| .average = 543.34343, |
| }; |
| |
| ni.number = 58; |
| |
| int dynamic_array[ni.number]; |
| dynamic_array[43] = 543; |
| |
| // work around unused variable warnings |
| return bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'; |
| ]], |
| dnl Try |
| dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) |
| dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99) |
| dnl Intel ICC -c99 |
| dnl IRIX -c99 |
| dnl Solaris (unused because it causes the compiler to assume C99 semantics for |
| dnl library functions, and this is invalid before Solaris 10: -xc99) |
| dnl Tru64 -c99 |
| dnl with extended modes being tried first. |
| [[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl |
| ])# _AC_PROG_CC_C99 |
| |
| # AC_PROG_CC_C99 |
| # -------------- |
| AC_DEFUN([AC_PROG_CC_C99], |
| [ AC_REQUIRE([AC_PROG_CC])dnl |
| _AC_PROG_CC_C99 |
| ]) |
| |
| # AC_USE_SYSTEM_EXTENSIONS |
| # ------------------------ |
| # Enable extensions on systems that normally disable them, |
| # typically due to standards-conformance issues. |
| m4_ifndef([AC_USE_SYSTEM_EXTENSIONS],[ |
| AC_DEFUN([AC_USE_SYSTEM_EXTENSIONS], |
| [ |
| AC_BEFORE([$0], [AC_COMPILE_IFELSE]) |
| AC_BEFORE([$0], [AC_RUN_IFELSE]) |
| |
| AC_REQUIRE([AC_GNU_SOURCE]) |
| AC_REQUIRE([AC_AIX]) |
| AC_REQUIRE([AC_MINIX]) |
| |
| AH_VERBATIM([__EXTENSIONS__], |
| [/* Enable extensions on Solaris. */ |
| #ifndef __EXTENSIONS__ |
| # undef __EXTENSIONS__ |
| #endif |
| #ifndef _POSIX_PTHREAD_SEMANTICS |
| # undef _POSIX_PTHREAD_SEMANTICS |
| #endif]) |
| AC_CACHE_CHECK([whether it is safe to define __EXTENSIONS__], |
| [ac_cv_safe_to_define___extensions__], |
| [AC_COMPILE_IFELSE( |
| [AC_LANG_PROGRAM([ |
| # define __EXTENSIONS__ 1 |
| AC_INCLUDES_DEFAULT])], |
| [ac_cv_safe_to_define___extensions__=yes], |
| [ac_cv_safe_to_define___extensions__=no])]) |
| test $ac_cv_safe_to_define___extensions__ = yes && |
| AC_DEFINE([__EXTENSIONS__]) |
| AC_DEFINE([_POSIX_PTHREAD_SEMANTICS]) |
| ]) |
| ]) |