Prefer HTTPS to FTP and HTTP

[autoconf.git] / lib / m4sugar / m4sh.m4

# This file is part of Autoconf.                          -*- Autoconf -*-
# M4 sugar for common shell constructs.
# Requires GNU M4 and M4sugar.
#
# Copyright (C) 2000-2017 Free Software Foundation, Inc.

# This file is part of Autoconf.  This program is free
# software; you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# Under Section 7 of GPL version 3, you are granted additional
# permissions described in the Autoconf Configure Script Exception,
# version 3.0, as published by the Free Software Foundation.
#
# You should have received a copy of the GNU General Public License
# and a copy of the Autoconf Configure Script Exception along with
# this program; see the files COPYINGv3 and COPYING.EXCEPTION
# respectively.  If not, see <https://www.gnu.org/licenses/>.

# 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
# <https://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
# <https://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 ${ZSH_VERSION+y} && (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
# <https://lists.gnu.org/archive/html/bug-autoconf/2006-06/msg00017.html>
# and on HP-UX 11.11, see the failure of test 120 in
# <https://lists.gnu.org/archive/html/bug-autoconf/2006-10/msg00003.html>
#
# FIXME: The code should test for the OSF bug described in
# <https://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
dnl By default, do not force re-execution of the script just because
dnl the user has pre-set $CONFIG_SHELL; do so only if the m4sh client has
dnl defined the internal variable `_AS_FORCE_REEXEC_WITH_CONFIG_SHELL' to
dnl "yes".
dnl FIXME: This interface is acceptable for the moment, as a private,
dnl FIXME: internal one; but if we want to make the "always re-execute"
dnl FIXME: feature public, we should find a better interface!
[m4_if(_AS_FORCE_REEXEC_WITH_CONFIG_SHELL, [yes],
  [# Use a proper internal environment variable to ensure we don't fall
  # into an infinite loop, continuously re-executing ourselves.
  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
    _as_can_reexec=no; export _as_can_reexec;
    _AS_REEXEC_WITH_SHELL([$CONFIG_SHELL])
  fi
  # We don't want this to propagate to other subprocesses.
  dnl This might be especially important in case an m4sh-generated script
  dnl is used to later execute other m4sh-generated scripts.  This happens
  dnl for example in autoconf's own testsuite (and happens *a lot* there,
  dnl in fact).
  AS_UNSET([_as_can_reexec])
])]dnl
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],
            [export CONFIG_SHELL
             _AS_REEXEC_WITH_SHELL([$CONFIG_SHELL])])

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 ${ZSH_VERSION+y} ; 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
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS
_m4_popdef([AS_EXIT])])# _AS_DETECT_BETTER_SHELL

# _AS_REEXEC_WITH_SHELL(SHELL)
# ----------------------------
# Re-execute the current script with the given shell, trying to preserve
# portable settings (e.g., the `xtrace' and `verbose' shell flag).
m4_defun([_AS_REEXEC_WITH_SHELL], [dnl
# 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.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in @%:@ ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $1 $as_opts "$as_myself" ${1+"$[@]"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
AS_ECHO(["$[]0: could not re-execute with $1"]) >&2
AS_EXIT([255])])# _AS_REEXEC_WITH_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_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.)
as_nl='
'
export as_nl
IFS=" ""        $as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
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 \${$as_var+y} \
  && ( (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_REQUIRED([_AS_TEST_X_WORKS])
_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 uses : and provides a default case, to work around Solaris
# /bin/sh bugs regarding the exit status.
m4_define([_AS_CASE],
[ [@%:@(]
  $1[)] :
    $2 ;;])
m4_define([_AS_CASE_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.
# Then there are shells that don't inherit $? correctly into the start of
# a shell function, so we must always be given an argument.
# 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.])],
[  set +e
  as_fn_set_status $[1]
  exit $[1]])])#_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 :
  $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 when IF-TRUE1 and/or IF-FALSE are empty.
#
m4_define([_AS_IF],
[elif $1
then :
  $2
])
m4_define([_AS_IF_ELSE],
[m4_ifnblank([$1],
[else
  $1
])])

m4_defun([AS_IF],
[if $1
then :
  $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_WORD_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.  Use `xy' because `\c' echoed
# in a command substitution prints only the first character of the output
# with ksh version M-11/16/88f on AIX 6.1; it needs to be reset by another
# backquoted echo.
m4_defun([_AS_ECHO_N_PREPARE],
[ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in @%:@(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T=' ';;
  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], [STATUS 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=$[1]; test $as_status -eq 0 && as_status=1
m4_ifval(AS_MESSAGE_LOG_FD,
[m4_pushdef([AS_MESSAGE_LOG_FD], [$[4]])dnl
  if test "$[4]"; then
    AS_LINENO_PUSH([$[3]])
    _AS_ECHO_LOG([error: $[2]])
  fi
m4_define([AS_MESSAGE_LOG_FD])], [m4_pushdef([AS_MESSAGE_LOG_FD])])dnl
  AS_MESSAGE([error: $[2]], [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[]])])],
[as_fn_error m4_default([$2], [$?]) "_AS_QUOTE([$1])"m4_ifval(AS_MESSAGE_LOG_FD,
  [ "$LINENO" AS_MESSAGE_LOG_FD])])


# 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.
#
# No need to use AS_UNSET, since as_lineno is necessarily set.
m4_defun([AS_LINENO_POP],
[eval $as_lineno_stack; ${as_lineno_stack:+:} 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([AS_ECHO],
[printf "%s\n" $1])


# AS_ECHO_N(WORD)
# ---------------
# Like AS_ECHO(WORD), except do not output the trailing newline.
m4_defun([AS_ECHO_N],
[printf %s $1])


# AS_TEST_X
# ---------
# Check whether a file has executable or search permissions.
# FIXME: This macro is no longer useful; consider deleting it in 2014
# after we ensure m4sh scripts can always find a shell with test -x.
m4_defun_init([AS_TEST_X],
[AS_REQUIRE([_AS_TEST_PREPARE])],
[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])],
[as_fn_executable_p $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])

  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
  # already done that, so ensure we don't try to do so again and fall
  # in an infinite loop.  This has already happened in practice.
  _as_can_reexec=no; export _as_can_reexec
  # 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 -pR' 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 -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
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 ${PATH_SEPARATOR+false} :; 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', with a trailing slash
# already present.  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_if([$1], m4_translit([[$1]], [:;]),
[for as_dir in m4_default([$1], [$PATH])],
[as_dummy="$1"
for as_dir in $as_dummy])
do
  IFS=$as_save_IFS
  case $as_dir in #(((
    '') as_dir=./ ;;
    */) ;;
    *) as_dir=$as_dir/ ;;
  esac
  m4_ifvaln([$3], [as_found=:])dnl
  $2
  m4_ifvaln([$3], [as_found=false])dnl
