OpenXM/src/ox_toolkit/ltmain.sh - diff

Return to ltmain.sh CVS log

Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/ltmain.sh between version 1.3 and 1.4

version 1.3, 2012/05/07 17:38:09

version 1.4, 2015/08/27 09:51:57

Line 1

#! /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.2

# libtool (GNU libtool) 2.4.6

# Provide generalized library-building support services.

# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996

# 2007, 2008, 2009, 2010, 2011 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.

Line 23

Line 26

# 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

# along with this program. If not, see <http://www.gnu.org/licenses/>.

# 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.

# Usage: $progname [OPTION]... [MODE-ARG]...

# Provide generalized library-building support services.

# --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

# --preserve-dup-deps don't remove duplicate dependency libraries

# --quiet, --silent don't print informational messages

# --no-quiet, --no-silent

# print informational messages (default)

# --no-warn don't display warning messages

# --tag=TAG use configuration variables from tag TAG

# -v, --verbose print more informational messages than default

# --no-verbose don't print the extra informational messages

# --version print version information

# -h, --help, --help-all print short, long, or detailed 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)

# $progname: (GNU libtool) 2.4.2

# automake: $automake_version

# autoconf: $autoconf_version

# 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/>.

PROGRAM=libtool

PACKAGE=libtool

VERSION=2.4.2

VERSION=2.4.6

TIMESTAMP=""

package_revision=2.4.6

package_revision=1.3337

# Be Bourne compatible

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

## ------ ##

## 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

# 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=:

# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

# 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

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

BIN_SH=xpg4; export BIN_SH # for Tru64

DUALCASE=1; export DUALCASE # for MKS sh

# A function that is used when there is no print builtin or printf.

# NLS nuisances: We save the old values in case they are required later.

func_fallback_echo ()

_G_user_locale=

{

_G_safe_locale=

eval 'cat <<_LTECHO_EOF

for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

_LTECHO_EOF'

}

# NLS nuisances: We save the old values to restore during execute mode.

lt_user_locale=

lt_safe_locale=

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

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

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

save_$lt_var=\$$lt_var

save_$_G_var=\$$_G_var

$lt_var=C

$_G_var=C

export $lt_var

export $_G_var

lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"

_G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"

lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"

_G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"

fi"

done

LC_ALL=C

LANGUAGE=C

export LANGUAGE LC_ALL

$lt_unset CDPATH

# CDPATH.

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

# Make sure IFS has a sensible default

sp=' '

nl='

IFS="$sp $nl"

# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

# There are apparently some retarded systems that use ';' as a PATH separator!

# is ksh but when the shell is invoked as "sh" and the current value of

if test "${PATH_SEPARATOR+set}" != set; then

# the _XPG environment variable is not equal to 1 (one), the special

PATH_SEPARATOR=:

# positional parameter $0, within a function call, is the name of the

(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {

# function.

(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||

progpath="$0"

PATH_SEPARATOR=';'

}

## ------------------------- ##

## 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

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 :

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

# 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 :

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

# 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"}

test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}

: ${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}"}

: ${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

## -------------------- ##

## Useful sed snippets. ##

## -------------------- ##

# Make sure IFS has a sensible default

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

lt_nl='

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

IFS=" $lt_nl"

dirname="s,/[^/]*$,,"

# Sed substitution that helps us do robust quoting. It backslashifies

basename="s,^.*/,,"

# metacharacters that are still active within double-quoted strings.

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

# func_dirname file append nondir_replacement

# Same as above, but do not quote variable references.

# Compute the dirname of FILE. If nonempty, add APPEND to the result,

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

# otherwise set result to NONDIR_REPLACEMENT.

func_dirname ()

{

func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`

if test "X$func_dirname_result" = "X${1}"; then

func_dirname_result="${3}"

else

func_dirname_result="$func_dirname_result${2}"

} # func_dirname may be replaced by extended shell implementation

# Sed substitution that turns a string into a regex matching for the

# string literally.

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

# func_basename file

# Sed substitution that converts a w32 file name or path

func_basename ()

# that contains forward slashes, into one that contains

{

# (escaped) backslashes. A very naive implementation.

func_basename_result=`$ECHO "${1}" | $SED "$basename"`

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

} # func_basename may be replaced by extended shell implementation

# 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/&\\

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"

# 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"

# Implementation must be kept synchronized with func_dirname

# and func_basename. For efficiency, we do not delegate to

# those functions but instead duplicate the functionality here.

func_dirname_and_basename ()

{

# Extract subdirectory from the argument.

func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`

if test "X$func_dirname_result" = "X${1}"; then

func_dirname_result="${3}"

else

func_dirname_result="$func_dirname_result${2}"

func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`

} # func_dirname_and_basename may be replaced by extended shell implementation

## ----------------- ##

## Global variables. ##

## ----------------- ##

# func_stripname prefix suffix name

# Except for the global variables explicitly listed below, the following

# strip PREFIX and SUFFIX off of NAME.

# functions in the '^func_' namespace, and the '^require_' namespace

# PREFIX and SUFFIX must not contain globbing or regex special

# variables initialised in the 'Resource management' section, sourcing

# characters, hashes, percent signs, but SUFFIX may contain a leading

# this file will not pollute your global namespace with anything

# dot (in which case that matches only a dot).

# else. There's no portable way to scope variables in Bourne shell

# func_strip_suffix prefix name

# though, so actually running these functions will sometimes place

func_stripname ()

# results into a variable named after the function, and often use

{

# temporary variables in the '^_G_' namespace. If you are careful to

case ${2} in

# avoid using those namespaces casually in your sourcing script, things

.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;

# should continue to work as you expect. And, of course, you can freely

*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;

# overwrite any of the functions or variables defined here before

esac

# calling anything to customize them.

} # func_stripname may be replaced by extended shell implementation

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.

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

# Allow overriding, eg assuming that you follow the convention of

pathcar='s,^/$[^/]*$.*$,\1,'

# putting '$debug_cmd' at the start of all your functions, you can get

pathcdr='s,^/[^/]*,,'

# bash to show function call trace with:

removedotparts=':dotsl

s@/\./@/@g

# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name

t dotsl

debug_cmd=${debug_cmd-":"}

s,/\.$,/,'

exit_cmd=:

collapseslashes='s@/\{1,\}@/@g'

finalslash='s,/*$,/,'

# func_normal_abspath PATH

# By convention, finish your script with:

# Remove doubled-up and trailing slashes, "." path components,

# and cancel out any ".." path components in PATH after making

# exit $exit_status

# it an absolute path.

# value returned in "$func_normal_abspath_result"

# so that you can set exit_status to non-zero if you want to indicate

func_normal_abspath ()

# something went wrong during execution without actually bailing out at

{

# the point of failure.

# Start from root dir and reassemble the path.

exit_status=$EXIT_SUCCESS

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=/

break

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_normal_abspath_result=$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

# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

# generates a relative path from SRCDIR to DSTDIR, with a trailing

# is ksh but when the shell is invoked as "sh" and the current value of

# slash if non-empty, suitable for immediately appending a filename

# the _XPG environment variable is not equal to 1 (one), the special

# without needing to append a separator.

# positional parameter $0, within a function call, is the name of the

# value returned in "$func_relative_path_result"

# function.

func_relative_path ()

progpath=$0

{

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

# The name of this program.

while :; do

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

# 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=.

break

;;

func_dirname $func_relative_path_tlibdir

func_relative_path_tlibdir=${func_dirname_result}

if test "x$func_relative_path_tlibdir" = x ; 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

func_relative_path_result=../$func_relative_path_result

;;

esac

done

# Now calculate path; take care to avoid doubling-up slashes.

# Make sure we have an absolute progpath for reexecution:

func_stripname '' '/' "$func_relative_path_result"

func_relative_path_result=$func_stripname_result

func_stripname '/' '/' "$func_relative_path_tcancelled"

if test "x$func_stripname_result" != x ; then

func_relative_path_result=${func_relative_path_result}/${func_stripname_result}

# Normalisation. If bindir is libdir, return empty string,

# else relative path ending with a slash; either way, target

# file name can be directly appended.

if test ! -z "$func_relative_path_result"; then

func_stripname './' '' "$func_relative_path_result/"

func_relative_path_result=$func_stripname_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=`$ECHO "$progpath" |$SED "$sed_dirname"`

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

progpath="$progdir/$progname"

progpath=$progdir/$progname

;;

save_IFS="$IFS"

_G_IFS=$IFS

IFS=${PATH_SEPARATOR-:}

for progdir in $PATH; do

IFS="$save_IFS"

IFS=$_G_IFS

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

done

IFS="$save_IFS"

IFS=$_G_IFS

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

progpath="$progdir/$progname"

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'

## Standard options. ##

## ----------------- ##

# Sed substitution that turns a string into a regex matching for the

# The following options affect the operation of the functions defined

# string literally.

# below, and should be set appropriately depending on run-time para-

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

# meters passed on the command line.

# 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/&\\

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...

# Categories 'all' and 'none' are always available. Append any others

# Echo program name prefixed message, along with the current mode

# you will pass as the first argument to func_warning from your own

# name if it has been set yet.

# code.

func_echo ()

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

{

$ECHO "$progname: ${opt_mode+$opt_mode: }$*"

$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`

}

require_term_colors=:

}

# func_verbose arg...

# Echo program name prefixed message in verbose mode only.

## ----------------- ##

func_verbose ()

## 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

# _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"

}

# 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"

}

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

{

$opt_verbose && func_echo ${1+"$@"}

$debug_cmd

# A bug in bash halts the script if the last line of a function

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

# fails when set -e is in force, so we need another command to

_G_delim=`expr "$2" : '$.$'`

# work around that:

case $_G_delim$_G_current_value$_G_delim in

*"$2$_G_delim"*) ;;

*) func_append "$@" ;;

esac

}

# func_echo_all arg...

# 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 "$@"`

}

# 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'

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_error arg...

# Echo program name prefixed message to standard error.

# func_echo_infix_1 INFIX ARG...

func_error ()

# ------------------------------

# Echo program name, followed by INFIX on the first line, with any

# additional lines not showing INFIX.

func_echo_infix_1 ()

{

$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2

$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"

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_warning arg...

# Echo program name prefixed warning message to standard error.

# func_error ARG...

func_warning ()

# -----------------

# Echo program name prefixed message to standard error.

func_error ()

{

$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2

$debug_cmd

# bash bug again:

$require_term_colors

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

}

# func_fatal_error arg...

# func_fatal_error ARG...

# -----------------------

# Echo program name prefixed message to standard error, and exit.

func_fatal_error ()

{

func_error ${1+"$@"}

$debug_cmd

func_error "$*"

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

# 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_mkdir_p directory-path

# 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`

}

# func_mkdir_p DIRECTORY-PATH

# ---------------------------

# Make sure the entire path to DIRECTORY-PATH is available.

func_mkdir_p ()

{

my_directory_path="$1"

$debug_cmd

my_dir_list=

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

_G_directory_path=$1

_G_dir_list=

# Protect directory names starting with `-'

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

case $my_directory_path in

-*) my_directory_path="./$my_directory_path" ;;

# 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 "$my_directory_path"; do

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.

my_dir_list="$my_directory_path:$my_dir_list"

_G_dir_list=$_G_directory_path:$_G_dir_list

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

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

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

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

my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`

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

done

my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`

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

save_mkdir_p_IFS="$IFS"; IFS=':'

func_mkdir_p_IFS=$IFS; IFS=:

for my_dir in $my_dir_list; do

for _G_dir in $_G_dir_list; do

IFS="$save_mkdir_p_IFS"

IFS=$func_mkdir_p_IFS

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

# 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 || :

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

done

IFS="$save_mkdir_p_IFS"

IFS=$func_mkdir_p_IFS

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

test -d "$my_directory_path" || \

test -d "$_G_directory_path" || \

func_fatal_error "Failed to create \`$1'"

func_fatal_error "Failed to create '$1'"

}

# func_mktempdir [string]

# func_mktempdir [BASENAME]

# -------------------------

# 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.

# given, BASENAME is the basename for that directory.

func_mktempdir ()

{

my_template="${TMPDIR-/tmp}/${1-$progname}"

$debug_cmd

if test "$opt_dry_run" = ":"; then

_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

my_tmpdir="${my_template}-$$"

_G_tmpdir=$_G_template-$$

else

# If mktemp works, use that first and foremost

my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

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

if test ! -d "$my_tmpdir"; then

if test ! -d "$_G_tmpdir"; then

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

my_tmpdir="${my_template}-${RANDOM-0}$$"

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

save_mktempdir_umask=`umask`

func_mktempdir_umask=`umask`

umask 0077

$MKDIR "$my_tmpdir"

$MKDIR "$_G_tmpdir"

umask $save_mktempdir_umask

umask $func_mktempdir_umask

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

test -d "$my_tmpdir" || \

test -d "$_G_tmpdir" || \

func_fatal_error "cannot create temporary directory \`$my_tmpdir'"

func_fatal_error "cannot create temporary directory '$_G_tmpdir'"

$ECHO "$my_tmpdir"

$ECHO "$_G_tmpdir"

}

# func_quote_for_eval arg

# func_normal_abspath PATH

# Aesthetically quote ARG to be evaled later.

# ------------------------

# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

# Remove doubled-up and trailing slashes, "." path components,

# is double-quoted, suitable for a subsequent eval, whereas

# and cancel out any ".." path components in PATH after making

# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

# it an absolute path.

# which are still active within double quotes backslashified.

func_normal_abspath ()

func_quote_for_eval ()

{

case $1 in

$debug_cmd

*[\\\`\"\$]*)

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

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

# Double-quote args containing shell metacharacters to delay

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

# word splitting, command substitution and and variable

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

# expansion for a subsequent eval.

_G_removedotparts=':dotsl

# Many Bourne shells cannot handle close brackets correctly

s|/\./|/|g

# in scan sets, so we specify it separately.

t dotsl

*[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

s|/\.$|/|'

func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

_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.

;;

func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

# 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=/

break

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_quote_for_expand arg

# 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=.

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

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"

# 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

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"

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"

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

*[\\\`\"]*)

my_arg=`$ECHO "$1" | $SED \

_G_arg=`$ECHO "$1" | $SED \

-e "$double_quote_subst" -e "$sed_double_backslash"` ;;

-e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;

my_arg="$1" ;;

_G_arg=$1 ;;

esac

case $my_arg in

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.

*[\[\~\#\^\&\*\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")

my_arg="\"$my_arg\""

_G_arg=\"$_G_arg\"

;;

esac

func_quote_for_expand_result="$my_arg"

func_quote_for_expand_result=$_G_arg

}

# func_show_eval cmd [fail_exp]

# func_stripname PREFIX SUFFIX NAME

# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is

# ---------------------------------

# 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

}

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

{

my_cmd="$1"

$debug_cmd

my_fail_exp="${2-:}"

${opt_silent-false} || {

_G_cmd=$1

func_quote_for_expand "$my_cmd"

_G_fail_exp=${2-':'}

eval "func_echo $func_quote_for_expand_result"

}

if ${opt_dry_run-false}; then :; else

func_quote_for_expand "$_G_cmd"

eval "$my_cmd"

eval "func_notquiet $func_quote_for_expand_result"

my_status=$?

if test "$my_status" -eq 0; then :; else

$opt_dry_run || {

eval "(exit $my_status); $my_fail_exp"

eval "$_G_cmd"

_G_status=$?

if test 0 -ne "$_G_status"; then

eval "(exit $_G_status); $_G_fail_exp"

}

# func_show_eval_locale cmd [fail_exp]

# func_show_eval_locale CMD [FAIL_EXP]

# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is

# ------------------------------------

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

{

my_cmd="$1"

$debug_cmd

my_fail_exp="${2-:}"

${opt_silent-false} || {

_G_cmd=$1

func_quote_for_expand "$my_cmd"

_G_fail_exp=${2-':'}

$opt_quiet || {

func_quote_for_expand "$_G_cmd"

eval "func_echo $func_quote_for_expand_result"

}

if ${opt_dry_run-false}; then :; else

$opt_dry_run || {

eval "$lt_user_locale

eval "$_G_user_locale

$my_cmd"

$_G_cmd"

my_status=$?

_G_status=$?

eval "$lt_safe_locale"

eval "$_G_safe_locale"

if test "$my_status" -eq 0; then :; else

if test 0 -ne "$_G_status"; then

eval "(exit $my_status); $my_fail_exp"

eval "(exit $_G_status); $_G_fail_exp"

}

# 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

$debug_cmd

[0-9]* | *[!a-zA-Z0-9_]*)

func_tr_sh_result=`$ECHO "$1" | $SED 's/^$[0-9]$/_\1/; s/[^a-zA-Z0-9_]/_/g'`

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_tr_sh_result=$1

;;

esac

}

# func_version

# func_verbose ARG...

# Echo version message to standard output and exit.

# -------------------

func_version ()

# Echo program name prefixed message in verbose mode only.

func_verbose ()

{

$opt_debug

$debug_cmd

$SED -n '/(C)/!b go

$opt_verbose && func_echo "$*"

:more

/\./!{

s/\n# / /

b more

}

:go

/^# '$PROGRAM' (GNU /,/# warranty; / {

s/^# //

s/^# *$//

s/$(C)$[ 0-9,-]*$ [1-9][0-9]*$/\1\2/

}' < "$progpath"

exit $?

}

# func_usage

# Echo short help message to standard output and exit.

# func_warn_and_continue ARG...

func_usage ()

# -----------------------------

# Echo program name prefixed warning message to standard error.

func_warn_and_continue ()

{

$opt_debug

$debug_cmd

$SED -n '/^# Usage:/,/^# *.*--help/ {

$require_term_colors

s/^# //

s/^# *$//

func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2

s/\$progname/'$progname'/

}' < "$progpath"

echo

$ECHO "run \`$progname --help | more' for full usage"

exit $?

}

# func_help [NOEXIT]

# Echo long help message to standard output and exit,

# func_warning CATEGORY ARG...

# unless 'noexit' is passed as argument.

# ----------------------------

# 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

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

{

$opt_debug

$debug_cmd

$SED -n '/^# Usage:/,/# Report bugs to/ {

func_usage_message

:print

$ECHO "$long_help_message"

s/^# //

exit 0

s/^# *$//

s*\$progname*'$progname'*

s*\$host*'"$host"'*

s*\$SHELL*'"$SHELL"'*

s*\$LTCC*'"$LTCC"'*

s*\$LTCFLAGS*'"$LTCFLAGS"'*

s*\$LD*'"$LD"'*

s/\$with_gnu_ld/'"$with_gnu_ld"'/

s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/

s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/

}

/^# .* home page:/b print

/^# General help using/b print

' < "$progpath"

ret=$?

if test -z "$1"; then

exit $ret

}

# func_missing_arg argname

# func_missing_arg ARGNAME

# ------------------------

# Echo program name prefixed message to standard error and set global

# exit_cmd.

func_missing_arg ()

{

$opt_debug

$debug_cmd

func_error "missing argument for $1."

func_error "Missing argument for '$1'."

exit_cmd=exit

}

# func_split_short_opt shortopt

# 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.

func_split_short_opt ()

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

{

my_sed_short_opt='1s/^$..$.*$/\1/;q'

$debug_cmd

my_sed_short_rest='1s/^..$.*$$/\1/;q'

func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`

func_usage_message

func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`

$ECHO "Run '$progname --help |${PAGER-more}' for full usage"

} # func_split_short_opt may be replaced by extended shell implementation

exit 0

}

# func_split_long_opt longopt

# func_usage_message

# Set func_split_long_opt_name and func_split_long_opt_arg shell

# ------------------

# variables after splitting LONGOPT at the `=' sign.

# Echo short help message to standard output.

func_split_long_opt ()

func_usage_message ()

{

my_sed_long_opt='1s/^$--[^=]*$=.*/\1/;q'

$debug_cmd

my_sed_long_arg='1s/^--[^=]*=//'

func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`

eval \$ECHO \""Usage: $usage"\"

func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`

echo

} # func_split_long_opt may be replaced by extended shell implementation

$SED -n 's|^# ||

/^Written by/{

x;p;x

}

/^Written by/q' < "$progpath"

echo

eval \$ECHO \""$usage_message"\"

}

exit_cmd=:

# 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

/\./!{

s|\n# | |

b more

}

:go

/^# Written by /,/# warranty; / {

s|^# ||

s|^# *$||

s|$(C)$[ 0-9,-]*[ ,-]$[1-9][0-9]* $|\1 \2|

}

/^# Written by / {

s|^# ||

}

/^warranty; /q' < "$progpath"

exit $?

}

magic="%%%MAGIC variable%%%"

# Local variables:

magic_exe="%%%MAGIC EXE variable%%%"

# 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:

# Global variables.

# Set a version string.

nonopt=

scriptversion='(GNU libtool) 2.4.6'

preserve_args=

lo2o="s/\\.lo\$/.${objext}/"

o2lo="s/\\.${objext}\$/.lo/"

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=

# func_append var value

# func_echo ARG...

# Append VALUE to the end of shell variable VAR.

# ----------------

func_append ()

# Libtool also displays the current mode in messages, so override

# funclib.sh func_echo with this custom definition.

func_echo ()

{

eval "${1}=\$${1}\${2}"

$debug_cmd

} # func_append may be replaced by extended shell implementation

# func_append_quoted var value

_G_message=$*

# Quote VALUE and append to the end of shell variable VAR, separated

# by a space.

func_append_quoted ()

{

func_quote_for_eval "${2}"

eval "${1}=\$${1}\\ \$func_quote_for_eval_result"

} # func_append_quoted may be replaced by extended shell implementation

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_arith arithmetic-term...

func_arith ()

# func_warning ARG...

# -------------------

# Libtool warnings are not categorized, so override funclib.sh

# func_warning with this simpler definition.

func_warning ()

{

func_arith_result=`expr "${@}"`

$debug_cmd

} # func_arith may be replaced by extended shell implementation

$warning_func ${1+"$@"}

}

# func_len string

# STRING may not start with a hyphen.

func_len ()

{

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

} # func_len may be replaced by extended shell implementation

## ---------------- ##

## Options parsing. ##

## ---------------- ##

# func_lo2o object

# Hook in the functions to make sure our own options are parsed during

func_lo2o ()

# the option parsing loop.

{

func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`

} # func_lo2o may be replaced by extended shell implementation

usage='$progpath [OPTION]... [MODE-ARG]...'

# func_xform libobj-or-source

# Short help message in response to '-h'.

func_xform ()

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

{

func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`

$debug_cmd

} # func_xform may be replaced by extended shell implementation

func_usage_message

$ECHO "$long_help_message

# func_fatal_configuration arg...

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|'`

}

# func_fatal_configuration ARG...

# -------------------------------

# Echo program name prefixed message to standard error, followed by

# a configuration failure hint, and exit.

func_fatal_configuration ()

{

func_error ${1+"$@"}

func__fatal_error ${1+"$@"} \

func_error "See the $PACKAGE documentation for more information."

"See the $PACKAGE documentation for more information." \

func_fatal_error "Fatal configuration error."

"Fatal configuration error."

}

# func_config

# -----------

# Display the configuration for all the tags in this script.

func_config ()

{

Line 915 func_config ()

Line 2149 func_config ()

exit $?

}

# func_features

# -------------

# Display the features supported by this script.

func_features ()

{

echo "host: $host"

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

echo "enable shared libraries"

else

echo "disable shared libraries"

if test "$build_old_libs" = yes; then

if test yes = "$build_old_libs"; then

echo "enable static libraries"

else

echo "disable static libraries"

Line 934 func_features ()

Line 2170 func_features ()

exit $?

}

# func_enable_tag tagname

# 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"

tagname=$1

re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"

re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"

sed_extractcf="/$re_begincf/,/$re_endcf/p"

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"

;;

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

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

exit $EXIT_MISMATCH

}

# Shorthand for --mode=foo, only valid as the first argument

# libtool_options_prep [ARG]...

case $1 in

# -----------------------------

