See the “Input” section of the manual for more detail, including
where to get the auxiliary scripts that may be needed by autoconf macros.
+*** Setting CC to a C++ compiler is no longer supported.
+
+ The C and C++ languages have diverged enough that we can no longer
+ guarantee that test C programs will be processed as intended by a
+ C++ compiler. In this release, configure will proceed anyway, but
+ many test results will be incorrect. In a future release, we may
+ make AC_PROG_CC error out if it detects that CC is a C++ compiler.
+
+ See the “Language Choice” section of the manual for instructions on
+ how to write configure scripts for C++ programs, and for programs
+ with code in more than one language.
+
*** Older versions of automake and aclocal (< 1.8) are no longer supported.
*** AC_CONFIG_SUBDIRS no longer directly supports Cygnus configure.
## Extensions. ##
## ------------ ##
+AT_CHECK_CONFIGURE_AC([Object file extensions],
+[[AC_PROG_CC
+
# As far as we know only `foo', `foo.exe' are possible executable,
# and `foo.o', `foo.obj' are possible object files. Autoconf must not
# know that, but it is OK for the test suite to take this into account.
-AT_CHECK_MACRO([Extensions],
-[[AC_PROG_CC
-case $ac_exeext in
- '' | '.exe' ) ;;
- * ) AC_MSG_ERROR([suspicious executable suffix: $ac_exeext]);;
-esac
+AS@&t@_CASE([$ac_exeext],
+ ['' | '.exe'],
+ [],
+ [AC_MSG_ERROR([suspicious executable suffix: $ac_exeext])])
-case $ac_objext in
- 'o' | 'obj' ) ;;
- * ) AC_MSG_ERROR([suspicious object suffix: $ac_objext]);;
-esac
-]])
+AS@&t@_CASE([$ac_objext],
+ ['o' | 'obj'],
+ [],
+ [AC_MSG_ERROR([suspicious object suffix: $ac_objext])])
+AC_OUTPUT
+]])
## -------------------------- ##
AT_DATA([configure.ac],
[[AC_INIT
-CC=no-such-compiler
AC_PROG_CC
AC_OUTPUT
]])
AT_CHECK_AUTOCONF
-AT_CHECK_CONFIGURE([], 77, ignore, ignore)
+AT_CHECK_CONFIGURE([CC=no-such-compiler], 77, ignore, ignore)
AT_CLEANUP
## C keywords. ##
## ------------ ##
-# GCC supports `const', `typeof', and `volatile'.
-AT_CHECK_MACRO([C keywords],
+AT_CHECK_CONFIGURE_AC([C keywords],
[[AC_PROG_CC
+
AC_C_CONST
AC_C_TYPEOF
AC_C_VOLATILE
+
+# If the C compiler is GCC, AC_C_{CONST,TYPEOF,VOLATILE} ought to all
+# detect support for their respective keyword.
case $GCC,$ac_cv_c_const,$ac_cv_c_typeof,$ac_cv_c_volatile in
yes,*no*)
AC_MSG_ERROR([failed to detect `const', `typeof', or `volatile' support]);;
]])
-
## --------------------------------- ##
## AC_PROG_CPP requires AC_PROG_CC. ##
## --------------------------------- ##
-# Must invoke AC_PROG_CC.
-AT_CHECK_MACRO([AC_PROG_CPP requires AC_PROG_CC],
+AT_CHECK_CONFIGURE_AC([AC_PROG_CPP requires AC_PROG_CC],
[[AC_PROG_CPP
-test -z "$CC" &&
+
+# AC_PROG_CPP should have AC_REQUIREd AC_PROG_CC.
+if test -z "$CC"; then
AC_MSG_ERROR([looked for a C preprocessor without looking for a compiler])
+fi
]])
-
## --------------------------- ##
## AC_PROG_CPP with warnings. ##
## --------------------------- ##
## AC_NO_EXECUTABLES (working linker). ##
## ------------------------------------ ##
-AT_CHECK_MACRO([AC_NO_EXECUTABLES (working linker)],
-[AC_NO_EXECUTABLES
+AT_CHECK_CONFIGURE_AC([AC_NO_EXECUTABLES (working linker)],
+[[AC_NO_EXECUTABLES
AC_PROG_CC
-])
+]])
## ----------------------------------- ##
## AC_NO_EXECUTABLES (broken linker). ##
## ----------------------------------- ##
-AT_CHECK_MACRO([AC_NO_EXECUTABLES (broken linker)],
-[LDFLAGS=-lnosuchlibrary
+AT_CHECK_CONFIGURE_AC([AC_NO_EXECUTABLES (broken linker)],
+[[LDFLAGS=-lnosuchlibrary
AC_NO_EXECUTABLES
AC_PROG_CC
-])
+]])
## -------------------------- ##
[ERLANG_INSTALL_LIB_DIR_.*|ERLANG_ERTS_VER|OBJC|OBJCPP|OBJCFLAGS],
[OBJCXX|OBJCXXCPP|OBJCXXFLAGS],
[GOC|GOFLAGS],
- [OPENMP_CFLAGS],
+ [OPENMP_(C|CXX)FLAGS],
[LIBS|LIB@&t@OBJS|LTLIBOBJS|LDFLAGS],
[INSTALL(_(DATA|PROGRAM|SCRIPT))?],
[EXEEXT|OBJEXT],
} [#]at_check_env])
-# AT_CONFIG_CMP(VAR-FILE-A, VAR-FILE-B)
-# -------------------------------------
+# AT_CONFIG_CMP(VAR-FILE-A, VAR-FILE-B, [EXTRA-VARIANCE])
+# -------------------------------------------------------
# Check the outcomes of two configure runs for equality by comparing dumps of
# their shell variables. VAR-FILE-A and VAR-FILE-B are two `set'-style shell
# variable space dumps.
# - BASH_ARGV [bash]
# - LINENO [Posix]
# - _AST_FEATURES [ksh93]
+# - Optionally, variables that are expected to vary in a particular test.
+# This is controlled by the EXTRA-VARIANCE argument, which is a
+# whitespace-separated sequence of tokens. Each token means to ignore
+# one or more additional variables and/or rename some variables, as follows:
+#
+# cross: ignore cross_compiling
+# cxx: ignore all of:
+# - CC, CPP, CCC, CXX, CXXCPP, CFLAGS, CXXFLAGS, GCC, GXX
+# - ac_cv_env_(any of the above)_(set|value)
+# - ac_cv_c_compiler_gnu, ac_cv_cxx_compiler_gnu
+# - ac_cv_c_decl_report, ac_cv_cxx_decl_report
+# - ac_cv_prog_c_*, ac_cv_prog_cxx_*, ac_cv_prog_ac_ct_(CC|CXX)
+# - ac_cv_prog_CPP, ac_cv_prog_CXXCPP
+# + other ac_cv_c_* are renamed to ac_cv_cxx_*
+# + OPENMP_CFLAGS is renamed to OPENMP_CXXFLAGS
+# vary:NAME (where NAME is any identifier): ignore ac_cv_NAME
#
# Furthermore, it is okay for a non-cache variable initialized to empty in one
# run to be unset in another run. This happens when, for example, cache update
#
# Lines that do not look like `foo=bar' are probably latter lines of
# multiline values; trim them.
-#
m4_define([AT_CONFIG_CMP],
[for act_file in $1 $2
do
- $SED '/^ac_cv_/ b
+ $SED '/^ac_cv_/ b skip
/^m4_defn([m4_re_word])=./ !d
/^[[^=]]*='\'''\''$/ d
/^a[[cs]]_/ d
+ : skip
/^OLDPWD=/ d
/^PPID=/ d
/^RANDOM=/ d
/^BASH_ARGV=/ d
/^LINENO=/ d
/^_AST_FEATURES=/ d
- ' $act_file >at_config_vars-$act_file
+m4_map_args_w([$3], [_AT_CONFIG_CMP_PRUNE(], [)])dnl
+' < $act_file > at_config_vars-$act_file
done
AT_CMP([at_config_vars-$1], [at_config_vars-$2])[]dnl
])# AT_CONFIG_CMP
+# _AT_CONFIG_CMP_PRUNE(TOKEN)
+# ---------------------------
+# Subroutine of AT_CONFIG_CMP which implements the extra-variance rules
+# described above. Expands to additional sed commands to be inserted in
+# the program above.
+# Note for future readers: not all sed implementations allow alternations
+# in regexes (e.g. /^ac_cv_env_CC_\(set\|value\)=/ would not be portable).
+m4_define([_AT_CONFIG_CMP_PRUNE],
+[m4_bmatch([$1],
+ [^cross$],
+[ /^cross_compiling=/ d
+],
+ [^cxx$],
+[ /^CC=/ d
+ /^CPP=/ d
+ /^CCC=/ d
+ /^CXX=/ d
+ /^CXXCPP=/ d
+ /^CFLAGS=/ d
+ /^CXXFLAGS=/ d
+ /^GCC=/ d
+ /^GXX=/ d
+ /^ac_cv_env_CC_set=/ d
+ /^ac_cv_env_CC_value=/ d
+ /^ac_cv_env_CPP_set=/ d
+ /^ac_cv_env_CPP_value=/ d
+ /^ac_cv_env_CFLAGS_set=/ d
+ /^ac_cv_env_CFLAGS_value=/ d
+ /^ac_cv_env_GCC_set=/ d
+ /^ac_cv_env_GCC_value=/ d
+ /^ac_cv_env_CCC_set=/ d
+ /^ac_cv_env_CCC_value=/ d
+ /^ac_cv_env_CXX_set=/ d
+ /^ac_cv_env_CXX_value=/ d
+ /^ac_cv_env_CXXCPP_set=/ d
+ /^ac_cv_env_CXXCPP_value=/ d
+ /^ac_cv_env_CXXFLAGS_set=/ d
+ /^ac_cv_env_CXXFLAGS_value=/ d
+ /^ac_cv_env_GXX_set=/ d
+ /^ac_cv_env_GXX_value=/ d
+ /^ac_cv_prog_ac_ct_CC=/ d
+ /^ac_cv_prog_ac_ct_CXX=/ d
+ /^ac_cv_prog_CPP=/ d
+ /^ac_cv_prog_CXXCPP=/ d
+ /^ac_cv_c_compiler_gnu=/ d
+ /^ac_cv_cxx_compiler_gnu=/ d
+ /^ac_cv_c_decl_report=/ d
+ /^ac_cv_cxx_decl_report=/ d
+ /^ac_cv_prog_c_@<:@^=@:>@*=/ d
+ /^ac_cv_prog_cc_@<:@^=@:>@*=/ d
+ /^ac_cv_prog_cxx_@<:@^=@:>@*=/ d
+ s/^ac_cv_c_/ac_cv_cxx_/
+ s/^OPENMP_CFLAGS=/OPENMP_CXXFLAGS=/
+],
+ [^vary:],
+[ /^ac_cv_]m4_bpatsubsts([$1], [\<vary:], [])[=/ d
+],
+ [m4_fatal([unrecognized AT_CONFIG_CMP variance token: "$1"])])])
+
+
+# AT_DEFINES_CMP(CONFIG-H-A, CONFIG-H-B, [EXTRA-VARIANCE])
+# --------------------------------------------------------
+# Check the outcomes of two configure runs for equality by comparing the
+# config.h headers they produced. Optionally, ignore changes to particular
+# defines, under the control of the EXTRA-VARIANCE argument, which is a
+# whitespace-separated sequence of tokens. Each token means to ignore
+# one or more additional defines, as follows:
+# vary:NAME (where NAME is any identifier): ignore #define/#undef NAME
+m4_define([AT_DEFINES_CMP],
+[m4_ifblank([$3], [AT_CMP([$1], [$2])],
+[for act_file in $1 $2
+do
+ $SED '
+m4_map_args_w([$3], [_AT_DEFINES_CMP_PRUNE(], [)])
+' < $act_file > at_defines-$act_file
+done
+AT_CMP([at_defines-$1], [at_defines-$2])[]dnl
+])])# AT_DEFINES_CMP
+
+
+# _AT_DEFINES_CMP_PRUNE(TOKEN)
+# ---------------------------
+# Subroutine of AT_DEFINES_CMP which implements the extra-variance rules
+# described above. Expands to one or more sed commands.
+# After quadrigraph replacement, each sed command group will be
+# /#define macro_name[ (]/ d ;#)
+# /#undef macro_name[ (]/ d ;#)
+# AC_DEFINE never emits tabs or puts whitespace between '#' and
+# 'define' or 'undef', so this is sufficient.
+m4_define([_AT_DEFINES_CMP_PRUNE],
+[m4_bmatch([$1],
+ [^vary:],
+[ /@%:@define ]m4_bpatsubsts([$1], [\<vary:], [])dnl
+[@<:@ @{:@@:>@/ d ;@%:@@:}@
+ /@%:@undef ]m4_bpatsubsts([$1], [\<vary:], [])dnl
+[@<:@ @{:@@:>@/ d ;@%:@@:}@
+],
+ [m4_fatal([unrecognized AT_DEFINES_CMP variance token: "$1"])])])
+
+
+# AT_PRESERVE_CONFIG_STATUS(SUFFIX)
+# ---------------------------------
+# Copy the files 'state-env.after', 'config.h', 'config.log', and
+# 'config.status' to names ending with SUFFIX, so they are not
+# clobbered by a subsequent run of configure.
+m4_define([AT_PRESERVE_CONFIG_STATUS],
+[cp -f state-env.after state-env.$1
+cp -f config.h config-h.$1
+cp -f config.log config-log.$1
+cp -f config.status config-status.$1
+])
+
# AT_CHECK_DEFINES(CONTENT)
# -------------------------
])
-# _AT_CHECK_AC_MACRO(AC-BODY, PRE-TESTS, [AUTOCONF-FLAGS])
-# --------------------------------------
+# _AT_CHECK_AC_MACRO(AC-BODY, [PRE-TESTS], [AUTOCONF-FLAGS])
+# ----------------------------------------------------------
# Create a minimalist configure.ac running the macro named
# NAME-OF-THE-MACRO, check that autoconf runs on that script,
# and that the generated configure script runs without error.
AT_CHECK_ENV
])# _AT_CHECK_AC_MACRO
+# AT_CHECK_CONFIGURE_AC(NAME, AC-BODY, [AUTOCONF-FLAGS],
+# [PRE-TESTS], [POST-TESTS])
+# -----------------------------------------------------
+# Shorthand for a complete test "group" consisting of a single
+# invocation of _AT_CHECK_AC_MACRO, possibly with some additional
+# tests executed before and after.
+m4_define([AT_CHECK_CONFIGURE_AC],
+[AT_SETUP([$1])
+_AT_CHECK_AC_MACRO([$2], [$4], [$3])
+$5
+AT_CLEANUP
+])
# AT_CHECK_MACRO(MACRO, [MACRO-USE], [ADDITIONAL-CMDS],
-# [AUTOCONF-FLAGS])
+# [AUTOCONF-FLAGS], [TEST-PARAMETERS])
# -----------------------------------------------------
-# Create a minimalist configure.ac running the macro named
-# NAME-OF-THE-MACRO, check that autoconf runs on that script,
+# Create a minimalist configure.ac running the macro named MACRO
+# (using the code in MACRO-USE if that argument is not empty,
+# otherwise a bare invocation of MACRO with no arguments),
+# check that autoconf runs on that script,
# and that the generated configure script runs without error.
-#
-# We run `configure' twice, both times with a cache, and compare
-# the environment after each run to detect inconsistencies.
+# AUTOCONF-FLAGS are passed to all invocations of autoconf.
+#
+# We always generate two variants of the minimalist configure.ac,
+# with and without forcing the script into cross-compilation mode
+# before executing MACRO-USE. If a C++ compiler is available, we
+# generate two more variants in which MACRO-USE is invoked while
+# AC_LANG([C++]) is in effect; as before, one forces the script into
+# cross-compilation mode and the other doesn't. All variants of the
+# generated configure script are run twice, once with an empty cache,
+# and once with a cache primed by the previous run.
+#
+# All four (or eight, if C++ is available) runs are expected to
+# produce the same results, except for the value of 'cross_compiling'
+# and differences due to running AC_PROG_CXX instead of AC_PROG_CC.
+# (See AT_CONFIG_CMP for details.)
+#
+# If ADDITIONAL-CMDS are present, they are executed after the first
+# pair of tests (with the C compiler, in native mode).
+#
+# If TEST-PARAMETERS are present, they should be a space-separated
+# list of modifiers to how the test is carried out. Currently
+# the following modifiers are defined:
+#
+# - `no-cross': Don't test this macro in cross-compilation mode.
+# This is for macros that use AC_RUN_IFELSE, and therefore, when
+# cross-compiling, they either crash or give a `best guess' answer
+# that may be wrong.
+#
+# - `cxx_cv_varies:NAME': The value of the cache variable ac_cv_NAME
+# may legitimately vary between the C tests and the C++ tests.
+#
+# - `cxx_define_varies:NAME' The value of the AC_DEFINEd macro NAME
+# may legitimately vary between the C tests and the C++ tests.
m4_define([AT_CHECK_MACRO],
[AT_SETUP([$1])
+# C compiler, native mode.
AT_CONFIGURE_AC([m4_default([$2], [$1])])
-
AT_CHECK_AUTOCONF([$4])
AT_CHECK_AUTOHEADER([$4], [ignore])
-for at_run in r1 r2
-do
- AT_CHECK_CONFIGURE([-C])
- cp -f state-env.after state-env.$at_run
- cp -f config.h config-h.$at_run
- cp -f config.log config-log.$at_run
- cp -f config.status config-status.$at_run
- AT_CHECK_ENV
-done
+cp -f configure.ac configure-ac.c-native
+cp -f configure configure.c-native
+cp -f config.hin config-hin.c-native
-AT_CMP([config-h.r1], [config-h.r2])
-AT_CONFIG_CMP([state-env.r1], [state-env.r2])
+AT_CHECK_CONFIGURE([-C])
+AT_PRESERVE_CONFIG_STATUS([c-native-r1])
+AT_CHECK_ENV
+AT_CHECK_CONFIGURE([-C])
+AT_PRESERVE_CONFIG_STATUS([c-native-r2])
+AT_CHECK_ENV
-$3
+AT_DEFINES_CMP([config-h.c-native-r1], [config-h.c-native-r2])
+AT_CONFIG_CMP([state-env.c-native-r1], [state-env.c-native-r2])
-AT_CLEANUP[]dnl
+m4_n([$3])dnl
+m4_bmatch([$5], [\<no-cross\>], [], [dnl
+
+# C compiler, cross-compilation mode.
+rm -rf config.cache autom4te.cache
+AT_CONFIGURE_AC(
+[cross_compiling=yes
+ac_tool_warned=yes
+m4_default([$2], [$1])])
+AT_CHECK_AUTOCONF([$4])
+AT_CHECK_AUTOHEADER([$4], [ignore])
+
+cp -f configure.ac configure-ac.c-cross
+cp -f configure configure.c-cross
+cp -f config.hin config-hin.c-cross
+
+AT_CHECK_CONFIGURE([-C])
+AT_PRESERVE_CONFIG_STATUS([c-cross-r1])
+AT_CHECK_ENV
+AT_DEFINES_CMP([config-h.c-native-r1], [config-h.c-cross-r1])
+AT_CONFIG_CMP([state-env.c-native-r1], [state-env.c-cross-r1], [cross])
+
+AT_CHECK_CONFIGURE([-C])
+AT_PRESERVE_CONFIG_STATUS([c-cross-r2])
+AT_CHECK_ENV
+AT_DEFINES_CMP([config-h.c-native-r1], [config-h.c-cross-r2])
+AT_CONFIG_CMP([state-env.c-native-r1], [state-env.c-cross-r2], [cross])
+])dnl
+
+# To save time, skip the C++-mode tests for any macro that did not
+# transitively require AC_PROG_CC; it won't make any difference.
+if grep '^CC=' state-env.c-native-r1 > /dev/null 2>&1; then
+
+ # C++ compiler, native mode.
+ rm -rf config.cache autom4te.cache
+ AT_CONFIGURE_AC(
+ [AC_LANG([C++])
+ m4_default([$2], [$1])])
+
+ # Autoconf may fail here because of an AC_LANG_ASSERT([C]); this
+ # means the macro is specific to C and should not be tested with the
+ # C++ compiler.
+ AT_CHECK_AUTOCONF([$4], [ignore], [ignore], [stderr])
+ if test -s stderr; then
+ AT_CHECK([grep 'error: AC_LANG_ASSERT: current language is not C' stderr],
+ [0], [ignore], [ignore])
+ else
+ AT_CHECK_AUTOHEADER([$4], [ignore])
+
+ cp -f configure.ac configure-ac.cxx-native
+ cp -f configure configure.cxx-native
+ cp -f config.hin config-hin.cxx-native
+
+ # If this configure pass fails with code 77, that means there is no
+ # C++ compiler available; don't mark the entire test group skipped,
+ # just skip the rest of the C++ testing.
+ AT_CHECK_CONFIGURE([-C;
+ status=$?
+ if test $status -eq 77; then
+ touch at-no-cxx
+ exit 0
+ else
+ exit $status
+ fi
+ ])
+ if test ! -f at-no-cxx; then
+ AT_PRESERVE_CONFIG_STATUS([cxx-native-r1])
+ AT_CHECK_ENV
+ AT_DEFINES_CMP([config-h.c-native-r1], [config-h.cxx-native-r1],
+ _AT_FILTER_CXX_DEFINE_VARIES([$5]))
+ AT_CONFIG_CMP([state-env.c-native-r1], [state-env.cxx-native-r1],
+ [cxx ]_AT_FILTER_CXX_CV_VARIES([$5]))
+
+ AT_CHECK_CONFIGURE([-C])
+ AT_PRESERVE_CONFIG_STATUS([cxx-native-r2])
+ AT_CHECK_ENV
+ AT_DEFINES_CMP([config-h.cxx-native-r1], [config-h.cxx-native-r2])
+ AT_CONFIG_CMP([state-env.cxx-native-r1], [state-env.cxx-native-r2])
+m4_bmatch([$5], [\<no-cross\>], [], [dnl
+
+ # Fourth run: C++ compiler, cross-compilation mode.
+
+ rm -rf config.cache autom4te.cache
+ AT_CONFIGURE_AC(
+ [cross_compiling=yes
+ ac_tool_warned=yes
+ AC_LANG([C++])
+ m4_default([$2], [$1])])
+ AT_CHECK_AUTOCONF([$4])
+ AT_CHECK_AUTOHEADER([$4], [ignore])
+
+ cp -f configure.ac configure-ac.cxx-cross
+ cp -f configure configure.cxx-cross
+ cp -f config.hin config-hin.cxx-cross
+
+ AT_CHECK_CONFIGURE([-C])
+ AT_PRESERVE_CONFIG_STATUS([cxx-cross-r1])
+ AT_CHECK_ENV
+ AT_DEFINES_CMP([config-h.cxx-native-r1], [config-h.cxx-cross-r1])
+ AT_CONFIG_CMP([state-env.cxx-native-r1], [state-env.cxx-cross-r1],
+ [cross])
+
+ AT_CHECK_CONFIGURE([-C])
+ AT_PRESERVE_CONFIG_STATUS([cxx-cross-r2])
+ AT_CHECK_ENV
+ AT_DEFINES_CMP([config-h.cxx-cross-r1], [config-h.cxx-cross-r2])
+ AT_CONFIG_CMP([state-env.cxx-cross-r1], [state-env.cxx-cross-r2])
+])dnl
+ fi # C++ compiler available
+ fi # macro can be used with C++
+fi # C++ makes a difference
+
+AT_CLEANUP
])# AT_CHECK_MACRO
-# AT_CHECK_MACRO_CROSS(MACRO, [MACRO-USE], [ADDITIONAL-CMDS],
-# [AUTOCONF-FLAGS])
-# -----------------------------------------------------------
-# Like the previous one, but creates two checks: for native
-# compile and for cross-compile.
-m4_define([AT_CHECK_MACRO_CROSS],
-[AT_CHECK_MACRO($@)
-AT_CHECK_MACRO([$1 (cross compile)],
- [AT_KEYWORDS([cross])
- # Exercise the code used when cross-compiling.
- cross_compiling=yes
- ac_tool_warned=yes
- m4_default([$2], [$1])],
- [$3], [$4])
-])
+# _AT_FILTER_CXX_CV_VARIES(TEST-PARAMETERS)
+# ---------------------------------------------
+# Subroutine of AT_CHECK_MACRO that expands to a sequence of
+# zero or more `vary:NAME' tokens, one for each occurrence of
+# `cxx_cv_varies:NAME' in TEST-PARAMETERS.
+m4_define([_AT_FILTER_CXX_CV_VARIES],
+[m4_map_args_w([$1], [_AT_FILTER_CXX_CV_VARY(], [)], [ ])])
+
+m4_define([_AT_FILTER_CXX_CV_VARY],
+[m4_bmatch([$1], [^cxx_cv_varies:],
+ [m4_bpatsubsts([$1], [\<cxx_cv_varies:], [vary:])])])
-# AT_CHECK_AU_MACRO(MACRO)
+# _AT_FILTER_CXX_DEFINE_VARIES(TEST-PARAMETERS)
+# ---------------------------------------------
+# Subroutine of AT_CHECK_MACRO that expands to a sequence of
+# zero or more `vary:NAME' tokens, one for each occurrence of
+# `cxx_define_varies:NAME' in TEST-PARAMETERS.
+m4_define([_AT_FILTER_CXX_DEFINE_VARIES],
+[m4_map_args_w([$1], [_AT_FILTER_CXX_DEFINE_VARY(], [)], [ ])])
+
+m4_define([_AT_FILTER_CXX_DEFINE_VARY],
+[m4_bmatch([$1], [^cxx_define_varies:],
+ [m4_bpatsubsts([$1], [\<cxx_define_varies:], [vary:])])])
+
+
+# AT_CHECK_AU_MACRO(MACRO, [MACRO-USE], [ADDITIONAL-CMDS],
+# [AUTOCONF-FLAGS], [TEST-PARAMETERS])
# ------------------------
-# Create a minimalist configure.ac running the macro named
-# NAME-OF-THE-MACRO, check that autoconf runs on that script,
-# and that the generated configure script runs without error.
-#
-# Then run autoupdate on that script, and check that NAME-OF-THE-MACRO
-# no longer appears in configure.ac, autoconf runs on the updated
-# script, the configure script still runs without error, and the
-# result is unchanged.
-#
-# On the first pass, check for a -Wobsolete warning naming
-# NAME-OF-THE-MACRO. On the second pass, *don't* check for the
-# absence of -Wobsolete warnings, because many of autoupdate's edits
-# leave the configure.ac author with some manual work to do, and
-# indicate this by inserting an m4_warn message to be removed
-# after the manual work is complete.
+# Do all the tests that AT_CHECK_MACRO(...) would do.
+#
+# In addition, run autoupdate on configure.ac; afterward, verify that
+# MACRO no longer appears in configure.ac, autoconf runs on the
+# updated script, the configure script still runs without error, and
+# the result of configuration is unchanged.
+#
+# Before running autoupdate, check for a -Wobsolete warning naming
+# MACRO from configure. After running autoupdate, *don't* check for
+# the absence of -Wobsolete warnings, because many of autoupdate's
+# edits leave the configure.ac author with some manual work to do, and
+# indicate this by inserting an m4_warn message to be removed after
+# the manual work is complete.
m4_define([AT_CHECK_AU_MACRO],
-[AT_SETUP([$1])
+[AT_CHECK_MACRO([$1], [$2], [$3], [-Wno-obsolete $4], [$5])
+
+AT_SETUP([autoupdating $1])
AT_KEYWORDS([autoupdate])
-AT_CONFIGURE_AC([$1])
+AT_CONFIGURE_AC([m4_default([$2], [$1])])
-AT_CHECK_AUTOCONF([], 0, [], [stderr])
+AT_CHECK_AUTOCONF([$4], 0, [], [stderr])
AT_CHECK([grep 'macro .$1. is obsolete' stderr], 0, [ignore], [ignore])
-AT_CHECK_AUTOHEADER([-Wno-obsolete], [ignore])
+AT_CHECK_AUTOHEADER([-Wno-obsolete $4], [ignore])
AT_CHECK_CONFIGURE
AT_CHECK_ENV
+AT_PRESERVE_CONFIG_STATUS([before-au])
rm config.hin
AT_CHECK_AUTOUPDATE([], 0, [], ignore)
AT_CHECK([grep '^$1$' configure.ac], 1)
-AT_CHECK_AUTOCONF([-Wno-obsolete])
-AT_CHECK_AUTOHEADER([-Wno-obsolete], [ignore])
+AT_CHECK_AUTOCONF([-Wno-obsolete $4])
+AT_CHECK_AUTOHEADER([-Wno-obsolete $4], [ignore])
AT_CHECK_CONFIGURE
AT_CHECK_ENV
+AT_PRESERVE_CONFIG_STATUS([after-au])
+
+AT_CMP([config-h.before-au], [config-h.after-au])
+AT_CONFIG_CMP([state-env.before-au], [state-env.after-au])
AT_CLEANUP[]dnl
])# AT_CHECK_AU_MACRO
## maintainer-check ##
-# These cannot be run in parallel.
+# The test suite cannot be run in parallel with itself.
maintainer-check:
+ $(MAKE) $(AM_MAKEFLAGS) check
$(MAKE) $(AM_MAKEFLAGS) maintainer-check-posix
- $(MAKE) $(AM_MAKEFLAGS) maintainer-check-c++
# The hairy heredoc is more robust than using echo.
CLEANFILES += expr
maintainer-check-posix: expr
POSIXLY_CORRECT=yes $(MAKE) $(AM_MAKEFLAGS) check
rm expr
-
-# Try using G++ as a C compiler.
-maintainer-check-c++:
- CC=g++ $(MAKE) $(AM_MAKEFLAGS) check
# Not every macro can be run without arguments, and some are already
# tested elsewhere.
my @ac_exclude_list = (
- # Internal macros are used elsewhere.
+ # Internal macros should not be invoked directly from a configure.ac.
qr/^_?_AC_/,
# Used in many places.
qr/^AC_(DIAGNOSE|FATAL|OBSOLETE|WARNING)$/,
qr/^AC_(FOREACH|LINK_FILES|PREREQ)$/,
+ # Need arguments. Tested in semantics.at.
+ qr/^AC_HAVE_LIBRARY$/,
+ qr/^AC_COMPILE_CHECK$/,
+ qr/^AC_TRY_(COMPILE|CPP|LINK|RUN)$/,
+
# Not macros, just mapping from old variable name to a new one.
qr/^ac_cv_prog_(gcc|gxx|g77)$/,
);
+# test_parameters
+# ---------------
+# Extra arguments to pass to the test macro for particular macros.
+# Keys are macro names, values are records containing one or more
+# of the possible optional arguments to AT_CHECK_(AU_)MACRO:
+# macro_use, additional_commands, autoconf_flags, test_parameters => '...'.
+# Entries in this hash are grouped by common situations, and sorted
+# alphabetically within each group.
+# Note that you must provide M4 quotation; emit_test will not quote
+# the arguments for you. (This is so you can _not_ quote the arguments
+# when that's useful.)
+
+my %test_parameters = (
+ # Uses AC_RUN_IFELSE, cross-compilation test fails.
+ AC_FC_CHECK_BOUNDS => { test_parameters => '[no-cross]' },
+ AC_FUNC_CHOWN => { test_parameters => '[no-cross]' },
+ AC_FUNC_FNMATCH => { test_parameters => '[no-cross]' },
+ AC_FUNC_FORK => { test_parameters => '[no-cross]' },
+ AC_FUNC_GETGROUPS => { test_parameters => '[no-cross]' },
+ AC_FUNC_LSTAT => { test_parameters => '[no-cross]' },
+ AC_FUNC_MALLOC => { test_parameters => '[no-cross]' },
+ AC_FUNC_MEMCMP => { test_parameters => '[no-cross]' },
+ AC_FUNC_MKTIME => { test_parameters => '[no-cross]' },
+ AC_FUNC_MMAP => { test_parameters => '[no-cross]' },
+ AC_FUNC_REALLOC => { test_parameters => '[no-cross]' },
+ AC_FUNC_STAT => { test_parameters => '[no-cross]' },
+ AC_FUNC_STRCOLL => { test_parameters => '[no-cross]' },
+ AC_FUNC_STRNLEN => { test_parameters => '[no-cross]' },
+ AC_FUNC_STRTOD => { test_parameters => '[no-cross]' },
+
+ # Different result with a C++ compiler than a C compiler:
+ # C++ compilers may or may not support these features from C1999 and later.
+ AC_C_RESTRICT => {
+ test_parameters => ('[cxx_define_varies:restrict' .
+ ' cxx_cv_varies:cxx_restrict]')
+ },
+ AC_C_TYPEOF => {
+ test_parameters => ('[cxx_define_varies:typeof' .
+ ' cxx_define_varies:HAVE_TYPEOF' .
+ ' cxx_cv_varies:cxx_typeof]')
+ },
+ AC_C__GENERIC => {
+ test_parameters => ('[cxx_define_varies:HAVE_C__GENERIC' .
+ ' cxx_cv_varies:cxx__Generic]')
+ },
+ AC_C_VARARRAYS => {
+ test_parameters => ('[cxx_define_varies:HAVE_C_VARARRAYS' .
+ ' cxx_define_varies:__STDC_NO_VLA__' .
+ ' cxx_cv_varies:cxx_vararrays]')
+ },
+
+ # stdbool.h is supposed to be includeable from C++, per C++2011
+ # [support.runtime], but the type _Bool was not added to the C++
+ # standard, so it may or may not be present depending on how much
+ # the C++ compiler cares about C source compatibility.
+ AC_CHECK_HEADER_STDBOOL => {
+ test_parameters => ('[cxx_define_varies:HAVE__BOOL' .
+ ' cxx_cv_varies:type__Bool]')
+ },
+ AC_HEADER_STDBOOL => {
+ test_parameters => ('[cxx_define_varies:HAVE__BOOL' .
+ ' cxx_cv_varies:type__Bool]')
+ },
+
+ # G++ forces -D_GNU_SOURCE which, with some versions of GNU libc,
+ # changes the declaration of strerror_r. Blech.
+ AC_FUNC_STRERROR_R => {
+ test_parameters => ('[cxx_define_varies:STRERROR_R_CHAR_P' .
+ ' cxx_cv_varies:func_strerror_r_char_p]')
+ },
+);
+
# skip_macro MACRO, EXCLUDE-LIST
# ------------------------------
# Returns truthy if any of the regexes in EXCLUDE-LIST match MACRO.
}
+# emit_test FH, TEST-MACRO, MACRO
+# --------------------------------
+# Emit code to FH to test MACRO using TEST-MACRO.
+# TEST-MACRO is expected to be either AT_CHECK_MACRO or AT_CHECK_AU_MACRO;
+# see local.at.
+sub emit_test
+{
+ my ($fh, $test_macro, $macro) = @_;
+ my $params = $test_parameters{$macro} || {};
+ my $macro_use = ${$params}{macro_use} || '';
+ my $additional_commands = ${$params}{additional_commands} || '';
+ my $autoconf_flags = ${$params}{autoconf_flags} || '';
+ my $test_parameters = ${$params}{test_parameters} || '';
+
+ $autoconf_flags = '[]'
+ if $autoconf_flags eq '' && $test_parameters ne '';
+ $additional_commands = '[]'
+ if $additional_commands eq '' && $autoconf_flags ne '';
+ $macro_use = '[]'
+ if $macro_use eq '' && $additional_commands ne '';
+
+ print $fh "$test_macro([$macro]";
+ print $fh ", $autoconf_flags" if $autoconf_flags ne '';
+ print $fh ", $additional_commands" if $additional_commands ne '';
+ print $fh ", $autoconf_flags" if $autoconf_flags ne '';
+ print $fh ", $test_parameters" if $test_parameters ne '';
+ print $fh ")\n";
+}
+
# scan_m4_files
# -------------
# Scan all of the Autoconf source files and produce lists of macros
if (@$ac_macros)
{
print $fh "\n# Modern macros.\n";
- print $fh "AT_CHECK_MACRO([$_])\n" for sort @$ac_macros;
+ emit_test ($fh, 'AT_CHECK_MACRO', $_)
+ for sort @$ac_macros;
}
if (@$au_macros)
{
print $fh "\n# Obsolete macros.\n";
- print $fh "AT_CHECK_AU_MACRO([$_])\n" for sort @$au_macros;
+ emit_test ($fh, 'AT_CHECK_AU_MACRO', $_)
+ for sort @$au_macros;
}
}
else
# AC_CHECK_LIB
# ------------
-# Well, I can't imagine a system where `cos' is neither in libc, nor
-# in libm. Nor can I imagine a lib more likely to exists than libm.
-# But there are systems without libm, on which we don't want to have
-# this test fail, so exit successfully if `cos' is in libc.
-AT_CHECK_MACRO([AC_CHECK_LIB],
-[AC_TRY_LINK_FUNC(cos,
- [AC_MSG_ERROR([`cos' is in `libc'], 77)])
+# Test for symbols in a library that is very likely to be available
+# and can be used from both C and C++: zlib, which we assume is
+# available unless <zlib.h> doesn't exist.
+# We used to use math library symbols for this, but that no longer
+# works, because some C++ compilers pull in libm by default when the
+# matching C compiler doesn't, breaking AT_CHECK_MACRO's expectations.
+AT_CHECK_MACRO([AC_CHECK_LIB], [[
+AC_CHECK_HEADER([zlib.h], [], [
+ AC_MSG_NOTICE([zlib not available, skipping test])
+ AS_EXIT(77)
+])
-AC_CHECK_LIB(m, cos,,
- [AC_MSG_ERROR([cannot find `cos' in `libm'])])
+# Using : for the ACTION-IF-FOUND in each call to AC_CHECK_LIB
+# prevents LIBS from accumulating copies of "-lz".
-# No kidding, using variables was broken in 2.50 :(
-ac_sin=sin
-AC_CHECK_LIB(m, $ac_sin,,
- [AC_MSG_ERROR([cannot find `\$ac_sin' (= `$ac_sin') in `libm'])])
-
-AS_UNSET([ac_cv_lib_m_acos])
-ac_m=m
-AC_CHECK_LIB($ac_m, acos,,
- [AC_MSG_ERROR([cannot find `acos' in `\$ac_m' (= `$ac_m')])])
-if test "${ac_cv_lib_m_acos+set}" != set; then
- AC_MSG_ERROR([ac_cv_lib_m_acos not set])
+AC_CHECK_LIB([z], [zlibVersion], [:], [
+ AC_MSG_ERROR([cannot find zlibVersion in libz])
+])
+if test "${ac_cv_lib_z_zlibVersion+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_zlibVersion not set])
fi
-ac_asin=asin
-AC_CHECK_LIB($ac_m, $ac_asin,,
- [AC_MSG_ERROR([cannot find `\$ac_asin' (= `$ac_asin') in `\$ac_m' (= `$ac_m')])])
-# But if the bug is in the caching mechanism, then be sure we
-# correctly detect failures.
+# No kidding, using variables was broken in 2.50 :(
+ac_deflate=deflate
+AC_CHECK_LIB([z], [$ac_deflate], [:], [
+ AC_MSG_ERROR([cannot find \$ac_deflate (= $ac_deflate) in libz])
+])
+if test "${ac_cv_lib_z_deflate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_deflate not set])
+fi
-AC_CHECK_LIB(m, cossack,
- [AC_MSG_ERROR([found `cossack' in `libm'])])
+ac_z=z
+AC_CHECK_LIB([$ac_z], [deflateEnd], [:], [
+ AC_MSG_ERROR([cannot find deflateEnd in lib\$ac_z (= lib$ac_z)])
+])
+if test "${ac_cv_lib_z_deflateEnd+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_deflateEnd not set])
+fi
-# No kidding, using variables was broken in 2.50 :(
-ac_sinner=sinner
-AC_CHECK_LIB(m, $ac_sinner,
- [AC_MSG_ERROR([found `\$ac_sinner' (= `$ac_sinner') in `libm'])])
+ac_inflate=inflate
+AC_CHECK_LIB([$ac_z], [$ac_inflate], [:], [
+ AC_MSG_ERROR(
+ [cannot find \$ac_inflate (= $ac_inflate) in lib\$ac_z (= lib$ac_z)])
+])
+if test "${ac_cv_lib_z_inflate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_inflate not set])
+fi
-ac_m=m
-AC_CHECK_LIB($ac_m, acossack,
- [AC_MSG_ERROR([found `acossack' in `\$ac_m' (= `$ac_m')])])
+# Also test for symbols that don't (well, shouldn't) exist.
+# These should still set their cache variables!
+AC_CHECK_LIB([z], [deflagrate], [
+ AC_MSG_ERROR([found deflagrate in libz])
+], [:])
+if test "${ac_cv_lib_z_deflagrate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_zlibVersion not set])
+fi
-ac_asinner=asinner
-AC_CHECK_LIB($ac_m, $ac_asinner,
- [AC_MSG_ERROR([found `\$ac_asinner' (= `$ac_asinner') in `\$ac_m' (= `$ac_m')])])
+ac_defenestrate=defenestrate
+AC_CHECK_LIB([z], [$ac_defenestrate], [
+ AC_MSG_ERROR([found \$ac_defenestrate (= $ac_defenestrate) in libz])
+], [:])
+if test "${ac_cv_lib_z_defenestrate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_defenestrate not set])
+fi
-])
+AC_CHECK_LIB([$ac_z], [defoliate], [
+ AC_MSG_ERROR([found defoliate in lib\$ac_z (= lib$ac_z)])
+], [:])
+if test "${ac_cv_lib_z_defoliate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_defoliate not set])
+fi
+
+ac_infiltrate=infiltrate
+AC_CHECK_LIB([$ac_z], [$ac_infiltrate], [
+ AC_MSG_ERROR(
+ [found \$ac_infiltrate (= $ac_infiltrate) in lib\$ac_z (= lib$ac_z)])
+], [:])
+if test "${ac_cv_lib_z_infiltrate+set}" != set; then
+ AC_MSG_ERROR([ac_cv_lib_z_infiltrate not set])
+fi
+]])
# AC_SEARCH_LIBS
# --------------
-AT_CHECK_MACRO([AC_SEARCH_LIBS],
-[
-AC_SEARCH_LIBS(cos, oser m ust,,
- [AC_MSG_ERROR([cannot find `cos'])])
-
-case "$ac_cv_search_cos" in
- -loser|-lust) AC_MSG_ERROR([jeez, $ac_cv_search_cos must be a cool library!]) ;;
-esac
+# Like AC_CHECK_LIBS, we use zlib here because we need the behavior to
+# be consistent between the C and C++ compilers.
+AT_CHECK_MACRO([AC_SEARCH_LIBS (needed)], [[
+AC_CHECK_HEADER([zlib.h], [], [
+ AC_MSG_NOTICE([zlib not available, skipping test])
+ AS_EXIT(77)
])
+# Unlike AC_CHECK_LIBS, AC_SEARCH_LIBS sets $LIBS *even if*
+# ACTION-IF-FOUND is given, so we need to reset it after each test.
+ac_at_save_LIBS="$LIBS"
+
+AC_SEARCH_LIBS([zlibVersion], [z], [:], [:])
+if test x"$ac_cv_search_zlibVersion" != x-lz; then
+ AC_MSG_ERROR([wrong zlibVersion search result: $ac_cv_search_zlibVersion])
+fi
+LIBS="$ac_at_save_LIBS"
+
+# No kidding, using variables was broken in 2.50 :(
+ac_deflate=deflate
+AC_SEARCH_LIBS([$ac_deflate], [z], [:], [:])
+if test x"$ac_cv_search_deflate" != x-lz; then
+ AC_MSG_ERROR([wrong deflate search result: $ac_cv_search_deflate])
+fi
+LIBS="$ac_at_save_LIBS"
+
+ac_z=z
+AC_SEARCH_LIBS([deflateEnd], [$ac_z], [:], [:])
+if test x"$ac_cv_search_deflateEnd" != x-lz; then
+ AC_MSG_ERROR([wrong deflateEnd search result: $ac_cv_search_deflateEnd])
+fi
+LIBS="$ac_at_save_LIBS"
+
+ac_inflate=inflate
+AC_SEARCH_LIBS([$ac_inflate], [$ac_z], [:], [:])
+if test x"$ac_cv_search_inflate" != x-lz; then
+ AC_MSG_ERROR([wrong inflate search result: $ac_cv_search_inflate])
+fi
+LIBS="$ac_at_save_LIBS"
+
+# Also test for symbols that don't (well, shouldn't) exist.
+# These should still set their cache variables!
+AC_SEARCH_LIBS([deflagrate], [z], [:], [:])
+if test x"$ac_cv_search_deflagrate" != xno; then
+ AC_MSG_ERROR([wrong deflagrate search result: $ac_cv_search_deflagrate])
+fi
+LIBS="$ac_at_save_LIBS"
+
+ac_defenestrate=defenestrate
+AC_SEARCH_LIBS([$ac_defenestrate], [z], [:], [:])
+if test x"$ac_cv_search_defenestrate" != xno; then
+ AC_MSG_ERROR([wrong defenestrate search result: $ac_cv_search_defenestrate])
+fi
+LIBS="$ac_at_save_LIBS"
+
+AC_SEARCH_LIBS([defoliate], [$ac_z], [:], [:])
+if test x"$ac_cv_search_defoliate" != xno; then
+ AC_MSG_ERROR([wrong defoliate search result: $ac_cv_search_defoliate])
+fi
+LIBS="$ac_at_save_LIBS"
+
+ac_infiltrate=infiltrate
+AC_SEARCH_LIBS([$ac_infiltrate], [$ac_z], [:], [:])
+if test x"$ac_cv_search_infiltrate" != xno; then
+ AC_MSG_ERROR([wrong infiltrate search result: $ac_cv_search_infiltrate])
+fi
+LIBS="$ac_at_save_LIBS"
+]])
+
# AC_SEARCH_LIBS (none needed)
# ----------------------------
-AT_CHECK_MACRO([AC_SEARCH_LIBS (none needed)],
-[
-AC_SEARCH_LIBS(printf, oser c ust,,
- [AC_MSG_ERROR([cannot find `printf'])])
-
-case "$ac_cv_search_printf" in
- -loser|-lust) AC_MSG_ERROR([jeez, $ac_cv_search_printf must be a cool library!]) ;;
- -lc) AC_MSG_ERROR([huh, you need to give -lc?])
-esac
-])
+# This test doesn't need to be nearly as thorough as the above; its
+# purpose is simply to ensure that when no library is needed,
+# AC_SEARCH_LIBS really does produce "none needed" as its result.
+AT_CHECK_MACRO([AC_SEARCH_LIBS (none needed)], [[
+# No library should be required to link with printf, but we throw
+# -lc in the search list so that it includes both libraries that
+# don't exist and libraries that probably do.
+AC_SEARCH_LIBS([printf], [oser c ust], [:], [:])
+
+if test x"$ac_cv_search_printf" != "xnone required"; then
+ AC_MSG_ERROR([wrong printf search result: $ac_cv_search_printf])
+fi
+]])
# AC_CHECK_DECLS
]])
AC_LANG_WERROR
AC_CHECK_DECL([undeclared (char *)], [AS_EXIT([1])],, [[]])
- if test -z "$ac_c_werror_flag"; then
- AC_MSG_ERROR([ac_c_werror_flag overwritten])
+ if test -z "$ac_[]_AC_LANG_ABBREV[]_werror_flag"; then
+ AC_MSG_ERROR([ac_]_AC_LANG_ABBREV[_werror_flag overwritten])
fi
]],
[AT_CHECK_DEFINES(
# AC_CHECK_ALIGNOF
# ----------------
-AT_CHECK_MACRO_CROSS([AC_CHECK_ALIGNOF],
+AT_CHECK_MACRO([AC_CHECK_ALIGNOF],
[[AC_CHECK_ALIGNOF(char)
AC_CHECK_ALIGNOF(charchar,
[[#include <stddef.h>
# AC_CHECK_ALIGNOF struct
# -----------------------
-AT_CHECK_MACRO_CROSS([AC_CHECK_ALIGNOF struct],
+AT_CHECK_MACRO([AC_CHECK_ALIGNOF struct],
[[AC_CHECK_ALIGNOF([struct { char c; }])
AC_CHECK_ALIGNOF([struct nosuchstruct])
]],
# AC_CHECK_SIZEOF
# ---------------
-AT_CHECK_MACRO_CROSS([AC_CHECK_SIZEOF],
+AT_CHECK_MACRO([AC_CHECK_SIZEOF],
[[AC_CHECK_SIZEOF(char)
AC_CHECK_SIZEOF(charchar,,
[[#include <stdio.h>
# AC_CHECK_SIZEOF struct
# ----------------------
-AT_CHECK_MACRO_CROSS([AC_CHECK_SIZEOF struct],
+AT_CHECK_MACRO([AC_CHECK_SIZEOF struct],
[[AC_C_CONST
AC_CHECK_SIZEOF([struct x], [], [struct x { char c; int x; };])
AC_CHECK_SIZEOF([const struct x], [], [struct x { const char *p; int x; };])
# --------------
# FIXME: To really test HAVE_AC_EXISTS2 and HAVE_AC_MISSING2 we need to
# open AH_TEMPLATE to `configure.ac', which is not yet the case.
-AT_CHECK_MACRO([AC_CHECK_FILES],
-[touch at-exists1 at-exists2
+# Don't use AT_CHECK_MACRO for this one because AC_CHECK_FILES can't be
+# used when cross compiling.
+
+AT_CHECK_CONFIGURE_AC([AC_CHECK_FILES],
+[[touch at-exists1 at-exists2
ac_exists2=at-exists2
ac_missing2=at-missing2
AC_CHECK_FILES(at-exists1 at-missing1 $ac_exists2 $ac_missing2)
-rm at-exists1 at-exists2],
+rm at-exists1 at-exists2]],
+[], [],
[AT_CHECK_DEFINES(
[#define HAVE_AT_EXISTS1 1
/* #undef HAVE_AT_MISSING1 */
## ------------------------------- ##
-AT_CHECK_MACRO([AC_SYS_RESTARTABLE_SYSCALLS], , ,[-W no-obsolete])
+AT_CHECK_MACRO([AC_SYS_RESTARTABLE_SYSCALLS], , ,[-W no-obsolete], [no-cross])
AT_CHECK_MACRO([AC_FUNC_SETVBUF_REVERSED], , ,[-W no-obsolete])
-AT_CHECK_MACRO([AC_FUNC_WAIT3], , ,[-W no-obsolete])
+AT_CHECK_MACRO([AC_FUNC_WAIT3], , ,[-W no-obsolete], [no-cross])
+
+
+## ------------------------------------- ##
+## Obsolete macros requiring arguments. ##
+## ------------------------------------- ##
+
+# These all wrap the macro under test in an AC_CACHE_CHECK and an
+# AC_DEFINE so the full verification machinery of AT_CHECK_MACRO is
+# effective. Caution: AT_CHECK_AU_MACRO expects that after an
+# autoupdate run, a naive grep will not find the old macro name
+# anywhere in the updated configure.ac, not even as part of a
+# longer identifier. (But it's case sensitive.)
+
+AT_CHECK_AU_MACRO([AC_TRY_CPP],
+[[AC_CACHE_CHECK([working ac_try_cpp], [ac_cv_ac_try_cpp_works], [
+ AC_TRY_CPP([
+ @%:@if 2 + 2 != 4
+ @%:@error "SEVEN!" /* in memory of Stanislaw Lem */
+ @%:@endif
+ ], [ac_cv_ac_try_cpp_works=yes],
+ [ac_cv_ac_try_cpp_works=no])
+])
+if test $ac_cv_ac_try_cpp_works = yes; then
+ AC_DEFINE([ac_try_cpp_works], [1], [label])
+fi
+]])
+
+
+AT_CHECK_AU_MACRO([AC_TRY_COMPILE],
+[[AC_CACHE_CHECK([working ac_try_compile], [ac_cv_ac_try_compile_works], [
+ AC_TRY_COMPILE([int variable;], [return variable;],
+ [ac_cv_ac_try_compile_works=yes],
+ [ac_cv_ac_try_compile_works=no])
+])
+if test $ac_cv_ac_try_compile_works = yes; then
+ AC_DEFINE([ac_try_compile_works], [1], [label])
+fi
+]])
+
+
+AT_CHECK_AU_MACRO([AC_TRY_LINK],
+[[AC_CACHE_CHECK([working ac_try_link], [ac_cv_ac_try_link_works], [
+ AC_TRY_LINK([@%:@include <stdio.h>], [return !feof(stdin);],
+ [ac_cv_ac_try_link_works=yes],
+ [ac_cv_ac_try_link_works=no])
+])
+if test $ac_cv_ac_try_link_works = yes; then
+ AC_DEFINE([ac_try_link_works], [1], [label])
+fi
+]])
+
+
+# Oddly enough, AC_COMPILE_CHECK was shorthand for AC_MSG_CHECKING +
+# AC_TRY_LINK, not AC_TRY_COMPILE. When not cached, this will print
+# checking for working ac_compile_check... checking for feof ... yes
+# but whatever.
+AT_CHECK_AU_MACRO([AC_COMPILE_CHECK],
+[[AC_CACHE_CHECK([working ac_compile_check], [ac_cv_ac_compile_check_works], [
+ AC_COMPILE_CHECK([feof], [@%:@include <stdio.h>], [return !feof(stdin);],
+ [ac_cv_ac_compile_check_works=yes],
+ [ac_cv_ac_compile_check_works=no])
+])
+if test $ac_cv_ac_compile_check_works = yes; then
+ AC_DEFINE([ac_compile_check_works], [1], [label])
+fi
+]])
+
+
+AT_CHECK_AU_MACRO([AC_TRY_RUN],
+[[AC_CACHE_CHECK([working ac_try_run], [ac_cv_ac_try_run_works], [
+ AC_TRY_RUN([int main(void) { return 0; }],
+ [ac_cv_ac_try_run_works=yes],
+ [ac_cv_ac_try_run_works=no],
+ [ac_cv_ac_try_run_works=yes]) # cross compile, assume it works
+])
+if test $ac_cv_ac_try_run_works = yes; then
+ AC_DEFINE([ac_try_run_works], [1], [label])
+fi
+]])
+
+
+# For purpose of this test, we don't care whether these libraries
+# exist (as long as the result is consistent between C and C++)
+# but we _do_ need to make sure that autoupdate correctly handles
+# AC_HAVE_LIBRARY's acceptance of "-lfoo" and "libfoo.a" as the
+# LIBRARY argument, where AC_CHECK_LIB only takes "foo".
+AT_CHECK_AU_MACRO([AC_HAVE_LIBRARY],
+[[AC_HAVE_LIBRARY([alice])
+AC_HAVE_LIBRARY([-lbob])
+AC_HAVE_LIBRARY([libmallory.a])
+]])
## ----------------------------------------- ##
projects / thirdparty / autoconf.git / commitdiff