done
IFS=$as_save_IFS
m4_ifvaln([$3], [$as_found || { $3; }])dnl
])


# 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 @%:@((
.) AS_VAR_SET([$1], [$3]);;
*)
  case $3 in @%:@(((
  .) AS_VAR_SET([$1], [$2]);;
  [[\\/]]* | ?:[[\\/]]* ) AS_VAR_SET([$1], [$3]);;
  *) AS_VAR_SET([$1], [$2/$3]);;
  esac;;
esac[]])# AS_SET_CATFILE


# _AS_TEST_X_WORKS
# ----------------
# These days, we require that `test -x' works.
m4_define([_AS_TEST_X_WORKS], [test -x /])

# _AS_TEST_PREPARE
# ----------------
# Provide back-compat to people that hooked into our undocumented
# internals (here's looking at you, libtool).
m4_defun([_AS_TEST_PREPARE],
[AS_REQUIRE_SHELL_FN([as_fn_executable_p],
  [AS_FUNCTION_DESCRIBE([as_fn_executable_p], [FILE],
    [Test if FILE is an executable regular file.])],
  [  test -f "$[]1" && test -x "$[]1"])]dnl
[as_test_x='test -x'
as_executable_p=as_fn_executable_p
])# _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],
[_$0(m4_expand([$1]), [$2])])