clean|clea|cle|cl)

# Preparation for options parsed by libtool.

shift; set dummy --mode clean ${1+"$@"}; shift

libtool_options_prep ()

;;

{

compile|compil|compi|comp|com|co|c)

$debug_mode

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

;;

shift; set dummy --mode uninstall ${1+"$@"}; shift

;;

esac

# 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=

# Option defaults:

# Shorthand for --mode=foo, only valid as the first argument

opt_debug=:

case $1 in

opt_dry_run=false

clean|clea|cle|cl)

opt_config=false

shift; set dummy --mode clean ${1+"$@"}; shift

opt_preserve_dup_deps=false

;;

opt_features=false

compile|compil|compi|comp|com|co|c)

opt_finish=false

shift; set dummy --mode compile ${1+"$@"}; shift

opt_help=false

;;

opt_help_all=false

execute|execut|execu|exec|exe|ex|e)

opt_silent=:

shift; set dummy --mode execute ${1+"$@"}; shift

opt_warning=:

;;

opt_verbose=:

finish|finis|fini|fin|fi|f)

opt_silent=false

shift; set dummy --mode finish ${1+"$@"}; shift

opt_verbose=false

;;

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

;;

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

# Parse options once, thoroughly. This comes as soon as possible in the

# script to make things like `--version' happen as quickly as we can.

# libtool_parse_options [ARG]...

# ---------------------------------

# Provide handling for libtool specific options.

libtool_parse_options ()

{

# this just eases exit handling

$debug_cmd

while test $# -gt 0; do

opt="$1"

shift

case $opt in

--debug|-x) opt_debug='set -x'

func_echo "enabling shell trace mode"

$opt_debug

;;

--dry-run|--dryrun|-n)

opt_dry_run=:

;;

--config)

opt_config=:

func_config

;;

--dlopen|-dlopen)

optarg="$1"

opt_dlopen="${opt_dlopen+$opt_dlopen

}$optarg"

shift

;;

--preserve-dup-deps)

opt_preserve_dup_deps=:

;;

--features)

opt_features=:

func_features

;;

--finish)

opt_finish=:

set dummy --mode finish ${1+"$@"}; shift

;;

--help)

opt_help=:

;;

--help-all)

opt_help_all=:

opt_help=': help-all'

;;

--mode)

test $# = 0 && func_missing_arg $opt && break

optarg="$1"

opt_mode="$optarg"

case $optarg in

# Valid mode arguments:

# Catch anything else as an error

# Perform our own loop to consume as many options as possible in

*) func_error "invalid argument for $opt"

# each iteration.

exit_cmd=exit

while test $# -gt 0; do

break

_G_opt=$1

;;

shift

esac

case $_G_opt in

shift

--dry-run|--dryrun|-n)

;;

opt_dry_run=:

--no-silent|--no-quiet)

;;

opt_silent=false

func_append preserve_args " $opt"

;;

--no-warning|--no-warn)

opt_warning=false

func_append preserve_args " $opt"

;;

--no-verbose)

opt_verbose=false

func_append preserve_args " $opt"

;;

--silent|--quiet)

opt_silent=:

func_append preserve_args " $opt"

opt_verbose=false

;;

--verbose|-v)

opt_verbose=:

func_append preserve_args " $opt"

opt_silent=false

;;

--tag)

test $# = 0 && func_missing_arg $opt && break

optarg="$1"

opt_tag="$optarg"

func_append preserve_args " $opt $optarg"

func_enable_tag "$optarg"

shift

;;

-\?|-h) func_usage ;;

--config) func_config ;;

--help) func_help ;;

--version) func_version ;;

# Separate optargs to long options:

--dlopen|-dlopen)

--*=*)

opt_dlopen="${opt_dlopen+$opt_dlopen

func_split_long_opt "$opt"

}$1"

set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}

shift

;;

# Separate non-argument short options:

--preserve-dup-deps)

-\?*|-h*|-n*|-v*)

opt_preserve_dup_deps=: ;;

func_split_short_opt "$opt"

set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}

shift

;;

--) break ;;

--features) func_features ;;

-*) func_fatal_help "unrecognized option \`$opt'" ;;

*) set dummy "$opt" ${1+"$@"}; shift; break ;;

esac

done

# Validate options:

--finish) set dummy --mode finish ${1+"$@"}; shift ;;

# save first non-option argument

--help) opt_help=: ;;

if test "$#" -gt 0; then

nonopt="$opt"

shift

# preserve --debug

--help-all) opt_help=': help-all' ;;

test "$opt_debug" = : || func_append preserve_args " --debug"

case $host in

--mode) test $# = 0 && func_missing_arg $_G_opt && break

*cygwin* | *mingw* | *pw32* | *cegcc*)

opt_mode=$1

# don't eliminate duplications in $postdeps and $predeps

case $1 in

opt_duplicate_compiler_generated_deps=:

# Valid mode arguments:

;;

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

;;

esac

$opt_help || {

# Catch anything else as an error

# Sanity checks first:

*) func_error "invalid argument for $_G_opt"

func_check_version_match

exit_cmd=exit

break

;;

esac

shift

;;

if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then

--no-silent|--no-quiet)

func_fatal_configuration "not configured to build any kind of library"

opt_quiet=false

func_append preserve_args " $_G_opt"

;;

# Darwin sucks

--no-warnings|--no-warning|--no-warn)

eval std_shrext=\"$shrext_cmds\"

opt_warning=false

func_append preserve_args " $_G_opt"

;;

# Only execute mode is allowed to have -dlopen flags.

--no-verbose)

if test -n "$opt_dlopen" && test "$opt_mode" != execute; then

opt_verbose=false

func_error "unrecognized option \`-dlopen'"

func_append preserve_args " $_G_opt"

$ECHO "$help" 1>&2

;;

exit $EXIT_FAILURE

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

# Change the help message to a mode-specific one.

# preserve --debug

generic_help="$help"

test : = "$debug_cmd" || func_append preserve_args " --debug"

help="Try \`$progname --help --mode=$opt_mode' for more information."

}

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

# don't eliminate duplications in $postdeps and $predeps

opt_duplicate_compiler_generated_deps=:

;;

opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps

;;

esac

# Bail if the options were screwed

$opt_help || {

$exit_cmd $EXIT_FAILURE

# 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

# 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

_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.

# 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 \

$SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p

| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1

}

# func_lalib_unsafe_p file

# True iff FILE is a libtool `.la' library or `.lo' object 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.

# fatal anyway. Works if 'file' does not exist.

func_lalib_unsafe_p ()

{

lalib_p=no

Line 1249 func_lalib_unsafe_p ()

Line 2521 func_lalib_unsafe_p ()

for lalib_p_l in 1 2 3 4

read lalib_p_line

case "$lalib_p_line" in

case $lalib_p_line in

\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;

esac

done

exec 0<&5 5<&-

test "$lalib_p" = yes

test yes = "$lalib_p"

}

# func_ltwrapper_script_p file

Line 1264 func_lalib_unsafe_p ()

Line 2536 func_lalib_unsafe_p ()

# determined imposters.

func_ltwrapper_script_p ()

{

func_lalib_p "$1"

test -f "$1" &&

$lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p

}

# func_ltwrapper_executable_p file

Line 1289 func_ltwrapper_scriptname ()

Line 2562 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_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper

}

# func_ltwrapper_p file

Line 1308 func_ltwrapper_p ()

Line 2581 func_ltwrapper_p ()

# FAIL_CMD may read-access the current command in variable CMD!

func_execute_cmds ()

