Mercurial > sdl-ios-xcode
changeset 3382:294fb5e6f301
A better solution to making the default build optimization -O3
Cygwin32 autoconf complains about c.m4 ... of course. :)
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Sun, 11 Oct 2009 10:38:38 +0000 |
| parents | c4d6458121db |
| children | 90935231e9b6 |
| files | acinclude/c.m4 configure.in |
| diffstat | 2 files changed, 7 insertions(+), 1958 deletions(-) [+] |
line wrap: on
line diff
--- a/acinclude/c.m4 Sun Oct 11 10:30:47 2009 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1958 +0,0 @@ -# This file is part of Autoconf. -*- Autoconf -*- -# Programming languages support. -# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free -# Software Foundation, Inc. -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2, or (at your option) -# any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -# 02110-1301, USA. -# -# As a special exception, the Free Software Foundation gives unlimited -# permission to copy, distribute and modify the configure scripts that -# are the output of Autoconf. You need not follow the terms of the GNU -# General Public License when using or distributing such scripts, even -# though portions of the text of Autoconf appear in them. The GNU -# General Public License (GPL) does govern all other use of the material -# that constitutes the Autoconf program. -# -# Certain portions of the Autoconf source text are designed to be copied -# (in certain cases, depending on the input) into the output of -# Autoconf. We call these the "data" portions. The rest of the Autoconf -# source text consists of comments plus executable code that decides which -# of the data portions to output in any given case. We call these -# comments and executable code the "non-data" portions. Autoconf never -# copies any of the non-data portions into its output. -# -# This special exception to the GPL applies to versions of Autoconf -# released by the Free Software Foundation. When you make and -# distribute a modified version of Autoconf, you may extend this special -# exception to the GPL to apply to your modified version as well, *unless* -# your modified version has the potential to copy into its output some -# of the text that was the non-data portion of the version that you started -# with. (In other words, unless your change moves or copies text from -# the non-data portions to the data portions.) If your modification has -# such potential, you must delete any notice of this special exception -# to the GPL from your modified version. -# -# Written by David MacKenzie, with help from -# Akim Demaille, Paul Eggert, -# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor, -# Roland McGrath, Noah Friedman, david d zuhn, and many others. - - -# Table of Contents: -# -# 1. Language selection -# and routines to produce programs in a given language. -# 1a. C 1b. C++ 1c. Objective C -# -# 2. Producing programs in a given language. -# 2a. C 2b. C++ 2c. Objective C -# -# 3. Looking for a compiler -# And possibly the associated preprocessor. -# 3a. C 3b. C++ 3c. Objective C -# -# 4. Compilers' characteristics. -# 4a. C - - - -## ----------------------- ## -## 1. Language selection. ## -## ----------------------- ## - -# -------------------- # -# 1a. The C language. # -# -------------------- # - - -# AC_LANG(C) -# ---------- -# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C)], -[ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -]) - - -# AC_LANG_C -# --------- -AU_DEFUN([AC_LANG_C], [AC_LANG(C)]) - - -# _AC_LANG_ABBREV(C) -# ------------------ -m4_define([_AC_LANG_ABBREV(C)], [c]) - - -# _AC_LANG_PREFIX(C) -# ------------------ -m4_define([_AC_LANG_PREFIX(C)], [C]) - - - -# ---------------------- # -# 1b. The C++ language. # -# ---------------------- # - - -# AC_LANG(C++) -# ------------ -# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C++)], -[ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -]) - - -# AC_LANG_CPLUSPLUS -# ----------------- -AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) - - -# _AC_LANG_ABBREV(C++) -# -------------------- -m4_define([_AC_LANG_ABBREV(C++)], [cxx]) - - -# _AC_LANG_PREFIX(C++) -# -------------------- -m4_define([_AC_LANG_PREFIX(C++)], [CXX]) - - - -# ------------------------------ # -# 1c. The Objective C language. # -# ------------------------------ # - - -# AC_LANG(Objective C) -# -------------------- -m4_define([AC_LANG(Objective C)], -[ac_ext=m -ac_cpp='$OBJCPP $CPPFLAGS' -ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_objc_compiler_gnu -]) - - -# AC_LANG_OBJC -# ------------ -AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)]) - - -# _AC_LANG_ABBREV(Objective C) -# ---------------------------- -m4_define([_AC_LANG_ABBREV(Objective C)], [objc]) - - -# _AC_LANG_PREFIX(Objective C) -# ---------------------------- -m4_define([_AC_LANG_PREFIX(Objective C)], [OBJC]) - - - -## ----------------------- ## -## 2. Producing programs. ## -## ----------------------- ## - -# --------------- # -# 2a. C sources. # -# --------------- # - - -# AC_LANG_SOURCE(C)(BODY) -# ----------------------- -# We can't use '#line $LINENO "configure"' here, since -# Sun c89 (Sun WorkShop 6 update 2 C 5.3 Patch 111679-08 2002/05/09) -# rejects $LINENO greater than 32767, and some configure scripts -# are longer than 32767 lines. -m4_define([AC_LANG_SOURCE(C)], -[/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -$1]) - - -# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) -# -------------------------------------- -m4_define([AC_LANG_PROGRAM(C)], -[$1 -m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS])[]dnl -m4_ifdef([_AC_LANG_PROGRAM_C_FC_HOOKS], [_AC_LANG_PROGRAM_C_FC_HOOKS])[]dnl -int -main () -{ -dnl Do *not* indent the following line: there may be CPP directives. -dnl Don't move the `;' right after for the same reason. -$2 - ; - return 0; -}]) - - -# AC_LANG_CALL(C)(PROLOGUE, FUNCTION) -# ----------------------------------- -# Avoid conflicting decl of main. -m4_define([AC_LANG_CALL(C)], -[AC_LANG_PROGRAM([$1 -m4_if([$2], [main], , -[/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char $2 ();])], [return $2 ();])]) - - -# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION) -# ---------------------------------- -# Don't include <ctype.h> because on OSF/1 3.0 it includes -# <sys/types.h> which includes <sys/select.h> which contains a -# prototype for select. Similarly for bzero. -# -# This test used to merely assign f=$1 in main(), but that was -# optimized away by HP unbundled cc A.05.36 for ia64 under +O3, -# presumably on the basis that there's no need to do that store if the -# program is about to exit. Conversely, the AIX linker optimizes an -# unused external declaration that initializes f=$1. So this test -# program has both an external initialization of f, and a use of f in -# main that affects the exit status. -# -m4_define([AC_LANG_FUNC_LINK_TRY(C)], -[AC_LANG_PROGRAM( -[/* Define $1 to an innocuous variant, in case <limits.h> declares $1. - For example, HP-UX 11i <limits.h> declares gettimeofday. */ -#define $1 innocuous_$1 - -/* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $1 (); below. - Prefer <limits.h> to <assert.h> if __STDC__ is defined, since - <limits.h> exists even on freestanding compilers. */ - -#ifdef __STDC__ -# include <limits.h> -#else -# include <assert.h> -#endif - -#undef $1 - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char $1 (); -/* The GNU C library defines this for functions which it implements - to always fail with ENOSYS. Some functions are actually named - something starting with __ and the normal name is an alias. */ -#if defined __stub_$1 || defined __stub___$1 -choke me -#endif -], [return $1 ();])]) - - -# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION) -# ------------------------------------------------- -# Return a program that is valid if EXPRESSION is nonzero. -# EXPRESSION must be an integer constant expression. -# Be sure to use this array to avoid `unused' warnings, which are even -# errors with `-W error'. -m4_define([AC_LANG_BOOL_COMPILE_TRY(C)], -[AC_LANG_PROGRAM([$1], [static int test_array @<:@1 - 2 * !($2)@:>@; -test_array @<:@0@:>@ = 0 -])]) - - -# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION) -# ----------------------------------------- -# We need `stdio.h' to open a `FILE' and `stdlib.h' for `exit'. -# But we include them only after the EXPRESSION has been evaluated. -m4_define([AC_LANG_INT_SAVE(C)], -[AC_LANG_PROGRAM([$1 -static long int longval () { return $2; } -static unsigned long int ulongval () { return $2; } -@%:@include <stdio.h> -@%:@include <stdlib.h>], -[ - FILE *f = fopen ("conftest.val", "w"); - if (! f) - return 1; - if (($2) < 0) - { - long int i = longval (); - if (i != ($2)) - return 1; - fprintf (f, "%ld", i); - } - else - { - unsigned long int i = ulongval (); - if (i != ($2)) - return 1; - fprintf (f, "%lu", i); - } - /* Do not output a trailing newline, as this causes \r\n confusion - on some platforms. */ - return ferror (f) || fclose (f) != 0; -])]) - - - -# ----------------- # -# 2b. C++ sources. # -# ----------------- # - - -# AC_LANG_SOURCE(C++)(BODY) -# ------------------------- -m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)]) - - -# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY]) -# ---------------------------------------- -m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)]) - - -# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION) -# ------------------------------------- -m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)]) - - -# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION) -# ------------------------------------ -m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)]) - - -# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION) -# --------------------------------------------------- -m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)]) - - -# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION) -# ------------------------------------------- -m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)]) - - - -# ------------------------- # -# 2c. Objective C sources. # -# ------------------------- # - - -# AC_LANG_SOURCE(Objective C)(BODY) -# --------------------------------- -m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)]) - - -# AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY]) -# ------------------------------------------------ -m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)]) - - -# AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION) -# --------------------------------------------- -m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)]) - - -# AC_LANG_FUNC_LINK_TRY(Objective C)(FUNCTION) -# -------------------------------------------- -m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(Objective C)]) - - -# AC_LANG_BOOL_COMPILE_TRY(Objective C)(PROLOGUE, EXPRESSION) -# ----------------------------------------------------------- -m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(Objective C)]) - - -# AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION) -# --------------------------------------------------- -m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)]) - - - -## -------------------------------------------- ## -## 3. Looking for Compilers and Preprocessors. ## -## -------------------------------------------- ## - -# -------------------- # -# 3a. The C compiler. # -# -------------------- # - - -# _AC_ARG_VAR_CPPFLAGS -# -------------------- -# Document and register CPPFLAGS, which is used by -# AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP}. -AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], -[AC_ARG_VAR([CPPFLAGS], - [C/C++/Objective C preprocessor flags, e.g. -I<include dir> - if you have headers in a nonstandard directory <include dir>])]) - - -# _AC_ARG_VAR_LDFLAGS -# ------------------- -# Document and register LDFLAGS, which is used by -# AC_PROG_{CC, CXX, F77, FC, OBJC}. -AC_DEFUN([_AC_ARG_VAR_LDFLAGS], -[AC_ARG_VAR([LDFLAGS], - [linker flags, e.g. -L<lib dir> if you have libraries in a - nonstandard directory <lib dir>])]) - - -# _AC_ARG_VAR_LIBS -# ---------------- -# Document and register LIBS, which is used by -# AC_PROG_{CC, CXX, F77, FC, OBJS}. -AC_DEFUN([_AC_ARG_VAR_LIBS], -[AC_ARG_VAR([LIBS], - [libraries to pass to the linker, e.g. -l<library>])]) - - -# AC_LANG_PREPROC(C) -# ------------------- -# Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C)], -[AC_REQUIRE([AC_PROG_CPP])]) - - -# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT) -# ----------------------------------------------- -# Check if $ac_cpp is a working preprocessor that can flag absent -# includes either by the exit status or by warnings. -# This macro is for all languages, not only C. -AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE], -[ac_preproc_ok=false -for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since - # <limits.h> exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__ -@%:@ include <limits.h> -@%:@else -@%:@ include <assert.h> -@%:@endif - Syntax error]])], - [], - [# Broken: fails on valid input. -continue]) - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])], - [# Broken: success on invalid input. -continue], - [# Passes both tests. -ac_preproc_ok=: -break]) - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.err conftest.$ac_ext -AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE - - -# AC_PROG_CPP -# ----------- -# Find a working C preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC. -AN_MAKEVAR([CPP], [AC_PROG_CPP]) -AN_PROGRAM([cpp], [AC_PROG_CPP]) -AC_DEFUN([AC_PROG_CPP], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_ARG_VAR([CPP], [C preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C)dnl -AC_MSG_CHECKING([how to run the C preprocessor]) -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - AC_CACHE_VAL([ac_cv_prog_CPP], - [dnl - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CPP=$CPP - ])dnl - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -AC_MSG_RESULT([$CPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])]) -AC_SUBST(CPP)dnl -AC_LANG_POP(C)dnl -])# AC_PROG_CPP - -# AC_PROG_CPP_WERROR -# ------------------ -# Treat warnings from the preprocessor as errors. -AC_DEFUN([AC_PROG_CPP_WERROR], -[AC_REQUIRE([AC_PROG_CPP])dnl -ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR - -# AC_LANG_COMPILER(C) -# ------------------- -# Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C)], -[AC_REQUIRE([AC_PROG_CC])]) - - -# ac_cv_prog_gcc -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gcc], -[ac_cv_c_compiler_gnu]) - - -# AC_PROG_CC([COMPILER ...]) -# -------------------------- -# COMPILER ... is a space separated list of C compilers to search for. -# This just gives the user an opportunity to specify an alternative -# search list for the C compiler. -AN_MAKEVAR([CC], [AC_PROG_CC]) -AN_PROGRAM([cc], [AC_PROG_CC]) -AN_PROGRAM([gcc], [AC_PROG_CC]) -AC_DEFUN([AC_PROG_CC], -[AC_LANG_PUSH(C)dnl -AC_ARG_VAR([CC], [C compiler command])dnl -AC_ARG_VAR([CFLAGS], [C compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_LIBS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -m4_ifval([$1], - [AC_CHECK_TOOLS(CC, [$1])], -[AC_CHECK_TOOL(CC, gcc) -if test -z "$CC"; then - dnl Here we want: - dnl AC_CHECK_TOOL(CC, cc) - dnl but without the check for a tool without the prefix. - dnl Until the check is removed from there, copy the code: - if test -n "$ac_tool_prefix"; then - AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc]) - fi -fi -if test -z "$CC"; then - AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) -fi -if test -z "$CC"; then - AC_CHECK_TOOLS(CC, cl.exe) -fi -]) - -test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH]) - -# Provide some information about the compiler. -_AS_ECHO_LOG([checking for _AC_LANG compiler version]) -set X $ac_compile -ac_compiler=$[2] -_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -if test $ac_compiler_gnu = yes; then - GCC=yes -else - GCC= -fi -_AC_PROG_CC_G -_AC_PROG_CC_C89 -AC_LANG_POP(C)dnl -])# AC_PROG_CC - - -# _AC_PROG_CC_G -# ------------- -# Check whether -g works, even if CFLAGS is set, in case the package -# plays around with CFLAGS (such as to build both debugging and normal -# versions of a library), tasteless as that idea is. -# Don't consider -g to work if it generates warnings when plain compiles don't. -m4_define([_AC_PROG_CC_G], -[ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g, - [ac_save_c_werror_flag=$ac_c_werror_flag - ac_c_werror_flag=yes - ac_cv_prog_cc_g=no - CFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cc_g=yes], - [CFLAGS="" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [], - [ac_c_werror_flag=$ac_save_c_werror_flag - CFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cc_g=yes])])]) - ac_c_werror_flag=$ac_save_c_werror_flag]) -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O3" - else - CFLAGS="-g" - fi -else - if test "$GCC" = yes; then - CFLAGS="-O3" - else - CFLAGS= - fi -fi[]dnl -])# _AC_PROG_CC_G - - -# AC_PROG_GCC_TRADITIONAL -# ----------------------- -AC_DEFUN([AC_PROG_GCC_TRADITIONAL], -[AC_REQUIRE([AC_PROG_CC])dnl -if test $ac_cv_c_compiler_gnu = yes; then - AC_CACHE_CHECK(whether $CC needs -traditional, - ac_cv_prog_gcc_traditional, -[ ac_pattern="Autoconf.*'x'" - AC_EGREP_CPP($ac_pattern, [#include <sgtty.h> -Autoconf TIOCGETP], - ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no) - - if test $ac_cv_prog_gcc_traditional = no; then - AC_EGREP_CPP($ac_pattern, [#include <termio.h> -Autoconf TCGETA], - ac_cv_prog_gcc_traditional=yes) - fi]) - if test $ac_cv_prog_gcc_traditional = yes; then - CC="$CC -traditional" - fi -fi -])# AC_PROG_GCC_TRADITIONAL - - -# AC_PROG_CC_C_O -# -------------- -AC_DEFUN([AC_PROG_CC_C_O], -[AC_REQUIRE([AC_PROG_CC])dnl -if test "x$CC" != xcc; then - AC_MSG_CHECKING([whether $CC and cc understand -c and -o together]) -else - AC_MSG_CHECKING([whether cc understands -c and -o together]) -fi -set dummy $CC; ac_cc=`AS_ECHO(["$[2]"]) | - sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'` -AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o, -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# Make sure it works both with $CC and with simple cc. -# We do the test twice because some compilers refuse to overwrite an -# existing .o file with -o, though they will create one. -ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' -rm -f conftest2.* -if _AC_DO_VAR(ac_try) && - test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try); -then - eval ac_cv_prog_cc_${ac_cc}_c_o=yes - if test "x$CC" != xcc; then - # Test first that cc exists at all. - if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then - ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' - rm -f conftest2.* - if _AC_DO_VAR(ac_try) && - test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try); - then - # cc works too. - : - else - # cc exists but doesn't like -o. - eval ac_cv_prog_cc_${ac_cc}_c_o=no - fi - fi - fi -else - eval ac_cv_prog_cc_${ac_cc}_c_o=no -fi -rm -f core conftest* -])dnl -if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then - AC_MSG_RESULT([yes]) -else - AC_MSG_RESULT([no]) - AC_DEFINE(NO_MINUS_C_MINUS_O, 1, - [Define to 1 if your C compiler doesn't accept -c and -o together.]) -fi -])# AC_PROG_CC_C_O - - - -# ---------------------- # -# 3b. The C++ compiler. # -# ---------------------- # - - -# AC_LANG_PREPROC(C++) -# --------------------- -# Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C++)], -[AC_REQUIRE([AC_PROG_CXXCPP])]) - - -# AC_PROG_CXXCPP -# -------------- -# Find a working C++ preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX. -AC_DEFUN([AC_PROG_CXXCPP], -[AC_REQUIRE([AC_PROG_CXX])dnl -AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C++)dnl -AC_MSG_CHECKING([how to run the C++ preprocessor]) -if test -z "$CXXCPP"; then - AC_CACHE_VAL(ac_cv_prog_CXXCPP, - [dnl - # Double quotes because CXXCPP needs to be expanded - for CXXCPP in "$CXX -E" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CXXCPP=$CXXCPP - ])dnl - CXXCPP=$ac_cv_prog_CXXCPP -else - ac_cv_prog_CXXCPP=$CXXCPP -fi -AC_MSG_RESULT([$CXXCPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])]) -AC_SUBST(CXXCPP)dnl -AC_LANG_POP(C++)dnl -])# AC_PROG_CXXCPP - - -# AC_LANG_COMPILER(C++) -# --------------------- -# Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C++)], -[AC_REQUIRE([AC_PROG_CXX])]) - - -# ac_cv_prog_gxx -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gxx], -[ac_cv_cxx_compiler_gnu]) - - -# AC_PROG_CXX([LIST-OF-COMPILERS]) -# -------------------------------- -# LIST-OF-COMPILERS is a space separated list of C++ compilers to search -# for (if not specified, a default list is used). This just gives the -# user an opportunity to specify an alternative search list for the C++ -# compiler. -# aCC HP-UX C++ compiler much better than `CC', so test before. -# FCC Fujitsu C++ compiler -# KCC KAI C++ compiler -# RCC Rational C++ -# xlC_r AIX C Set++ (with support for reentrant code) -# xlC AIX C Set++ -AN_MAKEVAR([CXX], [AC_PROG_CXX]) -AN_PROGRAM([CC], [AC_PROG_CXX]) -AN_PROGRAM([c++], [AC_PROG_CXX]) -AN_PROGRAM([g++], [AC_PROG_CXX]) -AC_DEFUN([AC_PROG_CXX], -[AC_LANG_PUSH(C++)dnl -AC_ARG_VAR([CXX], [C++ compiler command])dnl -AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_LIBS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -_AC_ARG_VAR_PRECIOUS([CCC])dnl -if test -z "$CXX"; then - if test -n "$CCC"; then - CXX=$CCC - else - AC_CHECK_TOOLS(CXX, - [m4_default([$1], - [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])], - g++) - fi -fi -# Provide some information about the compiler. -_AS_ECHO_LOG([checking for _AC_LANG compiler version]) -set X $ac_compile -ac_compiler=$[2] -_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -if test $ac_compiler_gnu = yes; then - GXX=yes -else - GXX= -fi -_AC_PROG_CXX_G -AC_LANG_POP(C++)dnl -])# AC_PROG_CXX - - -# _AC_PROG_CXX_G -# -------------- -# Check whether -g works, even if CXXFLAGS is set, in case the package -# plays around with CXXFLAGS (such as to build both debugging and -# normal versions of a library), tasteless as that idea is. -# Don't consider -g to work if it generates warnings when plain compiles don't. -m4_define([_AC_PROG_CXX_G], -[ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g, - [ac_save_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - ac_cv_prog_cxx_g=no - CXXFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cxx_g=yes], - [CXXFLAGS="" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [], - [ac_cxx_werror_flag=$ac_save_cxx_werror_flag - CXXFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cxx_g=yes])])]) - ac_cxx_werror_flag=$ac_save_cxx_werror_flag]) -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O3" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O3" - else - CXXFLAGS= - fi -fi[]dnl -])# _AC_PROG_CXX_G - - -# AC_PROG_CXX_C_O -# --------------- -# Test if the C++ compiler accepts the options `-c' and `-o' -# simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not. -AC_DEFUN([AC_PROG_CXX_C_O], -[AC_REQUIRE([AC_PROG_CXX])dnl -AC_LANG_PUSH([C++])dnl -AC_CACHE_CHECK([whether $CXX understands -c and -o together], - [ac_cv_prog_cxx_c_o], -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# We test twice because some compilers refuse to overwrite an existing -# `.o' file with `-o', although they will create one. -ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD' -rm -f conftest2.* -if _AC_DO_VAR(ac_try) && - test -f conftest2.$ac_objext && - _AC_DO_VAR(ac_try); then - ac_cv_prog_cxx_c_o=yes -else - ac_cv_prog_cxx_c_o=no -fi -rm -f conftest*]) -if test $ac_cv_prog_cxx_c_o = no; then - AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1, - [Define to 1 if your C++ compiler doesn't accept - -c and -o together.]) -fi -AC_LANG_POP([C++])dnl -])# AC_PROG_CXX_C_O - - - -# ------------------------------ # -# 3c. The Objective C compiler. # -# ------------------------------ # - - -# AC_LANG_PREPROC(Objective C) -# ---------------------------- -# Find the Objective C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(Objective C)], -[AC_REQUIRE([AC_PROG_OBJCPP])]) - - -# AC_PROG_OBJCPP -# -------------- -# Find a working Objective C preprocessor. -AC_DEFUN([AC_PROG_OBJCPP], -[AC_REQUIRE([AC_PROG_OBJC])dnl -AC_ARG_VAR([OBJCPP], [Objective C preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(Objective C)dnl -AC_MSG_CHECKING([how to run the Objective C preprocessor]) -if test -z "$OBJCPP"; then - AC_CACHE_VAL(ac_cv_prog_OBJCPP, - [dnl - # Double quotes because OBJCPP needs to be expanded - for OBJCPP in "$OBJC -E" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_OBJCPP=$OBJCPP - ])dnl - OBJCPP=$ac_cv_prog_OBJCPP -else - ac_cv_prog_OBJCPP=$OBJCPP -fi -AC_MSG_RESULT([$OBJCPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])]) -AC_SUBST(OBJCPP)dnl -AC_LANG_POP(Objective C)dnl -])# AC_PROG_OBJCPP - - -# AC_LANG_COMPILER(Objective C) -# ----------------------------- -# Find the Objective C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(Objective C)], -[AC_REQUIRE([AC_PROG_OBJC])]) - - - -# AC_PROG_OBJC([LIST-OF-COMPILERS]) -# --------------------------------- -# LIST-OF-COMPILERS is a space separated list of Objective C compilers to -# search for (if not specified, a default list is used). This just gives -# the user an opportunity to specify an alternative search list for the -# Objective C compiler. -# objcc StepStone Objective-C compiler (also "standard" name for OBJC) -# objc David Stes' POC. If you installed this, you likely want it. -# cc Native C compiler (for instance, Apple). -# CC You never know. -AN_MAKEVAR([OBJC], [AC_PROG_OBJC]) -AN_PROGRAM([objcc], [AC_PROG_OBJC]) -AN_PROGRAM([objc], [AC_PROG_OBJC]) -AC_DEFUN([AC_PROG_OBJC], -[AC_LANG_PUSH(Objective C)dnl -AC_ARG_VAR([OBJC], [Objective C compiler command])dnl -AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_LIBS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -_AC_ARG_VAR_PRECIOUS([OBJC])dnl -AC_CHECK_TOOLS(OBJC, - [m4_default([$1], [gcc objcc objc cc CC])], - gcc) -# Provide some information about the compiler. -_AS_ECHO_LOG([checking for _AC_LANG compiler version]) -set X $ac_compile -ac_compiler=$[2] -_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD]) -_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -if test $ac_compiler_gnu = yes; then - GOBJC=yes -else - GOBJC= -fi -_AC_PROG_OBJC_G -AC_LANG_POP(Objective C)dnl -])# AC_PROG_OBJC - - -# _AC_PROG_OBJC_G -# --------------- -# Check whether -g works, even if OBJCFLAGS is set, in case the package -# plays around with OBJCFLAGS (such as to build both debugging and -# normal versions of a library), tasteless as that idea is. -# Don't consider -g to work if it generates warnings when plain compiles don't. -m4_define([_AC_PROG_OBJC_G], -[ac_test_OBJCFLAGS=${OBJCFLAGS+set} -ac_save_OBJCFLAGS=$OBJCFLAGS -AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g, - [ac_save_objc_werror_flag=$ac_objc_werror_flag - ac_objc_werror_flag=yes - ac_cv_prog_objc_g=no - OBJCFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_objc_g=yes], - [OBJCFLAGS="" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [], - [ac_objc_werror_flag=$ac_save_objc_werror_flag - OBJCFLAGS="-g" - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_objc_g=yes])])]) - ac_objc_werror_flag=$ac_save_objc_werror_flag]) -if test "$ac_test_OBJCFLAGS" = set; then - OBJCFLAGS=$ac_save_OBJCFLAGS -elif test $ac_cv_prog_objc_g = yes; then - if test "$GOBJC" = yes; then - OBJCFLAGS="-g -O3" - else - OBJCFLAGS="-g" - fi -else - if test "$GOBJC" = yes; then - OBJCFLAGS="-O3" - else - OBJCFLAGS= - fi -fi[]dnl -])# _AC_PROG_OBJC_G - - - -## ------------------------------- ## -## 4. Compilers' characteristics. ## -## ------------------------------- ## - -# -------------------------------- # -# 4a. C compiler characteristics. # -# -------------------------------- # - - -# _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ---------------------------------------------------------------- -# If the C compiler is not in ANSI C89 (ISO C90) mode by default, try -# to add an option to output variable CC to make it so. This macro -# tries various options that select ANSI C89 on some system or -# another. It considers the compiler to be in ANSI C89 mode if it -# handles function prototypes correctly. -AC_DEFUN([_AC_PROG_CC_C89], -[_AC_C_STD_TRY([c89], -[[#include <stdarg.h> -#include <stdio.h> -#include <sys/types.h> -#include <sys/stat.h> -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv;]], -[[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]], -dnl Don't try gcc -ansi; that turns off useful extensions and -dnl breaks some systems' header files. -dnl AIX circa 2003 -qlanglvl=extc89 -dnl old AIX -qlanglvl=ansi -dnl Ultrix, OSF/1, Tru64 -std -dnl HP-UX 10.20 and later -Ae -dnl HP-UX older versions -Aa -D_HPUX_SOURCE -dnl SVR4 -Xc -D__EXTENSIONS__ -[-qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl -])# _AC_PROG_CC_C89 - - -# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST, -# ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE) -# -------------------------------------------------------------- -# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99') -# by trying to compile a program of TEST-PROLOGUE and TEST-BODY. If this fails, -# try again with each compiler option in the space-separated OPTION-LIST; if one -# helps, append it to CC. If eventually successful, run ACTION-IF-AVAILABLE, -# else ACTION-IF-UNAVAILABLE. -AC_DEFUN([_AC_C_STD_TRY], -[AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C])) -AC_CACHE_VAL(ac_cv_prog_cc_$1, -[ac_cv_prog_cc_$1=no -ac_save_CC=$CC -AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])]) -for ac_arg in '' $4 -do - CC="$ac_save_CC $ac_arg" - _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg]) - test "x$ac_cv_prog_cc_$1" != "xno" && break -done -rm -f conftest.$ac_ext -CC=$ac_save_CC -])# AC_CACHE_VAL -case "x$ac_cv_prog_cc_$1" in - x) - AC_MSG_RESULT([none needed]) ;; - xno) - AC_MSG_RESULT([unsupported]) ;; - *) - CC="$CC $ac_cv_prog_cc_$1" - AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;; -esac -AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6]) -])# _AC_C_STD_TRY - - -# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE]) -# ---------------------------------------------------------------- -# If the C compiler is not in ISO C99 mode by default, try to add an -# option to output variable CC to make it so. This macro tries -# various options that select ISO C99 on some system or another. It -# considers the compiler to be in ISO C99 mode if it handles _Bool, -# // comments, flexible array members, inline, long long int, mixed -# code and declarations, named initialization of structs, restrict, -# va_copy, varargs macros, variable declarations in for loops and -# variable length arrays. -AC_DEFUN([_AC_PROG_CC_C99], -[_AC_C_STD_TRY([c99], -[[#include <stdarg.h> -#include <stdbool.h> -#include <stdlib.h> -#include <wchar.h> -#include <stdio.h> - -// Check varargs macros. These examples are taken from C99 6.10.3.5. -#define debug(...) fprintf (stderr, __VA_ARGS__) -#define showlist(...) puts (#__VA_ARGS__) -#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) -static void -test_varargs_macros (void) -{ - int x = 1234; - int y = 5678; - debug ("Flag"); - debug ("X = %d\n", x); - showlist (The first, second, and third items.); - report (x>y, "x is %d but y is %d", x, y); -} - -// Check long long types. -#define BIG64 18446744073709551615ull -#define BIG32 4294967295ul -#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) -#if !BIG_OK - your preprocessor is broken; -#endif -#if BIG_OK -#else - your preprocessor is broken; -#endif -static long long int bignum = -9223372036854775807LL; -static unsigned long long int ubignum = BIG64; - -struct incomplete_array -{ - int datasize; - double data[]; -}; - -struct named_init { - int number; - const wchar_t *name; - double average; -}; - -typedef const char *ccp; - -static inline int -test_restrict (ccp restrict text) -{ - // See if C++-style comments work. - // Iterate through items via the restricted pointer. - // Also check for declarations in for loops. - for (unsigned int i = 0; *(text+i) != '\0'; ++i) - continue; - return 0; -} - -// Check varargs and va_copy. -static void -test_varargs (const char *format, ...) -{ - va_list args; - va_start (args, format); - va_list args_copy; - va_copy (args_copy, args); - - const char *str; - int number; - float fnumber; - - while (*format) - { - switch (*format++) - { - case 's': // string - str = va_arg (args_copy, const char *); - break; - case 'd': // int - number = va_arg (args_copy, int); - break; - case 'f': // float - fnumber = va_arg (args_copy, double); - break; - default: - break; - } - } - va_end (args_copy); - va_end (args); -} -]], -[[ - // Check bool. - _Bool success = false; - - // Check restrict. - if (test_restrict ("String literal") == 0) - success = true; - char *restrict newvar = "Another string"; - - // Check varargs. - test_varargs ("s, d' f .", "string", 65, 34.234); - test_varargs_macros (); - - // Check flexible array members. - struct incomplete_array *ia = - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); - ia->datasize = 10; - for (int i = 0; i < ia->datasize; ++i) - ia->data[i] = i * 1.234; - - // Check named initializers. - struct named_init ni = { - .number = 34, - .name = L"Test wide string", - .average = 543.34343, - }; - - ni.number = 58; - - int dynamic_array[ni.number]; - dynamic_array[ni.number - 1] = 543; - - // work around unused variable warnings - return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' - || dynamic_array[ni.number - 1] != 543); -]], -dnl Try -dnl GCC -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999) -dnl AIX -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99) -dnl HP cc -AC99 -dnl Intel ICC -std=c99, -c99 (deprecated) -dnl IRIX -c99 -dnl Solaris -xc99=all (Forte Developer 7 C mishandles -xc99 on Solaris 9, -dnl as it incorrectly assumes C99 semantics for library functions) -dnl Tru64 -c99 -dnl with extended modes being tried first. -[[-std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99]], [$1], [$2])[]dnl -])# _AC_PROG_CC_C99 - - -# AC_PROG_CC_C89 -# -------------- -AC_DEFUN([AC_PROG_CC_C89], -[ AC_REQUIRE([AC_PROG_CC])dnl - _AC_PROG_CC_C89 -]) - - -# AC_PROG_CC_C99 -# -------------- -AC_DEFUN([AC_PROG_CC_C99], -[ AC_REQUIRE([AC_PROG_CC])dnl - _AC_PROG_CC_C99 -]) - - -# AC_PROG_CC_STDC -# --------------- -AC_DEFUN([AC_PROG_CC_STDC], -[ AC_REQUIRE([AC_PROG_CC])dnl - AS_CASE([$ac_cv_prog_cc_stdc], - [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no], - [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99], - [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89], - [ac_cv_prog_cc_stdc=no])])])dnl - AC_MSG_CHECKING([for $CC option to accept ISO Standard C]) - AC_CACHE_VAL([ac_cv_prog_cc_stdc], []) - AS_CASE([$ac_cv_prog_cc_stdc], - [no], [AC_MSG_RESULT([unsupported])], - [''], [AC_MSG_RESULT([none needed])], - [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])]) -]) - - -# AC_C_BACKSLASH_A -# ---------------- -AC_DEFUN([AC_C_BACKSLASH_A], -[ - AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a, - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], - [[ -#if '\a' == 'a' - syntax error; -#endif - char buf['\a' == 'a' ? -1 : 1]; - buf[0] = '\a'; - return buf[0] != "\a"[0]; - ]])], - [ac_cv_c_backslash_a=yes], - [ac_cv_c_backslash_a=no])]) - if test $ac_cv_c_backslash_a = yes; then - AC_DEFINE(HAVE_C_BACKSLASH_A, 1, - [Define if backslash-a works in C strings.]) - fi -]) - - -# AC_C_CROSS -# ---------- -# Has been merged into AC_PROG_CC. -AU_DEFUN([AC_C_CROSS], []) - - -# AC_C_CHAR_UNSIGNED -# ------------------ -AC_DEFUN([AC_C_CHAR_UNSIGNED], -[AH_VERBATIM([__CHAR_UNSIGNED__], -[/* Define to 1 if type `char' is unsigned and you are not using gcc. */ -#ifndef __CHAR_UNSIGNED__ -# undef __CHAR_UNSIGNED__ -#endif])dnl -AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned, -[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])], - [((char) -1) < 0])], - ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)]) -if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then - AC_DEFINE(__CHAR_UNSIGNED__) -fi -])# AC_C_CHAR_UNSIGNED - - -# AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN], -# [ACTION-IF-UNIVERSAL]) -# ------------------------------------------------------------------------- -AC_DEFUN([AC_C_BIGENDIAN], -[AH_VERBATIM([WORDS_BIGENDIAN], -[/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most - significant byte first (like Motorola and SPARC, unlike Intel). */ -#if defined AC_APPLE_UNIVERSAL_BUILD -# if defined __BIG_ENDIAN__ -# define WORDS_BIGENDIAN 1 -# endif -#else -# ifndef WORDS_BIGENDIAN -# undef WORDS_BIGENDIAN -# endif -#endif])dnl - AC_CACHE_CHECK([whether byte ordering is bigendian], [ac_cv_c_bigendian], - [ac_cv_c_bigendian=unknown - # See if we're dealing with a universal compiler. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#ifndef __APPLE_CC__ - not a universal capable compiler - #endif - typedef int dummy; - ]])], - [ - # Check for potential -arch flags. It is not universal unless - # there are some -arch flags. Note that *ppc* also matches - # ppc64. This check is also rather less than ideal. - case "${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS}" in #( - *-arch*ppc*|*-arch*i386*|*-arch*x86_64*) ac_cv_c_bigendian=universal;; - esac]) - if test $ac_cv_c_bigendian = unknown; then - # See if sys/param.h defines the BYTE_ORDER macro. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <sys/types.h> - #include <sys/param.h> - ]], - [[#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ - && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ - && LITTLE_ENDIAN) - bogus endian macros - #endif - ]])], - [# It does; now see whether it defined to BIG_ENDIAN or not. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <sys/types.h> - #include <sys/param.h> - ]], - [[#if BYTE_ORDER != BIG_ENDIAN - not big endian - #endif - ]])], - [ac_cv_c_bigendian=yes], - [ac_cv_c_bigendian=no])]) - fi - if test $ac_cv_c_bigendian = unknown; then - # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <limits.h> - ]], - [[#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) - bogus endian macros - #endif - ]])], - [# It does; now see whether it defined to _BIG_ENDIAN or not. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <limits.h> - ]], - [[#ifndef _BIG_ENDIAN - not big endian - #endif - ]])], - [ac_cv_c_bigendian=yes], - [ac_cv_c_bigendian=no])]) - fi - if test $ac_cv_c_bigendian = unknown; then - # Compile a test program. - AC_RUN_IFELSE( - [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], - [[ - /* Are we little or big endian? From Harbison&Steele. */ - union - { - long int l; - char c[sizeof (long int)]; - } u; - u.l = 1; - return u.c[sizeof (long int) - 1] == 1; - ]])], - [ac_cv_c_bigendian=no], - [ac_cv_c_bigendian=yes], - [# Try to guess by grepping values from an object file. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[short int ascii_mm[] = - { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; - short int ascii_ii[] = - { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; - int use_ascii (int i) { - return ascii_mm[i] + ascii_ii[i]; - } - short int ebcdic_ii[] = - { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; - short int ebcdic_mm[] = - { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; - int use_ebcdic (int i) { - return ebcdic_mm[i] + ebcdic_ii[i]; - } - extern int foo; - ]], - [[return use_ascii (foo) == use_ebcdic (foo);]])], - [if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then - ac_cv_c_bigendian=yes - fi - if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then - if test "$ac_cv_c_bigendian" = unknown; then - ac_cv_c_bigendian=no - else - # finding both strings is unlikely to happen, but who knows? - ac_cv_c_bigendian=unknown - fi - fi])]) - fi]) - case $ac_cv_c_bigendian in #( - yes) - m4_default([$1], - [AC_DEFINE([WORDS_BIGENDIAN], 1)]);; #( - no) - $2 ;; #( - universal) -dnl Note that AC_APPLE_UNIVERSAL_BUILD sorts less than WORDS_BIGENDIAN; -dnl this is a necessity for proper config header operation. Warn if -dnl the user did not specify a config header but is relying on the -dnl default behavior for universal builds. - m4_default([$4], - [AC_CONFIG_COMMANDS_PRE([m4_ifset([AH_HEADER], [], - [AC_DIAGNOSE([obsolete], - [AC_C_BIGENDIAN should be used with AC_CONFIG_HEADERS])])])dnl - AC_DEFINE([AC_APPLE_UNIVERSAL_BUILD],1, - [Define if building universal (internal helper macro)])]) - ;; #( - *) - m4_default([$3], - [AC_MSG_ERROR([unknown endianness - presetting ac_cv_c_bigendian=no (or yes) will help])]) ;; - esac -])# AC_C_BIGENDIAN - - -# AC_C_INLINE -# ----------- -# Do nothing if the compiler accepts the inline keyword. -# Otherwise define inline to __inline__ or __inline if one of those work, -# otherwise define inline to be empty. -# -# HP C version B.11.11.04 doesn't allow a typedef as the return value for an -# inline function, only builtin types. -# -AN_IDENTIFIER([inline], [AC_C_INLINE]) -AC_DEFUN([AC_C_INLINE], -[AC_CACHE_CHECK([for inline], ac_cv_c_inline, -[ac_cv_c_inline=no -for ac_kw in inline __inline__ __inline; do - AC_COMPILE_IFELSE([AC_LANG_SOURCE( -[#ifndef __cplusplus -typedef int foo_t; -static $ac_kw foo_t static_foo () {return 0; } -$ac_kw foo_t foo () {return 0; } -#endif -])], - [ac_cv_c_inline=$ac_kw]) - test "$ac_cv_c_inline" != no && break -done -]) -AH_VERBATIM([inline], -[/* Define to `__inline__' or `__inline' if that's what the C compiler - calls it, or to nothing if 'inline' is not supported under any name. */ -#ifndef __cplusplus -#undef inline -#endif]) -case $ac_cv_c_inline in - inline | yes) ;; - *) - case $ac_cv_c_inline in - no) ac_val=;; - *) ac_val=$ac_cv_c_inline;; - esac - cat >>confdefs.h <<_ACEOF -#ifndef __cplusplus -#define inline $ac_val -#endif -_ACEOF - ;; -esac -])# AC_C_INLINE - - -# AC_C_CONST -# ---------- -AC_DEFUN([AC_C_CONST], -[AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], -[[/* FIXME: Include the comments suggested by Paul. */ -#ifndef __cplusplus - /* Ultrix mips cc rejects this. */ - typedef int charset[2]; - const charset cs; - /* SunOS 4.1.1 cc rejects this. */ - char const *const *pcpcc; - char **ppc; - /* NEC SVR4.0.2 mips cc rejects this. */ - struct point {int x, y;}; - static struct point const zero = {0,0}; - /* AIX XL C 1.02.0.0 rejects this. - It does not let you subtract one const X* pointer from another in - an arm of an if-expression whose if-part is not a constant - expression */ - const char *g = "string"; - pcpcc = &g + (g ? g-g : 0); - /* HPUX 7.0 cc rejects these. */ - ++pcpcc; - ppc = (char**) pcpcc; - pcpcc = (char const *const *) ppc; - { /* SCO 3.2v4 cc rejects this. */ - char *t; - char const *s = 0 ? (char *) 0 : (char const *) 0; - - *t++ = 0; - if (s) return 0; - } - { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ - int x[] = {25, 17}; - const int *foo = &x[0]; - ++foo; - } - { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ - typedef const int *iptr; - iptr p = 0; - ++p; - } - { /* AIX XL C 1.02.0.0 rejects this saying - "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ - struct s { int j; const int *ap[3]; }; - struct s *b; b->j = 5; - } - { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ - const int foo = 10; - if (!foo) return 0; - } - return !cs[0] && !zero.x; -#endif -]])], - [ac_cv_c_const=yes], - [ac_cv_c_const=no])]) -if test $ac_cv_c_const = no; then - AC_DEFINE(const,, - [Define to empty if `const' does not conform to ANSI C.]) -fi -])# AC_C_CONST - - -# AC_C_RESTRICT -# ------------- -# based on acx_restrict.m4, from the GNU Autoconf Macro Archive at: -# http://autoconf-archive.cryp.to/acx_restrict.html -# -# Determine whether the C/C++ compiler supports the "restrict" keyword -# introduced in ANSI C99, or an equivalent. Define "restrict" to the alternate -# spelling, if any; these are more likely to work in both C and C++ compilers of -# the same family, and in the presence of varying compiler options. If only -# plain "restrict" works, do nothing. Here are some variants: -# - GCC supports both __restrict and __restrict__ -# - older DEC Alpha C compilers support only __restrict -# - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C -# Otherwise, define "restrict" to be empty. -AN_IDENTIFIER([restrict], [AC_C_RESTRICT]) -AC_DEFUN([AC_C_RESTRICT], -[AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict, - [ac_cv_c_restrict=no - # The order here caters to the fact that C++ does not require restrict. - for ac_kw in __restrict __restrict__ _Restrict restrict; do - AC_COMPILE_IFELSE([AC_LANG_PROGRAM( - [[typedef int * int_ptr; - int foo (int_ptr $ac_kw ip) { - return ip[0]; - }]], - [[int s[1]; - int * $ac_kw t = s; - t[0] = 0; - return foo(t)]])], - [ac_cv_c_restrict=$ac_kw]) - test "$ac_cv_c_restrict" != no && break - done - ]) - AH_VERBATIM([restrict], -[/* Define to the equivalent of the C99 'restrict' keyword, or to - nothing if this is not supported. Do not define if restrict is - supported directly. */ -#undef restrict -/* Work around a bug in Sun C++: it does not support _Restrict, even - though the corresponding Sun C compiler does, which causes - "#define restrict _Restrict" in the previous line. Perhaps some future - version of Sun C++ will work with _Restrict; if so, it'll probably - define __RESTRICT, just as Sun C does. */ -#if defined __SUNPRO_CC && !defined __RESTRICT -# define _Restrict -#endif]) - case $ac_cv_c_restrict in - restrict) ;; - no) AC_DEFINE([restrict], []) ;; - *) AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;; - esac -])# AC_C_RESTRICT - - -# AC_C_VOLATILE -# ------------- -# Note that, unlike const, #defining volatile to be the empty string can -# actually turn a correct program into an incorrect one, since removing -# uses of volatile actually grants the compiler permission to perform -# optimizations that could break the user's code. So, do not #define -# volatile away unless it is really necessary to allow the user's code -# to compile cleanly. Benign compiler failures should be tolerated. -AC_DEFUN([AC_C_VOLATILE], -[AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [ -volatile int x; -int * volatile y = (int *) 0; -return !x && !y;])], - [ac_cv_c_volatile=yes], - [ac_cv_c_volatile=no])]) -if test $ac_cv_c_volatile = no; then - AC_DEFINE(volatile,, - [Define to empty if the keyword `volatile' does not work. - Warning: valid code using `volatile' can become incorrect - without. Disable with care.]) -fi -])# AC_C_VOLATILE - - -# AC_C_STRINGIZE -# -------------- -# Checks if `#' can be used to glue strings together at the CPP level. -# Defines HAVE_STRINGIZE if positive. -AC_DEFUN([AC_C_STRINGIZE], -[AC_CACHE_CHECK([for preprocessor stringizing operator], - [ac_cv_c_stringize], -[AC_EGREP_CPP([@%:@teststring], - [@%:@define x(y) #y - -char *s = x(teststring);], - [ac_cv_c_stringize=no], - [ac_cv_c_stringize=yes])]) -if test $ac_cv_c_stringize = yes; then - AC_DEFINE(HAVE_STRINGIZE, 1, - [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.]) -fi -])# AC_C_STRINGIZE - - -# AC_C_PROTOTYPES -# --------------- -# Check if the C compiler supports prototypes, included if it needs -# options. -AC_DEFUN([AC_C_PROTOTYPES], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_MSG_CHECKING([for function prototypes]) -if test "$ac_cv_prog_cc_c89" != no; then - AC_MSG_RESULT([yes]) - AC_DEFINE(PROTOTYPES, 1, - [Define to 1 if the C compiler supports function prototypes.]) - AC_DEFINE(__PROTOTYPES, 1, - [Define like PROTOTYPES; this can be used by system headers.]) -else - AC_MSG_RESULT([no]) -fi -])# AC_C_PROTOTYPES - - -# AC_C_FLEXIBLE_ARRAY_MEMBER -# -------------------------- -# Check whether the C compiler supports flexible array members. -AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER], -[ - AC_CACHE_CHECK([for flexible array members], - ac_cv_c_flexmember, - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <stdlib.h> - #include <stdio.h> - #include <stddef.h> - struct s { int n; double d[]; };]], - [[int m = getchar (); - struct s *p = malloc (offsetof (struct s, d) - + m * sizeof (double)); - p->d[0] = 0.0; - return p->d != (double *) NULL;]])], - [ac_cv_c_flexmember=yes], - [ac_cv_c_flexmember=no])]) - if test $ac_cv_c_flexmember = yes; then - AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], - [Define to nothing if C supports flexible array members, and to - 1 if it does not. That way, with a declaration like `struct s - { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack - can be used with pre-C99 compilers. - When computing the size of such an object, don't use 'sizeof (struct s)' - as it overestimates the size. Use 'offsetof (struct s, d)' instead. - Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with - MSVC and with C++ compilers.]) - else - AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1) - fi -]) - - -# AC_C_VARARRAYS -# -------------- -# Check whether the C compiler supports variable-length arrays. -AC_DEFUN([AC_C_VARARRAYS], -[ - AC_CACHE_CHECK([for variable-length arrays], - ac_cv_c_vararrays, - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([], - [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])], - [ac_cv_c_vararrays=yes], - [ac_cv_c_vararrays=no])]) - if test $ac_cv_c_vararrays = yes; then - AC_DEFINE([HAVE_C_VARARRAYS], 1, - [Define to 1 if C supports variable-length arrays.]) - fi -]) - - -# AC_C_TYPEOF -# ----------- -# Check if the C compiler supports GCC's typeof syntax. -# The test case provokes incompatibilities in the Sun C compilers -# (both Solaris 8 and Solaris 10). -AC_DEFUN([AC_C_TYPEOF], -[ - AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof, - [ac_cv_c_typeof=no - for ac_kw in typeof __typeof__ no; do - test $ac_kw = no && break - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], - [[ - int value; - typedef struct { - char a [1 - + ! (($ac_kw (value)) - (($ac_kw (value)) 0 < ($ac_kw (value)) -1 - ? ($ac_kw (value)) - 1 - : ~ (~ ($ac_kw (value)) 0 - << sizeof ($ac_kw (value)))))]; } - ac__typeof_type_; - return - (! ((void) ((ac__typeof_type_ *) 0), 0)); - ]])], - [ac_cv_c_typeof=$ac_kw]) - test $ac_cv_c_typeof != no && break - done]) - if test $ac_cv_c_typeof != no; then - AC_DEFINE([HAVE_TYPEOF], 1, - [Define to 1 if typeof works with your compiler.]) - if test $ac_cv_c_typeof != typeof; then - AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof], - [Define to __typeof__ if your compiler spells it that way.]) - fi - fi -]) - - -# _AC_LANG_OPENMP -# --------------- -# Expands to some language dependent source code for testing the presence of -# OpenMP. -AC_DEFUN([_AC_LANG_OPENMP], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - -# _AC_LANG_OPENMP(C) -# ------------------ -m4_define([_AC_LANG_OPENMP(C)], -[ -#ifndef _OPENMP - choke me -#endif -#include <omp.h> -int main () { return omp_get_num_threads (); } -]) - -# _AC_LANG_OPENMP(C++) -# -------------------- -m4_copy([_AC_LANG_OPENMP(C)], [_AC_LANG_OPENMP(C++)]) - -# _AC_LANG_OPENMP(Fortran 77) -# --------------------------- -m4_define([_AC_LANG_OPENMP(Fortran 77)], -[AC_LANG_FUNC_LINK_TRY([omp_get_num_threads])]) - -# _AC_LANG_OPENMP(Fortran) -# --------------------------- -m4_copy([_AC_LANG_OPENMP(Fortran 77)], [_AC_LANG_OPENMP(Fortran)]) - -# AC_OPENMP -# --------- -# Check which options need to be passed to the C compiler to support OpenMP. -# Set the OPENMP_CFLAGS / OPENMP_CXXFLAGS / OPENMP_FFLAGS variable to these -# options. -# The options are necessary at compile time (so the #pragmas are understood) -# and at link time (so the appropriate library is linked with). -# This macro takes care to not produce redundant options if $CC $CFLAGS already -# supports OpenMP. It also is careful to not pass options to compilers that -# misinterpret them; for example, most compilers accept "-openmp" and create -# an output file called 'penmp' rather than activating OpenMP support. -AC_DEFUN([AC_OPENMP], -[ - OPENMP_[]_AC_LANG_PREFIX[]FLAGS= - AC_ARG_ENABLE([openmp], - [AS_HELP_STRING([--disable-openmp], [do not use OpenMP])]) - if test "$enable_openmp" != no; then - AC_CACHE_CHECK([for $CC option to support OpenMP], - [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp], - [AC_LINK_IFELSE([_AC_LANG_OPENMP], - [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='none needed'], - [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='unsupported' - dnl Try these flags: - dnl GCC >= 4.2 -fopenmp - dnl SunPRO C -xopenmp - dnl Intel C -openmp - dnl SGI C, PGI C -mp - dnl Tru64 Compaq C -omp - dnl IBM C (AIX, Linux) -qsmp=omp - dnl If in this loop a compiler is passed an option that it doesn't - dnl understand or that it misinterprets, the AC_LINK_IFELSE test - dnl will fail (since we know that it failed without the option), - dnl therefore the loop will continue searching for an option, and - dnl no output file called 'penmp' or 'mp' is created. - for ac_option in -fopenmp -xopenmp -openmp -mp -omp -qsmp=omp; do - ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS - _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $ac_option" - AC_LINK_IFELSE([_AC_LANG_OPENMP], - [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp=$ac_option]) - _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS - if test "$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp" != unsupported; then - break - fi - done])]) - case $ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp in #( - "none needed" | unsupported) - ;; #( - *) - OPENMP_[]_AC_LANG_PREFIX[]FLAGS=$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp ;; - esac - fi - AC_SUBST([OPENMP_]_AC_LANG_PREFIX[FLAGS]) -])
--- a/configure.in Sun Oct 11 10:30:47 2009 +0000 +++ b/configure.in Sun Oct 11 10:38:38 2009 +0000 @@ -4,6 +4,9 @@ AC_GNU_SOURCE AC_CONFIG_AUX_DIRS($srcdir/build-scripts) +dnl Save the CFLAGS to see whether they were passed in or generated +orig_CFLAGS="$CFLAGS" + dnl Set various version strings - taken gratefully from the GTk sources # # Making releases: @@ -87,6 +90,10 @@ ;; esac BUILD_CFLAGS="$CFLAGS $CPPFLAGS" +# The default optimization for SDL 1.3 is -O3 (Bug #31) +if test x$orig_CFLAGS = x; then + BUILD_CFLAGS=`echo $BUILD_CFLAGS | sed 's/-O2/-O3/'` +fi EXTRA_CFLAGS="$INCLUDE $BASE_CFLAGS" BUILD_LDFLAGS="$LDFLAGS" EXTRA_LDFLAGS="$BASE_LDFLAGS"