11148 lines
316 KiB
Bash
11148 lines
316 KiB
Bash
#! /bin/sh
|
||
## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
|
||
## by inline-source v2014-01-03.01
|
||
|
||
# libtool (GNU libtool) 2.4.6
|
||
# Provide generalized library-building support services.
|
||
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
|
||
|
||
# Copyright (C) 1996-2015 Free Software Foundation, Inc.
|
||
# This is free software; see the source for copying conditions. There is NO
|
||
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
||
# GNU Libtool is free software; you can redistribute it and/or modify
|
||
# it under the terms of the GNU General Public License as published by
|
||
# the Free Software Foundation; either version 2 of the License, or
|
||
# (at your option) any later version.
|
||
#
|
||
# As a special exception to the GNU General Public License,
|
||
# if you distribute this file as part of a program or library that
|
||
# is built using GNU Libtool, you may include this file under the
|
||
# same distribution terms that you use for the rest of that program.
|
||
#
|
||
# GNU Libtool is distributed in the hope that it will be useful, but
|
||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
# General Public License for more details.
|
||
#
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
|
||
PROGRAM=libtool
|
||
PACKAGE=libtool
|
||
VERSION=2.4.6
|
||
package_revision=2.4.6
|
||
|
||
|
||
## ------ ##
|
||
## Usage. ##
|
||
## ------ ##
|
||
|
||
# Run './libtool --help' for help with using this script from the
|
||
# command line.
|
||
|
||
|
||
## ------------------------------- ##
|
||
## User overridable command paths. ##
|
||
## ------------------------------- ##
|
||
|
||
# After configure completes, it has a better idea of some of the
|
||
# shell tools we need than the defaults used by the functions shared
|
||
# with bootstrap, so set those here where they can still be over-
|
||
# ridden by the user, but otherwise take precedence.
|
||
|
||
: ${AUTOCONF="autoconf"}
|
||
: ${AUTOMAKE="automake"}
|
||
|
||
|
||
## -------------------------- ##
|
||
## Source external libraries. ##
|
||
## -------------------------- ##
|
||
|
||
# Much of our low-level functionality needs to be sourced from external
|
||
# libraries, which are installed to $pkgauxdir.
|
||
|
||
# Set a version string for this script.
|
||
scriptversion=2015-01-20.17; # UTC
|
||
|
||
# General shell script boiler plate, and helper functions.
|
||
# Written by Gary V. Vaughan, 2004
|
||
|
||
# Copyright (C) 2004-2015 Free Software Foundation, Inc.
|
||
# This is free software; see the source for copying conditions. There is NO
|
||
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
||
# 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.
|
||
|
||
# As a special exception to the GNU General Public License, if you distribute
|
||
# this file as part of a program or library that is built using GNU Libtool,
|
||
# you may include this file under the same distribution terms that you use
|
||
# for the rest of that program.
|
||
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
|
||
# General Public License for more details.
|
||
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
# Please report bugs or propose patches to gary@gnu.org.
|
||
|
||
|
||
## ------ ##
|
||
## Usage. ##
|
||
## ------ ##
|
||
|
||
# Evaluate this file near the top of your script to gain access to
|
||
# the functions and variables defined here:
|
||
#
|
||
# . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
|
||
#
|
||
# If you need to override any of the default environment variable
|
||
# settings, do that before evaluating this file.
|
||
|
||
|
||
## -------------------- ##
|
||
## Shell normalisation. ##
|
||
## -------------------- ##
|
||
|
||
# Some shells need a little help to be as Bourne compatible as possible.
|
||
# Before doing anything else, make sure all that help has been provided!
|
||
|
||
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
|
||
else
|
||
case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
|
||
fi
|
||
|
||
# NLS nuisances: We save the old values in case they are required later.
|
||
_G_user_locale=
|
||
_G_safe_locale=
|
||
for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
|
||
do
|
||
eval "if test set = \"\${$_G_var+set}\"; then
|
||
save_$_G_var=\$$_G_var
|
||
$_G_var=C
|
||
export $_G_var
|
||
_G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
|
||
_G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
|
||
fi"
|
||
done
|
||
|
||
# CDPATH.
|
||
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
|
||
|
||
# Make sure IFS has a sensible default
|
||
sp=' '
|
||
nl='
|
||
'
|
||
IFS="$sp $nl"
|
||
|
||
# There are apparently some retarded systems that use ';' as a PATH separator!
|
||
if test "${PATH_SEPARATOR+set}" != set; then
|
||
PATH_SEPARATOR=:
|
||
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
|
||
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
|
||
PATH_SEPARATOR=';'
|
||
}
|
||
fi
|
||
|
||
|
||
|
||
## ------------------------- ##
|
||
## Locate command utilities. ##
|
||
## ------------------------- ##
|
||
|
||
|
||
# func_executable_p FILE
|
||
# ----------------------
|
||
# Check that FILE is an executable regular file.
|
||
func_executable_p ()
|
||
{
|
||
test -f "$1" && test -x "$1"
|
||
}
|
||
|
||
|
||
# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
|
||
# --------------------------------------------
|
||
# Search for either a program that responds to --version with output
|
||
# containing "GNU", or else returned by CHECK_FUNC otherwise, by
|
||
# trying all the directories in PATH with each of the elements of
|
||
# PROGS_LIST.
|
||
#
|
||
# CHECK_FUNC should accept the path to a candidate program, and
|
||
# set $func_check_prog_result if it truncates its output less than
|
||
# $_G_path_prog_max characters.
|
||
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
|
||
}
|
||
}
|
||
|
||
|
||
# We want to be able to use the functions in this file before configure
|
||
# has figured out where the best binaries are kept, which means we have
|
||
# to search for them ourselves - except when the results are already set
|
||
# where we skip the searches.
|
||
|
||
# Unless the user overrides by setting SED, search the path for either GNU
|
||
# sed, or the sed that truncates its output the least.
|
||
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
|
||
}
|
||
|
||
|
||
# Unless the user overrides by setting GREP, search the path for either GNU
|
||
# grep, or the grep that truncates its output the least.
|
||
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
|
||
}
|
||
|
||
|
||
## ------------------------------- ##
|
||
## User overridable command paths. ##
|
||
## ------------------------------- ##
|
||
|
||
# All uppercase variable names are used for environment variables. These
|
||
# variables can be overridden by the user before calling a script that
|
||
# uses them if a suitable command of that name is not already available
|
||
# in the command search PATH.
|
||
|
||
: ${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}"}
|
||
|
||
|
||
## -------------------- ##
|
||
## Useful sed snippets. ##
|
||
## -------------------- ##
|
||
|
||
sed_dirname='s|/[^/]*$||'
|
||
sed_basename='s|^.*/||'
|
||
|
||
# Sed substitution that helps us do robust quoting. It backslashifies
|
||
# metacharacters that are still active within double-quoted strings.
|
||
sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
|
||
|
||
# Same as above, but do not quote variable references.
|
||
sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
|
||
|
||
# Sed substitution that turns a string into a regex matching for the
|
||
# string literally.
|
||
sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
|
||
|
||
# Sed substitution that converts a w32 file name or path
|
||
# that contains forward slashes, into one that contains
|
||
# (escaped) backslashes. A very naive implementation.
|
||
sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
|
||
|
||
# Re-'\' parameter expansions in output of sed_double_quote_subst that
|
||
# were '\'-ed in input to the same. If an odd number of '\' preceded a
|
||
# '$' in input to sed_double_quote_subst, that '$' was protected from
|
||
# expansion. Since each input '\' is now two '\'s, look for any number
|
||
# of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'.
|
||
_G_bs='\\'
|
||
_G_bs2='\\\\'
|
||
_G_bs4='\\\\\\\\'
|
||
_G_dollar='\$'
|
||
sed_double_backslash="\
|
||
s/$_G_bs4/&\\
|
||
/g
|
||
s/^$_G_bs2$_G_dollar/$_G_bs&/
|
||
s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
|
||
s/\n//g"
|
||
|
||
|
||
## ----------------- ##
|
||
## Global variables. ##
|
||
## ----------------- ##
|
||
|
||
# Except for the global variables explicitly listed below, the following
|
||
# functions in the '^func_' namespace, and the '^require_' namespace
|
||
# variables initialised in the 'Resource management' section, sourcing
|
||
# this file will not pollute your global namespace with anything
|
||
# else. There's no portable way to scope variables in Bourne shell
|
||
# though, so actually running these functions will sometimes place
|
||
# results into a variable named after the function, and often use
|
||
# temporary variables in the '^_G_' namespace. If you are careful to
|
||
# avoid using those namespaces casually in your sourcing script, things
|
||
# should continue to work as you expect. And, of course, you can freely
|
||
# overwrite any of the functions or variables defined here before
|
||
# calling anything to customize them.
|
||
|
||
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.
|
||
|
||
# Allow overriding, eg assuming that you follow the convention of
|
||
# putting '$debug_cmd' at the start of all your functions, you can get
|
||
# bash to show function call trace with:
|
||
#
|
||
# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
|
||
debug_cmd=${debug_cmd-":"}
|
||
exit_cmd=:
|
||
|
||
# By convention, finish your script with:
|
||
#
|
||
# exit $exit_status
|
||
#
|
||
# so that you can set exit_status to non-zero if you want to indicate
|
||
# something went wrong during execution without actually bailing out at
|
||
# the point of failure.
|
||
exit_status=$EXIT_SUCCESS
|
||
|
||
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
|
||
# is ksh but when the shell is invoked as "sh" and the current value of
|
||
# the _XPG environment variable is not equal to 1 (one), the special
|
||
# positional parameter $0, within a function call, is the name of the
|
||
# function.
|
||
progpath=$0
|
||
|
||
# The name of this program.
|
||
progname=`$ECHO "$progpath" |$SED "$sed_basename"`
|
||
|
||
# Make sure we have an absolute progpath for reexecution:
|
||
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
|
||
;;
|
||
esac
|
||
|
||
|
||
## ----------------- ##
|
||
## Standard options. ##
|
||
## ----------------- ##
|
||
|
||
# The following options affect the operation of the functions defined
|
||
# below, and should be set appropriately depending on run-time para-
|
||
# meters passed on the command line.
|
||
|
||
opt_dry_run=false
|
||
opt_quiet=false
|
||
opt_verbose=false
|
||
|
||
# Categories 'all' and 'none' are always available. Append any others
|
||
# you will pass as the first argument to func_warning from your own
|
||
# code.
|
||
warning_categories=
|
||
|
||
# By default, display warnings according to 'opt_warning_types'. Set
|
||
# 'warning_func' to ':' to elide all warnings, or func_fatal_error to
|
||
# treat the next displayed warning as a fatal error.
|
||
warning_func=func_warn_and_continue
|
||
|
||
# Set to 'all' to display all warnings, 'none' to suppress all
|
||
# warnings, or a space delimited list of some subset of
|
||
# 'warning_categories' to display only the listed warnings.
|
||
opt_warning_types=all
|
||
|
||
|
||
## -------------------- ##
|
||
## Resource management. ##
|
||
## -------------------- ##
|
||
|
||
# This section contains definitions for functions that each ensure a
|
||
# particular resource (a file, or a non-empty configuration variable for
|
||
# example) is available, and if appropriate to extract default values
|
||
# from pertinent package files. Call them using their associated
|
||
# 'require_*' variable to ensure that they are executed, at most, once.
|
||
#
|
||
# It's entirely deliberate that calling these functions can set
|
||
# variables that don't obey the namespace limitations obeyed by the rest
|
||
# of this file, in order that that they be as useful as possible to
|
||
# callers.
|
||
|
||
|
||
# require_term_colors
|
||
# -------------------
|
||
# Allow display of bold text on terminals that support it.
|
||
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='[0m'
|
||
tc_bold='[1m'; tc_standout='[7m'
|
||
tc_red='[31m'; tc_green='[32m'
|
||
tc_blue='[34m'; tc_cyan='[36m'
|
||
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=:
|
||
}
|
||
|
||
|
||
## ----------------- ##
|
||
## Function library. ##
|
||
## ----------------- ##
|
||
|
||
# This section contains a variety of useful functions to call in your
|
||
# scripts. Take note of the portable wrappers for features provided by
|
||
# some modern shells, which will fall back to slower equivalents on
|
||
# less featureful shells.
|
||
|
||
|
||
# func_append VAR VALUE
|
||
# ---------------------
|
||
# Append VALUE onto the existing contents of VAR.
|
||
|
||
# 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"
|
||
then
|
||
# This is an XSI compatible shell, allowing a faster implementation...
|
||
eval 'func_append ()
|
||
{
|
||
$debug_cmd
|
||
|
||
eval "$1+=\$2"
|
||
}'
|
||
else
|
||
# ...otherwise fall back to using expr, which is often a shell builtin.
|
||
func_append ()
|
||
{
|
||
$debug_cmd
|
||
|
||
eval "$1=\$$1\$2"
|
||
}
|
||
fi
|
||
|
||
|
||
# func_append_quoted VAR VALUE
|
||
# ----------------------------
|
||
# Quote VALUE and append to the end of shell variable VAR, separated
|
||
# by a space.
|
||
if test yes = "$_G_HAVE_PLUSEQ_OP"; then
|
||
eval 'func_append_quoted ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_quote_for_eval "$2"
|
||
eval "$1+=\\ \$func_quote_for_eval_result"
|
||
}'
|
||
else
|
||
func_append_quoted ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_quote_for_eval "$2"
|
||
eval "$1=\$$1\\ \$func_quote_for_eval_result"
|
||
}
|
||
fi
|
||
|
||
|
||
# func_append_uniq VAR VALUE
|
||
# --------------------------
|
||
# Append unique VALUE onto the existing contents of VAR, assuming
|
||
# entries are delimited by the first character of VALUE. For example:
|
||
#
|
||
# func_append_uniq options " --another-option option-argument"
|
||
#
|
||
# will only append to $options if " --another-option option-argument "
|
||
# is not already present somewhere in $options already (note spaces at
|
||
# each end implied by leading space in second argument).
|
||
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
|
||
}
|
||
|
||
|
||
# func_arith TERM...
|
||
# ------------------
|
||
# Set func_arith_result to the result of evaluating TERMs.
|
||
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 ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_arith_result=$(( $* ))
|
||
}'
|
||
else
|
||
func_arith ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_arith_result=`expr "$@"`
|
||
}
|
||
fi
|
||
|
||
|
||
# func_basename FILE
|
||
# ------------------
|
||
# Set func_basename_result to FILE with everything up to and including
|
||
# the last / stripped.
|
||
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
|
||
*/*) func_dirname_result=${1%/*}$2 ;;
|
||
* ) func_dirname_result=$3 ;;
|
||
esac'
|
||
|
||
else
|
||
# ...otherwise fall back to using sed.
|
||
_b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
|
||
_d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"`
|
||
if test "X$func_dirname_result" = "X$1"; then
|
||
func_dirname_result=$3
|
||
else
|
||
func_append func_dirname_result "$2"
|
||
fi'
|
||
fi
|
||
|
||
eval 'func_basename ()
|
||
{
|
||
$debug_cmd
|
||
|
||
'"$_b"'
|
||
}'
|
||
|
||
|
||
# func_dirname FILE APPEND NONDIR_REPLACEMENT
|
||
# -------------------------------------------
|
||
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
|
||
# otherwise set result to NONDIR_REPLACEMENT.
|
||
eval 'func_dirname ()
|
||
{
|
||
$debug_cmd
|
||
|
||
'"$_d"'
|
||
}'
|
||
|
||
|
||
# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
|
||
# --------------------------------------------------------
|
||
# Perform func_basename and func_dirname in a single function
|
||
# call:
|
||
# dirname: Compute the dirname of FILE. If nonempty,
|
||
# add APPEND to the result, otherwise set result
|
||
# to NONDIR_REPLACEMENT.
|
||
# value returned in "$func_dirname_result"
|
||
# basename: Compute filename of FILE.
|
||
# value retuned in "$func_basename_result"
|
||
# For efficiency, we do not delegate to the functions above but instead
|
||
# duplicate the functionality here.
|
||
eval 'func_dirname_and_basename ()
|
||
{
|
||
$debug_cmd
|
||
|
||
'"$_b"'
|
||
'"$_d"'
|
||
}'
|
||
|
||
|
||
# func_echo ARG...
|
||
# ----------------
|
||
# Echo program name prefixed message.
|
||
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 ARG...
|
||
# --------------------
|
||
# Invoke $ECHO with all args, space-separated.
|
||
func_echo_all ()
|
||
{
|
||
$ECHO "$*"
|
||
}
|
||
|
||
|
||
# func_echo_infix_1 INFIX ARG...
|
||
# ------------------------------
|
||
# Echo program name, followed by INFIX on the first line, with any
|
||
# additional lines not showing INFIX.
|
||
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 ARG...
|
||
# -----------------
|
||
# Echo program name prefixed message to standard error.
|
||
func_error ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$require_term_colors
|
||
|
||
func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2
|
||
}
|
||
|
||
|
||
# func_fatal_error ARG...
|
||
# -----------------------
|
||
# Echo program name prefixed message to standard error, and exit.
|
||
func_fatal_error ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_error "$*"
|
||
exit $EXIT_FAILURE
|
||
}
|
||
|
||
|
||
# func_grep EXPRESSION FILENAME
|
||
# -----------------------------
|
||
# Check whether EXPRESSION matches any line of FILENAME, without output.
|
||
func_grep ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$GREP "$1" "$2" >/dev/null 2>&1
|
||
}
|
||
|
||
|
||
# func_len STRING
|
||
# ---------------
|
||
# Set func_len_result to the length of STRING. STRING may not
|
||
# start with a hyphen.
|
||
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 ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_len_result=${#1}
|
||
}'
|
||
else
|
||
func_len ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
|
||
}
|
||
fi
|
||
|
||
|
||
# func_mkdir_p DIRECTORY-PATH
|
||
# ---------------------------
|
||
# Make sure the entire path to DIRECTORY-PATH is available.
|
||
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 [BASENAME]
|
||
# -------------------------
|
||
# Make a temporary directory that won't clash with other running
|
||
# libtool processes, and avoids race conditions if possible. If
|
||
# given, BASENAME is the basename for that directory.
|
||
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 PATH
|
||
# ------------------------
|
||
# Remove doubled-up and trailing slashes, "." path components,
|
||
# and cancel out any ".." path components in PATH after making
|
||
# it an absolute path.
|
||
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
|
||
s|/\./|/|g
|
||
t dotsl
|
||
s|/\.$|/|'
|
||
_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 \
|
||
-e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
|
||
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 \
|
||
-e "$_G_pathcar"`
|
||
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
|
||
-e "$_G_pathcdr"`
|
||
# 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
|
||
;;
|
||
*)
|
||
# Actual path component, append it.
|
||
func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
|
||
;;
|
||
esac
|
||
done
|
||
# Restore leading double-slash if one was found on entry.
|
||
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
|
||
}
|
||
|
||
|
||
# func_notquiet ARG...
|
||
# --------------------
|
||
# Echo program name prefixed message only when not in quiet mode.
|
||
func_notquiet ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$opt_quiet || func_echo ${1+"$@"}
|
||
|
||
# A bug in bash halts the script if the last line of a function
|
||
# fails when set -e is in force, so we need another command to
|
||
# work around that:
|
||
:
|
||
}
|
||
|
||
|
||
# func_relative_path SRCDIR DSTDIR
|
||
# --------------------------------
|
||
# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
|
||
func_relative_path ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_relative_path_result=
|
||
func_normal_abspath "$1"
|
||
func_relative_path_tlibdir=$func_normal_abspath_result
|
||
func_normal_abspath "$2"
|
||
func_relative_path_tbindir=$func_normal_abspath_result
|
||
|
||
# Ascend the tree starting from libdir
|
||
while :; do
|
||
# check if we have found a prefix of bindir
|
||
case $func_relative_path_tbindir in
|
||
$func_relative_path_tlibdir)
|
||
# found an exact match
|
||
func_relative_path_tcancelled=
|
||
break
|
||
;;
|
||
$func_relative_path_tlibdir*)
|
||
# found a matching prefix
|
||
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
|
||
func_relative_path_tcancelled=$func_stripname_result
|
||
if test -z "$func_relative_path_result"; then
|
||
func_relative_path_result=.
|
||
fi
|
||
break
|
||
;;
|
||
*)
|
||
func_dirname $func_relative_path_tlibdir
|
||
func_relative_path_tlibdir=$func_dirname_result
|
||
if test -z "$func_relative_path_tlibdir"; then
|
||
# Have to descend all the way to the root!
|
||
func_relative_path_result=../$func_relative_path_result
|
||
func_relative_path_tcancelled=$func_relative_path_tbindir
|
||
break
|
||
fi
|
||
func_relative_path_result=../$func_relative_path_result
|
||
;;
|
||
esac
|
||
done
|
||
|
||
# Now calculate path; take care to avoid doubling-up slashes.
|
||
func_stripname '' '/' "$func_relative_path_result"
|
||
func_relative_path_result=$func_stripname_result
|
||
func_stripname '/' '/' "$func_relative_path_tcancelled"
|
||
if test -n "$func_stripname_result"; then
|
||
func_append func_relative_path_result "/$func_stripname_result"
|
||
fi
|
||
|
||
# Normalisation. If bindir is libdir, return '.' else relative path.
|
||
if test -n "$func_relative_path_result"; then
|
||
func_stripname './' '' "$func_relative_path_result"
|
||
func_relative_path_result=$func_stripname_result
|
||
fi
|
||
|
||
test -n "$func_relative_path_result" || func_relative_path_result=.
|
||
|
||
:
|
||
}
|
||
|
||
|
||
# func_quote_for_eval ARG...
|
||
# --------------------------
|
||
# Aesthetically quote ARGs to be evaled later.
|
||
# This function returns two values:
|
||
# i) func_quote_for_eval_result
|
||
# double-quoted, suitable for a subsequent eval
|
||
# ii) func_quote_for_eval_unquoted_result
|
||
# has all characters that are still active within double
|
||
# quotes backslashified.
|
||
func_quote_for_eval ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_quote_for_eval_unquoted_result=
|
||
func_quote_for_eval_result=
|
||
while test 0 -lt $#; do
|
||
case $1 in
|
||
*[\\\`\"\$]*)
|
||
_G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
|
||
*)
|
||
_G_unquoted_arg=$1 ;;
|
||
esac
|
||
if test -n "$func_quote_for_eval_unquoted_result"; then
|
||
func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
|
||
else
|
||
func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
|
||
fi
|
||
|
||
case $_G_unquoted_arg in
|
||
# Double-quote args containing shell metacharacters to delay
|
||
# word splitting, command substitution and variable expansion
|
||
# for a subsequent eval.
|
||
# Many Bourne shells cannot handle close brackets correctly
|
||
# in scan sets, so we specify it separately.
|
||
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
|
||
_G_quoted_arg=\"$_G_unquoted_arg\"
|
||
;;
|
||
*)
|
||
_G_quoted_arg=$_G_unquoted_arg
|
||
;;
|
||
esac
|
||
|
||
if test -n "$func_quote_for_eval_result"; then
|
||
func_append func_quote_for_eval_result " $_G_quoted_arg"
|
||
else
|
||
func_append func_quote_for_eval_result "$_G_quoted_arg"
|
||
fi
|
||
shift
|
||
done
|
||
}
|
||
|
||
|
||
# func_quote_for_expand ARG
|
||
# -------------------------
|
||
# Aesthetically quote ARG to be evaled later; same as above,
|
||
# but do not quote variable references.
|
||
func_quote_for_expand ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case $1 in
|
||
*[\\\`\"]*)
|
||
_G_arg=`$ECHO "$1" | $SED \
|
||
-e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
|
||
*)
|
||
_G_arg=$1 ;;
|
||
esac
|
||
|
||
case $_G_arg in
|
||
# Double-quote args containing shell metacharacters to delay
|
||
# word splitting and command substitution for a subsequent eval.
|
||
# Many Bourne shells cannot handle close brackets correctly
|
||
# in scan sets, so we specify it separately.
|
||
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
|
||
_G_arg=\"$_G_arg\"
|
||
;;
|
||
esac
|
||
|
||
func_quote_for_expand_result=$_G_arg
|
||
}
|
||
|
||
|
||
# func_stripname PREFIX SUFFIX NAME
|
||
# ---------------------------------
|
||
# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
|
||
# PREFIX and SUFFIX must not contain globbing or regex special
|
||
# characters, hashes, percent signs, but SUFFIX may contain a leading
|
||
# dot (in which case that matches only a dot).
|
||
if test yes = "$_G_HAVE_XSI_OPS"; then
|
||
eval 'func_stripname ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
|
||
# positional parameters, so assign one to ordinary variable first.
|
||
func_stripname_result=$3
|
||
func_stripname_result=${func_stripname_result#"$1"}
|
||
func_stripname_result=${func_stripname_result%"$2"}
|
||
}'
|
||
else
|
||
func_stripname ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case $2 in
|
||
.*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
|
||
*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
|
||
esac
|
||
}
|
||
fi
|
||
|
||
|
||
# func_show_eval CMD [FAIL_EXP]
|
||
# -----------------------------
|
||
# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
|
||
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
|
||
# is given, then evaluate it.
|
||
func_show_eval ()
|
||
{
|
||
$debug_cmd
|
||
|
||
_G_cmd=$1
|
||
_G_fail_exp=${2-':'}
|
||
|
||
func_quote_for_expand "$_G_cmd"
|
||
eval "func_notquiet $func_quote_for_expand_result"
|
||
|
||
$opt_dry_run || {
|
||
eval "$_G_cmd"
|
||
_G_status=$?
|
||
if test 0 -ne "$_G_status"; then
|
||
eval "(exit $_G_status); $_G_fail_exp"
|
||
fi
|
||
}
|
||
}
|
||
|
||
|
||
# func_show_eval_locale CMD [FAIL_EXP]
|
||
# ------------------------------------
|
||
# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
|
||
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
|
||
# is given, then evaluate it. Use the saved locale for evaluation.
|
||
func_show_eval_locale ()
|
||
{
|
||
$debug_cmd
|
||
|
||
_G_cmd=$1
|
||
_G_fail_exp=${2-':'}
|
||
|
||
$opt_quiet || {
|
||
func_quote_for_expand "$_G_cmd"
|
||
eval "func_echo $func_quote_for_expand_result"
|
||
}
|
||
|
||
$opt_dry_run || {
|
||
eval "$_G_user_locale
|
||
$_G_cmd"
|
||
_G_status=$?
|
||
eval "$_G_safe_locale"
|
||
if test 0 -ne "$_G_status"; then
|
||
eval "(exit $_G_status); $_G_fail_exp"
|
||
fi
|
||
}
|
||
}
|
||
|
||
|
||
# func_tr_sh
|
||
# ----------
|
||
# Turn $1 into a string suitable for a shell variable name.
|
||
# Result is stored in $func_tr_sh_result. All characters
|
||
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
|
||
# if $1 begins with a digit, a '_' is prepended as well.
|
||
func_tr_sh ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case $1 in
|
||
[0-9]* | *[!a-zA-Z0-9_]*)
|
||
func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
|
||
;;
|
||
* )
|
||
func_tr_sh_result=$1
|
||
;;
|
||
esac
|
||
}
|
||
|
||
|
||
# func_verbose ARG...
|
||
# -------------------
|
||
# Echo program name prefixed message in verbose mode only.
|
||
func_verbose ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$opt_verbose && func_echo "$*"
|
||
|
||
:
|
||
}
|
||
|
||
|
||
# func_warn_and_continue ARG...
|
||
# -----------------------------
|
||
# Echo program name prefixed warning message to standard error.
|
||
func_warn_and_continue ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$require_term_colors
|
||
|
||
func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
|
||
}
|
||
|
||
|
||
# func_warning CATEGORY ARG...
|
||
# ----------------------------
|
||
# Echo program name prefixed warning message to standard error. Warning
|
||
# messages can be filtered according to CATEGORY, where this function
|
||
# elides messages where CATEGORY is not listed in the global variable
|
||
# 'opt_warning_types'.
|
||
func_warning ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# CATEGORY must be in the warning_categories list!
|
||
case " $warning_categories " in
|
||
*" $1 "*) ;;
|
||
*) func_internal_error "invalid warning category '$1'" ;;
|
||
esac
|
||
|
||
_G_category=$1
|
||
shift
|
||
|
||
case " $opt_warning_types " in
|
||
*" $_G_category "*) $warning_func ${1+"$@"} ;;
|
||
esac
|
||
}
|
||
|
||
|
||
# func_sort_ver VER1 VER2
|
||
# -----------------------
|
||
# 'sort -V' is not generally available.
|
||
# Note this deviates from the version comparison in automake
|
||
# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
|
||
# but this should suffice as we won't be specifying old
|
||
# version formats or redundant trailing .0 in bootstrap.conf.
|
||
# If we did want full compatibility then we should probably
|
||
# use m4_version_compare from autoconf.
|
||
func_sort_ver ()
|
||
{
|
||
$debug_cmd
|
||
|
||
printf '%s\n%s\n' "$1" "$2" \
|
||
| sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
|
||
}
|
||
|
||
# func_lt_ver PREV CURR
|
||
# ---------------------
|
||
# Return true if PREV and CURR are in the correct order according to
|
||
# func_sort_ver, otherwise false. Use it like this:
|
||
#
|
||
# func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
|
||
func_lt_ver ()
|
||
{
|
||
$debug_cmd
|
||
|
||
test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
|
||
}
|
||
|
||
|
||
# Local variables:
|
||
# mode: shell-script
|
||
# sh-indentation: 2
|
||
# eval: (add-hook 'before-save-hook 'time-stamp)
|
||
# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
|
||
# time-stamp-time-zone: "UTC"
|
||
# End:
|
||
#! /bin/sh
|
||
|
||
# Set a version string for this script.
|
||
scriptversion=2014-01-07.03; # UTC
|
||
|
||
# A portable, pluggable option parser for Bourne shell.
|
||
# Written by Gary V. Vaughan, 2010
|
||
|
||
# Copyright (C) 2010-2015 Free Software Foundation, Inc.
|
||
# This is free software; see the source for copying conditions. There is NO
|
||
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
||
# 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.
|
||
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
# Please report bugs or propose patches to gary@gnu.org.
|
||
|
||
|
||
## ------ ##
|
||
## Usage. ##
|
||
## ------ ##
|
||
|
||
# This file is a library for parsing options in your shell scripts along
|
||
# with assorted other useful supporting features that you can make use
|
||
# of too.
|
||
#
|
||
# For the simplest scripts you might need only:
|
||
#
|
||
# #!/bin/sh
|
||
# . relative/path/to/funclib.sh
|
||
# . relative/path/to/options-parser
|
||
# scriptversion=1.0
|
||
# func_options ${1+"$@"}
|
||
# eval set dummy "$func_options_result"; shift
|
||
# ...rest of your script...
|
||
#
|
||
# In order for the '--version' option to work, you will need to have a
|
||
# suitably formatted comment like the one at the top of this file
|
||
# starting with '# Written by ' and ending with '# warranty; '.
|
||
#
|
||
# For '-h' and '--help' to work, you will also need a one line
|
||
# description of your script's purpose in a comment directly above the
|
||
# '# Written by ' line, like the one at the top of this file.
|
||
#
|
||
# The default options also support '--debug', which will turn on shell
|
||
# execution tracing (see the comment above debug_cmd below for another
|
||
# use), and '--verbose' and the func_verbose function to allow your script
|
||
# to display verbose messages only when your user has specified
|
||
# '--verbose'.
|
||
#
|
||
# After sourcing this file, you can plug processing for additional
|
||
# options by amending the variables from the 'Configuration' section
|
||
# below, and following the instructions in the 'Option parsing'
|
||
# section further down.
|
||
|
||
## -------------- ##
|
||
## Configuration. ##
|
||
## -------------- ##
|
||
|
||
# You should override these variables in your script after sourcing this
|
||
# file so that they reflect the customisations you have added to the
|
||
# option parser.
|
||
|
||
# The usage line for option parsing errors and the start of '-h' and
|
||
# '--help' output messages. You can embed shell variables for delayed
|
||
# expansion at the time the message is displayed, but you will need to
|
||
# quote other shell meta-characters carefully to prevent them being
|
||
# expanded when the contents are evaled.
|
||
usage='$progpath [OPTION]...'
|
||
|
||
# Short help message in response to '-h' and '--help'. Add to this or
|
||
# override it after sourcing this library to reflect the full set of
|
||
# options your script accepts.
|
||
usage_message="\
|
||
--debug enable verbose shell tracing
|
||
-W, --warnings=CATEGORY
|
||
report the warnings falling in CATEGORY [all]
|
||
-v, --verbose verbosely report processing
|
||
--version print version information and exit
|
||
-h, --help print short or long help message and exit
|
||
"
|
||
|
||
# Additional text appended to 'usage_message' in response to '--help'.
|
||
long_help_message="
|
||
Warning categories include:
|
||
'all' show all warnings
|
||
'none' turn off all the warnings
|
||
'error' warnings are treated as fatal errors"
|
||
|
||
# Help message printed before fatal option parsing errors.
|
||
fatal_help="Try '\$progname --help' for more information."
|
||
|
||
|
||
|
||
## ------------------------- ##
|
||
## Hook function management. ##
|
||
## ------------------------- ##
|
||
|
||
# This section contains functions for adding, removing, and running hooks
|
||
# to the main code. A hook is just a named list of of function, that can
|
||
# be run in order later on.
|
||
|
||
# func_hookable FUNC_NAME
|
||
# -----------------------
|
||
# Declare that FUNC_NAME will run hooks added with
|
||
# 'func_add_hook FUNC_NAME ...'.
|
||
func_hookable ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_append hookable_fns " $1"
|
||
}
|
||
|
||
|
||
# func_add_hook FUNC_NAME HOOK_FUNC
|
||
# ---------------------------------
|
||
# Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must
|
||
# first have been declared "hookable" by a call to 'func_hookable'.
|
||
func_add_hook ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case " $hookable_fns " in
|
||
*" $1 "*) ;;
|
||
*) func_fatal_error "'$1' does not accept hook functions." ;;
|
||
esac
|
||
|
||
eval func_append ${1}_hooks '" $2"'
|
||
}
|
||
|
||
|
||
# func_remove_hook FUNC_NAME HOOK_FUNC
|
||
# ------------------------------------
|
||
# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
|
||
func_remove_hook ()
|
||
{
|
||
$debug_cmd
|
||
|
||
eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
|
||
}
|
||
|
||
|
||
# func_run_hooks FUNC_NAME [ARG]...
|
||
# ---------------------------------
|
||
# Run all hook functions registered to FUNC_NAME.
|
||
# It is assumed that the list of hook functions contains nothing more
|
||
# than a whitespace-delimited list of legal shell function names, and
|
||
# no effort is wasted trying to catch shell meta-characters or preserve
|
||
# whitespace.
|
||
func_run_hooks ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case " $hookable_fns " in
|
||
*" $1 "*) ;;
|
||
*) func_fatal_error "'$1' does not support hook funcions.n" ;;
|
||
esac
|
||
|
||
eval _G_hook_fns=\$$1_hooks; shift
|
||
|
||
for _G_hook in $_G_hook_fns; do
|
||
eval $_G_hook '"$@"'
|
||
|
||
# store returned options list back into positional
|
||
# parameters for next 'cmd' execution.
|
||
eval _G_hook_result=\$${_G_hook}_result
|
||
eval set dummy "$_G_hook_result"; shift
|
||
done
|
||
|
||
func_quote_for_eval ${1+"$@"}
|
||
func_run_hooks_result=$func_quote_for_eval_result
|
||
}
|
||
|
||
|
||
|
||
## --------------- ##
|
||
## Option parsing. ##
|
||
## --------------- ##
|
||
|
||
# In order to add your own option parsing hooks, you must accept the
|
||
# full positional parameter list in your hook function, remove any
|
||
# options that you action, and then pass back the remaining unprocessed
|
||
# options in '<hooked_function_name>_result', escaped suitably for
|
||
# 'eval'. Like this:
|
||
#
|
||
# my_options_prep ()
|
||
# {
|
||
# $debug_cmd
|
||
#
|
||
# # Extend the existing usage message.
|
||
# usage_message=$usage_message'
|
||
# -s, --silent don'\''t print informational messages
|
||
# '
|
||
#
|
||
# func_quote_for_eval ${1+"$@"}
|
||
# my_options_prep_result=$func_quote_for_eval_result
|
||
# }
|
||
# func_add_hook func_options_prep my_options_prep
|
||
#
|
||
#
|
||
# my_silent_option ()
|
||
# {
|
||
# $debug_cmd
|
||
#
|
||
# # Note that for efficiency, we parse as many options as we can
|
||
# # recognise in a loop before passing the remainder back to the
|
||
# # caller on the first unrecognised argument we encounter.
|
||
# while test $# -gt 0; do
|
||
# opt=$1; shift
|
||
# case $opt in
|
||
# --silent|-s) opt_silent=: ;;
|
||
# # Separate non-argument short options:
|
||
# -s*) func_split_short_opt "$_G_opt"
|
||
# set dummy "$func_split_short_opt_name" \
|
||
# "-$func_split_short_opt_arg" ${1+"$@"}
|
||
# shift
|
||
# ;;
|
||
# *) set dummy "$_G_opt" "$*"; shift; break ;;
|
||
# esac
|
||
# done
|
||
#
|
||
# func_quote_for_eval ${1+"$@"}
|
||
# my_silent_option_result=$func_quote_for_eval_result
|
||
# }
|
||
# func_add_hook func_parse_options my_silent_option
|
||
#
|
||
#
|
||
# my_option_validation ()
|
||
# {
|
||
# $debug_cmd
|
||
#
|
||
# $opt_silent && $opt_verbose && func_fatal_help "\
|
||
# '--silent' and '--verbose' options are mutually exclusive."
|
||
#
|
||
# func_quote_for_eval ${1+"$@"}
|
||
# my_option_validation_result=$func_quote_for_eval_result
|
||
# }
|
||
# func_add_hook func_validate_options my_option_validation
|
||
#
|
||
# You'll alse need to manually amend $usage_message to reflect the extra
|
||
# options you parse. It's preferable to append if you can, so that
|
||
# multiple option parsing hooks can be added safely.
|
||
|
||
|
||
# func_options [ARG]...
|
||
# ---------------------
|
||
# All the functions called inside func_options are hookable. See the
|
||
# individual implementations for details.
|
||
func_hookable func_options
|
||
func_options ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_options_prep ${1+"$@"}
|
||
eval func_parse_options \
|
||
${func_options_prep_result+"$func_options_prep_result"}
|
||
eval func_validate_options \
|
||
${func_parse_options_result+"$func_parse_options_result"}
|
||
|
||
eval func_run_hooks func_options \
|
||
${func_validate_options_result+"$func_validate_options_result"}
|
||
|
||
# save modified positional parameters for caller
|
||
func_options_result=$func_run_hooks_result
|
||
}
|
||
|
||
|
||
# func_options_prep [ARG]...
|
||
# --------------------------
|
||
# All initialisations required before starting the option parse loop.
|
||
# Note that when calling hook functions, we pass through the list of
|
||
# positional parameters. If a hook function modifies that list, and
|
||
# needs to propogate that back to rest of this script, then the complete
|
||
# modified list must be put in 'func_run_hooks_result' before
|
||
# returning.
|
||
func_hookable func_options_prep
|
||
func_options_prep ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# Option defaults:
|
||
opt_verbose=false
|
||
opt_warning_types=
|
||
|
||
func_run_hooks func_options_prep ${1+"$@"}
|
||
|
||
# save modified positional parameters for caller
|
||
func_options_prep_result=$func_run_hooks_result
|
||
}
|
||
|
||
|
||
# func_parse_options [ARG]...
|
||
# ---------------------------
|
||
# The main option parsing loop.
|
||
func_hookable func_parse_options
|
||
func_parse_options ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_parse_options_result=
|
||
|
||
# this just eases exit handling
|
||
while test $# -gt 0; do
|
||
# Defer to hook functions for initial option parsing, so they
|
||
# get priority in the event of reusing an option name.
|
||
func_run_hooks func_parse_options ${1+"$@"}
|
||
|
||
# Adjust func_parse_options positional parameters to match
|
||
eval set dummy "$func_run_hooks_result"; shift
|
||
|
||
# Break out of the loop if we already parsed every option.
|
||
test $# -gt 0 || break
|
||
|
||
_G_opt=$1
|
||
shift
|
||
case $_G_opt in
|
||
--debug|-x) debug_cmd='set -x'
|
||
func_echo "enabling shell trace mode"
|
||
$debug_cmd
|
||
;;
|
||
|
||
--no-warnings|--no-warning|--no-warn)
|
||
set dummy --warnings none ${1+"$@"}
|
||
shift
|
||
;;
|
||
|
||
--warnings|--warning|-W)
|
||
test $# = 0 && func_missing_arg $_G_opt && break
|
||
case " $warning_categories $1" in
|
||
*" $1 "*)
|
||
# trailing space prevents matching last $1 above
|
||
func_append_uniq opt_warning_types " $1"
|
||
;;
|
||
*all)
|
||
opt_warning_types=$warning_categories
|
||
;;
|
||
*none)
|
||
opt_warning_types=none
|
||
warning_func=:
|
||
;;
|
||
*error)
|
||
opt_warning_types=$warning_categories
|
||
warning_func=func_fatal_error
|
||
;;
|
||
*)
|
||
func_fatal_error \
|
||
"unsupported warning category: '$1'"
|
||
;;
|
||
esac
|
||
shift
|
||
;;
|
||
|
||
--verbose|-v) opt_verbose=: ;;
|
||
--version) func_version ;;
|
||
-\?|-h) func_usage ;;
|
||
--help) func_help ;;
|
||
|
||
# Separate optargs to long options (plugins may need this):
|
||
--*=*) func_split_equals "$_G_opt"
|
||
set dummy "$func_split_equals_lhs" \
|
||
"$func_split_equals_rhs" ${1+"$@"}
|
||
shift
|
||
;;
|
||
|
||
# Separate optargs to short options:
|
||
-W*)
|
||
func_split_short_opt "$_G_opt"
|
||
set dummy "$func_split_short_opt_name" \
|
||
"$func_split_short_opt_arg" ${1+"$@"}
|
||
shift
|
||
;;
|
||
|
||
# Separate non-argument short options:
|
||
-\?*|-h*|-v*|-x*)
|
||
func_split_short_opt "$_G_opt"
|
||
set dummy "$func_split_short_opt_name" \
|
||
"-$func_split_short_opt_arg" ${1+"$@"}
|
||
shift
|
||
;;
|
||
|
||
--) break ;;
|
||
-*) func_fatal_help "unrecognised option: '$_G_opt'" ;;
|
||
*) set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
|
||
esac
|
||
done
|
||
|
||
# save modified positional parameters for caller
|
||
func_quote_for_eval ${1+"$@"}
|
||
func_parse_options_result=$func_quote_for_eval_result
|
||
}
|
||
|
||
|
||
# func_validate_options [ARG]...
|
||
# ------------------------------
|
||
# Perform any sanity checks on option settings and/or unconsumed
|
||
# arguments.
|
||
func_hookable func_validate_options
|
||
func_validate_options ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# Display all warnings if -W was not given.
|
||
test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
|
||
|
||
func_run_hooks func_validate_options ${1+"$@"}
|
||
|
||
# Bail if the options were screwed!
|
||
$exit_cmd $EXIT_FAILURE
|
||
|
||
# save modified positional parameters for caller
|
||
func_validate_options_result=$func_run_hooks_result
|
||
}
|
||
|
||
|
||
|
||
## ----------------- ##
|
||
## Helper functions. ##
|
||
## ----------------- ##
|
||
|
||
# This section contains the helper functions used by the rest of the
|
||
# hookable option parser framework in ascii-betical order.
|
||
|
||
|
||
# func_fatal_help ARG...
|
||
# ----------------------
|
||
# Echo program name prefixed message to standard error, followed by
|
||
# a help hint, and exit.
|
||
func_fatal_help ()
|
||
{
|
||
$debug_cmd
|
||
|
||
eval \$ECHO \""Usage: $usage"\"
|
||
eval \$ECHO \""$fatal_help"\"
|
||
func_error ${1+"$@"}
|
||
exit $EXIT_FAILURE
|
||
}
|
||
|
||
|
||
# func_help
|
||
# ---------
|
||
# Echo long help message to standard output and exit.
|
||
func_help ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_usage_message
|
||
$ECHO "$long_help_message"
|
||
exit 0
|
||
}
|
||
|
||
|
||
# func_missing_arg ARGNAME
|
||
# ------------------------
|
||
# Echo program name prefixed message to standard error and set global
|
||
# exit_cmd.
|
||
func_missing_arg ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_error "Missing argument for '$1'."
|
||
exit_cmd=exit
|
||
}
|
||
|
||
|
||
# func_split_equals STRING
|
||
# ------------------------
|
||
# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
|
||
# splitting STRING at the '=' sign.
|
||
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
|
||
# This is an XSI compatible shell, allowing a faster implementation...
|
||
eval 'func_split_equals ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_split_equals_lhs=${1%%=*}
|
||
func_split_equals_rhs=${1#*=}
|
||
test "x$func_split_equals_lhs" = "x$1" \
|
||
&& func_split_equals_rhs=
|
||
}'
|
||
else
|
||
# ...otherwise fall back to using expr, which is often a shell builtin.
|
||
func_split_equals ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
|
||
func_split_equals_rhs=
|
||
test "x$func_split_equals_lhs" = "x$1" \
|
||
|| func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
|
||
}
|
||
fi #func_split_equals
|
||
|
||
|
||
# func_split_short_opt SHORTOPT
|
||
# -----------------------------
|
||
# Set func_split_short_opt_name and func_split_short_opt_arg shell
|
||
# variables after splitting SHORTOPT after the 2nd character.
|
||
if test yes = "$_G_HAVE_XSI_OPS"
|
||
then
|
||
# This is an XSI compatible shell, allowing a faster implementation...
|
||
eval 'func_split_short_opt ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_split_short_opt_arg=${1#??}
|
||
func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
|
||
}'
|
||
else
|
||
# ...otherwise fall back to using expr, which is often a shell builtin.
|
||
func_split_short_opt ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
|
||
func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
|
||
}
|
||
fi #func_split_short_opt
|
||
|
||
|
||
# func_usage
|
||
# ----------
|
||
# Echo short help message to standard output and exit.
|
||
func_usage ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_usage_message
|
||
$ECHO "Run '$progname --help |${PAGER-more}' for full usage"
|
||
exit 0
|
||
}
|
||
|
||
|
||
# func_usage_message
|
||
# ------------------
|
||
# Echo short help message to standard output.
|
||
func_usage_message ()
|
||
{
|
||
$debug_cmd
|
||
|
||
eval \$ECHO \""Usage: $usage"\"
|
||
echo
|
||
$SED -n 's|^# ||
|
||
/^Written by/{
|
||
x;p;x
|
||
}
|
||
h
|
||
/^Written by/q' < "$progpath"
|
||
echo
|
||
eval \$ECHO \""$usage_message"\"
|
||
}
|
||
|
||
|
||
# func_version
|
||
# ------------
|
||
# Echo version message to standard output and exit.
|
||
func_version ()
|
||
{
|
||
$debug_cmd
|
||
|
||
printf '%s\n' "$progname $scriptversion"
|
||
$SED -n '
|
||
/(C)/!b go
|
||
:more
|
||
/\./!{
|
||
N
|
||
s|\n# | |
|
||
b more
|
||
}
|
||
:go
|
||
/^# Written by /,/# warranty; / {
|
||
s|^# ||
|
||
s|^# *$||
|
||
s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
|
||
p
|
||
}
|
||
/^# Written by / {
|
||
s|^# ||
|
||
p
|
||
}
|
||
/^warranty; /q' < "$progpath"
|
||
|
||
exit $?
|
||
}
|
||
|
||
|
||
# Local variables:
|
||
# mode: shell-script
|
||
# sh-indentation: 2
|
||
# eval: (add-hook 'before-save-hook 'time-stamp)
|
||
# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
|
||
# time-stamp-time-zone: "UTC"
|
||
# End:
|
||
|
||
# Set a version string.
|
||
scriptversion='(GNU libtool) 2.4.6'
|
||
|
||
|
||
# func_echo ARG...
|
||
# ----------------
|
||
# Libtool also displays the current mode in messages, so override
|
||
# funclib.sh func_echo with this custom definition.
|
||
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${opt_mode+: $opt_mode}: $_G_line"
|
||
done
|
||
IFS=$func_echo_IFS
|
||
}
|
||
|
||
|
||
# func_warning ARG...
|
||
# -------------------
|
||
# Libtool warnings are not categorized, so override funclib.sh
|
||
# func_warning with this simpler definition.
|
||
func_warning ()
|
||
{
|
||
$debug_cmd
|
||
|
||
$warning_func ${1+"$@"}
|
||
}
|
||
|
||
|
||
## ---------------- ##
|
||
## Options parsing. ##
|
||
## ---------------- ##
|
||
|
||
# Hook in the functions to make sure our own options are parsed during
|
||
# the option parsing loop.
|
||
|
||
usage='$progpath [OPTION]... [MODE-ARG]...'
|
||
|
||
# Short help message in response to '-h'.
|
||
usage_message="Options:
|
||
--config show all configuration variables
|
||
--debug enable verbose shell tracing
|
||
-n, --dry-run display commands without modifying any files
|
||
--features display basic configuration information and exit
|
||
--mode=MODE use operation mode MODE
|
||
--no-warnings equivalent to '-Wnone'
|
||
--preserve-dup-deps don't remove duplicate dependency libraries
|
||
--quiet, --silent don't print informational messages
|
||
--tag=TAG use configuration variables from tag TAG
|
||
-v, --verbose print more informational messages than default
|
||
--version print version information
|
||
-W, --warnings=CATEGORY report the warnings falling in CATEGORY [all]
|
||
-h, --help, --help-all print short, long, or detailed help message
|
||
"
|
||
|
||
# Additional text appended to 'usage_message' in response to '--help'.
|
||
func_help ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_usage_message
|
||
$ECHO "$long_help_message
|
||
|
||
MODE must be one of the following:
|
||
|
||
clean remove files from the build directory
|
||
compile compile a source file into a libtool object
|
||
execute automatically set library path, then run a program
|
||
finish complete the installation of libtool libraries
|
||
install install libraries or executables
|
||
link create a library or an executable
|
||
uninstall remove libraries from an installed directory
|
||
|
||
MODE-ARGS vary depending on the MODE. When passed as first option,
|
||
'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
|
||
Try '$progname --help --mode=MODE' for a more detailed description of MODE.
|
||
|
||
When reporting a bug, please describe a test case to reproduce it and
|
||
include the following information:
|
||
|
||
host-triplet: $host
|
||
shell: $SHELL
|
||
compiler: $LTCC
|
||
compiler flags: $LTCFLAGS
|
||
linker: $LD (gnu? $with_gnu_ld)
|
||
version: $progname (GNU libtool) 2.4.6
|
||
automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
|
||
autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q`
|
||
|
||
Report bugs to <bug-libtool@gnu.org>.
|
||
GNU libtool home page: <http://www.gnu.org/software/libtool/>.
|
||
General help using GNU software: <http://www.gnu.org/gethelp/>."
|
||
exit 0
|
||
}
|
||
|
||
|
||
# func_lo2o OBJECT-NAME
|
||
# ---------------------
|
||
# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
|
||
# object suffix.
|
||
|
||
lo2o=s/\\.lo\$/.$objext/
|
||
o2lo=s/\\.$objext\$/.lo/
|
||
|
||
if test yes = "$_G_HAVE_XSI_OPS"; then
|
||
eval 'func_lo2o ()
|
||
{
|
||
case $1 in
|
||
*.lo) func_lo2o_result=${1%.lo}.$objext ;;
|
||
* ) func_lo2o_result=$1 ;;
|
||
esac
|
||
}'
|
||
|
||
# func_xform LIBOBJ-OR-SOURCE
|
||
# ---------------------------
|
||
# Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
|
||
# suffix to a '.lo' libtool-object suffix.
|
||
eval 'func_xform ()
|
||
{
|
||
func_xform_result=${1%.*}.lo
|
||
}'
|
||
else
|
||
# ...otherwise fall back to using sed.
|
||
func_lo2o ()
|
||
{
|
||
func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
|
||
}
|
||
|
||
func_xform ()
|
||
{
|
||
func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
|
||
}
|
||
fi
|
||
|
||
|
||
# func_fatal_configuration ARG...
|
||
# -------------------------------
|
||
# Echo program name prefixed message to standard error, followed by
|
||
# a configuration failure hint, and exit.
|
||
func_fatal_configuration ()
|
||
{
|
||
func__fatal_error ${1+"$@"} \
|
||
"See the $PACKAGE documentation for more information." \
|
||
"Fatal configuration error."
|
||
}
|
||
|
||
|
||
# func_config
|
||
# -----------
|
||
# Display the configuration for all the tags in this script.
|
||
func_config ()
|
||
{
|
||
re_begincf='^# ### BEGIN LIBTOOL'
|
||
re_endcf='^# ### END LIBTOOL'
|
||
|
||
# Default configuration.
|
||
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
|
||
|
||
# Now print the configurations for the tags.
|
||
for tagname in $taglist; do
|
||
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
|
||
done
|
||
|
||
exit $?
|
||
}
|
||
|
||
|
||
# func_features
|
||
# -------------
|
||
# Display the features supported by this script.
|
||
func_features ()
|
||
{
|
||
echo "host: $host"
|
||
if test yes = "$build_libtool_libs"; then
|
||
echo "enable shared libraries"
|
||
else
|
||
echo "disable shared libraries"
|
||
fi
|
||
if test yes = "$build_old_libs"; then
|
||
echo "enable static libraries"
|
||
else
|
||
echo "disable static libraries"
|
||
fi
|
||
|
||
exit $?
|
||
}
|
||
|
||
|
||
# func_enable_tag TAGNAME
|
||
# -----------------------
|
||
# Verify that TAGNAME is valid, and either flag an error and exit, or
|
||
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
|
||
# variable here.
|
||
func_enable_tag ()
|
||
{
|
||
# Global variable:
|
||
tagname=$1
|
||
|
||
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
|
||
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
|
||
sed_extractcf=/$re_begincf/,/$re_endcf/p
|
||
|
||
# Validate tagname.
|
||
case $tagname in
|
||
*[!-_A-Za-z0-9,/]*)
|
||
func_fatal_error "invalid tag name: $tagname"
|
||
;;
|
||
esac
|
||
|
||
# Don't test for the "default" C tag, as we know it's
|
||
# there but not specially marked.
|
||
case $tagname in
|
||
CC) ;;
|
||
*)
|
||
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
|
||
taglist="$taglist $tagname"
|
||
|
||
# Evaluate the configuration. Be careful to quote the path
|
||
# and the sed script, to avoid splitting on whitespace, but
|
||
# also don't use non-portable quotes within backquotes within
|
||
# quotes we have to do it in 2 steps:
|
||
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
|
||
eval "$extractedcf"
|
||
else
|
||
func_error "ignoring unknown tag $tagname"
|
||
fi
|
||
;;
|
||
esac
|
||
}
|
||
|
||
|
||
# func_check_version_match
|
||
# ------------------------
|
||
# Ensure that we are using m4 macros, and libtool script from the same
|
||
# release of libtool.
|
||
func_check_version_match ()
|
||
{
|
||
if test "$package_revision" != "$macro_revision"; then
|
||
if test "$VERSION" != "$macro_version"; then
|
||
if test -z "$macro_version"; then
|
||
cat >&2 <<_LT_EOF
|
||
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
|
||
$progname: definition of this LT_INIT comes from an older release.
|
||
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
|
||
$progname: and run autoconf again.
|
||
_LT_EOF
|
||
else
|
||
cat >&2 <<_LT_EOF
|
||
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
|
||
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
|
||
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
|
||
$progname: and run autoconf again.
|
||
_LT_EOF
|
||
fi
|
||
else
|
||
cat >&2 <<_LT_EOF
|
||
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
|
||
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
|
||
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
|
||
$progname: of $PACKAGE $VERSION and run autoconf again.
|
||
_LT_EOF
|
||
fi
|
||
|
||
exit $EXIT_MISMATCH
|
||
fi
|
||
}
|
||
|
||
|
||
# libtool_options_prep [ARG]...
|
||
# -----------------------------
|
||
# Preparation for options parsed by libtool.
|
||
libtool_options_prep ()
|
||
{
|
||
$debug_mode
|
||
|
||
# Option defaults:
|
||
opt_config=false
|
||
opt_dlopen=
|
||
opt_dry_run=false
|
||
opt_help=false
|
||
opt_mode=
|
||
opt_preserve_dup_deps=false
|
||
opt_quiet=false
|
||
|
||
nonopt=
|
||
preserve_args=
|
||
|
||
# Shorthand for --mode=foo, only valid as the first argument
|
||
case $1 in
|
||
clean|clea|cle|cl)
|
||
shift; set dummy --mode clean ${1+"$@"}; shift
|
||
;;
|
||
compile|compil|compi|comp|com|co|c)
|
||
shift; set dummy --mode compile ${1+"$@"}; shift
|
||
;;
|
||
execute|execut|execu|exec|exe|ex|e)
|
||
shift; set dummy --mode execute ${1+"$@"}; shift
|
||
;;
|
||
finish|finis|fini|fin|fi|f)
|
||
shift; set dummy --mode finish ${1+"$@"}; shift
|
||
;;
|
||
install|instal|insta|inst|ins|in|i)
|
||
shift; set dummy --mode install ${1+"$@"}; shift
|
||
;;
|
||
link|lin|li|l)
|
||
shift; set dummy --mode link ${1+"$@"}; shift
|
||
;;
|
||
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
|
||
shift; set dummy --mode uninstall ${1+"$@"}; shift
|
||
;;
|
||
esac
|
||
|
||
# Pass back the list of options.
|
||
func_quote_for_eval ${1+"$@"}
|
||
libtool_options_prep_result=$func_quote_for_eval_result
|
||
}
|
||
func_add_hook func_options_prep libtool_options_prep
|
||
|
||
|
||
# libtool_parse_options [ARG]...
|
||
# ---------------------------------
|
||
# Provide handling for libtool specific options.
|
||
libtool_parse_options ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# Perform our own loop to consume as many options as possible in
|
||
# each iteration.
|
||
while test $# -gt 0; do
|
||
_G_opt=$1
|
||
shift
|
||
case $_G_opt in
|
||
--dry-run|--dryrun|-n)
|
||
opt_dry_run=:
|
||
;;
|
||
|
||
--config) func_config ;;
|
||
|
||
--dlopen|-dlopen)
|
||
opt_dlopen="${opt_dlopen+$opt_dlopen
|
||
}$1"
|
||
shift
|
||
;;
|
||
|
||
--preserve-dup-deps)
|
||
opt_preserve_dup_deps=: ;;
|
||
|
||
--features) func_features ;;
|
||
|
||
--finish) set dummy --mode finish ${1+"$@"}; shift ;;
|
||
|
||
--help) opt_help=: ;;
|
||
|
||
--help-all) opt_help=': help-all' ;;
|
||
|
||
--mode) test $# = 0 && func_missing_arg $_G_opt && break
|
||
opt_mode=$1
|
||
case $1 in
|
||
# Valid mode arguments:
|
||
clean|compile|execute|finish|install|link|relink|uninstall) ;;
|
||
|
||
# Catch anything else as an error
|
||
*) func_error "invalid argument for $_G_opt"
|
||
exit_cmd=exit
|
||
break
|
||
;;
|
||
esac
|
||
shift
|
||
;;
|
||
|
||
--no-silent|--no-quiet)
|
||
opt_quiet=false
|
||
func_append preserve_args " $_G_opt"
|
||
;;
|
||
|
||
--no-warnings|--no-warning|--no-warn)
|
||
opt_warning=false
|
||
func_append preserve_args " $_G_opt"
|
||
;;
|
||
|
||
--no-verbose)
|
||
opt_verbose=false
|
||
func_append preserve_args " $_G_opt"
|
||
;;
|
||
|
||
--silent|--quiet)
|
||
opt_quiet=:
|
||
opt_verbose=false
|
||
func_append preserve_args " $_G_opt"
|
||
;;
|
||
|
||
--tag) test $# = 0 && func_missing_arg $_G_opt && break
|
||
opt_tag=$1
|
||
func_append preserve_args " $_G_opt $1"
|
||
func_enable_tag "$1"
|
||
shift
|
||
;;
|
||
|
||
--verbose|-v) opt_quiet=false
|
||
opt_verbose=:
|
||
func_append preserve_args " $_G_opt"
|
||
;;
|
||
|
||
# An option not handled by this hook function:
|
||
*) set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
|
||
esac
|
||
done
|
||
|
||
|
||
# save modified positional parameters for caller
|
||
func_quote_for_eval ${1+"$@"}
|
||
libtool_parse_options_result=$func_quote_for_eval_result
|
||
}
|
||
func_add_hook func_parse_options libtool_parse_options
|
||
|
||
|
||
|
||
# libtool_validate_options [ARG]...
|
||
# ---------------------------------
|
||
# Perform any sanity checks on option settings and/or unconsumed
|
||
# arguments.
|
||
libtool_validate_options ()
|
||
{
|
||
# save first non-option argument
|
||
if test 0 -lt $#; then
|
||
nonopt=$1
|
||
shift
|
||
fi
|
||
|
||
# preserve --debug
|
||
test : = "$debug_cmd" || func_append preserve_args " --debug"
|
||
|
||
case $host in
|
||
# Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
|
||
# see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
|
||
*cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
|
||
# don't eliminate duplications in $postdeps and $predeps
|
||
opt_duplicate_compiler_generated_deps=:
|
||
;;
|
||
*)
|
||
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
|
||
;;
|
||
esac
|
||
|
||
$opt_help || {
|
||
# Sanity checks first:
|
||
func_check_version_match
|
||
|
||
test yes != "$build_libtool_libs" \
|
||
&& test yes != "$build_old_libs" \
|
||
&& func_fatal_configuration "not configured to build any kind of library"
|
||
|
||
# Darwin sucks
|
||
eval std_shrext=\"$shrext_cmds\"
|
||
|
||
# Only execute mode is allowed to have -dlopen flags.
|
||
if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
|
||
func_error "unrecognized option '-dlopen'"
|
||
$ECHO "$help" 1>&2
|
||
exit $EXIT_FAILURE
|
||
fi
|
||
|
||
# Change the help message to a mode-specific one.
|
||
generic_help=$help
|
||
help="Try '$progname --help --mode=$opt_mode' for more information."
|
||
}
|
||
|
||
# Pass back the unparsed argument list
|
||
func_quote_for_eval ${1+"$@"}
|
||
libtool_validate_options_result=$func_quote_for_eval_result
|
||
}
|
||
func_add_hook func_validate_options libtool_validate_options
|
||
|
||
|
||
# Process options as early as possible so that --help and --version
|
||
# can return quickly.
|
||
func_options ${1+"$@"}
|
||
eval set dummy "$func_options_result"; shift
|
||
|
||
|
||
|
||
## ----------- ##
|
||
## Main. ##
|
||
## ----------- ##
|
||
|
||
magic='%%%MAGIC variable%%%'
|
||
magic_exe='%%%MAGIC EXE variable%%%'
|
||
|
||
# Global variables.
|
||
extracted_archives=
|
||
extracted_serial=0
|
||
|
||
# If this variable is set in any of the actions, the command in it
|
||
# will be execed at the end. This prevents here-documents from being
|
||
# left over by shells.
|
||
exec_cmd=
|
||
|
||
|
||
# A function that is used when there is no print builtin or printf.
|
||
func_fallback_echo ()
|
||
{
|
||
eval 'cat <<_LTECHO_EOF
|
||
$1
|
||
_LTECHO_EOF'
|
||
}
|
||
|
||
# func_generated_by_libtool
|
||
# True iff stdin has been generated by Libtool. This function is only
|
||
# a basic sanity check; it will hardly flush out determined imposters.
|
||
func_generated_by_libtool_p ()
|
||
{
|
||
$GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
|
||
}
|
||
|
||
# func_lalib_p file
|
||
# True iff FILE is a libtool '.la' library or '.lo' object file.
|
||
# This function is only a basic sanity check; it will hardly flush out
|
||
# determined imposters.
|
||
func_lalib_p ()
|
||
{
|
||
test -f "$1" &&
|
||
$SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
|
||
}
|
||
|
||
# func_lalib_unsafe_p file
|
||
# True iff FILE is a libtool '.la' library or '.lo' object file.
|
||
# This function implements the same check as func_lalib_p without
|
||
# resorting to external programs. To this end, it redirects stdin and
|
||
# closes it afterwards, without saving the original file descriptor.
|
||
# As a safety measure, use it only where a negative result would be
|
||
# fatal anyway. Works if 'file' does not exist.
|
||
func_lalib_unsafe_p ()
|
||
{
|
||
lalib_p=no
|
||
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
|
||
for lalib_p_l in 1 2 3 4
|
||
do
|
||
read lalib_p_line
|
||
case $lalib_p_line in
|
||
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
|
||
esac
|
||
done
|
||
exec 0<&5 5<&-
|
||
fi
|
||
test yes = "$lalib_p"
|
||
}
|
||
|
||
# func_ltwrapper_script_p file
|
||
# True iff FILE is a libtool wrapper script
|
||
# This function is only a basic sanity check; it will hardly flush out
|
||
# determined imposters.
|
||
func_ltwrapper_script_p ()
|
||
{
|
||
test -f "$1" &&
|
||
$lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
|
||
}
|
||
|
||
# func_ltwrapper_executable_p file
|
||
# True iff FILE is a libtool wrapper executable
|
||
# This function is only a basic sanity check; it will hardly flush out
|
||
# determined imposters.
|
||
func_ltwrapper_executable_p ()
|
||
{
|
||
func_ltwrapper_exec_suffix=
|
||
case $1 in
|
||
*.exe) ;;
|
||
*) func_ltwrapper_exec_suffix=.exe ;;
|
||
esac
|
||
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
|
||
}
|
||
|
||
# func_ltwrapper_scriptname file
|
||
# Assumes file is an ltwrapper_executable
|
||
# uses $file to determine the appropriate filename for a
|
||
# temporary ltwrapper_script.
|
||
func_ltwrapper_scriptname ()
|
||
{
|
||
func_dirname_and_basename "$1" "" "."
|
||
func_stripname '' '.exe' "$func_basename_result"
|
||
func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
|
||
}
|
||
|
||
# func_ltwrapper_p file
|
||
# True iff FILE is a libtool wrapper script or wrapper executable
|
||
# This function is only a basic sanity check; it will hardly flush out
|
||
# determined imposters.
|
||
func_ltwrapper_p ()
|
||
{
|
||
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
|
||
}
|
||
|
||
|
||
# func_execute_cmds commands fail_cmd
|
||
# Execute tilde-delimited COMMANDS.
|
||
# If FAIL_CMD is given, eval that upon failure.
|
||
# FAIL_CMD may read-access the current command in variable CMD!
|
||
func_execute_cmds ()
|
||
{
|
||
$debug_cmd
|
||
|
||
save_ifs=$IFS; IFS='~'
|
||
for cmd in $1; do
|
||
IFS=$sp$nl
|
||
eval cmd=\"$cmd\"
|
||
IFS=$save_ifs
|
||
func_show_eval "$cmd" "${2-:}"
|
||
done
|
||
IFS=$save_ifs
|
||
}
|
||
|
||
|
||
# func_source file
|
||
# Source FILE, adding directory component if necessary.
|
||
# Note that it is not necessary on cygwin/mingw to append a dot to
|
||
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
|
||
# behavior happens only for exec(3), not for open(2)! Also, sourcing
|
||
# 'FILE.' does not work on cygwin managed mounts.
|
||
func_source ()
|
||
{
|
||
$debug_cmd
|
||
|
||
case $1 in
|
||
*/* | *\\*) . "$1" ;;
|
||
*) . "./$1" ;;
|
||
esac
|
||
}
|
||
|
||
|
||
# func_resolve_sysroot PATH
|
||
# Replace a leading = in PATH with a sysroot. Store the result into
|
||
# func_resolve_sysroot_result
|
||
func_resolve_sysroot ()
|
||
{
|
||
func_resolve_sysroot_result=$1
|
||
case $func_resolve_sysroot_result in
|
||
=*)
|
||
func_stripname '=' '' "$func_resolve_sysroot_result"
|
||
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# func_replace_sysroot PATH
|
||
# If PATH begins with the sysroot, replace it with = and
|
||
# store the result into func_replace_sysroot_result.
|
||
func_replace_sysroot ()
|
||
{
|
||
case $lt_sysroot:$1 in
|
||
?*:"$lt_sysroot"*)
|
||
func_stripname "$lt_sysroot" '' "$1"
|
||
func_replace_sysroot_result='='$func_stripname_result
|
||
;;
|
||
*)
|
||
# Including no sysroot.
|
||
func_replace_sysroot_result=$1
|
||
;;
|
||
esac
|
||
}
|
||
|
||
# func_infer_tag arg
|
||
# Infer tagged configuration to use if any are available and
|
||
# if one wasn't chosen via the "--tag" command line option.
|
||
# Only attempt this if the compiler in the base compile
|
||
# command doesn't match the default compiler.
|
||
# arg is usually of the form 'gcc ...'
|
||
func_infer_tag ()
|
||
{
|
||
$debug_cmd
|
||
|
||
if test -n "$available_tags" && test -z "$tagname"; then
|
||
CC_quoted=
|
||
for arg in $CC; do
|
||
func_append_quoted CC_quoted "$arg"
|
||
done
|
||
CC_expanded=`func_echo_all $CC`
|
||
CC_quoted_expanded=`func_echo_all $CC_quoted`
|
||
case $@ in
|
||
# Blanks in the command may have been stripped by the calling shell,
|
||
# but not from the CC environment variable when configure was run.
|
||
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
|
||
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
|
||
# Blanks at the start of $base_compile will cause this to fail
|
||
# if we don't check for them as well.
|
||
*)
|
||
for z in $available_tags; do
|
||
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
|
||
# Evaluate the configuration.
|
||
eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
|
||
CC_quoted=
|
||
for arg in $CC; do
|
||
# Double-quote args containing other shell metacharacters.
|
||
func_append_quoted CC_quoted "$arg"
|
||
done
|
||
CC_expanded=`func_echo_all $CC`
|
||
CC_quoted_expanded=`func_echo_all $CC_quoted`
|
||
case "$@ " in
|
||
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
|
||
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
|
||
# The compiler in the base compile command matches
|
||
# the one in the tagged configuration.
|
||
# Assume this is the tagged configuration we want.
|
||
tagname=$z
|
||
break
|
||
;;
|
||
esac
|
||
fi
|
||
done
|
||
# If $tagname still isn't set, then no tagged configuration
|
||
# was found and let the user know that the "--tag" command
|
||
# line option must be used.
|
||
if test -z "$tagname"; then
|
||
func_echo "unable to infer tagged configuration"
|
||
func_fatal_error "specify a tag with '--tag'"
|
||
# else
|
||
# func_verbose "using $tagname tagged configuration"
|
||
fi
|
||
;;
|
||
esac
|
||
fi
|
||
}
|
||
|
||
|
||
|
||
# func_write_libtool_object output_name pic_name nonpic_name
|
||
# Create a libtool object file (analogous to a ".la" file),
|
||
# but don't create it if we're doing a dry run.
|
||
func_write_libtool_object ()
|
||
{
|
||
write_libobj=$1
|
||
if test yes = "$build_libtool_libs"; then
|
||
write_lobj=\'$2\'
|
||
else
|
||
write_lobj=none
|
||
fi
|
||
|
||
if test yes = "$build_old_libs"; then
|
||
write_oldobj=\'$3\'
|
||
else
|
||
write_oldobj=none
|
||
fi
|
||
|
||
$opt_dry_run || {
|
||
cat >${write_libobj}T <<EOF
|
||
# $write_libobj - a libtool object file
|
||
# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
|
||
#
|
||
# Please DO NOT delete this file!
|
||
# It is necessary for linking the library.
|
||
|
||
# Name of the PIC object.
|
||
pic_object=$write_lobj
|
||
|
||
# Name of the non-PIC object
|
||
non_pic_object=$write_oldobj
|
||
|
||
EOF
|
||
$MV "${write_libobj}T" "$write_libobj"
|
||
}
|
||
}
|
||
|
||
|
||
##################################################
|
||
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
|
||
##################################################
|
||
|
||
# func_convert_core_file_wine_to_w32 ARG
|
||
# Helper function used by file name conversion functions when $build is *nix,
|
||
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
|
||
# correctly configured wine environment available, with the winepath program
|
||
# in $build's $PATH.
|
||
#
|
||
# ARG is the $build file name to be converted to w32 format.
|
||
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
|
||
# be empty on error (or when ARG is empty)
|
||
func_convert_core_file_wine_to_w32 ()
|
||
{
|
||
$debug_cmd
|
||
|
||
func_convert_core_file_wine_to_w32_result=$1
|
||
if test -n "$1"; then
|
||
# Unfortunately, winepath does not exit with a non-zero error code, so we
|
||
# are forced to check the contents of stdout. On the other hand, if the
|
||
# command is not found, the shell will set an exit code of 127 and print
|
||
# *an error message* to stdout. So we must check for both error code of
|
||
# zero AND non-empty stdout, which explains the odd construction:
|
||
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
|
||
if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
|
||
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
|
||
$SED -e "$sed_naive_backslashify"`
|
||
else
|
||
func_convert_core_file_wine_to_w32_result=
|
||
fi
|
||
fi
|
||
}
|
||
# end: func_convert_core_file_wine_to_w32
|
||
|
||
|
||
# func_convert_core_path_wine_to_w32 ARG
|
||
# Helper function used by path conversion functions when $build is *nix, and
|
||
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
|
||
# configured wine environment available, with the winepath program in $build's
|
||
# $PATH. Assumes ARG has no leading or trailing path separator characters.
|
||
#
|
||
# ARG is path to be converted from $build format to win32.
|
||
# Result is available in $func_convert_core_path_wine_to_w32_result.
|
||
# Unconvertible file (directory) names in ARG are skipped; if no directory names
|
||
# are convertible, then the result may be empty.
|
||
func_convert_core_path_wine_to_w32 ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# unfortunately, winepath doesn't convert paths, only file names
|
||
func_convert_core_path_wine_to_w32_result=
|
||
if test -n "$1"; then
|
||
oldIFS=$IFS
|
||
IFS=:
|
||
for func_convert_core_path_wine_to_w32_f in $1; do
|
||
IFS=$oldIFS
|
||
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
|
||
if test -n "$func_convert_core_file_wine_to_w32_result"; then
|
||
if test -z "$func_convert_core_path_wine_to_w32_result"; then
|
||
func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
|
||
else
|
||
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
|
||
fi
|
||
fi
|
||
done
|
||
IFS=$oldIFS
|
||
fi
|
||
}
|
||
# end: func_convert_core_path_wine_to_w32
|
||
|
||
|
||
# func_cygpath ARGS...
|
||
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
|
||
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
|
||
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
|
||
# (2), returns the Cygwin file name or path in func_cygpath_result (input
|
||
# file name or path is assumed to be in w32 format, as previously converted
|
||
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
|
||
# or path in func_cygpath_result (input file name or path is assumed to be in
|
||
# Cygwin format). Returns an empty string on error.
|
||
#
|
||
# ARGS are passed to cygpath, with the last one being the file name or path to
|
||
# be converted.
|
||
#
|
||
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
|
||
# environment variable; do not put it in $PATH.
|
||
func_cygpath ()
|
||
{
|
||
$debug_cmd
|
||
|
||
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
|
||
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
|
||
if test "$?" -ne 0; then
|
||
# on failure, ensure result is empty
|
||
func_cygpath_result=
|
||
fi
|
||
else
|
||
func_cygpath_result=
|
||
func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
|
||
fi
|
||
}
|
||
#end: func_cygpath
|
||
|
||
|
||
# func_convert_core_msys_to_w32 ARG
|
||
# Convert file name or path ARG from MSYS format to w32 format. Return
|
||
# result in func_convert_core_msys_to_w32_result.
|
||
func_convert_core_msys_to_w32 ()
|
||
{
|
||
$debug_cmd
|
||
|
||
# awkward: cmd appends spaces to result
|
||
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
|
||
$SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
|
||
}
|
||
#end: func_convert_core_msys_to_w32
|
||
|
||
|
||
# func_convert_file_check ARG1 ARG2
|
||
# Verify that ARG1 (a file name in $build format) was converted to $host
|
||
# format in ARG2. Otherwise, emit an error message, but continue (resetting
|
||
# func_to_host_file_result to ARG1).
|
||
func_convert_file_check ()
|
||
{
|
||
$debug_cmd
|
||
|
||
if test -z "$2" && test -n "$1"; then
|
||
func_error "Could not determine host file name corresponding to"
|
||
func_error " '$1'"
|
||
func_error "Continuing, but uninstalled executables may not work."
|
||
# Fallback:
|
||
func_to_host_file_result=$1
|
||
fi
|
||
}
|
||
# end func_convert_file_check
|
||
|
||
|
||
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
|
||
# Verify that FROM_PATH (a path in $build format) was converted to $host
|
||
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
|
||
# func_to_host_file_result to a simplistic fallback value (see below).
|
||
func_convert_path_check ()
|
||
{
|
||
$debug_cmd
|
||
|
||
if test -z "$4" && test -n "$3"; then
|
||
func_error "Could not determine the host path corresponding to"
|
||
func_error " '$3'"
|
||
func_error "Continuing, but uninstalled executables may not work."
|
||
# Fallback. This is a deliberately simplistic "conversion" and
|
||
# should not be "improved". See libtool.info.
|
||
if test "x$1" != "x$2"; then
|
||
lt_replace_pathsep_chars="s|$1|$2|g"
|
||
func_to_host_path_result=`echo "$3" |
|
||
$SED -e "$lt_replace_pathsep_chars"`
|
||
else
|
||
func_to_host_path_result=$3
|
||
fi
|
||
fi
|
||
}
|
||
# end func_convert_path_check
|
||
|
||
|
||
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
|
||
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
|
||
# and appending REPL if ORIG matches BACKPAT.
|
||
func_convert_path_front_back_pathsep ()
|
||
{
|
||
$debug_cmd
|
||
|
||