| blob | 2f9c8fc883fc26b460e420ce100c1053f0ee48ac |
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.
54 # -------------------- #
55 # 1b. The C language. #
56 # -------------------- #
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 ])
71 # AC_LANG_C
72 # ---------
73 AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
76 # _AC_LANG_ABBREV(C)
77 # ------------------
78 m4_define([_AC_LANG_ABBREV(C)], [c])
81 # _AC_LANG_PREFIX(C)
82 # ------------------
83 m4_define([_AC_LANG_PREFIX(C)], [C])
86 # ---------------------- #
87 # 1c. The C++ language. #
88 # ---------------------- #
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 ])
103 # AC_LANG_CPLUSPLUS
104 # -----------------
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)],
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 ])
135 # AC_LANG_OBJC
136 # ------------
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 ## ---------------------- ##
156 # --------------- #
157 # 2b. C sources. #
158 # --------------- #
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])
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 }])
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 ();])])
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
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. */
232 #ifdef __STDC__
233 # include <limits.h>
234 #else
235 # include <assert.h>
236 #endif
238 #undef $1
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 ();])])
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 ])])
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 ])])
300 # ----------------- #
301 # 2c. C++ sources. #
302 # ----------------- #
304 # AC_LANG_SOURCE(C++)(BODY)
305 # -------------------------
306 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
309 # AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
310 # ----------------------------------------
311 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
314 # AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
315 # -------------------------------------
316 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
319 # AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
320 # ------------------------------------
321 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
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++)])
329 # AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
330 # -------------------------------------------
331 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
335 # ------------------------- #
336 # 2d. Objective C sources. #
337 # ------------------------- #
339 # AC_LANG_SOURCE(Objective C)(BODY)
340 # ---------------------------------
341 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)])
344 # AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY])
345 # ------------------------------------------------
346 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)])
349 # AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION)
350 # ---------------------------------------------
351 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)])
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)])
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)])
364 # AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION)
365 # ---------------------------------------------------
366 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)])
370 ## -------------------------------------------- ##
371 ## 3. Looking for Compilers and Preprocessors. ##
372 ## -------------------------------------------- ##
374 # -------------------- #
375 # 3b. The C compiler. #
376 # -------------------- #
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>])])
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>])])
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>])])
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])])
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])
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])
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
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
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
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])])
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])
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 ])
549 test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
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])
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
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
610 # AC_PROG_GCC_TRADITIONAL
611 # -----------------------
612 AN_FUNCTION([ioctl], [AC_PROG_GCC_TRADITIONAL])
613 AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
614 [if test $ac_cv_c_compiler_gnu = yes; then
615 AC_CACHE_CHECK(whether $CC needs -traditional,
616 ac_cv_prog_gcc_traditional,
617 [ ac_pattern="Autoconf.*'x'"
618 AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
619 Autoconf TIOCGETP],
620 ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
622 if test $ac_cv_prog_gcc_traditional = no; then
623 AC_EGREP_CPP($ac_pattern, [#include <termio.h>
624 Autoconf TCGETA],
625 ac_cv_prog_gcc_traditional=yes)
626 fi])
627 if test $ac_cv_prog_gcc_traditional = yes; then
628 CC="$CC -traditional"
629 fi
630 fi
631 ])# AC_PROG_GCC_TRADITIONAL
634 # AC_PROG_CC_C_O
635 # --------------
636 AC_DEFUN([AC_PROG_CC_C_O],
637 [AC_REQUIRE([AC_PROG_CC])dnl
638 if test "x$CC" != xcc; then
639 AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
640 else
641 AC_MSG_CHECKING([whether cc understands -c and -o together])
642 fi
643 set dummy $CC; ac_cc=`echo $[2] |
644 sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
645 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
646 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
647 # Make sure it works both with $CC and with simple cc.
648 # We do the test twice because some compilers refuse to overwrite an
649 # existing .o file with -o, though they will create one.
650 ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
651 rm -f conftest2.*
652 if _AC_DO_VAR(ac_try) &&
653 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
654 then
655 eval ac_cv_prog_cc_${ac_cc}_c_o=yes
656 if test "x$CC" != xcc; then
657 # Test first that cc exists at all.
658 if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
659 ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
660 rm -f conftest2.*
661 if _AC_DO_VAR(ac_try) &&
662 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
663 then
664 # cc works too.
665 :
666 else
667 # cc exists but doesn't like -o.
668 eval ac_cv_prog_cc_${ac_cc}_c_o=no
669 fi
670 fi
671 fi
672 else
673 eval ac_cv_prog_cc_${ac_cc}_c_o=no
674 fi
675 rm -f core conftest*
676 ])dnl
677 if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
678 AC_MSG_RESULT([yes])
679 else
680 AC_MSG_RESULT([no])
681 AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
682 [Define to 1 if your C compiler doesn't accept -c and -o together.])
683 fi
684 ])# AC_PROG_CC_C_O
687 # ---------------------- #
688 # 3c. The C++ compiler. #
689 # ---------------------- #
692 # AC_LANG_PREPROC(C++)
693 # ---------------------
694 # Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
695 AC_DEFUN([AC_LANG_PREPROC(C++)],
696 [AC_REQUIRE([AC_PROG_CXXCPP])])
699 # AC_PROG_CXXCPP
700 # --------------
701 # Find a working C++ preprocessor.
702 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
703 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
704 AC_DEFUN([AC_PROG_CXXCPP],
705 [AC_REQUIRE([AC_PROG_CXX])dnl
706 AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl
707 _AC_ARG_VAR_CPPFLAGS()dnl
708 AC_LANG_PUSH(C++)dnl
709 AC_MSG_CHECKING([how to run the C++ preprocessor])
710 if test -z "$CXXCPP"; then
711 AC_CACHE_VAL(ac_cv_prog_CXXCPP,
712 [dnl
713 # Double quotes because CXXCPP needs to be expanded
714 for CXXCPP in "$CXX -E" "/lib/cpp"
715 do
716 _AC_PROG_PREPROC_WORKS_IFELSE([break])
717 done
718 ac_cv_prog_CXXCPP=$CXXCPP
719 ])dnl
720 CXXCPP=$ac_cv_prog_CXXCPP
721 else
722 ac_cv_prog_CXXCPP=$CXXCPP
723 fi
724 AC_MSG_RESULT([$CXXCPP])
725 _AC_PROG_PREPROC_WORKS_IFELSE([],
726 [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])])
727 AC_SUBST(CXXCPP)dnl
728 AC_LANG_POP(C++)dnl
729 ])# AC_PROG_CXXCPP
732 # AC_LANG_COMPILER(C++)
733 # ---------------------
734 # Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
735 AC_DEFUN([AC_LANG_COMPILER(C++)],
736 [AC_REQUIRE([AC_PROG_CXX])])
739 # ac_cv_prog_gxx
740 # --------------
741 # We used to name the cache variable this way.
742 AU_DEFUN([ac_cv_prog_gxx],
743 [ac_cv_cxx_compiler_gnu])
746 # AC_PROG_CXX([LIST-OF-COMPILERS])
747 # --------------------------------
748 # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
749 # for (if not specified, a default list is used). This just gives the
750 # user an opportunity to specify an alternative search list for the C++
751 # compiler.
752 # aCC HP-UX C++ compiler much better than `CC', so test before.
753 # FCC Fujitsu C++ compiler
754 # KCC KAI C++ compiler
755 # RCC Rational C++
756 # xlC_r AIX C Set++ (with support for reentrant code)
757 # xlC AIX C Set++
758 AN_MAKEVAR([CXX], [AC_PROG_CXX])
759 AN_PROGRAM([CC], [AC_PROG_CXX])
760 AN_PROGRAM([c++], [AC_PROG_CXX])
761 AN_PROGRAM([g++], [AC_PROG_CXX])
762 AC_DEFUN([AC_PROG_CXX],
763 [AC_LANG_PUSH(C++)dnl
764 AC_ARG_VAR([CXX], [C++ compiler command])dnl
765 AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
766 _AC_ARG_VAR_LDFLAGS()dnl
767 _AC_ARG_VAR_LIBS()dnl
768 _AC_ARG_VAR_CPPFLAGS()dnl
769 _AC_ARG_VAR_PRECIOUS([CCC])dnl
770 if test -z "$CXX"; then
771 if test -n "$CCC"; then
772 CXX=$CCC
773 else
774 AC_CHECK_TOOLS(CXX,
775 [m4_default([$1],
776 [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])],
777 g++)
778 fi
779 fi
780 # Provide some information about the compiler.
781 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
782 ac_compiler=`set X $ac_compile; echo $[2]`
783 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
784 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
785 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
787 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
788 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
789 _AC_LANG_COMPILER_GNU
790 GXX=`test $ac_compiler_gnu = yes && echo yes`
791 _AC_PROG_CXX_G
792 AC_LANG_POP(C++)dnl
793 ])# AC_PROG_CXX
796 # _AC_PROG_CXX_G
797 # --------------
798 # Check whether -g works, even if CXXFLAGS is set, in case the package
799 # plays around with CXXFLAGS (such as to build both debugging and
800 # normal versions of a library), tasteless as that idea is.
801 # Don't consider -g to work if it generates warnings when plain compiles don't.
802 m4_define([_AC_PROG_CXX_G],
803 [ac_test_CXXFLAGS=${CXXFLAGS+set}
804 ac_save_CXXFLAGS=$CXXFLAGS
805 AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
806 [ac_save_cxx_werror_flag=$ac_cxx_werror_flag
807 ac_cxx_werror_flag=yes
808 ac_cv_prog_cxx_g=no
809 CXXFLAGS="-g"
810 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
811 [ac_cv_prog_cxx_g=yes],
812 [CXXFLAGS=""
813 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
814 [],
815 [ac_cxx_werror_flag=$ac_save_cxx_werror_flag
816 CXXFLAGS="-g"
817 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
818 [ac_cv_prog_cxx_g=yes])])])
819 ac_cxx_werror_flag=$ac_save_cxx_werror_flag])
820 if test "$ac_test_CXXFLAGS" = set; then
821 CXXFLAGS=$ac_save_CXXFLAGS
822 elif test $ac_cv_prog_cxx_g = yes; then
823 if test "$GXX" = yes; then
824 CXXFLAGS="-g -O2"
825 else
826 CXXFLAGS="-g"
827 fi
828 else
829 if test "$GXX" = yes; then
830 CXXFLAGS="-O2"
831 else
832 CXXFLAGS=
833 fi
834 fi[]dnl
835 ])# _AC_PROG_CXX_G
838 # AC_PROG_CXX_C_O
839 # ---------------
840 # Test if the C++ compiler accepts the options `-c' and `-o'
841 # simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not.
842 AC_DEFUN([AC_PROG_CXX_C_O],
843 [AC_REQUIRE([AC_PROG_CXX])dnl
844 AC_LANG_PUSH([C++])dnl
845 AC_CACHE_CHECK([whether $CXX understands -c and -o together],
846 [ac_cv_prog_cxx_c_o],
847 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
848 # We test twice because some compilers refuse to overwrite an existing
849 # `.o' file with `-o', although they will create one.
850 ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
851 rm -f conftest2.*
852 if _AC_DO_VAR(ac_try) &&
853 test -f conftest2.$ac_objext &&
854 _AC_DO_VAR(ac_try); then
855 ac_cv_prog_cxx_c_o=yes
856 else
857 ac_cv_prog_cxx_c_o=no
858 fi
859 rm -f conftest*])
860 if test $ac_cv_prog_cxx_c_o = no; then
861 AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1,
862 [Define to 1 if your C++ compiler doesn't accept
863 -c and -o together.])
864 fi
865 AC_LANG_POP([C++])dnl
866 ])# AC_PROG_CXX_C_O
869 # ------------------------------ #
870 # 3d. The Objective C compiler. #
871 # ------------------------------ #
874 # AC_LANG_PREPROC(Objective C)
875 # ----------------------------
876 # Find the Objective C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
877 AC_DEFUN([AC_LANG_PREPROC(Objective C)],
878 [AC_REQUIRE([AC_PROG_OBJCPP])])
881 # AC_PROG_OBJCPP
882 # --------------
883 # Find a working Objective C preprocessor.
884 AC_DEFUN([AC_PROG_OBJCPP],
885 [AC_REQUIRE([AC_PROG_OBJC])dnl
886 AC_ARG_VAR([OBJCPP], [Objective C preprocessor])dnl
887 _AC_ARG_VAR_CPPFLAGS()dnl
888 AC_LANG_PUSH(Objective C)dnl
889 AC_MSG_CHECKING([how to run the Objective C preprocessor])
890 if test -z "$OBJCPP"; then
891 AC_CACHE_VAL(ac_cv_prog_OBJCPP,
892 [dnl
893 # Double quotes because OBJCPP needs to be expanded
894 for OBJCPP in "$OBJC -E" "/lib/cpp"
895 do
896 _AC_PROG_PREPROC_WORKS_IFELSE([break])
897 done
898 ac_cv_prog_OBJCPP=$OBJCPP
899 ])dnl
900 OBJCPP=$ac_cv_prog_OBJCPP
901 else
902 ac_cv_prog_OBJCPP=$OBJCPP
903 fi
904 AC_MSG_RESULT([$OBJCPP])
905 _AC_PROG_PREPROC_WORKS_IFELSE([],
906 [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])])
907 AC_SUBST(OBJCPP)dnl
908 AC_LANG_POP(Objective C)dnl
909 ])# AC_PROG_OBJCPP
912 # AC_LANG_COMPILER(Objective C)
913 # -----------------------------
914 # Find the Objective C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able.
915 AC_DEFUN([AC_LANG_COMPILER(Objective C)],
916 [AC_REQUIRE([AC_PROG_OBJC])])
920 # AC_PROG_OBJC([LIST-OF-COMPILERS])
921 # ---------------------------------
922 # LIST-OF-COMPILERS is a space separated list of Objective C compilers to
923 # search for (if not specified, a default list is used). This just gives
924 # the user an opportunity to specify an alternative search list for the
925 # Objective C compiler.
926 # objcc StepStone Objective-C compiler (also "standard" name for OBJC)
927 # objc David Stes' POC. If you installed this, you likely want it.
928 # cc Native C compiler (for instance, Apple).
929 # CC You never know.
930 AN_MAKEVAR([OBJC], [AC_PROG_OBJC])
931 AN_PROGRAM([objcc], [AC_PROG_OBJC])
932 AN_PROGRAM([objc], [AC_PROG_OBJC])
933 AC_DEFUN([AC_PROG_OBJC],
934 [AC_LANG_PUSH(Objective C)dnl
935 AC_ARG_VAR([OBJC], [Objective C compiler command])dnl
936 AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl
937 _AC_ARG_VAR_LDFLAGS()dnl
938 _AC_ARG_VAR_LIBS()dnl
939 _AC_ARG_VAR_CPPFLAGS()dnl
940 _AC_ARG_VAR_PRECIOUS([OBJC])dnl
941 AC_CHECK_TOOLS(OBJC,
942 [m4_default([$1], [gcc objcc objc cc CC])],
943 gcc)
944 # Provide some information about the compiler.
945 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
946 ac_compiler=`set X $ac_compile; echo $[2]`
947 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
948 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
949 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
951 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
952 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
953 _AC_LANG_COMPILER_GNU
954 GOBJC=`test $ac_compiler_gnu = yes && echo yes`
955 _AC_PROG_OBJC_G
956 AC_LANG_POP(Objective C)dnl
957 ])# AC_PROG_OBJC
960 # _AC_PROG_OBJC_G
961 # ---------------
962 # Check whether -g works, even if OBJCFLAGS is set, in case the package
963 # plays around with OBJCFLAGS (such as to build both debugging and
964 # normal versions of a library), tasteless as that idea is.
965 # Don't consider -g to work if it generates warnings when plain compiles don't.
966 m4_define([_AC_PROG_OBJC_G],
967 [ac_test_OBJCFLAGS=${OBJCFLAGS+set}
968 ac_save_OBJCFLAGS=$OBJCFLAGS
969 AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g,
970 [ac_save_objc_werror_flag=$ac_objc_werror_flag
971 ac_objc_werror_flag=yes
972 ac_cv_prog_objc_g=no
973 OBJCFLAGS="-g"
974 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
975 [ac_cv_prog_objc_g=yes],
976 [OBJCFLAGS=""
977 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
978 [],
979 [ac_objc_werror_flag=$ac_save_objc_werror_flag
980 OBJCFLAGS="-g"
981 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
982 [ac_cv_prog_objc_g=yes])])])
983 ac_objc_werror_flag=$ac_save_objc_werror_flag])
984 if test "$ac_test_OBJCFLAGS" = set; then
985 OBJCFLAGS=$ac_save_OBJCFLAGS
986 elif test $ac_cv_prog_objc_g = yes; then
987 if test "$GOBJC" = yes; then
988 OBJCFLAGS="-g -O2"
989 else
990 OBJCFLAGS="-g"
991 fi
992 else
993 if test "$GOBJC" = yes; then
994 OBJCFLAGS="-O2"
995 else
996 OBJCFLAGS=
997 fi
998 fi[]dnl
999 ])# _AC_PROG_OBJC_G
1006 ## ------------------------------- ##
1007 ## 4. Compilers' characteristics. ##
1008 ## ------------------------------- ##
1011 # -------------------------------- #
1012 # 4b. C compiler characteristics. #
1013 # -------------------------------- #
1015 # _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1016 # ----------------------------------------------------------------
1017 # If the C compiler is not in ANSI C89 (ISO C90) mode by default, try
1018 # to add an option to output variable CC to make it so. This macro
1019 # tries various options that select ANSI C89 on some system or
1020 # another. It considers the compiler to be in ANSI C89 mode if it
1021 # handles function prototypes correctly.
1022 AC_DEFUN([_AC_PROG_CC_C89],
1023 [_AC_C_STD_TRY([c89],
1024 [[#include <stdarg.h>
1025 #include <stdio.h>
1026 #include <sys/types.h>
1027 #include <sys/stat.h>
1028 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
1029 struct buf { int x; };
1030 FILE * (*rcsopen) (struct buf *, struct stat *, int);
1031 static char *e (p, i)
1032 char **p;
1033 int i;
1034 {
1035 return p[i];
1036 }
1037 static char *f (char * (*g) (char **, int), char **p, ...)
1038 {
1039 char *s;
1040 va_list v;
1041 va_start (v,p);
1042 s = g (p, va_arg (v,int));
1043 va_end (v);
1044 return s;
1045 }
1047 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
1048 function prototypes and stuff, but not '\xHH' hex character constants.
1049 These don't provoke an error unfortunately, instead are silently treated
1050 as 'x'. The following induces an error, until -std is added to get
1051 proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
1052 array size at least. It's necessary to write '\x00'==0 to get something
1053 that's true only with -std. */
1054 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
1056 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
1057 inside strings and character constants. */
1058 #define FOO(x) 'x'
1059 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
1061 int test (int i, double x);
1062 struct s1 {int (*f) (int a);};
1063 struct s2 {int (*f) (double a);};
1064 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
1065 int argc;
1066 char **argv;]],
1067 [[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]],
1068 dnl Don't try gcc -ansi; that turns off useful extensions and
1069 dnl breaks some systems' header files.
1070 dnl AIX circa 2003 -qlanglvl=extc89
1071 dnl old AIX -qlanglvl=ansi
1072 dnl Ultrix, OSF/1, Tru64 -std
1073 dnl HP-UX 10.20 and later -Ae
1074 dnl HP-UX older versions -Aa -D_HPUX_SOURCE
1075 dnl SVR4 -Xc -D__EXTENSIONS__
1076 [-qlanglvl=extc89 -qlanglvl=ansi -std \
1077 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl
1078 ])# _AC_PROG_CC_C89
1081 # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
1082 # ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
1083 # --------------------------------------------------------------
1084 # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
1085 # by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails,
1086 # try again with each compiler option in the space-separated OPTION-LIST; if one
1087 # helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE,
1088 # else ACTION-IF-UNAVAILABLE.
1089 AC_DEFUN([_AC_C_STD_TRY],
1090 [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
1091 AC_CACHE_VAL(ac_cv_prog_cc_$1,
1092 [ac_cv_prog_cc_$1=no
1093 ac_save_CC=$CC
1094 AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
1095 for ac_arg in '' $4
1096 do
1097 CC="$ac_save_CC $ac_arg"
1098 _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
1099 test "x$ac_cv_prog_cc_$1" != "xno" && break
1100 done
1101 rm -f conftest.$ac_ext
1102 CC=$ac_save_CC
1103 ])# AC_CACHE_VAL
1104 case "x$ac_cv_prog_cc_$1" in
1105 x)
1106 AC_MSG_RESULT([none needed]) ;;
1107 xno)
1108 AC_MSG_RESULT([unsupported]) ;;
1109 *)
1110 CC="$CC $ac_cv_prog_cc_$1"
1111 AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
1112 esac
1113 AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
1114 ])# _AC_C_STD_TRY
1117 # _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1118 # ----------------------------------------------------------------
1119 # If the C compiler is not in ISO C99 mode by default, try to add an
1120 # option to output variable CC to make it so. This macro tries
1121 # various options that select ISO C99 on some system or another. It
1122 # considers the compiler to be in ISO C99 mode if it handles _Bool,
1123 # // comments, flexible array members, inline, long long int, mixed
1124 # code and declarations, named initialization of structs, restrict,
1125 # va_copy, varargs macros, variable declarations in for loops and
1126 # variable length arrays.
1127 AC_DEFUN([_AC_PROG_CC_C99],
1128 [_AC_C_STD_TRY([c99],
1129 [[#include <stdarg.h>
1130 #include <stdbool.h>
1131 #include <stdlib.h>
1132 #include <wchar.h>
1133 #include <stdio.h>
1135 // Check varargs macros. These examples are taken from C99 6.10.3.5.
1136 #define debug(...) fprintf (stderr, __VA_ARGS__)
1137 #define showlist(...) puts (#__VA_ARGS__)
1138 #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
1139 static void
1140 test_varargs_macros (void)
1141 {
1142 int x = 1234;
1143 int y = 5678;
1144 debug ("Flag");
1145 debug ("X = %d\n", x);
1146 showlist (The first, second, and third items.);
1147 report (x>y, "x is %d but y is %d", x, y);
1148 }
1150 // Check long long types.
1151 #define BIG64 18446744073709551615ull
1152 #define BIG32 4294967295ul
1153 #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
1154 #if !BIG_OK
1155 your preprocessor is broken;
1156 #endif
1157 #if BIG_OK
1158 #else
1159 your preprocessor is broken;
1160 #endif
1161 static long long int bignum = -9223372036854775807LL;
1162 static unsigned long long int ubignum = BIG64;
1164 struct incomplete_array
1165 {
1166 int datasize;
1167 double data[];
1168 };
1170 struct named_init {
1171 int number;
1172 const wchar_t *name;
1173 double average;
1174 };
1176 typedef const char *ccp;
1178 static inline int
1179 test_restrict (ccp restrict text)
1180 {
1181 // See if C++-style comments work.
1182 // Iterate through items via the restricted pointer.
1183 // Also check for declarations in for loops.
1184 for (unsigned int i = 0; *(text+i) != '\0'; ++i)
1185 continue;
1186 return 0;
1187 }
1189 // Check varargs and va_copy.
1190 static void
1191 test_varargs (const char *format, ...)
1192 {
1193 va_list args;
1194 va_start (args, format);
1195 va_list args_copy;
1196 va_copy (args_copy, args);
1198 const char *str;
1199 int number;
1200 float fnumber;
1202 while (*format)
1203 {
1204 switch (*format++)
1205 {
1206 case 's': // string
1207 str = va_arg (args_copy, const char *);
1208 break;
1209 case 'd': // int
1210 number = va_arg (args_copy, int);
1211 break;
1212 case 'f': // float
1213 fnumber = va_arg (args_copy, double);
1214 break;
1215 default:
1216 break;
1217 }
1218 }
1219 va_end (args_copy);
1220 va_end (args);
1221 }
1222 ]],
1223 [[
1224 // Check bool.
1225 _Bool success = false;
1227 // Check restrict.
1228 if (test_restrict ("String literal") == 0)
1229 success = true;
1230 char *restrict newvar = "Another string";
1232 // Check varargs.
1233 test_varargs ("s, d' f .", "string", 65, 34.234);
1234 test_varargs_macros ();
1236 // Check flexible array members.
1237 struct incomplete_array *ia =
1238 malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
1239 ia->datasize = 10;
1240 for (int i = 0; i < ia->datasize; ++i)
1241 ia->data[i] = i * 1.234;
1243 // Check named initializers.
1244 struct named_init ni = {
1245 .number = 34,
1246 .name = L"Test wide string",
1247 .average = 543.34343,
1248 };
1250 ni.number = 58;
1252 int dynamic_array[ni.number];
1253 dynamic_array[ni.number - 1] = 543;
1255 // work around unused variable warnings
1256 return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
1257 || dynamic_array[ni.number - 1] != 543);
1258 ]],
1259 dnl Try
1260 dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
1261 dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
1262 dnl Intel ICC -c99
1263 dnl IRIX -c99
1264 dnl Solaris (unused because it causes the compiler to assume C99 semantics for
1265 dnl library functions, and this is invalid before Solaris 10: -xc99)
1266 dnl Tru64 -c99
1267 dnl with extended modes being tried first.
1268 [[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl
1269 ])# _AC_PROG_CC_C99
1272 # AC_PROG_CC_C89
1273 # --------------
1274 AC_DEFUN([AC_PROG_CC_C89],
1275 [ AC_REQUIRE([AC_PROG_CC])dnl
1276 _AC_PROG_CC_C89
1277 ])
1280 # AC_PROG_CC_C99
1281 # --------------
1282 AC_DEFUN([AC_PROG_CC_C99],
1283 [ AC_REQUIRE([AC_PROG_CC])dnl
1284 _AC_PROG_CC_C99
1285 ])
1288 # AC_PROG_CC_STDC
1289 # ---------------
1290 AC_DEFUN([AC_PROG_CC_STDC],
1291 [ AC_REQUIRE([AC_PROG_CC])dnl
1292 AS_CASE([$ac_cv_prog_cc_stdc],
1293 [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
1294 [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
1295 [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
1296 [ac_cv_prog_cc_stdc=no])])])dnl
1297 AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
1298 AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
1299 AS_CASE([$ac_cv_prog_cc_stdc],
1300 [no], [AC_MSG_RESULT([unsupported])],
1301 [''], [AC_MSG_RESULT([none needed])],
1302 [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
1303 ])
1306 # AC_C_BACKSLASH_A
1307 # ----------------
1308 AC_DEFUN([AC_C_BACKSLASH_A],
1309 [
1310 AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a,
1311 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1312 [[
1313 #if '\a' == 'a'
1314 syntax error;
1315 #endif
1316 char buf['\a' == 'a' ? -1 : 1];
1317 buf[0] = '\a';
1318 return buf[0] != "\a"[0];
1319 ]])],
1320 [ac_cv_c_backslash_a=yes],
1321 [ac_cv_c_backslash_a=no])])
1322 if test $ac_cv_c_backslash_a = yes; then
1323 AC_DEFINE(HAVE_C_BACKSLASH_A, 1,
1324 [Define if backslash-a works in C strings.])
1325 fi
1326 ])
1329 # AC_C_CROSS
1330 # ----------
1331 # Has been merged into AC_PROG_CC.
1332 AU_DEFUN([AC_C_CROSS], [])
1335 # AC_C_CHAR_UNSIGNED
1336 # ------------------
1337 AC_DEFUN([AC_C_CHAR_UNSIGNED],
1338 [AH_VERBATIM([__CHAR_UNSIGNED__],
1339 [/* Define to 1 if type `char' is unsigned and you are not using gcc. */
1340 #ifndef __CHAR_UNSIGNED__
1341 # undef __CHAR_UNSIGNED__
1342 #endif])dnl
1343 AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1344 [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
1345 [((char) -1) < 0])],
1346 ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
1347 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1348 AC_DEFINE(__CHAR_UNSIGNED__)
1349 fi
1350 ])# AC_C_CHAR_UNSIGNED
1353 # AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN])
1354 # -------------------------------------------------------------------------
1355 AC_DEFUN([AC_C_BIGENDIAN],
1356 [AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
1357 [# See if sys/param.h defines the BYTE_ORDER macro.
1358 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1359 #include <sys/param.h>
1360 ],
1361 [#if ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
1362 && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
1363 bogus endian macros
1364 #endif
1365 ])],
1366 [# It does; now see whether it defined to BIG_ENDIAN or not.
1367 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1368 #include <sys/param.h>
1369 ], [#if BYTE_ORDER != BIG_ENDIAN
1370 not big endian
1371 #endif
1372 ])], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=no])],
1373 [# It does not; compile a test program.
1374 AC_RUN_IFELSE(
1375 [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [[
1376 /* Are we little or big endian? From Harbison&Steele. */
1377 union
1378 {
1379 long int l;
1380 char c[sizeof (long int)];
1381 } u;
1382 u.l = 1;
1383 return u.c[sizeof (long int) - 1] == 1;
1384 ]])],
1385 [ac_cv_c_bigendian=no],
1386 [ac_cv_c_bigendian=yes],
1387 [# try to guess the endianness by grepping values into an object file
1388 ac_cv_c_bigendian=unknown
1389 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1390 [[short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
1391 short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
1392 void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
1393 short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
1394 short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
1395 void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }]],
1396 [[ _ascii (); _ebcdic (); ]])],
1397 [if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
1398 ac_cv_c_bigendian=yes
1399 fi
1400 if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
1401 if test "$ac_cv_c_bigendian" = unknown; then
1402 ac_cv_c_bigendian=no
1403 else
1404 # finding both strings is unlikely to happen, but who knows?
1405 ac_cv_c_bigendian=unknown
1406 fi
1407 fi])])])])
1408 case $ac_cv_c_bigendian in
1409 yes)
1410 m4_default([$1],
1411 [AC_DEFINE([WORDS_BIGENDIAN], 1,
1412 [Define to 1 if your processor stores words with the most significant
1413 byte first (like Motorola and SPARC, unlike Intel and VAX).])]) ;;
1414 no)
1415 $2 ;;
1416 *)
1417 m4_default([$3],
1418 [AC_MSG_ERROR([unknown endianness
1419 presetting ac_cv_c_bigendian=no (or yes) will help])]) ;;
1420 esac
1421 ])# AC_C_BIGENDIAN
1424 # AC_C_INLINE
1425 # -----------
1426 # Do nothing if the compiler accepts the inline keyword.
1427 # Otherwise define inline to __inline__ or __inline if one of those work,
1428 # otherwise define inline to be empty.
1429 #
1430 # HP C version B.11.11.04 doesn't allow a typedef as the return value for an
1431 # inline function, only builtin types.
1432 #
1433 AN_IDENTIFIER([inline], [AC_C_INLINE])
1434 AC_DEFUN([AC_C_INLINE],
1435 [AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1436 [ac_cv_c_inline=no
1437 for ac_kw in inline __inline__ __inline; do
1438 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1439 [#ifndef __cplusplus
1440 typedef int foo_t;
1441 static $ac_kw foo_t static_foo () {return 0; }
1442 $ac_kw foo_t foo () {return 0; }
1443 #endif
1444 ])],
1445 [ac_cv_c_inline=$ac_kw])
1446 test "$ac_cv_c_inline" != no && break
1447 done
1448 ])
1449 AH_VERBATIM([inline],
1450 [/* Define to `__inline__' or `__inline' if that's what the C compiler
1451 calls it, or to nothing if 'inline' is not supported under any name. */
1452 #ifndef __cplusplus
1453 #undef inline
1454 #endif])
1455 case $ac_cv_c_inline in
1456 inline | yes) ;;
1457 *)
1458 case $ac_cv_c_inline in
1459 no) ac_val=;;
1460 *) ac_val=$ac_cv_c_inline;;
1461 esac
1462 cat >>confdefs.h <<_ACEOF
1463 #ifndef __cplusplus
1464 #define inline $ac_val
1465 #endif
1466 _ACEOF
1467 ;;
1468 esac
1469 ])# AC_C_INLINE
1472 # AC_C_CONST
1473 # ----------
1474 AN_IDENTIFIER([const], [AC_C_CONST])
1475 AC_DEFUN([AC_C_CONST],
1476 [AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
1477 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1478 [[/* FIXME: Include the comments suggested by Paul. */
1479 #ifndef __cplusplus
1480 /* Ultrix mips cc rejects this. */
1481 typedef int charset[2];
1482 const charset cs;
1483 /* SunOS 4.1.1 cc rejects this. */
1484 char const *const *pcpcc;
1485 char **ppc;
1486 /* NEC SVR4.0.2 mips cc rejects this. */
1487 struct point {int x, y;};
1488 static struct point const zero = {0,0};
1489 /* AIX XL C 1.02.0.0 rejects this.
1490 It does not let you subtract one const X* pointer from another in
1491 an arm of an if-expression whose if-part is not a constant
1492 expression */
1493 const char *g = "string";
1494 pcpcc = &g + (g ? g-g : 0);
1495 /* HPUX 7.0 cc rejects these. */
1496 ++pcpcc;
1497 ppc = (char**) pcpcc;
1498 pcpcc = (char const *const *) ppc;
1499 { /* SCO 3.2v4 cc rejects this. */
1500 char *t;
1501 char const *s = 0 ? (char *) 0 : (char const *) 0;
1503 *t++ = 0;
1504 if (s) return 0;
1505 }
1506 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */
1507 int x[] = {25, 17};
1508 const int *foo = &x[0];
1509 ++foo;
1510 }
1511 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
1512 typedef const int *iptr;
1513 iptr p = 0;
1514 ++p;
1515 }
1516 { /* AIX XL C 1.02.0.0 rejects this saying
1517 "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
1518 struct s { int j; const int *ap[3]; };
1519 struct s *b; b->j = 5;
1520 }
1521 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
1522 const int foo = 10;
1523 if (!foo) return 0;
1524 }
1525 return !cs[0] && !zero.x;
1526 #endif
1527 ]])],
1528 [ac_cv_c_const=yes],
1529 [ac_cv_c_const=no])])
1530 if test $ac_cv_c_const = no; then
1531 AC_DEFINE(const,,
1532 [Define to empty if `const' does not conform to ANSI C.])
1533 fi
1534 ])# AC_C_CONST
1537 # AC_C_RESTRICT
1538 # -------------
1539 # based on acx_restrict.m4, from the GNU Autoconf Macro Archive at:
1540 # http://autoconf-archive.cryp.to/acx_restrict.html
1541 #
1542 # Determine whether the C/C++ compiler supports the "restrict" keyword
1543 # introduced in ANSI C99, or an equivalent. Do nothing if the compiler
1544 # accepts it. Otherwise, if the compiler supports an equivalent,
1545 # define "restrict" to be that. Here are some variants:
1546 # - GCC supports both __restrict and __restrict__
1547 # - older DEC Alpha C compilers support only __restrict
1548 # - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C
1549 # Otherwise, define "restrict" to be empty.
1550 AN_IDENTIFIER([restrict], [AC_C_RESTRICT])
1551 AC_DEFUN([AC_C_RESTRICT],
1552 [AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
1553 [ac_cv_c_restrict=no
1554 # Try the official restrict keyword, then gcc's __restrict, and
1555 # the less common variants.
1556 for ac_kw in restrict __restrict __restrict__ _Restrict; do
1557 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1558 [[typedef int * int_ptr;
1559 int foo (int_ptr $ac_kw ip) {
1560 return ip[0];
1561 }]],
1562 [[int s[1];
1563 int * $ac_kw t = s;
1564 t[0] = 0;
1565 return foo(t)]])],
1566 [ac_cv_c_restrict=$ac_kw])
1567 test "$ac_cv_c_restrict" != no && break
1568 done
1569 ])
1570 case $ac_cv_c_restrict in
1571 restrict) ;;
1572 no) AC_DEFINE(restrict,,
1573 [Define to equivalent of C99 restrict keyword, or to nothing if this
1574 is not supported. Do not define if restrict is supported directly.]) ;;
1575 *) AC_DEFINE_UNQUOTED(restrict, $ac_cv_c_restrict) ;;
1576 esac
1577 ])# AC_C_RESTRICT
1580 # AC_C_VOLATILE
1581 # -------------
1582 # Note that, unlike const, #defining volatile to be the empty string can
1583 # actually turn a correct program into an incorrect one, since removing
1584 # uses of volatile actually grants the compiler permission to perform
1585 # optimizations that could break the user's code. So, do not #define
1586 # volatile away unless it is really necessary to allow the user's code
1587 # to compile cleanly. Benign compiler failures should be tolerated.
1588 AN_IDENTIFIER([volatile], [AC_C_VOLATILE])
1589 AC_DEFUN([AC_C_VOLATILE],
1590 [AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
1591 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1592 volatile int x;
1593 int * volatile y = (int *) 0;
1594 return !x && !y;])],
1595 [ac_cv_c_volatile=yes],
1596 [ac_cv_c_volatile=no])])
1597 if test $ac_cv_c_volatile = no; then
1598 AC_DEFINE(volatile,,
1599 [Define to empty if the keyword `volatile' does not work.
1600 Warning: valid code using `volatile' can become incorrect
1601 without. Disable with care.])
1602 fi
1603 ])# AC_C_VOLATILE
1606 # AC_C_STRINGIZE
1607 # --------------
1608 # Checks if `#' can be used to glue strings together at the CPP level.
1609 # Defines HAVE_STRINGIZE if positive.
1610 AC_DEFUN([AC_C_STRINGIZE],
1611 [AC_CACHE_CHECK([for preprocessor stringizing operator],
1612 [ac_cv_c_stringize],
1613 [AC_EGREP_CPP([@%:@teststring],
1614 [@%:@define x(y) #y
1616 char *s = x(teststring);],
1617 [ac_cv_c_stringize=no],
1618 [ac_cv_c_stringize=yes])])
1619 if test $ac_cv_c_stringize = yes; then
1620 AC_DEFINE(HAVE_STRINGIZE, 1,
1621 [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.])
1622 fi
1623 ])# AC_C_STRINGIZE
1626 # AC_C_PROTOTYPES
1627 # ---------------
1628 # Check if the C compiler supports prototypes, included if it needs
1629 # options.
1630 AC_DEFUN([AC_C_PROTOTYPES],
1631 [AC_REQUIRE([AC_PROG_CC])dnl
1632 AC_MSG_CHECKING([for function prototypes])
1633 if test "$ac_cv_prog_cc_c89" != no; then
1634 AC_MSG_RESULT([yes])
1635 AC_DEFINE(PROTOTYPES, 1,
1636 [Define to 1 if the C compiler supports function prototypes.])
1637 AC_DEFINE(__PROTOTYPES, 1,
1638 [Define like PROTOTYPES; this can be used by system headers.])
1639 else
1640 AC_MSG_RESULT([no])
1641 fi
1642 ])# AC_C_PROTOTYPES
1645 # AC_C_TYPEOF
1646 # -----------
1647 # Check if the C compiler supports GCC's typeof syntax.
1648 # The test case provokes incompatibilities in the Sun C compilers
1649 # (both Solaris 8 and Solaris 10).
1650 AC_DEFUN([AC_C_TYPEOF],
1651 [
1652 AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof,
1653 [ac_cv_c_typeof=no
1654 for ac_kw in typeof __typeof__ no; do
1655 test $ac_kw = no && break
1656 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1657 [[
1658 int value;
1659 typedef struct {
1660 char a [1
1661 + ! (($ac_kw (value))
1662 (($ac_kw (value)) 0 < ($ac_kw (value)) -1
1663 ? ($ac_kw (value)) - 1
1664 : ~ (~ ($ac_kw (value)) 0
1665 << sizeof ($ac_kw (value)))))]; }
1666 ac__typeof_type_;
1667 return
1668 (! ((void) ((ac__typeof_type_ *) 0), 0));
1669 ]])],
1670 [ac_cv_c_typeof=$ac_kw])
1671 test $ac_cv_c_typeof != no && break
1672 done])
1673 if test $ac_cv_c_typeof != no; then
1674 AC_DEFINE([HAVE_TYPEOF], 1,
1675 [Define to 1 if typeof works with your compiler.])
1676 if test $ac_cv_c_typeof != typeof; then
1677 AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof],
1678 [Define to __typeof__ if your compiler spells it that way.])
1679 fi
1680 fi
1681 ])