mirror of
git://git.sv.gnu.org/autoconf
synced 2025-04-24 15:40:44 +08:00
dade4a8a31
AC_PROG_LEX has three different operating modes (“yywrap”, “noyywrap”,
and 2.69 compatibility mode) which were all tangled together and hard
to understand. In addition, the way we were handling yywrap, in all
three modes, was imprecise to the point where I am unsure we were
actually testing the property people want to test.
Refactor AC_PROG_LEX into a set of smaller macros:
- AC_PROG_LEX and _AC_PROG_LEX_1 perform argument validation and
normalization. _AC_PROG_LEX_1 also ensures that repeated invocation
of AC_PROG_LEX is harmless.
- _AC_PROG_LEX_2 is invoked with exactly one argument which is the
name of one of the three _AC_PROG_LEX_LIBL_* macros (described below).
It invokes, in sequence, AC_CHECK_PROGS([LEX]), _AC_PROG_LEX_OUTPUT_ROOT,
the _AC_PROG_LEX_LIBL_ macro it was given as an argument, and
finally _AC_PROG_LEX_YYTEXT_DECL. If any of these sets LEX to ‘:’,
further tests are skipped. _AC_PROG_LEX_2 is also responsible for
cleaning up conftest.l and lex.yy.c afterward.
- _AC_PROG_LEX_YYTEXT_DECL now *only* tests whether yytext is a
pointer. It reuses the conftest.l from previous tests.
- _AC_PROG_LEX_OUTPUT_ROOT just does the test for the name of the
file produced by running ‘lex conftest.l’ with no further arguments.
- _AC_PROG_LEX_LIBL_YYWRAP, _AC_PROG_LEX_LIBL_NOYYWRAP, and
_AC_PROG_LEX_LIBL_COMPAT determine whether a generated lexer needs
to be linked with -ll or -lfl. Each is dedicated to one of the
three operating modes, and uses a conftest.l specialized for that mode.
In compat mode we do *not* look for ‘yywrap’ using AC_SEARCH_LIBS;
instead we actually try to link a generated lexer that uses yywrap.
- _AC_PROG_LEX_SEARCH_LIBL, _AC_PROG_LEX_TEST_COMMON,
_AC_PROG_LEX_TEST_YYWRAP, and _AC_PROG_LEX_TEST_NOYYWRAP are
subroutines of the _AC_PROG_LEX_LIBL_* macros.
TODO:
- Shrink and sharpen the test program used by _AC_PROG_LEX_YYTEXT_DECL and
make it independent of previous operations. Possibly smush it
back together with _AC_PROG_LEX_OUTPUT_ROOT.
- Re-audit the “noyywrap” program, it might be better to declare
“_static_ int yywrap(void)” in the %{ %} block instead of not
declaring it at all.
- Re-audit the “yywrap” program, it might be better to rely on the
skeleton to declare yywrap.
* lib/autoconf/programs.m4 (AC_PROG_LEX): Extensive refactor.
Test for yywrap is now done by linking a generated lexer, not with
AC_SEARCH_LIBS.
(_AC_PROG_LEX_YYTEXT_DECL): Just test whether yytext is a pointer.
(_AC_PROG_LEX): Removed.
(_AC_PROG_LEX_1, _AC_PROG_LEX_2): New macros dividing up the labor
formerly performed by _AC_PROG_LEX and the order of operations in
the old _AC_PROG_LEX_YYTEXT_DECL.
(_AC_PROG_LEX_OUTPUT_ROOT, _AC_PROG_LEX_SEARCH_LIBL)
(_AC_PROG_LEX_LIBL_YYWRAP, _AC_PROG_LEX_LIBL_NOYYWRAP)
(_AC_PROG_LEX_LIBL_COMPAT, _AC_PROG_LEX_TEST_COMMON)
(_AC_PROG_LEX_TEST_YYWRAP, _AC_PROG_LEX_TEST_NOYYWRAP):
New macros dividing up the rest of the labor formerly performed by
_AC_PROG_LEX_YYTEXT_DECL.
* tests/semantics.at
(AC_PROG_LEX with noyywrap): Rename “AC_PROG_LEX: noyywrap”.
(AC_PROG_LEX with yywrap): Rename “AC_PROG_LEX: yywrap”. No longer
necessary to skip this test on OSes where there is no -ll nor -lfl.
(AC_PROG_LEX in legacy mode): Rename “AC_PROG_LEX: compat mode.”
Convert to AT_CHECK_MACRO test using -Wno-obsolete.
(Invalid arguments to AC_PROG_LEX): Rename “AC_PROG_LEX: invalid
arguments and warnings.” Move the test for the warning
“AC_PROG_LEX without either yywrap or noyywrap is obsolete” here.
Adjust expected stack traces.
1364 lines
37 KiB
Plaintext
1364 lines
37 KiB
Plaintext
# -*- Autotest -*-
|
|
|
|
AT_BANNER([Semantics.])
|
|
|
|
# Copyright (C) 2000-2002, 2004-2007, 2009-2017, 2020-2023 Free Software
|
|
# Foundation, Inc.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 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.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
|
|
## -------------------------------- ##
|
|
## Members of the AC_CHECK family. ##
|
|
## -------------------------------- ##
|
|
|
|
|
|
# AC_CHECK_LIB
|
|
# ------------
|
|
# 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)
|
|
])
|
|
|
|
# Using : for the ACTION-IF-FOUND in each call to AC_CHECK_LIB
|
|
# prevents LIBS from accumulating copies of "-lz".
|
|
|
|
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
|
|
|
|
|
|
# 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_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
|
|
|
|
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
|
|
|
|
# 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_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
|
|
# --------------
|
|
# 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)
|
|
# ----------------------------
|
|
# 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
|
|
# --------------
|
|
# Check that it performs the correct actions:
|
|
AT_CHECK_MACRO([AC_CHECK_DECLS],
|
|
[[AC_CHECK_DECLS([yes, no, myenum, mystruct, myfunc, mymacro1, mymacro2],,,
|
|
[[extern int yes;
|
|
enum { myenum };
|
|
extern struct mystruct_s { int x[20]; } mystruct;
|
|
extern int myfunc (int);
|
|
#define mymacro1(arg) arg
|
|
#define mymacro2]])
|
|
# Ensure we can detect missing declarations of functions whose
|
|
# signature may be built into the compiler.
|
|
AC_CHECK_DECLS([memcpy, strchr, strerror],,, [[]])
|
|
# The difference in space-before-open-paren is intentional.
|
|
AC_CHECK_DECLS([basenam (char *), dirnam(char *),
|
|
moreargs (char, short, int, long, void *, char *, float, double)],,,
|
|
[[#ifdef __cplusplus
|
|
extern "C++" char *basenam (char *);
|
|
extern "C++" const char *basenam (const char *);
|
|
#else
|
|
extern char *basenam (const char *);
|
|
#endif
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
extern int moreargs (char, short, int, long, void *,
|
|
char [], float, double);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
]])
|
|
AC_CHECK_DECL([declared (char *)],, [AS_EXIT([1])],
|
|
[[#ifdef __cplusplus
|
|
extern "C++" char *declared (char *);
|
|
extern "C++" const char *declared (const char *);
|
|
#else
|
|
extern char *declared (const char *);
|
|
#endif
|
|
]])
|
|
AC_LANG_WERROR
|
|
AC_CHECK_DECL([undeclared (char *)], [AS_EXIT([1])],, [[]])
|
|
if test -z "$ac_[]_AC_LANG_ABBREV[]_werror_flag"; then
|
|
AC_MSG_ERROR([ac_]_AC_LANG_ABBREV[_werror_flag overwritten])
|
|
fi
|
|
]],
|
|
[AT_CHECK_DEFINES(
|
|
[#define HAVE_DECL_BASENAM 1
|
|
#define HAVE_DECL_DIRNAM 0
|
|
#define HAVE_DECL_MEMCPY 0
|
|
#define HAVE_DECL_MOREARGS 1
|
|
#define HAVE_DECL_MYENUM 1
|
|
#define HAVE_DECL_MYFUNC 1
|
|
#define HAVE_DECL_MYMACRO1 1
|
|
#define HAVE_DECL_MYMACRO2 1
|
|
#define HAVE_DECL_MYSTRUCT 1
|
|
#define HAVE_DECL_NO 0
|
|
#define HAVE_DECL_STRCHR 0
|
|
#define HAVE_DECL_STRERROR 0
|
|
#define HAVE_DECL_YES 1
|
|
])])
|
|
|
|
|
|
# AC_CHECK_FUNCS
|
|
# --------------
|
|
# Check that it performs the correct actions:
|
|
# Must define HAVE_PRINTF, but not HAVE_AUTOCONF_FTNIRP
|
|
AT_CHECK_MACRO([AC_CHECK_FUNCS],
|
|
[AC_CHECK_FUNCS(printf autoconf_ftnirp)],
|
|
[AT_CHECK_DEFINES(
|
|
[/* #undef HAVE_AUTOCONF_FTNIRP */
|
|
#define HAVE_PRINTF 1
|
|
])])
|
|
|
|
|
|
# AC_REPLACE_FUNCS
|
|
# ----------------
|
|
# Check that it performs the correct actions: autoconf_ftnirp.c must
|
|
# be compiled, and must define HAVE_PRINTF, but not HAVE_AUTOCONF_FTNIRP
|
|
# FIXME: Maybe check the traces?
|
|
AT_SETUP([AC_REPLACE_FUNCS])
|
|
|
|
AT_DATA([config.in],
|
|
[@LIBOBJS@
|
|
])
|
|
|
|
# AC_REPLACE_FUNCS has an AS_LITERAL_IF optimization; test both paths.
|
|
# Manual invocation of AH_TEMPLATE should only be necessary for functions
|
|
# whose names are hidden inside a shell variable at m4 expansion time.
|
|
AT_CONFIGURE_AC(
|
|
[[AC_CONFIG_FILES([config.libobjs:config.in])
|
|
AC_REPLACE_FUNCS([printf autoconf_ftnirp])
|
|
funcs='fprintf autoconf_ftnirpf'
|
|
AH_TEMPLATE([HAVE_FPRINTF], [])
|
|
AH_TEMPLATE([HAVE_AUTOCONF_FTNIRPF], [])
|
|
AC_REPLACE_FUNCS([\
|
|
$funcs \
|
|
fopen \
|
|
autoconf_nepof])
|
|
AS@&t@_UNSET([funcs])]])
|
|
|
|
AT_CHECK_AUTOCONF([], [], [],
|
|
[[configure.ac:9: warning: AC_REPLACE_FUNCS($funcs): you should use literals
|
|
functions.m4: AC_REPLACE_FUNCS is expanded from...
|
|
configure.ac:9: the top level
|
|
]])
|
|
AT_CHECK_AUTOHEADER([], [
|
|
HAVE_AUTOCONF_FTNIRP
|
|
HAVE_AUTOCONF_FTNIRPF
|
|
HAVE_AUTOCONF_NEPOF
|
|
HAVE_FOPEN
|
|
HAVE_FPRINTF
|
|
HAVE_PRINTF
|
|
])
|
|
AT_CHECK_CONFIGURE
|
|
AT_CHECK_ENV
|
|
AT_CHECK_DEFINES(
|
|
[/* #undef HAVE_AUTOCONF_FTNIRP */
|
|
/* #undef HAVE_AUTOCONF_FTNIRPF */
|
|
/* #undef HAVE_AUTOCONF_NEPOF */
|
|
#define HAVE_FOPEN 1
|
|
#define HAVE_FPRINTF 1
|
|
#define HAVE_PRINTF 1
|
|
])
|
|
|
|
AT_CHECK([sed 's/ */ /g;s/^ //;s/ $//' config.libobjs | tr ' ' '
|
|
' | sort], [],
|
|
[${LIBOBJDIR}autoconf_ftnirp$U.o
|
|
${LIBOBJDIR}autoconf_ftnirpf$U.o
|
|
${LIBOBJDIR}autoconf_nepof$U.o
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# AC_CHECK_HEADERS
|
|
# ----------------
|
|
# Check that it performs the correct actions:
|
|
# Must define HAVE_FLOAT_H, but not HAVE_AUTOCONF_IO_H.
|
|
AT_SETUP([AC_CHECK_HEADERS])
|
|
|
|
AT_DATA([autoconf_io.h],
|
|
[blah blah
|
|
])
|
|
|
|
AT_CONFIGURE_AC([AC_CHECK_HEADERS([float.h autoconf_io.h])])
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK_AUTOHEADER([], [
|
|
HAVE_AUTOCONF_IO_H
|
|
HAVE_FLOAT_H
|
|
HAVE_INTTYPES_H
|
|
HAVE_STDINT_H
|
|
HAVE_STDIO_H
|
|
HAVE_STDLIB_H
|
|
HAVE_STRINGS_H
|
|
HAVE_STRING_H
|
|
HAVE_SYS_STAT_H
|
|
HAVE_SYS_TYPES_H
|
|
HAVE_UNISTD_H
|
|
STDC_HEADERS
|
|
])
|
|
AT_CHECK_CONFIGURE([CPPFLAGS=-I.])
|
|
AT_CHECK_ENV
|
|
AT_CHECK_DEFINES(
|
|
[/* #undef HAVE_AUTOCONF_IO_H */
|
|
#define HAVE_FLOAT_H 1
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# AC_CHECK_HEADERS_OLD
|
|
# --------------------
|
|
# Check that it performs the correct actions:
|
|
# Must not check prerequisites, hence define header2.h
|
|
AT_SETUP([AC_CHECK_HEADERS (preprocessor test)])
|
|
|
|
AT_DATA([header1.h],
|
|
[typedef int foo;
|
|
])
|
|
|
|
AT_DATA([header2.h],
|
|
[typedef foo bar;
|
|
])
|
|
|
|
AT_CONFIGURE_AC([[AC_CHECK_HEADERS([header2.h], [], [], [-])]])
|
|
|
|
AT_CHECK_AUTOCONF([], 0, [],
|
|
[[configure.ac:4: warning: Checking for headers with the preprocessor is
|
|
configure.ac:4: deprecated. Specify prerequisite code to AC_CHECK_HEADER
|
|
configure.ac:4: instead of using fourth argument '-'. (Many headers need
|
|
configure.ac:4: no prerequisites. If you truly need to test whether
|
|
configure.ac:4: something passes the preprocessor but not the compiler,
|
|
configure.ac:4: use AC_PREPROC_IFELSE.)
|
|
headers.m4: _AC_CHECK_HEADER_PREPROC is expanded from...
|
|
headers.m4: AC_CHECK_HEADER is expanded from...
|
|
headers.m4: AC_CHECK_HEADERS is expanded from...
|
|
configure.ac:4: the top level
|
|
]])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [HAVE_HEADER2_H])
|
|
AT_CHECK_CONFIGURE([CPPFLAGS=-I.])
|
|
AT_CHECK_ENV
|
|
AT_CHECK_DEFINES(
|
|
[#define HAVE_HEADER2_H 1
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# AC_CHECK_HEADERS_NEW
|
|
# --------------------
|
|
# Check that it performs the correct actions:
|
|
# Must check prerequisites, hence define header2.h but not header3.h
|
|
AT_SETUP([AC_CHECK_HEADERS (compiler test)])
|
|
|
|
AT_DATA([header1.h],
|
|
[typedef int foo;
|
|
])
|
|
|
|
AT_DATA([header2.h],
|
|
[typedef foo bar;
|
|
])
|
|
|
|
AT_DATA([header3.h],
|
|
[typedef bar wow;
|
|
])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[AC_CHECK_HEADERS(header2.h header3.h, [], [], [[@%:@include "header1.h"]])])
|
|
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK_AUTOHEADER([], [
|
|
HAVE_HEADER2_H
|
|
HAVE_HEADER3_H
|
|
])
|
|
AT_CHECK_CONFIGURE([CPPFLAGS=-I.])
|
|
AT_CHECK_ENV
|
|
AT_CHECK_DEFINES(
|
|
[#define HAVE_HEADER2_H 1
|
|
/* #undef HAVE_HEADER3_H */
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# AC_CHECK_MEMBER
|
|
# ---------------
|
|
# Check that it performs the correct actions.
|
|
# Must define HAVE_STRUCT_YES_S_YES, but not HAVE_STRUCT_YES_S_NO.
|
|
AT_CHECK_MACRO([AC_CHECK_MEMBER],
|
|
[[AC_CHECK_MEMBER([struct yes_s.yes],
|
|
[AC_DEFINE([HAVE_STRUCT_YES_S_YES], [1],
|
|
[Define to 1 if 'yes' is a member of 'struct yes_s'.])],,
|
|
[struct sub { int x; };
|
|
struct yes_s { int yes; struct sub substruct; };])
|
|
AC_CHECK_MEMBER([struct yes_s.no],
|
|
[AC_DEFINE([HAVE_STRUCT_YES_S_NO], [1],
|
|
[Define to 1 if 'no' is a member of 'struct yes_s'.])],,
|
|
[struct sub { int x; };
|
|
struct yes_s { int yes; struct sub substruct; };])
|
|
AC_CHECK_MEMBER([struct yes_s.substruct],
|
|
[AC_DEFINE([HAVE_STRUCT_YES_S_SUBSTRUCT], [1],
|
|
[Define to 1 if 'substruct' is a member of 'struct yes_s'.])],,
|
|
[struct sub { int x; };
|
|
struct yes_s { int yes; struct sub substruct; };])]],
|
|
[AT_CHECK_DEFINES(
|
|
[/* #undef HAVE_STRUCT_YES_S_NO */
|
|
#define HAVE_STRUCT_YES_S_SUBSTRUCT 1
|
|
#define HAVE_STRUCT_YES_S_YES 1
|
|
])])
|
|
|
|
# AC_CHECK_MEMBERS
|
|
# ----------------
|
|
# Check that it performs the correct actions.
|
|
# Must define HAVE_STRUCT_YES_S_YES, but not HAVE_STRUCT_YES_S_NO.
|
|
AT_CHECK_MACRO([AC_CHECK_MEMBERS],
|
|
[[AC_CHECK_MEMBERS([struct yes_s.yes, struct yes_s.no, struct yes_s.substruct],,,
|
|
[struct sub { int x; };
|
|
struct yes_s { int yes; struct sub substruct; };])]],
|
|
[AT_CHECK_DEFINES(
|
|
[/* #undef HAVE_STRUCT_YES_S_NO */
|
|
#define HAVE_STRUCT_YES_S_SUBSTRUCT 1
|
|
#define HAVE_STRUCT_YES_S_YES 1
|
|
])
|
|
AT_CHECK([grep 'yes.*member of.*yes_s' config.h], [], [ignore])
|
|
])
|
|
|
|
|
|
# AC_CHECK_ALIGNOF
|
|
# ----------------
|
|
AT_CHECK_MACRO([AC_CHECK_ALIGNOF],
|
|
[[AC_CHECK_ALIGNOF(char)
|
|
AC_CHECK_ALIGNOF(charchar,
|
|
[[#include <stddef.h>
|
|
#include <stdio.h>
|
|
typedef char charchar[2];]])
|
|
AC_CHECK_ALIGNOF(charcharchar)
|
|
]],
|
|
[AT_CHECK_DEFINES(
|
|
[#define ALIGNOF_CHAR 1
|
|
#define ALIGNOF_CHARCHAR 1
|
|
#define ALIGNOF_CHARCHARCHAR 0
|
|
])])
|
|
|
|
|
|
# AC_CHECK_ALIGNOF struct
|
|
# -----------------------
|
|
AT_CHECK_MACRO([AC_CHECK_ALIGNOF struct],
|
|
[[AC_CHECK_ALIGNOF([struct { char c; }])
|
|
AC_CHECK_ALIGNOF([struct nosuchstruct])
|
|
]],
|
|
[AT_CHECK([[grep "#define ALIGNOF_STRUCT___CHAR_C___ [1-9]" config.h]],
|
|
0, ignore)
|
|
AT_CHECK([[grep "#define ALIGNOF_STRUCT_NOSUCHSTRUCT 0" config.h]],
|
|
0, ignore)
|
|
])
|
|
|
|
# AC_CHECK_SIZEOF
|
|
# ---------------
|
|
AT_CHECK_MACRO([AC_CHECK_SIZEOF],
|
|
[[AC_CHECK_SIZEOF(char)
|
|
AC_CHECK_SIZEOF(charchar,,
|
|
[[#include <stdio.h>
|
|
typedef char charchar[2];]])
|
|
AC_CHECK_SIZEOF(charcharchar)
|
|
]],
|
|
[AT_CHECK_DEFINES(
|
|
[#define SIZEOF_CHAR 1
|
|
#define SIZEOF_CHARCHAR 2
|
|
#define SIZEOF_CHARCHARCHAR 0
|
|
])])
|
|
|
|
|
|
# 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; };])
|
|
AC_CHECK_SIZEOF([struct nosuchstruct])
|
|
# Taken from autoconf.texi:Generic Compiler Characteristics.
|
|
AC_CHECK_SIZEOF([int *])
|
|
]],
|
|
[AT_CHECK([[grep "#define SIZEOF_STRUCT_X [1-9]" config.h]],
|
|
0, ignore)
|
|
AT_CHECK([[grep "#define SIZEOF_CONST_STRUCT_X [1-9]" config.h]],
|
|
0, ignore)
|
|
AT_CHECK([[grep "#define SIZEOF_STRUCT_NOSUCHSTRUCT 0" config.h]],
|
|
0, ignore)
|
|
AT_CHECK([[grep "#define SIZEOF_INT_P [1-9]" config.h]],
|
|
0, ignore)
|
|
])
|
|
|
|
|
|
# AC_CHECK_TYPES
|
|
# --------------
|
|
# Check that it performs the correct actions.
|
|
# Must define HAVE_STRUCT_YES_S, HAVE_INT, but not HAVE_STRUCT_NO_S.
|
|
# 'int' and 'struct yes_s' are both checked to test both the compiler
|
|
# builtin types, and defined types.
|
|
AT_CHECK_MACRO([AC_CHECK_TYPES],
|
|
[[AC_CHECK_TYPES([int, struct yes_s, struct no_s],,,
|
|
[struct yes_s { int yes ;} ;])]],
|
|
[AT_CHECK_DEFINES(
|
|
[#define HAVE_INT 1
|
|
/* #undef HAVE_STRUCT_NO_S */
|
|
#define HAVE_STRUCT_YES_S 1
|
|
])])
|
|
|
|
|
|
# AC_CHECK_TYPES
|
|
# --------------
|
|
# Check that we properly dispatch properly to the old implementation
|
|
# or to the new one.
|
|
AT_SETUP([AC_CHECK_TYPES: backward compatibility])
|
|
|
|
AT_DATA([configure.ac],
|
|
[[AC_INIT
|
|
define([_AC_CHECK_TYPE_NEW], [NEW])
|
|
define([_AC_CHECK_TYPE_OLD], [OLD])
|
|
#(cut-from-here
|
|
AC_CHECK_TYPE(ptrdiff_t)
|
|
AC_CHECK_TYPE(ptrdiff_t, int)
|
|
AC_CHECK_TYPE(quad, long long int)
|
|
AC_CHECK_TYPE(table_42, [int[42]])
|
|
# Nice machine!
|
|
AC_CHECK_TYPE(uint8_t, uint65536_t)
|
|
AC_CHECK_TYPE(a,b,c,d)
|
|
#to-here)
|
|
AC_OUTPUT
|
|
]])
|
|
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK([[sed -e '/^#(cut-from-here/,/^#to-here)/!d' -e '/^#/d' configure]],
|
|
0,
|
|
[NEW
|
|
OLD
|
|
OLD
|
|
OLD
|
|
OLD
|
|
NEW
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# AC_CHECK_FILES
|
|
# --------------
|
|
# 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.
|
|
# 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]],
|
|
[], [],
|
|
[AT_CHECK_DEFINES(
|
|
[#define HAVE_AT_EXISTS1 1
|
|
/* #undef HAVE_AT_MISSING1 */
|
|
])])
|
|
|
|
|
|
|
|
## ------------------------------ ##
|
|
## AC_CHECK_PROG & AC_PATH_PROG. ##
|
|
## ------------------------------ ##
|
|
|
|
|
|
# AT_CHECK_PROGS_PREPARE
|
|
# ----------------------
|
|
# Create a sub directory 'path' with 6 subdirs which all 7 contain
|
|
# an executable 'tool'. '6' contains a 'better' tool.
|
|
m4_define([AT_CHECK_PROGS_PREPARE],
|
|
[mkdir path
|
|
|
|
cat >path/tool <<\EOF
|
|
#! /bin/sh
|
|
exit 0
|
|
EOF
|
|
chmod +x path/tool
|
|
|
|
for i in 1 2 3 4 5 6
|
|
do
|
|
mkdir path/$i
|
|
cp path/tool path/$i
|
|
done
|
|
cp path/tool path/6/better])
|
|
|
|
|
|
# -------------------------------- #
|
|
# AC_CHECK_PROG & AC_CHECK_PROGS. #
|
|
# -------------------------------- #
|
|
|
|
AT_SETUP([AC_CHECK_PROG & AC_CHECK_PROGS])
|
|
|
|
AT_CHECK_PROGS_PREPARE
|
|
|
|
AT_DATA([configure.ac],
|
|
[[AC_INIT
|
|
pwd=`pwd`
|
|
p="1${PATH_SEPARATOR}2${PATH_SEPARATOR}3${PATH_SEPARATOR}4${PATH_SEPARATOR}5${PATH_SEPARATOR}6"
|
|
path=`echo $p | sed -e 's,\([[0-9]]\),'"$pwd"'/path/\1,g'`
|
|
fail=false
|
|
|
|
AC_CHECK_PROG(TOOL1, tool, found, not-found, $path)
|
|
test "$TOOL1" = found || fail=:
|
|
|
|
# Yes, the semantics of this macro is weird.
|
|
AC_CHECK_PROG(TOOL2, tool,, not-found, $path)
|
|
test "$TOOL2" = not-found || fail=:
|
|
|
|
AC_CHECK_PROG(TOOL3, tool, tool, not-found, $path, $pwd/path/1/tool)
|
|
test "$TOOL3" = "$pwd/path/2/tool" || fail=:
|
|
|
|
AC_CHECK_PROG(TOOL4, better, better, not-found, $path, $pwd/path/1/tool)
|
|
test "$TOOL4" = better || fail=:
|
|
|
|
# When a tool is not found, and no value is given for not-found,
|
|
# the variable is left empty.
|
|
AC_CHECK_PROGS(TOOL5, missing,, $path)
|
|
test -z "$TOOL5" || fail=:
|
|
|
|
AC_CHECK_PROGS(TOOL6, missing tool better,, $path)
|
|
test "$TOOL6" = tool || fail=:
|
|
|
|
$fail &&
|
|
AC_MSG_ERROR([[CHECK_PROG failed]])
|
|
|
|
AC_OUTPUT
|
|
]])
|
|
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK_CONFIGURE
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
|
|
## ---------------- ##
|
|
## AC_C_BIGENDIAN. ##
|
|
## ---------------- ##
|
|
|
|
AT_SETUP([AC_C_BIGENDIAN])
|
|
AT_KEYWORDS([cross])
|
|
|
|
# Make sure that AC_C_BIGENDIAN behave the same whether we are
|
|
# cross-compiling or not.
|
|
|
|
_AT_CHECK_AC_MACRO(
|
|
[[AC_C_BIGENDIAN(
|
|
[ac_endian=big],
|
|
[ac_endian=little],
|
|
[ac_endian=unknown],
|
|
[ac_endian=universal])
|
|
echo $ac_endian > at-endian
|
|
]])
|
|
|
|
rm -f config.hin # So that next run of autoheader is quiet.
|
|
_AT_CHECK_AC_MACRO(
|
|
[[# Force cross compiling.
|
|
cross_compiling=yes
|
|
ac_tool_warned=yes
|
|
AC_C_BIGENDIAN(
|
|
[ac_endian=big],
|
|
[ac_endian=little],
|
|
[ac_endian=unknown],
|
|
[ac_endian=universal])
|
|
ac_prevendian=`cat at-endian`
|
|
# Check that we have found the same result as in the previous run
|
|
# or unknown (because the cross-compiling check is allowed to fail;
|
|
# although it might be interesting to suppress this comparison, just
|
|
# to know on which system it fails if it ever does).
|
|
if test $ac_endian != $ac_prevendian && test $ac_endian != unknown; then
|
|
AC_MSG_ERROR([unexpected endianness: first run found '$ac_prevendian' but second run found '$ac_endian'])
|
|
fi
|
|
]])
|
|
|
|
# Make sure AC_C_BIGENDIAN with no argument will create a config.h template
|
|
# containing "WORDS_BIGENDIAN".
|
|
AT_CONFIGURE_AC([[AC_C_BIGENDIAN]])
|
|
# --force is necessary, the computer might be too fast.
|
|
AT_CHECK_AUTOHEADER([--force], [
|
|
AC_APPLE_UNIVERSAL_BUILD
|
|
HAVE_INTTYPES_H
|
|
HAVE_STDINT_H
|
|
HAVE_STDIO_H
|
|
HAVE_STDLIB_H
|
|
HAVE_STRINGS_H
|
|
HAVE_STRING_H
|
|
HAVE_SYS_STAT_H
|
|
HAVE_SYS_TYPES_H
|
|
HAVE_UNISTD_H
|
|
STDC_HEADERS
|
|
WORDS_BIGENDIAN
|
|
])
|
|
AT_CHECK([grep WORDS_BIGENDIAN config.hin], [], [ignore])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
# ------------------------------ #
|
|
# AC_PATH_PROG & AC_PATH_PROGS. #
|
|
# ------------------------------ #
|
|
|
|
AT_SETUP([AC_PATH_PROG & AC_PATH_PROGS])
|
|
|
|
AT_CHECK_PROGS_PREPARE
|
|
|
|
AT_DATA([configure.ac],
|
|
[[AC_INIT
|
|
pwd=`pwd`
|
|
p="1${PATH_SEPARATOR}2${PATH_SEPARATOR}3${PATH_SEPARATOR}4${PATH_SEPARATOR}5${PATH_SEPARATOR}6"
|
|
path=`echo $p | sed -e 's,\([[0-9]]\),'"$pwd"'/path/\1,g'`
|
|
fail=false
|
|
|
|
AC_PATH_PROG(TOOL1, tool, not-found, $path)
|
|
test "$TOOL1" = "$pwd/path/1/tool" || fail=:
|
|
|
|
AC_PATH_PROG(TOOL2, better, not-found, $path)
|
|
test "$TOOL2" = "$pwd/path/6/better" || fail=:
|
|
|
|
# When a tool is not found, and no value is given for not-found,
|
|
# the variable is left empty.
|
|
AC_PATH_PROGS(TOOL3, missing,, $path)
|
|
test -z "$TOOL3" || fail=:
|
|
|
|
AC_PATH_PROGS(TOOL4, missing tool better,, $path)
|
|
test "$TOOL4" = "$pwd/path/1/tool" || fail=:
|
|
|
|
$fail &&
|
|
AC_MSG_ERROR([[PATH_PROG failed]])
|
|
|
|
AC_OUTPUT
|
|
]])
|
|
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK_CONFIGURE
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
|
|
# ----------------------------- #
|
|
# AC_PATH_PROGS_FEATURE_CHECK. #
|
|
# ----------------------------- #
|
|
|
|
AT_SETUP([AC_PATH_PROGS_FEATURE_CHECK])
|
|
|
|
# This test doesn't work if `pwd` contains white space
|
|
case `pwd` in
|
|
*\ * | *\ *) AT_CHECK([exit 77]) ;;
|
|
esac
|
|
|
|
AT_CHECK_PROGS_PREPARE
|
|
|
|
AT_DATA([configure.ac],
|
|
[[AC_INIT
|
|
pwd=`pwd`
|
|
p="1${PATH_SEPARATOR}2${PATH_SEPARATOR}3${PATH_SEPARATOR}4${PATH_SEPARATOR}5${PATH_SEPARATOR}6"
|
|
path=`echo $p | sed -e 's,\([[0-9]]\),'"$pwd"'/path/\1,g'`
|
|
fail=false
|
|
|
|
# Find first candidate and stop search
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL1, [tool better],
|
|
[$ac_path_TOOL1 && ac_cv_path_TOOL1=$ac_path_TOOL1 ac_path_TOOL1_found=:],
|
|
fail=:, $path)
|
|
test -z "$TOOL1" || fail=:
|
|
test "$ac_cv_path_TOOL1" = "$pwd/path/1/tool" || fail=:
|
|
|
|
# Keep searching each candidate
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL2, [tool better],
|
|
[$ac_path_TOOL2 && ac_cv_path_TOOL2=$ac_path_TOOL2],
|
|
fail=:, $path)
|
|
test "$ac_cv_path_TOOL2" = "$pwd/path/6/better" || fail=:
|
|
|
|
# Only accept better candidate
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL3, [tool better],
|
|
[case "$ac_path_TOOL3" in #(
|
|
*better) ac_cv_path_TOOL3=$ac_path_TOOL3;;
|
|
esac],
|
|
fail=:, $path)
|
|
test "$ac_cv_path_TOOL3" = "$pwd/path/6/better" || fail=:
|
|
|
|
# When a tool is not found, and no action is given for not-found,
|
|
# the variable is left empty.
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL4, missing,
|
|
[ac_cv_path_TOOL4=$ac_path_TOOL4], [], $path)
|
|
test -z "$ac_cv_path_TOOL4" || fail=:
|
|
|
|
# Test action when tool is not found
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL5, missing, [],
|
|
[ac_cv_path_TOOL5='not found'], $path)
|
|
test "$ac_cv_path_TOOL5" = "not found" || fail=:
|
|
|
|
# Test that pre-set tool bypasses feature test
|
|
TOOL6=$pwd/path/6/better
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL6, tool, fail=:, fail=:, $path)
|
|
test "$ac_cv_path_TOOL6" = "$pwd/path/6/better" || fail=:
|
|
|
|
# A blank pre-set does not bypass feature test
|
|
TOOL7=
|
|
AC_PATH_PROGS_FEATURE_CHECK(TOOL7, [tool better],
|
|
[$ac_path_TOOL7 && ac_cv_path_TOOL7=$ac_path_TOOL7 ac_path_TOOL7_found=:],
|
|
fail=:, $path)
|
|
test -z "$TOOL7" || fail=:
|
|
test "$ac_cv_path_TOOL7" = "$pwd/path/1/tool" || fail=:
|
|
|
|
$fail &&
|
|
AC_MSG_ERROR([[PATH_PROG failed]])
|
|
|
|
AC_OUTPUT
|
|
]])
|
|
|
|
AT_CHECK_AUTOCONF
|
|
AT_CHECK_CONFIGURE
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
|
|
|
|
## -------------- ##
|
|
## AC_PATH_XTRA. ##
|
|
## -------------- ##
|
|
|
|
|
|
AT_SETUP([AC_PATH_XTRA])
|
|
|
|
_AT_CHECK_AC_MACRO([AC_PATH_XTRA])
|
|
|
|
# Check X_DISPLAY_MISSING.
|
|
AT_CHECK_CONFIGURE([--without-x])
|
|
AT_CHECK_DEFINES(
|
|
[#define X_DISPLAY_MISSING 1
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
## ------------------------------- ##
|
|
## Obsolete non-updatable macros. ##
|
|
## ------------------------------- ##
|
|
|
|
|
|
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], [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])
|
|
]])
|
|
|
|
|
|
## ----------------------------------------- ##
|
|
## Expansion of whitespace-separated lists. ##
|
|
## ----------------------------------------- ##
|
|
|
|
|
|
m4_define([AT_CHECK_EXPANSION_IN_FUNCS],
|
|
[AT_SETUP([Macro expansion in $1]m4_if([$2],[literal],[],[ (literal)]))
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([fn_bar],[fn_quux])
|
|
$1([dn@&t@l
|
|
fn_foo dn@&t@l
|
|
fn_nocomment
|
|
fn_bar dn@&t@l Ordinary comment
|
|
fn_blurf dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:6: warning: whitespace-separated list contains macros;
|
|
configure.ac:6: in a future version of Autoconf they will not be expanded
|
|
configure.ac:6: note: 'dn@&t@l' is a macro
|
|
functions.m4: $1 is expanded from...
|
|
configure.ac:6: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [
|
|
HAVE_FN_BLURF
|
|
HAVE_FN_FOO
|
|
HAVE_FN_NOCOMMENT
|
|
HAVE_FN_QUUX
|
|
])
|
|
AT_CHECK_CONFIGURE
|
|
AT_CLEANUP
|
|
|
|
m4_if([$2], [literal], [], [
|
|
AT_SETUP([Macro expansion in $1 (variable)])
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([fn_bar],[fn_quux])
|
|
fns="fn_foo" _AH_CHECK_FUNC([fn_foo])
|
|
fns="$fns fn_nocomment" _AH_CHECK_FUNC([fn_nocomment])
|
|
$1([dn@&t@l
|
|
$[]fns
|
|
fn_bar dn@&t@l Ordinary comment
|
|
fn_blurf dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:8: warning: whitespace-separated list contains macros;
|
|
configure.ac:8: in a future version of Autoconf they will not be expanded
|
|
configure.ac:8: note: 'dn@&t@l' is a macro
|
|
functions.m4: $1 is expanded from...
|
|
configure.ac:8: the top level
|
|
configure.ac:8: warning: $1($fns): you should use literals
|
|
functions.m4: $1 is expanded from...
|
|
configure.ac:8: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [
|
|
HAVE_FN_BLURF
|
|
HAVE_FN_FOO
|
|
HAVE_FN_NOCOMMENT
|
|
HAVE_FN_QUUX
|
|
])
|
|
AT_CHECK_CONFIGURE
|
|
AT_CLEANUP
|
|
])])
|
|
|
|
m4_define([AT_CHECK_EXPANSION_IN_HEADERS],
|
|
[AT_SETUP([Macro expansion in $1]m4_if([$2],[literal],[],[ (literal)]))
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([bar],[quux])
|
|
$1([dn@&t@l
|
|
foo.h dn@&t@l
|
|
nocomment.h
|
|
bar.h dn@&t@l Ordinary comment
|
|
blurf.h dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:6: warning: whitespace-separated list contains macros;
|
|
configure.ac:6: in a future version of Autoconf they will not be expanded
|
|
configure.ac:6: note: 'dn@&t@l' is a macro
|
|
headers.m4: $1 is expanded from...
|
|
configure.ac:6: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [
|
|
HAVE_BLURF_H
|
|
HAVE_FOO_H
|
|
HAVE_INTTYPES_H
|
|
HAVE_NOCOMMENT_H
|
|
HAVE_QUUX_H
|
|
HAVE_STDINT_H
|
|
HAVE_STDIO_H
|
|
HAVE_STDLIB_H
|
|
HAVE_STRINGS_H
|
|
HAVE_STRING_H
|
|
HAVE_SYS_STAT_H
|
|
HAVE_SYS_TYPES_H
|
|
HAVE_UNISTD_H
|
|
STDC_HEADERS
|
|
])
|
|
AT_CHECK_CONFIGURE
|
|
AT_CLEANUP
|
|
|
|
m4_if([$2], [literal], [], [
|
|
AT_SETUP([Macro expansion in $1 (variable)])
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([bar],[quux])
|
|
hs="foo.h" _AH_CHECK_HEADER([foo.h])
|
|
hs="$hs nocomment.h" _AH_CHECK_HEADER([nocomment.h])
|
|
$1([dn@&t@l
|
|
$[]hs
|
|
bar.h dn@&t@l Ordinary comment
|
|
blurf.h dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:8: warning: whitespace-separated list contains macros;
|
|
configure.ac:8: in a future version of Autoconf they will not be expanded
|
|
configure.ac:8: note: 'dn@&t@l' is a macro
|
|
headers.m4: $1 is expanded from...
|
|
configure.ac:8: the top level
|
|
configure.ac:8: warning: $1($hs): you should use literals
|
|
headers.m4: $1 is expanded from...
|
|
configure.ac:8: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [
|
|
HAVE_BLURF_H
|
|
HAVE_FOO_H
|
|
HAVE_INTTYPES_H
|
|
HAVE_NOCOMMENT_H
|
|
HAVE_QUUX_H
|
|
HAVE_STDINT_H
|
|
HAVE_STDIO_H
|
|
HAVE_STDLIB_H
|
|
HAVE_STRINGS_H
|
|
HAVE_STRING_H
|
|
HAVE_SYS_STAT_H
|
|
HAVE_SYS_TYPES_H
|
|
HAVE_UNISTD_H
|
|
STDC_HEADERS
|
|
])
|
|
AT_CHECK_CONFIGURE
|
|
AT_CLEANUP
|
|
])])
|
|
|
|
AT_CHECK_EXPANSION_IN_FUNCS([AC_CHECK_FUNCS])
|
|
AT_CHECK_EXPANSION_IN_FUNCS([AC_CHECK_FUNCS_ONCE], [literal])
|
|
AT_CHECK_EXPANSION_IN_FUNCS([AC_REPLACE_FUNCS])
|
|
|
|
AT_CHECK_EXPANSION_IN_HEADERS([AC_CHECK_HEADERS])
|
|
AT_CHECK_EXPANSION_IN_HEADERS([AC_CHECK_HEADERS_ONCE], [literal])
|
|
|
|
AT_SETUP([Macro expansion in AC_CHECK_FILES])
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([f_bar], [f_quux])
|
|
AC_CHECK_FILES([dn@&t@l
|
|
/nonex/f_foo
|
|
/nonex/f_bar dn@&t@l Ordinary comment
|
|
/nonex/f_blurf dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:6: warning: whitespace-separated list contains macros;
|
|
configure.ac:6: in a future version of Autoconf they will not be expanded
|
|
configure.ac:6: note: 'dn@&t@l' is a macro
|
|
general.m4: AC_CHECK_FILES is expanded from...
|
|
configure.ac:6: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete], [
|
|
HAVE__NONEX_F_BLURF
|
|
HAVE__NONEX_F_FOO
|
|
HAVE__NONEX_F_QUUX
|
|
])
|
|
|
|
AT_CHECK_CONFIGURE
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([Macro expansion in AC_CONFIG_MACRO_DIRS])
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([d_bar], [d_quux])
|
|
AC_CONFIG_MACRO_DIRS([dn@&t@l
|
|
d_foo
|
|
d_bar dn@&t@l Ordinary comment
|
|
d_blurf dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([-t AC_CONFIG_MACRO_DIR_TRACE], [0],
|
|
[configure.ac:6:AC_CONFIG_MACRO_DIR_TRACE:d_foo
|
|
configure.ac:6:AC_CONFIG_MACRO_DIR_TRACE:d_quux
|
|
configure.ac:6:AC_CONFIG_MACRO_DIR_TRACE:d_blurf
|
|
],
|
|
[configure.ac:6: warning: whitespace-separated list contains macros;
|
|
configure.ac:6: in a future version of Autoconf they will not be expanded
|
|
configure.ac:6: note: 'dn@&t@l' is a macro
|
|
general.m4: AC_CONFIG_MACRO_DIRS is expanded from...
|
|
configure.ac:6: the top level
|
|
])
|
|
|
|
AT_CLEANUP
|
|
|
|
AT_SETUP([Macro expansion in AC_CONFIG_SUBDIRS])
|
|
|
|
(set -ex
|
|
for d in d_foo d_bar d_blurf d_quux; do
|
|
mkdir $d
|
|
printf '%s\n%s\n' '#! /bin/sh' "echo entered $d/configure" \
|
|
> $d/configure
|
|
chmod +x $d/configure
|
|
done)
|
|
|
|
AT_CONFIGURE_AC([[
|
|
m4@&t@_define([d_bar], [d_quux])
|
|
AC_CONFIG_SUBDIRS([dn@&t@l
|
|
d_foo
|
|
d_bar dn@&t@l Ordinary comment
|
|
d_blurf dn@&t@l Apos'trophed comment
|
|
])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[configure.ac:6: warning: whitespace-separated list contains macros;
|
|
configure.ac:6: in a future version of Autoconf they will not be expanded
|
|
configure.ac:6: note: 'dn@&t@l' is a macro
|
|
status.m4: AC_CONFIG_SUBDIRS is expanded from...
|
|
configure.ac:6: the top level
|
|
])
|
|
AT_CHECK_AUTOHEADER([-W no-obsolete])
|
|
AT_CHECK_CONFIGURE([], [0], [stdout])
|
|
AT_CHECK([grep '^entered' stdout], [0],
|
|
[[entered d_foo/configure
|
|
entered d_quux/configure
|
|
entered d_blurf/configure
|
|
]])
|
|
|
|
AT_CLEANUP
|
|
|
|
|
|
## ------------------------------------- ##
|
|
## AC_PROG_LEX with and without yywrap. ##
|
|
## ------------------------------------- ##
|
|
|
|
# We don't currently have a good way of verifying that each mode
|
|
# does what it's supposed to, but we can at least put them through
|
|
# their paces as much as the autogenerated AT_CHECK_MACRO invocation
|
|
# used to, back when AC_PROG_LEX took no arguments.
|
|
|
|
AT_CHECK_MACRO([AC_PROG_LEX: noyywrap],
|
|
[AC_PROG_LEX([noyywrap])])
|
|
|
|
AT_CHECK_MACRO([AC_PROG_LEX: yywrap],
|
|
[AC_PROG_LEX([yywrap])])
|
|
|
|
AT_CHECK_MACRO([AC_PROG_LEX: compat mode],
|
|
[AC_PROG_LEX], [], [-Wno-obsolete])
|
|
|
|
## ---------------------------------- ##
|
|
## Invalid arguments to AC_PROG_LEX. ##
|
|
## ---------------------------------- ##
|
|
|
|
AT_SETUP([AC_PROG_LEX: invalid arguments and warnings])
|
|
|
|
AT_CONFIGURE_AC([[AC_PROG_LEX]])
|
|
AT_CHECK_AUTOCONF([], [], [],
|
|
[[configure.ac:4: warning: AC_PROG_LEX without either yywrap or noyywrap is obsolete
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([nonsense])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: AC_PROG_LEX: unrecognized argument: nonsense
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([too],[many])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: too many arguments to AC_PROG_LEX
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([yywrap noyywrap])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: AC_PROG_LEX: yywrap and noyywrap are mutually exclusive
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([noyywrap yywrap])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: AC_PROG_LEX: yywrap and noyywrap are mutually exclusive
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([yywrap nonsense])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: AC_PROG_LEX: unrecognized argument: yywrap nonsense
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([nonsense noyywrap])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [1], [],
|
|
[[configure.ac:4: error: AC_PROG_LEX: unrecognized argument: nonsense noyywrap
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:4: the top level
|
|
autom4te: error: m4 failed with exit status: 1
|
|
]])
|
|
|
|
# A double invocation with matching arguments should be accepted
|
|
# without complaint. FIXME: verify that it runs the test only once.
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([noyywrap])
|
|
AC_PROG_LEX([noyywrap])
|
|
]])
|
|
AT_CHECK_AUTOCONF
|
|
|
|
# A double invocation with matching arguments should trigger a warning.
|
|
AT_CONFIGURE_AC(
|
|
[[AC_PROG_LEX([yywrap])
|
|
AC_PROG_LEX([noyywrap])
|
|
]])
|
|
AT_CHECK_AUTOCONF([], [0], [],
|
|
[[configure.ac:5: warning: AC_PROG_LEX used twice with mismatched options
|
|
programs.m4: _AC_PROG_LEX_1 is expanded from...
|
|
programs.m4: AC_PROG_LEX is expanded from...
|
|
configure.ac:5: the top level
|
|
]])
|
|
|
|
AT_CLEANUP
|