{

$opt_debug

$debug_cmd

save_ifs=$IFS; IFS='~'

for cmd in $1; do

IFS=$save_ifs

IFS=$sp$nl

eval cmd=\"$cmd\"

IFS=$save_ifs

func_show_eval "$cmd" "${2-:}"

done

IFS=$save_ifs

Line 1324 func_execute_cmds ()

Line 2599 func_execute_cmds ()

# 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.

# 'FILE.' does not work on cygwin managed mounts.

func_source ()

{

$opt_debug

$debug_cmd

case $1 in

*/* | *\\*) . "$1" ;;

*) . "./$1" ;;

Line 1354 func_resolve_sysroot ()

Line 2630 func_resolve_sysroot ()

# store the result into func_replace_sysroot_result.

func_replace_sysroot ()

{

case "$lt_sysroot:$1" in

case $lt_sysroot:$1 in

?*:"$lt_sysroot"*)

func_stripname "$lt_sysroot" '' "$1"

func_replace_sysroot_result="=$func_stripname_result"

func_replace_sysroot_result='='$func_stripname_result

;;

# Including no sysroot.

Line 1374 func_replace_sysroot ()

Line 2650 func_replace_sysroot ()

# arg is usually of the form 'gcc ...'

func_infer_tag ()

{

$opt_debug

$debug_cmd

# FreeBSD-specific: where we install compilers with non-standard names

tag_compilers_CC="*cc cc* *gcc gcc* clang"

tag_compilers_CXX="*c++ c++* *g++ g++* clang++"

base_compiler=`set -- "$@"; echo $1`

# If $tagname isn't set, then try to infer if the default "CC" tag applies

if test -z "$tagname"; then

for zp in $tag_compilers_CC; do

case $base_compiler in

$zp) tagname="CC"; break;;

esac

done

if test -n "$available_tags" && test -z "$tagname"; then

CC_quoted=

for arg in $CC; do

Line 1408 func_infer_tag ()

Line 2670 func_infer_tag ()

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`"

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.

Line 1426 func_infer_tag ()

Line 2688 func_infer_tag ()

break

;;

esac

# FreeBSD-specific: try compilers based on inferred tag

if test -z "$tagname"; then

eval "tag_compilers=\$tag_compilers_${z}"

if test -n "$tag_compilers"; then

for zp in $tag_compilers; do

case $base_compiler in

$zp) tagname=$z; break;;

esac

done

if test -n "$tagname"; then

break

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'"

func_fatal_error "specify a tag with '--tag'"

# else

# func_verbose "using $tagname tagged configuration"

Line 1464 func_infer_tag ()

Line 2711 func_infer_tag ()

# but don't create it if we're doing a dry run.

func_write_libtool_object ()

{

write_libobj=${1}

write_libobj=$1

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

write_lobj=\'${2}\'

write_lobj=\'$2\'

else

write_lobj=none

if test "$build_old_libs" = yes; then

if test yes = "$build_old_libs"; then

write_oldobj=\'${3}\'

write_oldobj=\'$3\'

else

write_oldobj=none

Line 1480 func_write_libtool_object ()

Line 2727 func_write_libtool_object ()

$opt_dry_run || {

cat >${write_libobj}T <<EOF

# $write_libobj - a libtool object file

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

# Generated by $PROGRAM (GNU $PACKAGE) $VERSION

# Please DO NOT delete this file!

# It is necessary for linking the library.

Line 1492 pic_object=$write_lobj

Line 2739 pic_object=$write_lobj

non_pic_object=$write_oldobj

EOF

$MV "${write_libobj}T" "${write_libobj}"

$MV "${write_libobj}T" "$write_libobj"

}

Line 1512 EOF

Line 2759 EOF

# be empty on error (or when ARG is empty)

func_convert_core_file_wine_to_w32 ()

{

$opt_debug

$debug_cmd

func_convert_core_file_wine_to_w32_result="$1"

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

Line 1521 func_convert_core_file_wine_to_w32 ()

Line 2769 func_convert_core_file_wine_to_w32 ()

# *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

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 "$lt_sed_naive_backslashify"`

$SED -e "$sed_naive_backslashify"`

else

func_convert_core_file_wine_to_w32_result=

Line 1544 func_convert_core_file_wine_to_w32 ()

Line 2792 func_convert_core_file_wine_to_w32 ()

# are convertible, then the result may be empty.

func_convert_core_path_wine_to_w32 ()

{

$opt_debug

$debug_cmd

# unfortunately, winepath doesn't convert paths, only file names

func_convert_core_path_wine_to_w32_result=""

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 -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"

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"

Line 1584 func_convert_core_path_wine_to_w32 ()

Line 2833 func_convert_core_path_wine_to_w32 ()

# environment variable; do not put it in $PATH.

func_cygpath ()

{

$opt_debug

$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

Line 1593 func_cygpath ()

Line 2843 func_cygpath ()

else

func_cygpath_result=

func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"

func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"

}

#end: func_cygpath

Line 1604 func_cygpath ()

Line 2854 func_cygpath ()

# result in func_convert_core_msys_to_w32_result.

func_convert_core_msys_to_w32 ()

{

$opt_debug

$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 "$lt_sed_naive_backslashify"`

$SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`

}

#end: func_convert_core_msys_to_w32

Line 1618 func_convert_core_msys_to_w32 ()

Line 2869 func_convert_core_msys_to_w32 ()

# func_to_host_file_result to ARG1).

func_convert_file_check ()

{

$opt_debug

$debug_cmd

if test -z "$2" && test -n "$1" ; then

if test -z "$2" && test -n "$1"; then

func_error "Could not determine host file name corresponding to"

func_error " \`$1'"

func_error " '$1'"

func_error "Continuing, but uninstalled executables may not work."

# Fallback:

func_to_host_file_result="$1"

func_to_host_file_result=$1

}

# end func_convert_file_check

Line 1636 func_convert_file_check ()

Line 2888 func_convert_file_check ()

# func_to_host_file_result to a simplistic fallback value (see below).

func_convert_path_check ()

{

$opt_debug

$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 " '$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.

Line 1648 func_convert_path_check ()

Line 2901 func_convert_path_check ()

func_to_host_path_result=`echo "$3" |

$SED -e "$lt_replace_pathsep_chars"`

else

func_to_host_path_result="$3"

func_to_host_path_result=$3

}

Line 1660 func_convert_path_check ()

Line 2913 func_convert_path_check ()

# and appending REPL if ORIG matches BACKPAT.

func_convert_path_front_back_pathsep ()

{

$opt_debug

$debug_cmd

case $4 in

$1 ) func_to_host_path_result="$3$func_to_host_path_result"

$1 ) func_to_host_path_result=$3$func_to_host_path_result

;;

esac

case $4 in

Line 1676 func_convert_path_front_back_pathsep ()

Line 2930 func_convert_path_front_back_pathsep ()

##################################################

# $build to $host FILE NAME CONVERSION FUNCTIONS #

##################################################

# invoked via `$to_host_file_cmd ARG'

# invoked via '$to_host_file_cmd ARG'

# In each case, ARG is the path to be converted from $build to $host format.

# Result will be available in $func_to_host_file_result.

Line 1687 func_convert_path_front_back_pathsep ()

Line 2941 func_convert_path_front_back_pathsep ()

# in func_to_host_file_result.

func_to_host_file ()

{

$opt_debug

$debug_cmd

$to_host_file_cmd "$1"

}

# end func_to_host_file

Line 1699 func_to_host_file ()

Line 2954 func_to_host_file ()

# in (the comma separated) LAZY, no conversion takes place.

func_to_tool_file ()

{

$opt_debug

$debug_cmd

case ,$2, in

*,"$to_tool_file_cmd",*)

func_to_tool_file_result=$1

Line 1717 func_to_tool_file ()

Line 2973 func_to_tool_file ()

# Copy ARG to func_to_host_file_result.

func_convert_file_noop ()

{

func_to_host_file_result="$1"

func_to_host_file_result=$1

}

# end func_convert_file_noop

Line 1728 func_convert_file_noop ()

Line 2984 func_convert_file_noop ()

# func_to_host_file_result.

func_convert_file_msys_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_file_result="$1"

func_to_host_file_result=$1

if test -n "$1"; then

func_convert_core_msys_to_w32 "$1"

func_to_host_file_result="$func_convert_core_msys_to_w32_result"

func_to_host_file_result=$func_convert_core_msys_to_w32_result

func_convert_file_check "$1" "$func_to_host_file_result"

}

Line 1744 func_convert_file_msys_to_w32 ()

Line 3001 func_convert_file_msys_to_w32 ()

# func_to_host_file_result.

func_convert_file_cygwin_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_file_result="$1"

func_to_host_file_result=$1

if test -n "$1"; then

# because $build is cygwin, we call "the" cygpath in $PATH; no need to use

# LT_CYGPATH in this case.

Line 1761 func_convert_file_cygwin_to_w32 ()

Line 3019 func_convert_file_cygwin_to_w32 ()

# and a working winepath. Returns result in func_to_host_file_result.

func_convert_file_nix_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_file_result="$1"

func_to_host_file_result=$1

if test -n "$1"; then

func_convert_core_file_wine_to_w32 "$1"

func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"

func_to_host_file_result=$func_convert_core_file_wine_to_w32_result

func_convert_file_check "$1" "$func_to_host_file_result"

}

Line 1777 func_convert_file_nix_to_w32 ()

Line 3036 func_convert_file_nix_to_w32 ()

# Returns result in func_to_host_file_result.

func_convert_file_msys_to_cygwin ()

{

$opt_debug

$debug_cmd

func_to_host_file_result="$1"

func_to_host_file_result=$1

if test -n "$1"; then

func_convert_core_msys_to_w32 "$1"

func_cygpath -u "$func_convert_core_msys_to_w32_result"

func_to_host_file_result="$func_cygpath_result"

func_to_host_file_result=$func_cygpath_result

func_convert_file_check "$1" "$func_to_host_file_result"

}

Line 1795 func_convert_file_msys_to_cygwin ()

Line 3055 func_convert_file_msys_to_cygwin ()

# in func_to_host_file_result.

func_convert_file_nix_to_cygwin ()

{

$opt_debug

$debug_cmd

func_to_host_file_result="$1"

func_to_host_file_result=$1

if test -n "$1"; then

# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.

func_convert_core_file_wine_to_w32 "$1"

func_cygpath -u "$func_convert_core_file_wine_to_w32_result"

func_to_host_file_result="$func_cygpath_result"

func_to_host_file_result=$func_cygpath_result

func_convert_file_check "$1" "$func_to_host_file_result"

}

Line 1811 func_convert_file_nix_to_cygwin ()

Line 3072 func_convert_file_nix_to_cygwin ()

#############################################

# $build to $host PATH CONVERSION FUNCTIONS #

#############################################

# invoked via `$to_host_path_cmd ARG'

# invoked via '$to_host_path_cmd ARG'

# In each case, ARG is the path to be converted from $build to $host format.

# The result will be available in $func_to_host_path_result.

Line 1835 func_convert_file_nix_to_cygwin ()

Line 3096 func_convert_file_nix_to_cygwin ()

to_host_path_cmd=

func_init_to_host_path_cmd ()

{

$opt_debug

$debug_cmd

if test -z "$to_host_path_cmd"; then

func_stripname 'func_convert_file_' '' "$to_host_file_cmd"

to_host_path_cmd="func_convert_path_${func_stripname_result}"

to_host_path_cmd=func_convert_path_$func_stripname_result

}

Line 1848 func_init_to_host_path_cmd ()

Line 3110 func_init_to_host_path_cmd ()

# in func_to_host_path_result.

func_to_host_path ()

{

$opt_debug

$debug_cmd

func_init_to_host_path_cmd

$to_host_path_cmd "$1"

}

Line 1859 func_to_host_path ()

Line 3122 func_to_host_path ()

# Copy ARG to func_to_host_path_result.

func_convert_path_noop ()

{

func_to_host_path_result="$1"

func_to_host_path_result=$1

}

# end func_convert_path_noop

Line 1870 func_convert_path_noop ()

Line 3133 func_convert_path_noop ()

# func_to_host_path_result.

func_convert_path_msys_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_path_result="$1"

func_to_host_path_result=$1

if test -n "$1"; then

# Remove leading and trailing path separator characters from ARG. MSYS

# behavior is inconsistent here; cygpath turns them into '.;' and ';.';

Line 1879 func_convert_path_msys_to_w32 ()

Line 3143 func_convert_path_msys_to_w32 ()

func_stripname : : "$1"

func_to_host_path_tmp1=$func_stripname_result

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

func_to_host_path_result="$func_convert_core_msys_to_w32_result"

func_to_host_path_result=$func_convert_core_msys_to_w32_result

func_convert_path_check : ";" \

"$func_to_host_path_tmp1" "$func_to_host_path_result"

func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"

Line 1893 func_convert_path_msys_to_w32 ()

Line 3157 func_convert_path_msys_to_w32 ()

# func_to_host_file_result.

func_convert_path_cygwin_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_path_result="$1"

func_to_host_path_result=$1

if test -n "$1"; then

# See func_convert_path_msys_to_w32:

func_stripname : : "$1"

Line 1913 func_convert_path_cygwin_to_w32 ()

Line 3178 func_convert_path_cygwin_to_w32 ()

# a working winepath. Returns result in func_to_host_file_result.

func_convert_path_nix_to_w32 ()

{

$opt_debug

$debug_cmd

func_to_host_path_result="$1"

func_to_host_path_result=$1

if test -n "$1"; then

# See func_convert_path_msys_to_w32:

func_stripname : : "$1"

func_to_host_path_tmp1=$func_stripname_result

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"

func_to_host_path_result=$func_convert_core_path_wine_to_w32_result

func_convert_path_check : ";" \

"$func_to_host_path_tmp1" "$func_to_host_path_result"

func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"

Line 1934 func_convert_path_nix_to_w32 ()

Line 3200 func_convert_path_nix_to_w32 ()

# Returns result in func_to_host_file_result.

func_convert_path_msys_to_cygwin ()

{

$opt_debug

$debug_cmd

func_to_host_path_result="$1"

func_to_host_path_result=$1

if test -n "$1"; then

# See func_convert_path_msys_to_w32:

func_stripname : : "$1"

func_to_host_path_tmp1=$func_stripname_result

func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"

func_cygpath -u -p "$func_convert_core_msys_to_w32_result"

func_to_host_path_result="$func_cygpath_result"

func_to_host_path_result=$func_cygpath_result

func_convert_path_check : : \

"$func_to_host_path_tmp1" "$func_to_host_path_result"

func_convert_path_front_back_pathsep ":*" "*:" : "$1"

Line 1957 func_convert_path_msys_to_cygwin ()

Line 3224 func_convert_path_msys_to_cygwin ()

# func_to_host_file_result.

func_convert_path_nix_to_cygwin ()

{

$opt_debug

$debug_cmd

func_to_host_path_result="$1"

func_to_host_path_result=$1

if test -n "$1"; then

# Remove leading and trailing path separator characters from

# ARG. msys behavior is inconsistent here, cygpath turns them

Line 1967 func_convert_path_nix_to_cygwin ()

Line 3235 func_convert_path_nix_to_cygwin ()

func_to_host_path_tmp1=$func_stripname_result

func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"

func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"

func_to_host_path_result="$func_cygpath_result"

func_to_host_path_result=$func_cygpath_result

func_convert_path_check : : \

"$func_to_host_path_tmp1" "$func_to_host_path_result"

func_convert_path_front_back_pathsep ":*" "*:" : "$1"

Line 1976 func_convert_path_nix_to_cygwin ()

Line 3244 func_convert_path_nix_to_cygwin ()

# end func_convert_path_nix_to_cygwin

# func_dll_def_p FILE

# True iff FILE is a Windows DLL '.def' file.

# Keep in sync with _LT_DLL_DEF_P in libtool.m4

func_dll_def_p ()

{

$debug_cmd

func_dll_def_p_tmp=`$SED -n \

-e 's/^[ ]*//' \

-e '/^$;.*$*$/d' \

-e 's/^$EXPORTS\|LIBRARY$$[ ].*$*$/DEF/p' \

-e q \

"$1"`

test DEF = "$func_dll_def_p_tmp"

}

# func_mode_compile arg...

func_mode_compile ()

{

$opt_debug

$debug_cmd

# Get the compilation command and the source file.

base_compile=

srcfile="$nonopt" # always keep a non-empty value in "srcfile"

srcfile=$nonopt # always keep a non-empty value in "srcfile"

suppress_opt=yes

suppress_output=

arg_mode=normal

Line 1995 func_mode_compile ()

Line 3281 func_mode_compile ()

case $arg_mode in

arg )

# do not "continue". Instead, add this to base_compile

lastarg="$arg"

lastarg=$arg

arg_mode=normal

;;

target )

libobj="$arg"

libobj=$arg

arg_mode=normal

continue

;;

Line 2010 func_mode_compile ()

Line 3296 func_mode_compile ()

case $arg in

-o)

test -n "$libobj" && \

func_fatal_error "you cannot specify \`-o' more than once"

func_fatal_error "you cannot specify '-o' more than once"

arg_mode=target

continue

;;

Line 2039 func_mode_compile ()

Line 3325 func_mode_compile ()

func_stripname '-Wc,' '' "$arg"

args=$func_stripname_result

lastarg=

save_ifs="$IFS"; IFS=','

save_ifs=$IFS; IFS=,

for arg in $args; do

IFS="$save_ifs"

IFS=$save_ifs

func_append_quoted lastarg "$arg"

done

IFS="$save_ifs"

IFS=$save_ifs

func_stripname ' ' '' "$lastarg"

lastarg=$func_stripname_result

Line 2057 func_mode_compile ()

Line 3343 func_mode_compile ()

# Accept the current argument as the source file.

# The previous "srcfile" becomes the current argument.

lastarg="$srcfile"

lastarg=$srcfile

srcfile="$arg"

srcfile=$arg

;;

esac # case $arg

;;

Line 2073 func_mode_compile ()

Line 3359 func_mode_compile ()

func_fatal_error "you must specify an argument for -Xcompile"

;;

target)

func_fatal_error "you must specify a target with \`-o'"

func_fatal_error "you must specify a target with '-o'"

;;

# Get the name of the library object.

test -z "$libobj" && {

func_basename "$srcfile"

libobj="$func_basename_result"

libobj=$func_basename_result

}

;;

esac

Line 2099 func_mode_compile ()

Line 3385 func_mode_compile ()

case $libobj in

*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;

func_fatal_error "cannot determine name of library object from \`$libobj'"

func_fatal_error "cannot determine name of library object from '$libobj'"

;;

esac

Line 2108 func_mode_compile ()

Line 3394 func_mode_compile ()

for arg in $later; do

case $arg in

-shared)

test "$build_libtool_libs" != yes && \

test yes = "$build_libtool_libs" \

func_fatal_configuration "can not build a shared library"

|| func_fatal_configuration "cannot build a shared library"

build_old_libs=no

continue

;;

Line 2135 func_mode_compile ()

Line 3421 func_mode_compile ()

func_quote_for_eval "$libobj"

test "X$libobj" != "X$func_quote_for_eval_result" \

&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \

&& func_warning "libobj name \`$libobj' may not contain shell special characters."

&& func_warning "libobj name '$libobj' may not contain shell special characters."

func_dirname_and_basename "$obj" "/" ""

objname="$func_basename_result"

objname=$func_basename_result

xdir="$func_dirname_result"

xdir=$func_dirname_result

lobj=${xdir}$objdir/$objname

lobj=$xdir$objdir/$objname

test -z "$base_compile" && \

func_fatal_help "you must specify a compilation command"

# Delete any leftover library objects.

if test "$build_old_libs" = yes; then

if test yes = "$build_old_libs"; then

removelist="$obj $lobj $libobj ${libobj}T"

else

removelist="$lobj $libobj ${libobj}T"

Line 2157 func_mode_compile ()

Line 3443 func_mode_compile ()

pic_mode=default

;;

esac

if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then

# non-PIC code in shared libraries is not supported

pic_mode=default

# Calculate the filename of the output object if compiler does

# not support -o with -c

if test "$compiler_c_o" = no; then

if test no = "$compiler_c_o"; then

output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}

output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext

lockfile="$output_obj.lock"

lockfile=$output_obj.lock

else

output_obj=

need_locks=no

Line 2175 func_mode_compile ()

Line 3461 func_mode_compile ()

# Lock this critical section if it is needed

# We use this script file to make the link, it avoids creating a new file

if test "$need_locks" = yes; then

if test yes = "$need_locks"; then

until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do

func_echo "Waiting for $lockfile to be removed"

sleep 2

done

elif test "$need_locks" = warn; then

elif test warn = "$need_locks"; then

if test -f "$lockfile"; then

$ECHO "\

*** ERROR, $lockfile exists and contains:

Line 2188 func_mode_compile ()

Line 3474 func_mode_compile ()

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

your compiler does not support '-c' and '-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

Line 2210 compiler."

Line 3496 compiler."

qsrcfile=$func_quote_for_eval_result

# Only build a PIC object if we are building libtool libraries.

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

# Without this assignment, base_compile gets emptied.

fbsd_hideous_sh_bug=$base_compile

if test "$pic_mode" != no; then

if test no != "$pic_mode"; then

command="$base_compile $qsrcfile $pic_flag"

else

# Don't build PIC code

Line 2231 compiler."

Line 3517 compiler."

func_show_eval_locale "$command" \

'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'

if test "$need_locks" = warn &&

if test warn = "$need_locks" &&

test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

$ECHO "\

*** ERROR, $lockfile contains:

Line 2242 $srcfile

Line 3528 $srcfile

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

your compiler does not support '-c' and '-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

Line 2258 compiler."

Line 3544 compiler."

# Allow error messages only from the first compilation.

if test "$suppress_opt" = yes; then

if test yes = "$suppress_opt"; then

suppress_output=' >/dev/null 2>&1'

# Only build a position-dependent object if we build old libraries.

if test "$build_old_libs" = yes; then

if test yes = "$build_old_libs"; then

if test "$pic_mode" != yes; then

if test yes != "$pic_mode"; then

# Don't build PIC code

command="$base_compile $qsrcfile$pie_flag"

else

command="$base_compile $qsrcfile $pic_flag"

if test "$compiler_c_o" = yes; then

if test yes = "$compiler_c_o"; then

func_append command " -o $obj"

Line 2280 compiler."

Line 3566 compiler."

func_show_eval_locale "$command" \

'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'

if test "$need_locks" = warn &&

if test warn = "$need_locks" &&

test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

$ECHO "\

*** ERROR, $lockfile contains:

Line 2291 $srcfile

Line 3577 $srcfile

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together. If you

your compiler does not support '-c' and '-o' together. If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

Line 2311 compiler."

Line 3597 compiler."

func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

# Unlock the critical section if it was locked

if test "$need_locks" != no; then

if test no != "$need_locks"; then

removelist=$lockfile

$RM "$lockfile"

Line 2321 compiler."

Line 3607 compiler."

}

$opt_help || {

test "$opt_mode" = compile && func_mode_compile ${1+"$@"}

test compile = "$opt_mode" && func_mode_compile ${1+"$@"}

}

func_mode_help ()

Line 2341 func_mode_help ()

Line 3627 func_mode_help ()

Remove files from the build directory.

RM is the name of the program to use to delete files associated with each FILE

(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed

to RM.

If FILE is a libtool library, object or program, all the files associated

Line 2360 This mode accepts the following additional options:

Line 3646 This mode accepts the following additional options:

-no-suppress do not suppress compiler output for multiple passes

-prefer-pic try to build PIC objects only

-prefer-non-pic try to build non-PIC objects only

-shared do not build a \`.o' file suitable for static linking

-shared do not build a '.o' file suitable for static linking

-static only build a \`.o' file suitable for static linking

-static only build a '.o' file suitable for static linking

-Wc,FLAG pass FLAG directly to the compiler

COMPILE-COMMAND is a command to be used in creating a \`standard' object file

COMPILE-COMMAND is a command to be used in creating a 'standard' object file

from the given SOURCEFILE.

The output file name is determined by removing the directory component from

SOURCEFILE, then substituting the C source code suffix \`.c' with the

SOURCEFILE, then substituting the C source code suffix '.c' with the

library object suffix, \`.lo'."

library object suffix, '.lo'."

;;

execute)

Line 2382 This mode accepts the following additional options:

Line 3668 This mode accepts the following additional options:

-dlopen FILE add the directory containing FILE to the library path

This mode sets the library path environment variable according to \`-dlopen'

This mode sets the library path environment variable according to '-dlopen'

flags.

If any of the ARGS are libtool executable wrappers, then they are translated

Line 2401 Complete the installation of libtool libraries.

Line 3687 Complete the installation of libtool libraries.

Each LIBDIR is a directory that contains libtool libraries.

The commands that this mode executes may require superuser privileges. Use

the \`--dry-run' option if you just want to see what would be executed."

the '--dry-run' option if you just want to see what would be executed."

;;

install)

Line 2411 the \`--dry-run' option if you just want to see what w

Line 3697 the \`--dry-run' option if you just want to see what w

Install executables or libraries.

INSTALL-COMMAND is the installation command. The first component should be

either the \`install' or \`cp' program.

either the 'install' or 'cp' program.

The following components of INSTALL-COMMAND are treated specially:

Line 2437 The following components of LINK-COMMAND are treated s

Line 3723 The following components of LINK-COMMAND are treated s

-avoid-version do not add a version suffix if possible

-bindir BINDIR specify path to binaries directory (for systems where

libraries must be found in the PATH setting at runtime)

-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime

-dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime

-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols

-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)

-export-symbols SYMFILE

Line 2451 The following components of LINK-COMMAND are treated s

Line 3737 The following components of LINK-COMMAND are treated s

-no-install link a not-installable executable

-no-undefined declare that a library does not refer to external symbols

-o OUTPUT-FILE create OUTPUT-FILE from the specified objects

-objectlist FILE Use a list of object files found in FILE to specify objects

-objectlist FILE use a list of object files found in FILE to specify objects

-os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes)

-precious-files-regex REGEX

don't remove output files matching REGEX

-release RELEASE specify package release information

Line 2471 The following components of LINK-COMMAND are treated s

Line 3758 The following components of LINK-COMMAND are treated s

-Xlinker FLAG pass linker-specific FLAG directly to the linker

-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)

All other options (arguments beginning with \`-') are ignored.

All other options (arguments beginning with '-') are ignored.

Every other argument is treated as a filename. Files ending in \`.la' are

Every other argument is treated as a filename. Files ending in '.la' are

treated as uninstalled libtool libraries, other files are standard or library

object files.

If the OUTPUT-FILE ends in \`.la', then a libtool library is created,

If the OUTPUT-FILE ends in '.la', then a libtool library is created,

only library objects (\`.lo' files) may be specified, and \`-rpath' is

only library objects ('.lo' files) may be specified, and '-rpath' is

required, except when creating a convenience library.

If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created

If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created

using \`ar' and \`ranlib', or on Windows using \`lib'.

using 'ar' and 'ranlib', or on Windows using 'lib'.

If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file

If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file

is created, otherwise an executable program is created."

;;

Line 2495 is created, otherwise an executable program is created

Line 3782 is created, otherwise an executable program is created

Remove libraries from an installation directory.

RM is the name of the program to use to delete files associated with each FILE

(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed

(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed

to RM.

If FILE is a libtool library, all the files associated with it are deleted.

Line 2503 Otherwise, only FILE itself is deleted using RM."

Line 3790 Otherwise, only FILE itself is deleted using RM."

;;

func_fatal_help "invalid operation mode \`$opt_mode'"

func_fatal_help "invalid operation mode '$opt_mode'"

;;

esac

echo

$ECHO "Try \`$progname --help' for more information about other modes."

$ECHO "Try '$progname --help' for more information about other modes."

}

# Now that we've collected a possible --mode arg, show help if necessary

if $opt_help; then

if test "$opt_help" = :; then

if test : = "$opt_help"; then

func_mode_help

else

{

Line 2521 if $opt_help; then

Line 3808 if $opt_help; then

for opt_mode in compile link execute install finish uninstall clean; do

func_mode_help

done

} | sed -n '1p; 2,$s/^Usage:/ or: /p'

} | $SED -n '1p; 2,$s/^Usage:/ or: /p'

{

func_help noexit

for opt_mode in compile link execute install finish uninstall clean; do

Line 2529 if $opt_help; then

Line 3816 if $opt_help; then

func_mode_help

done

} |

sed '1d

$SED '1d

/^When reporting/,/^Report/{

Line 2546 fi

Line 3833 fi

# func_mode_execute arg...

func_mode_execute ()

{

$opt_debug

$debug_cmd

# The first argument is the command name.

cmd="$nonopt"

cmd=$nonopt

test -z "$cmd" && \

func_fatal_help "you must specify a COMMAND"

# Handle -dlopen flags immediately.

for file in $opt_dlopen; do

test -f "$file" \

|| func_fatal_help "\`$file' is not a file"

|| func_fatal_help "'$file' is not a file"

dir=

case $file in

Line 2565 func_mode_execute ()

Line 3853 func_mode_execute ()

# Check to see that this really is a libtool archive.

func_lalib_unsafe_p "$file" \

|| func_fatal_help "\`$lib' is not a valid libtool archive"

|| func_fatal_help "'$lib' is not a valid libtool archive"

# Read the libtool library.

dlname=

Line 2576 func_mode_execute ()

Line 3864 func_mode_execute ()

if test -z "$dlname"; then

# Warn if it was a shared library.

test -n "$library_names" && \

func_warning "\`$file' was not linked with \`-export-dynamic'"

func_warning "'$file' was not linked with '-export-dynamic'"

continue

func_dirname "$file" "" "."

dir="$func_dirname_result"

dir=$func_dirname_result

if test -f "$dir/$objdir/$dlname"; then

func_append dir "/$objdir"

else

if test ! -f "$dir/$dlname"; then

func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"

func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"

;;

Line 2595 func_mode_execute ()

Line 3883 func_mode_execute ()

*.lo)

# Just add the directory containing the .lo file.

func_dirname "$file" "" "."

dir="$func_dirname_result"

dir=$func_dirname_result

;;

func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"

func_warning "'-dlopen' is ignored for non-libtool libraries and objects"

continue

;;

esac

# Get the absolute pathname.

absdir=`cd "$dir" && pwd`

test -n "$absdir" && dir="$absdir"

test -n "$absdir" && dir=$absdir

# Now add the directory to shlibpath_var.

if eval "test -z \"\$$shlibpath_var\""; then

Line 2618 func_mode_execute ()

Line 3906 func_mode_execute ()

# This variable tells wrapper scripts just to set shlibpath_var

# rather than running their programs.

libtool_execute_magic="$magic"

libtool_execute_magic=$magic

# Check if any of the arguments is a wrapper script.

args=

Line 2631 func_mode_execute ()

Line 3919 func_mode_execute ()

if func_ltwrapper_script_p "$file"; then

func_source "$file"

# Transform arg to wrapped name.

file="$progdir/$program"

file=$progdir/$program

elif func_ltwrapper_executable_p "$file"; then

func_ltwrapper_scriptname "$file"

func_source "$func_ltwrapper_scriptname_result"

# Transform arg to wrapped name.

file="$progdir/$program"

file=$progdir/$program

;;

esac

Line 2644 func_mode_execute ()

Line 3932 func_mode_execute ()

func_append_quoted args "$file"

done

if test "X$opt_dry_run" = Xfalse; then

if $opt_dry_run; then

# Display what would be done.

if test -n "$shlibpath_var"; then

eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""

echo "export $shlibpath_var"

$ECHO "$cmd$args"

exit $EXIT_SUCCESS

else

if test -n "$shlibpath_var"; then

# Export the shlibpath_var.

eval "export $shlibpath_var"

Line 2661 func_mode_execute ()

Line 3957 func_mode_execute ()

done

# Now prepare to actually exec the command.

exec_cmd="\$cmd$args"

exec_cmd=\$cmd$args

else

# Display what would be done.

if test -n "$shlibpath_var"; then

eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""

echo "export $shlibpath_var"

$ECHO "$cmd$args"

exit $EXIT_SUCCESS

}

test "$opt_mode" = execute && func_mode_execute ${1+"$@"}

test execute = "$opt_mode" && func_mode_execute ${1+"$@"}

# func_mode_finish arg...

func_mode_finish ()

{

$opt_debug

$debug_cmd

libs=

libdirs=

admincmds=

Line 2693 func_mode_finish ()

Line 3982 func_mode_finish ()

if func_lalib_unsafe_p "$opt"; then

func_append libs " $opt"

else

func_warning "\`$opt' is not a valid libtool archive"

func_warning "'$opt' is not a valid libtool archive"

else

func_fatal_error "invalid argument \`$opt'"

func_fatal_error "invalid argument '$opt'"

done

Line 2712 func_mode_finish ()

Line 4001 func_mode_finish ()

# Remove sysroot references

if $opt_dry_run; then

for lib in $libs; do

echo "removing references to $lt_sysroot and \`=' prefixes from $lib"

echo "removing references to $lt_sysroot and '=' prefixes from $lib"

done

else

tmpdir=`func_mktempdir`

for lib in $libs; do

sed -e "${sysroot_cmd} s/$[ ']-[LR]$=/\1/g; s/$[ ']$=/\1/g" $lib \

$SED -e "$sysroot_cmd s/$[ ']-[LR]$=/\1/g; s/$[ ']$=/\1/g" $lib \

> $tmpdir/tmp-la

mv -f $tmpdir/tmp-la $lib

done

Line 2742 func_mode_finish ()

Line 4031 func_mode_finish ()

# Exit here if they wanted silent mode.

$opt_silent && exit $EXIT_SUCCESS

$opt_quiet && exit $EXIT_SUCCESS

if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then

echo "----------------------------------------------------------------------"

Line 2753 func_mode_finish ()

Line 4042 func_mode_finish ()

echo

echo "If you ever happen to want to link against installed libraries"

echo "in a given directory, LIBDIR, you must either use libtool, and"

echo "specify the full pathname of the library, or use the \`-LLIBDIR'"

echo "specify the full pathname of the library, or use the '-LLIBDIR'"

echo "flag during linking and do at least one of the following:"

if test -n "$shlibpath_var"; then

echo " - add LIBDIR to the \`$shlibpath_var' environment variable"

echo " - add LIBDIR to the '$shlibpath_var' environment variable"

echo " during execution"

if test -n "$runpath_var"; then

echo " - add LIBDIR to the \`$runpath_var' environment variable"

echo " - add LIBDIR to the '$runpath_var' environment variable"

echo " during linking"

if test -n "$hardcode_libdir_flag_spec"; then

libdir=LIBDIR

eval flag=\"$hardcode_libdir_flag_spec\"

$ECHO " - use the \`$flag' linker flag"

$ECHO " - use the '$flag' linker flag"

if test -n "$admincmds"; then

$ECHO " - have your system administrator run these commands:$admincmds"

if test -f /etc/ld.so.conf; then

echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"

echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'"

echo

Line 2792 func_mode_finish ()

Line 4081 func_mode_finish ()

exit $EXIT_SUCCESS

}

test "$opt_mode" = finish && func_mode_finish ${1+"$@"}

test finish = "$opt_mode" && func_mode_finish ${1+"$@"}

# func_mode_install arg...

func_mode_install ()

{

$opt_debug

$debug_cmd

# There may be an optional sh(1) argument at the beginning of

# install_prog (especially on Windows NT).

if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||

if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||

# Allow the use of GNU shtool's install command.

case $nonopt in *shtool*) :;; *) false;; esac; then

case $nonopt in *shtool*) :;; *) false;; esac

then

# Aesthetically quote it.

func_quote_for_eval "$nonopt"

install_prog="$func_quote_for_eval_result "

Line 2830 func_mode_install ()

Line 4121 func_mode_install ()

opts=

prev=

install_type=

isdir=no

isdir=false

stripme=

no_mode=:

for arg

Line 2843 func_mode_install ()

Line 4134 func_mode_install ()

case $arg in

-d) isdir=yes ;;

-d) isdir=: ;;

-f)

if $install_cp; then :; else

prev=$arg

Line 2861 func_mode_install ()

Line 4152 func_mode_install ()

# If the previous option needed an argument, then skip it.

if test -n "$prev"; then

if test "x$prev" = x-m && test -n "$install_override_mode"; then

if test X-m = "X$prev" && test -n "$install_override_mode"; then

arg2=$install_override_mode

no_mode=false

Line 2886 func_mode_install ()

Line 4177 func_mode_install ()

func_fatal_help "you must specify an install program"

test -n "$prev" && \

func_fatal_help "the \`$prev' option requires an argument"

func_fatal_help "the '$prev' option requires an argument"

if test -n "$install_override_mode" && $no_mode; then

if $install_cp; then :; else

Line 2908 func_mode_install ()

Line 4199 func_mode_install ()

dest=$func_stripname_result

# Check to see that the destination is a directory.

test -d "$dest" && isdir=yes

test -d "$dest" && isdir=:

if test "$isdir" = yes; then

if $isdir; then

destdir="$dest"

destdir=$dest

destname=

else

func_dirname_and_basename "$dest" "" "."

destdir="$func_dirname_result"

destdir=$func_dirname_result

destname="$func_basename_result"

destname=$func_basename_result

# Not a directory, so check to see that there is only one file specified.

set dummy $files; shift

test "$#" -gt 1 && \

func_fatal_help "\`$dest' is not a directory"

func_fatal_help "'$dest' is not a directory"

case $destdir in

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

Line 2929 func_mode_install ()

Line 4220 func_mode_install ()

case $file in

*.lo) ;;

func_fatal_help "\`$destdir' must be an absolute directory name"

func_fatal_help "'$destdir' must be an absolute directory name"

;;

esac

done

Line 2938 func_mode_install ()

Line 4229 func_mode_install ()

# This variable tells wrapper scripts just to set variables rather

# than running their programs.

libtool_install_magic="$magic"

libtool_install_magic=$magic

staticlibs=

future_libdirs=

Line 2958 func_mode_install ()

Line 4249 func_mode_install ()

# Check to see that this really is a libtool archive.

func_lalib_unsafe_p "$file" \

|| func_fatal_help "\`$file' is not a valid libtool archive"

|| func_fatal_help "'$file' is not a valid libtool archive"

library_names=

old_library=

Line 2980 func_mode_install ()

Line 4271 func_mode_install ()

func_dirname "$file" "/" ""

dir="$func_dirname_result"

dir=$func_dirname_result

func_append dir "$objdir"

if test -n "$relink_command"; then

Line 2994 func_mode_install ()

Line 4285 func_mode_install ()

# are installed into $libdir/../bin (currently, that works fine)

# but it's something to keep an eye on.

test "$inst_prefix_dir" = "$destdir" && \

func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"

func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"

if test -n "$inst_prefix_dir"; then

# Stick the inst_prefix_dir data into the link command.

Line 3003 func_mode_install ()

Line 4294 func_mode_install ()

relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`

func_warning "relinking \`$file'"

func_warning "relinking '$file'"

func_show_eval "$relink_command" \

'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'

'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'

# See the names of the shared library.

set dummy $library_names; shift

if test -n "$1"; then

realname="$1"

realname=$1

shift

srcname="$realname"

srcname=$realname

test -n "$relink_command" && srcname="$realname"T

test -n "$relink_command" && srcname=${realname}T

# Install the shared library and build the symlinks.

func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \

'exit $?'

tstripme="$stripme"

tstripme=$stripme

case $host_os in

cygwin* | mingw* | pw32* | cegcc*)

case $realname in

*.dll.a)

tstripme=""

tstripme=

;;

esac

;;

os2*)

case $realname in

*_dll.a)

tstripme=

;;

esac

;;

esac

if test -n "$tstripme" && test -n "$striplib"; then

func_show_eval "$striplib $destdir/$realname" 'exit $?'

Line 3036 func_mode_install ()

Line 4334 func_mode_install ()

if test "$#" -gt 0; then

# Delete the old symlinks, and create new ones.

# Try `ln -sf' first, because the `ln' binary might depend on

# Try 'ln -sf' first, because the 'ln' binary might depend on

# the symlink we replace! Solaris /bin/ln does not understand -f,

# so we also need to try rm && ln -s.

for linkname

Line 3047 func_mode_install ()

Line 4345 func_mode_install ()

# Do each command in the postinstall commands.

lib="$destdir/$realname"

