231 lines
11 KiB
Plaintext
231 lines
11 KiB
Plaintext
# checkbuild.m4 -*- Autoconf -*-
|
|
#==============================================================================
|
|
# Copyright (C)2003 by Eric Sunshine <sunshine@sunshineco.com>
|
|
#
|
|
# This library is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU Library General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# This library 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 Library General Public
|
|
# License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Library General Public License
|
|
# along with this library; if not, write to the Free Software Foundation,
|
|
# Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
#
|
|
#==============================================================================
|
|
AC_PREREQ([2.56])
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_SPLIT_TUPLE(TUPLE, OUTPUT-VARIABLES)
|
|
# Split a build-tuple into its component parts. A build tuple is
|
|
# constructed by CS_CREATE_TUPLE() and is comprised of compiler flags,
|
|
# linker flags, and library references. OUTPUT-VARIABLES is a
|
|
# comma-delimited list of shell variables which should receive the
|
|
# extracted compiler flags, linker flags, and library references,
|
|
# respectively.
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_SPLIT_TUPLE],
|
|
[CS_SPLIT([$1], [cs_dummy,$2], [@])
|
|
m4_map([_CS_SPLIT_TUPLE], [$2])])
|
|
|
|
AC_DEFUN([_CS_SPLIT_TUPLE],
|
|
[$1=`echo $$1 | sed 'y%@%:@% %'`
|
|
])
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_CREATE_TUPLE([CFLAGS], [LFLAGS], [LIBS])
|
|
# Construct a build-tuple which is comprised of compiler flags, linker
|
|
# flags, and library references. Build tuples are encoded so as to
|
|
# preserve whitespace in each component. This makes it possible for
|
|
# macros (such as CS_BUILD_IFELSE) which employ build tuples to accept
|
|
# whitespace-delimited lists of tuples, and for shell "for" statements to
|
|
# iterate over tuple lists without compromising whitespace embedded
|
|
# within individual flags or library references.
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_CREATE_TUPLE], [`echo @$1@$2@$3 | sed 'y% %@%:@%'`])
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_LANG_CFLAGS
|
|
# Return the literal string CFLAGS if the current language is C. Return
|
|
# the literal string CXXFLAGS if the current language is C++. Generic
|
|
# compiler test macros which need to modify or save the compiler flags
|
|
# can invoke this macro to get the name of the compiler flags environment
|
|
# variable (either CFLAGS or CXXFLAGS) depending upon the current
|
|
# language. For example:
|
|
# CS_LANG_CFLAGS="$CS_LANG_CFLAGS -Wall"
|
|
# With C, this expands to:
|
|
# CFLAGS="$CFLAGS -Wall"
|
|
# With C++, it expands to:
|
|
# CXXFLAGS="$CXXFLAGS -Wall"
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_LANG_CFLAGS], [AC_LANG_CASE([C], [CFLAGS], [C++], [CXXFLAGS])])
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_BUILD_IFELSE([PROGRAM], [FLAGS], [LANGUAGE], [ACTION-IF-BUILT],
|
|
# [ACTION-IF-NOT-BUILT], [OTHER-CFLAGS], [OTHER-LFLAGS],
|
|
# [OTHER-LIBS], [INHIBIT-OTHER-FLAGS], [ERROR-REGEX])
|
|
# Try building a program using the supplied compiler flags, linker flags,
|
|
# and library references. PROGRAM is typically a program composed via
|
|
# AC_LANG_PROGRAM(). PROGRAM may be omitted if you are interested only
|
|
# in learning if the compiler or linker respects certain flags. LANGUAGE
|
|
# is typically either C or C++ and specifies which compiler to use for
|
|
# the test. If LANGUAGE is omitted, C is used. FLAGS is a whitespace
|
|
# delimited list of build tuples. Tuples are created with
|
|
# CS_CREATE_TUPLE() and are composed of up to three elements each. The
|
|
# first element represents compiler flags, the second linker flags, and
|
|
# the third libraries used when linking the program. Each tuple from
|
|
# FLAGS is attempted in order. If you want a build attempted with no
|
|
# special flags prior to builds with specialized flags, create an empty
|
|
# tuple with CS_CREATE_TUPLE() at the start of the FLAGS list. If the
|
|
# build is successful, then the shell variables cs_build_ok is set to
|
|
# "yes", cs_build_cflags, cs_build_lflags, and cs_build_libs are set to
|
|
# the tuple elements which resulted in the successful build, and
|
|
# ACTION-IF-BUILT is invoked. Upon successful build, no further tuples
|
|
# are consulted. If no tuple results in a successful build, then
|
|
# cs_build_ok is set to "no" and ACTION-IF-NOT-BUILT is invoked.
|
|
# OTHER-CFLAGS, OTHER-LFLAGS, and OTHER-LIBS specify additional compiler
|
|
# flags, linker flags, and libraries which should be used with each tuple
|
|
# build attempt. Upon successful build, these additional flags are also
|
|
# reflected in the variables cs_build_cflags, cs_build_lflags, and
|
|
# cs_build_libs unless INHIBIT-OTHER-FLAGS is a non-empty string. The
|
|
# optional ERROR-REGEX places an additional constraint upon the build
|
|
# check. If specified, ERROR-REGEX, which is a standard `grep' regular
|
|
# expression, is applied to output captured from the compiler and linker.
|
|
# If ERROR-REGEX matches, then the build is deemed a failure, and
|
|
# cs_build_ok is set to "no". This facility is useful for broken build
|
|
# tools which emit an error message yet still return success as a result.
|
|
# In such cases, it should be possible to detect the failure by scanning
|
|
# the tools' output.
|
|
#
|
|
# IMPLEMENTATION NOTES
|
|
#
|
|
# In Autoconf 2.57 and earlier, AC_LINK_IFELSE() invokes AC_TRY_EVAL(),
|
|
# which does not provide access to the captured output. To work around
|
|
# this limitation, we temporarily re-define AC_TRY_EVAL() as
|
|
# _AC_EVAL_STDERR(), which leaves the captured output in conftest.err
|
|
# (which we must also delete). In Autoconf 2.58, however,
|
|
# AC_LINK_IFELSE() instead already invokes _AC_EVAL_STDERR() on our
|
|
# behalf, however we must be careful to apply ERROR-REGEX within the
|
|
# invocation AC_LINK_IFELSE(), since AC_LINK_IFELSE() deletes
|
|
# conftest.err before it returns.
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_BUILD_IFELSE],
|
|
[AC_LANG_PUSH(m4_default([$3],[C]))
|
|
cs_cflags_save="$CS_LANG_CFLAGS"
|
|
cs_lflags_save="$LDFLAGS"
|
|
cs_libs_save="$LIBS"
|
|
cs_build_ok=no
|
|
m4_ifval([$10], [m4_pushdef([AC_TRY_EVAL], [_AC_EVAL_STDERR]($$[1]))])
|
|
|
|
for cs_build_item in m4_default([$2],[CS_CREATE_TUPLE()])
|
|
do
|
|
CS_SPLIT_TUPLE(
|
|
[$cs_build_item],[cs_cflags_test,cs_lflags_test,cs_libs_test])
|
|
CS_LANG_CFLAGS="$cs_cflags_test $6 $cs_cflags_save"
|
|
LDFLAGS="$cs_lflags_test $7 $cs_lflags_save"
|
|
LIBS="$cs_libs_test $8 $cs_libs_save"
|
|
AC_LINK_IFELSE(m4_default([$1], [AC_LANG_PROGRAM([],[])]),
|
|
[m4_ifval([$10],
|
|
[AS_IF([AC_TRY_COMMAND(
|
|
[grep "AS_ESCAPE([$10])" conftest.err >/dev/null 2>&1])],
|
|
[cs_build_ok=no], [cs_build_ok=yes])],
|
|
[cs_build_ok=yes])])
|
|
AS_IF([test $cs_build_ok = yes], [break])
|
|
done
|
|
|
|
m4_ifval([$10], [m4_popdef([AC_TRY_EVAL]) rm -f conftest.err])
|
|
CS_LANG_CFLAGS=$cs_cflags_save
|
|
LDFLAGS=$cs_lflags_save
|
|
LIBS=$cs_libs_save
|
|
AC_LANG_POP(m4_default([$3],[C]))
|
|
|
|
AS_IF([test $cs_build_ok = yes],
|
|
[cs_build_cflags=CS_TRIM([$cs_cflags_test[]m4_ifval([$9],[],[ $6])])
|
|
cs_build_lflags=CS_TRIM([$cs_lflags_test[]m4_ifval([$9],[],[ $7])])
|
|
cs_build_libs=CS_TRIM([$cs_libs_test[]m4_ifval([$9],[],[ $8])])
|
|
$4],
|
|
[$5])])
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_CHECK_BUILD(MESSAGE, CACHE-VAR, [PROGRAM], [FLAGS], [LANGUAGE],
|
|
# [ACTION-IF-BUILT], [ACTION-IF-NOT-BUILT], [IGNORE-CACHE],
|
|
# [OTHER-CFLAGS], [OTHER-LFLAGS], [OTHER-LIBS],
|
|
# [INHIBIT-OTHER-FLAGS], [ERROR-REGEX])
|
|
# Like CS_BUILD_IFELSE() but also prints "checking" and result messages,
|
|
# and optionally respects the cache. Sets CACHE-VAR to "yes" upon
|
|
# success, else "no" upon failure. Additionally, sets CACHE-VAR_cflags,
|
|
# CACHE-VAR_lflags, and CACHE-VAR_libs to the values which resulted in a
|
|
# successful build. If IGNORE-CACHE is "yes", then the cache variables
|
|
# are ignored upon entry to this macro, however they are still set to
|
|
# appropriate values upon exit.
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_CHECK_BUILD],
|
|
[AS_IF([test "$8" != yes],
|
|
[AC_CACHE_CHECK([$1], [$2],
|
|
[CS_BUILD_IFELSE([$3], [$4], [$5],
|
|
[$2=yes
|
|
$2_cflags=$cs_build_cflags
|
|
$2_lflags=$cs_build_lflags
|
|
$2_libs=$cs_build_libs],
|
|
[$2=no], [$9], [$10], [$11], [$12], [$13])])],
|
|
[AC_MSG_CHECKING([$1])
|
|
CS_BUILD_IFELSE([$3], [$4], [$5],
|
|
[$2=yes
|
|
$2_cflags=$cs_build_cflags
|
|
$2_lflags=$cs_build_lflags
|
|
$2_libs=$cs_build_libs],
|
|
[$2=no], [$9], [$10], [$11], [$12], [$13])
|
|
AC_MSG_RESULT([$$2])])
|
|
AS_IF([test $$2 = yes], [$6],
|
|
[$2_cflags=''
|
|
$2_lflags=''
|
|
$2_libs=''
|
|
$7])])
|
|
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# CS_CHECK_BUILD_FLAGS(MESSAGE, CACHE-VAR, FLAGS, [LANGUAGE],
|
|
# [ACTION-IF-RECOGNIZED], [ACTION-IF-NOT-RECOGNIZED],
|
|
# [OTHER-CFLAGS], [OTHER-LFLAGS], [OTHER-LIBS],
|
|
# [ERROR-REGEX])
|
|
# Like CS_CHECK_BUILD(), but checks only if the compiler or linker
|
|
# recognizes a command-line option or options. MESSAGE is the "checking"
|
|
# message. CACHE-VAR is the shell cache variable which receives the flag
|
|
# or flags recognized by the compiler or linker. FLAGS is a
|
|
# whitespace-delimited list of build tuples created with
|
|
# CS_CREATE_TUPLE(). Each tuple from FLAGS is attempted in order until
|
|
# one is found which is recognized by the compiler. After that, no
|
|
# further flags are checked. LANGUAGE is typically either C or C++ and
|
|
# specifies which compiler to use for the test. If LANGUAGE is omitted,
|
|
# C is used. If a command-line option is recognized, then CACHE-VAR is
|
|
# set to the composite value of $cs_build_cflags, $cs_build_lflags, and
|
|
# $cs_build_libs of the FLAGS element which succeeded (not including the
|
|
# "other" flags) and ACTION-IF-RECOGNIZED is invoked. If no options are
|
|
# recognized, then CACHE-VAR is set to the empty string, and
|
|
# ACTION-IF-NOT-RECOGNIZED is invoked. As a convenience, in case
|
|
# comparing CACHE-VAR against the empty string to test for failure is
|
|
# undesirable, a second variable named CACHE-VAR_ok is set to the literal
|
|
# "no" upon failure, and to the same value as CACHE-VAR upon success.
|
|
#------------------------------------------------------------------------------
|
|
AC_DEFUN([CS_CHECK_BUILD_FLAGS],
|
|
[AC_CACHE_CHECK([$1], [$2_ok],
|
|
[CS_BUILD_IFELSE([], [$3], [$4],
|
|
[$2=CS_TRIM([$cs_build_cflags $cs_build_lflags $cs_build_libs])
|
|
$2_ok="$$2"],
|
|
[$2=''
|
|
$2_ok=no], [$7], [$8], [$9], [Y], [$10])])
|
|
AS_IF([test "$$2_ok" != no], [$5], [$6])])
|