mirror of
git://git.sv.gnu.org/autoconf
synced 2025-02-05 11:10:57 +08:00
286c51ccf3
* lib/m4sugar/m4sh.m4 (AS_LITERAL_IF): Update a comment that fell
out of date when this function was moved/renamed in 59ecd766.
* THANKS: Update.
Signed-off-by: Allan Caffee <allan.caffee@gmail.com>
Signed-off-by: Eric Blake <ebb9@byu.net>
2057 lines
69 KiB
Plaintext
2057 lines
69 KiB
Plaintext
# This file is part of Autoconf. -*- Autoconf -*-
|
|
# M4 sugar for common shell constructs.
|
|
# Requires GNU M4 and M4sugar.
|
|
#
|
|
# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
|
|
# 2009 Free Software Foundation, Inc.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2, or (at your option)
|
|
# any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
# 02110-1301, USA.
|
|
#
|
|
# As a special exception, the Free Software Foundation gives unlimited
|
|
# permission to copy, distribute and modify the configure scripts that
|
|
# are the output of Autoconf. You need not follow the terms of the GNU
|
|
# General Public License when using or distributing such scripts, even
|
|
# though portions of the text of Autoconf appear in them. The GNU
|
|
# General Public License (GPL) does govern all other use of the material
|
|
# that constitutes the Autoconf program.
|
|
#
|
|
# Certain portions of the Autoconf source text are designed to be copied
|
|
# (in certain cases, depending on the input) into the output of
|
|
# Autoconf. We call these the "data" portions. The rest of the Autoconf
|
|
# source text consists of comments plus executable code that decides which
|
|
# of the data portions to output in any given case. We call these
|
|
# comments and executable code the "non-data" portions. Autoconf never
|
|
# copies any of the non-data portions into its output.
|
|
#
|
|
# This special exception to the GPL applies to versions of Autoconf
|
|
# released by the Free Software Foundation. When you make and
|
|
# distribute a modified version of Autoconf, you may extend this special
|
|
# exception to the GPL to apply to your modified version as well, *unless*
|
|
# your modified version has the potential to copy into its output some
|
|
# of the text that was the non-data portion of the version that you started
|
|
# with. (In other words, unless your change moves or copies text from
|
|
# the non-data portions to the data portions.) If your modification has
|
|
# such potential, you must delete any notice of this special exception
|
|
# to the GPL from your modified version.
|
|
#
|
|
# Written by Akim Demaille, Pavel Roskin, Alexandre Oliva, Lars J. Aas
|
|
# and many other people.
|
|
|
|
|
|
# We heavily use m4's diversions both for the initializations and for
|
|
# required macros, because in both cases we have to issue soon in
|
|
# output something which is discovered late.
|
|
#
|
|
#
|
|
# KILL is only used to suppress output.
|
|
#
|
|
# - BINSH
|
|
# AC_REQUIRE'd #! /bin/sh line
|
|
# - HEADER-REVISION
|
|
# RCS keywords etc.
|
|
# - HEADER-COMMENT
|
|
# Purpose of the script etc.
|
|
# - HEADER-COPYRIGHT
|
|
# Copyright notice(s)
|
|
# - M4SH-SANITIZE
|
|
# M4sh's shell setup
|
|
# - M4SH-INIT-FN
|
|
# M4sh initialization (shell functions)
|
|
# - M4SH-INIT
|
|
# M4sh initialization (detection code)
|
|
# - BODY
|
|
# The body of the script.
|
|
|
|
|
|
# _m4_divert(DIVERSION-NAME)
|
|
# --------------------------
|
|
# Convert a diversion name into its number. Otherwise, return
|
|
# DIVERSION-NAME which is supposed to be an actual diversion number.
|
|
# Of course it would be nicer to use m4_case here, instead of zillions
|
|
# of little macros, but it then takes twice longer to run `autoconf'!
|
|
m4_define([_m4_divert(BINSH)], 0)
|
|
m4_define([_m4_divert(HEADER-REVISION)], 1)
|
|
m4_define([_m4_divert(HEADER-COMMENT)], 2)
|
|
m4_define([_m4_divert(HEADER-COPYRIGHT)], 3)
|
|
m4_define([_m4_divert(M4SH-SANITIZE)], 4)
|
|
m4_define([_m4_divert(M4SH-INIT-FN)], 5)
|
|
m4_define([_m4_divert(M4SH-INIT)], 6)
|
|
m4_define([_m4_divert(BODY)], 1000)
|
|
|
|
# Aaarg. Yet it starts with compatibility issues... Libtool wants to
|
|
# use NOTICE to insert its own LIBTOOL-INIT stuff. People should ask
|
|
# before diving into our internals :(
|
|
m4_copy([_m4_divert(M4SH-INIT)], [_m4_divert(NOTICE)])
|
|
|
|
|
|
|
|
## ------------------------- ##
|
|
## 1. Sanitizing the shell. ##
|
|
## ------------------------- ##
|
|
# Please maintain lexicographic sorting of this section, ignoring leading _.
|
|
|
|
# AS_BOURNE_COMPATIBLE
|
|
# --------------------
|
|
# Try to be as Bourne and/or POSIX as possible.
|
|
#
|
|
# This does not set BIN_SH, due to the problems described in
|
|
# <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>.
|
|
# People who need BIN_SH should set it in their environment before invoking
|
|
# configure; apparently this would include UnixWare, as described in
|
|
# <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00025.html>.
|
|
m4_define([AS_BOURNE_COMPATIBLE],
|
|
[# Be more Bourne compatible
|
|
DUALCASE=1; export DUALCASE # for MKS sh
|
|
_$0
|
|
])
|
|
|
|
# _AS_BOURNE_COMPATIBLE
|
|
# ---------------------
|
|
# This is the part of AS_BOURNE_COMPATIBLE which has to be repeated inside
|
|
# each instance.
|
|
m4_define([_AS_BOURNE_COMPATIBLE],
|
|
[AS_IF([test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1],
|
|
[emulate sh
|
|
NULLCMD=:
|
|
[#] Pre-4.2 versions of Zsh do word splitting on ${1+"$[@]"}, which
|
|
# is contrary to our usage. Disable this feature.
|
|
alias -g '${1+"$[@]"}'='"$[@]"'
|
|
setopt NO_GLOB_SUBST],
|
|
[AS_CASE([`(set -o) 2>/dev/null`], [*posix*], [set -o posix])])
|
|
])
|
|
|
|
|
|
# _AS_CLEANUP
|
|
# -----------
|
|
# Expanded as the last thing before m4sugar cleanup begins. Macros
|
|
# may append m4sh cleanup hooks to this as appropriate.
|
|
m4_define([_AS_CLEANUP],
|
|
[m4_divert_text([M4SH-SANITIZE], [_AS_DETECT_BETTER_SHELL])])
|
|
|
|
|
|
# AS_COPYRIGHT(TEXT)
|
|
# ------------------
|
|
# Emit TEXT, a copyright notice, as a shell comment near the top of the
|
|
# script. TEXT is evaluated once; to accomplish that, we do not prepend
|
|
# `# ' but `@%:@ '.
|
|
m4_define([AS_COPYRIGHT],
|
|
[m4_divert_text([HEADER-COPYRIGHT],
|
|
[m4_bpatsubst([
|
|
$1], [^], [@%:@ ])])])
|
|
|
|
|
|
# _AS_DETECT_EXPAND(VAR, SET)
|
|
# ---------------------------
|
|
# Assign the contents of VAR from the contents of SET, expanded in such
|
|
# a manner that VAR can be passed to _AS_RUN. In order to make
|
|
# _AS_LINENO_WORKS operate correctly, we must specially handle the
|
|
# first instance of $LINENO within any line being expanded (the first
|
|
# instance is important to tests using the current shell, leaving
|
|
# remaining instances for tests using a candidate shell). Bash loses
|
|
# track of line numbers if a double quote contains a newline, hence,
|
|
# we must piece-meal the assignment of VAR such that $LINENO expansion
|
|
# occurs in a single line.
|
|
m4_define([_AS_DETECT_EXPAND],
|
|
[$1="m4_bpatsubst(m4_dquote(AS_ESCAPE(_m4_expand(m4_set_contents([$2], [
|
|
])))), [\\\$LINENO\(.*\)$], [";$1=$$1$LINENO;$1=$$1"\1])"])
|
|
|
|
|
|
# _AS_DETECT_REQUIRED(TEST)
|
|
# -------------------------
|
|
# Refuse to execute under a shell that does not pass the given TEST.
|
|
# Does not do AS_REQUIRE for the better-shell detection code.
|
|
#
|
|
# M4sh should never require something not required by POSIX, although
|
|
# other clients are free to do so.
|
|
m4_defun([_AS_DETECT_REQUIRED],
|
|
[m4_set_add([_AS_DETECT_REQUIRED_BODY], [$1 || AS_EXIT])])
|
|
|
|
|
|
# _AS_DETECT_SUGGESTED(TEST)
|
|
# --------------------------
|
|
# Prefer to execute under a shell that passes the given TEST.
|
|
# Does not do AS_REQUIRE for the better-shell detection code.
|
|
#
|
|
# M4sh should never suggest something not required by POSIX, although
|
|
# other clients are free to do so.
|
|
m4_defun([_AS_DETECT_SUGGESTED],
|
|
[m4_set_add([_AS_DETECT_SUGGESTED_BODY], [$1 || AS_EXIT])])
|
|
|
|
|
|
# _AS_DETECT_SUGGESTED_PRUNE(TEST)
|
|
# --------------------------------
|
|
# If TEST is also a required test, remove it from the set of suggested tests.
|
|
m4_define([_AS_DETECT_SUGGESTED_PRUNE],
|
|
[m4_set_contains([_AS_DETECT_REQUIRED_BODY], [$1],
|
|
[m4_set_remove([_AS_DETECT_SUGGESTED_BODY], [$1])])])
|
|
|
|
|
|
# _AS_DETECT_BETTER_SHELL
|
|
# -----------------------
|
|
# The real workhorse for detecting a shell with the correct
|
|
# features.
|
|
#
|
|
# In previous versions, we prepended /usr/posix/bin to the path, but that
|
|
# caused a regression on OpenServer 6.0.0
|
|
# <http://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00017.html>
|
|
# and on HP-UX 11.11, see the failure of test 120 in
|
|
# <http://lists.gnu.org/archive/html/bug-autoconf/2006-10/msg00003.html>
|
|
#
|
|
# FIXME: The code should test for the OSF bug described in
|
|
# <http://lists.gnu.org/archive/html/autoconf-patches/2006-03/msg00081.html>.
|
|
#
|
|
# This code is run outside any trap 0 context, hence we can simplify AS_EXIT.
|
|
m4_defun([_AS_DETECT_BETTER_SHELL],
|
|
dnl Remove any tests from suggested that are also required
|
|
[m4_set_map([_AS_DETECT_SUGGESTED_BODY], [_AS_DETECT_SUGGESTED_PRUNE])]dnl
|
|
[m4_pushdef([AS_EXIT], [exit m4_default(]m4_dquote([$][1])[, 1)])]dnl
|
|
[if test "x$CONFIG_SHELL" = x; then
|
|
as_bourne_compatible="AS_ESCAPE(_m4_expand([_AS_BOURNE_COMPATIBLE]))"
|
|
_AS_DETECT_EXPAND([as_required], [_AS_DETECT_REQUIRED_BODY])
|
|
_AS_DETECT_EXPAND([as_suggested], [_AS_DETECT_SUGGESTED_BODY])
|
|
AS_IF([_AS_RUN(["$as_required"])],
|
|
[as_have_required=yes],
|
|
[as_have_required=no])
|
|
AS_IF([test x$as_have_required = xyes && _AS_RUN(["$as_suggested"])],
|
|
[],
|
|
[_AS_PATH_WALK([/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH],
|
|
[case $as_dir in @%:@(
|
|
/*)
|
|
for as_base in sh bash ksh sh5; do
|
|
# Try only shells that exist, to save several forks.
|
|
as_shell=$as_dir/$as_base
|
|
AS_IF([{ test -f "$as_shell" || test -f "$as_shell.exe"; } &&
|
|
_AS_RUN(["$as_required"], ["$as_shell"])],
|
|
[CONFIG_SHELL=$as_shell as_have_required=yes
|
|
m4_set_empty([_AS_DETECT_SUGGESTED_BODY], [break 2],
|
|
[AS_IF([_AS_RUN(["$as_suggested"], ["$as_shell"])],
|
|
[break 2])])])
|
|
done;;
|
|
esac],
|
|
[AS_IF([{ test -f "$SHELL" || test -f "$SHELL.exe"; } &&
|
|
_AS_RUN(["$as_required"], ["$SHELL"])],
|
|
[CONFIG_SHELL=$SHELL as_have_required=yes])])
|
|
|
|
AS_IF([test "x$CONFIG_SHELL" != x],
|
|
[# We cannot yet assume a decent shell, so we have to provide a
|
|
# neutralization value for shells without unset; and this also
|
|
# works around shells that cannot unset nonexistent variables.
|
|
BASH_ENV=/dev/null
|
|
ENV=/dev/null
|
|
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
|
export CONFIG_SHELL
|
|
exec "$CONFIG_SHELL" "$as_myself" ${1+"$[@]"}])
|
|
|
|
dnl Unfortunately, $as_me isn't available here.
|
|
AS_IF([test x$as_have_required = xno],
|
|
[AS_ECHO(["$[]0: This script requires a shell more modern than all"])
|
|
AS_ECHO(["$[]0: the shells that I found on your system."])
|
|
if test x${ZSH_VERSION+set} = xset ; then
|
|
AS_ECHO(["$[]0: In particular, zsh $ZSH_VERSION has bugs and should"])
|
|
AS_ECHO(["$[]0: be upgraded to zsh 4.3.4 or later."])
|
|
else
|
|
AS_ECHO("m4_text_wrap([Please tell ]_m4_defn([m4_PACKAGE_BUGREPORT])
|
|
m4_ifset([AC_PACKAGE_BUGREPORT], [m4_if(_m4_defn([m4_PACKAGE_BUGREPORT]),
|
|
_m4_defn([AC_PACKAGE_BUGREPORT]), [], [and _m4_defn([AC_PACKAGE_BUGREPORT])])])
|
|
[about your system, including any error possibly output before this message.
|
|
Then install a modern shell, or manually run the script under such a
|
|
shell if you do have one.], [$[]0: ], [], [62])")
|
|
fi
|
|
AS_EXIT])])
|
|
fi
|
|
SHELL=${CONFIG_SHELL-/bin/sh}
|
|
export SHELL
|
|
_m4_popdef([AS_EXIT])])# _AS_DETECT_BETTER_SHELL
|
|
|
|
|
|
# _AS_PREPARE
|
|
# -----------
|
|
# This macro has a very special status. Normal use of M4sh relies
|
|
# heavily on AS_REQUIRE, so that needed initializations (such as
|
|
# _AS_TEST_PREPARE) are performed on need, not on demand. But
|
|
# Autoconf is the first client of M4sh, and for two reasons: configure
|
|
# and config.status. Relying on AS_REQUIRE is of course fine for
|
|
# configure, but fails for config.status (which is created by
|
|
# configure). So we need a means to force the inclusion of the
|
|
# various _AS_*_PREPARE on top of config.status. That's basically why
|
|
# there are so many _AS_*_PREPARE below, and that's also why it is
|
|
# important not to forget some: config.status needs them.
|
|
# List any preparations that create shell functions first, then
|
|
# topologically sort the others by their dependencies.
|
|
#
|
|
# Special case: we do not need _AS_LINENO_PREPARE, because the
|
|
# parent will have substituted $LINENO for us when processing its
|
|
# own invocation of _AS_LINENO_PREPARE.
|
|
#
|
|
# Special case: the full definition of _AS_ERROR_PREPARE is not output
|
|
# unless AS_MESSAGE_LOG_FD is non-empty, although the value of
|
|
# AS_MESSAGE_LOG_FD is not relevant.
|
|
m4_defun([_AS_PREPARE],
|
|
[m4_pushdef([AS_REQUIRE])]dnl
|
|
[m4_pushdef([AS_REQUIRE_SHELL_FN], _m4_defn([_AS_REQUIRE_SHELL_FN])
|
|
)]dnl
|
|
[m4_pushdef([AS_MESSAGE_LOG_FD], [-1])]dnl
|
|
[_AS_ERROR_PREPARE
|
|
_m4_popdef([AS_MESSAGE_LOG_FD])]dnl
|
|
[_AS_EXIT_PREPARE
|
|
_AS_UNSET_PREPARE
|
|
_AS_VAR_APPEND_PREPARE
|
|
_AS_VAR_ARITH_PREPARE
|
|
|
|
_AS_EXPR_PREPARE
|
|
_AS_BASENAME_PREPARE
|
|
_AS_DIRNAME_PREPARE
|
|
_AS_ME_PREPARE
|
|
_AS_CR_PREPARE
|
|
_AS_ECHO_N_PREPARE
|
|
_AS_LN_S_PREPARE
|
|
_AS_MKDIR_P_PREPARE
|
|
_AS_TEST_PREPARE
|
|
_AS_TR_CPP_PREPARE
|
|
_AS_TR_SH_PREPARE
|
|
_m4_popdef([AS_REQUIRE], [AS_REQUIRE_SHELL_FN])])
|
|
|
|
# AS_PREPARE
|
|
# ----------
|
|
# Output all the M4sh possible initialization into the initialization
|
|
# diversion. We do not use _AS_PREPARE so that the m4_provide symbols for
|
|
# AS_REQUIRE and AS_REQUIRE_SHELL_FN are defined properly, and so that
|
|
# shell functions are placed in M4SH-INIT-FN.
|
|
m4_defun([AS_PREPARE],
|
|
[m4_divert_push([KILL])
|
|
m4_append_uniq([_AS_CLEANUP],
|
|
[m4_divert_text([M4SH-INIT-FN], [_AS_ERROR_PREPARE[]])])
|
|
AS_REQUIRE([_AS_EXPR_PREPARE])
|
|
AS_REQUIRE([_AS_BASENAME_PREPARE])
|
|
AS_REQUIRE([_AS_DIRNAME_PREPARE])
|
|
AS_REQUIRE([_AS_ME_PREPARE])
|
|
AS_REQUIRE([_AS_CR_PREPARE])
|
|
AS_REQUIRE([_AS_LINENO_PREPARE])
|
|
AS_REQUIRE([_AS_ECHO_N_PREPARE])
|
|
AS_REQUIRE([_AS_EXIT_PREPARE])
|
|
AS_REQUIRE([_AS_LN_S_PREPARE])
|
|
AS_REQUIRE([_AS_MKDIR_P_PREPARE])
|
|
AS_REQUIRE([_AS_TEST_PREPARE])
|
|
AS_REQUIRE([_AS_TR_CPP_PREPARE])
|
|
AS_REQUIRE([_AS_TR_SH_PREPARE])
|
|
AS_REQUIRE([_AS_UNSET_PREPARE])
|
|
AS_REQUIRE([_AS_VAR_APPEND_PREPARE], [], [M4SH-INIT-FN])
|
|
AS_REQUIRE([_AS_VAR_ARITH_PREPARE], [], [M4SH-INIT-FN])
|
|
m4_divert_pop[]])
|
|
|
|
|
|
# AS_REQUIRE(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK],
|
|
# [DIVERSION = M4SH-INIT])
|
|
# -----------------------------------------------------------
|
|
# BODY-TO-EXPAND is some initialization which must be expanded in the
|
|
# given diversion when expanded (required or not). The expansion
|
|
# goes in the named diversion or an earlier one.
|
|
#
|
|
# Since $2 can be quite large, this is factored for faster execution, giving
|
|
# either m4_require([$1], [$2]) or m4_divert_require(desired, [$1], [$2]).
|
|
m4_defun([AS_REQUIRE],
|
|
[m4_define([_m4_divert_desired], [m4_default_quoted([$3], [M4SH-INIT])])]dnl
|
|
[m4_if(m4_eval(_m4_divert_dump - 0 <= _m4_divert(_m4_divert_desired)),
|
|
1, [m4_require(],
|
|
[m4_divert_require(_m4_divert_desired,]) [$1], [$2])])
|
|
|
|
# _AS_REQUIRE_SHELL_FN(NAME-TO-CHECK, COMMENT, BODY-TO-EXPAND)
|
|
# ------------------------------------------------------------
|
|
# Core of AS_REQUIRE_SHELL_FN, but without diversion support.
|
|
m4_define([_AS_REQUIRE_SHELL_FN], [
|
|
m4_n([$2])$1 ()
|
|
{
|
|
$3
|
|
} @%:@ $1[]])
|
|
|
|
# AS_REQUIRE_SHELL_FN(NAME-TO-CHECK, COMMENT, BODY-TO-EXPAND,
|
|
# [DIVERSION = M4SH-INIT-FN])
|
|
# -----------------------------------------------------------
|
|
# BODY-TO-EXPAND is the body of a shell function to be emitted in the
|
|
# given diversion when expanded (required or not). Unlike other
|
|
# xx_REQUIRE macros, BODY-TO-EXPAND is mandatory. If COMMENT is
|
|
# provided (often via AS_FUNCTION_DESCRIBE), it is listed with a
|
|
# newline before the function name.
|
|
m4_define([AS_REQUIRE_SHELL_FN],
|
|
[m4_provide_if([AS_SHELL_FN_$1], [],
|
|
[AS_REQUIRE([AS_SHELL_FN_$1],
|
|
[m4_provide([AS_SHELL_FN_$1])_$0($@)],
|
|
m4_default_quoted([$4], [M4SH-INIT-FN]))])])
|
|
|
|
|
|
# _AS_RUN(TEST, [SHELL])
|
|
# ----------------------
|
|
# Run TEST under the current shell (if one parameter is used)
|
|
# or under the given SHELL, protecting it from syntax errors.
|
|
# Set as_run in order to assist _AS_LINENO_WORKS.
|
|
m4_define([_AS_RUN],
|
|
[m4_ifval([$2], [{ $as_echo "$as_bourne_compatible"$1 | as_run=a $2; }],
|
|
[(eval $1)]) 2>/dev/null])
|
|
|
|
|
|
# _AS_SHELL_FN_WORK
|
|
# -----------------
|
|
# This is a spy to detect "in the wild" shells that do not support shell
|
|
# functions correctly. It is based on the m4sh.at Autotest testcases.
|
|
m4_define([_AS_SHELL_FN_WORK],
|
|
[as_fn_return () { (exit [$]1); }
|
|
as_fn_success () { as_fn_return 0; }
|
|
as_fn_failure () { as_fn_return 1; }
|
|
as_fn_ret_success () { return 0; }
|
|
as_fn_ret_failure () { return 1; }
|
|
|
|
exitcode=0
|
|
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
|
|
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
|
|
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
|
|
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
|
|
AS_IF([( set x; as_fn_ret_success y && test x = "[$]1" )], [],
|
|
[exitcode=1; echo positional parameters were not saved.])
|
|
test x$exitcode = x0[]])# _AS_SHELL_FN_WORK
|
|
|
|
|
|
# _AS_SHELL_SANITIZE
|
|
# ------------------
|
|
# This is the prolog that is emitted by AS_INIT and AS_INIT_GENERATED;
|
|
# it is executed prior to shell function definitions, hence the
|
|
# temporary redefinition of AS_EXIT.
|
|
m4_defun([_AS_SHELL_SANITIZE],
|
|
[m4_pushdef([AS_EXIT], [exit m4_default(]m4_dquote([$][1])[, 1)])]dnl
|
|
[m4_text_box([M4sh Initialization.])
|
|
|
|
AS_BOURNE_COMPATIBLE
|
|
_AS_ECHO_PREPARE
|
|
_AS_PATH_SEPARATOR_PREPARE
|
|
|
|
# IFS
|
|
# We need space, tab and new line, in precisely that order. Quoting is
|
|
# there to prevent editors from complaining about space-tab.
|
|
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
|
|
# splitting by setting IFS to empty value.)
|
|
IFS=" "" $as_nl"
|
|
|
|
# Find who we are. Look in the path if we contain no directory separator.
|
|
case $[0] in @%:@((
|
|
*[[\\/]]* ) as_myself=$[0] ;;
|
|
*) _AS_PATH_WALK([],
|
|
[test -r "$as_dir/$[0]" && as_myself=$as_dir/$[0] && break])
|
|
;;
|
|
esac
|
|
# We did not find ourselves, most probably we were run as `sh COMMAND'
|
|
# in which case we are not to be found in the path.
|
|
if test "x$as_myself" = x; then
|
|
as_myself=$[0]
|
|
fi
|
|
if test ! -f "$as_myself"; then
|
|
AS_ECHO(["$as_myself: error: cannot find myself; rerun with an absolute file name"]) >&2
|
|
AS_EXIT
|
|
fi
|
|
|
|
# Unset variables that we do not need and which cause bugs (e.g. in
|
|
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
|
|
# suppresses any "Segmentation fault" message there. '((' could
|
|
# trigger a bug in pdksh 5.2.14.
|
|
for as_var in BASH_ENV ENV MAIL MAILPATH
|
|
do eval test x\${$as_var+set} = xset \
|
|
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
|
|
done
|
|
PS1='$ '
|
|
PS2='> '
|
|
PS4='+ '
|
|
|
|
# NLS nuisances.
|
|
LC_ALL=C
|
|
export LC_ALL
|
|
LANGUAGE=C
|
|
export LANGUAGE
|
|
|
|
# CDPATH.
|
|
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
|
|
_m4_popdef([AS_EXIT])])# _AS_SHELL_SANITIZE
|
|
|
|
|
|
# AS_SHELL_SANITIZE
|
|
# -----------------
|
|
# This is only needed for the sake of Libtool, which screws up royally
|
|
# in its usage of M4sh internals.
|
|
m4_define([AS_SHELL_SANITIZE],
|
|
[_AS_SHELL_SANITIZE
|
|
m4_provide_if([AS_INIT], [],
|
|
[m4_provide([AS_INIT])
|
|
_AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK])
|
|
_AS_DETECT_BETTER_SHELL
|
|
_AS_UNSET_PREPARE
|
|
])])
|
|
|
|
|
|
## ----------------------------- ##
|
|
## 2. Wrappers around builtins. ##
|
|
## ----------------------------- ##
|
|
|
|
# This section is lexicographically sorted.
|
|
|
|
|
|
# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT])
|
|
# ----------------------------------------------------
|
|
# Expand into
|
|
# | case WORD in #(
|
|
# | PATTERN1) IF-MATCHED1 ;; #(
|
|
# | ...
|
|
# | *) DEFAULT ;;
|
|
# | esac
|
|
# The shell comments are intentional, to work around people who don't
|
|
# realize the impacts of using insufficient m4 quoting. This macro
|
|
# always provides a default case, to work around a Solaris /bin/sh
|
|
# bug regarding the exit status when no case matches.
|
|
m4_define([_AS_CASE],
|
|
[ [@%:@(]
|
|
$1[)] m4_default([$2], [:]) ;;])
|
|
m4_define([_AS_CASE_DEFAULT],
|
|
[ [@%:@(]
|
|
*[)] m4_default([$1], [:]) ;;])
|
|
|
|
m4_defun([AS_CASE],
|
|
[case $1 in[]m4_map_args_pair([_$0], [_$0_DEFAULT],
|
|
m4_shift($@m4_if(m4_eval([$# & 1]), [1], [,])))
|
|
esac])# AS_CASE
|
|
|
|
|
|
# _AS_EXIT_PREPARE
|
|
# ----------------
|
|
# Ensure AS_EXIT and AS_SET_STATUS will work.
|
|
#
|
|
# We cannot simply use "exit N" because some shells (zsh and Solaris sh)
|
|
# will not set $? to N while running the code set by "trap 0"
|
|
# Some shells fork even for (exit N), so we use a helper function
|
|
# to set $? prior to the exit.
|
|
# Other shells don't use `$?' as default for `exit', hence just repeating
|
|
# the exit value can only help improving portability.
|
|
m4_defun([_AS_EXIT_PREPARE],
|
|
[AS_REQUIRE_SHELL_FN([as_fn_set_status],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_set_status], [STATUS],
|
|
[Set $? to STATUS, without forking.])], [ return $[]1])]dnl
|
|
[AS_REQUIRE_SHELL_FN([as_fn_exit],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_exit], [[[STATUS=$?]]],
|
|
[Exit the shell with STATUS, even in a "trap 0" or "set -e" context.])],
|
|
[ as_status=$?
|
|
set +e
|
|
as_fn_set_status ${1-$as_status}
|
|
exit ${1-$as_status}])])#_AS_EXIT_PREPARE
|
|
|
|
|
|
# AS_EXIT([EXIT-CODE = $?])
|
|
# -------------------------
|
|
# Exit, with status set to EXIT-CODE in the way that it's seen
|
|
# within "trap 0", and without interference from "set -e". If
|
|
# EXIT-CODE is omitted, then use $?.
|
|
m4_defun([AS_EXIT],
|
|
[AS_REQUIRE([_AS_EXIT_PREPARE])[]as_fn_exit[]m4_ifval([$1], [ $1])])
|
|
|
|
|
|
# AS_FOR(MACRO, SHELL-VAR, [LIST = "$@"], [BODY = :])
|
|
# ---------------------------------------------------
|
|
# Expand to a shell loop that assigns SHELL-VAR to each of the
|
|
# whitespace-separated entries in LIST (or "$@" if LIST is empty),
|
|
# then executes BODY. BODY may call break to abort the loop, or
|
|
# continue to proceed with the next element of LIST. Requires that
|
|
# IFS be set to the normal space-tab-newline. As an optimization,
|
|
# BODY should access MACRO rather than $SHELL-VAR. Normally, MACRO
|
|
# expands to $SHELL-VAR, but if LIST contains only a single element
|
|
# that needs no additional shell quoting, then MACRO will expand to
|
|
# that element, thus providing a direct value rather than a shell
|
|
# variable indirection.
|
|
#
|
|
# Only use the optimization if LIST can be used without additional
|
|
# shell quoting in either a literal or double-quoted context (that is,
|
|
# we give up on default IFS chars, parameter expansion, command
|
|
# substitution, shell quoting, globs, or quadrigraphs). Inline the
|
|
# m4_defn for speed.
|
|
m4_defun([AS_FOR],
|
|
[m4_pushdef([$1], m4_if([$3], [], [[$$2]], m4_translit([$3], ]dnl
|
|
m4_dquote(_m4_defn([m4_cr_symbols2]))[[%+=:,./-]), [], [[$3]], [[$$2]]))]dnl
|
|
[for $2[]m4_ifval([$3], [ in $3])
|
|
do
|
|
m4_default([$4], [:])
|
|
done[]_m4_popdef([$1])])
|
|
|
|
|
|
# AS_IF(TEST1, [IF-TRUE1 = :]...[IF-FALSE = :])
|
|
# ---------------------------------------------
|
|
# Expand into
|
|
# | if TEST1; then
|
|
# | IF-TRUE1
|
|
# | elif TEST2; then
|
|
# | IF-TRUE2
|
|
# [...]
|
|
# | else
|
|
# | IF-FALSE
|
|
# | fi
|
|
# with simplifications if IF-TRUE1 and/or IF-FALSE is empty.
|
|
#
|
|
m4_define([_AS_IF],
|
|
[elif $1; then
|
|
m4_default([$2], [:])
|
|
])
|
|
m4_define([_AS_IF_ELSE],
|
|
[m4_ifvaln([$1],
|
|
[else
|
|
$1])])
|
|
|
|
m4_defun([AS_IF],
|
|
[if $1; then
|
|
m4_default([$2], [:])
|
|
m4_map_args_pair([_$0], [_$0_ELSE], m4_shift2($@))]dnl
|
|
[fi[]])# AS_IF
|
|
|
|
|
|
# AS_SET_STATUS(STATUS)
|
|
# ---------------------
|
|
# Set the shell status ($?) to STATUS, without forking.
|
|
m4_defun([AS_SET_STATUS],
|
|
[AS_REQUIRE([_AS_EXIT_PREPARE])[]as_fn_set_status $1])
|
|
|
|
|
|
# _AS_UNSET_PREPARE
|
|
# -----------------
|
|
# Define $as_unset to execute AS_UNSET, for backwards compatibility
|
|
# with older versions of M4sh.
|
|
m4_defun([_AS_UNSET_PREPARE],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_unset], [VAR], [Portably unset VAR.])
|
|
as_fn_unset ()
|
|
{
|
|
AS_UNSET([$[1]])
|
|
}
|
|
as_unset=as_fn_unset])
|
|
|
|
|
|
# AS_UNSET(VAR)
|
|
# -------------
|
|
# Unset the env VAR, working around shells that do not allow unsetting
|
|
# a variable that is not already set. You should not unset MAIL and
|
|
# MAILCHECK, as that triggers a bug in Bash 2.01.
|
|
m4_defun([AS_UNSET],
|
|
[{ AS_LITERAL_IF([$1], [], [eval ])$1=; unset $1;}])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## ------------------------------------------ ##
|
|
## 3. Error and warnings at the shell level. ##
|
|
## ------------------------------------------ ##
|
|
|
|
|
|
# AS_MESSAGE_FD
|
|
# -------------
|
|
# Must expand to the fd where messages will be sent. Defaults to 1,
|
|
# although a script may reassign this value and use exec to either
|
|
# copy stdout to the new fd, or open the new fd on /dev/null.
|
|
m4_define([AS_MESSAGE_FD], [1])
|
|
|
|
# AS_MESSAGE_LOG_FD
|
|
# -----------------
|
|
# Must expand to either the empty string (when no logging is
|
|
# performed), or to the fd of a log file. Defaults to empty, although
|
|
# a script may reassign this value and use exec to open a log. When
|
|
# not empty, messages to AS_MESSAGE_FD are duplicated to the log,
|
|
# along with a LINENO reference.
|
|
m4_define([AS_MESSAGE_LOG_FD])
|
|
|
|
|
|
# AS_ORIGINAL_STDIN_FD
|
|
# --------------------
|
|
# Must expand to the fd of the script's original stdin. Defaults to
|
|
# 0, although the script may reassign this value and use exec to
|
|
# shuffle fd's.
|
|
m4_define([AS_ORIGINAL_STDIN_FD], [0])
|
|
|
|
|
|
# AS_ESCAPE(STRING, [CHARS = `\"$])
|
|
# ---------------------------------
|
|
# Add backslash escaping to the CHARS in STRING. In an effort to
|
|
# optimize use of this macro inside double-quoted shell constructs,
|
|
# the behavior is intentionally undefined if CHARS is longer than 4
|
|
# bytes, or contains bytes outside of the set [`\"$]. However,
|
|
# repeated bytes within the set are permissible (AS_ESCAPE([$1], [""])
|
|
# being a common way to be nice to syntax highlighting).
|
|
#
|
|
# Avoid the m4_bpatsubst if there are no interesting characters to escape.
|
|
# _AS_ESCAPE bypasses argument defaulting.
|
|
m4_define([AS_ESCAPE],
|
|
[_$0([$1], m4_if([$2], [], [[`], [\"$]], [m4_substr([$2], [0], [1]), [$2]]))])
|
|
|
|
# _AS_ESCAPE(STRING, KEY, SET)
|
|
# ----------------------------
|
|
# Backslash-escape all instances of the single byte KEY or up to four
|
|
# bytes in SET occurring in STRING. Although a character can occur
|
|
# multiple times, optimum efficiency occurs when KEY and SET are
|
|
# distinct, and when SET does not exceed two bytes. These particular
|
|
# semantics allow for the fewest number of parses of STRING, as well
|
|
# as taking advantage of the optimizations in m4 1.4.13+ when
|
|
# m4_translit is passed SET of size 2 or smaller.
|
|
m4_define([_AS_ESCAPE],
|
|
[m4_if(m4_index(m4_translit([[$1]], [$3], [$2$2$2$2]), [$2]), [-1],
|
|
[$0_], [m4_bpatsubst])([$1], [[$2$3]], [\\\&])])
|
|
m4_define([_AS_ESCAPE_], [$1])
|
|
|
|
|
|
# _AS_QUOTE(STRING)
|
|
# -----------------
|
|
# If there are quoted (via backslash) backquotes, output STRING
|
|
# literally and warn; otherwise, output STRING with ` and " quoted.
|
|
#
|
|
# Compatibility glue between the old AS_MSG suite which did not
|
|
# quote anything, and the modern suite which quotes the quotes.
|
|
# If STRING contains `\\' or `\$', it's modern.
|
|
# If STRING contains `\"' or `\`', it's old.
|
|
# Otherwise it's modern.
|
|
#
|
|
# Profiling shows that m4_index is 5 to 8x faster than m4_bregexp. The
|
|
# slower implementation used:
|
|
# m4_bmatch([$1],
|
|
# [\\[\\$]], [$2],
|
|
# [\\[`"]], [$3],
|
|
# [$2])
|
|
# The current implementation caters to the common case of no backslashes,
|
|
# to minimize m4_index expansions (hence the nested if).
|
|
m4_define([_AS_QUOTE],
|
|
[m4_cond([m4_index([$1], [\])], [-1], [_AS_QUOTE_MODERN],
|
|
[m4_eval(m4_index(m4_translit([[$1]], [$], [\]), [\\]) >= 0)],
|
|
[1], [_AS_QUOTE_MODERN],
|
|
[m4_eval(m4_index(m4_translit([[$1]], ["], [`]), [\`]) >= 0)],dnl"
|
|
[1], [_AS_QUOTE_OLD],
|
|
[_AS_QUOTE_MODERN])([$1])])
|
|
|
|
m4_define([_AS_QUOTE_MODERN],
|
|
[_AS_ESCAPE([$1], [`], [""])])
|
|
|
|
m4_define([_AS_QUOTE_OLD],
|
|
[m4_warn([obsolete],
|
|
[back quotes and double quotes must not be escaped in: $1])$1])
|
|
|
|
|
|
# _AS_ECHO_UNQUOTED(STRING, [FD = AS_MESSAGE_FD])
|
|
# -----------------------------------------------
|
|
# Perform shell expansions on STRING and echo the string to FD.
|
|
m4_define([_AS_ECHO_UNQUOTED],
|
|
[AS_ECHO(["$1"]) >&m4_default([$2], [AS_MESSAGE_FD])])
|
|
|
|
|
|
# _AS_ECHO(STRING, [FD = AS_MESSAGE_FD])
|
|
# --------------------------------------
|
|
# Protect STRING from backquote expansion, echo the result to FD.
|
|
m4_define([_AS_ECHO],
|
|
[_AS_ECHO_UNQUOTED([_AS_QUOTE([$1])], [$2])])
|
|
|
|
|
|
# _AS_ECHO_LOG(STRING)
|
|
# --------------------
|
|
# Log the string to AS_MESSAGE_LOG_FD.
|
|
m4_defun_init([_AS_ECHO_LOG],
|
|
[AS_REQUIRE([_AS_LINENO_PREPARE])],
|
|
[_AS_ECHO([$as_me:${as_lineno-$LINENO}: $1], AS_MESSAGE_LOG_FD)])
|
|
|
|
|
|
# _AS_ECHO_N_PREPARE
|
|
# ------------------
|
|
# Check whether to use -n, \c, or newline-tab to separate
|
|
# checking messages from result messages.
|
|
# Don't try to cache, since the results of this macro are needed to
|
|
# display the checking message. In addition, caching something used once
|
|
# has little interest.
|
|
# Idea borrowed from dist 3.0. Use `*c*,', not `*c,' because if `\c'
|
|
# failed there is also a newline to match.
|
|
m4_defun([_AS_ECHO_N_PREPARE],
|
|
[ECHO_C= ECHO_N= ECHO_T=
|
|
case `echo -n x` in @%:@((((
|
|
-n*)
|
|
case `echo 'x\c'` in
|
|
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
|
|
*) ECHO_C='\c';;
|
|
esac;;
|
|
*)
|
|
ECHO_N='-n';;
|
|
esac
|
|
])# _AS_ECHO_N_PREPARE
|
|
|
|
|
|
# _AS_ECHO_N(STRING, [FD = AS_MESSAGE_FD])
|
|
# ----------------------------------------
|
|
# Same as _AS_ECHO, but echo doesn't return to a new line.
|
|
m4_define([_AS_ECHO_N],
|
|
[AS_ECHO_N(["_AS_QUOTE([$1])"]) >&m4_default([$2], [AS_MESSAGE_FD])])
|
|
|
|
|
|
# AS_MESSAGE(STRING, [FD = AS_MESSAGE_FD])
|
|
# ----------------------------------------
|
|
# Output "`basename $0`: STRING" to the open file FD, and if logging
|
|
# is enabled, copy it to the log with a reference to LINENO.
|
|
m4_defun_init([AS_MESSAGE],
|
|
[AS_REQUIRE([_AS_ME_PREPARE])],
|
|
[m4_ifval(AS_MESSAGE_LOG_FD,
|
|
[{ _AS_ECHO_LOG([$1])
|
|
_AS_ECHO([$as_me: $1], [$2]);}],
|
|
[_AS_ECHO([$as_me: $1], [$2])])[]])
|
|
|
|
|
|
# AS_WARN(PROBLEM)
|
|
# ----------------
|
|
# Output "`basename $0`: WARNING: PROBLEM" to stderr.
|
|
m4_define([AS_WARN],
|
|
[AS_MESSAGE([WARNING: $1], [2])])# AS_WARN
|
|
|
|
|
|
# _AS_ERROR_PREPARE
|
|
# -----------------
|
|
# Output the shell function used by AS_ERROR. This is designed to be
|
|
# expanded during the m4_wrap cleanup.
|
|
#
|
|
# If AS_MESSAGE_LOG_FD is non-empty at the end of the script, then
|
|
# make this function take optional parameters that use LINENO at the
|
|
# points where AS_ERROR was expanded with non-empty AS_MESSAGE_LOG_FD;
|
|
# otherwise, assume the entire script does not do logging.
|
|
m4_define([_AS_ERROR_PREPARE],
|
|
[AS_REQUIRE_SHELL_FN([as_fn_error],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_error], [ERROR]m4_ifval(AS_MESSAGE_LOG_FD,
|
|
[[ [[LINENO LOG_FD]]]]),
|
|
[Output "`basename @S|@0`: error: ERROR" to stderr.]
|
|
m4_ifval(AS_MESSAGE_LOG_FD,
|
|
[[If LINENO and LOG_FD are provided, also output the error to LOG_FD,
|
|
referencing LINENO.]])
|
|
[Then exit the script with status $?, using 1 if that was 0.])],
|
|
[ as_status=$?; test $as_status -eq 0 && as_status=1
|
|
m4_ifval(AS_MESSAGE_LOG_FD,
|
|
[m4_pushdef([AS_MESSAGE_LOG_FD], [$[3]])dnl
|
|
if test "$[3]"; then
|
|
AS_LINENO_PUSH([$[2]])
|
|
_AS_ECHO_LOG([error: $[1]])
|
|
fi
|
|
m4_define([AS_MESSAGE_LOG_FD])], [m4_pushdef([AS_MESSAGE_LOG_FD])])dnl
|
|
AS_MESSAGE([error: $[1]], [2])
|
|
_m4_popdef([AS_MESSAGE_LOG_FD])dnl
|
|
AS_EXIT([$as_status])])])
|
|
|
|
# AS_ERROR(ERROR, [EXIT-STATUS = max($?/1)])
|
|
# ------------------------------------------
|
|
# Output "`basename $0`: error: ERROR" to stderr, then exit the
|
|
# script with EXIT-STATUS.
|
|
m4_defun_init([AS_ERROR],
|
|
[m4_append_uniq([_AS_CLEANUP],
|
|
[m4_divert_text([M4SH-INIT-FN], [_AS_ERROR_PREPARE[]])])],
|
|
[m4_ifvaln([$2], [{ AS_SET_STATUS([$2])])]dnl
|
|
[as_fn_error "_AS_QUOTE([$1])"m4_ifval(AS_MESSAGE_LOG_FD,
|
|
[ "$LINENO" AS_MESSAGE_LOG_FD])[]m4_ifval([$2], [; }])])
|
|
|
|
|
|
# AS_LINENO_PUSH([LINENO])
|
|
# ------------------------
|
|
# If this is the outermost call to AS_LINENO_PUSH, make sure that
|
|
# AS_MESSAGE will print LINENO as the line number.
|
|
m4_defun([AS_LINENO_PUSH],
|
|
[as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack])
|
|
|
|
|
|
# AS_LINENO_POP([LINENO])
|
|
# ------------------------
|
|
# If this is call balances the outermost call to AS_LINENO_PUSH,
|
|
# AS_MESSAGE will restart printing $LINENO as the line number.
|
|
m4_defun([AS_LINENO_POP],
|
|
[eval $as_lineno_stack; test "x$as_lineno_stack" = x && AS_UNSET([as_lineno])])
|
|
|
|
|
|
|
|
## -------------------------------------- ##
|
|
## 4. Portable versions of common tools. ##
|
|
## -------------------------------------- ##
|
|
|
|
# This section is lexicographically sorted.
|
|
|
|
|
|
# AS_BASENAME(FILE-NAME)
|
|
# ----------------------
|
|
# Simulate the command 'basename FILE-NAME'. Not all systems have basename.
|
|
# Also see the comments for AS_DIRNAME.
|
|
|
|
m4_defun([_AS_BASENAME_EXPR],
|
|
[$as_expr X/[]$1 : '.*/\([[^/][^/]*]\)/*$' \| \
|
|
X[]$1 : 'X\(//\)$' \| \
|
|
X[]$1 : 'X\(/\)' \| .])
|
|
|
|
m4_defun([_AS_BASENAME_SED],
|
|
[AS_ECHO([X/[]$1]) |
|
|
sed ['/^.*\/\([^/][^/]*\)\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\/\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q']])
|
|
|
|
m4_defun_init([AS_BASENAME],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[$as_basename -- $1 ||
|
|
_AS_BASENAME_EXPR([$1]) 2>/dev/null ||
|
|
_AS_BASENAME_SED([$1])])
|
|
|
|
|
|
# _AS_BASENAME_PREPARE
|
|
# --------------------
|
|
# Avoid Solaris 9 /usr/ucb/basename, as `basename /' outputs an empty line.
|
|
# Also, traditional basename mishandles --. Require here _AS_EXPR_PREPARE,
|
|
# to avoid problems when _AS_BASENAME is called from the M4SH-INIT diversion.
|
|
m4_defun([_AS_BASENAME_PREPARE],
|
|
[AS_REQUIRE([_AS_EXPR_PREPARE])]dnl
|
|
[if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
|
|
as_basename=basename
|
|
else
|
|
as_basename=false
|
|
fi
|
|
])# _AS_BASENAME_PREPARE
|
|
|
|
|
|
# AS_DIRNAME(FILE-NAME)
|
|
# ---------------------
|
|
# Simulate the command 'dirname FILE-NAME'. Not all systems have dirname.
|
|
# This macro must be usable from inside ` `.
|
|
#
|
|
# Prefer expr to echo|sed, since expr is usually faster and it handles
|
|
# backslashes and newlines correctly. However, older expr
|
|
# implementations (e.g. SunOS 4 expr and Solaris 8 /usr/ucb/expr) have
|
|
# a silly length limit that causes expr to fail if the matched
|
|
# substring is longer than 120 bytes. So fall back on echo|sed if
|
|
# expr fails.
|
|
m4_defun_init([_AS_DIRNAME_EXPR],
|
|
[AS_REQUIRE([_AS_EXPR_PREPARE])],
|
|
[$as_expr X[]$1 : 'X\(.*[[^/]]\)//*[[^/][^/]]*/*$' \| \
|
|
X[]$1 : 'X\(//\)[[^/]]' \| \
|
|
X[]$1 : 'X\(//\)$' \| \
|
|
X[]$1 : 'X\(/\)' \| .])
|
|
|
|
m4_defun([_AS_DIRNAME_SED],
|
|
[AS_ECHO([X[]$1]) |
|
|
sed ['/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)[^/].*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\/\)$/{
|
|
s//\1/
|
|
q
|
|
}
|
|
/^X\(\/\).*/{
|
|
s//\1/
|
|
q
|
|
}
|
|
s/.*/./; q']])
|
|
|
|
m4_defun_init([AS_DIRNAME],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[$as_dirname -- $1 ||
|
|
_AS_DIRNAME_EXPR([$1]) 2>/dev/null ||
|
|
_AS_DIRNAME_SED([$1])])
|
|
|
|
|
|
# _AS_DIRNAME_PREPARE
|
|
# --------------------
|
|
m4_defun([_AS_DIRNAME_PREPARE],
|
|
[AS_REQUIRE([_AS_EXPR_PREPARE])]dnl
|
|
[if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
|
|
as_dirname=dirname
|
|
else
|
|
as_dirname=false
|
|
fi
|
|
])# _AS_DIRNAME_PREPARE
|
|
|
|
|
|
# AS_ECHO(WORD)
|
|
# -------------
|
|
# Output WORD followed by a newline. WORD must be a single shell word
|
|
# (typically a quoted string). The bytes of WORD are output as-is, even
|
|
# if it starts with "-" or contains "\".
|
|
m4_defun_init([AS_ECHO],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[$as_echo $1])
|
|
|
|
|
|
# AS_ECHO_N(WORD)
|
|
# -------------
|
|
# Like AS_ECHO(WORD), except do not output the trailing newline.
|
|
m4_defun_init([AS_ECHO_N],
|
|
[AS_REQUIRE([_AS_ECHO_PREPARE])],
|
|
[$as_echo_n $1])
|
|
|
|
|
|
# _AS_ECHO_PREPARE
|
|
# -----------------
|
|
# Arrange for $as_echo 'FOO' to echo FOO without escape-interpretation;
|
|
# and similarly for $as_echo_n, which omits the trailing newline.
|
|
# 'FOO' is an optional single argument; a missing FOO is treated as empty.
|
|
m4_defun([_AS_ECHO_PREPARE],
|
|
[[as_nl='
|
|
'
|
|
export as_nl
|
|
# Printing a long string crashes Solaris 7 /usr/bin/printf.
|
|
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
|
|
# Prefer a ksh shell builtin over an external printf program on Solaris,
|
|
# but without wasting forks for bash or zsh.
|
|
if test -z "$BASH_VERSION$ZSH_VERSION" \
|
|
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='print -r --'
|
|
as_echo_n='print -rn --'
|
|
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
|
|
as_echo='printf %s\n'
|
|
as_echo_n='printf %s'
|
|
else
|
|
if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
|
|
as_echo_body='eval /usr/ucb/echo -n "$][1$as_nl"'
|
|
as_echo_n='/usr/ucb/echo -n'
|
|
else
|
|
as_echo_body='eval expr "X$][1" : "X\\(.*\\)"'
|
|
as_echo_n_body='eval
|
|
arg=$][1;
|
|
case $arg in @%:@(
|
|
*"$as_nl"*)
|
|
expr "X$arg" : "X\\(.*\\)$as_nl";
|
|
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
|
|
esac;
|
|
expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
|
|
'
|
|
export as_echo_n_body
|
|
as_echo_n='sh -c $as_echo_n_body as_echo'
|
|
fi
|
|
export as_echo_body
|
|
as_echo='sh -c $as_echo_body as_echo'
|
|
fi
|
|
]])# _AS_ECHO_PREPARE
|
|
|
|
|
|
# AS_TEST_X
|
|
# ---------
|
|
# Check whether a file has executable or search permissions.
|
|
m4_defun_init([AS_TEST_X],
|
|
[AS_REQUIRE([_AS_TEST_PREPARE])],
|
|
[$as_test_x $1[]])# AS_TEST_X
|
|
|
|
|
|
# AS_EXECUTABLE_P
|
|
# ---------------
|
|
# Check whether a file is a regular file that has executable permissions.
|
|
m4_defun_init([AS_EXECUTABLE_P],
|
|
[AS_REQUIRE([_AS_TEST_PREPARE])],
|
|
[{ test -f $1 && AS_TEST_X([$1]); }])# AS_EXECUTABLE_P
|
|
|
|
|
|
# _AS_EXPR_PREPARE
|
|
# ----------------
|
|
# QNX 4.25 expr computes and issue the right result but exits with failure.
|
|
# Tru64 expr mishandles leading zeros in numeric strings.
|
|
# Detect these flaws.
|
|
m4_defun([_AS_EXPR_PREPARE],
|
|
[if expr a : '\(a\)' >/dev/null 2>&1 &&
|
|
test "X`expr 00001 : '.*\(...\)'`" = X001; then
|
|
as_expr=expr
|
|
else
|
|
as_expr=false
|
|
fi
|
|
])# _AS_EXPR_PREPARE
|
|
|
|
|
|
# _AS_ME_PREPARE
|
|
# --------------
|
|
# Define $as_me to the basename of the executable file's name.
|
|
m4_defun([AS_ME_PREPARE], [AS_REQUIRE([_$0])])
|
|
m4_defun([_AS_ME_PREPARE],
|
|
[AS_REQUIRE([_AS_BASENAME_PREPARE])]dnl
|
|
[as_me=`AS_BASENAME("$[0]")`
|
|
])
|
|
|
|
# _AS_LINENO_WORKS
|
|
# ---------------
|
|
# Succeed if the currently executing shell supports LINENO.
|
|
# This macro does not expand to a single shell command, so be careful
|
|
# when using it. Surrounding the body of this macro with {} would
|
|
# cause "bash -c '_ASLINENO_WORKS'" to fail (with Bash 2.05, anyway),
|
|
# but that bug is irrelevant to our use of LINENO. We can't use
|
|
# AS_VAR_ARITH, as this is expanded prior to shell functions.
|
|
#
|
|
# Testing for LINENO support is hard; we use _AS_LINENO_WORKS inside
|
|
# _AS_RUN, which sometimes eval's its argument (pdksh gives false
|
|
# negatives if $LINENO is expanded by eval), and sometimes passes the
|
|
# argument to another shell (if the current shell supports LINENO,
|
|
# then expanding $LINENO prior to the string leads to false
|
|
# positives). Hence, we perform two tests, and coordinate with
|
|
# _AS_DETECT_EXPAND (which ensures that only the first of two LINENO
|
|
# is expanded in advance) and _AS_RUN (which sets $as_run to 'a' when
|
|
# handing the test to another shell), so that we know which test to
|
|
# trust.
|
|
m4_define([_AS_LINENO_WORKS],
|
|
[ as_lineno_1=$LINENO as_lineno_1a=$LINENO
|
|
as_lineno_2=$LINENO as_lineno_2a=$LINENO
|
|
eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
|
|
test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"'])
|
|
|
|
|
|
# _AS_LINENO_PREPARE
|
|
# ------------------
|
|
# If LINENO is not supported by the shell, produce a version of this
|
|
# script where LINENO is hard coded.
|
|
# Comparing LINENO against _oline_ is not a good solution, since in
|
|
# the case of embedded executables (such as config.status within
|
|
# configure) you'd compare LINENO wrt config.status vs. _oline_ wrt
|
|
# configure.
|
|
#
|
|
# AS_ERROR normally uses LINENO if logging, but AS_LINENO_PREPARE uses
|
|
# AS_ERROR. Besides, if the logging fd is open, we don't want to use
|
|
# $LINENO in the log complaining about broken LINENO. We break the
|
|
# circular require by changing AS_ERROR and AS_MESSAGE_LOG_FD.
|
|
m4_defun([AS_LINENO_PREPARE], [AS_REQUIRE([_$0])])
|
|
m4_defun([_AS_LINENO_PREPARE],
|
|
[AS_REQUIRE([_AS_CR_PREPARE])]dnl
|
|
[AS_REQUIRE([_AS_ME_PREPARE])]dnl
|
|
[_AS_DETECT_SUGGESTED([_AS_LINENO_WORKS])]dnl
|
|
[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
|
|
[m4_pushdef([AS_ERROR],
|
|
[{ AS_MESSAGE(]m4_dquote([error: $][1])[, [2]); AS_EXIT([1]); }])]dnl
|
|
dnl Create $as_me.lineno as a copy of $as_myself, but with $LINENO
|
|
dnl uniformly replaced by the line number. The first 'sed' inserts a
|
|
dnl line-number line after each line using $LINENO; the second 'sed'
|
|
dnl does the real work. The second script uses 'N' to pair each
|
|
dnl line-number line with the line containing $LINENO, and appends
|
|
dnl trailing '-' during substitution so that $LINENO is not a special
|
|
dnl case at line end. (Raja R Harinath suggested sed '=', and Paul
|
|
dnl Eggert wrote the scripts with optimization help from Paolo Bonzini).
|
|
[_AS_LINENO_WORKS || {
|
|
# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
|
|
sed -n '
|
|
p
|
|
/[[$]]LINENO/=
|
|
' <$as_myself |
|
|
sed '
|
|
s/[[$]]LINENO.*/&-/
|
|
t lineno
|
|
b
|
|
:lineno
|
|
N
|
|
:loop
|
|
s/[[$]]LINENO\([[^'$as_cr_alnum'_]].*\n\)\(.*\)/\2\1\2/
|
|
t loop
|
|
s/-\n.*//
|
|
' >$as_me.lineno &&
|
|
chmod +x "$as_me.lineno" ||
|
|
AS_ERROR([cannot create $as_me.lineno; rerun with a POSIX shell])
|
|
|
|
# Don't try to exec as it changes $[0], causing all sort of problems
|
|
# (the dirname of $[0] is not the place where we might find the
|
|
# original and so on. Autoconf is especially sensitive to this).
|
|
. "./$as_me.lineno"
|
|
# Exit status is that of the last command.
|
|
exit
|
|
}
|
|
_m4_popdef([AS_MESSAGE_LOG_FD], [AS_ERROR])])# _AS_LINENO_PREPARE
|
|
|
|
|
|
# _AS_LN_S_PREPARE
|
|
# ----------------
|
|
# Don't use conftest.sym to avoid file name issues on DJGPP, where this
|
|
# would yield conftest.sym.exe for DJGPP < 2.04. And don't use `conftest'
|
|
# as base name to avoid prohibiting concurrency (e.g., concurrent
|
|
# config.statuses). On read-only media, assume 'cp -p' and hope we
|
|
# are just running --help anyway.
|
|
m4_defun([_AS_LN_S_PREPARE],
|
|
[rm -f conf$$ conf$$.exe conf$$.file
|
|
if test -d conf$$.dir; then
|
|
rm -f conf$$.dir/conf$$.file
|
|
else
|
|
rm -f conf$$.dir
|
|
mkdir conf$$.dir 2>/dev/null
|
|
fi
|
|
if (echo >conf$$.file) 2>/dev/null; then
|
|
if ln -s conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s='ln -s'
|
|
# ... but there are two gotchas:
|
|
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
|
|
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
|
|
# In both cases, we have to default to `cp -p'.
|
|
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
|
|
as_ln_s='cp -p'
|
|
elif ln conf$$.file conf$$ 2>/dev/null; then
|
|
as_ln_s=ln
|
|
else
|
|
as_ln_s='cp -p'
|
|
fi
|
|
else
|
|
as_ln_s='cp -p'
|
|
fi
|
|
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
|
|
rmdir conf$$.dir 2>/dev/null
|
|
])# _AS_LN_S_PREPARE
|
|
|
|
|
|
# AS_LN_S(FILE, LINK)
|
|
# -------------------
|
|
# FIXME: Should we add the glue code to handle properly relative symlinks
|
|
# simulated with `ln' or `cp'?
|
|
m4_defun_init([AS_LN_S],
|
|
[AS_REQUIRE([_AS_LN_S_PREPARE])],
|
|
[$as_ln_s $1 $2])
|
|
|
|
|
|
# _AS_MKDIR_P
|
|
# -----------
|
|
# Emit code that can be used to emulate `mkdir -p` with plain `mkdir';
|
|
# the code assumes that "$as_dir" contains the directory to create.
|
|
# $as_dir is normalized, so there is no need to worry about using --.
|
|
m4_define([_AS_MKDIR_P],
|
|
[case $as_dir in #(
|
|
-*) as_dir=./$as_dir;;
|
|
esac
|
|
test -d "$as_dir" || eval $as_mkdir_p || {
|
|
as_dirs=
|
|
while :; do
|
|
case $as_dir in #(
|
|
*\'*) as_qdir=`AS_ECHO(["$as_dir"]) | sed "s/'/'\\\\\\\\''/g"`;; #'(
|
|
*) as_qdir=$as_dir;;
|
|
esac
|
|
as_dirs="'$as_qdir' $as_dirs"
|
|
as_dir=`AS_DIRNAME("$as_dir")`
|
|
test -d "$as_dir" && break
|
|
done
|
|
test -z "$as_dirs" || eval "mkdir $as_dirs"
|
|
} || test -d "$as_dir" || AS_ERROR([cannot create directory $as_dir])
|
|
])
|
|
|
|
# AS_MKDIR_P(DIR)
|
|
# ---------------
|
|
# Emulate `mkdir -p' with plain `mkdir' if needed.
|
|
m4_defun_init([AS_MKDIR_P],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[as_dir=$1; as_fn_mkdir_p])# AS_MKDIR_P
|
|
|
|
|
|
# _AS_MKDIR_P_PREPARE
|
|
# -------------------
|
|
m4_defun([_AS_MKDIR_P_PREPARE],
|
|
[AS_REQUIRE_SHELL_FN([as_fn_mkdir_p],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_mkdir_p], [],
|
|
[Create "$as_dir" as a directory, including parents if necessary.])],
|
|
[
|
|
_AS_MKDIR_P
|
|
])]dnl
|
|
[if mkdir -p . 2>/dev/null; then
|
|
as_mkdir_p='mkdir -p "$as_dir"'
|
|
else
|
|
test -d ./-p && rmdir ./-p
|
|
as_mkdir_p=false
|
|
fi
|
|
])# _AS_MKDIR_P_PREPARE
|
|
|
|
|
|
# _AS_PATH_SEPARATOR_PREPARE
|
|
# --------------------------
|
|
# Compute the path separator.
|
|
m4_defun([_AS_PATH_SEPARATOR_PREPARE],
|
|
[# The user is always right.
|
|
if test "${PATH_SEPARATOR+set}" != set; then
|
|
PATH_SEPARATOR=:
|
|
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
|
|
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
|
|
PATH_SEPARATOR=';'
|
|
}
|
|
fi
|
|
])# _AS_PATH_SEPARATOR_PREPARE
|
|
|
|
|
|
# _AS_PATH_WALK([PATH = $PATH], BODY, [IF-NOT-FOUND])
|
|
# ---------------------------------------------------
|
|
# Walk through PATH running BODY for each `as_dir'. If BODY never does a
|
|
# `break', evaluate IF-NOT-FOUND.
|
|
#
|
|
# Still very private as its interface looks quite bad.
|
|
#
|
|
# `$as_dummy' forces splitting on constant user-supplied paths.
|
|
# POSIX.2 field splitting is done only on the result of word
|
|
# expansions, not on literal text. This closes a longstanding sh security
|
|
# hole. Optimize it away when not needed, i.e., if there are no literal
|
|
# path separators.
|
|
m4_defun_init([_AS_PATH_WALK],
|
|
[AS_REQUIRE([_AS_PATH_SEPARATOR_PREPARE])],
|
|
[as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
|
|
m4_ifvaln([$3], [as_found=false])dnl
|
|
m4_bmatch([$1], [[:;]],
|
|
[as_dummy="$1"
|
|
for as_dir in $as_dummy],
|
|
[for as_dir in m4_default([$1], [$PATH])])
|
|
do
|
|
IFS=$as_save_IFS
|
|
test -z "$as_dir" && as_dir=.
|
|
m4_ifvaln([$3], [as_found=:])dnl
|
|
$2
|
|
m4_ifvaln([$3], [as_found=false])dnl
|
|
done
|
|
m4_ifvaln([$3], [$as_found || { $3; }])dnl
|
|
IFS=$as_save_IFS
|
|
])
|
|
|
|
|
|
# AS_SET_CATFILE(VAR, DIR-NAME, FILE-NAME)
|
|
# ----------------------------------------
|
|
# Set VAR to DIR-NAME/FILE-NAME.
|
|
# Optimize the common case where $2 or $3 is '.'.
|
|
m4_define([AS_SET_CATFILE],
|
|
[case $2 in @%:@((
|
|
.) $1=$3;;
|
|
*)
|
|
case $3 in @%:@(((
|
|
.) $1=$2;;
|
|
[[\\/]]* | ?:[[\\/]]* ) $1=$3;;
|
|
*) $1=$2/$3;;
|
|
esac;;
|
|
esac[]])# AS_SET_CATFILE
|
|
|
|
|
|
# _AS_TEST_PREPARE
|
|
# ----------------
|
|
# Find out whether `test -x' works. If not, prepare a substitute
|
|
# that should work well enough for most scripts.
|
|
#
|
|
# Here are some of the problems with the substitute.
|
|
# The 'ls' tests whether the owner, not the current user, can execute/search.
|
|
# The eval means '*', '?', and '[' cause inadvertent file name globbing
|
|
# after the 'eval', so jam together as many tokens as we can to minimize
|
|
# the likelihood that the inadvertent globbing will actually do anything.
|
|
# Luckily, this gorp is needed only on really ancient hosts.
|
|
#
|
|
m4_defun([_AS_TEST_PREPARE],
|
|
[if test -x / >/dev/null 2>&1; then
|
|
as_test_x='test -x'
|
|
else
|
|
if ls -dL / >/dev/null 2>&1; then
|
|
as_ls_L_option=L
|
|
else
|
|
as_ls_L_option=
|
|
fi
|
|
as_test_x='
|
|
eval sh -c '\''
|
|
if test -d "$[]1"; then
|
|
test -d "$[]1/.";
|
|
else
|
|
case $[]1 in @%:@(
|
|
-*)set "./$[]1";;
|
|
esac;
|
|
case `ls -ld'$as_ls_L_option' "$[]1" 2>/dev/null` in @%:@((
|
|
???[[sx]]*):;;*)false;;esac;fi
|
|
'\'' sh
|
|
'
|
|
fi
|
|
dnl as_executable_p is present for backward compatibility with Libtool
|
|
dnl 1.5.22, but it should go away at some point.
|
|
as_executable_p=$as_test_x
|
|
])# _AS_TEST_PREPARE
|
|
|
|
|
|
|
|
|
|
## ------------------ ##
|
|
## 5. Common idioms. ##
|
|
## ------------------ ##
|
|
|
|
# This section is lexicographically sorted.
|
|
|
|
|
|
# AS_BOX(MESSAGE, [FRAME-CHARACTER = `-'])
|
|
# ----------------------------------------
|
|
# Output MESSAGE, a single line text, framed with FRAME-CHARACTER (which
|
|
# must not be `/').
|
|
m4_define([AS_BOX],
|
|
[AS_LITERAL_IF([$1],
|
|
[_AS_BOX_LITERAL($@)],
|
|
[_AS_BOX_INDIR($@)])])
|
|
|
|
|
|
# _AS_BOX_LITERAL(MESSAGE, [FRAME-CHARACTER = `-'])
|
|
# -------------------------------------------------
|
|
m4_define([_AS_BOX_LITERAL],
|
|
[cat <<\_ASBOX
|
|
m4_text_box($@)
|
|
_ASBOX])
|
|
|
|
|
|
# _AS_BOX_INDIR(MESSAGE, [FRAME-CHARACTER = `-'])
|
|
# -----------------------------------------------
|
|
m4_define([_AS_BOX_INDIR],
|
|
[sed 'h;s/./m4_default([$2], [-])/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX
|
|
@%:@@%:@ $1 @%:@@%:@
|
|
_ASBOX])
|
|
|
|
|
|
# AS_FUNCTION_DESCRIBE(NAME, [ARGS], DESCRIPTION, [WRAP-COLUMN = 79])
|
|
# -------------------------------------------------------------------
|
|
# Output a shell comment describing NAME and its arguments ARGS, then
|
|
# a separator line, then the DESCRIPTION wrapped at a decimal
|
|
# WRAP-COLUMN. The output resembles:
|
|
# # NAME ARGS
|
|
# # ---------
|
|
# # Wrapped DESCRIPTION text
|
|
# NAME and ARGS are expanded, while DESCRIPTION is treated as a
|
|
# whitespace-separated list of strings that are not expanded.
|
|
m4_define([AS_FUNCTION_DESCRIBE],
|
|
[@%:@ $1[]m4_ifval([$2], [ $2])
|
|
@%:@ m4_translit(m4_format([%*s],
|
|
m4_decr(m4_qlen(_m4_expand([$1[]m4_ifval([$2], [ $2])
|
|
]))), []), [ ], [-])
|
|
m4_text_wrap([$3], [@%:@ ], [], [$4])])
|
|
|
|
|
|
# AS_HELP_STRING(LHS, RHS, [INDENT-COLUMN = 26], [WRAP-COLUMN = 79])
|
|
# ------------------------------------------------------------------
|
|
#
|
|
# Format a help string so that it looks pretty when the user executes
|
|
# "script --help". This macro takes up to four arguments, a
|
|
# "left hand side" (LHS), a "right hand side" (RHS), a decimal
|
|
# INDENT-COLUMN which is the column where wrapped lines should begin
|
|
# (the default of 26 is recommended), and a decimal WRAP-COLUMN which is
|
|
# the column where lines should wrap (the default of 79 is recommended).
|
|
# LHS is expanded, RHS is not.
|
|
#
|
|
# For backwards compatibility not documented in the manual, INDENT-COLUMN
|
|
# can also be specified as a string of white spaces, whose width
|
|
# determines the indentation column. Using TABs in INDENT-COLUMN is not
|
|
# recommended, since screen width of TAB is not computed.
|
|
#
|
|
# The resulting string is suitable for use in other macros that require
|
|
# a help string (e.g. AC_ARG_WITH).
|
|
#
|
|
# Here is the sample string from the Autoconf manual (Node: External
|
|
# Software) which shows the proper spacing for help strings.
|
|
#
|
|
# --with-readline support fancy command line editing
|
|
# ^ ^ ^
|
|
# | | |
|
|
# | column 2 column 26
|
|
# |
|
|
# column 0
|
|
#
|
|
# A help string is made up of a "left hand side" (LHS) and a "right
|
|
# hand side" (RHS). In the example above, the LHS is
|
|
# "--with-readline", while the RHS is "support fancy command line
|
|
# editing".
|
|
#
|
|
# If the LHS contains more than (INDENT-COLUMN - 3) characters, then the
|
|
# LHS is terminated with a newline so that the RHS starts on a line of its
|
|
# own beginning at INDENT-COLUMN. In the default case, this corresponds to an
|
|
# LHS with more than 23 characters.
|
|
#
|
|
# Therefore, in the example, if the LHS were instead
|
|
# "--with-readline-blah-blah-blah", then the AS_HELP_STRING macro would
|
|
# expand into:
|
|
#
|
|
#
|
|
# --with-readline-blah-blah-blah
|
|
# ^ ^ support fancy command line editing
|
|
# | | ^
|
|
# | column 2 |
|
|
# column 0 column 26
|
|
#
|
|
#
|
|
# m4_text_wrap hacks^Wworks around the fact that m4_format does not
|
|
# know quadrigraphs.
|
|
#
|
|
m4_define([AS_HELP_STRING],
|
|
[m4_text_wrap([$2], m4_cond([[$3]], [], [ ],
|
|
[m4_eval([$3]+0)], [0], [[$3]],
|
|
[m4_format([[%*s]], [$3], [])]),
|
|
m4_expand([ $1 ]), [$4])])# AS_HELP_STRING
|
|
|
|
|
|
# AS_IDENTIFIER_IF(EXPRESSION, IF-IDENT, IF-NOT-IDENT)
|
|
# ----------------------------------------------------
|
|
# If EXPRESSION serves as an identifier (ie, after removal of @&t@, it
|
|
# matches the regex `^[a-zA-Z_][a-zA-Z_0-9]*$'), execute IF-IDENT,
|
|
# otherwise IF-NOT-IDENT.
|
|
#
|
|
# This is generally faster than the alternative:
|
|
# m4_bmatch(m4_bpatsubst([[$1]], [@&t@]), ^m4_defn([m4_re_word])$,
|
|
# [$2], [$3])
|
|
#
|
|
# Rather than expand m4_defn every time AS_IDENTIFIER_IF is expanded, we
|
|
# inline its expansion up front. Only use a regular expression if we
|
|
# detect a potential quadrigraph.
|
|
#
|
|
# First, check if the entire string matches m4_cr_symbol2. Only then do
|
|
# we worry if the first character also matches m4_cr_symbol1 (ie. does not
|
|
# match m4_cr_digit).
|
|
m4_define([AS_IDENTIFIER_IF],
|
|
[m4_if(m4_index([$1], [@]), [-1],
|
|
[_$0($@)],
|
|
[_$0(m4_bpatsubst([[$1]], [@&t@]), [$2], [$3])])])
|
|
m4_define([_AS_IDENTIFIER_IF],
|
|
[m4_cond([[$1]], [], [$3],
|
|
[m4_eval(m4_len(m4_translit([[$1]], ]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[)) > 0)], [1], [$3],
|
|
[m4_len(m4_translit(m4_format([[%.1s]], [$1]), ]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_symbols1])))[[))], [0], [$2], [$3])])
|
|
|
|
|
|
# AS_LITERAL_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL)
|
|
# -----------------------------------------------------
|
|
# If EXPRESSION has shell indirections ($var or `expr`), expand
|
|
# IF-LITERAL, else IF-NOT-LITERAL.
|
|
# This is an *approximation*: for instance EXPRESSION = `\$' is
|
|
# definitely a literal, but will not be recognized as such.
|
|
#
|
|
# Why do we reject EXPRESSION expanding with `[' or `]' as a literal?
|
|
# Because AS_TR_SH is MUCH faster if it can use m4_translit on literals
|
|
# instead of m4_bpatsubst; but m4_translit is much tougher to do safely
|
|
# if `[' is translated.
|
|
#
|
|
# Note that the quadrigraph @S|@ can result in non-literals, but outright
|
|
# rejecting all @ would make AC_INIT complain on its bug report address.
|
|
#
|
|
# We used to use m4_bmatch(m4_quote($1), [[`$]], [$3], [$2]), but
|
|
# profiling shows that it is faster to use m4_translit.
|
|
#
|
|
# Because the translit is stripping quotes, it must also neutralize anything
|
|
# that might be in a macro name, as well as comments and commas. All the
|
|
# problem characters are unified so that a single m4_index can scan the
|
|
# result.
|
|
#
|
|
# Rather than expand m4_defn every time AS_LITERAL_IF is expanded, we
|
|
# inline its expansion up front.
|
|
m4_define([AS_LITERAL_IF],
|
|
[m4_cond([m4_eval(m4_index(m4_quote($1), [@S|@]) == -1)], [0], [$3],
|
|
[m4_index(m4_translit(m4_quote($1),
|
|
[[]`,#]]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[,
|
|
[$$$]),
|
|
[$])], [-1], [$2],
|
|
[$3])])
|
|
|
|
|
|
# AS_TMPDIR(PREFIX, [DIRECTORY = $TMPDIR [= /tmp]])
|
|
# -------------------------------------------------
|
|
# Create as safely as possible a temporary directory in DIRECTORY
|
|
# which name is inspired by PREFIX (should be 2-4 chars max).
|
|
m4_define([AS_TMPDIR],
|
|
[# Create a (secure) tmp directory for tmp files.
|
|
m4_if([$2], [], [: ${TMPDIR=/tmp}])
|
|
{
|
|
tmp=`(umask 077 && mktemp -d "m4_default([$2], [$TMPDIR])/$1XXXXXX") 2>/dev/null` &&
|
|
test -n "$tmp" && test -d "$tmp"
|
|
} ||
|
|
{
|
|
tmp=m4_default([$2], [$TMPDIR])/$1$$-$RANDOM
|
|
(umask 077 && mkdir "$tmp")
|
|
} || AS_ERROR([cannot create a temporary directory in m4_default([$2],
|
|
[$TMPDIR])])])# AS_TMPDIR
|
|
|
|
|
|
# AS_UNAME
|
|
# --------
|
|
# Try to describe this machine. Meant for logs.
|
|
m4_define([AS_UNAME],
|
|
[{
|
|
cat <<_ASUNAME
|
|
m4_text_box([Platform.])
|
|
|
|
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
|
|
uname -m = `(uname -m) 2>/dev/null || echo unknown`
|
|
uname -r = `(uname -r) 2>/dev/null || echo unknown`
|
|
uname -s = `(uname -s) 2>/dev/null || echo unknown`
|
|
uname -v = `(uname -v) 2>/dev/null || echo unknown`
|
|
|
|
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
|
|
/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
|
|
|
|
/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
|
|
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
|
|
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
|
|
/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
|
|
/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
|
|
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
|
|
/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
|
|
|
|
_ASUNAME
|
|
|
|
_AS_PATH_WALK([$PATH], [AS_ECHO(["PATH: $as_dir"])])
|
|
}])
|
|
|
|
|
|
# _AS_VERSION_COMPARE_PREPARE
|
|
# ---------------------------
|
|
# Output variables for comparing version numbers.
|
|
m4_defun([_AS_VERSION_COMPARE_PREPARE],
|
|
[[as_awk_strverscmp='
|
|
# Use only awk features that work with 7th edition Unix awk (1978).
|
|
# My, what an old awk you have, Mr. Solaris!
|
|
END {
|
|
while (length(v1) && length(v2)) {
|
|
# Set d1 to be the next thing to compare from v1, and likewise for d2.
|
|
# Normally this is a single character, but if v1 and v2 contain digits,
|
|
# compare them as integers and fractions as strverscmp does.
|
|
if (v1 ~ /^[0-9]/ && v2 ~ /^[0-9]/) {
|
|
# Split v1 and v2 into their leading digit string components d1 and d2,
|
|
# and advance v1 and v2 past the leading digit strings.
|
|
for (len1 = 1; substr(v1, len1 + 1) ~ /^[0-9]/; len1++) continue
|
|
for (len2 = 1; substr(v2, len2 + 1) ~ /^[0-9]/; len2++) continue
|
|
d1 = substr(v1, 1, len1); v1 = substr(v1, len1 + 1)
|
|
d2 = substr(v2, 1, len2); v2 = substr(v2, len2 + 1)
|
|
if (d1 ~ /^0/) {
|
|
if (d2 ~ /^0/) {
|
|
# Compare two fractions.
|
|
while (d1 ~ /^0/ && d2 ~ /^0/) {
|
|
d1 = substr(d1, 2); len1--
|
|
d2 = substr(d2, 2); len2--
|
|
}
|
|
if (len1 != len2 && ! (len1 && len2 && substr(d1, 1, 1) == substr(d2, 1, 1))) {
|
|
# The two components differ in length, and the common prefix
|
|
# contains only leading zeros. Consider the longer to be less.
|
|
d1 = -len1
|
|
d2 = -len2
|
|
} else {
|
|
# Otherwise, compare as strings.
|
|
d1 = "x" d1
|
|
d2 = "x" d2
|
|
}
|
|
} else {
|
|
# A fraction is less than an integer.
|
|
exit 1
|
|
}
|
|
} else {
|
|
if (d2 ~ /^0/) {
|
|
# An integer is greater than a fraction.
|
|
exit 2
|
|
} else {
|
|
# Compare two integers.
|
|
d1 += 0
|
|
d2 += 0
|
|
}
|
|
}
|
|
} else {
|
|
# The normal case, without worrying about digits.
|
|
d1 = substr(v1, 1, 1); v1 = substr(v1, 2)
|
|
d2 = substr(v2, 1, 1); v2 = substr(v2, 2)
|
|
}
|
|
if (d1 < d2) exit 1
|
|
if (d1 > d2) exit 2
|
|
}
|
|
# Beware Solaris /usr/xgp4/bin/awk (at least through Solaris 10),
|
|
# which mishandles some comparisons of empty strings to integers.
|
|
if (length(v2)) exit 1
|
|
if (length(v1)) exit 2
|
|
}
|
|
']])# _AS_VERSION_COMPARE_PREPARE
|
|
|
|
|
|
# AS_VERSION_COMPARE(VERSION-1, VERSION-2,
|
|
# [ACTION-IF-LESS], [ACTION-IF-EQUAL], [ACTION-IF-GREATER])
|
|
# -----------------------------------------------------------------------------
|
|
# Compare two strings possibly containing shell variables as version strings.
|
|
#
|
|
# This usage is portable even to ancient awk,
|
|
# so don't worry about finding a "nice" awk version.
|
|
m4_defun_init([AS_VERSION_COMPARE],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[as_arg_v1=$1
|
|
as_arg_v2=$2
|
|
awk "$as_awk_strverscmp" v1="$as_arg_v1" v2="$as_arg_v2" /dev/null
|
|
AS_CASE([$?],
|
|
[1], [$3],
|
|
[0], [$4],
|
|
[2], [$5])])# AS_VERSION_COMPARE
|
|
|
|
|
|
|
|
## --------------------------------------- ##
|
|
## 6. Common m4/sh character translation. ##
|
|
## --------------------------------------- ##
|
|
|
|
# The point of this section is to provide high level macros comparable
|
|
# to m4's `translit' primitive, but m4/sh polymorphic.
|
|
# Transliteration of literal strings should be handled by m4, while
|
|
# shell variables' content will be translated at runtime (tr or sed).
|
|
|
|
|
|
# _AS_CR_PREPARE
|
|
# --------------
|
|
# Output variables defining common character ranges.
|
|
# See m4_cr_letters etc.
|
|
m4_defun([_AS_CR_PREPARE],
|
|
[# Avoid depending upon Character Ranges.
|
|
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
|
|
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
|
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
|
|
as_cr_digits='0123456789'
|
|
as_cr_alnum=$as_cr_Letters$as_cr_digits
|
|
])
|
|
|
|
|
|
# _AS_TR_SH_PREPARE
|
|
# -----------------
|
|
m4_defun([_AS_TR_SH_PREPARE],
|
|
[AS_REQUIRE([_AS_CR_PREPARE])]dnl
|
|
[# Sed expression to map a string onto a valid variable name.
|
|
as_tr_sh="eval sed 'y%*+%pp%;s%[[^_$as_cr_alnum]]%_%g'"
|
|
])
|
|
|
|
|
|
# AS_TR_SH(EXPRESSION)
|
|
# --------------------
|
|
# Transform EXPRESSION into a valid shell variable name.
|
|
# sh/m4 polymorphic.
|
|
# Be sure to update the definition of `$as_tr_sh' if you change this.
|
|
#
|
|
# AS_LITERAL_IF guarantees that a literal does not have any nested quotes,
|
|
# once $1 is expanded. m4_translit silently uses only the first occurrence
|
|
# of a character that appears multiple times in argument 2, since we know
|
|
# that m4_cr_not_symbols2 also contains [ and ]. m4_translit also silently
|
|
# ignores characters in argument 3 that do not match argument 2; we use this
|
|
# fact to skip worrying about the length of m4_cr_not_symbols2.
|
|
#
|
|
# For speed, we inline the literal definitions that can be computed up front.
|
|
m4_defun_init([AS_TR_SH],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[AS_LITERAL_IF([$1],
|
|
[m4_translit([$1], [*+[]]]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_not_symbols2])))[[,
|
|
[pp[]]]]dnl
|
|
m4_dquote(m4_dquote(m4_for(,1,255,,[[_]])))[[)],
|
|
[`AS_ECHO(["_AS_ESCAPE(m4_dquote(m4_expand([$1])),
|
|
[`], [\])"]) | $as_tr_sh`])])
|
|
|
|
|
|
# _AS_TR_CPP_PREPARE
|
|
# ------------------
|
|
m4_defun([_AS_TR_CPP_PREPARE],
|
|
[AS_REQUIRE([_AS_CR_PREPARE])]dnl
|
|
[# Sed expression to map a string onto a valid CPP name.
|
|
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[[^_$as_cr_alnum]]%_%g'"
|
|
])
|
|
|
|
|
|
# AS_TR_CPP(EXPRESSION)
|
|
# ---------------------
|
|
# Map EXPRESSION to an upper case string which is valid as rhs for a
|
|
# `#define'. sh/m4 polymorphic. Be sure to update the definition
|
|
# of `$as_tr_cpp' if you change this.
|
|
#
|
|
# See implementation comments in AS_TR_SH.
|
|
m4_defun_init([AS_TR_CPP],
|
|
[AS_REQUIRE([_$0_PREPARE])],
|
|
[AS_LITERAL_IF([$1],
|
|
[m4_translit([$1], [*[]]]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_letters])m4_defn([m4_cr_not_symbols2])))[[,
|
|
[P[]]]]dnl
|
|
m4_dquote(m4_dquote(m4_defn([m4_cr_LETTERS])m4_for(,1,255,,[[_]])))[[)],
|
|
[`AS_ECHO(["$1"]) | $as_tr_cpp`])])
|
|
|
|
|
|
# _AS_TR_PREPARE
|
|
# --------------
|
|
m4_defun([_AS_TR_PREPARE],
|
|
[AS_REQUIRE([_AS_TR_SH_PREPARE])AS_REQUIRE([_AS_TR_CPP_PREPARE])])
|
|
|
|
|
|
|
|
|
|
## ------------------------------------------------------ ##
|
|
## 7. Common m4/sh handling of variables (indirections). ##
|
|
## ------------------------------------------------------ ##
|
|
|
|
|
|
# The purpose of this section is to provide a uniform API for
|
|
# reading/setting sh variables with or without indirection.
|
|
# Typically, one can write
|
|
# AS_VAR_SET(var, val)
|
|
# or
|
|
# AS_VAR_SET(as_$var, val)
|
|
# and expect the right thing to happen. In the descriptions below,
|
|
# a literal name matches the regex [a-zA-Z_][a-zA-Z0-9_]*, an
|
|
# indirect name is a shell expression that produces a literal name
|
|
# when passed through eval, and a polymorphic name is either type.
|
|
|
|
|
|
# _AS_VAR_APPEND_PREPARE
|
|
# ----------------------
|
|
# Define as_fn_append to the optimum definition for the current
|
|
# shell (bash and zsh provide the += assignment operator to avoid
|
|
# quadratic append growth over repeated appends).
|
|
m4_defun([_AS_VAR_APPEND_PREPARE],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_append], [VAR VALUE],
|
|
[Append the text in VALUE to the end of the definition contained in
|
|
VAR. Take advantage of any shell optimizations that allow amortized
|
|
linear growth over repeated appends, instead of the typical quadratic
|
|
growth present in naive implementations.])
|
|
AS_IF([_AS_RUN(["AS_ESCAPE(m4_quote(_AS_VAR_APPEND_WORKS))"])],
|
|
[eval 'as_fn_append ()
|
|
{
|
|
eval $[]1+=\$[]2
|
|
}'],
|
|
[as_fn_append ()
|
|
{
|
|
eval $[]1=\$$[]1\$[]2
|
|
}]) # as_fn_append
|
|
])
|
|
|
|
# _AS_VAR_APPEND_WORKS
|
|
# --------------------
|
|
# Output a shell test to discover whether += works.
|
|
m4_define([_AS_VAR_APPEND_WORKS],
|
|
[as_var=1; as_var+=2; test x$as_var = x12])
|
|
|
|
# AS_VAR_APPEND(VAR, VALUE)
|
|
# -------------------------
|
|
# Append the shell expansion of VALUE to the end of the existing
|
|
# contents of the polymorphic shell variable VAR, taking advantage of
|
|
# any shell optimizations that allow repeated appends to result in
|
|
# amortized linear scaling rather than quadratic behavior. This macro
|
|
# is not worth the overhead unless the expected final size of the
|
|
# contents of VAR outweigh the typical VALUE size of repeated appends.
|
|
# Note that unlike AS_VAR_SET, VALUE must be properly quoted to avoid
|
|
# field splitting and file name expansion.
|
|
m4_defun_init([AS_VAR_APPEND],
|
|
[AS_REQUIRE([_AS_VAR_APPEND_PREPARE], [], [M4SH-INIT-FN])],
|
|
[as_fn_append $1 $2])
|
|
|
|
|
|
# _AS_VAR_ARITH_PREPARE
|
|
# ---------------------
|
|
# Define as_fn_arith to the optimum definition for the current
|
|
# shell (using POSIX $(()) where supported).
|
|
m4_defun([_AS_VAR_ARITH_PREPARE],
|
|
[AS_FUNCTION_DESCRIBE([as_fn_arith], [ARG...],
|
|
[Perform arithmetic evaluation on the ARGs, and store the result in
|
|
the global $as_val. Take advantage of shells that can avoid forks.
|
|
The arguments must be portable across $(()) and expr.])
|
|
AS_IF([_AS_RUN(["AS_ESCAPE(m4_quote(_AS_VAR_ARITH_WORKS))"])],
|
|
[eval 'as_fn_arith ()
|
|
{
|
|
as_val=$(( $[]* ))
|
|
}'],
|
|
[as_fn_arith ()
|
|
{
|
|
as_val=`expr "$[]@" || test $? -eq 1`
|
|
}]) # as_fn_arith
|
|
])
|
|
|
|
# _AS_VAR_ARITH_WORKS
|
|
# -------------------
|
|
# Output a shell test to discover whether $(()) works.
|
|
m4_define([_AS_VAR_ARITH_WORKS],
|
|
[test $(( 1 + 1 )) = 2])
|
|
|
|
# AS_VAR_ARITH(VAR, EXPR)
|
|
# -----------------------
|
|
# Perform the arithmetic evaluation of the arguments in EXPR, and set
|
|
# contents of the polymorphic shell variable VAR to the result, taking
|
|
# advantage of any shell optimizations that perform arithmetic without
|
|
# forks. Note that numbers occuring within EXPR must be written in
|
|
# decimal, and without leading zeroes; variables containing numbers
|
|
# must be expanded prior to arithmetic evaluation; the first argument
|
|
# must not be a negative number; there is no portable equality
|
|
# operator; and operators must be given as separate arguments and
|
|
# properly quoted.
|
|
m4_defun_init([AS_VAR_ARITH],
|
|
[_AS_DETECT_SUGGESTED([_AS_VAR_ARITH_WORKS])]dnl
|
|
[AS_REQUIRE([_AS_VAR_ARITH_PREPARE], [], [M4SH-INIT-FN])],
|
|
[as_fn_arith $2 && AS_VAR_SET([$1], [$as_val])])
|
|
|
|
|
|
# AS_VAR_COPY(DEST, SOURCE)
|
|
# -------------------------
|
|
# Set the polymorphic shell variable DEST to the contents of the polymorphic
|
|
# shell variable SOURCE.
|
|
m4_define([AS_VAR_COPY],
|
|
[AS_LITERAL_IF([$1[]$2], [$1=$$2], [eval $1=\$$2])])
|
|
|
|
|
|
# AS_VAR_GET(VARIABLE)
|
|
# --------------------
|
|
# Get the value of the shell VARIABLE.
|
|
# Evaluates to $VARIABLE if there are no indirection in VARIABLE,
|
|
# else into the appropriate `eval' sequence.
|
|
# This macro is deprecated because it sometimes mishandles trailing newlines;
|
|
# use AS_VAR_COPY instead.
|
|
m4_define([AS_VAR_GET],
|
|
[AS_LITERAL_IF([$1],
|
|
[$$1],
|
|
[`eval 'as_val=${'_AS_ESCAPE([[$1]], [`], [\])'};AS_ECHO(["$as_val"])'`])])
|
|
|
|
|
|
# AS_VAR_IF(VARIABLE, VALUE, IF-TRUE, IF-FALSE)
|
|
# ---------------------------------------------
|
|
# Implement a shell `if test $VARIABLE = VALUE; then-else'.
|
|
# Polymorphic, and avoids sh expansion error upon interrupt or term signal.
|
|
m4_define([AS_VAR_IF],
|
|
[AS_LITERAL_IF([$1],
|
|
[AS_IF([test "x$$1" = x""$2], [$3], [$4])],
|
|
[AS_VAR_COPY([as_val], [$1])
|
|
AS_IF([test "x$as_val" = x""$2], [$3], [$4])])])
|
|
|
|
|
|
# AS_VAR_PUSHDEF and AS_VAR_POPDEF
|
|
# --------------------------------
|
|
#
|
|
|
|
# Sometimes we may have to handle literals (e.g. `stdlib.h'), while at
|
|
# other moments, the same code may have to get the value from a
|
|
# variable (e.g., `ac_header'). To have a uniform handling of both
|
|
# cases, when a new value is about to be processed, declare a local
|
|
# variable, e.g.:
|
|
#
|
|
# AS_VAR_PUSHDEF([header], [ac_cv_header_$1])
|
|
#
|
|
# and then in the body of the macro, use `header' as is. It is of
|
|
# first importance to use `AS_VAR_*' to access this variable.
|
|
#
|
|
# If the value `$1' was a literal (e.g. `stdlib.h'), then `header' is
|
|
# in fact the value `ac_cv_header_stdlib_h'. If `$1' was indirect,
|
|
# then `header's value in m4 is in fact `$as_header', the shell
|
|
# variable that holds all of the magic to get the expansion right.
|
|
#
|
|
# At the end of the block, free the variable with
|
|
#
|
|
# AS_VAR_POPDEF([header])
|
|
|
|
|
|
# AS_VAR_POPDEF(VARNAME)
|
|
# ----------------------
|
|
# Free the shell variable accessor VARNAME. To be dnl'ed.
|
|
m4_define([AS_VAR_POPDEF],
|
|
[m4_popdef([$1])])
|
|
|
|
|
|
# AS_VAR_PUSHDEF(VARNAME, VALUE)
|
|
# ------------------------------
|
|
# Define the m4 macro VARNAME to an accessor to the shell variable
|
|
# named VALUE. VALUE does not need to be a valid shell variable name:
|
|
# the transliteration is handled here. To be dnl'ed.
|
|
#
|
|
# AS_TR_SH attempts to play with diversions if _AS_TR_SH_PREPARE has
|
|
# not been expanded. However, users are expected to do subsequent
|
|
# calls that trigger AS_LITERAL_IF([VARNAME]), and that macro performs
|
|
# expansion inside an argument collection context, where diversions
|
|
# don't work. Therefore, we must require the preparation ourselves.
|
|
m4_defun_init([AS_VAR_PUSHDEF],
|
|
[AS_REQUIRE([_AS_TR_SH_PREPARE])],
|
|
[AS_LITERAL_IF([$2],
|
|
[m4_pushdef([$1], [AS_TR_SH($2)])],
|
|
[as_$1=AS_TR_SH($2)
|
|
m4_pushdef([$1], [$as_[$1]])])])
|
|
|
|
|
|
# AS_VAR_SET(VARIABLE, VALUE)
|
|
# ---------------------------
|
|
# Set the contents of the polymorphic shell VARIABLE to the shell
|
|
# expansion of VALUE. VALUE is immune to field splitting and file
|
|
# name expansion.
|
|
m4_define([AS_VAR_SET],
|
|
[AS_LITERAL_IF([$1],
|
|
[$1=$2],
|
|
[eval "$1=AS_ESCAPE([$2])"])])
|
|
|
|
|
|
# AS_VAR_SET_IF(VARIABLE, IF-TRUE, IF-FALSE)
|
|
# ------------------------------------------
|
|
# Implement a shell `if-then-else' depending whether VARIABLE is set
|
|
# or not. Polymorphic.
|
|
m4_define([AS_VAR_SET_IF],
|
|
[AS_IF([AS_VAR_TEST_SET([$1])], [$2], [$3])])
|
|
|
|
|
|
# AS_VAR_TEST_SET(VARIABLE)
|
|
# -------------------------
|
|
# Expands into the `test' expression which is true if VARIABLE
|
|
# is set. Polymorphic.
|
|
m4_define([AS_VAR_TEST_SET],
|
|
[AS_LITERAL_IF([$1],
|
|
[test "${$1+set}" = set],
|
|
[{ as_var=$1; eval "test \"\${$as_var+set}\" = set"; }])])
|
|
|
|
|
|
## -------------------- ##
|
|
## 8. Setting M4sh up. ##
|
|
## -------------------- ##
|
|
|
|
|
|
# AS_INIT_GENERATED(FILE, [COMMENT])
|
|
# ----------------------------------
|
|
# Generate a child script FILE with all initialization necessary to
|
|
# reuse the environment learned by the parent script, and make the
|
|
# file executable. If COMMENT is supplied, it is inserted after the
|
|
# `#!' sequence but before initialization text begins. After this
|
|
# macro, additional text can be appended to FILE to form the body of
|
|
# the child script. The macro ends with non-zero status if the
|
|
# file could not be fully written (such as if the disk is full).
|
|
m4_defun([AS_INIT_GENERATED],
|
|
[m4_require([AS_PREPARE])]dnl
|
|
[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
|
|
[as_write_fail=0
|
|
cat >$1 <<_ASEOF || as_write_fail=1
|
|
#! $SHELL
|
|
# Generated by $as_me.
|
|
$2
|
|
SHELL=\${CONFIG_SHELL-$SHELL}
|
|
export SHELL
|
|
_ASEOF
|
|
cat >>$1 <<\_ASEOF || as_write_fail=1
|
|
_AS_SHELL_SANITIZE
|
|
_AS_PREPARE
|
|
m4_if(AS_MESSAGE_FD, [1], [], [exec AS_MESSAGE_FD>&1
|
|
])]dnl
|
|
[m4_text_box([Main body of $1 script.])
|
|
_ASEOF
|
|
test $as_write_fail = 0 && chmod +x $1[]dnl
|
|
_m4_popdef([AS_MESSAGE_LOG_FD])])# AS_INIT_GENERATED
|
|
|
|
|
|
# AS_INIT
|
|
# -------
|
|
# Initialize m4sh.
|
|
m4_define([AS_INIT],
|
|
[# Wrap our cleanup prior to m4sugar's cleanup.
|
|
m4_wrap([_AS_CLEANUP])
|
|
m4_init
|
|
m4_provide([AS_INIT])
|
|
|
|
# Forbidden tokens and exceptions.
|
|
m4_pattern_forbid([^_?AS_])
|
|
|
|
# Bangshe and minimal initialization.
|
|
m4_divert_text([BINSH], [@%:@! /bin/sh])
|
|
m4_divert_text([HEADER-COMMENT],
|
|
[@%:@ Generated from __file__ by m4_PACKAGE_STRING.])
|
|
m4_divert_text([M4SH-SANITIZE], [_AS_SHELL_SANITIZE])
|
|
m4_divert_text([M4SH-INIT-FN], [m4_text_box([M4sh Shell Functions.])])
|
|
|
|
# Let's go!
|
|
m4_divert([BODY])dnl
|
|
m4_text_box([Main body of script.])
|
|
_AS_DETECT_REQUIRED([_AS_SHELL_FN_WORK])dnl
|
|
AS_REQUIRE([_AS_UNSET_PREPARE], [], [M4SH-INIT-FN])dnl
|
|
])
|