lib=$destdir/$realname

func_execute_cmds "$postinstall_cmds" 'exit $?'

# Install the pseudo-library for information purposes.

func_basename "$file"

name="$func_basename_result"

name=$func_basename_result

instname="$dir/$name"i

instname=$dir/${name}i

func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'

# Maybe install the static library, too.

Line 3066 func_mode_install ()

Line 4364 func_mode_install ()

# Figure out destination file name, if it wasn't already specified.

if test -n "$destname"; then

destfile="$destdir/$destname"

destfile=$destdir/$destname

else

func_basename "$file"

destfile="$func_basename_result"

destfile=$func_basename_result

destfile="$destdir/$destfile"

destfile=$destdir/$destfile

# Deduce the name of the destination old-style object file.

Line 3080 func_mode_install ()

Line 4378 func_mode_install ()

staticdest=$func_lo2o_result

;;

*.$objext)

staticdest="$destfile"

staticdest=$destfile

destfile=

;;

func_fatal_help "cannot copy a libtool object to \`$destfile'"

func_fatal_help "cannot copy a libtool object to '$destfile'"

;;

esac

Line 3093 func_mode_install ()

Line 4391 func_mode_install ()

func_show_eval "$install_prog $file $destfile" 'exit $?'

# Install the old object if enabled.

if test "$build_old_libs" = yes; then

if test yes = "$build_old_libs"; then

# Deduce the name of the old-style object file.

func_lo2o "$file"

staticobj=$func_lo2o_result

Line 3105 func_mode_install ()

Line 4403 func_mode_install ()

# Figure out destination file name, if it wasn't already specified.

if test -n "$destname"; then

destfile="$destdir/$destname"

destfile=$destdir/$destname

else

func_basename "$file"

destfile="$func_basename_result"

destfile=$func_basename_result

destfile="$destdir/$destfile"

destfile=$destdir/$destfile

# If the file is missing, and there is a .exe on the end, strip it

# because it is most likely a libtool script we actually want to

# install

stripped_ext=""

stripped_ext=

case $file in

*.exe)

if test ! -f "$file"; then

func_stripname '' '.exe' "$file"

file=$func_stripname_result

stripped_ext=".exe"

stripped_ext=.exe

;;

esac

Line 3149 func_mode_install ()

Line 4447 func_mode_install ()

# Check the variables that should have been set.

test -z "$generated_by_libtool_version" && \

func_fatal_error "invalid libtool wrapper script \`$wrapper'"

func_fatal_error "invalid libtool wrapper script '$wrapper'"

finalize=yes

finalize=:

for lib in $notinst_deplibs; do

# Check to see that each library is installed.

libdir=

if test -f "$lib"; then

func_source "$lib"

libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test

libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`

if test -n "$libdir" && test ! -f "$libfile"; then

func_warning "\`$lib' has not been installed in \`$libdir'"

func_warning "'$lib' has not been installed in '$libdir'"

finalize=no

finalize=false

done

Line 3169 func_mode_install ()

Line 4467 func_mode_install ()

func_source "$wrapper"

outputname=

if test "$fast_install" = no && test -n "$relink_command"; then

if test no = "$fast_install" && test -n "$relink_command"; then

$opt_dry_run || {

if test "$finalize" = yes; then

if $finalize; then

tmpdir=`func_mktempdir`

func_basename "$file$stripped_ext"

file="$func_basename_result"

file=$func_basename_result

outputname="$tmpdir/$file"

outputname=$tmpdir/$file

# Replace the output file specification.

relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`

$opt_silent || {

$opt_quiet || {

func_quote_for_expand "$relink_command"

eval "func_echo $func_quote_for_expand_result"

}

if eval "$relink_command"; then :

else

func_error "error: relink \`$file' with the above command before installing it"

func_error "error: relink '$file' with the above command before installing it"

$opt_dry_run || ${RM}r "$tmpdir"

continue

file="$outputname"

file=$outputname

else

func_warning "cannot relink \`$file'"

func_warning "cannot relink '$file'"

}

else

Line 3228 func_mode_install ()

Line 4526 func_mode_install ()

for file in $staticlibs; do

func_basename "$file"

name="$func_basename_result"

name=$func_basename_result

# Set up the ranlib parameters.

oldlib="$destdir/$name"

oldlib=$destdir/$name

func_to_tool_file "$oldlib" func_convert_file_msys_to_w32

tool_oldlib=$func_to_tool_file_result

Line 3246 func_mode_install ()

Line 4544 func_mode_install ()

done

test -n "$future_libdirs" && \

func_warning "remember to run \`$progname --finish$future_libdirs'"

func_warning "remember to run '$progname --finish$future_libdirs'"

if test -n "$current_libdirs"; then

# Maybe just do a dry run.

$opt_dry_run && current_libdirs=" -n$current_libdirs"

exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'

exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'

else

exit $EXIT_SUCCESS

}

test "$opt_mode" = install && func_mode_install ${1+"$@"}

test install = "$opt_mode" && func_mode_install ${1+"$@"}

# func_generate_dlsyms outputname originator pic_p

