mirror of
git://git.savannah.gnu.org/libtool.git
synced 2024-11-27 06:09:57 +08:00
eabd3ad629
* build-aub/general.m4sh (lt_HAVE_PLUSEQ_OP): Instead of using $((..)) arithmetic, which causes an error on dash, use a case based bash version check. (lt_HAVE_ARITH_OP, lt_HAVE_XSI_OPS): Also short circuit the feature probing forks and set these automatically when zsh is detected. Reported by Stefano Lattarini. Signed-off-by: Gary V. Vaughan <gary@gnu.org>
743 lines
21 KiB
Plaintext
743 lines
21 KiB
Plaintext
m4_divert_push([KILL]) -*- Autoconf -*-
|
|
# general.m4sh -- general shell script boiler plate
|
|
#
|
|
# Copyright (C) 2004, 2005, 2007, 2008, 2010 Free Software Foundation, Inc.
|
|
# Written by Gary V. Vaughan, 2004
|
|
#
|
|
# This file is part of GNU Libtool.
|
|
#
|
|
# 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 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 GNU Libtool; see the file COPYING. If not, a copy
|
|
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
|
|
# or obtained by writing to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
m4_define([M4SH_VERBATIM], [$1])
|
|
|
|
m4_ifndef([M4SH_IN_HEADER],
|
|
[m4_define([M4SH_IN_HEADER],
|
|
[m4_divert_text([HEADER-COPYRIGHT], [$1])])])
|
|
|
|
m4_divert_pop([KILL])M4SH_IN_HEADER([dnl
|
|
# 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
|
|
])
|
|
|
|
M4SH_VERBATIM([[
|
|
: ${CP="cp -f"}
|
|
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
|
|
: ${EGREP="@EGREP@"}
|
|
: ${FGREP="@FGREP@"}
|
|
: ${GREP="@GREP@"}
|
|
: ${LN_S="@LN_S@"}
|
|
: ${MAKE="make"}
|
|
: ${MKDIR="mkdir"}
|
|
: ${MV="mv -f"}
|
|
: ${RM="rm -f"}
|
|
: ${SED="@SED@"}
|
|
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
|
|
: ${Xsed="$SED -e 1s/^X//"}
|
|
|
|
# Global variables:
|
|
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.
|
|
|
|
exit_status=$EXIT_SUCCESS
|
|
|
|
# Make sure IFS has a sensible default
|
|
lt_nl='
|
|
'
|
|
IFS=" $lt_nl"
|
|
|
|
dirname='s|/[^/]*$||'
|
|
basename='s|^.*/||'
|
|
|
|
|
|
# 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}"; then
|
|
: ${lt_HAVE_ARITH_OP="yes"}
|
|
: ${lt_HAVE_XSI_OPS="yes"}
|
|
# The += operator was introduced in bash 3.1
|
|
case $BASH_VERSION in
|
|
[12].* | 3.0 | 3.0.*) ;;
|
|
*) lt_HAVE_PLUSEQ_OP=yes ;;
|
|
esac
|
|
fi
|
|
|
|
|
|
# lt_HAVE_PLUSEQ_OP
|
|
# Can be empty, in which case the shell is probed, "yes" if += is useable
|
|
# or anything else if += does not work.
|
|
test -z "$lt_HAVE_PLUSEQ_OP" \
|
|
&& (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
|
|
&& lt_HAVE_PLUSEQ_OP=yes
|
|
|
|
if test yes = "$lt_HAVE_PLUSEQ_OP"; then
|
|
# func_append var value
|
|
# Append VALUE to the end of shell variable VAR.
|
|
eval 'func_append ()
|
|
{
|
|
eval "$1+=\$2"
|
|
}'
|
|
|
|
# func_append_quoted var value
|
|
# Quote VALUE and append to the end of shell variable VAR, separated
|
|
# by a space.
|
|
eval 'func_append_quoted ()
|
|
{
|
|
func_quote_for_eval "$2"
|
|
eval "$1+=\\ \$func_quote_for_eval_result"
|
|
}'
|
|
else
|
|
func_append ()
|
|
{
|
|
eval "$1=\$$1\$2"
|
|
}
|
|
|
|
func_append_quoted ()
|
|
{
|
|
func_quote_for_eval "$2"
|
|
eval "$1=\$$1\\ \$func_quote_for_eval_result"
|
|
}
|
|
fi
|
|
|
|
|
|
# lt_HAVE_ARITH_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 "$lt_HAVE_ARITH_OP" \
|
|
&& (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
|
|
&& lt_HAVE_ARITH_OP=yes
|
|
|
|
# func_arith arithmetic-term...
|
|
if test yes = "$lt_HAVE_ARITH_OP"; then
|
|
eval 'func_arith ()
|
|
{
|
|
func_arith_result=$(( $* ))
|
|
}'
|
|
else
|
|
func_arith ()
|
|
{
|
|
func_arith_result=`expr "$@"`
|
|
}
|
|
fi
|
|
|
|
|
|
# lt_HAVE_XSI_OPS
|
|
# Can be empty, in which case the shell is probed, "yes" if XSI length
|
|
# and matching operators are useable or anything else if they do not work.
|
|
test -z "$lt_HAVE_XSI_OPS" \
|
|
&& (eval 'x=a/b/c;
|
|
test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
|
|
&& lt_HAVE_XSI_OPS=yes
|
|
|
|
|
|
# func_len string
|
|
# STRING may not start with a hyphen.
|
|
if test yes = "$lt_HAVE_XSI_OPS"; then
|
|
eval 'func_len ()
|
|
{
|
|
func_len_result=${#1}
|
|
}'
|
|
else
|
|
func_len ()
|
|
{
|
|
func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
|
|
}
|
|
fi
|
|
|
|
|
|
if test yes = "$lt_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 "$basename"`'
|
|
_d='func_dirname_result=`$ECHO "$1" |$SED "$dirname"`
|
|
if test "X$func_dirname_result" = "X$1"; then
|
|
func_dirname_result=$3
|
|
else
|
|
func_append func_dirname_result "$2"
|
|
fi'
|
|
fi
|
|
|
|
|
|
# func_basename file
|
|
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_stripname prefix suffix name
|
|
# strip PREFIX and SUFFIX off of NAME.
|
|
# 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).
|
|
# func_strip_suffix prefix name
|
|
if test yes = "$lt_HAVE_XSI_OPS"; then
|
|
eval 'func_stripname ()
|
|
{
|
|
# 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 ()
|
|
{
|
|
case $2 in
|
|
.*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%\\\\$2\$%%"`;;
|
|
*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%$2\$%%"`;;
|
|
esac
|
|
}
|
|
fi
|
|
|
|
|
|
# These SED scripts presuppose an absolute path with a trailing slash.
|
|
pathcar='s|^/\([^/]*\).*$|\1|'
|
|
pathcdr='s|^/[^/]*||'
|
|
removedotparts=':dotsl
|
|
s|/\./|/|g
|
|
t dotsl
|
|
s|/\.$|/|'
|
|
collapseslashes='s|/\{1,\}|/|g'
|
|
finalslash='s|/*$|/|'
|
|
|
|
# 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.
|
|
# value returned in "$func_normal_abspath_result"
|
|
func_normal_abspath ()
|
|
{
|
|
# 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 "$removedotparts" -e "$collapseslashes" -e "$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 "$pathcar"`
|
|
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
|
|
-e "$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_relative_path SRCDIR DSTDIR
|
|
# generates a relative path from SRCDIR to DSTDIR.
|
|
# value returned in "$func_relative_path_result"
|
|
func_relative_path ()
|
|
{
|
|
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=.
|
|
}
|
|
|
|
# The name of this program:
|
|
func_dirname_and_basename "$progpath"
|
|
progname=$func_basename_result
|
|
|
|
# Make sure we have an absolute path for reexecution:
|
|
case $progpath in
|
|
[\\/]*|[A-Za-z]:\\*) ;;
|
|
*[\\/]*)
|
|
progdir=$func_dirname_result
|
|
progdir=`cd "$progdir" && pwd`
|
|
progpath=$progdir/$progname
|
|
;;
|
|
*)
|
|
save_IFS=$IFS
|
|
IFS=${PATH_SEPARATOR-:}
|
|
for progdir in $PATH; do
|
|
IFS=$save_IFS
|
|
test -x "$progdir/$progname" && break
|
|
done
|
|
IFS=$save_IFS
|
|
test -n "$progdir" || progdir=`pwd`
|
|
progpath=$progdir/$progname
|
|
;;
|
|
esac
|
|
|
|
# Sed substitution that helps us do robust quoting. It backslashifies
|
|
# metacharacters that are still active within double-quoted strings.
|
|
Xsed="$SED -e 1s/^X//"
|
|
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
|
|
|
|
# Same as above, but do not quote variable references.
|
|
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
|
|
# which contains forward slashes, into one that contains
|
|
# (escaped) backslashes. A very naive implementation.
|
|
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
|
|
|
|
# Re-`\' parameter expansions in output of double_quote_subst that were
|
|
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
|
|
# in input to 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 '$'.
|
|
bs='\\'
|
|
bs2='\\\\'
|
|
bs4='\\\\\\\\'
|
|
dollar='\$'
|
|
sed_double_backslash="\
|
|
s/$bs4/&\\
|
|
/g
|
|
s/^$bs2$dollar/$bs&/
|
|
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
|
|
s/\n//g"
|
|
|
|
# Standard options:
|
|
opt_dry_run=false
|
|
opt_help=false
|
|
opt_quiet=false
|
|
opt_verbose=false
|
|
opt_warning=:
|
|
|
|
# func_echo arg...
|
|
# Echo program name prefixed message, along with the current mode
|
|
# name if it has been set yet.
|
|
func_echo ()
|
|
{
|
|
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
|
|
}
|
|
|
|
# func_verbose arg...
|
|
# Echo program name prefixed message in verbose mode only.
|
|
func_verbose ()
|
|
{
|
|
$opt_verbose && 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_echo_all arg...
|
|
# Invoke $ECHO with all args, space-separated.
|
|
func_echo_all ()
|
|
{
|
|
$ECHO "$*"
|
|
}
|
|
|
|
# func_error arg...
|
|
# Echo program name prefixed message to standard error.
|
|
func_error ()
|
|
{
|
|
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
|
|
}
|
|
|
|
# func_warning arg...
|
|
# Echo program name prefixed warning message to standard error.
|
|
func_warning ()
|
|
{
|
|
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
|
|
|
|
# bash bug again:
|
|
:
|
|
}
|
|
|
|
# func_fatal_error arg...
|
|
# Echo program name prefixed message to standard error, and exit.
|
|
func_fatal_error ()
|
|
{
|
|
func_error ${1+"$@"}
|
|
exit $EXIT_FAILURE
|
|
}
|
|
|
|
# func_fatal_help arg...
|
|
# Echo program name prefixed message to standard error, followed by
|
|
# a help hint, and exit.
|
|
func_fatal_help ()
|
|
{
|
|
func_error ${1+"$@"}
|
|
func_fatal_error "$help"
|
|
}
|
|
help="Try \`$progname --help' for more information." ## default
|
|
|
|
|
|
# func_grep expression filename
|
|
# Check whether EXPRESSION matches any line of FILENAME, without output.
|
|
func_grep ()
|
|
{
|
|
$GREP "$1" "$2" >/dev/null 2>&1
|
|
}
|
|
|
|
|
|
# func_mkdir_p directory-path
|
|
# Make sure the entire path to DIRECTORY-PATH is available.
|
|
func_mkdir_p ()
|
|
{
|
|
my_directory_path=$1
|
|
my_dir_list=
|
|
|
|
if test -n "$my_directory_path" && test : != "$opt_dry_run"; then
|
|
|
|
# Protect directory names starting with `-'
|
|
case $my_directory_path in
|
|
-*) my_directory_path=./$my_directory_path ;;
|
|
esac
|
|
|
|
# While some portion of DIR does not yet exist...
|
|
while test ! -d "$my_directory_path"; do
|
|
# ...make a list in topmost first order. Use a colon delimited
|
|
# list incase some portion of path contains whitespace.
|
|
my_dir_list=$my_directory_path:$my_dir_list
|
|
|
|
# If the last portion added has no slash in it, the list is done
|
|
case $my_directory_path in */*) ;; *) break ;; esac
|
|
|
|
# ...otherwise throw away the child directory and loop
|
|
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
|
|
done
|
|
my_dir_list=`$ECHO "$my_dir_list" | $SED 's|:*$||'`
|
|
|
|
save_mkdir_p_IFS=$IFS; IFS=:
|
|
for my_dir in $my_dir_list; do
|
|
IFS=$save_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 "$my_dir" 2>/dev/null || :
|
|
done
|
|
IFS=$save_mkdir_p_IFS
|
|
|
|
# Bail out if we (or some other process) failed to create a directory.
|
|
test -d "$my_directory_path" || \
|
|
func_fatal_error "Failed to create \`$1'"
|
|
fi
|
|
}
|
|
|
|
|
|
# func_mktempdir [string]
|
|
# Make a temporary directory that won't clash with other running
|
|
# libtool processes, and avoids race conditions if possible. If
|
|
# given, STRING is the basename for that directory.
|
|
func_mktempdir ()
|
|
{
|
|
my_template=${TMPDIR-/tmp}/${1-$progname}
|
|
|
|
if test : = "$opt_dry_run"; then
|
|
# Return a directory name, but don't create it in dry-run mode
|
|
my_tmpdir=$my_template-$$
|
|
else
|
|
|
|
# If mktemp works, use that first and foremost
|
|
my_tmpdir=`mktemp -d "$my_template-XXXXXXXX" 2>/dev/null`
|
|
|
|
if test ! -d "$my_tmpdir"; then
|
|
# Failing that, at least try and use $RANDOM to avoid a race
|
|
my_tmpdir=$my_template-${RANDOM-0}$$
|
|
|
|
save_mktempdir_umask=`umask`
|
|
umask 0077
|
|
$MKDIR "$my_tmpdir"
|
|
umask $save_mktempdir_umask
|
|
fi
|
|
|
|
# If we're not in dry-run mode, bomb out on failure
|
|
test -d "$my_tmpdir" || \
|
|
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
|
|
fi
|
|
|
|
$ECHO "$my_tmpdir"
|
|
}
|
|
|
|
|
|
# func_quote_for_eval arg
|
|
# Aesthetically quote ARG to be evaled later.
|
|
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
|
|
# is double-quoted, suitable for a subsequent eval, whereas
|
|
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
|
|
# which are still active within double quotes backslashified.
|
|
func_quote_for_eval ()
|
|
{
|
|
case $1 in
|
|
*[\\\`\"\$]*)
|
|
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
|
|
*)
|
|
func_quote_for_eval_unquoted_result=$1 ;;
|
|
esac
|
|
|
|
case $func_quote_for_eval_unquoted_result 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.
|
|
*[\@<:@\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*@:>@*|"")
|
|
func_quote_for_eval_result=\"$func_quote_for_eval_unquoted_result\"
|
|
;;
|
|
*)
|
|
func_quote_for_eval_result=$func_quote_for_eval_unquoted_result
|
|
esac
|
|
}
|
|
|
|
|
|
# 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 ()
|
|
{
|
|
case $1 in
|
|
*[\\\`\"]*)
|
|
my_arg=`$ECHO "$1" | $SED \
|
|
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
|
|
*)
|
|
my_arg=$1 ;;
|
|
esac
|
|
|
|
case $my_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.
|
|
*[\@<:@\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*@:>@*|"")
|
|
my_arg=\"$my_arg\"
|
|
;;
|
|
esac
|
|
|
|
func_quote_for_expand_result=$my_arg
|
|
}
|
|
|
|
|
|
# func_show_eval cmd [fail_exp]
|
|
# Unless opt_silent 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 ()
|
|
{
|
|
my_cmd=$1
|
|
my_fail_exp=${2-':'}
|
|
|
|
${opt_silent-false} || {
|
|
func_quote_for_expand "$my_cmd"
|
|
eval "func_echo $func_quote_for_expand_result"
|
|
}
|
|
|
|
if ${opt_dry_run-false}; then :; else
|
|
eval "$my_cmd"
|
|
my_status=$?
|
|
if test 0 -eq $my_status; then :; else
|
|
eval "(exit $my_status); $my_fail_exp"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
# func_show_eval_locale cmd [fail_exp]
|
|
# Unless opt_silent 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 ()
|
|
{
|
|
my_cmd=$1
|
|
my_fail_exp=${2-':'}
|
|
|
|
${opt_silent-false} || {
|
|
func_quote_for_expand "$my_cmd"
|
|
eval "func_echo $func_quote_for_expand_result"
|
|
}
|
|
|
|
if ${opt_dry_run-false}; then :; else
|
|
eval "$lt_user_locale
|
|
$my_cmd"
|
|
my_status=$?
|
|
eval "$lt_safe_locale"
|
|
if test 0 -eq "$my_status"; then :; else
|
|
eval "(exit $my_status); $my_fail_exp"
|
|
fi
|
|
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 ()
|
|
{
|
|
case $1 in
|
|
[0-9]* | *[!a-zA-Z0-9_]*)
|
|
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
|
|
;;
|
|
* )
|
|
func_tr_sh_result=$1
|
|
;;
|
|
esac
|
|
}
|
|
]])
|