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 ()

{

_G_progs_list=$1

_G_check_func=$2

_G_PATH=${3-"$PATH"}

_G_path_prog_max=0

_G_path_prog_found=false

_G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}

for _G_dir in $_G_PATH; do

IFS=$_G_save_IFS

test -z "$_G_dir" && _G_dir=.

for _G_prog_name in $_G_progs_list; do

for _exeext in '' .EXE; do

_G_path_prog=$_G_dir/$_G_prog_name$_exeext

func_executable_p "$_G_path_prog" || continue

case `"$_G_path_prog" --version 2>&1` in

*GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;

*) $_G_check_func $_G_path_prog

func_path_progs_result=$func_check_prog_result

;;

esac

$_G_path_prog_found && break 3

done

done

done

IFS=$_G_save_IFS

test -z "$func_path_progs_result" && {

echo "no acceptable sed could be found in \$PATH" >&2

exit 1

}

}

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 ()

{

_G_path_prog=$1

_G_count=0

printf 0123456789 >conftest.in

while :

do

cat conftest.in conftest.in >conftest.tmp

mv conftest.tmp conftest.in

cp conftest.in conftest.nl

echo '' >> conftest.nl

"$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break

diff conftest.out conftest.nl >/dev/null 2>&1 || break

_G_count=`expr $_G_count + 1`

if test "$_G_count" -gt "$_G_path_prog_max"; then

# Best one so far, save it but keep looking for a better one

func_check_prog_result=$_G_path_prog

_G_path_prog_max=$_G_count

fi

# 10*(2^10) chars as input seems more than enough

test 10 -lt "$_G_count" && break

done

rm -f conftest.in conftest.tmp conftest.nl conftest.out

}

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 ()

{

_G_path_prog=$1

_G_count=0

_G_path_prog_max=0

printf 0123456789 >conftest.in

while :

do

cat conftest.in conftest.in >conftest.tmp

mv conftest.tmp conftest.in

cp conftest.in conftest.nl

echo 'GREP' >> conftest.nl

"$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break

diff conftest.out conftest.nl >/dev/null 2>&1 || break

_G_count=`expr $_G_count + 1`

if test "$_G_count" -gt "$_G_path_prog_max"; then

# Best one so far, save it but keep looking for a better one

func_check_prog_result=$_G_path_prog

_G_path_prog_max=$_G_count

fi

# 10*(2^10) chars as input seems more than enough

test 10 -lt "$_G_count" && break

done

rm -f conftest.in conftest.tmp conftest.nl conftest.out

}

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 ()

{

$debug_cmd

test -t 1 && {

# COLORTERM and USE_ANSI_COLORS environment variables take

# precedence, because most terminfo databases neglect to describe

# whether color sequences are supported.

test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}

if test 1 = "$USE_ANSI_COLORS"; then

# Standard ANSI escape sequences

tc_reset=''

tc_bold=''; tc_standout=''

tc_red=''; tc_green=''

tc_blue=''; tc_cyan=''

else

# Otherwise trust the terminfo database after all.

test -n "`tput sgr0 2>/dev/null`" && {

tc_reset=`tput sgr0`

test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`

tc_standout=$tc_bold

test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`

test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`

test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`

test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`

test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`

}

fi

}

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 ()

{

$debug_cmd

eval "$1=\$$1\$2"

}

if test yes = "$_G_HAVE_PLUSEQ_OP"; then

eval 'func_append_quoted ()

func_append_quoted ()

{

$debug_cmd

func_quote_for_eval "$2"

eval "$1=\$$1\\ \$func_quote_for_eval_result"

}

func_append_uniq ()

{

$debug_cmd

eval _G_current_value='`$ECHO $'$1'`'

_G_delim=`expr "$2" : '\(.\)'`

case $_G_delim$_G_current_value$_G_delim in

*"$2$_G_delim"*) ;;

*) func_append "$@" ;;

esac

}

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 ()

{

$debug_cmd

func_arith_result=`expr "$@"`

}

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 ()

{

$debug_cmd

_G_message=$*

func_echo_IFS=$IFS

IFS=$nl

for _G_line in $_G_message; do

IFS=$func_echo_IFS

$ECHO "$progname: $_G_line"

done

IFS=$func_echo_IFS

}

func_echo_all ()

{

$ECHO "$*"

}

func_echo_infix_1 ()

{

$debug_cmd

$require_term_colors

_G_infix=$1; shift

_G_indent=$_G_infix

_G_prefix="$progname: $_G_infix: "

_G_message=$*

# Strip color escape sequences before counting printable length

for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"

do

test -n "$_G_tc" && {

_G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`

_G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`

}

done

_G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes

func_echo_infix_1_IFS=$IFS

IFS=$nl

for _G_line in $_G_message; do

IFS=$func_echo_infix_1_IFS

$ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2

_G_prefix=$_G_indent

done

IFS=$func_echo_infix_1_IFS

}