Line 3265 test "$opt_mode" = install && func_mode_install ${1+"$

Line 4563 test "$opt_mode" = install && func_mode_install ${1+"$

# a dlpreopen symbol table.

func_generate_dlsyms ()

{

$opt_debug

$debug_cmd

my_outputname="$1"

my_originator="$2"

my_outputname=$1

my_pic_p="${3-no}"

my_originator=$2

my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`

my_pic_p=${3-false}

my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`

my_dlsyms=

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then

if test -n "$NM" && test -n "$global_symbol_pipe"; then

my_dlsyms="${my_outputname}S.c"

my_dlsyms=${my_outputname}S.c

else

func_error "not configured to extract global symbols from dlpreopened files"

Line 3285 func_generate_dlsyms ()

Line 4584 func_generate_dlsyms ()

"") ;;

*.c)

# Discover the nlist of each of the dlfiles.

nlist="$output_objdir/${my_outputname}.nm"

nlist=$output_objdir/$my_outputname.nm

func_show_eval "$RM $nlist ${nlist}S ${nlist}T"

Line 3293 func_generate_dlsyms ()

Line 4592 func_generate_dlsyms ()

func_verbose "creating $output_objdir/$my_dlsyms"

$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\

/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */

/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */

/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */

/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */

#ifdef __cplusplus

extern \"C\" {

#endif

#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))

#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))

#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"

#endif

/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */

#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)

#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE

/* DATA imports from DLLs on WIN32 con't be const, because runtime

/* DATA imports from DLLs on WIN32 can't be const, because runtime

relocations are performed -- see ld's documentation on pseudo-relocs. */

# define LT_DLSYM_CONST

#elif defined(__osf__)

#elif defined __osf__

/* This system does not cope well with relocations in const data. */

# define LT_DLSYM_CONST

#else

# define LT_DLSYM_CONST const

#endif

#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)

/* External symbol declarations for the compiler. */\

if test "$dlself" = yes; then

if test yes = "$dlself"; then

func_verbose "generating symbol list for \`$output'"

func_verbose "generating symbol list for '$output'"

$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"

Line 3328 extern \"C\" {

Line 4629 extern \"C\" {

progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`

for progfile in $progfiles; do

func_to_tool_file "$progfile" func_convert_file_msys_to_w32

func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"

func_verbose "extracting global C symbols from '$func_to_tool_file_result'"

$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"

done

Line 3348 extern \"C\" {

Line 4649 extern \"C\" {

# Prepare the list of exported symbols

if test -z "$export_symbols"; then

export_symbols="$output_objdir/$outputname.exp"

export_symbols=$output_objdir/$outputname.exp

$opt_dry_run || {

$RM $export_symbols

eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'

eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'

case $host in

*cygwin* | *mingw* | *cegcc* )

eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'

Line 3361 extern \"C\" {

Line 4662 extern \"C\" {

}

else

$opt_dry_run || {

eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'

eval "$SED -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'

eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'

eval '$MV "$nlist"T "$nlist"'

case $host in

Line 3375 extern \"C\" {

Line 4676 extern \"C\" {

for dlprefile in $dlprefiles; do

func_verbose "extracting global C symbols from \`$dlprefile'"

func_verbose "extracting global C symbols from '$dlprefile'"

func_basename "$dlprefile"

name="$func_basename_result"

name=$func_basename_result

case $host in

*cygwin* | *mingw* | *cegcc* )

# if an import library, we need to obtain dlname

if func_win32_import_lib_p "$dlprefile"; then

func_tr_sh "$dlprefile"

eval "curr_lafile=\$libfile_$func_tr_sh_result"

dlprefile_dlbasename=""

dlprefile_dlbasename=

if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then

# Use subshell, to avoid clobbering current variable values

dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`

if test -n "$dlprefile_dlname" ; then

if test -n "$dlprefile_dlname"; then

func_basename "$dlprefile_dlname"

dlprefile_dlbasename="$func_basename_result"

dlprefile_dlbasename=$func_basename_result

else

# no lafile. user explicitly requested -dlpreopen <import library>.

$sharedlib_from_linklib_cmd "$dlprefile"

Line 3398 extern \"C\" {

Line 4699 extern \"C\" {

$opt_dry_run || {

if test -n "$dlprefile_dlbasename" ; then

if test -n "$dlprefile_dlbasename"; then

eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'

else

func_warning "Could not compute DLL name from $name"

Line 3454 extern \"C\" {

Line 4755 extern \"C\" {

echo '/* NONE */' >> "$output_objdir/$my_dlsyms"

func_show_eval '$RM "${nlist}I"'

if test -n "$global_symbol_to_import"; then

eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'

echo >> "$output_objdir/$my_dlsyms" "\

/* The mapping between symbol names and symbols. */

Line 3462 typedef struct {

Line 4768 typedef struct {

void *address;

} lt_dlsymlist;

extern LT_DLSYM_CONST lt_dlsymlist

lt_${my_prefix}_LTX_preloaded_symbols[];

lt_${my_prefix}_LTX_preloaded_symbols[];\

if test -s "$nlist"I; then

echo >> "$output_objdir/$my_dlsyms" "\

static void lt_syminit(void)

{

LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;

for (; symbol->name; ++symbol)

$SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"

echo >> "$output_objdir/$my_dlsyms" "\

}

echo >> "$output_objdir/$my_dlsyms" "\

LT_DLSYM_CONST lt_dlsymlist

lt_${my_prefix}_LTX_preloaded_symbols[] =

{ {\"$my_originator\", (void *) 0},"

{ \"$my_originator\", (void *) 0 },"

if test -s "$nlist"I; then

echo >> "$output_objdir/$my_dlsyms" "\

{\"@INIT@\", (void *) &lt_syminit},"

case $need_lib_prefix in

no)

eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"

Line 3508 static const void *lt_preloaded_setup() {

Line 4833 static const void *lt_preloaded_setup() {

*-*-hpux*)

pic_flag_for_symtable=" $pic_flag" ;;

if test "X$my_pic_p" != Xno; then

$my_pic_p && pic_flag_for_symtable=" $pic_flag"

pic_flag_for_symtable=" $pic_flag"

;;

esac

;;

Line 3527 static const void *lt_preloaded_setup() {

Line 4850 static const void *lt_preloaded_setup() {

func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'

# Clean up the generated files.

func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'

func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'

# Transform the symbol file into the correct name.

symfileobj="$output_objdir/${my_outputname}S.$objext"

symfileobj=$output_objdir/${my_outputname}S.$objext

case $host in

*cygwin* | *mingw* | *cegcc* )

if test -f "$output_objdir/$my_outputname.def"; then

Line 3547 static const void *lt_preloaded_setup() {

Line 4870 static const void *lt_preloaded_setup() {

;;

esac

;;

*-*-freebsd*)

# FreeBSD doesn't need this...

;;

func_fatal_error "unknown suffix for \`$my_dlsyms'"

func_fatal_error "unknown suffix for '$my_dlsyms'"

;;

esac

else

Line 3565 static const void *lt_preloaded_setup() {

Line 4885 static const void *lt_preloaded_setup() {

}

# func_cygming_gnu_implib_p ARG

# This predicate returns with zero status (TRUE) if

# ARG is a GNU/binutils-style import library. Returns

# with nonzero status (FALSE) otherwise.

func_cygming_gnu_implib_p ()

{

$debug_cmd

func_to_tool_file "$1" func_convert_file_msys_to_w32

func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`

test -n "$func_cygming_gnu_implib_tmp"

}

# func_cygming_ms_implib_p ARG

# This predicate returns with zero status (TRUE) if

# ARG is an MS-style import library. Returns

# with nonzero status (FALSE) otherwise.

func_cygming_ms_implib_p ()

{

$debug_cmd

func_to_tool_file "$1" func_convert_file_msys_to_w32

func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`

test -n "$func_cygming_ms_implib_tmp"

}

# func_win32_libid arg

# return the library type of file 'arg'

Line 3574 static const void *lt_preloaded_setup() {

Line 4920 static const void *lt_preloaded_setup() {

# Despite the name, also deal with 64 bit binaries.

func_win32_libid ()

{

$opt_debug

$debug_cmd

win32_libid_type="unknown"

win32_libid_type=unknown

win32_fileres=`file -L $1 2>/dev/null`

case $win32_fileres in

*ar\ archive\ import\ library*) # definitely import

Line 3585 func_win32_libid ()

Line 4932 func_win32_libid ()

# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.

if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |

$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then

func_to_tool_file "$1" func_convert_file_msys_to_w32

case $nm_interface in

win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |

"MS dumpbin")

$SED -n -e '

if func_cygming_ms_implib_p "$1" ||

func_cygming_gnu_implib_p "$1"

then

win32_nmres=import

else

win32_nmres=

;;

func_to_tool_file "$1" func_convert_file_msys_to_w32

win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |

$SED -n -e '

1,100{

/ I /{

s,.*,import,

s|.*|import|

}

}'`

;;

esac

case $win32_nmres in

import*) win32_libid_type="x86 archive import";;

*) win32_libid_type="x86 archive static";;

Line 3626 func_win32_libid ()

Line 4986 func_win32_libid ()

# $sharedlib_from_linklib_result

func_cygming_dll_for_implib ()

{

$opt_debug

$debug_cmd

sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`

}

Line 3643 func_cygming_dll_for_implib ()

Line 5004 func_cygming_dll_for_implib ()

# specified import library.

func_cygming_dll_for_implib_fallback_core ()

{

$opt_debug

$debug_cmd

match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`

$OBJDUMP -s --section "$1" "$2" 2>/dev/null |

$SED '/^Contents of section '"$match_literal"':/{

Line 3679 func_cygming_dll_for_implib_fallback_core ()

Line 5041 func_cygming_dll_for_implib_fallback_core ()

/./p' |

# we now have a list, one entry per line, of the stringified

# contents of the appropriate section of all members of the

# archive which possess that section. Heuristic: eliminate

# archive that possess that section. Heuristic: eliminate

# all those which have a first or second character that is

# all those that have a first or second character that is

# a '.' (that is, objdump's representation of an unprintable

# character.) This should work for all archives with less than

# 0x302f exports -- but will fail for DLLs whose name actually

Line 3691 func_cygming_dll_for_implib_fallback_core ()

Line 5053 func_cygming_dll_for_implib_fallback_core ()

$SED -e '/^\./d;/^.\./d;q'

}

# func_cygming_gnu_implib_p ARG

# This predicate returns with zero status (TRUE) if

# ARG is a GNU/binutils-style import library. Returns

# with nonzero status (FALSE) otherwise.

func_cygming_gnu_implib_p ()

{

$opt_debug

func_to_tool_file "$1" func_convert_file_msys_to_w32

func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`

test -n "$func_cygming_gnu_implib_tmp"

}

# func_cygming_ms_implib_p ARG

# This predicate returns with zero status (TRUE) if

# ARG is an MS-style import library. Returns

# with nonzero status (FALSE) otherwise.

func_cygming_ms_implib_p ()

{

$opt_debug

func_to_tool_file "$1" func_convert_file_msys_to_w32

func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`

test -n "$func_cygming_ms_implib_tmp"

}

# func_cygming_dll_for_implib_fallback ARG

# Platform-specific function to extract the

# name of the DLL associated with the specified

Line 3728 func_cygming_ms_implib_p ()

Line 5066 func_cygming_ms_implib_p ()

# $sharedlib_from_linklib_result

func_cygming_dll_for_implib_fallback ()

{

$opt_debug

$debug_cmd

if func_cygming_gnu_implib_p "$1" ; then

if func_cygming_gnu_implib_p "$1"; then

# binutils import library

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`

elif func_cygming_ms_implib_p "$1" ; then

elif func_cygming_ms_implib_p "$1"; then

# ms-generated import library

sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`

else

# unknown

sharedlib_from_linklib_result=""

sharedlib_from_linklib_result=

}

Line 3745 func_cygming_dll_for_implib_fallback ()

Line 5084 func_cygming_dll_for_implib_fallback ()

# func_extract_an_archive dir oldlib

func_extract_an_archive ()

{

$opt_debug

$debug_cmd

f_ex_an_ar_dir="$1"; shift

f_ex_an_ar_oldlib="$1"

f_ex_an_ar_dir=$1; shift

if test "$lock_old_archive_extraction" = yes; then

f_ex_an_ar_oldlib=$1

if test yes = "$lock_old_archive_extraction"; then

lockfile=$f_ex_an_ar_oldlib.lock

until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do

func_echo "Waiting for $lockfile to be removed"

Line 3757 func_extract_an_archive ()

Line 5097 func_extract_an_archive ()

func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \

'stat=$?; rm -f "$lockfile"; exit $stat'

if test "$lock_old_archive_extraction" = yes; then

if test yes = "$lock_old_archive_extraction"; then

$opt_dry_run || rm -f "$lockfile"

if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then

Line 3771 func_extract_an_archive ()

Line 5111 func_extract_an_archive ()

# func_extract_archives gentop oldlib ...

func_extract_archives ()

{

$opt_debug

$debug_cmd

my_gentop="$1"; shift

my_gentop=$1; shift

my_oldlibs=${1+"$@"}

my_oldobjs=""

my_oldobjs=

my_xlib=""

my_xlib=

my_xabs=""

my_xabs=

my_xdir=""

my_xdir=

for my_xlib in $my_oldlibs; do

# Extract the objects.

case $my_xlib in

[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;

[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;

*) my_xabs=`pwd`"/$my_xlib" ;;

esac

func_basename "$my_xlib"

my_xlib="$func_basename_result"

my_xlib=$func_basename_result

my_xlib_u=$my_xlib

while :; do

case " $extracted_archives " in

Line 3798 func_extract_archives ()

Line 5139 func_extract_archives ()

esac

done

extracted_archives="$extracted_archives $my_xlib_u"

my_xdir="$my_gentop/$my_xlib_u"

my_xdir=$my_gentop/$my_xlib_u

func_mkdir_p "$my_xdir"

Line 3811 func_extract_archives ()

Line 5152 func_extract_archives ()

cd $my_xdir || exit $?

darwin_archive=$my_xabs

darwin_curdir=`pwd`

darwin_base_archive=`basename "$darwin_archive"`

func_basename "$darwin_archive"

darwin_base_archive=$func_basename_result

darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`

if test -n "$darwin_arches"; then

darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`

darwin_arch=

func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"

for darwin_arch in $darwin_arches ; do

for darwin_arch in $darwin_arches; do

func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"

func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"

$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"

$LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"

cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"

cd "unfat-$$/$darwin_base_archive-$darwin_arch"

func_extract_an_archive "`pwd`" "${darwin_base_archive}"

func_extract_an_archive "`pwd`" "$darwin_base_archive"

cd "$darwin_curdir"

$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"

$RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"

done # $darwin_arches

## Okay now we've a bunch of thin objects, gotta fatten them up :)

darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`

darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`

darwin_file=

darwin_files=

for darwin_file in $darwin_filelist; do

Line 3848 func_extract_archives ()

Line 5190 func_extract_archives ()

my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`

done

func_extract_archives_result="$my_oldobjs"

func_extract_archives_result=$my_oldobjs

}

Line 3863 func_extract_archives ()

Line 5205 func_extract_archives ()

# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR

# variable will take. If 'yes', then the emitted script

# will assume that the directory in which it is stored is

# will assume that the directory where it is stored is

# the $objdir directory. This is a cygwin/mingw-specific

# behavior.

func_emit_wrapper ()

Line 3874 func_emit_wrapper ()

Line 5216 func_emit_wrapper ()

#! $SHELL

# $output - temporary wrapper script for $objdir/$outputname

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

# Generated by $PROGRAM (GNU $PACKAGE) $VERSION

# The $output program cannot be directly executed until all the libtool

# libraries that it depends on are installed.

Line 3931 _LTECHO_EOF'

Line 5273 _LTECHO_EOF'

# Very basic option parsing. These options are (a) specific to

# the libtool wrapper, (b) are identical between the wrapper

# /script/ and the wrapper /executable/ which is used only on

# /script/ and the wrapper /executable/ that is used only on

# windows platforms, and (c) all begin with the string "--lt-"

# (application programs are unlikely to have options which match

# (application programs are unlikely to have options that match

# this pattern).

# There are only two supported options: --lt-debug and

Line 3966 func_parse_lt_options ()

Line 5308 func_parse_lt_options ()

# Print the debug banner immediately:

if test -n \"\$lt_option_debug\"; then

echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2

echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2

}

Line 3977 func_lt_dump_args ()

Line 5319 func_lt_dump_args ()

lt_dump_args_N=1;

for lt_arg

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"

\$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"

lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`

done

}

Line 3991 func_exec_program_core ()

Line 5333 func_exec_program_core ()

*-*-mingw | *-*-os2* | *-cegcc*)

$ECHO "\

if test -n \"\$lt_option_debug\"; then

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2

\$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2

func_lt_dump_args \${1+\"\$@\"} 1>&2

exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}

Line 4001 func_exec_program_core ()

Line 5343 func_exec_program_core ()

$ECHO "\

if test -n \"\$lt_option_debug\"; then

\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2

\$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2

func_lt_dump_args \${1+\"\$@\"} 1>&2

exec \"\$progdir/\$program\" \${1+\"\$@\"}

Line 4076 func_exec_program ()

Line 5418 func_exec_program ()

test -n \"\$absdir\" && thisdir=\"\$absdir\"

if test "$fast_install" = yes; then

if test yes = "$fast_install"; then

$ECHO "\

program=lt-'$outputname'$exeext

progdir=\"\$thisdir/$objdir\"

if test ! -f \"\$progdir/\$program\" ||

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\

{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\

test \"X\$file\" != \"X\$progdir/\$program\"; }; then

file=\"\$\$-\$program\"

Line 4099 func_exec_program ()

Line 5441 func_exec_program ()

if test -n \"\$relink_command\"; then

if relink_command_output=\`eval \$relink_command 2>&1\`; then :

else

$ECHO \"\$relink_command_output\" >&2

\$ECHO \"\$relink_command_output\" >&2

$RM \"\$progdir/\$file\"

exit 1

Line 4134 func_exec_program ()

Line 5476 func_exec_program ()

# Export our shlibpath_var if we have one.

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

$ECHO "\

# Add our own library path to $shlibpath_var

$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

Line 4154 func_exec_program ()

Line 5496 func_exec_program ()

else

# The program doesn't exist.

\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2

\$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2

\$ECHO \"This script is just a wrapper for \$program.\" 1>&2

\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2

exit 1

Line 4173 func_emit_cwrapperexe_src ()

Line 5515 func_emit_cwrapperexe_src ()

cat <<EOF

/* $cwrappersource - temporary wrapper executable for $objdir/$outputname

Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

Generated by $PROGRAM (GNU $PACKAGE) $VERSION

The $output program cannot be directly executed until all the libtool

libraries that it depends on are installed.

Line 4208 EOF

Line 5550 EOF

#include <fcntl.h>

#include <sys/stat.h>

#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)

/* declarations of non-ANSI functions */

#if defined(__MINGW32__)

#if defined __MINGW32__

# ifdef __STRICT_ANSI__

int _putenv (const char *);

# endif

#elif defined(__CYGWIN__)

#elif defined __CYGWIN__

# ifdef __STRICT_ANSI__

char *realpath (const char *, char *);

int putenv (char *);

int setenv (const char *, const char *, int);

# endif

/* #elif defined (other platforms) ... */

/* #elif defined other_platform || defined ... */

#endif

/* portability defines, excluding path handling macros */

#if defined(_MSC_VER)

#if defined _MSC_VER

# define setmode _setmode

# define stat _stat

# define chmod _chmod

# define getcwd _getcwd

# define putenv _putenv

# define S_IXUSR _S_IEXEC

# ifndef _INTPTR_T_DEFINED

#elif defined __MINGW32__

# define _INTPTR_T_DEFINED

# define intptr_t int

# endif

#elif defined(__MINGW32__)

# define setmode _setmode

# define stat _stat

# define chmod _chmod

# define getcwd _getcwd

# define putenv _putenv

#elif defined(__CYGWIN__)

#elif defined __CYGWIN__

# define HAVE_SETENV

# define FOPEN_WB "wb"

/* #elif defined (other platforms) ... */

/* #elif defined other platforms ... */

#endif

#if defined(PATH_MAX)

#if defined PATH_MAX

# define LT_PATHMAX PATH_MAX

#elif defined(MAXPATHLEN)

#elif defined MAXPATHLEN

# define LT_PATHMAX MAXPATHLEN

#else

# define LT_PATHMAX 1024

Line 4267 int setenv (const char *, const char *, int);

Line 5607 int setenv (const char *, const char *, int);

# define PATH_SEPARATOR ':'

#endif

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \

#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \

defined (__OS2__)

defined __OS2__

# define HAVE_DOS_BASED_FILE_SYSTEM

# define FOPEN_WB "wb"

# ifndef DIR_SEPARATOR_2

Line 4301 int setenv (const char *, const char *, int);

Line 5641 int setenv (const char *, const char *, int);

#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))

#define XFREE(stale) do { \

if (stale) { free ((void *) stale); stale = 0; } \

if (stale) { free (stale); stale = 0; } \

} while (0)

#if defined(LT_DEBUGWRAPPER)

#if defined LT_DEBUGWRAPPER

static int lt_debug = 1;

#else

static int lt_debug = 0;

Line 4333 void lt_dump_script (FILE *f);

Line 5673 void lt_dump_script (FILE *f);

EOF

cat <<EOF

volatile const char * MAGIC_EXE = "$magic_exe";

#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)

# define externally_visible volatile

#else

# define externally_visible __attribute__((externally_visible)) volatile

#endif

externally_visible const char * MAGIC_EXE = "$magic_exe";

const char * LIB_PATH_VARNAME = "$shlibpath_var";

EOF

if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then

func_to_host_path "$temp_rpath"

cat <<EOF

const char * LIB_PATH_VALUE = "$func_to_host_path_result";

Line 4361 const char * EXE_PATH_VALUE = "";

Line 5706 const char * EXE_PATH_VALUE = "";

EOF

if test "$fast_install" = yes; then

if test yes = "$fast_install"; then

cat <<EOF

const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */

EOF

Line 4390 main (int argc, char *argv[])

Line 5735 main (int argc, char *argv[])

char *actual_cwrapper_name;

char *target_name;

char *lt_argv_zero;

intptr_t rval = 127;

int rval = 127;

int i;

program_name = (char *) xstrdup (base_name (argv[0]));

newargz = XMALLOC (char *, argc + 1);

newargz = XMALLOC (char *, (size_t) argc + 1);

/* very simple arg parsing; don't want to rely on getopt

* also, copy all non cwrapper options to newargz, except

Line 4404 main (int argc, char *argv[])

Line 5749 main (int argc, char *argv[])

newargc=0;

for (i = 1; i < argc; i++)

{

if (strcmp (argv[i], dumpscript_opt) == 0)

if (STREQ (argv[i], dumpscript_opt))

{

EOF

case "$host" in

case $host in

*mingw* | *cygwin* )

# make stdout use "unix" line endings

echo " setmode(1,_O_BINARY);"

Line 4418 EOF

Line 5763 EOF

lt_dump_script (stdout);

return 0;

}

if (strcmp (argv[i], debug_opt) == 0)

if (STREQ (argv[i], debug_opt))

{

lt_debug = 1;

continue;

}

if (strcmp (argv[i], ltwrapper_option_prefix) == 0)

if (STREQ (argv[i], ltwrapper_option_prefix))

{

/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX

namespace, but it is not one of the ones we know about and

Line 4446 EOF

Line 5791 EOF

EOF

cat <<EOF

/* The GNU banner must be the first non-error debug message */

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");

lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");

EOF

cat <<"EOF"

lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);

Line 4557 EOF

Line 5902 EOF

cat <<"EOF"

/* execv doesn't actually work on mingw as expected on unix */

newargz = prepare_spawn (newargz);

rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);

if (rval == -1)

{

/* failed to start process */

Line 4602 base_name (const char *name)

Line 5947 base_name (const char *name)

{

const char *base;

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

#if defined HAVE_DOS_BASED_FILE_SYSTEM

/* Skip over the disk name in MSDOS pathnames. */

if (isalpha ((unsigned char) name[0]) && name[1] == ':')

name += 2;

Line 4661 find_executable (const char *wrapper)

Line 6006 find_executable (const char *wrapper)

const char *p_next;

/* static buffer for getcwd */

char tmp[LT_PATHMAX + 1];

int tmp_len;

size_t tmp_len;

char *concat_name;

lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",

Line 4671 find_executable (const char *wrapper)

Line 6016 find_executable (const char *wrapper)

return NULL;

/* Absolute path? */

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

#if defined HAVE_DOS_BASED_FILE_SYSTEM

if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')

{

concat_name = xstrdup (wrapper);

Line 4689 find_executable (const char *wrapper)

Line 6034 find_executable (const char *wrapper)

return concat_name;

XFREE (concat_name);

}

#if defined (HAVE_DOS_BASED_FILE_SYSTEM)

#if defined HAVE_DOS_BASED_FILE_SYSTEM

}

#endif

Line 4712 find_executable (const char *wrapper)

Line 6057 find_executable (const char *wrapper)

for (q = p; *q; q++)

if (IS_PATH_SEPARATOR (*q))

break;

p_len = q - p;

p_len = (size_t) (q - p);

p_next = (*q == '\0' ? q : q + 1);

if (p_len == 0)

{

Line 4831 strendzap (char *str, const char *pat)

Line 6176 strendzap (char *str, const char *pat)

if (patlen <= len)

{

str += len - patlen;

if (strcmp (str, pat) == 0)

if (STREQ (str, pat))

*str = '\0';

}

return str;

Line 4896 lt_setenv (const char *name, const char *value)

Line 6241 lt_setenv (const char *name, const char *value)

char *str = xstrdup (value);

setenv (name, str, 1);

#else

int len = strlen (name) + 1 + strlen (value) + 1;

size_t len = strlen (name) + 1 + strlen (value) + 1;

char *str = XMALLOC (char, len);

sprintf (str, "%s=%s", name, value);

if (putenv (str) != EXIT_SUCCESS)

Line 4913 lt_extend_str (const char *orig_value, const char *add

Line 6258 lt_extend_str (const char *orig_value, const char *add

char *new_value;

if (orig_value && *orig_value)

{

int orig_value_len = strlen (orig_value);

size_t orig_value_len = strlen (orig_value);

int add_len = strlen (add);

size_t add_len = strlen (add);

new_value = XMALLOC (char, add_len + orig_value_len + 1);

if (to_end)

{

Line 4945 lt_update_exe_path (const char *name, const char *valu

Line 6290 lt_update_exe_path (const char *name, const char *valu

{

char *new_value = lt_extend_str (getenv (name), value, 0);

/* some systems can't cope with a ':'-terminated path #' */

int len = strlen (new_value);

size_t len = strlen (new_value);

while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))

while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))

{

new_value[len-1] = '\0';

new_value[--len] = '\0';

}

lt_setenv (name, new_value);

XFREE (new_value);

Line 5115 EOF

Line 6460 EOF

# True if ARG is an import lib, as indicated by $file_magic_cmd

func_win32_import_lib_p ()

{

$opt_debug

$debug_cmd

case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in

*import*) : ;;

*) false ;;

esac

}

# func_suncc_cstd_abi

# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!

# Several compiler flags select an ABI that is incompatible with the

# Cstd library. Avoid specifying it if any are in CXXFLAGS.

func_suncc_cstd_abi ()

{

$debug_cmd

case " $compile_command " in

*" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)

suncc_use_cstd_abi=no

;;

suncc_use_cstd_abi=yes

;;

esac

}

# func_mode_link arg...

func_mode_link ()

{

$opt_debug

$debug_cmd

case $host in

*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)

# It is impossible to link a dll without this setting, and

# we shouldn't force the makefile maintainer to figure out

# which system we are compiling for in order to pass an extra

# what system we are compiling for in order to pass an extra

# flag for every libtool invocation.

# allow_undefined=no

# FIXME: Unfortunately, there are problems with the above when trying

# to make a dll which has undefined symbols, in which case not

# to make a dll that has undefined symbols, in which case not

# even a static library is built. For now, we need to specify

# -no-undefined on the libtool link line when we can be certain

# that all symbols are satisfied, otherwise we get a static library.

Line 5179 func_mode_link ()

Line 6544 func_mode_link ()

module=no

no_install=no

objs=

os2dllname=

non_pic_objects=

precious_files_regex=

prefer_static_libs=no

preload=no

preload=false

prev=

prevarg=

release=

Line 5194 func_mode_link ()

Line 6560 func_mode_link ()

vinfo=

vinfo_number=no

weak_libs=

single_module="${wl}-single_module"

single_module=$wl-single_module

func_infer_tag $base_compile

# We need to know -static, to get the right output filenames.

Line 5202 func_mode_link ()

Line 6568 func_mode_link ()

case $arg in

-shared)

test "$build_libtool_libs" != yes && \

test yes != "$build_libtool_libs" \

func_fatal_configuration "can not build a shared library"

&& func_fatal_configuration "cannot build a shared library"

build_old_libs=no

break

;;

-all-static | -static | -static-libtool-libs)

case $arg in

-all-static)

if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then

func_warning "complete static linking is impossible in this configuration"

if test -n "$link_static_flag"; then

Line 5243 func_mode_link ()

Line 6609 func_mode_link ()

# Go through the arguments, transforming them on the way.

while test "$#" -gt 0; do

arg="$1"

arg=$1

shift

func_quote_for_eval "$arg"

qarg=$func_quote_for_eval_unquoted_result

Line 5260 func_mode_link ()

Line 6626 func_mode_link ()

case $prev in

bindir)

bindir="$arg"

bindir=$arg

prev=

continue

;;

dlfiles|dlprefiles)

if test "$preload" = no; then

$preload || {

# Add the symbol object into the linking commands.

func_append compile_command " @SYMFILE@"

func_append finalize_command " @SYMFILE@"

preload=yes

preload=:

}

case $arg in

*.la | *.lo) ;; # We handle these cases below.

force)

if test "$dlself" = no; then

if test no = "$dlself"; then

dlself=needless

export_dynamic=yes

Line 5282 func_mode_link ()

Line 6648 func_mode_link ()

continue

;;

self)

if test "$prev" = dlprefiles; then

if test dlprefiles = "$prev"; then

dlself=yes

elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then

elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then

dlself=yes

else

dlself=needless

Line 5294 func_mode_link ()

Line 6660 func_mode_link ()

continue

;;

if test "$prev" = dlfiles; then

if test dlfiles = "$prev"; then

func_append dlfiles " $arg"

else

func_append dlprefiles " $arg"

Line 5305 func_mode_link ()

Line 6671 func_mode_link ()

esac

;;

expsyms)

export_symbols="$arg"

export_symbols=$arg

test -f "$arg" \

|| func_fatal_error "symbol file \`$arg' does not exist"

|| func_fatal_error "symbol file '$arg' does not exist"

prev=

continue

;;

expsyms_regex)

export_symbols_regex="$arg"

export_symbols_regex=$arg

prev=

continue

;;

Line 5330 func_mode_link ()

Line 6696 func_mode_link ()

continue

;;

inst_prefix)

inst_prefix_dir="$arg"

inst_prefix_dir=$arg

prev=

continue

;;

mllvm)

# Clang does not use LLVM to link, so we can simply discard any

# '-mllvm $arg' options when doing the link step.

prev=

continue

;;

objectlist)

if test -f "$arg"; then

save_arg=$arg

Line 5354 func_mode_link ()

Line 6726 func_mode_link ()

if test -z "$pic_object" ||

test -z "$non_pic_object" ||

test "$pic_object" = none &&

test none = "$pic_object" &&

test "$non_pic_object" = none; then

test none = "$non_pic_object"; then

func_fatal_error "cannot find name of object for \`$arg'"

func_fatal_error "cannot find name of object for '$arg'"

# Extract subdirectory from the argument.

func_dirname "$arg" "/" ""

xdir="$func_dirname_result"

xdir=$func_dirname_result

if test "$pic_object" != none; then

if test none != "$pic_object"; then

# Prepend the subdirectory the object is found in.

pic_object="$xdir$pic_object"

pic_object=$xdir$pic_object

if test "$prev" = dlfiles; then

if test dlfiles = "$prev"; then

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then

func_append dlfiles " $pic_object"

prev=

continue

Line 5379 func_mode_link ()

Line 6751 func_mode_link ()

# CHECK ME: I think I busted this. -Ossama

if test "$prev" = dlprefiles; then

if test dlprefiles = "$prev"; then

# Preload the old-style object.

func_append dlprefiles " $pic_object"

prev=

Line 5387 func_mode_link ()

Line 6759 func_mode_link ()

# A PIC object.

func_append libobjs " $pic_object"

arg="$pic_object"

arg=$pic_object

# Non-PIC object.

if test "$non_pic_object" != none; then

if test none != "$non_pic_object"; then

# Prepend the subdirectory the object is found in.

non_pic_object="$xdir$non_pic_object"

non_pic_object=$xdir$non_pic_object

# A standard non-PIC object

func_append non_pic_objects " $non_pic_object"

if test -z "$pic_object" || test "$pic_object" = none ; then

if test -z "$pic_object" || test none = "$pic_object"; then

arg="$non_pic_object"

arg=$non_pic_object

else

# If the PIC object exists, use it instead.

# $xdir was prepended to $pic_object above.

non_pic_object="$pic_object"

non_pic_object=$pic_object

func_append non_pic_objects " $non_pic_object"

else

Line 5411 func_mode_link ()

Line 6783 func_mode_link ()

if $opt_dry_run; then

# Extract subdirectory from the argument.

func_dirname "$arg" "/" ""

xdir="$func_dirname_result"

xdir=$func_dirname_result

func_lo2o "$arg"

pic_object=$xdir$objdir/$func_lo2o_result

Line 5419 func_mode_link ()

Line 6791 func_mode_link ()

func_append libobjs " $pic_object"

func_append non_pic_objects " $non_pic_object"

else

func_fatal_error "\`$arg' is not a valid libtool object"

func_fatal_error "'$arg' is not a valid libtool object"

done

else

func_fatal_error "link input file \`$arg' does not exist"

func_fatal_error "link input file '$arg' does not exist"

arg=$save_arg

prev=

continue

;;

os2dllname)

os2dllname=$arg

prev=

continue

;;

precious_regex)

precious_files_regex="$arg"

precious_files_regex=$arg

prev=

continue

;;

release)

release="-$arg"

release=-$arg

prev=

continue

;;

Line 5448 func_mode_link ()

Line 6825 func_mode_link ()

func_fatal_error "only absolute run-paths are allowed"

;;

esac

if test "$prev" = rpath; then

if test rpath = "$prev"; then

case "$rpath " in

*" $arg "*) ;;

*) func_append rpath " $arg" ;;

Line 5463 func_mode_link ()

Line 6840 func_mode_link ()

continue

;;

shrext)

shrext_cmds="$arg"

shrext_cmds=$arg

prev=

continue

;;

Line 5503 func_mode_link ()

Line 6880 func_mode_link ()

esac

fi # test -n "$prev"

prevarg="$arg"

prevarg=$arg

case $arg in

-all-static)

Line 5517 func_mode_link ()

Line 6894 func_mode_link ()

-allow-undefined)

# FIXME: remove this flag sometime in the future.

func_fatal_error "\`-allow-undefined' must not be used because it is the default"

func_fatal_error "'-allow-undefined' must not be used because it is the default"

;;

-avoid-version)

Line 5549 func_mode_link ()

Line 6926 func_mode_link ()

if test -n "$export_symbols" || test -n "$export_symbols_regex"; then

func_fatal_error "more than one -exported-symbols argument is not allowed"

if test "X$arg" = "X-export-symbols"; then

if test X-export-symbols = "X$arg"; then

prev=expsyms

else

prev=expsyms_regex

Line 5583 func_mode_link ()

Line 6960 func_mode_link ()

func_stripname "-L" '' "$arg"

if test -z "$func_stripname_result"; then

if test "$#" -gt 0; then

func_fatal_error "require no space between \`-L' and \`$1'"

func_fatal_error "require no space between '-L' and '$1'"

else

func_fatal_error "need path for \`-L' option"

func_fatal_error "need path for '-L' option"

func_resolve_sysroot "$func_stripname_result"

Line 5596 func_mode_link ()

Line 6973 func_mode_link ()

absdir=`cd "$dir" && pwd`

test -z "$absdir" && \

func_fatal_error "cannot determine absolute directory name of \`$dir'"

func_fatal_error "cannot determine absolute directory name of '$dir'"

dir="$absdir"

dir=$absdir

;;

esac

case "$deplibs " in

Line 5628 func_mode_link ()

Line 7005 func_mode_link ()

esac

;;

esac

deplibs="$deplibs $arg"

continue

;;

-l*)

if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then

if test X-lc = "X$arg" || test X-lm = "X$arg"; then

case $host in

# These systems don't actually have a C or math library (as such)

Line 5641 func_mode_link ()

Line 7017 func_mode_link ()

;;

*-*-os2*)

# These systems don't actually have a C library (as such)

test "X$arg" = "X-lc" && continue

test X-lc = "X$arg" && continue

;;

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)

# Do not include libc due to us having libc/libc_r.

test "X$arg" = "X-lc" && continue

test X-lc = "X$arg" && continue

;;

*-*-rhapsody* | *-*-darwin1.[012])

# Rhapsody C and math libraries are in the System framework

Line 5654 func_mode_link ()

Line 7030 func_mode_link ()

;;

*-*-sco3.2v5* | *-*-sco5v6*)

# Causes problems with __ctype

test "X$arg" = "X-lc" && continue

test X-lc = "X$arg" && continue

;;

*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)

# Compiler inserts libc in the correct place for threads to work

test "X$arg" = "X-lc" && continue

test X-lc = "X$arg" && continue

;;

esac

elif test "X$arg" = "X-lc_r"; then

elif test X-lc_r = "X$arg"; then

case $host in

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)

*-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)

# Do not include libc_r directly, use -pthread flag.

continue

;;

Line 5673 func_mode_link ()

Line 7049 func_mode_link ()

continue

;;

-mllvm)

prev=mllvm

continue

;;

-module)

module=yes

continue

Line 5702 func_mode_link ()

Line 7083 func_mode_link ()

;;

-multi_module)

single_module="${wl}-multi_module"

single_module=$wl-multi_module

continue

;;

Line 5716 func_mode_link ()

Line 7097 func_mode_link ()

# The PATH hackery in wrapper scripts is required on Windows

# and Darwin in order for the loader to find any dlls it needs.

func_warning "\`-no-install' is ignored for $host"

func_warning "'-no-install' is ignored for $host"

func_warning "assuming \`-no-fast-install' instead"

func_warning "assuming '-no-fast-install' instead"

fast_install=no

;;

*) no_install=yes ;;

Line 5735 func_mode_link ()

Line 7116 func_mode_link ()

continue

;;

-os2dllname)

prev=os2dllname

continue

;;

-o) prev=output ;;

-precious-files-regex)

Line 5822 func_mode_link ()

Line 7208 func_mode_link ()

func_stripname '-Wc,' '' "$arg"

args=$func_stripname_result

arg=

save_ifs="$IFS"; IFS=','

save_ifs=$IFS; IFS=,

for flag in $args; do

IFS="$save_ifs"

IFS=$save_ifs

func_quote_for_eval "$flag"

func_append arg " $func_quote_for_eval_result"

func_append compiler_flags " $func_quote_for_eval_result"

done

IFS="$save_ifs"

IFS=$save_ifs

func_stripname ' ' '' "$arg"

arg=$func_stripname_result

;;

Line 5838 func_mode_link ()

Line 7224 func_mode_link ()

func_stripname '-Wl,' '' "$arg"

args=$func_stripname_result

arg=

save_ifs="$IFS"; IFS=','

save_ifs=$IFS; IFS=,

for flag in $args; do

IFS="$save_ifs"

IFS=$save_ifs

func_quote_for_eval "$flag"

func_append arg " $wl$func_quote_for_eval_result"

func_append compiler_flags " $wl$func_quote_for_eval_result"

func_append linker_flags " $func_quote_for_eval_result"

done

IFS="$save_ifs"

IFS=$save_ifs

func_stripname ' ' '' "$arg"

arg=$func_stripname_result

;;

Line 5869 func_mode_link ()

Line 7255 func_mode_link ()

# -msg_* for osf cc

-msg_*)

func_quote_for_eval "$arg"

arg="$func_quote_for_eval_result"

arg=$func_quote_for_eval_result

;;

# Flags to be passed through unchanged, with rationale:

Line 5881 func_mode_link ()

Line 7267 func_mode_link ()

# -m*, -t[45]*, -txscale* architecture-specific flags for GCC

# -F/path path to uninstalled frameworks, gcc on darwin

# -p, -pg, --coverage, -fprofile-* profiling flags for GCC

# -fstack-protector* stack protector flags for GCC

# @file GCC response files

# -tp=* Portland pgcc target processor selection

# --sysroot=* for sysroot support

# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

# -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization

# -stdlib=* select c++ std lib with clang

-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \

-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \

-O*|-flto*|-fwhopr*|-fuse-linker-plugin)

func_quote_for_eval "$arg"

arg="$func_quote_for_eval_result"

arg=$func_quote_for_eval_result

func_append compile_command " $arg"

func_append finalize_command " $arg"

func_append compiler_flags " $arg"

continue

;;

-Z*)

if test os2 = "`expr $host : '.*$os2$'`"; then

# OS/2 uses -Zxxx to specify OS/2-specific options

compiler_flags="$compiler_flags $arg"

func_append compile_command " $arg"

func_append finalize_command " $arg"

case $arg in

-Zlinker | -Zstack)

prev=xcompiler

;;

esac

continue

else

# Otherwise treat like 'Some other compiler flag' below

func_quote_for_eval "$arg"

arg=$func_quote_for_eval_result

;;

# Some other compiler flag.

-* | +*)

func_quote_for_eval "$arg"

arg="$func_quote_for_eval_result"

arg=$func_quote_for_eval_result

;;

*.$objext)

Line 5920 func_mode_link ()

Line 7327 func_mode_link ()

if test -z "$pic_object" ||

test -z "$non_pic_object" ||

test "$pic_object" = none &&

test none = "$pic_object" &&

test "$non_pic_object" = none; then

test none = "$non_pic_object"; then

func_fatal_error "cannot find name of object for \`$arg'"

func_fatal_error "cannot find name of object for '$arg'"

# Extract subdirectory from the argument.

func_dirname "$arg" "/" ""

xdir="$func_dirname_result"

xdir=$func_dirname_result

if test "$pic_object" != none; then

test none = "$pic_object" || {

# Prepend the subdirectory the object is found in.

pic_object="$xdir$pic_object"

pic_object=$xdir$pic_object

if test "$prev" = dlfiles; then

if test dlfiles = "$prev"; then

if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then

if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then

func_append dlfiles " $pic_object"

prev=

continue

Line 5945 func_mode_link ()

Line 7352 func_mode_link ()

# CHECK ME: I think I busted this. -Ossama

if test "$prev" = dlprefiles; then

if test dlprefiles = "$prev"; then

# Preload the old-style object.

func_append dlprefiles " $pic_object"

prev=

Line 5953 func_mode_link ()

Line 7360 func_mode_link ()

# A PIC object.

func_append libobjs " $pic_object"

arg="$pic_object"

arg=$pic_object

}

# Non-PIC object.

if test "$non_pic_object" != none; then

if test none != "$non_pic_object"; then

# Prepend the subdirectory the object is found in.

non_pic_object="$xdir$non_pic_object"

non_pic_object=$xdir$non_pic_object

# A standard non-PIC object

func_append non_pic_objects " $non_pic_object"

if test -z "$pic_object" || test "$pic_object" = none ; then

if test -z "$pic_object" || test none = "$pic_object"; then

arg="$non_pic_object"

arg=$non_pic_object

else

# If the PIC object exists, use it instead.

# $xdir was prepended to $pic_object above.

non_pic_object="$pic_object"

non_pic_object=$pic_object

func_append non_pic_objects " $non_pic_object"

else

Line 5977 func_mode_link ()

Line 7384 func_mode_link ()

if $opt_dry_run; then

# Extract subdirectory from the argument.

func_dirname "$arg" "/" ""

xdir="$func_dirname_result"

xdir=$func_dirname_result

func_lo2o "$arg"

pic_object=$xdir$objdir/$func_lo2o_result

Line 5985 func_mode_link ()

Line 7392 func_mode_link ()

func_append libobjs " $pic_object"

func_append non_pic_objects " $non_pic_object"

else

func_fatal_error "\`$arg' is not a valid libtool object"

func_fatal_error "'$arg' is not a valid libtool object"

;;

Line 6001 func_mode_link ()

Line 7408 func_mode_link ()

# A libtool-controlled library.

func_resolve_sysroot "$arg"

if test "$prev" = dlfiles; then

if test dlfiles = "$prev"; then

# This library was specified with -dlopen.

func_append dlfiles " $func_resolve_sysroot_result"

prev=

elif test "$prev" = dlprefiles; then

elif test dlprefiles = "$prev"; then

# The library was specified with -dlpreopen.

func_append dlprefiles " $func_resolve_sysroot_result"

prev=

Line 6020 func_mode_link ()

Line 7427 func_mode_link ()

# Unknown arguments in both finalize_command and compile_command need

# to be aesthetically quoted because they are evaled later.

func_quote_for_eval "$arg"

arg="$func_quote_for_eval_result"

arg=$func_quote_for_eval_result

;;

esac # arg

Line 6032 func_mode_link ()

Line 7439 func_mode_link ()

done # argument parsing loop

test -n "$prev" && \

func_fatal_help "the \`$prevarg' option requires an argument"

func_fatal_help "the '$prevarg' option requires an argument"

if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then

if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then

eval arg=\"$export_dynamic_flag_spec\"

func_append compile_command " $arg"

func_append finalize_command " $arg"

Line 6043 func_mode_link ()

Line 7450 func_mode_link ()

oldlibs=

# calculate the name of the file, without its directory

func_basename "$output"

outputname="$func_basename_result"

outputname=$func_basename_result

libobjs_save="$libobjs"

libobjs_save=$libobjs

if test -n "$shlibpath_var"; then

# get the directories listed in $shlibpath_var

eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`

eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`

else

shlib_search_path=

eval sys_lib_search_path=\"$sys_lib_search_path_spec\"

eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

# Definition is injected by LT_CONFIG during libtool generation.

func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"

func_dirname "$output" "/" ""

output_objdir="$func_dirname_result$objdir"

output_objdir=$func_dirname_result$objdir

func_to_tool_file "$output_objdir/"

tool_output_objdir=$func_to_tool_file_result

# Create the object directory.

Line 6079 func_mode_link ()

Line 7489 func_mode_link ()

# Find all interdependent deplibs by searching for libraries

# that are linked more than once (e.g. -la -lb -la)

for deplib in $deplibs; do

if $opt_preserve_dup_deps ; then

if $opt_preserve_dup_deps; then

case "$libs " in

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

esac

Line 6087 func_mode_link ()

Line 7497 func_mode_link ()

func_append libs " $deplib"

done

if test "$linkmode" = lib; then

if test lib = "$linkmode"; then

libs="$predeps $libs $compiler_lib_search_path $postdeps"

# Compute libraries that are listed more than once in $predeps

Line 6119 func_mode_link ()

Line 7529 func_mode_link ()

case $file in

*.la) ;;

func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"

func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"

;;

esac

done

Line 6127 func_mode_link ()

Line 7537 func_mode_link ()

prog)

compile_deplibs=

finalize_deplibs=

alldeplibs=no

alldeplibs=false

newdlfiles=

newdlprefiles=

passes="conv scan dlopen dlpreopen link"

Line 6139 func_mode_link ()

Line 7549 func_mode_link ()

for pass in $passes; do

# The preopen pass in lib mode reverses $deplibs; put it back here

# so that -L comes before libs that need it for instance...

if test "$linkmode,$pass" = "lib,link"; then

if test lib,link = "$linkmode,$pass"; then

## FIXME: Find the place where the list is rebuilt in the wrong

## order, and fix it there properly

tmp_deplibs=

for deplib in $deplibs; do

tmp_deplibs="$deplib $tmp_deplibs"

done

deplibs="$tmp_deplibs"

deplibs=$tmp_deplibs

if test "$linkmode,$pass" = "lib,link" ||

if test lib,link = "$linkmode,$pass" ||

test "$linkmode,$pass" = "prog,scan"; then

test prog,scan = "$linkmode,$pass"; then

libs="$deplibs"

libs=$deplibs

deplibs=

if test "$linkmode" = prog; then

if test prog = "$linkmode"; then

case $pass in

dlopen) libs="$dlfiles" ;;

dlopen) libs=$dlfiles ;;

dlpreopen) libs="$dlprefiles" ;;

dlpreopen) libs=$dlprefiles ;;

link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;

esac

if test "$linkmode,$pass" = "lib,dlpreopen"; then

if test lib,dlpreopen = "$linkmode,$pass"; then

# Collect and forward deplibs of preopened libtool libs

for lib in $dlprefiles; do

# Ignore non-libtool-libs

Line 6182 func_mode_link ()

Line 7592 func_mode_link ()

esac

done

libs="$dlprefiles"

libs=$dlprefiles

if test "$pass" = dlopen; then

if test dlopen = "$pass"; then

# Collect dlpreopened libraries

save_deplibs="$deplibs"

save_deplibs=$deplibs

deplibs=

for deplib in $libs; do

lib=

found=no

found=false

case $deplib in

if test "$linkmode,$pass" = "prog,link"; then

if test prog,link = "$linkmode,$pass"; then

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

else

func_append compiler_flags " $deplib"

if test lib = "$linkmode"; then

case "$new_inherited_linker_flags " in

case $linkmode in

*" $deplib "*) ;;

lib)

* ) func_append new_inherited_linker_flags " $deplib" ;;

deplibs="$deplib $deplibs"

esac

test "$pass" = conv && continue

newdependency_libs="$deplib $newdependency_libs"

;;

prog)

if test "$pass" = conv; then

deplibs="$deplib $deplibs"

continue

if test "$pass" = scan; then

deplibs="$deplib $deplibs"

else

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

;;

esac # linkmode

continue

;;

-l*)

if test "$linkmode" != lib && test "$linkmode" != prog; then

if test lib != "$linkmode" && test prog != "$linkmode"; then

func_warning "\`-l' is ignored for archives/objects"

func_warning "'-l' is ignored for archives/objects"

continue

func_stripname '-l' '' "$deplib"

name=$func_stripname_result

if test "$linkmode" = lib; then

if test lib = "$linkmode"; then

searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"

else

searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"

Line 6242 func_mode_link ()

Line 7635 func_mode_link ()

for searchdir in $searchdirs; do

for search_ext in .la $std_shrext .so .a; do

# Search the libtool library

lib="$searchdir/lib${name}${search_ext}"

lib=$searchdir/lib$name$search_ext

if test -f "$lib"; then

if test "$search_ext" = ".la"; then

if test .la = "$search_ext"; then

found=yes

found=:

else

found=no

found=false

break 2

done

if test "$found" != yes; then

if $found; then

# deplib doesn't seem to be a libtool library

# deplib is a libtool library

if test "$linkmode,$pass" = "prog,link"; then

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

else

deplibs="$deplib $deplibs"

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

continue

else # deplib is a libtool library

# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,

# We need to do some special things here, and not later.

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

case " $predeps $postdeps " in

*" $deplib "*)

if func_lalib_p "$lib"; then

Line 6274 func_mode_link ()

Line 7658 func_mode_link ()

old_library=

func_source "$lib"

for l in $old_library $library_names; do

ll="$l"

ll=$l

done

if test "X$ll" = "X$old_library" ; then # only static version available

if test "X$ll" = "X$old_library"; then # only static version available

found=no

found=false

func_dirname "$lib" "" "."

ladir="$func_dirname_result"

ladir=$func_dirname_result

lib=$ladir/$old_library

if test "$linkmode,$pass" = "prog,link"; then

if test prog,link = "$linkmode,$pass"; then

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

else

deplibs="$deplib $deplibs"

test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"

test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"

continue

Line 6295 func_mode_link ()

Line 7679 func_mode_link ()

*) ;;

esac

else

# deplib doesn't seem to be a libtool library

if test prog,link = "$linkmode,$pass"; then

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

else

deplibs="$deplib $deplibs"

test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"

continue

;; # -l

*.ltframework)

if test "$linkmode,$pass" = "prog,link"; then

if test prog,link = "$linkmode,$pass"; then

compile_deplibs="$deplib $compile_deplibs"

finalize_deplibs="$deplib $finalize_deplibs"

else

deplibs="$deplib $deplibs"

if test "$linkmode" = lib ; then

if test lib = "$linkmode"; then

case "$new_inherited_linker_flags " in

*" $deplib "*) ;;

* ) func_append new_inherited_linker_flags " $deplib" ;;

Line 6316 func_mode_link ()

Line 7710 func_mode_link ()

case $linkmode in

lib)

deplibs="$deplib $deplibs"

test "$pass" = conv && continue

test conv = "$pass" && continue

newdependency_libs="$deplib $newdependency_libs"

func_stripname '-L' '' "$deplib"

func_resolve_sysroot "$func_stripname_result"

func_append newlib_search_path " $func_resolve_sysroot_result"

;;

prog)

if test "$pass" = conv; then

if test conv = "$pass"; then

deplibs="$deplib $deplibs"

continue

if test "$pass" = scan; then

if test scan = "$pass"; then

deplibs="$deplib $deplibs"

else

compile_deplibs="$deplib $compile_deplibs"

Line 6338 func_mode_link ()

Line 7732 func_mode_link ()

func_append newlib_search_path " $func_resolve_sysroot_result"

;;

func_warning "\`-L' is ignored for archives/objects"

func_warning "'-L' is ignored for archives/objects"

;;

esac # linkmode

continue

;; # -L

-R*)

if test "$pass" = link; then

if test link = "$pass"; then

func_stripname '-R' '' "$deplib"

func_resolve_sysroot "$func_stripname_result"

dir=$func_resolve_sysroot_result

Line 6362 func_mode_link ()

Line 7756 func_mode_link ()

lib=$func_resolve_sysroot_result

;;

*.$libext)

if test "$pass" = conv; then

if test conv = "$pass"; then

deplibs="$deplib $deplibs"

continue

Line 6373 func_mode_link ()

Line 7767 func_mode_link ()

case " $dlpreconveniencelibs " in

*" $deplib "*) ;;

valid_a_lib=no

valid_a_lib=false

case $deplibs_check_method in

match_pattern*)

set dummy $deplibs_check_method; shift

match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`

if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \

| $EGREP "$match_pattern_regex" > /dev/null; then

valid_a_lib=yes

valid_a_lib=:

;;

pass_all)

valid_a_lib=yes

valid_a_lib=:

;;

esac

if test "$valid_a_lib" != yes; then

if $valid_a_lib; then

echo

$ECHO "*** Warning: Linking the shared library $output against the"

$ECHO "*** static library $deplib is not portable!"

deplibs="$deplib $deplibs"

else

echo

$ECHO "*** Warning: Trying to link with static lib archive $deplib."

echo "*** I have the capability to make that library automatically link in when"

echo "*** you link to this library. But I can only do this if you have a"

echo "*** shared version of the library, which you do not appear to have"

echo "*** because the file extensions .$libext of this argument makes me believe"

echo "*** that it is just a static archive that I should not use here."

else

echo

$ECHO "*** Warning: Linking the shared library $output against the"

$ECHO "*** static library $deplib is not portable!"

deplibs="$deplib $deplibs"

;;

esac

continue

;;

prog)

if test "$pass" != link; then

if test link != "$pass"; then

deplibs="$deplib $deplibs"

else

compile_deplibs="$deplib $compile_deplibs"

Line 6417 func_mode_link ()

Line 7811 func_mode_link ()

esac # linkmode

;; # *.$libext

*.lo | *.$objext)

if test "$pass" = conv; then

if test conv = "$pass"; then

deplibs="$deplib $deplibs"

elif test "$linkmode" = prog; then

elif test prog = "$linkmode"; then

if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then

if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then

# If there is no dlopen support or we're linking statically,

# we need to preload.

func_append newdlprefiles " $deplib"

Line 6433 func_mode_link ()

Line 7827 func_mode_link ()

continue

;;

%DEPLIBS%)

alldeplibs=yes

alldeplibs=:

continue

;;

esac # case $deplib

if test "$found" = yes || test -f "$lib"; then :

$found || test -f "$lib" \

else

|| func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"

func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"

# Check to see that this really is a libtool archive.

func_lalib_unsafe_p "$lib" \

|| func_fatal_error "\`$lib' is not a valid libtool archive"

|| func_fatal_error "'$lib' is not a valid libtool archive"

func_dirname "$lib" "" "."

ladir="$func_dirname_result"

ladir=$func_dirname_result

dlname=

dlopen=

Line 6478 func_mode_link ()

Line 7870 func_mode_link ()

done

dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

if test "$linkmode,$pass" = "lib,link" ||

if test lib,link = "$linkmode,$pass" ||

test "$linkmode,$pass" = "prog,scan" ||

test prog,scan = "$linkmode,$pass" ||

{ test "$linkmode" != prog && test "$linkmode" != lib; }; then

{ test prog != "$linkmode" && test lib != "$linkmode"; }; then

test -n "$dlopen" && func_append dlfiles " $dlopen"

test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"

if test "$pass" = conv; then

if test conv = "$pass"; then

# Only check for convenience libraries

deplibs="$lib $deplibs"

if test -z "$libdir"; then

if test -z "$old_library"; then

func_fatal_error "cannot find name of link library for \`$lib'"

func_fatal_error "cannot find name of link library for '$lib'"

# It is a libtool convenience library, so add in its objects.

func_append convenience " $ladir/$objdir/$old_library"

func_append old_convenience " $ladir/$objdir/$old_library"

elif test "$linkmode" != prog && test "$linkmode" != lib; then

elif test prog != "$linkmode" && test lib != "$linkmode"; then

func_fatal_error "\`$lib' is not a convenience library"

func_fatal_error "'$lib' is not a convenience library"

tmp_libs=

for deplib in $dependency_libs; do

deplibs="$deplib $deplibs"

if $opt_preserve_dup_deps ; then

if $opt_preserve_dup_deps; then

case "$tmp_libs " in

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

esac

Line 6515 func_mode_link ()

Line 7907 func_mode_link ()

# Get the name of the library we link against.

linklib=

if test -n "$old_library" &&

{ test "$prefer_static_libs" = yes ||

{ test yes = "$prefer_static_libs" ||

test "$prefer_static_libs,$installed" = "built,no"; }; then

test built,no = "$prefer_static_libs,$installed"; }; then

linklib=$old_library

else

for l in $old_library $library_names; do

linklib="$l"

linklib=$l

done

if test -z "$linklib"; then

func_fatal_error "cannot find name of link library for \`$lib'"

func_fatal_error "cannot find name of link library for '$lib'"

# This library was specified with -dlopen.

if test "$pass" = dlopen; then

if test dlopen = "$pass"; then

if test -z "$libdir"; then

test -z "$libdir" \

func_fatal_error "cannot -dlopen a convenience library: \`$lib'"

&& func_fatal_error "cannot -dlopen a convenience library: '$lib'"

if test -z "$dlname" ||

test "$dlopen_support" != yes ||

test yes != "$dlopen_support" ||

test "$build_libtool_libs" = no; then

test no = "$build_libtool_libs"

then

# If there is no dlname, no dlopen support or we're linking

# statically, we need to preload. We also need to preload any

# dependent libraries so libltdl's deplib preloader doesn't

Line 6548 func_mode_link ()

Line 7940 func_mode_link ()

# We need an absolute path.

case $ladir in

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;

[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;

abs_ladir=`cd "$ladir" && pwd`

if test -z "$abs_ladir"; then

func_warning "cannot determine absolute directory name of \`$ladir'"

func_warning "cannot determine absolute directory name of '$ladir'"

func_warning "passing it literally to the linker, although it might fail"

abs_ladir="$ladir"

abs_ladir=$ladir

;;

esac

func_basename "$lib"

laname="$func_basename_result"

laname=$func_basename_result

# Find the relevant object directory and library name.

if test "X$installed" = Xyes; then

if test yes = "$installed"; then

if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then

func_warning "library \`$lib' was moved."

func_warning "library '$lib' was moved."

dir="$ladir"

dir=$ladir

absdir="$abs_ladir"

absdir=$abs_ladir

libdir="$abs_ladir"

libdir=$abs_ladir

else

dir="$lt_sysroot$libdir"

dir=$lt_sysroot$libdir

absdir="$lt_sysroot$libdir"

absdir=$lt_sysroot$libdir

test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes

test yes = "$hardcode_automatic" && avoidtemprpath=yes

else

if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then

dir="$ladir"

dir=$ladir

absdir="$abs_ladir"

absdir=$abs_ladir

# Remove this search path later

func_append notinst_path " $abs_ladir"

else

dir="$ladir/$objdir"

dir=$ladir/$objdir

absdir="$abs_ladir/$objdir"

absdir=$abs_ladir/$objdir

# Remove this search path later

func_append notinst_path " $abs_ladir"

Line 6590 func_mode_link ()

Line 7982 func_mode_link ()

name=$func_stripname_result

# This library was specified with -dlpreopen.

if test "$pass" = dlpreopen; then

if test dlpreopen = "$pass"; then

if test -z "$libdir" && test "$linkmode" = prog; then

if test -z "$libdir" && test prog = "$linkmode"; then

func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"

func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"

case "$host" in

case $host in

# special handling for platforms with PE-DLLs.

*cygwin* | *mingw* | *cegcc* )

# Linker will automatically link against shared library if both

Line 6638 func_mode_link ()

Line 8030 func_mode_link ()

if test -z "$libdir"; then

# Link the convenience library

if test "$linkmode" = lib; then

if test lib = "$linkmode"; then

deplibs="$dir/$old_library $deplibs"

elif test "$linkmode,$pass" = "prog,link"; then

elif test prog,link = "$linkmode,$pass"; then

compile_deplibs="$dir/$old_library $compile_deplibs"

finalize_deplibs="$dir/$old_library $finalize_deplibs"

else

Line 6650 func_mode_link ()

Line 8042 func_mode_link ()

if test "$linkmode" = prog && test "$pass" != link; then

if test prog = "$linkmode" && test link != "$pass"; then

func_append newlib_search_path " $ladir"

deplibs="$lib $deplibs"

linkalldeplibs=no

linkalldeplibs=false

if test "$link_all_deplibs" != no || test -z "$library_names" ||

if test no != "$link_all_deplibs" || test -z "$library_names" ||

test "$build_libtool_libs" = no; then

test no = "$build_libtool_libs"; then

linkalldeplibs=yes

linkalldeplibs=:

tmp_libs=

Line 6669 func_mode_link ()

Line 8061 func_mode_link ()

;;

esac

# Need to link against all dependency_libs?

if test "$linkalldeplibs" = yes; then

if $linkalldeplibs; then

deplibs="$deplib $deplibs"

else

# Need to hardcode shared library paths

# or/and link against static libraries

newdependency_libs="$deplib $newdependency_libs"

if $opt_preserve_dup_deps ; then

if $opt_preserve_dup_deps; then

case "$tmp_libs " in

*" $deplib "*) func_append specialdeplibs " $deplib" ;;

esac

Line 6686 func_mode_link ()

Line 8078 func_mode_link ()

continue

fi # $linkmode = prog...

if test "$linkmode,$pass" = "prog,link"; then

if test prog,link = "$linkmode,$pass"; then

if test -n "$library_names" &&

{ { test "$prefer_static_libs" = no ||

{ { test no = "$prefer_static_libs" ||

test "$prefer_static_libs,$installed" = "built,yes"; } ||

test built,yes = "$prefer_static_libs,$installed"; } ||

test -z "$old_library"; }; then

# We need to hardcode the library path

if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then

if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then

# Make sure the rpath contains only unique directories.

case "$temp_rpath:" in

case $temp_rpath: in

*"$absdir:"*) ;;

*) func_append temp_rpath "$absdir:" ;;

esac

Line 6723 func_mode_link ()

Line 8115 func_mode_link ()

esac

fi # $linkmode,$pass = prog,link...

if test "$alldeplibs" = yes &&

if $alldeplibs &&

{ test "$deplibs_check_method" = pass_all ||

{ test pass_all = "$deplibs_check_method" ||

{ test "$build_libtool_libs" = yes &&

{ test yes = "$build_libtool_libs" &&

test -n "$library_names"; }; }; then

# We only need to search for static libraries

continue

Line 6734 func_mode_link ()

Line 8126 func_mode_link ()

link_static=no # Whether the deplib will be linked statically

use_static_libs=$prefer_static_libs

if test "$use_static_libs" = built && test "$installed" = yes; then

if test built = "$use_static_libs" && test yes = "$installed"; then

use_static_libs=no

if test -n "$library_names" &&

{ test "$use_static_libs" = no || test -z "$old_library"; }; then

{ test no = "$use_static_libs" || test -z "$old_library"; }; then

case $host in

*cygwin* | *mingw* | *cegcc*)

*cygwin* | *mingw* | *cegcc* | *os2*)

# No point in relinking DLLs because paths are not encoded

func_append notinst_deplibs " $lib"

need_relink=no

;;

if test "$installed" = no; then

if test no = "$installed"; then

func_append notinst_deplibs " $lib"

need_relink=yes

Line 6756 func_mode_link ()

Line 8148 func_mode_link ()

# Warn about portability, can't link against -module's on some

# systems (darwin). Don't bleat about dlopened modules though!

dlopenmodule=""

dlopenmodule=

for dlpremoduletest in $dlprefiles; do

if test "X$dlpremoduletest" = "X$lib"; then

dlopenmodule="$dlpremoduletest"

dlopenmodule=$dlpremoduletest

break

done

if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then

if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then

echo

if test "$linkmode" = prog; then

if test prog = "$linkmode"; then

$ECHO "*** Warning: Linking the executable $output against the loadable module"

else

$ECHO "*** Warning: Linking the shared library $output against the loadable module"

$ECHO "*** $linklib is not portable!"

if test "$linkmode" = lib &&

if test lib = "$linkmode" &&

test "$hardcode_into_libs" = yes; then

test yes = "$hardcode_into_libs"; then

# Hardcode the library path.

# Skip directories that are in the system default run-time

# search path.

Line 6801 func_mode_link ()

Line 8193 func_mode_link ()

# figure out the soname

set dummy $library_names

shift

realname="$1"

realname=$1

shift

libname=`eval "\\$ECHO \"$libname_spec\""`

# use dlname if we got it. it's perfectly good, no?

if test -n "$dlname"; then

soname="$dlname"

soname=$dlname

elif test -n "$soname_spec"; then

# bleh windows

case $host in

*cygwin* | mingw* | *cegcc*)

*cygwin* | mingw* | *cegcc* | *os2*)

func_arith $current - $age

major=$func_arith_result

versuffix="-$major"

versuffix=-$major

;;

esac

eval soname=\"$soname_spec\"

else

soname="$realname"

soname=$realname

# Make a new name for the extract_expsyms_cmds to use

soroot="$soname"

soroot=$soname

func_basename "$soroot"

soname="$func_basename_result"

soname=$func_basename_result

func_stripname 'lib' '.dll' "$soname"

newlib=libimp-$func_stripname_result.a

# If the library has no export list, then create one now

if test -f "$output_objdir/$soname-def"; then :

else

func_verbose "extracting exported symbol list from \`$soname'"

func_verbose "extracting exported symbol list from '$soname'"

func_execute_cmds "$extract_expsyms_cmds" 'exit $?'

# Create $newlib

if test -f "$output_objdir/$newlib"; then :; else

func_verbose "generating import library for \`$soname'"

func_verbose "generating import library for '$soname'"

func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'

# make sure the library variables are pointing to the new library

Line 6845 func_mode_link ()

Line 8237 func_mode_link ()

linklib=$newlib

fi # test -n "$old_archive_from_expsyms_cmds"

if test "$linkmode" = prog || test "$opt_mode" != relink; then

if test prog = "$linkmode" || test relink != "$opt_mode"; then

add_shlibpath=

add_dir=

add=

lib_linked=yes

case $hardcode_action in

immediate | unsupported)

if test "$hardcode_direct" = no; then

if test no = "$hardcode_direct"; then

add="$dir/$linklib"

add=$dir/$linklib

case $host in

*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;

*-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;

*-*-sysv4*uw2*) add_dir="-L$dir" ;;

*-*-sysv4*uw2*) add_dir=-L$dir ;;

*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \

*-*-unixware7*) add_dir="-L$dir" ;;

