shell bypass 403
UnknownSec Shell
:
/
usr
/
share
/
autoconf
/
autoconf
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
c.m4
# This file is part of Autoconf. -*- Autoconf -*- # Programming languages support. # Copyright (C) 2001-2012 Free Software Foundation, Inc. # This file is part of Autoconf. 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 3 of the License, 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. # # Under Section 7 of GPL version 3, you are granted additional # permissions described in the Autoconf Configure Script Exception, # version 3.0, as published by the Free Software Foundation. # # You should have received a copy of the GNU General Public License # and a copy of the Autoconf Configure Script Exception along with # this program; see the files COPYINGv3 and COPYING.EXCEPTION # respectively. If not, see <http://www.gnu.org/licenses/>. # 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 # 2. and routines to produce programs in a given language. # 1a. C 2a. C # 1b. C++ # 1c. Objective C # 1d. Objective C++ # # 3. Looking for a compiler # And possibly the associated preprocessor. # 3a. C 3b. C++ 3c. Objective C 3d. Objective C++ # # 4. Compilers' characteristics. # 4a. C ## ----------------------- ## ## 1a/2a. The C language. ## ## ----------------------- ## # ------------------------ # # 1a. Language selection. # # ------------------------ # # AC_LANG(C) # ---------- # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. AC_LANG_DEFINE([C], [c], [C], [CC], [], [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)]) # ------------------------ # # 2a. Producing programs. # # ------------------------ # # AC_LANG_CONFTEST(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_CONFTEST(C)], [cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $1 _ACEOF]) # 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_IO_PROGRAM(C) # ---------------------- # Produce source that performs I/O, necessary for proper # cross-compiler detection. m4_define([_AC_LANG_IO_PROGRAM(C)], [AC_LANG_PROGRAM([@%:@include <stdio.h>], [FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 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; return test_array @<:@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; ])]) ## ---------------------- ## ## 1b. The C++ language. ## ## ---------------------- ## # AC_LANG(C++) # ------------ # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. AC_LANG_DEFINE([C++], [cxx], [CXX], [CXX], [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++)]) ## ------------------------------ ## ## 1c. The Objective C language. ## ## ------------------------------ ## # AC_LANG(Objective C) # -------------------- AC_LANG_DEFINE([Objective C], [objc], [OBJC], [OBJC], [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)]) ## -------------------------------- ## ## 1d. The Objective C++ language. ## ## -------------------------------- ## # AC_LANG(Objective C++) # ---------------------- AC_LANG_DEFINE([Objective C++], [objcxx], [OBJCXX], [OBJCXX], [C++], [ac_ext=mm ac_cpp='$OBJCXXCPP $CPPFLAGS' ac_compile='$OBJCXX -c $OBJCXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' ac_link='$OBJCXX -o conftest$ac_exeext $OBJCXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' ac_compiler_gnu=$ac_cv_objcxx_compiler_gnu ]) ## -------------------------------------------- ## ## 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, OBJCXX, OBJCXXCPP}. AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], [AC_ARG_VAR([CPPFLAGS], [(Objective) C/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, OBJCXX}. 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, OBJC, OBJCXX}. 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.i 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] for ac_option in --version -v -V -qversion; do _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) done 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 -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" 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] for ac_option in --version -v -V -qversion; do _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) done 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 -O2" else CXXFLAGS="-g" fi else if test "$GXX" = yes; then CXXFLAGS="-O2" 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] for ac_option in --version -v -V -qversion; do _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) done 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 -O2" else OBJCFLAGS="-g" fi else if test "$GOBJC" = yes; then OBJCFLAGS="-O2" else OBJCFLAGS= fi fi[]dnl ])# _AC_PROG_OBJC_G # -------------------------------- # # 3d. 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_OBJCXXCPP])]) # AC_PROG_OBJCXXCPP # ----------------- # Find a working Objective C++ preprocessor. AC_DEFUN([AC_PROG_OBJCXXCPP], [AC_REQUIRE([AC_PROG_OBJCXX])dnl AC_ARG_VAR([OBJCXXCPP], [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 "$OBJCXXCPP"; then AC_CACHE_VAL(ac_cv_prog_OBJCXXCPP, [dnl # Double quotes because OBJCXXCPP needs to be expanded for OBJCXXCPP in "$OBJCXX -E" "/lib/cpp" do _AC_PROG_PREPROC_WORKS_IFELSE([break]) done ac_cv_prog_OBJCXXCPP=$OBJCXXCPP ])dnl OBJCXXCPP=$ac_cv_prog_OBJCXXCPP else ac_cv_prog_OBJCXXCPP=$OBJCXXCPP fi AC_MSG_RESULT([$OBJCXXCPP]) _AC_PROG_PREPROC_WORKS_IFELSE([], [AC_MSG_FAILURE([Objective C++ preprocessor "$OBJCXXCPP" fails sanity check])]) AC_SUBST(OBJCXXCPP)dnl AC_LANG_POP(Objective C++)dnl ])# AC_PROG_OBJCXXCPP # 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_OBJCXX])]) # AC_PROG_OBJCXX([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. # FIXME: this list is pure guesswork # objc++ StepStone Objective-C++ compiler (also "standard" name for OBJCXX) # objcxx David Stes' POC. If you installed this, you likely want it. # c++ Native C++ compiler (for instance, Apple). # CXX You never know. AN_MAKEVAR([OBJCXX], [AC_PROG_OBJCXX]) AN_PROGRAM([objcxx], [AC_PROG_OBJCXX]) AC_DEFUN([AC_PROG_OBJCXX], [AC_LANG_PUSH(Objective C++)dnl AC_ARG_VAR([OBJCXX], [Objective C++ compiler command])dnl AC_ARG_VAR([OBJCXXFLAGS], [Objective C++ compiler flags])dnl _AC_ARG_VAR_LDFLAGS()dnl _AC_ARG_VAR_LIBS()dnl _AC_ARG_VAR_CPPFLAGS()dnl _AC_ARG_VAR_PRECIOUS([OBJCXX])dnl AC_CHECK_TOOLS(OBJCXX, [m4_default([$1], [g++ objc++ objcxx c++ CXX])], g++) # Provide some information about the compiler. _AS_ECHO_LOG([checking for _AC_LANG compiler version]) set X $ac_compile ac_compiler=$[2] for ac_option in --version -v -V -qversion; do _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD]) done 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 GOBJCXX=yes else GOBJCXX= fi _AC_PROG_OBJCXX_G AC_LANG_POP(Objective C++)dnl ])# AC_PROG_OBJCXX # _AC_PROG_OBJCXX_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_OBJCXX_G], [ac_test_OBJCXXFLAGS=${OBJCXXFLAGS+set} ac_save_OBJCXXFLAGS=$OBJCXXFLAGS AC_CACHE_CHECK(whether $OBJCXX accepts -g, ac_cv_prog_objcxx_g, [ac_save_objcxx_werror_flag=$ac_objcxx_werror_flag ac_objcxx_werror_flag=yes ac_cv_prog_objcxx_g=no OBJCXXFLAGS="-g" _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_objcxx_g=yes], [OBJCXXFLAGS="" _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [], [ac_objcxx_werror_flag=$ac_save_objcxx_werror_flag OBJCXXFLAGS="-g" _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_objcxx_g=yes])])]) ac_objcxx_werror_flag=$ac_save_objcx_werror_flag]) if test "$ac_test_OBJCXXFLAGS" = set; then OBJCXXFLAGS=$ac_save_OBJCXXFLAGS elif test $ac_cv_prog_objcxx_g = yes; then if test "$GOBJCXX" = yes; then OBJCXXFLAGS="-g -O2" else OBJCXXFLAGS="-g" fi else if test "$GOBJCXX" = yes; then OBJCXXFLAGS="-O2" else OBJCXXFLAGS= fi fi[]dnl ])# _AC_PROG_OBJCXX_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> struct stat; /* 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 -D_STDC_C99= dnl cc's -xc99 option uses linker magic to define the external dnl symbol __xpg4 as if by "int __xpg4 = 1;", which enables C99 dnl behavior for C library functions. This is not wanted here, dnl because it means that a single module compiled with -xc99 dnl alters C runtime behavior for the entire program, not for dnl just the module. Instead, define the (private) symbol dnl _STDC_C99, which suppresses a bogus failure in <stdbool.h>. dnl The resulting compiler passes the test case here, and that's dnl good enough. For more, please see the thread starting at: dnl http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html dnl Tru64 -c99 dnl with extended modes being tried first. [[-std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -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])])]) 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 at least two -arch flags with different values. ac_arch= ac_prev= for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do if test -n "$ac_prev"; then case $ac_word in i?86 | x86_64 | ppc | ppc64) if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then ac_arch=$ac_word else ac_cv_c_bigendian=universal break fi ;; esac ac_prev= elif test "x$ac_word" = "x-arch"; then ac_prev=arch fi done]) 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([], [[ #ifndef __cplusplus /* Ultrix mips cc rejects this sort of thing. */ typedef int charset[2]; const charset cs = { 0, 0 }; /* 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 sort of thing. */ char tx; char *t = &tx; 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 sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; } bx; struct s *b = &bx; 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 or __restrict__, even though the corresponding Sun C compiler ends up with "#define restrict _Restrict" or "#define restrict __restrict__" in the previous line. Perhaps some future version of Sun C++ will work with restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ #if defined __SUNPRO_CC && !defined __RESTRICT # define _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_SOURCE([_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)], [ program main implicit none !$ integer tid tid = 42 call omp_set_num_threads(2) end ]) # _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 $[]_AC_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 Cray CCE -homp dnl NEC SX -Popenmp dnl Lahey Fortran (Linux) --openmp 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 -homp \ -Popenmp --openmp; 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]) ])
© 2025 UnknownSec