m4_define([_AS_BOX],
[m4_if(m4_index(m4_translit([[$1]], [`\"], [$$$]), [$]),
  [-1], [$0_LITERAL], [$0_INDIR])($@)])


# _AS_BOX_LITERAL(MESSAGE, [FRAME-CHARACTER = `-'])
# -------------------------------------------------
m4_define([_AS_BOX_LITERAL],
[AS_ECHO(["_AS_ESCAPE(m4_dquote(m4_expand([m4_text_box($@)])), [`], [\"$])"])])


# _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_CLEAN_DIR(DIR)
# ------------------
# Remove all contents from within DIR, including any unwritable
# subdirectories, but leave DIR itself untouched.
m4_define([_AS_CLEAN_DIR],
[if test -d $1
then
  find $1 -type d ! -perm -700 -exec chmod u+rwx {} \;
  rm -fr $1/* $1/.[[!.]] $1/.??*
fi])


# 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(_$0(m4_if(m4_index([$1], [@]), [-1],
  [[$1]], [m4_bpatsubst([[$1]], [@&t@])])), [-], [$2], [$3])])

m4_define([_AS_IDENTIFIER_IF],
[m4_cond([[$1]], [], [],
         [m4_eval(m4_len(m4_translit([[$1]], ]]dnl
m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[)) > 0)], [1], [],
         [m4_len(m4_translit(m4_format([[%.1s]], [$1]), ]]dnl
m4_dquote(m4_dquote(m4_defn([m4_cr_symbols1])))[[))], [0], [-])])


# AS_LITERAL_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL,
#               [IF-SIMPLE-REF = IF-NOT-LITERAL])
# -----------------------------------------------------
# If EXPRESSION has no shell indirections ($var or `expr`), expand
# IF-LITERAL, else IF-NOT-LITERAL.  In some cases, IF-NOT-LITERAL
# must be complex to safely deal with ``, while a simpler
# expression IF-SIMPLE-REF can be used if the indirection
# involves only shell variable expansion (as in ${varname}).
#
# EXPRESSION is treated as a literal if it results in the same
# interpretation whether it is unquoted or contained within double
# quotes, with the exception that whitespace is ignored (on the
# assumption that it will be flattened to _).  Therefore, neither `\$'
# nor `a''b' is a literal, since both backslash and single quotes have
# different quoting behavior in the two contexts; and `a*' is not a
# literal, because it has different globbing.  Note, however, that
# while `${a+b}' is neither a literal nor a simple ref, `a+b' is a
# literal.  This macro is an *approximation*: it is possible that
# there are some EXPRESSIONs which the shell would treat as literals,
# but which this macro does not recognize.
#
# 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.  That, and file globbing matters.
#
# 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, commas,
# or unbalanced parentheses.  Valid shell variable characters and
# unambiguous literal characters are deleted (`a.b'), and remaining
# characters are normalized into `$' if they can form simple refs
# (${a}), `+' if they can potentially form literals (a+b), ``' if they
# can interfere with m4 parsing, or left alone otherwise.  If both `$'
# and `+' are left, it is treated as a complex reference (${a+b}),
# even though it could technically be a simple reference (${a}+b).
# _AS_LITERAL_IF_ only has to check for an empty string after removing
# one of the two normalized characters.
#
# Rather than expand m4_defn every time AS_LITERAL_IF is expanded, we
# inline its expansion up front.  _AS_LITERAL_IF expands to the name
# of a macro that takes three arguments: IF-SIMPLE-REF,
# IF-NOT-LITERAL, IF-LITERAL.  It also takes an optional argument of
# any additional characters to allow as literals (useful for AS_TR_SH
# and AS_TR_CPP to perform inline conversion of whitespace to _).  The
# order of the arguments allows reuse of m4_default.
m4_define([AS_LITERAL_IF],
[_$0(m4_expand([$1]), [  ][
])([$4], [$3], [$2])])

m4_define([_AS_LITERAL_IF],
[m4_if(m4_index([$1], [@S|@]), [-1], [$0_(m4_translit([$1],
  [-:=%/@{}[]#(),.$2]]]m4_dquote(m4_dquote(m4_defn([m4_cr_symbols2])))[[,
  [++++++$$`````]))], [$0_NO])])

m4_define([_AS_LITERAL_IF_],
[m4_if(m4_translit([$1], [+]), [], [$0YES],
       m4_translit([$1], [$]), [], [m4_default], [$0NO])])

m4_define([_AS_LITERAL_IF_YES], [$3])
m4_define([_AS_LITERAL_IF_NO], [$2])

# AS_LITERAL_WORD_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL,
#                    [IF-SIMPLE-REF = IF-NOT-LITERAL])
# ----------------------------------------------------------
# Like AS_LITERAL_IF, except that spaces and tabs in EXPRESSION
# are treated as non-literal.
m4_define([AS_LITERAL_WORD_IF],
[_AS_LITERAL_IF(m4_expand([$1]))([$4], [$3], [$2])])

# AS_LITERAL_HEREDOC_IF(EXPRESSION, IF-LITERAL, IF-NOT-LITERAL)
# -------------------------------------------------------------
# Like AS_LITERAL_IF, except that a string is considered literal
# if it results in the same output in both quoted and unquoted
# here-documents.
m4_define([AS_LITERAL_HEREDOC_IF],
[_$0(m4_expand([$1]))([$2], [$3])])

m4_define([_AS_LITERAL_HEREDOC_IF],
[m4_if(m4_index([$1], [@S|@]), [-1],
  [m4_if(m4_index(m4_translit([[$1]], [\`], [$]), [$]), [-1],
    [$0_YES], [$0_NO])],
  [$0_NO])])

m4_define([_AS_LITERAL_HEREDOC_IF_YES], [$1])
m4_define([_AS_LITERAL_HEREDOC_IF_NO], [$2])


# 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).
#
# Even though $tmp does not fit our normal naming scheme of $as_*,
# it is a documented part of the public API and must not be changed.
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 -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])],
[_$0(m4_expand([$1]))])

m4_define([_AS_TR_SH],
[_AS_LITERAL_IF([$1], [*][       ][
])([], [$0_INDIR], [$0_LITERAL])([$1])])

m4_define([_AS_TR_SH_LITERAL],
[m4_translit([[$1]],
  [*+[]]]m4_dquote(m4_defn([m4_cr_not_symbols2]))[,
  [pp[]]]m4_dquote(m4_for(,1,255,,[[_]]))[)])

m4_define([_AS_TR_SH_INDIR],
[`AS_ECHO(["_AS_ESCAPE([[$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])],
[_$0(m4_expand([$1]))])

m4_define([_AS_TR_CPP],
[_AS_LITERAL_IF([$1], [*][       ][
])([], [$0_INDIR], [$0_LITERAL])([$1])])

m4_define([_AS_TR_CPP_LITERAL],
[m4_translit([[$1]],
  [*[]]]m4_dquote(m4_defn([m4_cr_letters])m4_defn([m4_cr_not_symbols2]))[,
  [P[]]]m4_dquote(m4_defn([m4_cr_LETTERS])m4_for(,1,255,,[[_]]))[)])

m4_define([_AS_TR_CPP_INDIR],
[`AS_ECHO(["_AS_ESCAPE([[$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 occurring 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_WORD_IF([$1[]$2], [$1=$$2], [eval $1=\$$2])])


# AS_VAR_GET(VARIABLE)
# --------------------
# Get the value of the shell VARIABLE.
# Evaluates to $VARIABLE if there is no indirection in VARIABLE,
# else to 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_WORD_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_WORD_IF([$1],
  [AS_IF(m4_ifval([$2], [[test "x$$1" = x[]$2]], [[${$1:+false} :]])],
  [AS_VAR_COPY([as_val], [$1])
   AS_IF(m4_ifval([$2], [[test "x$as_val" = x[]$2]], [[${as_val:+false} :]])],
  [AS_IF(m4_ifval([$2],
    [[eval test \"x\$"$1"\" = x"_AS_ESCAPE([$2], [`], [\"$])"]],
    [[eval \${$1:+false} :]])]),
[$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])],
[_$0([$1], m4_expand([$2]))])

m4_define([_AS_VAR_PUSHDEF],
[_AS_LITERAL_IF([$2], [  ][
])([], [as_$1=_AS_TR_SH_INDIR([$2])
m4_pushdef([$1], [$as_[$1]])],
[m4_pushdef([$1], [_AS_TR_SH_LITERAL([$2])])])])


# 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_WORD_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 an expression which is true if VARIABLE
# is set.  Polymorphic.
m4_define([AS_VAR_TEST_SET],
[AS_LITERAL_WORD_IF([$1],
  [test ${$1+y}],
  [{ as_var=$1; eval test \${$as_var+y}; }],
  [eval test \${$1+y}])])


## -------------------- ##
## 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_DETECT_REQUIRED([_AS_TEST_X_WORKS])dnl
AS_REQUIRE([_AS_UNSET_PREPARE], [], [M4SH-INIT-FN])dnl
])