*-*-unixware7*) add_dir=-L$dir ;;

*-*-darwin* )

# if the lib is a (non-dlopened) module then we can not

# if the lib is a (non-dlopened) module then we cannot

# link against it, someone is ignoring the earlier warnings

if /usr/bin/file -L $add 2> /dev/null |

$GREP ": [^:]* bundle" >/dev/null ; then

$GREP ": [^:]* bundle" >/dev/null; then

if test "X$dlopenmodule" != "X$lib"; then

$ECHO "*** Warning: lib $linklib is a module, not a shared library"

if test -z "$old_library" ; then

if test -z "$old_library"; then

echo

echo "*** And there doesn't seem to be a static archive available"

echo "*** The link will probably fail, sorry"

else

add="$dir/$old_library"

add=$dir/$old_library

elif test -n "$old_library"; then

add="$dir/$old_library"

add=$dir/$old_library

esac

elif test "$hardcode_minus_L" = no; then

elif test no = "$hardcode_minus_L"; then

case $host in

*-*-sunos*) add_shlibpath="$dir" ;;

*-*-sunos*) add_shlibpath=$dir ;;

esac

add_dir="-L$dir"

add_dir=-L$dir

add="-l$name"

add=-l$name

elif test "$hardcode_shlibpath_var" = no; then

