]> git.saurik.com Git - wxWidgets.git/blob - build/autoconf_prepend-include/autoconf/c.m4
add XRC handler for wxSearchCtrl (extended patch 1751516)
[wxWidgets.git] / build / autoconf_prepend-include / autoconf / c.m4
1 # This file is part of Autoconf. -*- Autoconf -*-
2 # Programming languages support.
3 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4 # Foundation, Inc.
5 #
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2, or (at your option)
9 # any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 # 02110-1301, USA.
20 #
21 # As a special exception, the Free Software Foundation gives unlimited
22 # permission to copy, distribute and modify the configure scripts that
23 # are the output of Autoconf. You need not follow the terms of the GNU
24 # General Public License when using or distributing such scripts, even
25 # though portions of the text of Autoconf appear in them. The GNU
26 # General Public License (GPL) does govern all other use of the material
27 # that constitutes the Autoconf program.
28 #
29 # Certain portions of the Autoconf source text are designed to be copied
30 # (in certain cases, depending on the input) into the output of
31 # Autoconf. We call these the "data" portions. The rest of the Autoconf
32 # source text consists of comments plus executable code that decides which
33 # of the data portions to output in any given case. We call these
34 # comments and executable code the "non-data" portions. Autoconf never
35 # copies any of the non-data portions into its output.
36 #
37 # This special exception to the GPL applies to versions of Autoconf
38 # released by the Free Software Foundation. When you make and
39 # distribute a modified version of Autoconf, you may extend this special
40 # exception to the GPL to apply to your modified version as well, *unless*
41 # your modified version has the potential to copy into its output some
42 # of the text that was the non-data portion of the version that you started
43 # with. (In other words, unless your change moves or copies text from
44 # the non-data portions to the data portions.) If your modification has
45 # such potential, you must delete any notice of this special exception
46 # to the GPL from your modified version.
47 #
48 # Written by David MacKenzie, with help from
49 # Akim Demaille, Paul Eggert,
50 # Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
51 # Roland McGrath, Noah Friedman, david d zuhn, and many others.
52
53
54 # -------------------- #
55 # 1b. The C language. #
56 # -------------------- #
57
58
59 # AC_LANG(C)
60 # ----------
61 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
62 m4_define([AC_LANG(C)],
63 [ac_ext=c
64 ac_cpp='$CPP $CPPFLAGS'
65 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
66 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
67 ac_compiler_gnu=$ac_cv_c_compiler_gnu
68 ])
69
70
71 # AC_LANG_C
72 # ---------
73 AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
74
75
76 # _AC_LANG_ABBREV(C)
77 # ------------------
78 m4_define([_AC_LANG_ABBREV(C)], [c])
79
80
81 # _AC_LANG_PREFIX(C)
82 # ------------------
83 m4_define([_AC_LANG_PREFIX(C)], [C])
84
85
86 # ---------------------- #
87 # 1c. The C++ language. #
88 # ---------------------- #
89
90
91 # AC_LANG(C++)
92 # ------------
93 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
94 m4_define([AC_LANG(C++)],
95 [ac_ext=cpp
96 ac_cpp='$CXXCPP $CPPFLAGS'
97 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
98 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
99 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
100 ])
101
102
103 # AC_LANG_CPLUSPLUS
104 # -----------------
105 AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
106
107
108 # _AC_LANG_ABBREV(C++)
109 # --------------------
110 m4_define([_AC_LANG_ABBREV(C++)], [cxx])
111
112
113 # _AC_LANG_PREFIX(C++)
114 # --------------------
115 m4_define([_AC_LANG_PREFIX(C++)], [CXX])
116
117
118
119 # ------------------------------ #
120 # 1d. The Objective C language. #
121 # ------------------------------ #
122
123
124 # AC_LANG(Objective C)
125 # --------------------
126 m4_define([AC_LANG(Objective C)],
127 [ac_ext=m
128 ac_cpp='$OBJCPP $CPPFLAGS'
129 ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
130 ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
131 ac_compiler_gnu=$ac_cv_objc_compiler_gnu
132 ])
133
134
135 # AC_LANG_OBJC
136 # ------------
137 AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)])
138
139
140 # _AC_LANG_ABBREV(Objective C)
141 # ----------------------------
142 m4_define([_AC_LANG_ABBREV(Objective C)], [objc])
143
144
145 # _AC_LANG_PREFIX(Objective C)
146 # ----------------------------
147 m4_define([_AC_LANG_PREFIX(Objective C)], [OBJC])
148
149
150
151 ## ---------------------- ##
152 ## 2.Producing programs. ##
153 ## ---------------------- ##
154
155
156 # --------------- #
157 # 2b. C sources. #
158 # --------------- #
159
160 # AC_LANG_SOURCE(C)(BODY)
161 # -----------------------
162 # We can't use '#line $LINENO "configure"' here, since
163 # Sun c89 (Sun WorkShop 6 update 2 C 5.3 Patch 111679-08 2002/05/09)
164 # rejects $LINENO greater than 32767, and some configure scripts
165 # are longer than 32767 lines.
166 m4_define([AC_LANG_SOURCE(C)],
167 [/* confdefs.h. */
168 _ACEOF
169 cat confdefs.h >>conftest.$ac_ext
170 cat >>conftest.$ac_ext <<_ACEOF
171 /* end confdefs.h. */
172 $1])
173
174
175 # AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
176 # --------------------------------------
177 m4_define([AC_LANG_PROGRAM(C)],
178 [$1
179 m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS])[]dnl
180 m4_ifdef([_AC_LANG_PROGRAM_C_FC_HOOKS], [_AC_LANG_PROGRAM_C_FC_HOOKS])[]dnl
181 int
182 main ()
183 {
184 dnl Do *not* indent the following line: there may be CPP directives.
185 dnl Don't move the `;' right after for the same reason.
186 $2
187 ;
188 return 0;
189 }])
190
191
192 # AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
193 # -----------------------------------
194 # Avoid conflicting decl of main.
195 m4_define([AC_LANG_CALL(C)],
196 [AC_LANG_PROGRAM([$1
197 m4_if([$2], [main], ,
198 [/* Override any GCC internal prototype to avoid an error.
199 Use char because int might match the return type of a GCC
200 builtin and then its argument prototype would still apply. */
201 #ifdef __cplusplus
202 extern "C"
203 #endif
204 char $2 ();])], [return $2 ();])])
205
206
207 # AC_LANG_FUNC_LINK_TRY(C)(FUNCTION)
208 # ----------------------------------
209 # Don't include <ctype.h> because on OSF/1 3.0 it includes
210 # <sys/types.h> which includes <sys/select.h> which contains a
211 # prototype for select. Similarly for bzero.
212 #
213 # This test used to merely assign f=$1 in main(), but that was
214 # optimized away by HP unbundled cc A.05.36 for ia64 under +O3,
215 # presumably on the basis that there's no need to do that store if the
216 # program is about to exit. Conversely, the AIX linker optimizes an
217 # unused external declaration that initializes f=$1. So this test
218 # program has both an external initialization of f, and a use of f in
219 # main that affects the exit status.
220 #
221 m4_define([AC_LANG_FUNC_LINK_TRY(C)],
222 [AC_LANG_PROGRAM(
223 [/* Define $1 to an innocuous variant, in case <limits.h> declares $1.
224 For example, HP-UX 11i <limits.h> declares gettimeofday. */
225 #define $1 innocuous_$1
226
227 /* System header to define __stub macros and hopefully few prototypes,
228 which can conflict with char $1 (); below.
229 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
230 <limits.h> exists even on freestanding compilers. */
231
232 #ifdef __STDC__
233 # include <limits.h>
234 #else
235 # include <assert.h>
236 #endif
237
238 #undef $1
239
240 /* Override any GCC internal prototype to avoid an error.
241 Use char because int might match the return type of a GCC
242 builtin and then its argument prototype would still apply. */
243 #ifdef __cplusplus
244 extern "C"
245 #endif
246 char $1 ();
247 /* The GNU C library defines this for functions which it implements
248 to always fail with ENOSYS. Some functions are actually named
249 something starting with __ and the normal name is an alias. */
250 #if defined __stub_$1 || defined __stub___$1
251 choke me
252 #endif
253 ], [return $1 ();])])
254
255
256 # AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION)
257 # -------------------------------------------------
258 # Return a program that is valid if EXPRESSION is nonzero.
259 # EXPRESSION must be an integer constant expression.
260 # Be sure to use this array to avoid `unused' warnings, which are even
261 # errors with `-W error'.
262 m4_define([AC_LANG_BOOL_COMPILE_TRY(C)],
263 [AC_LANG_PROGRAM([$1], [static int test_array @<:@1 - 2 * !($2)@:>@;
264 test_array @<:@0@:>@ = 0
265 ])])
266
267
268 # AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION)
269 # -----------------------------------------
270 # We need `stdio.h' to open a `FILE' and `stdlib.h' for `exit'.
271 # But we include them only after the EXPRESSION has been evaluated.
272 m4_define([AC_LANG_INT_SAVE(C)],
273 [AC_LANG_PROGRAM([$1
274 static long int longval () { return $2; }
275 static unsigned long int ulongval () { return $2; }
276 @%:@include <stdio.h>
277 @%:@include <stdlib.h>],
278 [
279 FILE *f = fopen ("conftest.val", "w");
280 if (! f)
281 return 1;
282 if (($2) < 0)
283 {
284 long int i = longval ();
285 if (i != ($2))
286 return 1;
287 fprintf (f, "%ld\n", i);
288 }
289 else
290 {
291 unsigned long int i = ulongval ();
292 if (i != ($2))
293 return 1;
294 fprintf (f, "%lu\n", i);
295 }
296 return ferror (f) || fclose (f) != 0;
297 ])])
298
299
300 # ----------------- #
301 # 2c. C++ sources. #
302 # ----------------- #
303
304 # AC_LANG_SOURCE(C++)(BODY)
305 # -------------------------
306 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
307
308
309 # AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
310 # ----------------------------------------
311 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
312
313
314 # AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
315 # -------------------------------------
316 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
317
318
319 # AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
320 # ------------------------------------
321 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
322
323
324 # AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
325 # ---------------------------------------------------
326 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)])
327
328
329 # AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
330 # -------------------------------------------
331 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
332
333
334
335 # ------------------------- #
336 # 2d. Objective C sources. #
337 # ------------------------- #
338
339 # AC_LANG_SOURCE(Objective C)(BODY)
340 # ---------------------------------
341 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)])
342
343
344 # AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY])
345 # ------------------------------------------------
346 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)])
347
348
349 # AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION)
350 # ---------------------------------------------
351 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)])
352
353
354 # AC_LANG_FUNC_LINK_TRY(Objective C)(FUNCTION)
355 # --------------------------------------------
356 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(Objective C)])
357
358
359 # AC_LANG_BOOL_COMPILE_TRY(Objective C)(PROLOGUE, EXPRESSION)
360 # -----------------------------------------------------------
361 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(Objective C)])
362
363
364 # AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION)
365 # ---------------------------------------------------
366 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)])
367
368
369
370 ## -------------------------------------------- ##
371 ## 3. Looking for Compilers and Preprocessors. ##
372 ## -------------------------------------------- ##
373
374 # -------------------- #
375 # 3b. The C compiler. #
376 # -------------------- #
377
378
379 # _AC_ARG_VAR_CPPFLAGS
380 # --------------------
381 # Document and register CPPFLAGS, which is used by
382 # AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP}.
383 AC_DEFUN([_AC_ARG_VAR_CPPFLAGS],
384 [AC_ARG_VAR([CPPFLAGS],
385 [C/C++/Objective C preprocessor flags, e.g. -I<include dir>
386 if you have headers in a nonstandard directory <include dir>])])
387
388
389 # _AC_ARG_VAR_LDFLAGS
390 # -------------------
391 # Document and register LDFLAGS, which is used by
392 # AC_PROG_{CC, CXX, F77, FC, OBJC}.
393 AC_DEFUN([_AC_ARG_VAR_LDFLAGS],
394 [AC_ARG_VAR([LDFLAGS],
395 [linker flags, e.g. -L<lib dir> if you have libraries in a
396 nonstandard directory <lib dir>])])
397
398
399 # _AC_ARG_VAR_LIBS
400 # ----------------
401 # Document and register LIBS, which is used by
402 # AC_PROG_{CC, CXX, F77, FC, OBJS}.
403 AC_DEFUN([_AC_ARG_VAR_LIBS],
404 [AC_ARG_VAR([LIBS],
405 [libraries to pass to the linker, e.g. -l<library>])])
406
407
408 # AC_LANG_PREPROC(C)
409 # -------------------
410 # Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
411 AC_DEFUN([AC_LANG_PREPROC(C)],
412 [AC_REQUIRE([AC_PROG_CPP])])
413
414
415 # _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT)
416 # -----------------------------------------------
417 # Check if $ac_cpp is a working preprocessor that can flag absent
418 # includes either by the exit status or by warnings.
419 # This macro is for all languages, not only C.
420 AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE],
421 [ac_preproc_ok=false
422 for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes
423 do
424 # Use a header file that comes with gcc, so configuring glibc
425 # with a fresh cross-compiler works.
426 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
427 # <limits.h> exists even on freestanding compilers.
428 # On the NeXT, cc -E runs the code through the compiler's parser,
429 # not just through cpp. "Syntax error" is here to catch this case.
430 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__
431 @%:@ include <limits.h>
432 @%:@else
433 @%:@ include <assert.h>
434 @%:@endif
435 Syntax error]])],
436 [],
437 [# Broken: fails on valid input.
438 continue])
439
440 # OK, works on sane cases. Now check whether nonexistent headers
441 # can be detected and how.
442 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])],
443 [# Broken: success on invalid input.
444 continue],
445 [# Passes both tests.
446 ac_preproc_ok=:
447 break])
448
449 done
450 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
451 rm -f conftest.err conftest.$ac_ext
452 AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE
453
454
455 # AC_PROG_CPP
456 # -----------
457 # Find a working C preprocessor.
458 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
459 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC.
460 AN_MAKEVAR([CPP], [AC_PROG_CPP])
461 AN_PROGRAM([cpp], [AC_PROG_CPP])
462 AC_DEFUN([AC_PROG_CPP],
463 [AC_REQUIRE([AC_PROG_CC])dnl
464 AC_ARG_VAR([CPP], [C preprocessor])dnl
465 _AC_ARG_VAR_CPPFLAGS()dnl
466 AC_LANG_PUSH(C)dnl
467 AC_MSG_CHECKING([how to run the C preprocessor])
468 # On Suns, sometimes $CPP names a directory.
469 if test -n "$CPP" && test -d "$CPP"; then
470 CPP=
471 fi
472 if test -z "$CPP"; then
473 AC_CACHE_VAL([ac_cv_prog_CPP],
474 [dnl
475 # Double quotes because CPP needs to be expanded
476 for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
477 do
478 _AC_PROG_PREPROC_WORKS_IFELSE([break])
479 done
480 ac_cv_prog_CPP=$CPP
481 ])dnl
482 CPP=$ac_cv_prog_CPP
483 else
484 ac_cv_prog_CPP=$CPP
485 fi
486 AC_MSG_RESULT([$CPP])
487 _AC_PROG_PREPROC_WORKS_IFELSE([],
488 [AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])])
489 AC_SUBST(CPP)dnl
490 AC_LANG_POP(C)dnl
491 ])# AC_PROG_CPP
492
493 # AC_PROG_CPP_WERROR
494 # ------------------
495 # Treat warnings from the preprocessor as errors.
496 AC_DEFUN([AC_PROG_CPP_WERROR],
497 [AC_REQUIRE([AC_PROG_CPP])dnl
498 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
499
500 # AC_LANG_COMPILER(C)
501 # -------------------
502 # Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
503 AC_DEFUN([AC_LANG_COMPILER(C)],
504 [AC_REQUIRE([AC_PROG_CC])])
505
506
507 # ac_cv_prog_gcc
508 # --------------
509 # We used to name the cache variable this way.
510 AU_DEFUN([ac_cv_prog_gcc],
511 [ac_cv_c_compiler_gnu])
512
513
514 # AC_PROG_CC([COMPILER ...])
515 # --------------------------
516 # COMPILER ... is a space separated list of C compilers to search for.
517 # This just gives the user an opportunity to specify an alternative
518 # search list for the C compiler.
519 AN_MAKEVAR([CC], [AC_PROG_CC])
520 AN_PROGRAM([cc], [AC_PROG_CC])
521 AN_PROGRAM([gcc], [AC_PROG_CC])
522 AC_DEFUN([AC_PROG_CC],
523 [AC_LANG_PUSH(C)dnl
524 AC_ARG_VAR([CC], [C compiler command])dnl
525 AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
526 _AC_ARG_VAR_LDFLAGS()dnl
527 _AC_ARG_VAR_LIBS()dnl
528 _AC_ARG_VAR_CPPFLAGS()dnl
529 m4_ifval([$1],
530 [AC_CHECK_TOOLS(CC, [$1])],
531 [AC_CHECK_TOOL(CC, gcc)
532 if test -z "$CC"; then
533 dnl Here we want:
534 dnl AC_CHECK_TOOL(CC, cc)
535 dnl but without the check for a tool without the prefix.
536 dnl Until the check is removed from there, copy the code:
537 if test -n "$ac_tool_prefix"; then
538 AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
539 fi
540 fi
541 if test -z "$CC"; then
542 AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
543 fi
544 if test -z "$CC"; then
545 AC_CHECK_TOOLS(CC, cl.exe)
546 fi
547 ])
548
549 test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
550
551 # Provide some information about the compiler.
552 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
553 ac_compiler=`set X $ac_compile; echo $[2]`
554 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
555 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
556 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
557
558 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
559 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
560 _AC_LANG_COMPILER_GNU
561 GCC=`test $ac_compiler_gnu = yes && echo yes`
562 _AC_PROG_CC_G
563 _AC_PROG_CC_C89
564 AC_LANG_POP(C)dnl
565 ])# AC_PROG_CC
566
567
568 # _AC_PROG_CC_G
569 # -------------
570 # Check whether -g works, even if CFLAGS is set, in case the package
571 # plays around with CFLAGS (such as to build both debugging and normal
572 # versions of a library), tasteless as that idea is.
573 # Don't consider -g to work if it generates warnings when plain compiles don't.
574 m4_define([_AC_PROG_CC_G],
575 [ac_test_CFLAGS=${CFLAGS+set}
576 ac_save_CFLAGS=$CFLAGS
577 AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g,
578 [ac_save_c_werror_flag=$ac_c_werror_flag
579 ac_c_werror_flag=yes
580 ac_cv_prog_cc_g=no
581 CFLAGS="-g"
582 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
583 [ac_cv_prog_cc_g=yes],
584 [CFLAGS=""
585 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
586 [],
587 [ac_c_werror_flag=$ac_save_c_werror_flag
588 CFLAGS="-g"
589 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
590 [ac_cv_prog_cc_g=yes])])])
591 ac_c_werror_flag=$ac_save_c_werror_flag])
592 if test "$ac_test_CFLAGS" = set; then
593 CFLAGS=$ac_save_CFLAGS
594 elif test $ac_cv_prog_cc_g = yes; then
595 if test "$GCC" = yes; then
596 CFLAGS="-g -O2"
597 else
598 CFLAGS="-g"
599 fi
600 else
601 if test "$GCC" = yes; then
602 CFLAGS="-O2"
603 else
604 CFLAGS=
605 fi
606 fi[]dnl
607 ])# _AC_PROG_CC_G
608
609
610 # AC_PROG_GCC_TRADITIONAL
611 # -----------------------
612 AN_FUNCTION([ioctl], [AC_PROG_GCC_TRADITIONAL])
613 AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
614 [AC_REQUIRE([AC_PROG_CC])dnl
615 if test $ac_cv_c_compiler_gnu = yes; then
616 AC_CACHE_CHECK(whether $CC needs -traditional,
617 ac_cv_prog_gcc_traditional,
618 [ ac_pattern="Autoconf.*'x'"
619 AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
620 Autoconf TIOCGETP],
621 ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
622
623 if test $ac_cv_prog_gcc_traditional = no; then
624 AC_EGREP_CPP($ac_pattern, [#include <termio.h>
625 Autoconf TCGETA],
626 ac_cv_prog_gcc_traditional=yes)
627 fi])
628 if test $ac_cv_prog_gcc_traditional = yes; then
629 CC="$CC -traditional"
630 fi
631 fi
632 ])# AC_PROG_GCC_TRADITIONAL
633
634
635 # AC_PROG_CC_C_O
636 # --------------
637 AC_DEFUN([AC_PROG_CC_C_O],
638 [AC_REQUIRE([AC_PROG_CC])dnl
639 if test "x$CC" != xcc; then
640 AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
641 else
642 AC_MSG_CHECKING([whether cc understands -c and -o together])
643 fi
644 set dummy $CC; ac_cc=`echo $[2] |
645 sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
646 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
647 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
648 # Make sure it works both with $CC and with simple cc.
649 # We do the test twice because some compilers refuse to overwrite an
650 # existing .o file with -o, though they will create one.
651 ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
652 rm -f conftest2.*
653 if _AC_DO_VAR(ac_try) &&
654 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
655 then
656 eval ac_cv_prog_cc_${ac_cc}_c_o=yes
657 if test "x$CC" != xcc; then
658 # Test first that cc exists at all.
659 if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
660 ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
661 rm -f conftest2.*
662 if _AC_DO_VAR(ac_try) &&
663 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
664 then
665 # cc works too.
666 :
667 else
668 # cc exists but doesn't like -o.
669 eval ac_cv_prog_cc_${ac_cc}_c_o=no
670 fi
671 fi
672 fi
673 else
674 eval ac_cv_prog_cc_${ac_cc}_c_o=no
675 fi
676 rm -f core conftest*
677 ])dnl
678 if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
679 AC_MSG_RESULT([yes])
680 else
681 AC_MSG_RESULT([no])
682 AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
683 [Define to 1 if your C compiler doesn't accept -c and -o together.])
684 fi
685 ])# AC_PROG_CC_C_O
686
687
688 # ---------------------- #
689 # 3c. The C++ compiler. #
690 # ---------------------- #
691
692
693 # AC_LANG_PREPROC(C++)
694 # ---------------------
695 # Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
696 AC_DEFUN([AC_LANG_PREPROC(C++)],
697 [AC_REQUIRE([AC_PROG_CXXCPP])])
698
699
700 # AC_PROG_CXXCPP
701 # --------------
702 # Find a working C++ preprocessor.
703 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
704 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
705 AC_DEFUN([AC_PROG_CXXCPP],
706 [AC_REQUIRE([AC_PROG_CXX])dnl
707 AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl
708 _AC_ARG_VAR_CPPFLAGS()dnl
709 AC_LANG_PUSH(C++)dnl
710 AC_MSG_CHECKING([how to run the C++ preprocessor])
711 if test -z "$CXXCPP"; then
712 AC_CACHE_VAL(ac_cv_prog_CXXCPP,
713 [dnl
714 # Double quotes because CXXCPP needs to be expanded
715 for CXXCPP in "$CXX -E" "/lib/cpp"
716 do
717 _AC_PROG_PREPROC_WORKS_IFELSE([break])
718 done
719 ac_cv_prog_CXXCPP=$CXXCPP
720 ])dnl
721 CXXCPP=$ac_cv_prog_CXXCPP
722 else
723 ac_cv_prog_CXXCPP=$CXXCPP
724 fi
725 AC_MSG_RESULT([$CXXCPP])
726 _AC_PROG_PREPROC_WORKS_IFELSE([],
727 [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])])
728 AC_SUBST(CXXCPP)dnl
729 AC_LANG_POP(C++)dnl
730 ])# AC_PROG_CXXCPP
731
732
733 # AC_LANG_COMPILER(C++)
734 # ---------------------
735 # Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
736 AC_DEFUN([AC_LANG_COMPILER(C++)],
737 [AC_REQUIRE([AC_PROG_CXX])])
738
739
740 # ac_cv_prog_gxx
741 # --------------
742 # We used to name the cache variable this way.
743 AU_DEFUN([ac_cv_prog_gxx],
744 [ac_cv_cxx_compiler_gnu])
745
746
747 # AC_PROG_CXX([LIST-OF-COMPILERS])
748 # --------------------------------
749 # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
750 # for (if not specified, a default list is used). This just gives the
751 # user an opportunity to specify an alternative search list for the C++
752 # compiler.
753 # aCC HP-UX C++ compiler much better than `CC', so test before.
754 # FCC Fujitsu C++ compiler
755 # KCC KAI C++ compiler
756 # RCC Rational C++
757 # xlC_r AIX C Set++ (with support for reentrant code)
758 # xlC AIX C Set++
759 AN_MAKEVAR([CXX], [AC_PROG_CXX])
760 AN_PROGRAM([CC], [AC_PROG_CXX])
761 AN_PROGRAM([c++], [AC_PROG_CXX])
762 AN_PROGRAM([g++], [AC_PROG_CXX])
763 AC_DEFUN([AC_PROG_CXX],
764 [AC_LANG_PUSH(C++)dnl
765 AC_ARG_VAR([CXX], [C++ compiler command])dnl
766 AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
767 _AC_ARG_VAR_LDFLAGS()dnl
768 _AC_ARG_VAR_LIBS()dnl
769 _AC_ARG_VAR_CPPFLAGS()dnl
770 _AC_ARG_VAR_PRECIOUS([CCC])dnl
771 if test -z "$CXX"; then
772 if test -n "$CCC"; then
773 CXX=$CCC
774 else
775 AC_CHECK_TOOLS(CXX,
776 [m4_default([$1],
777 [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])],
778 g++)
779 fi
780 fi
781 # Provide some information about the compiler.
782 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
783 ac_compiler=`set X $ac_compile; echo $[2]`
784 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
785 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
786 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
787
788 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
789 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
790 _AC_LANG_COMPILER_GNU
791 GXX=`test $ac_compiler_gnu = yes && echo yes`
792 _AC_PROG_CXX_G
793 AC_LANG_POP(C++)dnl
794 ])# AC_PROG_CXX
795
796
797 # _AC_PROG_CXX_G
798 # --------------
799 # Check whether -g works, even if CXXFLAGS is set, in case the package
800 # plays around with CXXFLAGS (such as to build both debugging and
801 # normal versions of a library), tasteless as that idea is.
802 # Don't consider -g to work if it generates warnings when plain compiles don't.
803 m4_define([_AC_PROG_CXX_G],
804 [ac_test_CXXFLAGS=${CXXFLAGS+set}
805 ac_save_CXXFLAGS=$CXXFLAGS
806 AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
807 [ac_save_cxx_werror_flag=$ac_cxx_werror_flag
808 ac_cxx_werror_flag=yes
809 ac_cv_prog_cxx_g=no
810 CXXFLAGS="-g"
811 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
812 [ac_cv_prog_cxx_g=yes],
813 [CXXFLAGS=""
814 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
815 [],
816 [ac_cxx_werror_flag=$ac_save_cxx_werror_flag
817 CXXFLAGS="-g"
818 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
819 [ac_cv_prog_cxx_g=yes])])])
820 ac_cxx_werror_flag=$ac_save_cxx_werror_flag])
821 if test "$ac_test_CXXFLAGS" = set; then
822 CXXFLAGS=$ac_save_CXXFLAGS
823 elif test $ac_cv_prog_cxx_g = yes; then
824 if test "$GXX" = yes; then
825 CXXFLAGS="-g -O2"
826 else
827 CXXFLAGS="-g"
828 fi
829 else
830 if test "$GXX" = yes; then
831 CXXFLAGS="-O2"
832 else
833 CXXFLAGS=
834 fi
835 fi[]dnl
836 ])# _AC_PROG_CXX_G
837
838
839 # AC_PROG_CXX_C_O
840 # ---------------
841 # Test if the C++ compiler accepts the options `-c' and `-o'
842 # simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not.
843 AC_DEFUN([AC_PROG_CXX_C_O],
844 [AC_REQUIRE([AC_PROG_CXX])dnl
845 AC_LANG_PUSH([C++])dnl
846 AC_CACHE_CHECK([whether $CXX understands -c and -o together],
847 [ac_cv_prog_cxx_c_o],
848 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
849 # We test twice because some compilers refuse to overwrite an existing
850 # `.o' file with `-o', although they will create one.
851 ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
852 rm -f conftest2.*
853 if _AC_DO_VAR(ac_try) &&
854 test -f conftest2.$ac_objext &&
855 _AC_DO_VAR(ac_try); then
856 ac_cv_prog_cxx_c_o=yes
857 else
858 ac_cv_prog_cxx_c_o=no
859 fi
860 rm -f conftest*])
861 if test $ac_cv_prog_cxx_c_o = no; then
862 AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1,
863 [Define to 1 if your C++ compiler doesn't accept
864 -c and -o together.])
865 fi
866 AC_LANG_POP([C++])dnl
867 ])# AC_PROG_CXX_C_O
868
869
870 # ------------------------------ #
871 # 3d. The Objective C compiler. #
872 # ------------------------------ #
873
874
875 # AC_LANG_PREPROC(Objective C)
876 # ----------------------------
877 # Find the Objective C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
878 AC_DEFUN([AC_LANG_PREPROC(Objective C)],
879 [AC_REQUIRE([AC_PROG_OBJCPP])])
880
881
882 # AC_PROG_OBJCPP
883 # --------------
884 # Find a working Objective C preprocessor.
885 AC_DEFUN([AC_PROG_OBJCPP],
886 [AC_REQUIRE([AC_PROG_OBJC])dnl
887 AC_ARG_VAR([OBJCPP], [Objective C preprocessor])dnl
888 _AC_ARG_VAR_CPPFLAGS()dnl
889 AC_LANG_PUSH(Objective C)dnl
890 AC_MSG_CHECKING([how to run the Objective C preprocessor])
891 if test -z "$OBJCPP"; then
892 AC_CACHE_VAL(ac_cv_prog_OBJCPP,
893 [dnl
894 # Double quotes because OBJCPP needs to be expanded
895 for OBJCPP in "$OBJC -E" "/lib/cpp"
896 do
897 _AC_PROG_PREPROC_WORKS_IFELSE([break])
898 done
899 ac_cv_prog_OBJCPP=$OBJCPP
900 ])dnl
901 OBJCPP=$ac_cv_prog_OBJCPP
902 else
903 ac_cv_prog_OBJCPP=$OBJCPP
904 fi
905 AC_MSG_RESULT([$OBJCPP])
906 _AC_PROG_PREPROC_WORKS_IFELSE([],
907 [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])])
908 AC_SUBST(OBJCPP)dnl
909 AC_LANG_POP(Objective C)dnl
910 ])# AC_PROG_OBJCPP
911
912
913 # AC_LANG_COMPILER(Objective C)
914 # -----------------------------
915 # Find the Objective C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
916 AC_DEFUN([AC_LANG_COMPILER(Objective C)],
917 [AC_REQUIRE([AC_PROG_OBJC])])
918
919
920
921 # AC_PROG_OBJC([LIST-OF-COMPILERS])
922 # ---------------------------------
923 # LIST-OF-COMPILERS is a space separated list of Objective C compilers to
924 # search for (if not specified, a default list is used). This just gives
925 # the user an opportunity to specify an alternative search list for the
926 # Objective C compiler.
927 # objcc StepStone Objective-C compiler (also "standard" name for OBJC)
928 # objc David Stes' POC. If you installed this, you likely want it.
929 # cc Native C compiler (for instance, Apple).
930 # CC You never know.
931 AN_MAKEVAR([OBJC], [AC_PROG_OBJC])
932 AN_PROGRAM([objcc], [AC_PROG_OBJC])
933 AN_PROGRAM([objc], [AC_PROG_OBJC])
934 AC_DEFUN([AC_PROG_OBJC],
935 [AC_LANG_PUSH(Objective C)dnl
936 AC_ARG_VAR([OBJC], [Objective C compiler command])dnl
937 AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl
938 _AC_ARG_VAR_LDFLAGS()dnl
939 _AC_ARG_VAR_LIBS()dnl
940 _AC_ARG_VAR_CPPFLAGS()dnl
941 _AC_ARG_VAR_PRECIOUS([OBJC])dnl
942 AC_CHECK_TOOLS(OBJC,
943 [m4_default([$1], [gcc objcc objc cc CC])],
944 gcc)
945 # Provide some information about the compiler.
946 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
947 ac_compiler=`set X $ac_compile; echo $[2]`
948 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
949 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
950 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
951
952 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
953 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
954 _AC_LANG_COMPILER_GNU
955 GOBJC=`test $ac_compiler_gnu = yes && echo yes`
956 _AC_PROG_OBJC_G
957 AC_LANG_POP(Objective C)dnl
958 ])# AC_PROG_OBJC
959
960
961 # _AC_PROG_OBJC_G
962 # ---------------
963 # Check whether -g works, even if OBJCFLAGS is set, in case the package
964 # plays around with OBJCFLAGS (such as to build both debugging and
965 # normal versions of a library), tasteless as that idea is.
966 # Don't consider -g to work if it generates warnings when plain compiles don't.
967 m4_define([_AC_PROG_OBJC_G],
968 [ac_test_OBJCFLAGS=${OBJCFLAGS+set}
969 ac_save_OBJCFLAGS=$OBJCFLAGS
970 AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g,
971 [ac_save_objc_werror_flag=$ac_objc_werror_flag
972 ac_objc_werror_flag=yes
973 ac_cv_prog_objc_g=no
974 OBJCFLAGS="-g"
975 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
976 [ac_cv_prog_objc_g=yes],
977 [OBJCFLAGS=""
978 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
979 [],
980 [ac_objc_werror_flag=$ac_save_objc_werror_flag
981 OBJCFLAGS="-g"
982 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
983 [ac_cv_prog_objc_g=yes])])])
984 ac_objc_werror_flag=$ac_save_objc_werror_flag])
985 if test "$ac_test_OBJCFLAGS" = set; then
986 OBJCFLAGS=$ac_save_OBJCFLAGS
987 elif test $ac_cv_prog_objc_g = yes; then
988 if test "$GOBJC" = yes; then
989 OBJCFLAGS="-g -O2"
990 else
991 OBJCFLAGS="-g"
992 fi
993 else
994 if test "$GOBJC" = yes; then
995 OBJCFLAGS="-O2"
996 else
997 OBJCFLAGS=
998 fi
999 fi[]dnl
1000 ])# _AC_PROG_OBJC_G
1001
1002
1003
1004
1005
1006
1007 ## ------------------------------- ##
1008 ## 4. Compilers' characteristics. ##
1009 ## ------------------------------- ##
1010
1011
1012 # -------------------------------- #
1013 # 4b. C compiler characteristics. #
1014 # -------------------------------- #
1015
1016 # _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1017 # ----------------------------------------------------------------
1018 # If the C compiler is not in ANSI C89 (ISO C90) mode by default, try
1019 # to add an option to output variable CC to make it so. This macro
1020 # tries various options that select ANSI C89 on some system or
1021 # another. It considers the compiler to be in ANSI C89 mode if it
1022 # handles function prototypes correctly.
1023 AC_DEFUN([_AC_PROG_CC_C89],
1024 [_AC_C_STD_TRY([c89],
1025 [[#include <stdarg.h>
1026 #include <stdio.h>
1027 #include <sys/types.h>
1028 #include <sys/stat.h>
1029 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
1030 struct buf { int x; };
1031 FILE * (*rcsopen) (struct buf *, struct stat *, int);
1032 static char *e (p, i)
1033 char **p;
1034 int i;
1035 {
1036 return p[i];
1037 }
1038 static char *f (char * (*g) (char **, int), char **p, ...)
1039 {
1040 char *s;
1041 va_list v;
1042 va_start (v,p);
1043 s = g (p, va_arg (v,int));
1044 va_end (v);
1045 return s;
1046 }
1047
1048 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
1049 function prototypes and stuff, but not '\xHH' hex character constants.
1050 These don't provoke an error unfortunately, instead are silently treated
1051 as 'x'. The following induces an error, until -std is added to get
1052 proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
1053 array size at least. It's necessary to write '\x00'==0 to get something
1054 that's true only with -std. */
1055 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
1056
1057 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
1058 inside strings and character constants. */
1059 #define FOO(x) 'x'
1060 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
1061
1062 int test (int i, double x);
1063 struct s1 {int (*f) (int a);};
1064 struct s2 {int (*f) (double a);};
1065 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
1066 int argc;
1067 char **argv;]],
1068 [[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]],
1069 dnl Don't try gcc -ansi; that turns off useful extensions and
1070 dnl breaks some systems' header files.
1071 dnl AIX circa 2003 -qlanglvl=extc89
1072 dnl old AIX -qlanglvl=ansi
1073 dnl Ultrix, OSF/1, Tru64 -std
1074 dnl HP-UX 10.20 and later -Ae
1075 dnl HP-UX older versions -Aa -D_HPUX_SOURCE
1076 dnl SVR4 -Xc -D__EXTENSIONS__
1077 [-qlanglvl=extc89 -qlanglvl=ansi -std \
1078 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl
1079 ])# _AC_PROG_CC_C89
1080
1081
1082 # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
1083 # ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
1084 # --------------------------------------------------------------
1085 # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
1086 # by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails,
1087 # try again with each compiler option in the space-separated OPTION-LIST; if one
1088 # helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE,
1089 # else ACTION-IF-UNAVAILABLE.
1090 AC_DEFUN([_AC_C_STD_TRY],
1091 [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
1092 AC_CACHE_VAL(ac_cv_prog_cc_$1,
1093 [ac_cv_prog_cc_$1=no
1094 ac_save_CC=$CC
1095 AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
1096 for ac_arg in '' $4
1097 do
1098 CC="$ac_save_CC $ac_arg"
1099 _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
1100 test "x$ac_cv_prog_cc_$1" != "xno" && break
1101 done
1102 rm -f conftest.$ac_ext
1103 CC=$ac_save_CC
1104 ])# AC_CACHE_VAL
1105 case "x$ac_cv_prog_cc_$1" in
1106 x)
1107 AC_MSG_RESULT([none needed]) ;;
1108 xno)
1109 AC_MSG_RESULT([unsupported]) ;;
1110 *)
1111 CC="$CC $ac_cv_prog_cc_$1"
1112 AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
1113 esac
1114 AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
1115 ])# _AC_C_STD_TRY
1116
1117
1118 # _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1119 # ----------------------------------------------------------------
1120 # If the C compiler is not in ISO C99 mode by default, try to add an
1121 # option to output variable CC to make it so. This macro tries
1122 # various options that select ISO C99 on some system or another. It
1123 # considers the compiler to be in ISO C99 mode if it handles _Bool,
1124 # // comments, flexible array members, inline, long long int, mixed
1125 # code and declarations, named initialization of structs, restrict,
1126 # va_copy, varargs macros, variable declarations in for loops and
1127 # variable length arrays.
1128 AC_DEFUN([_AC_PROG_CC_C99],
1129 [_AC_C_STD_TRY([c99],
1130 [[#include <stdarg.h>
1131 #include <stdbool.h>
1132 #include <stdlib.h>
1133 #include <wchar.h>
1134 #include <stdio.h>
1135
1136 // Check varargs macros. These examples are taken from C99 6.10.3.5.
1137 #define debug(...) fprintf (stderr, __VA_ARGS__)
1138 #define showlist(...) puts (#__VA_ARGS__)
1139 #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
1140 static void
1141 test_varargs_macros (void)
1142 {
1143 int x = 1234;
1144 int y = 5678;
1145 debug ("Flag");
1146 debug ("X = %d\n", x);
1147 showlist (The first, second, and third items.);
1148 report (x>y, "x is %d but y is %d", x, y);
1149 }
1150
1151 // Check long long types.
1152 #define BIG64 18446744073709551615ull
1153 #define BIG32 4294967295ul
1154 #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
1155 #if !BIG_OK
1156 your preprocessor is broken;
1157 #endif
1158 #if BIG_OK
1159 #else
1160 your preprocessor is broken;
1161 #endif
1162 static long long int bignum = -9223372036854775807LL;
1163 static unsigned long long int ubignum = BIG64;
1164
1165 struct incomplete_array
1166 {
1167 int datasize;
1168 double data[];
1169 };
1170
1171 struct named_init {
1172 int number;
1173 const wchar_t *name;
1174 double average;
1175 };
1176
1177 typedef const char *ccp;
1178
1179 static inline int
1180 test_restrict (ccp restrict text)
1181 {
1182 // See if C++-style comments work.
1183 // Iterate through items via the restricted pointer.
1184 // Also check for declarations in for loops.
1185 for (unsigned int i = 0; *(text+i) != '\0'; ++i)
1186 continue;
1187 return 0;
1188 }
1189
1190 // Check varargs and va_copy.
1191 static void
1192 test_varargs (const char *format, ...)
1193 {
1194 va_list args;
1195 va_start (args, format);
1196 va_list args_copy;
1197 va_copy (args_copy, args);
1198
1199 const char *str;
1200 int number;
1201 float fnumber;
1202
1203 while (*format)
1204 {
1205 switch (*format++)
1206 {
1207 case 's': // string
1208 str = va_arg (args_copy, const char *);
1209 break;
1210 case 'd': // int
1211 number = va_arg (args_copy, int);
1212 break;
1213 case 'f': // float
1214 fnumber = va_arg (args_copy, double);
1215 break;
1216 default:
1217 break;
1218 }
1219 }
1220 va_end (args_copy);
1221 va_end (args);
1222 }
1223 ]],
1224 [[
1225 // Check bool.
1226 _Bool success = false;
1227
1228 // Check restrict.
1229 if (test_restrict ("String literal") == 0)
1230 success = true;
1231 char *restrict newvar = "Another string";
1232
1233 // Check varargs.
1234 test_varargs ("s, d' f .", "string", 65, 34.234);
1235 test_varargs_macros ();
1236
1237 // Check flexible array members.
1238 struct incomplete_array *ia =
1239 malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
1240 ia->datasize = 10;
1241 for (int i = 0; i < ia->datasize; ++i)
1242 ia->data[i] = i * 1.234;
1243
1244 // Check named initializers.
1245 struct named_init ni = {
1246 .number = 34,
1247 .name = L"Test wide string",
1248 .average = 543.34343,
1249 };
1250
1251 ni.number = 58;
1252
1253 int dynamic_array[ni.number];
1254 dynamic_array[ni.number - 1] = 543;
1255
1256 // work around unused variable warnings
1257 return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
1258 || dynamic_array[ni.number - 1] != 543);
1259 ]],
1260 dnl Try
1261 dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
1262 dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
1263 dnl Intel ICC -c99
1264 dnl IRIX -c99
1265 dnl Solaris (unused because it causes the compiler to assume C99 semantics for
1266 dnl library functions, and this is invalid before Solaris 10: -xc99)
1267 dnl Tru64 -c99
1268 dnl with extended modes being tried first.
1269 [[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl
1270 ])# _AC_PROG_CC_C99
1271
1272
1273 # AC_PROG_CC_C89
1274 # --------------
1275 AC_DEFUN([AC_PROG_CC_C89],
1276 [ AC_REQUIRE([AC_PROG_CC])dnl
1277 _AC_PROG_CC_C89
1278 ])
1279
1280
1281 # AC_PROG_CC_C99
1282 # --------------
1283 AC_DEFUN([AC_PROG_CC_C99],
1284 [ AC_REQUIRE([AC_PROG_CC])dnl
1285 _AC_PROG_CC_C99
1286 ])
1287
1288
1289 # AC_PROG_CC_STDC
1290 # ---------------
1291 AC_DEFUN([AC_PROG_CC_STDC],
1292 [ AC_REQUIRE([AC_PROG_CC])dnl
1293 AS_CASE([$ac_cv_prog_cc_stdc],
1294 [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
1295 [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
1296 [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
1297 [ac_cv_prog_cc_stdc=no])])])dnl
1298 AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
1299 AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
1300 AS_CASE([$ac_cv_prog_cc_stdc],
1301 [no], [AC_MSG_RESULT([unsupported])],
1302 [''], [AC_MSG_RESULT([none needed])],
1303 [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
1304 ])
1305
1306
1307 # AC_C_BACKSLASH_A
1308 # ----------------
1309 AC_DEFUN([AC_C_BACKSLASH_A],
1310 [
1311 AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a,
1312 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1313 [[
1314 #if '\a' == 'a'
1315 syntax error;
1316 #endif
1317 char buf['\a' == 'a' ? -1 : 1];
1318 buf[0] = '\a';
1319 return buf[0] != "\a"[0];
1320 ]])],
1321 [ac_cv_c_backslash_a=yes],
1322 [ac_cv_c_backslash_a=no])])
1323 if test $ac_cv_c_backslash_a = yes; then
1324 AC_DEFINE(HAVE_C_BACKSLASH_A, 1,
1325 [Define if backslash-a works in C strings.])
1326 fi
1327 ])
1328
1329
1330 # AC_C_CROSS
1331 # ----------
1332 # Has been merged into AC_PROG_CC.
1333 AU_DEFUN([AC_C_CROSS], [])
1334
1335
1336 # AC_C_CHAR_UNSIGNED
1337 # ------------------
1338 AC_DEFUN([AC_C_CHAR_UNSIGNED],
1339 [AH_VERBATIM([__CHAR_UNSIGNED__],
1340 [/* Define to 1 if type `char' is unsigned and you are not using gcc. */
1341 #ifndef __CHAR_UNSIGNED__
1342 # undef __CHAR_UNSIGNED__
1343 #endif])dnl
1344 AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1345 [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
1346 [((char) -1) < 0])],
1347 ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
1348 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1349 AC_DEFINE(__CHAR_UNSIGNED__)
1350 fi
1351 ])# AC_C_CHAR_UNSIGNED
1352
1353
1354 # AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN])
1355 # -------------------------------------------------------------------------
1356 AC_DEFUN([AC_C_BIGENDIAN],
1357 [AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
1358 [# See if sys/param.h defines the BYTE_ORDER macro.
1359 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1360 #include <sys/param.h>
1361 ],
1362 [#if ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
1363 && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
1364 bogus endian macros
1365 #endif
1366 ])],
1367 [# It does; now see whether it defined to BIG_ENDIAN or not.
1368 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1369 #include <sys/param.h>
1370 ], [#if BYTE_ORDER != BIG_ENDIAN
1371 not big endian
1372 #endif
1373 ])], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=no])],
1374 [# It does not; compile a test program.
1375 AC_RUN_IFELSE(
1376 [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [[
1377 /* Are we little or big endian? From Harbison&Steele. */
1378 union
1379 {
1380 long int l;
1381 char c[sizeof (long int)];
1382 } u;
1383 u.l = 1;
1384 return u.c[sizeof (long int) - 1] == 1;
1385 ]])],
1386 [ac_cv_c_bigendian=no],
1387 [ac_cv_c_bigendian=yes],
1388 [# try to guess the endianness by grepping values into an object file
1389 ac_cv_c_bigendian=unknown
1390 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1391 [[short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
1392 short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
1393 void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
1394 short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
1395 short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
1396 void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }]],
1397 [[ _ascii (); _ebcdic (); ]])],
1398 [if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
1399 ac_cv_c_bigendian=yes
1400 fi
1401 if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
1402 if test "$ac_cv_c_bigendian" = unknown; then
1403 ac_cv_c_bigendian=no
1404 else
1405 # finding both strings is unlikely to happen, but who knows?
1406 ac_cv_c_bigendian=unknown
1407 fi
1408 fi])])])])
1409 case $ac_cv_c_bigendian in
1410 yes)
1411 m4_default([$1],
1412 [AC_DEFINE([WORDS_BIGENDIAN], 1,
1413 [Define to 1 if your processor stores words with the most significant
1414 byte first (like Motorola and SPARC, unlike Intel and VAX).])]) ;;
1415 no)
1416 $2 ;;
1417 *)
1418 m4_default([$3],
1419 [AC_MSG_ERROR([unknown endianness
1420 presetting ac_cv_c_bigendian=no (or yes) will help])]) ;;
1421 esac
1422 ])# AC_C_BIGENDIAN
1423
1424
1425 # AC_C_INLINE
1426 # -----------
1427 # Do nothing if the compiler accepts the inline keyword.
1428 # Otherwise define inline to __inline__ or __inline if one of those work,
1429 # otherwise define inline to be empty.
1430 #
1431 # HP C version B.11.11.04 doesn't allow a typedef as the return value for an
1432 # inline function, only builtin types.
1433 #
1434 AN_IDENTIFIER([inline], [AC_C_INLINE])
1435 AC_DEFUN([AC_C_INLINE],
1436 [AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1437 [ac_cv_c_inline=no
1438 for ac_kw in inline __inline__ __inline; do
1439 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1440 [#ifndef __cplusplus
1441 typedef int foo_t;
1442 static $ac_kw foo_t static_foo () {return 0; }
1443 $ac_kw foo_t foo () {return 0; }
1444 #endif
1445 ])],
1446 [ac_cv_c_inline=$ac_kw])
1447 test "$ac_cv_c_inline" != no && break
1448 done
1449 ])
1450 AH_VERBATIM([inline],
1451 [/* Define to `__inline__' or `__inline' if that's what the C compiler
1452 calls it, or to nothing if 'inline' is not supported under any name. */
1453 #ifndef __cplusplus
1454 #undef inline
1455 #endif])
1456 case $ac_cv_c_inline in
1457 inline | yes) ;;
1458 *)
1459 case $ac_cv_c_inline in
1460 no) ac_val=;;
1461 *) ac_val=$ac_cv_c_inline;;
1462 esac
1463 cat >>confdefs.h <<_ACEOF
1464 #ifndef __cplusplus
1465 #define inline $ac_val
1466 #endif
1467 _ACEOF
1468 ;;
1469 esac
1470 ])# AC_C_INLINE
1471
1472
1473 # AC_C_CONST
1474 # ----------
1475 AN_IDENTIFIER([const], [AC_C_CONST])
1476 AC_DEFUN([AC_C_CONST],
1477 [AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
1478 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1479 [[/* FIXME: Include the comments suggested by Paul. */
1480 #ifndef __cplusplus
1481 /* Ultrix mips cc rejects this. */
1482 typedef int charset[2];
1483 const charset cs;
1484 /* SunOS 4.1.1 cc rejects this. */
1485 char const *const *pcpcc;
1486 char **ppc;
1487 /* NEC SVR4.0.2 mips cc rejects this. */
1488 struct point {int x, y;};
1489 static struct point const zero = {0,0};
1490 /* AIX XL C 1.02.0.0 rejects this.
1491 It does not let you subtract one const X* pointer from another in
1492 an arm of an if-expression whose if-part is not a constant
1493 expression */
1494 const char *g = "string";
1495 pcpcc = &g + (g ? g-g : 0);
1496 /* HPUX 7.0 cc rejects these. */
1497 ++pcpcc;
1498 ppc = (char**) pcpcc;
1499 pcpcc = (char const *const *) ppc;
1500 { /* SCO 3.2v4 cc rejects this. */
1501 char *t;
1502 char const *s = 0 ? (char *) 0 : (char const *) 0;
1503
1504 *t++ = 0;
1505 if (s) return 0;
1506 }
1507 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
1508 int x[] = {25, 17};
1509 const int *foo = &x[0];
1510 ++foo;
1511 }
1512 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
1513 typedef const int *iptr;
1514 iptr p = 0;
1515 ++p;
1516 }
1517 { /* AIX XL C 1.02.0.0 rejects this saying
1518 "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
1519 struct s { int j; const int *ap[3]; };
1520 struct s *b; b->j = 5;
1521 }
1522 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
1523 const int foo = 10;
1524 if (!foo) return 0;
1525 }
1526 return !cs[0] && !zero.x;
1527 #endif
1528 ]])],
1529 [ac_cv_c_const=yes],
1530 [ac_cv_c_const=no])])
1531 if test $ac_cv_c_const = no; then
1532 AC_DEFINE(const,,
1533 [Define to empty if `const' does not conform to ANSI C.])
1534 fi
1535 ])# AC_C_CONST
1536
1537
1538 # AC_C_RESTRICT
1539 # -------------
1540 # based on acx_restrict.m4, from the GNU Autoconf Macro Archive at:
1541 # http://autoconf-archive.cryp.to/acx_restrict.html
1542 #
1543 # Determine whether the C/C++ compiler supports the "restrict" keyword
1544 # introduced in ANSI C99, or an equivalent. Do nothing if the compiler
1545 # accepts it. Otherwise, if the compiler supports an equivalent,
1546 # define "restrict" to be that. Here are some variants:
1547 # - GCC supports both __restrict and __restrict__
1548 # - older DEC Alpha C compilers support only __restrict
1549 # - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C
1550 # Otherwise, define "restrict" to be empty.
1551 AN_IDENTIFIER([restrict], [AC_C_RESTRICT])
1552 AC_DEFUN([AC_C_RESTRICT],
1553 [AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
1554 [ac_cv_c_restrict=no
1555 # Try the official restrict keyword, then gcc's __restrict, and
1556 # the less common variants.
1557 for ac_kw in restrict __restrict __restrict__ _Restrict; do
1558 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1559 [[typedef int * int_ptr;
1560 int foo (int_ptr $ac_kw ip) {
1561 return ip[0];
1562 }]],
1563 [[int s[1];
1564 int * $ac_kw t = s;
1565 t[0] = 0;
1566 return foo(t)]])],
1567 [ac_cv_c_restrict=$ac_kw])
1568 test "$ac_cv_c_restrict" != no && break
1569 done
1570 ])
1571 case $ac_cv_c_restrict in
1572 restrict) ;;
1573 no) AC_DEFINE(restrict,,
1574 [Define to equivalent of C99 restrict keyword, or to nothing if this
1575 is not supported. Do not define if restrict is supported directly.]) ;;
1576 *) AC_DEFINE_UNQUOTED(restrict, $ac_cv_c_restrict) ;;
1577 esac
1578 ])# AC_C_RESTRICT
1579
1580
1581 # AC_C_VOLATILE
1582 # -------------
1583 # Note that, unlike const, #defining volatile to be the empty string can
1584 # actually turn a correct program into an incorrect one, since removing
1585 # uses of volatile actually grants the compiler permission to perform
1586 # optimizations that could break the user's code. So, do not #define
1587 # volatile away unless it is really necessary to allow the user's code
1588 # to compile cleanly. Benign compiler failures should be tolerated.
1589 AN_IDENTIFIER([volatile], [AC_C_VOLATILE])
1590 AC_DEFUN([AC_C_VOLATILE],
1591 [AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
1592 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1593 volatile int x;
1594 int * volatile y = (int *) 0;
1595 return !x && !y;])],
1596 [ac_cv_c_volatile=yes],
1597 [ac_cv_c_volatile=no])])
1598 if test $ac_cv_c_volatile = no; then
1599 AC_DEFINE(volatile,,
1600 [Define to empty if the keyword `volatile' does not work.
1601 Warning: valid code using `volatile' can become incorrect
1602 without. Disable with care.])
1603 fi
1604 ])# AC_C_VOLATILE
1605
1606
1607 # AC_C_STRINGIZE
1608 # --------------
1609 # Checks if `#' can be used to glue strings together at the CPP level.
1610 # Defines HAVE_STRINGIZE if positive.
1611 AC_DEFUN([AC_C_STRINGIZE],
1612 [AC_CACHE_CHECK([for preprocessor stringizing operator],
1613 [ac_cv_c_stringize],
1614 [AC_EGREP_CPP([@%:@teststring],
1615 [@%:@define x(y) #y
1616
1617 char *s = x(teststring);],
1618 [ac_cv_c_stringize=no],
1619 [ac_cv_c_stringize=yes])])
1620 if test $ac_cv_c_stringize = yes; then
1621 AC_DEFINE(HAVE_STRINGIZE, 1,
1622 [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.])
1623 fi
1624 ])# AC_C_STRINGIZE
1625
1626
1627 # AC_C_PROTOTYPES
1628 # ---------------
1629 # Check if the C compiler supports prototypes, included if it needs
1630 # options.
1631 AC_DEFUN([AC_C_PROTOTYPES],
1632 [AC_REQUIRE([AC_PROG_CC])dnl
1633 AC_MSG_CHECKING([for function prototypes])
1634 if test "$ac_cv_prog_cc_c89" != no; then
1635 AC_MSG_RESULT([yes])
1636 AC_DEFINE(PROTOTYPES, 1,
1637 [Define to 1 if the C compiler supports function prototypes.])
1638 AC_DEFINE(__PROTOTYPES, 1,
1639 [Define like PROTOTYPES; this can be used by system headers.])
1640 else
1641 AC_MSG_RESULT([no])
1642 fi
1643 ])# AC_C_PROTOTYPES
1644
1645
1646 # AC_C_FLEXIBLE_ARRAY_MEMBER
1647 # --------------------------
1648 # Check whether the C compiler supports flexible array members.
1649 AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER],
1650 [
1651 AC_CACHE_CHECK([for flexible array members],
1652 ac_cv_c_flexmember,
1653 [AC_COMPILE_IFELSE(
1654 [AC_LANG_PROGRAM(
1655 [[#include <stdlib.h>
1656 #include <stdio.h>
1657 #include <stddef.h>
1658 struct s { int n; double d[]; };]],
1659 [[int m = getchar ();
1660 struct s *p = malloc (offsetof (struct s, d)
1661 + m * sizeof (double));
1662 p->d[0] = 0.0;
1663 return p->d != (double *) NULL;]])],
1664 [ac_cv_c_flexmember=yes],
1665 [ac_cv_c_flexmember=no])])
1666 if test $ac_cv_c_flexmember = yes; then
1667 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [],
1668 [Define to nothing if C supports flexible array members, and to
1669 1 if it does not. That way, with a declaration like `struct s
1670 { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
1671 can be used with pre-C99 compilers.
1672 When computing the size of such an object, don't use 'sizeof (struct s)'
1673 as it overestimates the size. Use 'offsetof (struct s, d)' instead.
1674 Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with
1675 MSVC and with C++ compilers.])
1676 else
1677 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1)
1678 fi
1679 ])
1680
1681
1682 # AC_C_VARARRAYS
1683 # --------------
1684 # Check whether the C compiler supports variable-length arrays.
1685 AC_DEFUN([AC_C_VARARRAYS],
1686 [
1687 AC_CACHE_CHECK([for variable-length arrays],
1688 ac_cv_c_vararrays,
1689 [AC_COMPILE_IFELSE(
1690 [AC_LANG_PROGRAM([],
1691 [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])],
1692 [ac_cv_c_vararrays=yes],
1693 [ac_cv_c_vararrays=no])])
1694 if test $ac_cv_c_vararrays = yes; then
1695 AC_DEFINE([HAVE_C_VARARRAYS], 1,
1696 [Define to 1 if C supports variable-length arrays.])
1697 fi
1698 ])
1699
1700
1701 # AC_C_TYPEOF
1702 # -----------
1703 # Check if the C compiler supports GCC's typeof syntax.
1704 # The test case provokes incompatibilities in the Sun C compilers
1705 # (both Solaris 8 and Solaris 10).
1706 AC_DEFUN([AC_C_TYPEOF],
1707 [
1708 AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof,
1709 [ac_cv_c_typeof=no
1710 for ac_kw in typeof __typeof__ no; do
1711 test $ac_kw = no && break
1712 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1713 [[
1714 int value;
1715 typedef struct {
1716 char a [1
1717 + ! (($ac_kw (value))
1718 (($ac_kw (value)) 0 < ($ac_kw (value)) -1
1719 ? ($ac_kw (value)) - 1
1720 : ~ (~ ($ac_kw (value)) 0
1721 << sizeof ($ac_kw (value)))))]; }
1722 ac__typeof_type_;
1723 return
1724 (! ((void) ((ac__typeof_type_ *) 0), 0));
1725 ]])],
1726 [ac_cv_c_typeof=$ac_kw])
1727 test $ac_cv_c_typeof != no && break
1728 done])
1729 if test $ac_cv_c_typeof != no; then
1730 AC_DEFINE([HAVE_TYPEOF], 1,
1731 [Define to 1 if typeof works with your compiler.])
1732 if test $ac_cv_c_typeof != typeof; then
1733 AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof],
1734 [Define to __typeof__ if your compiler spells it that way.])
1735 fi
1736 fi
1737 ])