[people/ms/suricata.git] / acsite.m4

#These defines are needed because CentOS5 uses a old version of autoconf
#
AC_DEFUN([AC_TYPE_INT8_T], [_AC_TYPE_INT(8)])
AC_DEFUN([AC_TYPE_INT16_T], [_AC_TYPE_INT(16)])
AC_DEFUN([AC_TYPE_INT32_T], [_AC_TYPE_INT(32)])
AC_DEFUN([AC_TYPE_INT64_T], [_AC_TYPE_INT(64)])
AC_DEFUN([AC_TYPE_UINT8_T], [_AC_TYPE_UNSIGNED_INT(8)])
AC_DEFUN([AC_TYPE_UINT16_T], [_AC_TYPE_UNSIGNED_INT(16)])
AC_DEFUN([AC_TYPE_UINT32_T], [_AC_TYPE_UNSIGNED_INT(32)])
AC_DEFUN([AC_TYPE_UINT64_T], [_AC_TYPE_UNSIGNED_INT(64)])

# _AC_TYPE_INT(NBITS)
# -------------------
AC_DEFUN([_AC_TYPE_INT],
[
  AC_CACHE_CHECK([for int$1_t], [ac_cv_c_int$1_t],
    [ac_cv_c_int$1_t=no
     for ac_type in 'int$1_t' 'int' 'long int' \
	 'long long int' 'short int' 'signed char'; do
       AC_COMPILE_IFELSE(
	 [AC_LANG_BOOL_COMPILE_TRY(
	    [AC_INCLUDES_DEFAULT],
	    [[0 < ($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 1)]])],
	 [AC_COMPILE_IFELSE(
	    [AC_LANG_BOOL_COMPILE_TRY(
	       [AC_INCLUDES_DEFAULT],
	       [[($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 1)
	         < ($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 2)]])],
	    [],
	    [AS_CASE([$ac_type], [int$1_t],
	       [ac_cv_c_int$1_t=yes],
	       [ac_cv_c_int$1_t=$ac_type])])])
       test "$ac_cv_c_int$1_t" != no && break
     done])
  case $ac_cv_c_int$1_t in #(
  no|yes) ;; #(
  *)
    AC_DEFINE_UNQUOTED([int$1_t], [$ac_cv_c_int$1_t],
      [Define to the type of a signed integer type of width exactly $1 bits
       if such a type exists and the standard includes do not define it.]);;
  esac
])# _AC_TYPE_INT

# _AC_TYPE_UNSIGNED_INT(NBITS)
# ----------------------------
AC_DEFUN([_AC_TYPE_UNSIGNED_INT],
[
  AC_CACHE_CHECK([for uint$1_t], [ac_cv_c_uint$1_t],
    [ac_cv_c_uint$1_t=no
     for ac_type in 'uint$1_t' 'unsigned int' 'unsigned long int' \
	 'unsigned long long int' 'unsigned short int' 'unsigned char'; do
       AC_COMPILE_IFELSE(
	 [AC_LANG_BOOL_COMPILE_TRY(
	    [AC_INCLUDES_DEFAULT],
	    [[($ac_type) -1 >> ($1 - 1) == 1]])],
	 [AS_CASE([$ac_type], [uint$1_t],
	    [ac_cv_c_uint$1_t=yes],
	    [ac_cv_c_uint$1_t=$ac_type])])
       test "$ac_cv_c_uint$1_t" != no && break
     done])
  case $ac_cv_c_uint$1_t in #(
  no|yes) ;; #(
  *)
    m4_bmatch([$1], [^\(8\|32\|64\)$],
      [AC_DEFINE([_UINT$1_T], 1,
	 [Define for Solaris 2.5.1 so the uint$1_t typedef from
	  <sys/synch.h>, <pthread.h>, or <semaphore.h> is not used.
	  If the typedef was allowed, the #define below would cause a
	  syntax error.])])
    AC_DEFINE_UNQUOTED([uint$1_t], [$ac_cv_c_uint$1_t],
      [Define to the type of an unsigned integer type of width exactly $1 bits
       if such a type exists and the standard includes do not define it.]);;
  esac
])# _AC_TYPE_UNSIGNED_INT

# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT])
# ----------------------------------------------------
# Expand into
# | case WORD in
# | PATTERN1) IF-MATCHED1 ;;
# | ...
# | *) DEFAULT ;;
# | esac
m4_define([_AS_CASE],
[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
       [$#], 1, [  *) $1 ;;],
       [$#], 2, [  $1) m4_default([$2], [:]) ;;],
       [  $1) m4_default([$2], [:]) ;;
$0(m4_shiftn(2, $@))])dnl
])
m4_defun([AS_CASE],
[m4_ifval([$2$3],
[case $1 in
_AS_CASE(m4_shift($@))
esac
])dnl
])# AS_CASE

# _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 _Bool,
# // comments, flexible array members, inline, long long int, mixed
# code and declarations, named initialization of structs, restrict,
# va_copy, varargs macros, variable declarations in for loops and
# variable length arrays.
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>

// Check varargs macros.  These examples are taken from C99 6.10.3.5.
#define debug(...) fprintf (stderr, __VA_ARGS__)
#define showlist(...) puts (#__VA_ARGS__)
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
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.
#define BIG64 18446744073709551615ull
#define BIG32 4294967295ul
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
#if !BIG_OK
  your preprocessor is broken;
#endif
#if BIG_OK
#else
  your preprocessor is broken;
#endif
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 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 = va_arg (args_copy, double);
          break;
        default:
          break;
        }
    }
  va_end (args_copy);
  va_end (args);
}
]],
[[
  // Check bool.
  _Bool success = false;

  // 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);
  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);
]],
dnl Try
dnl GCC         -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
dnl AIX         -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
dnl HP cc       -AC99
dnl Intel ICC   -std=c99, -c99 (deprecated)
dnl IRIX        -c99
dnl Solaris     -xc99=all (Forte Developer 7 C mishandles -xc99 on Solaris 9,
dnl             as it incorrectly assumes C99 semantics for library functions)
dnl Tru64       -c99
dnl with extended modes being tried first.
[[-std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99]], [$1], [$2])[]dnl
])# _AC_PROG_CC_C99


# AC_PROG_CC_C89
# --------------
AC_DEFUN([AC_PROG_CC_C89],
[ AC_REQUIRE([AC_PROG_CC])dnl
  _AC_PROG_CC_C89
])

# AC_PROG_CC_C99
# --------------
AC_DEFUN([AC_PROG_CC_C99],
[ AC_REQUIRE([AC_PROG_CC])dnl
  _AC_PROG_CC_C99
])