elif test no = "$hardcode_shlibpath_var"; then

add_shlibpath="$dir"

add_shlibpath=$dir

add="-l$name"

add=-l$name

else

lib_linked=no

;;

relink)

if test "$hardcode_direct" = yes &&

if test yes = "$hardcode_direct" &&

test "$hardcode_direct_absolute" = no; then

test no = "$hardcode_direct_absolute"; then

add="$dir/$linklib"

add=$dir/$linklib

elif test "$hardcode_minus_L" = yes; then

elif test yes = "$hardcode_minus_L"; then

add_dir="-L$absdir"

add_dir=-L$absdir

# Try looking first in the location we're being installed to.

if test -n "$inst_prefix_dir"; then

case $libdir in

Line 6905 func_mode_link ()

Line 8297 func_mode_link ()

;;

esac

add="-l$name"

add=-l$name

elif test "$hardcode_shlibpath_var" = yes; then

elif test yes = "$hardcode_shlibpath_var"; then

add_shlibpath="$dir"

add_shlibpath=$dir

add="-l$name"

add=-l$name

else

lib_linked=no

Line 6916 func_mode_link ()

Line 8308 func_mode_link ()

*) lib_linked=no ;;

esac

if test "$lib_linked" != yes; then

if test yes != "$lib_linked"; then

func_fatal_configuration "unsupported hardcode properties"

Line 6926 func_mode_link ()

Line 8318 func_mode_link ()

*) func_append compile_shlibpath "$add_shlibpath:" ;;

esac

if test "$linkmode" = prog; then

if test prog = "$linkmode"; then

test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"

test -n "$add" && compile_deplibs="$add $compile_deplibs"

else

test -n "$add_dir" && deplibs="$add_dir $deplibs"

test -n "$add" && deplibs="$add $deplibs"

if test "$hardcode_direct" != yes &&

if test yes != "$hardcode_direct" &&

test "$hardcode_minus_L" != yes &&

test yes != "$hardcode_minus_L" &&

test "$hardcode_shlibpath_var" = yes; then

test yes = "$hardcode_shlibpath_var"; then

case :$finalize_shlibpath: in

*":$libdir:"*) ;;

*) func_append finalize_shlibpath "$libdir:" ;;

Line 6943 func_mode_link ()

Line 8335 func_mode_link ()

if test "$linkmode" = prog || test "$opt_mode" = relink; then

if test prog = "$linkmode" || test relink = "$opt_mode"; then

add_shlibpath=

add_dir=

add=

# Finalize command for both is simple: just hardcode it.

if test "$hardcode_direct" = yes &&

if test yes = "$hardcode_direct" &&

test "$hardcode_direct_absolute" = no; then

test no = "$hardcode_direct_absolute"; then

add="$libdir/$linklib"

add=$libdir/$linklib

elif test "$hardcode_minus_L" = yes; then

elif test yes = "$hardcode_minus_L"; then

add_dir="-L$libdir"

add_dir=-L$libdir

add="-l$name"

add=-l$name

elif test "$hardcode_shlibpath_var" = yes; then

elif test yes = "$hardcode_shlibpath_var"; then

case :$finalize_shlibpath: in

*":$libdir:"*) ;;

*) func_append finalize_shlibpath "$libdir:" ;;

esac

add="-l$name"

add=-l$name

elif test "$hardcode_automatic" = yes; then

elif test yes = "$hardcode_automatic"; then

if test -n "$inst_prefix_dir" &&

test -f "$inst_prefix_dir$libdir/$linklib" ; then

test -f "$inst_prefix_dir$libdir/$linklib"; then

add="$inst_prefix_dir$libdir/$linklib"

add=$inst_prefix_dir$libdir/$linklib

else

add="$libdir/$linklib"

add=$libdir/$linklib

else

# We cannot seem to hardcode it, guess we'll fake it.

add_dir="-L$libdir"

add_dir=-L$libdir

# Try looking first in the location we're being installed to.

if test -n "$inst_prefix_dir"; then

case $libdir in

Line 6978 func_mode_link ()

Line 8370 func_mode_link ()

;;

esac

add="-l$name"

add=-l$name

if test "$linkmode" = prog; then

if test prog = "$linkmode"; then

test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"

test -n "$add" && finalize_deplibs="$add $finalize_deplibs"

else

Line 6989 func_mode_link ()

Line 8381 func_mode_link ()

test -n "$add" && deplibs="$add $deplibs"

elif test "$linkmode" = prog; then

elif test prog = "$linkmode"; then

# Here we assume that one of hardcode_direct or hardcode_minus_L

# is not unsupported. This is valid on all known static and

# shared platforms.

if test "$hardcode_direct" != unsupported; then

if test unsupported != "$hardcode_direct"; then

test -n "$old_library" && linklib="$old_library"

test -n "$old_library" && linklib=$old_library

compile_deplibs="$dir/$linklib $compile_deplibs"

finalize_deplibs="$dir/$linklib $finalize_deplibs"

else

compile_deplibs="-l$name -L$dir $compile_deplibs"

finalize_deplibs="-l$name -L$dir $finalize_deplibs"

elif test "$build_libtool_libs" = yes; then

elif test yes = "$build_libtool_libs"; then

# Not a shared library

if test "$deplibs_check_method" != pass_all; then

if test pass_all != "$deplibs_check_method"; then

# We're trying link a shared library against a static one

# but the system doesn't support it.

# Just print a warning and add the library to dependency_libs so

# that the program can be linked against the static library.

echo

$ECHO "*** Warning: This system can not link to static lib archive $lib."

$ECHO "*** Warning: This system cannot link to static lib archive $lib."

echo "*** I have the capability to make that library automatically link in when"

echo "*** you link to this library. But I can only do this if you have a"

echo "*** shared version of the library, which you do not appear to have."

if test "$module" = yes; then

if test yes = "$module"; then

echo "*** But as you try to build a module library, libtool will still create "

echo "*** a static module, that should work as long as the dlopening application"

echo "*** is linked with the -dlopen flag to resolve symbols at runtime."

if test -z "$global_symbol_pipe"; then

echo

echo "*** However, this would only work if libtool was able to extract symbol"

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

echo "*** lists from a program, using 'nm' or equivalent, but libtool could"

echo "*** not find such a program. So, this module is probably useless."

echo "*** \`nm' from GNU binutils and a full rebuild may help."

echo "*** 'nm' from GNU binutils and a full rebuild may help."

if test "$build_old_libs" = no; then

if test no = "$build_old_libs"; then

build_libtool_libs=module

build_old_libs=yes

else

Line 7038 func_mode_link ()

Line 8430 func_mode_link ()

fi # link shared/static library?

if test "$linkmode" = lib; then

if test lib = "$linkmode"; then

if test -n "$dependency_libs" &&

{ test "$hardcode_into_libs" != yes ||

{ test yes != "$hardcode_into_libs" ||

test "$build_old_libs" = yes ||

test yes = "$build_old_libs" ||

test "$link_static" = yes; }; then

test yes = "$link_static"; }; then

# Extract -R from dependency_libs

temp_deplibs=

for libdir in $dependency_libs; do

Line 7056 func_mode_link ()

Line 8448 func_mode_link ()

*) func_append temp_deplibs " $libdir";;

esac

done

dependency_libs="$temp_deplibs"

dependency_libs=$temp_deplibs

func_append newlib_search_path " $absdir"

# Link against this library

test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"

# ... and its dependency_libs

tmp_libs=

for deplib in $dependency_libs; do

Line 7071 func_mode_link ()

Line 8463 func_mode_link ()

func_resolve_sysroot "$func_stripname_result";;

*) func_resolve_sysroot "$deplib" ;;

esac

if $opt_preserve_dup_deps ; then

if $opt_preserve_dup_deps; then

case "$tmp_libs " in

*" $func_resolve_sysroot_result "*)

func_append specialdeplibs " $func_resolve_sysroot_result" ;;

Line 7080 func_mode_link ()

Line 8472 func_mode_link ()

func_append tmp_libs " $func_resolve_sysroot_result"

done

if test "$link_all_deplibs" != no; then

if test no != "$link_all_deplibs"; then

# Add the search paths of all dependency libraries

for deplib in $dependency_libs; do

path=

case $deplib in

-L*) path="$deplib" ;;

-L*) path=$deplib ;;

*.la)

func_resolve_sysroot "$deplib"

deplib=$func_resolve_sysroot_result

Line 7093 func_mode_link ()

Line 8485 func_mode_link ()

dir=$func_dirname_result

# We need an absolute path.

case $dir in

[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;

[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;

absdir=`cd "$dir" && pwd`

if test -z "$absdir"; then

func_warning "cannot determine absolute directory name of \`$dir'"

func_warning "cannot determine absolute directory name of '$dir'"

absdir="$dir"

absdir=$dir

;;

esac

Line 7106 func_mode_link ()

Line 8498 func_mode_link ()

case $host in

*-*-darwin*)

depdepl=

eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`

eval deplibrary_names=`$SED -n -e 's/^library_names=$.*$$/\1/p' $deplib`

if test -n "$deplibrary_names" ; then

if test -n "$deplibrary_names"; then

for tmp in $deplibrary_names ; do

for tmp in $deplibrary_names; do

depdepl=$tmp

done

if test -f "$absdir/$objdir/$depdepl" ; then

if test -f "$absdir/$objdir/$depdepl"; then

depdepl="$absdir/$objdir/$depdepl"

depdepl=$absdir/$objdir/$depdepl

darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

if test -z "$darwin_install_name"; then

darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`

func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"

func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"

func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"

func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"

path=

;;

path="-L$absdir/$objdir"

path=-L$absdir/$objdir

;;

esac

else

eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`

eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $deplib`

test -z "$libdir" && \

func_fatal_error "\`$deplib' is not a valid libtool archive"

func_fatal_error "'$deplib' is not a valid libtool archive"

test "$absdir" != "$libdir" && \

func_warning "\`$deplib' seems to be moved"

func_warning "'$deplib' seems to be moved"

path="-L$absdir"

path=-L$absdir

;;

esac

Line 7146 func_mode_link ()

Line 8538 func_mode_link ()

fi # link_all_deplibs != no

fi # linkmode = lib

done # for deplib in $libs

if test "$pass" = link; then

if test link = "$pass"; then

if test "$linkmode" = "prog"; then

if test prog = "$linkmode"; then

compile_deplibs="$new_inherited_linker_flags $compile_deplibs"

finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"

else

compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $[^ $]*$.ltframework% -framework \1%g'`

dependency_libs="$newdependency_libs"

dependency_libs=$newdependency_libs

if test "$pass" = dlpreopen; then

if test dlpreopen = "$pass"; then

# Link the dlpreopened libraries before other libraries

for deplib in $save_deplibs; do

deplibs="$deplib $deplibs"

done

if test "$pass" != dlopen; then

if test dlopen != "$pass"; then

if test "$pass" != conv; then

test conv = "$pass" || {

# Make sure lib_search_path contains only unique directories.

lib_search_path=

for dir in $newlib_search_path; do

Line 7172 func_mode_link ()

Line 8564 func_mode_link ()

esac

done

newlib_search_path=

}

if test "$linkmode,$pass" != "prog,link"; then

if test prog,link = "$linkmode,$pass"; then

vars="deplibs"

else

vars="compile_deplibs finalize_deplibs"

else

vars=deplibs

for var in $vars dependency_libs; do

# Add libraries to $var in reverse order

Line 7235 func_mode_link ()

Line 8627 func_mode_link ()

eval $var=\"$tmp_libs\"

done # for var

# Add Sun CC postdeps if required:

test CXX = "$tagname" && {

case $host_os in

linux*)

case `$CC -V 2>&1 | sed 5q` in

*Sun\ C*) # Sun C++ 5.9

func_suncc_cstd_abi

if test no != "$suncc_use_cstd_abi"; then

func_append postdeps ' -library=Cstd -library=Crun'

;;

esac

;;

solaris*)

func_cc_basename "$CC"

case $func_cc_basename_result in

CC* | sunCC*)

func_suncc_cstd_abi

if test no != "$suncc_use_cstd_abi"; then

func_append postdeps ' -library=Cstd -library=Crun'

;;

esac

;;

esac

}

# Last step: remove runtime libs from dependency_libs

# (they stay in deplibs)

tmp_libs=

for i in $dependency_libs ; do

for i in $dependency_libs; do

case " $predeps $postdeps $compiler_lib_search_path " in

*" $i "*)

i=""

;;

esac

if test -n "$i" ; then

if test -n "$i"; then

func_append tmp_libs " $i"

done

dependency_libs=$tmp_libs

done # for pass

if test "$linkmode" = prog; then

if test prog = "$linkmode"; then

dlfiles="$newdlfiles"

dlfiles=$newdlfiles

if test "$linkmode" = prog || test "$linkmode" = lib; then

if test prog = "$linkmode" || test lib = "$linkmode"; then

dlprefiles="$newdlprefiles"

dlprefiles=$newdlprefiles

case $linkmode in

oldlib)

if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then

if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then

func_warning "\`-dlopen' is ignored for archives"

func_warning "'-dlopen' is ignored for archives"

case " $deplibs" in

*\ -l* | *\ -L*)

func_warning "\`-l' and \`-L' are ignored for archives" ;;

func_warning "'-l' and '-L' are ignored for archives" ;;

esac

test -n "$rpath" && \

func_warning "\`-rpath' is ignored for archives"

func_warning "'-rpath' is ignored for archives"

test -n "$xrpath" && \

func_warning "\`-R' is ignored for archives"

func_warning "'-R' is ignored for archives"

test -n "$vinfo" && \

func_warning "\`-version-info/-version-number' is ignored for archives"

func_warning "'-version-info/-version-number' is ignored for archives"

test -n "$release" && \

func_warning "\`-release' is ignored for archives"

func_warning "'-release' is ignored for archives"

test -n "$export_symbols$export_symbols_regex" && \

func_warning "\`-export-symbols' is ignored for archives"

func_warning "'-export-symbols' is ignored for archives"

# Now set the variables for building old libraries.

build_libtool_libs=no

oldlibs="$output"

oldlibs=$output

func_append objs "$old_deplibs"

;;

lib)

# Make sure we only generate libraries of the form `libNAME.la'.

# Make sure we only generate libraries of the form 'libNAME.la'.

case $outputname in

lib*)

func_stripname 'lib' '.la' "$outputname"

Line 7299 func_mode_link ()

Line 8722 func_mode_link ()

eval libname=\"$libname_spec\"

;;

test "$module" = no && \

test no = "$module" \

func_fatal_help "libtool library \`$output' must begin with \`lib'"

&& func_fatal_help "libtool library '$output' must begin with 'lib'"

if test "$need_lib_prefix" != no; then

if test no != "$need_lib_prefix"; then

# Add the "lib" prefix for modules if required

func_stripname '' '.la' "$outputname"

name=$func_stripname_result

Line 7316 func_mode_link ()

Line 8739 func_mode_link ()

esac

if test -n "$objs"; then

if test "$deplibs_check_method" != pass_all; then

if test pass_all != "$deplibs_check_method"; then

func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"

func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"

else

echo

$ECHO "*** Warning: Linking the shared library $output against the non-libtool"

Line 7326 func_mode_link ()

Line 8749 func_mode_link ()

test "$dlself" != no && \

test no = "$dlself" \

func_warning "\`-dlopen self' is ignored for libtool libraries"

|| func_warning "'-dlopen self' is ignored for libtool libraries"

set dummy $rpath

shift

test "$#" -gt 1 && \

test 1 -lt "$#" \

func_warning "ignoring multiple \`-rpath's for a libtool library"

&& func_warning "ignoring multiple '-rpath's for a libtool library"

install_libdir="$1"

install_libdir=$1

oldlibs=

if test -z "$rpath"; then

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

# Building a libtool convenience library.

# Some compilers have problems with a `.al' extension so

# Some compilers have problems with a '.al' extension so

# convenience libraries should have the same extension an

# archive normally would.

oldlibs="$output_objdir/$libname.$libext $oldlibs"

Line 7349 func_mode_link ()

Line 8772 func_mode_link ()

test -n "$vinfo" && \

func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

func_warning "'-version-info/-version-number' is ignored for convenience libraries"

test -n "$release" && \

func_warning "\`-release' is ignored for convenience libraries"

func_warning "'-release' is ignored for convenience libraries"

else

# Parse the version information argument.

save_ifs="$IFS"; IFS=':'

save_ifs=$IFS; IFS=:

set dummy $vinfo 0 0 0

shift

IFS="$save_ifs"

IFS=$save_ifs

test -n "$7" && \

func_fatal_help "too many parameters to \`-version-info'"

func_fatal_help "too many parameters to '-version-info'"

# convert absolute version numbers to libtool ages

# this retains compatibility with .la files and attempts

Line 7370 func_mode_link ()

Line 8793 func_mode_link ()

case $vinfo_number in

yes)

number_major="$1"

number_major=$1

number_minor="$2"

number_minor=$2

number_revision="$3"

number_revision=$3

# There are really only two kinds -- those that

# use the current revision as the major version

# and those that subtract age and use age as

# a minor version. But, then there is irix

# which has an extra 1 added just for fun

# that has an extra 1 added just for fun

case $version_type in

# correct linux to gnu/linux during the next big refactor

darwin|linux|osf|windows|none)

func_arith $number_major + $number_minor

current=$func_arith_result

age="$number_minor"

age=$number_minor

revision="$number_revision"

revision=$number_revision

;;

freebsd-aout|freebsd-elf|qnx|sunos)

freebsd-aout|qnx|sunos)

current="$number_major"

current=$number_major

revision="$number_minor"

revision=$number_minor

age="0"

age=0

;;

irix|nonstopux)

func_arith $number_major + $number_minor

current=$func_arith_result

age="$number_minor"

age=$number_minor

revision="$number_minor"

revision=$number_minor

lt_irix_increment=no

;;

esac

;;

no)

current="$1"

current=$1

revision="$2"

revision=$2

age="$3"

age=$3

;;

esac

Line 7413 func_mode_link ()

Line 8836 func_mode_link ()

case $current in

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

func_error "CURRENT \`$current' must be a nonnegative integer"

func_error "CURRENT '$current' must be a nonnegative integer"

func_fatal_error "\`$vinfo' is not valid version information"

func_fatal_error "'$vinfo' is not valid version information"

;;

esac

case $revision in

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

func_error "REVISION \`$revision' must be a nonnegative integer"

func_error "REVISION '$revision' must be a nonnegative integer"

func_fatal_error "\`$vinfo' is not valid version information"

func_fatal_error "'$vinfo' is not valid version information"

;;

esac

case $age in

0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;

func_error "AGE \`$age' must be a nonnegative integer"

func_error "AGE '$age' must be a nonnegative integer"

func_fatal_error "\`$vinfo' is not valid version information"

func_fatal_error "'$vinfo' is not valid version information"

;;

esac

if test "$age" -gt "$current"; then

func_error "AGE \`$age' is greater than the current interface number \`$current'"

func_error "AGE '$age' is greater than the current interface number '$current'"

func_fatal_error "\`$vinfo' is not valid version information"

func_fatal_error "'$vinfo' is not valid version information"

# Calculate the version variables.

Line 7451 func_mode_link ()

Line 8874 func_mode_link ()

# verstring for coding it into the library header

func_arith $current - $age

major=.$func_arith_result

versuffix="$major.$age.$revision"

versuffix=$major.$age.$revision

# Darwin ld doesn't like 0 for these options...

func_arith $current + 1

minor_current=$func_arith_result

xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"

xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"

verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

# On Darwin other compilers

case $CC in

nagfor*)

verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"

;;

verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"

;;

esac

;;

freebsd-aout)

major=".$current"

major=.$current

versuffix=".$current.$revision";

versuffix=.$current.$revision

;;

freebsd-elf)

major=".$current"

func_arith $current - $age

versuffix=".$current"

major=.$func_arith_result

versuffix=$major.$age.$revision

;;

irix | nonstopux)

if test "X$lt_irix_increment" = "Xno"; then

if test no = "$lt_irix_increment"; then

func_arith $current - $age

else

func_arith $current - $age + 1

Line 7481 func_mode_link ()

Line 8914 func_mode_link ()

nonstopux) verstring_prefix=nonstopux ;;

*) verstring_prefix=sgi ;;

esac

verstring="$verstring_prefix$major.$revision"

verstring=$verstring_prefix$major.$revision

# Add in all the interfaces that we are compatible with.

loop=$revision

while test "$loop" -ne 0; do

while test 0 -ne "$loop"; do

func_arith $revision - $loop

iface=$func_arith_result