func_error ()

{

$debug_cmd

$require_term_colors

func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2

}

func_fatal_error ()

{

$debug_cmd

func_error "$*"

exit $EXIT_FAILURE

}

func_grep ()

{

$debug_cmd

$GREP "$1" "$2" >/dev/null 2>&1

}

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 ()

{

$debug_cmd

func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`

}

func_mkdir_p ()

{

$debug_cmd

_G_directory_path=$1

_G_dir_list=

if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then

# Protect directory names starting with '-'

case $_G_directory_path in

-*) _G_directory_path=./$_G_directory_path ;;

esac

# While some portion of DIR does not yet exist...

while test ! -d "$_G_directory_path"; do

# ...make a list in topmost first order. Use a colon delimited

# list incase some portion of path contains whitespace.

_G_dir_list=$_G_directory_path:$_G_dir_list

# If the last portion added has no slash in it, the list is done

case $_G_directory_path in */*) ;; *) break ;; esac

# ...otherwise throw away the child directory and loop

_G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`

done

_G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`

func_mkdir_p_IFS=$IFS; IFS=:

for _G_dir in $_G_dir_list; do

IFS=$func_mkdir_p_IFS

# mkdir can fail with a 'File exist' error if two processes

# try to create one of the directories concurrently. Don't

# stop in that case!

$MKDIR "$_G_dir" 2>/dev/null || :

done

IFS=$func_mkdir_p_IFS

# Bail out if we (or some other process) failed to create a directory.

test -d "$_G_directory_path" || \

func_fatal_error "Failed to create '$1'"

fi

}

func_mktempdir ()

{

$debug_cmd

_G_template=${TMPDIR-/tmp}/${1-$progname}

if test : = "$opt_dry_run"; then

# Return a directory name, but don't create it in dry-run mode

_G_tmpdir=$_G_template-$$

else

# If mktemp works, use that first and foremost

_G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`

if test ! -d "$_G_tmpdir"; then

# Failing that, at least try and use $RANDOM to avoid a race

_G_tmpdir=$_G_template-${RANDOM-0}$$

func_mktempdir_umask=`umask`

umask 0077

$MKDIR "$_G_tmpdir"

umask $func_mktempdir_umask

fi

# If we're not in dry-run mode, bomb out on failure

test -d "$_G_tmpdir" || \

func_fatal_error "cannot create temporary directory '$_G_tmpdir'"

fi

$ECHO "$_G_tmpdir"

}

func_normal_abspath ()

{

$debug_cmd

# These SED scripts presuppose an absolute path with a trailing slash.

_G_pathcar='s|^/\([^/]*\).*$|\1|'

_G_pathcdr='s|^/[^/]*||'

_G_removedotparts=':dotsl

_G_collapseslashes='s|/\{1,\}|/|g'

_G_finalslash='s|/*$|/|'

# Start from root dir and reassemble the path.

func_normal_abspath_result=

func_normal_abspath_tpath=$1

func_normal_abspath_altnamespace=

case $func_normal_abspath_tpath in

"")

# Empty path, that just means $cwd.

func_stripname '' '/' "`pwd`"

func_normal_abspath_result=$func_stripname_result

return

;;

# The next three entries are used to spot a run of precisely

# two leading slashes without using negated character classes;

# we take advantage of case's first-match behaviour.

///*)

# Unusual form of absolute path, do nothing.

;;

//*)

# Not necessarily an ordinary path; POSIX reserves leading '//'

# and for example Cygwin uses it to access remote file shares

# over CIFS/SMB, so we conserve a leading double slash if found.

func_normal_abspath_altnamespace=/

;;

/*)

# Absolute path, do nothing.

;;

*)

# Relative path, prepend $cwd.

func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath

;;

esac

# Cancel out all the simple stuff to save iterations. We also want

# the path to end with a slash for ease of parsing, so make sure

# there is one (and only one) here.

func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

while :; do

# Processed it all yet?

if test / = "$func_normal_abspath_tpath"; then

# If we ascended to the root using ".." the result may be empty now.

if test -z "$func_normal_abspath_result"; then

func_normal_abspath_result=/

fi

break

fi

func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \

func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \

# Figure out what to do with it

case $func_normal_abspath_tcomponent in

"")

# Trailing empty path component, ignore it.

;;

..)

# Parent dir; strip last assembled component from result.

func_dirname "$func_normal_abspath_result"

func_normal_abspath_result=$func_dirname_result