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