func_arith $loop - 1

loop=$func_arith_result

verstring="$verstring_prefix$major.$iface:$verstring"

verstring=$verstring_prefix$major.$iface:$verstring

done

# Before this point, $major must not contain `.'.

# Before this point, $major must not contain '.'.

major=.$major

versuffix="$major.$revision"

versuffix=$major.$revision

;;

linux) # correct to gnu/linux during the next big refactor

func_arith $current - $age

major=.$func_arith_result

versuffix="$major.$age.$revision"

versuffix=$major.$age.$revision

;;

osf)

func_arith $current - $age

major=.$func_arith_result

versuffix=".$current.$age.$revision"

versuffix=.$current.$age.$revision

verstring="$current.$age.$revision"

verstring=$current.$age.$revision

# Add in all the interfaces that we are compatible with.

loop=$age

while test "$loop" -ne 0; do

while test 0 -ne "$loop"; do

func_arith $current - $loop

iface=$func_arith_result

func_arith $loop - 1

loop=$func_arith_result

verstring="$verstring:${iface}.0"

verstring=$verstring:$iface.0

done

# Make executables depend on our current version.

func_append verstring ":${current}.0"

func_append verstring ":$current.0"

;;

qnx)

major=".$current"

major=.$current

versuffix=".$current"

versuffix=.$current

;;

sco)

major=.$current

versuffix=.$current

;;

sunos)

major=".$current"

major=.$current

versuffix=".$current.$revision"

versuffix=.$current.$revision

;;

windows)

# Use '-' rather than '.', since we only want one

# extension on DOS 8.3 filesystems.

# extension on DOS 8.3 file systems.

func_arith $current - $age

major=$func_arith_result

versuffix="-$major"

versuffix=-$major

;;

func_fatal_configuration "unknown library version type \`$version_type'"

func_fatal_configuration "unknown library version type '$version_type'"

;;

esac

Line 7557 func_mode_link ()

Line 8995 func_mode_link ()

verstring=

;;

verstring="0.0"

verstring=0.0

;;

esac

if test "$need_version" = no; then

if test no = "$need_version"; then

versuffix=

else

versuffix=".0.0"

versuffix=.0.0

# Remove version info from name if versioning should be avoided

if test "$avoid_version" = yes && test "$need_version" = no; then

if test yes,no = "$avoid_version,$need_version"; then

major=

versuffix=

verstring=""

verstring=

# Check to see if the archive will have undefined symbols.

if test "$allow_undefined" = yes; then

if test yes = "$allow_undefined"; then

if test "$allow_undefined_flag" = unsupported; then

if test unsupported = "$allow_undefined_flag"; then

func_warning "undefined symbols not allowed in $host shared libraries"

if test yes = "$build_old_libs"; then

build_libtool_libs=no

func_warning "undefined symbols not allowed in $host shared libraries; building static only"

build_old_libs=yes

build_libtool_libs=no

else

func_fatal_error "can't build $host shared library unless -no-undefined is specified"

else

# Don't allow undefined symbols.

allow_undefined_flag="$no_undefined_flag"

allow_undefined_flag=$no_undefined_flag

func_generate_dlsyms "$libname" "$libname" "yes"

func_generate_dlsyms "$libname" "$libname" :

func_append libobjs " $symfileobj"

test "X$libobjs" = "X " && libobjs=

test " " = "$libobjs" && libobjs=

if test "$opt_mode" != relink; then

if test relink != "$opt_mode"; then

# Remove our outputs, but don't remove object files since they

# may have been created when compiling PIC objects.

removelist=

Line 7601 func_mode_link ()

Line 9042 func_mode_link ()

case $p in

*.$objext | *.gcno)

;;

$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)

$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)

if test "X$precious_files_regex" != "X"; then

if test -n "$precious_files_regex"; then

if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1

then

continue

Line 7618 func_mode_link ()

Line 9059 func_mode_link ()

# Now set the variables for building old libraries.

if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then

if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then

func_append oldlibs " $output_objdir/$libname.$libext"

# Transform .lo files to .o files.

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`

oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`

# Eliminate all temporary directories.

Line 7643 func_mode_link ()

Line 9084 func_mode_link ()

*) func_append finalize_rpath " $libdir" ;;

esac

done

if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then

if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then

dependency_libs="$temp_xrpath $dependency_libs"

# Make sure dlfiles contains only unique files that won't be dlpreopened

old_dlfiles="$dlfiles"

old_dlfiles=$dlfiles

dlfiles=

for lib in $old_dlfiles; do

case " $dlprefiles $dlfiles " in

Line 7659 func_mode_link ()

Line 9100 func_mode_link ()

done

# Make sure dlprefiles contains only unique files

old_dlprefiles="$dlprefiles"

old_dlprefiles=$dlprefiles

dlprefiles=

for lib in $old_dlprefiles; do

case "$dlprefiles " in

Line 7668 func_mode_link ()

Line 9109 func_mode_link ()

esac

done

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

if test -n "$rpath"; then

case $host in

Line 7692 func_mode_link ()

Line 9133 func_mode_link ()

;;

# Add libc to deplibs on all other systems if necessary.

if test "$build_libtool_need_lc" = "yes"; then

if test yes = "$build_libtool_need_lc"; then

func_append deplibs " -lc"

;;

Line 7708 func_mode_link ()

Line 9149 func_mode_link ()

# I'm not sure if I'm treating the release correctly. I think

# release should show up in the -l (ie -lgmp5) so we don't want to

# add it in twice. Is that correct?

release=""

release=

versuffix=""

versuffix=

major=""

major=

newdeplibs=

droppeddeps=no

case $deplibs_check_method in

Line 7739 EOF

Line 9180 EOF

-l*)

func_stripname -l '' "$i"

name=$func_stripname_result

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

case " $predeps $postdeps " in

*" $i "*)

func_append newdeplibs " $i"

i=""

;;

esac

if test -n "$i" ; then

if test -n "$i"; then

libname=`eval "\\$ECHO \"$libname_spec\""`

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

set dummy $deplib_matches; shift

deplib_match=$1

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then

func_append newdeplibs " $i"

else

droppeddeps=yes

Line 7782 EOF

Line 9223 EOF

$opt_dry_run || $RM conftest

if $LTCC $LTCFLAGS -o conftest conftest.c $i; then

ldd_output=`ldd conftest`

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

case " $predeps $postdeps " in

*" $i "*)

func_append newdeplibs " $i"

i=""

;;

esac

if test -n "$i" ; then

if test -n "$i"; then

libname=`eval "\\$ECHO \"$libname_spec\""`

deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`

set dummy $deplib_matches; shift

deplib_match=$1

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then

if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then

func_append newdeplibs " $i"

else

droppeddeps=yes

Line 7832 EOF

Line 9273 EOF

-l*)

func_stripname -l '' "$a_deplib"

name=$func_stripname_result

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

case " $predeps $postdeps " in

*" $a_deplib "*)

func_append newdeplibs " $a_deplib"

a_deplib=""

a_deplib=

;;

esac

if test -n "$a_deplib" ; then

if test -n "$a_deplib"; then

libname=`eval "\\$ECHO \"$libname_spec\""`

if test -n "$file_magic_glob"; then

libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`

else

libnameglob=$libname

test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`

test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

if test "$want_nocaseglob" = yes; then

if test yes = "$want_nocaseglob"; then

shopt -s nocaseglob

potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`

$nocaseglob

Line 7867 EOF

Line 9308 EOF

# We might still enter an endless loop, since a link

# loop can be closed while we follow links,

# but so what?

potlib="$potent_lib"

potlib=$potent_lib

while test -h "$potlib" 2>/dev/null; do

potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`

potliblink=`ls -ld $potlib | $SED 's/.* -> //'`

case $potliblink in

[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;

[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;

*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;

*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;

esac

done

if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |

$SED -e 10q |

$EGREP "$file_magic_regex" > /dev/null; then

func_append newdeplibs " $a_deplib"

a_deplib=""

a_deplib=

break 2

done

if test -n "$a_deplib" ; then

if test -n "$a_deplib"; then

droppeddeps=yes

echo

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

Line 7893 EOF

Line 9334 EOF

echo "*** you link to this library. But I can only do this if you have a"

echo "*** shared version of the library, which you do not appear to have"

echo "*** because I did check the linker path looking for a file starting"

if test -z "$potlib" ; then

if test -z "$potlib"; then

$ECHO "*** with $libname but no candidates were found. (...for file magic test)"

else

$ECHO "*** with $libname and none of the candidates passed a file format test"

Line 7916 EOF

Line 9357 EOF

-l*)

func_stripname -l '' "$a_deplib"

name=$func_stripname_result

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

case " $predeps $postdeps " in

*" $a_deplib "*)

func_append newdeplibs " $a_deplib"

a_deplib=""

a_deplib=

;;

esac

if test -n "$a_deplib" ; then

if test -n "$a_deplib"; then

libname=`eval "\\$ECHO \"$libname_spec\""`

for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do

potential_libs=`ls $i/$libname[.-]* 2>/dev/null`

for potent_lib in $potential_libs; do

potlib="$potent_lib" # see symlink-check above in file_magic test

potlib=$potent_lib # see symlink-check above in file_magic test

if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \

$EGREP "$match_pattern_regex" > /dev/null; then

func_append newdeplibs " $a_deplib"

a_deplib=""

a_deplib=

break 2

done

if test -n "$a_deplib" ; then

if test -n "$a_deplib"; then

droppeddeps=yes

echo

$ECHO "*** Warning: linker path does not have real file for library $a_deplib."

Line 7947 EOF

Line 9388 EOF

echo "*** you link to this library. But I can only do this if you have a"

echo "*** shared version of the library, which you do not appear to have"

echo "*** because I did check the linker path looking for a file starting"

if test -z "$potlib" ; then

if test -z "$potlib"; then

$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"

else

$ECHO "*** with $libname and none of the candidates passed a file format test"

Line 7963 EOF

Line 9404 EOF

done # Gone through all deplibs.

;;

none | unknown | *)

newdeplibs=""

newdeplibs=

tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`

if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then

if test yes = "$allow_libtool_libs_with_static_runtimes"; then

for i in $predeps $postdeps ; do

for i in $predeps $postdeps; do

# can't use Xsed below, because $i might contain '/'

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`

tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`

done

case $tmp_deplibs in

*[!\ \ ]*)

echo

if test "X$deplibs_check_method" = "Xnone"; then

if test none = "$deplibs_check_method"; then

echo "*** Warning: inter-library dependencies are not supported in this platform."

else

echo "*** Warning: inter-library dependencies are not known to be supported."

Line 7998 EOF

Line 9439 EOF

;;

esac

if test "$droppeddeps" = yes; then

if test yes = "$droppeddeps"; then

if test "$module" = yes; then

if test yes = "$module"; then

echo

echo "*** Warning: libtool could not satisfy all declared inter-library"

$ECHO "*** dependencies of module $libname. Therefore, libtool will create"

Line 8008 EOF

Line 9449 EOF

if test -z "$global_symbol_pipe"; then

echo

echo "*** However, this would only work if libtool was able to extract symbol"

echo "*** lists from a program, using \`nm' or equivalent, but libtool could"

echo "*** lists from a program, using 'nm' or equivalent, but libtool could"

echo "*** not find such a program. So, this module is probably useless."

echo "*** \`nm' from GNU binutils and a full rebuild may help."

echo "*** 'nm' from GNU binutils and a full rebuild may help."

if test "$build_old_libs" = no; then

if test no = "$build_old_libs"; then

oldlibs="$output_objdir/$libname.$libext"

oldlibs=$output_objdir/$libname.$libext

build_libtool_libs=module

build_old_libs=yes

else

Line 8024 EOF

Line 9465 EOF

echo "*** automatically added whenever a program is linked with this library"

echo "*** or is declared to -dlopen it."

if test "$allow_undefined" = no; then

if test no = "$allow_undefined"; then

echo

echo "*** Since this library must not contain undefined symbols,"

echo "*** because either the platform does not support them or"

echo "*** it was explicitly requested with -no-undefined,"

echo "*** libtool will only create a static version of it."

if test "$build_old_libs" = no; then

if test no = "$build_old_libs"; then

oldlibs="$output_objdir/$libname.$libext"

oldlibs=$output_objdir/$libname.$libext

build_libtool_libs=module

build_old_libs=yes

else

Line 8077 EOF

Line 9518 EOF

*) func_append new_libs " $deplib" ;;

esac

done

deplibs="$new_libs"

deplibs=$new_libs

# All the library-specific variables (install_libdir is set above).

library_names=

Line 8085 EOF

Line 9526 EOF

dlname=

# Test again, we may have decided not to build it any more

if test "$build_libtool_libs" = yes; then

if test yes = "$build_libtool_libs"; then

# Remove ${wl} instances when linking with ld.

# Remove $wl instances when linking with ld.

# FIXME: should test the right _cmds variable.

case $archive_cmds in

*\$LD\ *) wl= ;;

esac

if test "$hardcode_into_libs" = yes; then

if test yes = "$hardcode_into_libs"; then

# Hardcode the library paths

hardcode_libdirs=

dep_rpath=

rpath="$finalize_rpath"

rpath=$finalize_rpath

test "$opt_mode" != relink && rpath="$compile_rpath$rpath"

test relink = "$opt_mode" || rpath=$compile_rpath$rpath

for libdir in $rpath; do

if test -n "$hardcode_libdir_flag_spec"; then

if test -n "$hardcode_libdir_separator"; then

func_replace_sysroot "$libdir"

libdir=$func_replace_sysroot_result

if test -z "$hardcode_libdirs"; then

hardcode_libdirs="$libdir"

hardcode_libdirs=$libdir

else

# Just accumulate the unique libdirs.

case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in

Line 8128 EOF

Line 9569 EOF

# Substitute the hardcoded libdirs into the rpath.

if test -n "$hardcode_libdir_separator" &&

test -n "$hardcode_libdirs"; then

libdir="$hardcode_libdirs"

libdir=$hardcode_libdirs

eval "dep_rpath=\"$hardcode_libdir_flag_spec\""

if test -n "$runpath_var" && test -n "$perm_rpath"; then

Line 8142 EOF

Line 9583 EOF

test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"

shlibpath="$finalize_shlibpath"

shlibpath=$finalize_shlibpath

test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"

test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath

if test -n "$shlibpath"; then

eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"

Line 8153 EOF

Line 9594 EOF

eval library_names=\"$library_names_spec\"

set dummy $library_names

shift

realname="$1"

realname=$1

shift

if test -n "$soname_spec"; then

eval soname=\"$soname_spec\"

else

soname="$realname"

soname=$realname

if test -z "$dlname"; then

dlname=$soname

lib="$output_objdir/$realname"

lib=$output_objdir/$realname

linknames=

for link

Line 8179 EOF

Line 9620 EOF

delfiles=

if test -n "$export_symbols" && test -n "$include_expsyms"; then

$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"

export_symbols="$output_objdir/$libname.uexp"

export_symbols=$output_objdir/$libname.uexp

func_append delfiles " $export_symbols"

Line 8188 EOF

Line 9629 EOF

cygwin* | mingw* | cegcc*)

if test -n "$export_symbols" && test -z "$export_symbols_regex"; then

# exporting using user supplied symfile

if test "x`$SED 1q $export_symbols`" != xEXPORTS; then

func_dll_def_p "$export_symbols" || {

# and it's NOT already a .def file. Must figure out

# which of the given symbols are data symbols and tag

# them as such. So, trigger use of export_symbols_cmds.

# export_symbols gets reassigned inside the "prepare

# the list of exported symbols" if statement, so the

# include_expsyms logic still works.

orig_export_symbols="$export_symbols"

orig_export_symbols=$export_symbols

export_symbols=

always_export_symbols=yes

}

;;

esac

# Prepare the list of exported symbols

if test -z "$export_symbols"; then

if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then

if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then

func_verbose "generating symbol list for \`$libname.la'"

func_verbose "generating symbol list for '$libname.la'"

export_symbols="$output_objdir/$libname.exp"

export_symbols=$output_objdir/$libname.exp

$opt_dry_run || $RM $export_symbols

cmds=$export_symbols_cmds

save_ifs="$IFS"; IFS='~'

save_ifs=$IFS; IFS='~'

for cmd1 in $cmds; do

IFS="$save_ifs"

IFS=$save_ifs

# Take the normal branch if the nm_file_list_spec branch

# doesn't work or if tool conversion is not needed.

case $nm_file_list_spec~$to_tool_file_cmd in

Line 8226 EOF

Line 9667 EOF

try_normal_branch=no

;;

esac

if test "$try_normal_branch" = yes \

if test yes = "$try_normal_branch" \

&& { test "$len" -lt "$max_cmd_len" \

|| test "$max_cmd_len" -le -1; }

then

Line 8237 EOF

Line 9678 EOF

output_la=$func_basename_result

save_libobjs=$libobjs

save_output=$output

output=${output_objdir}/${output_la}.nm

output=$output_objdir/$output_la.nm

func_to_tool_file "$output"

libobjs=$nm_file_list_spec$func_to_tool_file_result

func_append delfiles " $output"

Line 8260 EOF

Line 9701 EOF

break

done

IFS="$save_ifs"

IFS=$save_ifs

if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then

if test -n "$export_symbols_regex" && test : != "$skipped_export"; then

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

func_show_eval '$MV "${export_symbols}T" "$export_symbols"'

Line 8269 EOF

Line 9710 EOF

if test -n "$export_symbols" && test -n "$include_expsyms"; then

tmp_export_symbols="$export_symbols"

tmp_export_symbols=$export_symbols

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then

if test : != "$skipped_export" && test -n "$orig_export_symbols"; then

# The given exports_symbols file has to be filtered, so filter it.

func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"

func_verbose "filter symbol list for '$libname.la' to tag DATA exports"

# FIXME: $output_objdir/$libname.filter potentially contains lots of

# 's' commands which not all seds can handle. GNU sed should be fine

# 's' commands, which not all seds can handle. GNU sed should be fine

# though. Also, the filter scales superlinearly with the number of

# global variables. join(1) would be nice here, but unfortunately

# isn't a blessed tool.

Line 8297 EOF

Line 9738 EOF

;;

esac

done

deplibs="$tmp_deplibs"

deplibs=$tmp_deplibs

if test -n "$convenience"; then

if test -n "$whole_archive_flag_spec" &&

test "$compiler_needs_object" = yes &&

test yes = "$compiler_needs_object" &&

test -z "$libobjs"; then

# extract the archives, so we have objects to list.

# TODO: could optimize this to just extract one archive.

Line 8312 EOF

Line 9753 EOF

eval libobjs=\"\$libobjs $whole_archive_flag_spec\"

test "X$libobjs" = "X " && libobjs=

else

gentop="$output_objdir/${outputname}x"

gentop=$output_objdir/${outputname}x

func_append generated " $gentop"

func_extract_archives $gentop $convenience

Line 8321 EOF

Line 9762 EOF

if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then

if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then

eval flag=\"$thread_safe_flag_spec\"

func_append linker_flags " $flag"

# Make a backup of the uninstalled library when relinking

if test "$opt_mode" = relink; then

if test relink = "$opt_mode"; then

$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?

# Do each of the archive commands.

if test "$module" = yes && test -n "$module_cmds" ; then

if test yes = "$module" && test -n "$module_cmds"; then

if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then

eval test_cmds=\"$module_expsym_cmds\"

cmds=$module_expsym_cmds

Line 8350 EOF

Line 9791 EOF

if test "X$skipped_export" != "X:" &&

if test : != "$skipped_export" &&

func_len " $test_cmds" &&

len=$func_len_result &&

test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then

Line 8383 EOF

Line 9824 EOF

last_robj=

k=1

if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then

if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then

output=${output_objdir}/${output_la}.lnkscript

output=$output_objdir/$output_la.lnkscript

func_verbose "creating GNU ld script: $output"

echo 'INPUT (' > $output

for obj in $save_libobjs

Line 8396 EOF

Line 9837 EOF

func_append delfiles " $output"

func_to_tool_file "$output"

output=$func_to_tool_file_result

elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then

elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then

output=${output_objdir}/${output_la}.lnk

output=$output_objdir/$output_la.lnk

func_verbose "creating linker input file list: $output"

: > $output

set x $save_libobjs

shift

firstobj=

if test "$compiler_needs_object" = yes; then

if test yes = "$compiler_needs_object"; then

firstobj="$1 "

shift

Line 8418 EOF

Line 9859 EOF

else

if test -n "$save_libobjs"; then

func_verbose "creating reloadable object files..."

output=$output_objdir/$output_la-${k}.$objext

output=$output_objdir/$output_la-$k.$objext

eval test_cmds=\"$reload_cmds\"

func_len " $test_cmds"

len0=$func_len_result

Line 8430 EOF

Line 9871 EOF

func_len " $obj"

func_arith $len + $func_len_result

len=$func_arith_result

if test "X$objlist" = X ||

if test -z "$objlist" ||

test "$len" -lt "$max_cmd_len"; then

func_append objlist " $obj"

else

# The command $test_cmds is almost too long, add a

# command to the queue.

if test "$k" -eq 1 ; then

if test 1 -eq "$k"; then

# The first file doesn't have a previous command to add.

reload_objs=$objlist

eval concat_cmds=\"$reload_cmds\"

Line 8446 EOF

Line 9887 EOF

reload_objs="$objlist $last_robj"

eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"

last_robj=$output_objdir/$output_la-${k}.$objext

last_robj=$output_objdir/$output_la-$k.$objext

func_arith $k + 1

k=$func_arith_result

output=$output_objdir/$output_la-${k}.$objext

output=$output_objdir/$output_la-$k.$objext

objlist=" $obj"

func_len " $last_robj"

func_arith $len0 + $func_len_result

Line 8461 EOF

Line 9902 EOF

# files will link in the last one created.

test -z "$concat_cmds" || concat_cmds=$concat_cmds~

reload_objs="$objlist $last_robj"

eval concat_cmds=\"\${concat_cmds}$reload_cmds\"

eval concat_cmds=\"\$concat_cmds$reload_cmds\"

if test -n "$last_robj"; then

eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"

eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

func_append delfiles " $output"

Line 8471 EOF

Line 9912 EOF

output=

if ${skipped_export-false}; then

${skipped_export-false} && {

func_verbose "generating symbol list for \`$libname.la'"

func_verbose "generating symbol list for '$libname.la'"

export_symbols="$output_objdir/$libname.exp"

export_symbols=$output_objdir/$libname.exp

$opt_dry_run || $RM $export_symbols

libobjs=$output

# Append the command to create the export file.

Line 8482 EOF

Line 9923 EOF

if test -n "$last_robj"; then

eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"

}

test -n "$save_libobjs" &&

func_verbose "creating a temporary reloadable object file: $output"

# Loop through the commands generated above and execute them.

save_ifs="$IFS"; IFS='~'

save_ifs=$IFS; IFS='~'

for cmd in $concat_cmds; do

IFS="$save_ifs"

IFS=$save_ifs

$opt_silent || {

$opt_quiet || {

func_quote_for_expand "$cmd"

eval "func_echo $func_quote_for_expand_result"

}

Line 8499 EOF

Line 9940 EOF

lt_exit=$?

# Restore the uninstalled library and exit

if test "$opt_mode" = relink; then

if test relink = "$opt_mode"; then

( cd "$output_objdir" && \

$RM "${realname}T" && \

$MV "${realname}U" "$realname" )

Line 8508 EOF

Line 9949 EOF

exit $lt_exit

}

done

IFS="$save_ifs"

IFS=$save_ifs

if test -n "$export_symbols_regex" && ${skipped_export-false}; then

func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'

Line 8516 EOF

Line 9957 EOF

if ${skipped_export-false}; then

${skipped_export-false} && {

if test -n "$export_symbols" && test -n "$include_expsyms"; then

tmp_export_symbols="$export_symbols"

tmp_export_symbols=$export_symbols

test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"

test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols

$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'

if test -n "$orig_export_symbols"; then