PROGRAM=libtool

PACKAGE=libtool

VERSION=2.4.6

package_revision=2.4.6

: ${AUTOCONF="autoconf"}

: ${AUTOMAKE="automake"}

scriptversion=2015-01-20.17; # UTC

DUALCASE=1; export DUALCASE # for MKS sh

if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :

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

case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac

_G_user_locale=

_G_safe_locale=

for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

eval "if test set = \"\${$_G_var+set}\"; then

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

sp=' '

nl='

IFS="$sp $nl"

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=';'

}

func_executable_p ()

{

test -f "$1" && test -x "$1"

}

func_path_progs ()

}

test -z "$SED" && {

_G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/

for _G_i in 1 2 3 4 5 6 7; do

_G_sed_script=$_G_sed_script$nl$_G_sed_script

done

echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed

_G_sed_script=

func_check_prog_sed ()

}

func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin

rm -f conftest.sed

SED=$func_path_progs_result

}

test -z "$GREP" && {

func_check_prog_grep ()

}

func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin

GREP=$func_path_progs_result

}

: ${CP="cp -f"}

: ${ECHO="printf %s\n"}

: ${EGREP="$GREP -E"}

: ${FGREP="$GREP -F"}

: ${LN_S="ln -s"}

: ${MAKE="make"}

: ${MKDIR="mkdir"}

: ${MV="mv -f"}

: ${RM="rm -f"}

: ${SHELL="${CONFIG_SHELL-/bin/sh}"}

sed_dirname='s|/[^/]*$||'

sed_basename='s|^.*/||'

sed_quote_subst='s|\([`"$\\]\)|\\\1|g'

sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'

sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'

sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'

_G_bs='\\'

_G_bs2='\\\\'

_G_bs4='\\\\\\\\'

_G_dollar='\$'

sed_double_backslash="\

EXIT_SUCCESS=0

EXIT_FAILURE=1

EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.

EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.

debug_cmd=${debug_cmd-":"}

exit_cmd=:

exit_status=$EXIT_SUCCESS

progpath=$0

progname=`$ECHO "$progpath" |$SED "$sed_basename"`

case $progpath in

[\\/]*|[A-Za-z]:\\*) ;;

*[\\/]*)

progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`

progdir=`cd "$progdir" && pwd`

progpath=$progdir/$progname

;;

*)

_G_IFS=$IFS

IFS=${PATH_SEPARATOR-:}

for progdir in $PATH; do

IFS=$_G_IFS

test -x "$progdir/$progname" && break

done

IFS=$_G_IFS

test -n "$progdir" || progdir=`pwd`

progpath=$progdir/$progname

;;

opt_dry_run=false

opt_quiet=false

opt_verbose=false

warning_categories=

warning_func=func_warn_and_continue

opt_warning_types=all

require_term_colors=func_require_term_colors

func_require_term_colors ()

}

# We should try to minimise forks, especially on Windows where they are

# unreasonably slow, so skip the feature probes when bash or zsh are

# being used:

if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then

: ${_G_HAVE_ARITH_OP="yes"}

: ${_G_HAVE_XSI_OPS="yes"}

# The += operator was introduced in bash 3.1

case $BASH_VERSION in

[12].* | 3.0 | 3.0*) ;;

*)

: ${_G_HAVE_PLUSEQ_OP="yes"}

;;

esac

fi

# _G_HAVE_PLUSEQ_OP

# Can be empty, in which case the shell is probed, "yes" if += is

# useable or anything else if it does not work.

test -z "$_G_HAVE_PLUSEQ_OP" \

&& (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \

&& _G_HAVE_PLUSEQ_OP=yes

if test yes = "$_G_HAVE_PLUSEQ_OP"

# This is an XSI compatible shell, allowing a faster implementation...

eval 'func_append ()

# ...otherwise fall back to using expr, which is often a shell builtin.

func_append ()

}

if test yes = "$_G_HAVE_PLUSEQ_OP"; then

eval 'func_append_quoted ()

func_append_quoted ()

}

func_append_uniq ()

}

test -z "$_G_HAVE_ARITH_OP" \

&& (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \

&& _G_HAVE_ARITH_OP=yes

if test yes = "$_G_HAVE_ARITH_OP"; then

eval 'func_arith ()

func_arith ()

}

if test yes = "$_G_HAVE_XSI_OPS"; then

# If this shell supports suffix pattern removal, then use it to avoid

# forking. Hide the definitions single quotes in case the shell chokes

# on unsupported syntax...

_b='func_basename_result=${1##*/}'

_d='case $1 in

# ...otherwise fall back to using sed.

_b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'

_d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"`

eval 'func_basename ()

eval 'func_dirname ()

eval 'func_dirname_and_basename ()

func_echo ()

}

func_echo_all ()

{

$ECHO "$*"

}

func_echo_infix_1 ()

}

func_error ()

}

func_fatal_error ()

}

func_grep ()

}

test -z "$_G_HAVE_XSI_OPS" \

&& (eval 'x=a/b/c;

test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \

&& _G_HAVE_XSI_OPS=yes

if test yes = "$_G_HAVE_XSI_OPS"; then

eval 'func_len ()

func_len ()

}

func_mkdir_p ()

}

func_mktempdir ()

}

func_normal_abspath ()