# AC_PROG_CC_STDC
# ---------------
AC_DEFUN([AC_PROG_CC_STDC],
[ AC_REQUIRE([AC_PROG_CC])dnl
  AS_CASE([$ac_cv_prog_cc_stdc],
    [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
          [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
             [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
                              [ac_cv_prog_cc_stdc=no])])])dnl
  AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
  AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
  AS_CASE([$ac_cv_prog_cc_stdc],
    [no], [AC_MSG_RESULT([unsupported])],
    [''], [AC_MSG_RESULT([none needed])],
          [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
])

# _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
Commit	Line	Data
58396a9a WM	1	#These defines are needed because CentOS5 uses a old version of autoconf
	2	#
	3	AC_DEFUN([AC_TYPE_INT8_T], [_AC_TYPE_INT(8)])
	4	AC_DEFUN([AC_TYPE_INT16_T], [_AC_TYPE_INT(16)])
	5	AC_DEFUN([AC_TYPE_INT32_T], [_AC_TYPE_INT(32)])
	6	AC_DEFUN([AC_TYPE_INT64_T], [_AC_TYPE_INT(64)])
	7	AC_DEFUN([AC_TYPE_UINT8_T], [_AC_TYPE_UNSIGNED_INT(8)])
	8	AC_DEFUN([AC_TYPE_UINT16_T], [_AC_TYPE_UNSIGNED_INT(16)])
	9	AC_DEFUN([AC_TYPE_UINT32_T], [_AC_TYPE_UNSIGNED_INT(32)])
	10	AC_DEFUN([AC_TYPE_UINT64_T], [_AC_TYPE_UNSIGNED_INT(64)])
	11
	12	# _AC_TYPE_INT(NBITS)
	13	# -------------------
	14	AC_DEFUN([_AC_TYPE_INT],
	15	[
	16	AC_CACHE_CHECK([for int$1_t], [ac_cv_c_int$1_t],
	17	[ac_cv_c_int$1_t=no
	18	for ac_type in 'int$1_t' 'int' 'long int' \
	19	'long long int' 'short int' 'signed char'; do
	20	AC_COMPILE_IFELSE(
	21	[AC_LANG_BOOL_COMPILE_TRY(
	22	[AC_INCLUDES_DEFAULT],
	23	[[0 < ($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 1)]])],
	24	[AC_COMPILE_IFELSE(
	25	[AC_LANG_BOOL_COMPILE_TRY(
	26	[AC_INCLUDES_DEFAULT],
	27	[[($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 1)
	28	< ($ac_type) (((($ac_type) 1 << ($1 - 2)) - 1) * 2 + 2)]])],
	29	[],
	30	[AS_CASE([$ac_type], [int$1_t],
	31	[ac_cv_c_int$1_t=yes],
	32	[ac_cv_c_int$1_t=$ac_type])])])
	33	test "$ac_cv_c_int$1_t" != no && break
	34	done])
	35	case $ac_cv_c_int$1_t in #(
	36	no\|yes) ;; #(
	37	*)
	38	AC_DEFINE_UNQUOTED([int$1_t], [$ac_cv_c_int$1_t],
	39	[Define to the type of a signed integer type of width exactly $1 bits
	40	if such a type exists and the standard includes do not define it.]);;
	41	esac
	42	])# _AC_TYPE_INT
	43
	44	# _AC_TYPE_UNSIGNED_INT(NBITS)
	45	# ----------------------------
	46	AC_DEFUN([_AC_TYPE_UNSIGNED_INT],
	47	[
	48	AC_CACHE_CHECK([for uint$1_t], [ac_cv_c_uint$1_t],
	49	[ac_cv_c_uint$1_t=no
	50	for ac_type in 'uint$1_t' 'unsigned int' 'unsigned long int' \
	51	'unsigned long long int' 'unsigned short int' 'unsigned char'; do
	52	AC_COMPILE_IFELSE(
	53	[AC_LANG_BOOL_COMPILE_TRY(
	54	[AC_INCLUDES_DEFAULT],
	55	[[($ac_type) -1 >> ($1 - 1) == 1]])],
	56	[AS_CASE([$ac_type], [uint$1_t],
	57	[ac_cv_c_uint$1_t=yes],
	58	[ac_cv_c_uint$1_t=$ac_type])])
	59	test "$ac_cv_c_uint$1_t" != no && break
	60	done])
	61	case $ac_cv_c_uint$1_t in #(
	62	no\|yes) ;; #(
	63	*)
	64	m4_bmatch([$1], [^\(8\\|32\\|64\)$],
65	[AC_DEFINE([_UINT$1_T], 1,
66	[Define for Solaris 2.5.1 so the uint$1_t typedef from
67	<sys/synch.h>, <pthread.h>, or <semaphore.h> is not used.
68	If the typedef was allowed, the #define below would cause a
69	syntax error.])])
70	AC_DEFINE_UNQUOTED([uint$1_t], [$ac_cv_c_uint$1_t],
71	[Define to the type of an unsigned integer type of width exactly $1 bits
72	if such a type exists and the standard includes do not define it.]);;
73	esac
74	])# _AC_TYPE_UNSIGNED_INT
75
76	# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT])
77	# ----------------------------------------------------
78	# Expand into
79	# \| case WORD in
80	# \| PATTERN1) IF-MATCHED1 ;;
81	# \| ...
82	# \| *) DEFAULT ;;
83	# \| esac
84	m4_define([_AS_CASE],
85	[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
86	[$#], 1, [ *) $1 ;;],
87	[$#], 2, [ $1) m4_default([$2], [:]) ;;],
88	[ $1) m4_default([$2], [:]) ;;
89	$0(m4_shiftn(2, $@))])dnl
90	])
91	m4_defun([AS_CASE],
92	[m4_ifval([$2$3],
93	[case $1 in
94	_AS_CASE(m4_shift($@))
95	esac
96	])dnl
97	])# AS_CASE
3e4d503e WM	98
	99	# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
	100	# ----------------------------------------------------------------
	101	# If the C compiler is not in ISO C99 mode by default, try to add an
	102	# option to output variable CC to make it so. This macro tries
	103	# various options that select ISO C99 on some system or another. It
	104	# considers the compiler to be in ISO C99 mode if it handles _Bool,
	105	# // comments, flexible array members, inline, long long int, mixed
	106	# code and declarations, named initialization of structs, restrict,
	107	# va_copy, varargs macros, variable declarations in for loops and
	108	# variable length arrays.
	109	AC_DEFUN([_AC_PROG_CC_C99],
	110	[_AC_C_STD_TRY([c99],
	111	[[#include <stdarg.h>
	112	#include <stdbool.h>
	113	#include <stdlib.h>
	114	#include <wchar.h>
	115	#include <stdio.h>
	116
	117	// Check varargs macros. These examples are taken from C99 6.10.3.5.
	118	#define debug(...) fprintf (stderr, __VA_ARGS__)
	119	#define showlist(...) puts (#__VA_ARGS__)
	120	#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
	121	static void
	122	test_varargs_macros (void)
	123	{
	124	int x = 1234;
	125	int y = 5678;
	126	debug ("Flag");
	127	debug ("X = %d\n", x);
	128	showlist (The first, second, and third items.);
	129	report (x>y, "x is %d but y is %d", x, y);
	130	}
	131
	132	// Check long long types.
	133	#define BIG64 18446744073709551615ull
	134	#define BIG32 4294967295ul
	135	#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
	136	#if !BIG_OK
	137	your preprocessor is broken;
	138	#endif
	139	#if BIG_OK
	140	#else
	141	your preprocessor is broken;
	142	#endif
	143	static long long int bignum = -9223372036854775807LL;
	144	static unsigned long long int ubignum = BIG64;
	145
	146	struct incomplete_array
	147	{
	148	int datasize;
	149	double data[];
	150	};
	151
	152	struct named_init {
	153	int number;
	154	const wchar_t *name;
	155	double average;
	156	};
	157
	158	typedef const char *ccp;
	159
	160	static inline int
	161	test_restrict (ccp restrict text)
162	{
163	// See if C++-style comments work.
164	// Iterate through items via the restricted pointer.
165	// Also check for declarations in for loops.
166	for (unsigned int i = 0; *(text+i) != '\0'; ++i)
167	continue;
168	return 0;
169	}
170
171	// Check varargs and va_copy.
172	static void
173	test_varargs (const char *format, ...)
174	{
175	va_list args;
176	va_start (args, format);
177	va_list args_copy;
178	va_copy (args_copy, args);
179
180	const char *str;
181	int number;
182	float fnumber;
183
184	while (*format)
185	{
186	switch (*format++)
187	{
188	case 's': // string
189	str = va_arg (args_copy, const char *);
190	break;
191	case 'd': // int
192	number = va_arg (args_copy, int);
193	break;
194	case 'f': // float
195	fnumber = va_arg (args_copy, double);
196	break;
197	default:
198	break;
199	}
200	}
201	va_end (args_copy);
202	va_end (args);
203	}
204	]],
205	[[
206	// Check bool.
207	_Bool success = false;
208
209	// Check restrict.
210	if (test_restrict ("String literal") == 0)
211	success = true;
212	char *restrict newvar = "Another string";
213
214	// Check varargs.
215	test_varargs ("s, d' f .", "string", 65, 34.234);
216	test_varargs_macros ();
217
218	// Check flexible array members.
219	struct incomplete_array *ia =
220	malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
221	ia->datasize = 10;
222	for (int i = 0; i < ia->datasize; ++i)
223	ia->data[i] = i * 1.234;
224
225	// Check named initializers.
226	struct named_init ni = {
227	.number = 34,
228	.name = L"Test wide string",
229	.average = 543.34343,
230	};
231
232	ni.number = 58;
233
234	int dynamic_array[ni.number];
235	dynamic_array[ni.number - 1] = 543;
236
237	// work around unused variable warnings
238	return (!success \|\| bignum == 0LL \|\| ubignum == 0uLL \|\| newvar[0] == 'x'
239	\|\| dynamic_array[ni.number - 1] != 543);
240	]],
241	dnl Try
242	dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
243	dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
244	dnl HP cc -AC99
245	dnl Intel ICC -std=c99, -c99 (deprecated)
246	dnl IRIX -c99
247	dnl Solaris -xc99=all (Forte Developer 7 C mishandles -xc99 on Solaris 9,
248	dnl as it incorrectly assumes C99 semantics for library functions)
249	dnl Tru64 -c99
250	dnl with extended modes being tried first.
251	[[-std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99]], [$1], [$2])[]dnl
252	])# _AC_PROG_CC_C99
253
254
255	# AC_PROG_CC_C89
256	# --------------
257	AC_DEFUN([AC_PROG_CC_C89],
258	[ AC_REQUIRE([AC_PROG_CC])dnl
259	_AC_PROG_CC_C89
260	])
261
262	# AC_PROG_CC_C99
263	# --------------
264	AC_DEFUN([AC_PROG_CC_C99],
265	[ AC_REQUIRE([AC_PROG_CC])dnl
266	_AC_PROG_CC_C99
267	])
268
269
270	# AC_PROG_CC_STDC
271	# ---------------
272	AC_DEFUN([AC_PROG_CC_STDC],
273	[ AC_REQUIRE([AC_PROG_CC])dnl
274	AS_CASE([$ac_cv_prog_cc_stdc],
275	[no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
276	[_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
277	[_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
278	[ac_cv_prog_cc_stdc=no])])])dnl
279	AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
280	AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
281	AS_CASE([$ac_cv_prog_cc_stdc],
282	[no], [AC_MSG_RESULT([unsupported])],
283	[''], [AC_MSG_RESULT([none needed])],
284	[AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
285	])
286
287	# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
288	# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
289	# --------------------------------------------------------------
290	# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
291	# by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails,
292	# try again with each compiler option in the space-separated OPTION-LIST; if one
293	# helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE,
294	# else ACTION-IF-UNAVAILABLE.
295	AC_DEFUN([_AC_C_STD_TRY],
296	[AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
297	AC_CACHE_VAL(ac_cv_prog_cc_$1,
298	[ac_cv_prog_cc_$1=no
299	ac_save_CC=$CC
300	AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
301	for ac_arg in '' $4
302	do
303	CC="$ac_save_CC $ac_arg"
304	_AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
305	test "x$ac_cv_prog_cc_$1" != "xno" && break
306	done
307	rm -f conftest.$ac_ext
308	CC=$ac_save_CC
309	])# AC_CACHE_VAL
310	case "x$ac_cv_prog_cc_$1" in
311	x)
312	AC_MSG_RESULT([none needed]) ;;
313	xno)
314	AC_MSG_RESULT([unsupported]) ;;
315	*)
316	CC="$CC $ac_cv_prog_cc_$1"
317	AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
318	esac
319	AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
320	])# _AC_C_STD_TRY
321
322