1 # This file is part of Autoconf. -*- Autoconf -*-
2 # Programming languages support.
3 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Free Software
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)
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.
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
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.
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.
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.
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.
54 # -------------------- #
55 # 1b. The C language. #
56 # -------------------- #
61 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
62 m4_define([AC_LANG(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
73 AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
78 m4_define([_AC_LANG_ABBREV(C)], [c])
83 m4_define([_AC_LANG_PREFIX(C)], [C])
86 # ---------------------- #
87 # 1c. The C++ language. #
88 # ---------------------- #
93 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
94 m4_define([AC_LANG(C++)],
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
105 AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
108 # _AC_LANG_ABBREV(C++)
109 # --------------------
110 m4_define([_AC_LANG_ABBREV(C++)], [cxx])
113 # _AC_LANG_PREFIX(C++)
114 # --------------------
115 m4_define([_AC_LANG_PREFIX(C++)], [CXX])
119 # ------------------------------ #
120 # 1d. The Objective C language. #
121 # ------------------------------ #
124 # AC_LANG(Objective C)
125 # --------------------
126 m4_define([AC_LANG(Objective C)],
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
137 AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)])
140 # _AC_LANG_ABBREV(Objective C)
141 # ----------------------------
142 m4_define([_AC_LANG_ABBREV(Objective C)], [objc])
145 # _AC_LANG_PREFIX(Objective C)
146 # ----------------------------
147 m4_define([_AC_LANG_PREFIX(Objective C)], [OBJC])
151 ## ---------------------- ##
152 ## 2.Producing programs. ##
153 ## ---------------------- ##
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)],
169 cat confdefs.h >>conftest.$ac_ext
170 cat >>conftest.$ac_ext <<_ACEOF
171 /* end confdefs.h. */
175 # AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
176 # --------------------------------------
177 m4_define([AC_LANG_PROGRAM(C)],
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
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.
192 # AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
193 # -----------------------------------
194 # Avoid conflicting decl of main.
195 m4_define([AC_LANG_CALL(C)],
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. */
204 char $2 ();])], [return $2 ();])])
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.
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.
221 m4_define([AC_LANG_FUNC_LINK_TRY(C)],
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
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. */
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. */
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
253 ], [return $1 ();])])
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
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)],
274 static long int longval () { return $2; }
275 static unsigned long int ulongval () { return $2; }
276 @%:@include <stdio.h>
277 @%:@include <stdlib.h>],
279 FILE *f = fopen ("conftest.val", "w");
284 long int i = longval ();
287 fprintf (f, "%ld", i);
291 unsigned long int i = ulongval ();
294 fprintf (f, "%lu", i);
296 /* Do not output a trailing newline, as this causes \r\n confusion
297 on some platforms. */
298 return ferror (f) || fclose (f) != 0;
302 # ----------------- #
304 # ----------------- #
306 # AC_LANG_SOURCE(C++)(BODY)
307 # -------------------------
308 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
311 # AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
312 # ----------------------------------------
313 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
316 # AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
317 # -------------------------------------
318 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
321 # AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
322 # ------------------------------------
323 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
326 # AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
327 # ---------------------------------------------------
328 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)])
331 # AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
332 # -------------------------------------------
333 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
337 # ------------------------- #
338 # 2d. Objective C sources. #
339 # ------------------------- #
341 # AC_LANG_SOURCE(Objective C)(BODY)
342 # ---------------------------------
343 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)])
346 # AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY])
347 # ------------------------------------------------
348 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)])
351 # AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION)
352 # ---------------------------------------------
353 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)])
356 # AC_LANG_FUNC_LINK_TRY(Objective C)(FUNCTION)
357 # --------------------------------------------
358 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(Objective C)])
361 # AC_LANG_BOOL_COMPILE_TRY(Objective C)(PROLOGUE, EXPRESSION)
362 # -----------------------------------------------------------
363 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(Objective C)])
366 # AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION)
367 # ---------------------------------------------------
368 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)])
372 ## -------------------------------------------- ##
373 ## 3. Looking for Compilers and Preprocessors. ##
374 ## -------------------------------------------- ##
376 # -------------------- #
377 # 3b. The C compiler. #
378 # -------------------- #
381 # _AC_ARG_VAR_CPPFLAGS
382 # --------------------
383 # Document and register CPPFLAGS, which is used by
384 # AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP}.
385 AC_DEFUN([_AC_ARG_VAR_CPPFLAGS],
386 [AC_ARG_VAR([CPPFLAGS],
387 [C/C++/Objective C preprocessor flags, e.g. -I<include dir>
388 if you have headers in a nonstandard directory <include dir>])])
391 # _AC_ARG_VAR_LDFLAGS
392 # -------------------
393 # Document and register LDFLAGS, which is used by
394 # AC_PROG_{CC, CXX, F77, FC, OBJC}.
395 AC_DEFUN([_AC_ARG_VAR_LDFLAGS],
396 [AC_ARG_VAR([LDFLAGS],
397 [linker flags, e.g. -L<lib dir> if you have libraries in a
398 nonstandard directory <lib dir>])])
403 # Document and register LIBS, which is used by
404 # AC_PROG_{CC, CXX, F77, FC, OBJS}.
405 AC_DEFUN([_AC_ARG_VAR_LIBS],
407 [libraries to pass to the linker, e.g. -l<library>])])
411 # -------------------
412 # Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
413 AC_DEFUN([AC_LANG_PREPROC(C)],
414 [AC_REQUIRE([AC_PROG_CPP])])
417 # _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT)
418 # -----------------------------------------------
419 # Check if $ac_cpp is a working preprocessor that can flag absent
420 # includes either by the exit status or by warnings.
421 # This macro is for all languages, not only C.
422 AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE],
424 for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes
426 # Use a header file that comes with gcc, so configuring glibc
427 # with a fresh cross-compiler works.
428 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
429 # <limits.h> exists even on freestanding compilers.
430 # On the NeXT, cc -E runs the code through the compiler's parser,
431 # not just through cpp. "Syntax error" is here to catch this case.
432 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__
433 @%:@ include <limits.h>
435 @%:@ include <assert.h>
439 [# Broken: fails on valid input.
442 # OK, works on sane cases. Now check whether nonexistent headers
443 # can be detected and how.
444 _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])],
445 [# Broken: success on invalid input.
447 [# Passes both tests.
452 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
453 rm -f conftest.err conftest.$ac_ext
454 AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE
459 # Find a working C preprocessor.
460 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
461 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC.
462 AN_MAKEVAR([CPP], [AC_PROG_CPP])
463 AN_PROGRAM([cpp], [AC_PROG_CPP])
464 AC_DEFUN([AC_PROG_CPP],
465 [AC_REQUIRE([AC_PROG_CC])dnl
466 AC_ARG_VAR([CPP], [C preprocessor])dnl
467 _AC_ARG_VAR_CPPFLAGS()dnl
469 AC_MSG_CHECKING([how to run the C preprocessor])
470 # On Suns, sometimes $CPP names a directory.
471 if test -n "$CPP" && test -d "$CPP"; then
474 if test -z "$CPP"; then
475 AC_CACHE_VAL([ac_cv_prog_CPP],
477 # Double quotes because CPP needs to be expanded
478 for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
480 _AC_PROG_PREPROC_WORKS_IFELSE([break])
488 AC_MSG_RESULT([$CPP])
489 _AC_PROG_PREPROC_WORKS_IFELSE([],
490 [AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])])
497 # Treat warnings from the preprocessor as errors.
498 AC_DEFUN([AC_PROG_CPP_WERROR],
499 [AC_REQUIRE([AC_PROG_CPP])dnl
500 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
502 # AC_LANG_COMPILER(C)
503 # -------------------
504 # Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
505 AC_DEFUN([AC_LANG_COMPILER(C)],
506 [AC_REQUIRE([AC_PROG_CC])])
511 # We used to name the cache variable this way.
512 AU_DEFUN([ac_cv_prog_gcc],
513 [ac_cv_c_compiler_gnu])
516 # AC_PROG_CC([COMPILER ...])
517 # --------------------------
518 # COMPILER ... is a space separated list of C compilers to search for.
519 # This just gives the user an opportunity to specify an alternative
520 # search list for the C compiler.
521 AN_MAKEVAR([CC], [AC_PROG_CC])
522 AN_PROGRAM([cc], [AC_PROG_CC])
523 AN_PROGRAM([gcc], [AC_PROG_CC])
524 AC_DEFUN([AC_PROG_CC],
526 AC_ARG_VAR([CC], [C compiler command])dnl
527 AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
528 _AC_ARG_VAR_LDFLAGS()dnl
529 _AC_ARG_VAR_LIBS()dnl
530 _AC_ARG_VAR_CPPFLAGS()dnl
532 [AC_CHECK_TOOLS(CC, [$1])],
533 [AC_CHECK_TOOL(CC, gcc)
534 if test -z "$CC"; then
536 dnl AC_CHECK_TOOL(CC, cc)
537 dnl but without the check for a tool without the prefix.
538 dnl Until the check is removed from there, copy the code:
539 if test -n "$ac_tool_prefix"; then
540 AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
543 if test -z "$CC"; then
544 AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
546 if test -z "$CC"; then
547 AC_CHECK_TOOLS(CC, cl.exe)
551 test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
553 # Provide some information about the compiler.
554 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
557 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
558 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
559 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
561 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
562 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
563 _AC_LANG_COMPILER_GNU
564 if test $ac_compiler_gnu = yes; then
577 # Check whether -g works, even if CFLAGS is set, in case the package
578 # plays around with CFLAGS (such as to build both debugging and normal
579 # versions of a library), tasteless as that idea is.
580 # Don't consider -g to work if it generates warnings when plain compiles don't.
581 m4_define([_AC_PROG_CC_G],
582 [ac_test_CFLAGS=${CFLAGS+set}
583 ac_save_CFLAGS=$CFLAGS
584 AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g,
585 [ac_save_c_werror_flag=$ac_c_werror_flag
589 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
590 [ac_cv_prog_cc_g=yes],
592 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
594 [ac_c_werror_flag=$ac_save_c_werror_flag
596 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
597 [ac_cv_prog_cc_g=yes])])])
598 ac_c_werror_flag=$ac_save_c_werror_flag])
599 if test "$ac_test_CFLAGS" = set; then
600 CFLAGS=$ac_save_CFLAGS
601 elif test $ac_cv_prog_cc_g = yes; then
602 if test "$GCC" = yes; then
608 if test "$GCC" = yes; then
617 # AC_PROG_GCC_TRADITIONAL
618 # -----------------------
619 AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
620 [AC_REQUIRE([AC_PROG_CC])dnl
621 if test $ac_cv_c_compiler_gnu = yes; then
622 AC_CACHE_CHECK(whether $CC needs -traditional,
623 ac_cv_prog_gcc_traditional,
624 [ ac_pattern="Autoconf.*'x'"
625 AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
627 ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
629 if test $ac_cv_prog_gcc_traditional = no; then
630 AC_EGREP_CPP($ac_pattern, [#include <termio.h>
632 ac_cv_prog_gcc_traditional=yes)
634 if test $ac_cv_prog_gcc_traditional = yes; then
635 CC="$CC -traditional"
638 ])# AC_PROG_GCC_TRADITIONAL
643 AC_DEFUN([AC_PROG_CC_C_O],
644 [AC_REQUIRE([AC_PROG_CC])dnl
645 if test "x$CC" != xcc; then
646 AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
648 AC_MSG_CHECKING([whether cc understands -c and -o together])
650 set dummy $CC; ac_cc=`AS_ECHO(["$[2]"]) |
651 sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
652 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
653 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
654 # Make sure it works both with $CC and with simple cc.
655 # We do the test twice because some compilers refuse to overwrite an
656 # existing .o file with -o, though they will create one.
657 ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
659 if _AC_DO_VAR(ac_try) &&
660 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
662 eval ac_cv_prog_cc_${ac_cc}_c_o=yes
663 if test "x$CC" != xcc; then
664 # Test first that cc exists at all.
665 if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
666 ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
668 if _AC_DO_VAR(ac_try) &&
669 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
674 # cc exists but doesn't like -o.
675 eval ac_cv_prog_cc_${ac_cc}_c_o=no
680 eval ac_cv_prog_cc_${ac_cc}_c_o=no
684 if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
688 AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
689 [Define to 1 if your C compiler doesn't accept -c and -o together.])
694 # ---------------------- #
695 # 3c. The C++ compiler. #
696 # ---------------------- #
699 # AC_LANG_PREPROC(C++)
700 # ---------------------
701 # Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
702 AC_DEFUN([AC_LANG_PREPROC(C++)],
703 [AC_REQUIRE([AC_PROG_CXXCPP])])
708 # Find a working C++ preprocessor.
709 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
710 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
711 AC_DEFUN([AC_PROG_CXXCPP],
712 [AC_REQUIRE([AC_PROG_CXX])dnl
713 AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl
714 _AC_ARG_VAR_CPPFLAGS()dnl
716 AC_MSG_CHECKING([how to run the C++ preprocessor])
717 if test -z "$CXXCPP"; then
718 AC_CACHE_VAL(ac_cv_prog_CXXCPP,
720 # Double quotes because CXXCPP needs to be expanded
721 for CXXCPP in "$CXX -E" "/lib/cpp"
723 _AC_PROG_PREPROC_WORKS_IFELSE([break])
725 ac_cv_prog_CXXCPP=$CXXCPP
727 CXXCPP=$ac_cv_prog_CXXCPP
729 ac_cv_prog_CXXCPP=$CXXCPP
731 AC_MSG_RESULT([$CXXCPP])
732 _AC_PROG_PREPROC_WORKS_IFELSE([],
733 [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])])
739 # AC_LANG_COMPILER(C++)
740 # ---------------------
741 # Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
742 AC_DEFUN([AC_LANG_COMPILER(C++)],
743 [AC_REQUIRE([AC_PROG_CXX])])
748 # We used to name the cache variable this way.
749 AU_DEFUN([ac_cv_prog_gxx],
750 [ac_cv_cxx_compiler_gnu])
753 # AC_PROG_CXX([LIST-OF-COMPILERS])
754 # --------------------------------
755 # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
756 # for (if not specified, a default list is used). This just gives the
757 # user an opportunity to specify an alternative search list for the C++
759 # aCC HP-UX C++ compiler much better than `CC', so test before.
760 # FCC Fujitsu C++ compiler
761 # KCC KAI C++ compiler
763 # xlC_r AIX C Set++ (with support for reentrant code)
765 AN_MAKEVAR([CXX], [AC_PROG_CXX])
766 AN_PROGRAM([CC], [AC_PROG_CXX])
767 AN_PROGRAM([c++], [AC_PROG_CXX])
768 AN_PROGRAM([g++], [AC_PROG_CXX])
769 AC_DEFUN([AC_PROG_CXX],
770 [AC_LANG_PUSH(C++)dnl
771 AC_ARG_VAR([CXX], [C++ compiler command])dnl
772 AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
773 _AC_ARG_VAR_LDFLAGS()dnl
774 _AC_ARG_VAR_LIBS()dnl
775 _AC_ARG_VAR_CPPFLAGS()dnl
776 _AC_ARG_VAR_PRECIOUS([CCC])dnl
777 if test -z "$CXX"; then
778 if test -n "$CCC"; then
783 [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])],
787 # Provide some information about the compiler.
788 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
791 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
792 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
793 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
795 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
796 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
797 _AC_LANG_COMPILER_GNU
798 if test $ac_compiler_gnu = yes; then
810 # Check whether -g works, even if CXXFLAGS is set, in case the package
811 # plays around with CXXFLAGS (such as to build both debugging and
812 # normal versions of a library), tasteless as that idea is.
813 # Don't consider -g to work if it generates warnings when plain compiles don't.
814 m4_define([_AC_PROG_CXX_G],
815 [ac_test_CXXFLAGS=${CXXFLAGS+set}
816 ac_save_CXXFLAGS=$CXXFLAGS
817 AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
818 [ac_save_cxx_werror_flag=$ac_cxx_werror_flag
819 ac_cxx_werror_flag=yes
822 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
823 [ac_cv_prog_cxx_g=yes],
825 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
827 [ac_cxx_werror_flag=$ac_save_cxx_werror_flag
829 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
830 [ac_cv_prog_cxx_g=yes])])])
831 ac_cxx_werror_flag=$ac_save_cxx_werror_flag])
832 if test "$ac_test_CXXFLAGS" = set; then
833 CXXFLAGS=$ac_save_CXXFLAGS
834 elif test $ac_cv_prog_cxx_g = yes; then
835 if test "$GXX" = yes; then
841 if test "$GXX" = yes; then
852 # Test if the C++ compiler accepts the options `-c' and `-o'
853 # simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not.
854 AC_DEFUN([AC_PROG_CXX_C_O],
855 [AC_REQUIRE([AC_PROG_CXX])dnl
856 AC_LANG_PUSH([C++])dnl
857 AC_CACHE_CHECK([whether $CXX understands -c and -o together],
858 [ac_cv_prog_cxx_c_o],
859 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
860 # We test twice because some compilers refuse to overwrite an existing
861 # `.o' file with `-o', although they will create one.
862 ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
864 if _AC_DO_VAR(ac_try) &&
865 test -f conftest2.$ac_objext &&
866 _AC_DO_VAR(ac_try); then
867 ac_cv_prog_cxx_c_o=yes
869 ac_cv_prog_cxx_c_o=no
872 if test $ac_cv_prog_cxx_c_o = no; then
873 AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1,
874 [Define to 1 if your C++ compiler doesn't accept
875 -c and -o together.])
877 AC_LANG_POP([C++])dnl
881 # ------------------------------ #
882 # 3d. The Objective C compiler. #
883 # ------------------------------ #
886 # AC_LANG_PREPROC(Objective C)
887 # ----------------------------
888 # Find the Objective C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
889 AC_DEFUN([AC_LANG_PREPROC(Objective C)],
890 [AC_REQUIRE([AC_PROG_OBJCPP])])
895 # Find a working Objective C preprocessor.
896 AC_DEFUN([AC_PROG_OBJCPP],
897 [AC_REQUIRE([AC_PROG_OBJC])dnl
898 AC_ARG_VAR([OBJCPP], [Objective C preprocessor])dnl
899 _AC_ARG_VAR_CPPFLAGS()dnl
900 AC_LANG_PUSH(Objective C)dnl
901 AC_MSG_CHECKING([how to run the Objective C preprocessor])
902 if test -z "$OBJCPP"; then
903 AC_CACHE_VAL(ac_cv_prog_OBJCPP,
905 # Double quotes because OBJCPP needs to be expanded
906 for OBJCPP in "$OBJC -E" "/lib/cpp"
908 _AC_PROG_PREPROC_WORKS_IFELSE([break])
910 ac_cv_prog_OBJCPP=$OBJCPP
912 OBJCPP=$ac_cv_prog_OBJCPP
914 ac_cv_prog_OBJCPP=$OBJCPP
916 AC_MSG_RESULT([$OBJCPP])
917 _AC_PROG_PREPROC_WORKS_IFELSE([],
918 [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])])
920 AC_LANG_POP(Objective C)dnl
924 # AC_LANG_COMPILER(Objective C)
925 # -----------------------------
926 # Find the Objective C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
927 AC_DEFUN([AC_LANG_COMPILER(Objective C)],
928 [AC_REQUIRE([AC_PROG_OBJC])])
932 # AC_PROG_OBJC([LIST-OF-COMPILERS])
933 # ---------------------------------
934 # LIST-OF-COMPILERS is a space separated list of Objective C compilers to
935 # search for (if not specified, a default list is used). This just gives
936 # the user an opportunity to specify an alternative search list for the
937 # Objective C compiler.
938 # objcc StepStone Objective-C compiler (also "standard" name for OBJC)
939 # objc David Stes' POC. If you installed this, you likely want it.
940 # cc Native C compiler (for instance, Apple).
942 AN_MAKEVAR([OBJC], [AC_PROG_OBJC])
943 AN_PROGRAM([objcc], [AC_PROG_OBJC])
944 AN_PROGRAM([objc], [AC_PROG_OBJC])
945 AC_DEFUN([AC_PROG_OBJC],
946 [AC_LANG_PUSH(Objective C)dnl
947 AC_ARG_VAR([OBJC], [Objective C compiler command])dnl
948 AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl
949 _AC_ARG_VAR_LDFLAGS()dnl
950 _AC_ARG_VAR_LIBS()dnl
951 _AC_ARG_VAR_CPPFLAGS()dnl
952 _AC_ARG_VAR_PRECIOUS([OBJC])dnl
954 [m4_default([$1], [gcc objcc objc cc CC])],
956 # Provide some information about the compiler.
957 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
960 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
961 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
962 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
964 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
965 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
966 _AC_LANG_COMPILER_GNU
967 if test $ac_compiler_gnu = yes; then
973 AC_LANG_POP(Objective C)dnl
979 # Check whether -g works, even if OBJCFLAGS is set, in case the package
980 # plays around with OBJCFLAGS (such as to build both debugging and
981 # normal versions of a library), tasteless as that idea is.
982 # Don't consider -g to work if it generates warnings when plain compiles don't.
983 m4_define([_AC_PROG_OBJC_G],
984 [ac_test_OBJCFLAGS=${OBJCFLAGS+set}
985 ac_save_OBJCFLAGS=$OBJCFLAGS
986 AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g,
987 [ac_save_objc_werror_flag=$ac_objc_werror_flag
988 ac_objc_werror_flag=yes
991 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
992 [ac_cv_prog_objc_g=yes],
994 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
996 [ac_objc_werror_flag=$ac_save_objc_werror_flag
998 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
999 [ac_cv_prog_objc_g=yes])])])
1000 ac_objc_werror_flag=$ac_save_objc_werror_flag])
1001 if test "$ac_test_OBJCFLAGS" = set; then
1002 OBJCFLAGS=$ac_save_OBJCFLAGS
1003 elif test $ac_cv_prog_objc_g = yes; then
1004 if test "$GOBJC" = yes; then
1010 if test "$GOBJC" = yes; then
1023 ## ------------------------------- ##
1024 ## 4. Compilers' characteristics. ##
1025 ## ------------------------------- ##
1028 # -------------------------------- #
1029 # 4b. C compiler characteristics. #
1030 # -------------------------------- #
1032 # _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1033 # ----------------------------------------------------------------
1034 # If the C compiler is not in ANSI C89 (ISO C90) mode by default, try
1035 # to add an option to output variable CC to make it so. This macro
1036 # tries various options that select ANSI C89 on some system or
1037 # another. It considers the compiler to be in ANSI C89 mode if it
1038 # handles function prototypes correctly.
1039 AC_DEFUN([_AC_PROG_CC_C89],
1040 [_AC_C_STD_TRY([c89],
1041 [[#include <stdarg.h>
1043 #include <sys/types.h>
1044 #include <sys/stat.h>
1045 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
1046 struct buf { int x; };
1047 FILE * (*rcsopen) (struct buf *, struct stat *, int);
1048 static char *e (p, i)
1054 static char *f (char * (*g) (char **, int), char **p, ...)
1059 s = g (p, va_arg (v,int));
1064 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
1065 function prototypes and stuff, but not '\xHH' hex character constants.
1066 These don't provoke an error unfortunately, instead are silently treated
1067 as 'x'. The following induces an error, until -std is added to get
1068 proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
1069 array size at least. It's necessary to write '\x00'==0 to get something
1070 that's true only with -std. */
1071 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
1073 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
1074 inside strings and character constants. */
1076 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
1078 int test (int i, double x);
1079 struct s1 {int (*f) (int a);};
1080 struct s2 {int (*f) (double a);};
1081 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
1084 [[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]],
1085 dnl Don't try gcc -ansi; that turns off useful extensions and
1086 dnl breaks some systems' header files.
1087 dnl AIX circa 2003 -qlanglvl=extc89
1088 dnl old AIX -qlanglvl=ansi
1089 dnl Ultrix, OSF/1, Tru64 -std
1090 dnl HP-UX 10.20 and later -Ae
1091 dnl HP-UX older versions -Aa -D_HPUX_SOURCE
1092 dnl SVR4 -Xc -D__EXTENSIONS__
1093 [-qlanglvl=extc89 -qlanglvl=ansi -std \
1094 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl
1098 # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
1099 # ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
1100 # --------------------------------------------------------------
1101 # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
1102 # by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails,
1103 # try again with each compiler option in the space-separated OPTION-LIST; if one
1104 # helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE,
1105 # else ACTION-IF-UNAVAILABLE.
1106 AC_DEFUN([_AC_C_STD_TRY],
1107 [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
1108 AC_CACHE_VAL(ac_cv_prog_cc_$1,
1109 [ac_cv_prog_cc_$1=no
1111 AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
1114 CC="$ac_save_CC $ac_arg"
1115 _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
1116 test "x$ac_cv_prog_cc_$1" != "xno" && break
1118 rm -f conftest.$ac_ext
1121 case "x$ac_cv_prog_cc_$1" in
1123 AC_MSG_RESULT([none needed]) ;;
1125 AC_MSG_RESULT([unsupported]) ;;
1127 CC="$CC $ac_cv_prog_cc_$1"
1128 AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
1130 AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
1134 # _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1135 # ----------------------------------------------------------------
1136 # If the C compiler is not in ISO C99 mode by default, try to add an
1137 # option to output variable CC to make it so. This macro tries
1138 # various options that select ISO C99 on some system or another. It
1139 # considers the compiler to be in ISO C99 mode if it handles _Bool,
1140 # // comments, flexible array members, inline, long long int, mixed
1141 # code and declarations, named initialization of structs, restrict,
1142 # va_copy, varargs macros, variable declarations in for loops and
1143 # variable length arrays.
1144 AC_DEFUN([_AC_PROG_CC_C99],
1145 [_AC_C_STD_TRY([c99],
1146 [[#include <stdarg.h>
1147 #include <stdbool.h>
1152 // Check varargs macros. These examples are taken from C99 6.10.3.5.
1153 #define debug(...) fprintf (stderr, __VA_ARGS__)
1154 #define showlist(...) puts (#__VA_ARGS__)
1155 #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
1157 test_varargs_macros (void)
1162 debug ("X = %d\n", x);
1163 showlist (The first, second, and third items.);
1164 report (x>y, "x is %d but y is %d", x, y);
1167 // Check long long types.
1168 #define BIG64 18446744073709551615ull
1169 #define BIG32 4294967295ul
1170 #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
1172 your preprocessor is broken;
1176 your preprocessor is broken;
1178 static long long int bignum = -9223372036854775807LL;
1179 static unsigned long long int ubignum = BIG64;
1181 struct incomplete_array
1189 const wchar_t *name;
1193 typedef const char *ccp;
1196 test_restrict (ccp restrict text)
1198 // See if C++-style comments work.
1199 // Iterate through items via the restricted pointer.
1200 // Also check for declarations in for loops.
1201 for (unsigned int i = 0; *(text+i) != '\0'; ++i)
1206 // Check varargs and va_copy.
1208 test_varargs (const char *format, ...)
1211 va_start (args, format);
1213 va_copy (args_copy, args);
1224 str = va_arg (args_copy, const char *);
1227 number = va_arg (args_copy, int);
1230 fnumber = va_arg (args_copy, double);
1242 _Bool success = false;
1245 if (test_restrict ("String literal") == 0)
1247 char *restrict newvar = "Another string";
1250 test_varargs ("s, d' f .", "string", 65, 34.234);
1251 test_varargs_macros ();
1253 // Check flexible array members.
1254 struct incomplete_array *ia =
1255 malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
1257 for (int i = 0; i < ia->datasize; ++i)
1258 ia->data[i] = i * 1.234;
1260 // Check named initializers.
1261 struct named_init ni = {
1263 .name = L"Test wide string",
1264 .average = 543.34343,
1269 int dynamic_array[ni.number];
1270 dynamic_array[ni.number - 1] = 543;
1272 // work around unused variable warnings
1273 return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
1274 || dynamic_array[ni.number - 1] != 543);
1277 dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
1278 dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
1281 dnl Solaris -xc99=all (Forte Developer 7 C mishandles -xc99 on Solaris 9,
1282 dnl as it incorrectly assumes C99 semantics for library functions)
1284 dnl with extended modes being tried first.
1285 [[-std=gnu99 -c99 -xc99=all -qlanglvl=extc99]], [$1], [$2])[]dnl
1291 AC_DEFUN([AC_PROG_CC_C89],
1292 [ AC_REQUIRE([AC_PROG_CC])dnl
1299 AC_DEFUN([AC_PROG_CC_C99],
1300 [ AC_REQUIRE([AC_PROG_CC])dnl
1307 AC_DEFUN([AC_PROG_CC_STDC],
1308 [ AC_REQUIRE([AC_PROG_CC])dnl
1309 AS_CASE([$ac_cv_prog_cc_stdc],
1310 [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
1311 [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
1312 [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
1313 [ac_cv_prog_cc_stdc=no])])])dnl
1314 AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
1315 AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
1316 AS_CASE([$ac_cv_prog_cc_stdc],
1317 [no], [AC_MSG_RESULT([unsupported])],
1318 [''], [AC_MSG_RESULT([none needed])],
1319 [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
1325 AC_DEFUN([AC_C_BACKSLASH_A],
1327 AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a,
1328 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1333 char buf['\a' == 'a' ? -1 : 1];
1335 return buf[0] != "\a"[0];
1337 [ac_cv_c_backslash_a=yes],
1338 [ac_cv_c_backslash_a=no])])
1339 if test $ac_cv_c_backslash_a = yes; then
1340 AC_DEFINE(HAVE_C_BACKSLASH_A, 1,
1341 [Define if backslash-a works in C strings.])
1348 # Has been merged into AC_PROG_CC.
1349 AU_DEFUN([AC_C_CROSS], [])
1352 # AC_C_CHAR_UNSIGNED
1353 # ------------------
1354 AC_DEFUN([AC_C_CHAR_UNSIGNED],
1355 [AH_VERBATIM([__CHAR_UNSIGNED__],
1356 [/* Define to 1 if type `char' is unsigned and you are not using gcc. */
1357 #ifndef __CHAR_UNSIGNED__
1358 # undef __CHAR_UNSIGNED__
1360 AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1361 [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
1362 [((char) -1) < 0])],
1363 ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
1364 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1365 AC_DEFINE(__CHAR_UNSIGNED__)
1367 ])# AC_C_CHAR_UNSIGNED
1370 # AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN],
1371 # [ACTION-IF-UNIVERSAL])
1372 # -------------------------------------------------------------------------
1373 AC_DEFUN([AC_C_BIGENDIAN],
1374 [AH_VERBATIM([WORDS_BIGENDIAN],
1375 [/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
1376 significant byte first (like Motorola and SPARC, unlike Intel and VAX). */
1377 #if defined __BIG_ENDIAN__
1378 # define WORDS_BIGENDIAN 1
1379 #elif ! defined __LITTLE_ENDIAN__
1380 /* #undef WORDS_BIGENDIAN */
1382 AC_CACHE_CHECK([whether byte ordering is bigendian], [ac_cv_c_bigendian],
1383 [ac_cv_c_bigendian=unknown
1384 # See if __BIG_ENDIAN__ or __LITTLE_ENDIAN__ is defined.
1387 [[#if ! (defined __BIG_ENDIAN__ || defined __LITTLE_ENDIAN__)
1392 [ac_cv_c_bigendian=universal])
1393 if test $ac_cv_c_bigendian = unknown; then
1394 # See if sys/param.h defines the BYTE_ORDER macro.
1397 [[#include <sys/types.h>
1398 #include <sys/param.h>
1400 [[#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
1401 && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
1406 [# It does; now see whether it defined to BIG_ENDIAN or not.
1409 [[#include <sys/types.h>
1410 #include <sys/param.h>
1412 [[#if BYTE_ORDER != BIG_ENDIAN
1416 [ac_cv_c_bigendian=yes],
1417 [ac_cv_c_bigendian=no])])
1419 if test $ac_cv_c_bigendian = unknown; then
1420 # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
1423 [[#include <limits.h>
1425 [[#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
1429 [# It does; now see whether it defined to _BIG_ENDIAN or not.
1432 [[#include <limits.h>
1434 [[#ifndef _BIG_ENDIAN
1438 [ac_cv_c_bigendian=yes],
1439 [ac_cv_c_bigendian=no])])
1441 if test $ac_cv_c_bigendian = unknown; then
1442 # Compile a test program.
1444 [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],
1446 /* Are we little or big endian? From Harbison&Steele. */
1450 char c[sizeof (long int)];
1453 return u.c[sizeof (long int) - 1] == 1;
1455 [ac_cv_c_bigendian=no],
1456 [ac_cv_c_bigendian=yes],
1457 [# Try to guess by grepping values from an object file.
1460 [[short int ascii_mm[] =
1461 { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
1462 short int ascii_ii[] =
1463 { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
1464 int use_ascii (int i) {
1465 return ascii_mm[i] + ascii_ii[i];
1467 short int ebcdic_ii[] =
1468 { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
1469 short int ebcdic_mm[] =
1470 { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
1471 int use_ebcdic (int i) {
1472 return ebcdic_mm[i] + ebcdic_ii[i];
1476 [[return use_ascii (foo) == use_ebcdic (foo);]])],
1477 [if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
1478 ac_cv_c_bigendian=yes
1480 if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
1481 if test "$ac_cv_c_bigendian" = unknown; then
1482 ac_cv_c_bigendian=no
1484 # finding both strings is unlikely to happen, but who knows?
1485 ac_cv_c_bigendian=unknown
1489 case $ac_cv_c_bigendian in #(
1492 [AC_DEFINE([WORDS_BIGENDIAN], 1)]);; #(
1499 [AC_MSG_ERROR([unknown endianness
1500 presetting ac_cv_c_bigendian=no (or yes) will help])]) ;;
1507 # Do nothing if the compiler accepts the inline keyword.
1508 # Otherwise define inline to __inline__ or __inline if one of those work,
1509 # otherwise define inline to be empty.
1511 # HP C version B.11.11.04 doesn't allow a typedef as the return value for an
1512 # inline function, only builtin types.
1514 AN_IDENTIFIER([inline], [AC_C_INLINE])
1515 AC_DEFUN([AC_C_INLINE],
1516 [AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1518 for ac_kw in inline __inline__ __inline; do
1519 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1520 [#ifndef __cplusplus
1522 static $ac_kw foo_t static_foo () {return 0; }
1523 $ac_kw foo_t foo () {return 0; }
1526 [ac_cv_c_inline=$ac_kw])
1527 test "$ac_cv_c_inline" != no && break
1530 AH_VERBATIM([inline],
1531 [/* Define to `__inline__' or `__inline' if that's what the C compiler
1532 calls it, or to nothing if 'inline' is not supported under any name. */
1536 case $ac_cv_c_inline in
1539 case $ac_cv_c_inline in
1541 *) ac_val=$ac_cv_c_inline;;
1543 cat >>confdefs.h <<_ACEOF
1545 #define inline $ac_val
1555 AC_DEFUN([AC_C_CONST],
1556 [AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
1557 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1558 [[/* FIXME: Include the comments suggested by Paul. */
1560 /* Ultrix mips cc rejects this. */
1561 typedef int charset[2];
1563 /* SunOS 4.1.1 cc rejects this. */
1564 char const *const *pcpcc;
1566 /* NEC SVR4.0.2 mips cc rejects this. */
1567 struct point {int x, y;};
1568 static struct point const zero = {0,0};
1569 /* AIX XL C 1.02.0.0 rejects this.
1570 It does not let you subtract one const X* pointer from another in
1571 an arm of an if-expression whose if-part is not a constant
1573 const char *g = "string";
1574 pcpcc = &g + (g ? g-g : 0);
1575 /* HPUX 7.0 cc rejects these. */
1577 ppc = (char**) pcpcc;
1578 pcpcc = (char const *const *) ppc;
1579 { /* SCO 3.2v4 cc rejects this. */
1581 char const *s = 0 ? (char *) 0 : (char const *) 0;
1586 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
1588 const int *foo = &x[0];
1591 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
1592 typedef const int *iptr;
1596 { /* AIX XL C 1.02.0.0 rejects this saying
1597 "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
1598 struct s { int j; const int *ap[3]; };
1599 struct s *b; b->j = 5;
1601 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
1605 return !cs[0] && !zero.x;
1608 [ac_cv_c_const=yes],
1609 [ac_cv_c_const=no])])
1610 if test $ac_cv_c_const = no; then
1612 [Define to empty if `const' does not conform to ANSI C.])
1619 # based on acx_restrict.m4, from the GNU Autoconf Macro Archive at:
1620 # http://autoconf-archive.cryp.to/acx_restrict.html
1622 # Determine whether the C/C++ compiler supports the "restrict" keyword
1623 # introduced in ANSI C99, or an equivalent. Do nothing if the compiler
1624 # accepts it. Otherwise, if the compiler supports an equivalent,
1625 # define "restrict" to be that. Here are some variants:
1626 # - GCC supports both __restrict and __restrict__
1627 # - older DEC Alpha C compilers support only __restrict
1628 # - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C
1629 # Otherwise, define "restrict" to be empty.
1630 AN_IDENTIFIER([restrict], [AC_C_RESTRICT])
1631 AC_DEFUN([AC_C_RESTRICT],
1632 [AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
1633 [ac_cv_c_restrict=no
1634 # Try the official restrict keyword, then gcc's __restrict, and
1635 # the less common variants.
1636 for ac_kw in restrict __restrict __restrict__ _Restrict; do
1637 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1638 [[typedef int * int_ptr;
1639 int foo (int_ptr $ac_kw ip) {
1646 [ac_cv_c_restrict=$ac_kw])
1647 test "$ac_cv_c_restrict" != no && break
1650 case $ac_cv_c_restrict in
1652 no) AC_DEFINE(restrict,,
1653 [Define to equivalent of C99 restrict keyword, or to nothing if this
1654 is not supported. Do not define if restrict is supported directly.]) ;;
1655 *) AC_DEFINE_UNQUOTED(restrict, $ac_cv_c_restrict) ;;
1662 # Note that, unlike const, #defining volatile to be the empty string can
1663 # actually turn a correct program into an incorrect one, since removing
1664 # uses of volatile actually grants the compiler permission to perform
1665 # optimizations that could break the user's code. So, do not #define
1666 # volatile away unless it is really necessary to allow the user's code
1667 # to compile cleanly. Benign compiler failures should be tolerated.
1668 AC_DEFUN([AC_C_VOLATILE],
1669 [AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
1670 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1672 int * volatile y = (int *) 0;
1673 return !x && !y;])],
1674 [ac_cv_c_volatile=yes],
1675 [ac_cv_c_volatile=no])])
1676 if test $ac_cv_c_volatile = no; then
1677 AC_DEFINE(volatile,,
1678 [Define to empty if the keyword `volatile' does not work.
1679 Warning: valid code using `volatile' can become incorrect
1680 without. Disable with care.])
1687 # Checks if `#' can be used to glue strings together at the CPP level.
1688 # Defines HAVE_STRINGIZE if positive.
1689 AC_DEFUN([AC_C_STRINGIZE],
1690 [AC_CACHE_CHECK([for preprocessor stringizing operator],
1691 [ac_cv_c_stringize],
1692 [AC_EGREP_CPP([@%:@teststring],
1695 char *s = x(teststring);],
1696 [ac_cv_c_stringize=no],
1697 [ac_cv_c_stringize=yes])])
1698 if test $ac_cv_c_stringize = yes; then
1699 AC_DEFINE(HAVE_STRINGIZE, 1,
1700 [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.])
1707 # Check if the C compiler supports prototypes, included if it needs
1709 AC_DEFUN([AC_C_PROTOTYPES],
1710 [AC_REQUIRE([AC_PROG_CC])dnl
1711 AC_MSG_CHECKING([for function prototypes])
1712 if test "$ac_cv_prog_cc_c89" != no; then
1713 AC_MSG_RESULT([yes])
1714 AC_DEFINE(PROTOTYPES, 1,
1715 [Define to 1 if the C compiler supports function prototypes.])
1716 AC_DEFINE(__PROTOTYPES, 1,
1717 [Define like PROTOTYPES; this can be used by system headers.])
1724 # AC_C_FLEXIBLE_ARRAY_MEMBER
1725 # --------------------------
1726 # Check whether the C compiler supports flexible array members.
1727 AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER],
1729 AC_CACHE_CHECK([for flexible array members],
1733 [[#include <stdlib.h>
1736 struct s { int n; double d[]; };]],
1737 [[int m = getchar ();
1738 struct s *p = malloc (offsetof (struct s, d)
1739 + m * sizeof (double));
1741 return p->d != (double *) NULL;]])],
1742 [ac_cv_c_flexmember=yes],
1743 [ac_cv_c_flexmember=no])])
1744 if test $ac_cv_c_flexmember = yes; then
1745 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [],
1746 [Define to nothing if C supports flexible array members, and to
1747 1 if it does not. That way, with a declaration like `struct s
1748 { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
1749 can be used with pre-C99 compilers.
1750 When computing the size of such an object, don't use 'sizeof (struct s)'
1751 as it overestimates the size. Use 'offsetof (struct s, d)' instead.
1752 Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with
1753 MSVC and with C++ compilers.])
1755 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1)
1762 # Check whether the C compiler supports variable-length arrays.
1763 AC_DEFUN([AC_C_VARARRAYS],
1765 AC_CACHE_CHECK([for variable-length arrays],
1768 [AC_LANG_PROGRAM([],
1769 [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])],
1770 [ac_cv_c_vararrays=yes],
1771 [ac_cv_c_vararrays=no])])
1772 if test $ac_cv_c_vararrays = yes; then
1773 AC_DEFINE([HAVE_C_VARARRAYS], 1,
1774 [Define to 1 if C supports variable-length arrays.])
1781 # Check if the C compiler supports GCC's typeof syntax.
1782 # The test case provokes incompatibilities in the Sun C compilers
1783 # (both Solaris 8 and Solaris 10).
1784 AC_DEFUN([AC_C_TYPEOF],
1786 AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof,
1788 for ac_kw in typeof __typeof__ no; do
1789 test $ac_kw = no && break
1790 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1795 + ! (($ac_kw (value))
1796 (($ac_kw (value)) 0 < ($ac_kw (value)) -1
1797 ? ($ac_kw (value)) - 1
1798 : ~ (~ ($ac_kw (value)) 0
1799 << sizeof ($ac_kw (value)))))]; }
1802 (! ((void) ((ac__typeof_type_ *) 0), 0));
1804 [ac_cv_c_typeof=$ac_kw])
1805 test $ac_cv_c_typeof != no && break
1807 if test $ac_cv_c_typeof != no; then
1808 AC_DEFINE([HAVE_TYPEOF], 1,
1809 [Define to 1 if typeof works with your compiler.])
1810 if test $ac_cv_c_typeof != typeof; then
1811 AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof],
1812 [Define to __typeof__ if your compiler spells it that way.])