~streib/g4track_debian.git

Ansicht | Historie | Commit | Commitdiff

Janis Streib

12.12.21 9feb9f15c37d89dac5acff403451c468276904d4

Commit \| Autor \| Alter
0a10d5	1
JS	2	# libtool (GNU libtool) 2.4.2
	3	# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
	4
	5	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
	6	# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
	7	# This is free software; see the source for copying conditions. There is NO
	8	# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	9
	10	# GNU Libtool is free software; you can redistribute it and/or modify
	11	# it under the terms of the GNU General Public License as published by
	12	# the Free Software Foundation; either version 2 of the License, or
	13	# (at your option) any later version.
	14	#
	15	# As a special exception to the GNU General Public License,
	16	# if you distribute this file as part of a program or library that
	17	# is built using GNU Libtool, you may include this file under the
	18	# same distribution terms that you use for the rest of that program.
	19	#
	20	# GNU Libtool is distributed in the hope that it will be useful, but
	21	# WITHOUT ANY WARRANTY; without even the implied warranty of
	22	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	23	# General Public License for more details.
	24	#
	25	# You should have received a copy of the GNU General Public License
	26	# along with GNU Libtool; see the file COPYING. If not, a copy
	27	# can be downloaded from http://www.gnu.org/licenses/gpl.html,
	28	# or obtained by writing to the Free Software Foundation, Inc.,
	29	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	30
	31	# Usage: $progname [OPTION]... [MODE-ARG]...
	32	#
	33	# Provide generalized library-building support services.
	34	#
	35	# --config show all configuration variables
	36	# --debug enable verbose shell tracing
	37	# -n, --dry-run display commands without modifying any files
	38	# --features display basic configuration information and exit
	39	# --mode=MODE use operation mode MODE
	40	# --preserve-dup-deps don't remove duplicate dependency libraries
	41	# --quiet, --silent don't print informational messages
	42	# --no-quiet, --no-silent
	43	# print informational messages (default)
	44	# --no-warn don't display warning messages
	45	# --tag=TAG use configuration variables from tag TAG
	46	# -v, --verbose print more informational messages than default
	47	# --no-verbose don't print the extra informational messages
	48	# --version print version information
	49	# -h, --help, --help-all print short, long, or detailed help message
	50	#
	51	# MODE must be one of the following:
	52	#
	53	# clean remove files from the build directory
	54	# compile compile a source file into a libtool object
	55	# execute automatically set library path, then run a program
	56	# finish complete the installation of libtool libraries
	57	# install install libraries or executables
	58	# link create a library or an executable
	59	# uninstall remove libraries from an installed directory
	60	#
	61	# MODE-ARGS vary depending on the MODE. When passed as first option,
	62	# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
	63	# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
	64	#
	65	# When reporting a bug, please describe a test case to reproduce it and
	66	# include the following information:
	67	#
	68	# host-triplet: $host
	69	# shell: $SHELL
	70	# compiler: $LTCC
	71	# compiler flags: $LTCFLAGS
	72	# linker: $LD (gnu? $with_gnu_ld)
	73	# $progname: (GNU libtool) 2.4.2
	74	# automake: $automake_version
	75	# autoconf: $autoconf_version
	76	#
	77	# Report bugs to <bug-libtool@gnu.org>.
	78	# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
	79	# General help using GNU software: <http://www.gnu.org/gethelp/>.
	80
	81	PROGRAM=libtool
	82	PACKAGE=libtool
	83	VERSION=2.4.2
	84	TIMESTAMP=""
	85	package_revision=1.3337
	86
	87	# Be Bourne compatible
	88	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
	89	emulate sh
	90	NULLCMD=:
	91	# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
	92	# is contrary to our usage. Disable this feature.
	93	alias -g '${1+"$@"}'='"$@"'
	94	setopt NO_GLOB_SUBST
	95	else
	96	case `(set -o) 2>/dev/null` in posix) set -o posix;; esac
	97	fi
	98	BIN_SH=xpg4; export BIN_SH # for Tru64
	99	DUALCASE=1; export DUALCASE # for MKS sh
	100
	101	# A function that is used when there is no print builtin or printf.
	102	func_fallback_echo ()
	103	{
	104	eval 'cat <<_LTECHO_EOF
	105	$1
	106	_LTECHO_EOF'
	107	}
	108
	109	# NLS nuisances: We save the old values to restore during execute mode.
	110	lt_user_locale=
	111	lt_safe_locale=
	112	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
	113	do
	114	eval "if test \"\${$lt_var+set}\" = set; then
	115	save_$lt_var=\$$lt_var
	116	$lt_var=C
	117	export $lt_var
	118	lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
	119	lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
	120	fi"
	121	done
	122	LC_ALL=C
	123	LANGUAGE=C
	124	export LANGUAGE LC_ALL
	125
	126	$lt_unset CDPATH
	127
	128
	129	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
	130	# is ksh but when the shell is invoked as "sh" and the current value of
	131	# the _XPG environment variable is not equal to 1 (one), the special
	132	# positional parameter $0, within a function call, is the name of the
	133	# function.
	134	progpath="$0"
	135
	136
	137
	138	: ${CP="cp -f"}
	139	test "${ECHO+set}" = set \|\| ECHO=${as_echo-'printf %s\n'}
	140	: ${MAKE="make"}
	141	: ${MKDIR="mkdir"}
	142	: ${MV="mv -f"}
	143	: ${RM="rm -f"}
	144	: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
	145	: ${Xsed="$SED -e 1s/^X//"}
	146
	147	# Global variables:
	148	EXIT_SUCCESS=0
	149	EXIT_FAILURE=1
	150	EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
	151	EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
	152
	153	exit_status=$EXIT_SUCCESS
	154
	155	# Make sure IFS has a sensible default
	156	lt_nl='
	157	'
	158	IFS=" $lt_nl"
	159
	160	dirname="s,/[^/]*$,,"
	161	basename="s,^.*/,,"
	162
	163	# func_dirname file append nondir_replacement
	164	# Compute the dirname of FILE. If nonempty, add APPEND to the result,
	165	# otherwise set result to NONDIR_REPLACEMENT.
	166	func_dirname ()
	167	{
	168	func_dirname_result=`$ECHO "${1}" \| $SED "$dirname"`
	169	if test "X$func_dirname_result" = "X${1}"; then
	170	func_dirname_result="${3}"
	171	else
	172	func_dirname_result="$func_dirname_result${2}"
	173	fi
	174	} # func_dirname may be replaced by extended shell implementation
	175
	176
	177	# func_basename file
	178	func_basename ()
	179	{
	180	func_basename_result=`$ECHO "${1}" \| $SED "$basename"`
	181	} # func_basename may be replaced by extended shell implementation
	182
	183
	184	# func_dirname_and_basename file append nondir_replacement
	185	# perform func_basename and func_dirname in a single function
	186	# call:
	187	# dirname: Compute the dirname of FILE. If nonempty,
	188	# add APPEND to the result, otherwise set result
	189	# to NONDIR_REPLACEMENT.
	190	# value returned in "$func_dirname_result"
	191	# basename: Compute filename of FILE.
	192	# value retuned in "$func_basename_result"
	193	# Implementation must be kept synchronized with func_dirname
	194	# and func_basename. For efficiency, we do not delegate to
	195	# those functions but instead duplicate the functionality here.
	196	func_dirname_and_basename ()
	197	{
	198	# Extract subdirectory from the argument.
	199	func_dirname_result=`$ECHO "${1}" \| $SED -e "$dirname"`
	200	if test "X$func_dirname_result" = "X${1}"; then
	201	func_dirname_result="${3}"
	202	else
	203	func_dirname_result="$func_dirname_result${2}"
	204	fi
	205	func_basename_result=`$ECHO "${1}" \| $SED -e "$basename"`
	206	} # func_dirname_and_basename may be replaced by extended shell implementation
	207
	208
	209	# func_stripname prefix suffix name
	210	# strip PREFIX and SUFFIX off of NAME.
	211	# PREFIX and SUFFIX must not contain globbing or regex special
	212	# characters, hashes, percent signs, but SUFFIX may contain a leading
	213	# dot (in which case that matches only a dot).
	214	# func_strip_suffix prefix name
	215	func_stripname ()
	216	{
	217	case ${2} in
	218	.*) func_stripname_result=`$ECHO "${3}" \| $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
	219	*) func_stripname_result=`$ECHO "${3}" \| $SED "s%^${1}%%; s%${2}\$%%"`;;
	220	esac
	221	} # func_stripname may be replaced by extended shell implementation
	222
	223
	224	# These SED scripts presuppose an absolute path with a trailing slash.
	225	pathcar='s,^/$[^/]$.$,\1,'
	226	pathcdr='s,^/[^/]*,,'
	227	removedotparts=':dotsl
	228	s@/\./@/@g
	229	t dotsl
	230	s,/\.$,/,'
	231	collapseslashes='s@/\{1,\}@/@g'
	232	finalslash='s,/*$,/,'
	233
	234	# func_normal_abspath PATH
	235	# Remove doubled-up and trailing slashes, "." path components,
	236	# and cancel out any ".." path components in PATH after making
	237	# it an absolute path.
	238	# value returned in "$func_normal_abspath_result"
	239	func_normal_abspath ()
	240	{
	241	# Start from root dir and reassemble the path.
	242	func_normal_abspath_result=
	243	func_normal_abspath_tpath=$1
	244	func_normal_abspath_altnamespace=
	245	case $func_normal_abspath_tpath in
	246	"")
	247	# Empty path, that just means $cwd.
	248	func_stripname '' '/' "`pwd`"
	249	func_normal_abspath_result=$func_stripname_result
	250	return
	251	;;
	252	# The next three entries are used to spot a run of precisely
	253	# two leading slashes without using negated character classes;
	254	# we take advantage of case's first-match behaviour.
	255	///*)
	256	# Unusual form of absolute path, do nothing.
	257	;;
	258	//*)
	259	# Not necessarily an ordinary path; POSIX reserves leading '//'
	260	# and for example Cygwin uses it to access remote file shares
	261	# over CIFS/SMB, so we conserve a leading double slash if found.
	262	func_normal_abspath_altnamespace=/
	263	;;
	264	/*)
	265	# Absolute path, do nothing.
	266	;;
	267	*)
	268	# Relative path, prepend $cwd.
	269	func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
	270	;;
	271	esac
	272	# Cancel out all the simple stuff to save iterations. We also want
	273	# the path to end with a slash for ease of parsing, so make sure
	274	# there is one (and only one) here.
	275	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" \| $SED \
	276	-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
	277	while :; do
	278	# Processed it all yet?
	279	if test "$func_normal_abspath_tpath" = / ; then
	280	# If we ascended to the root using ".." the result may be empty now.
	281	if test -z "$func_normal_abspath_result" ; then
	282	func_normal_abspath_result=/
	283	fi
	284	break
	285	fi
	286	func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" \| $SED \
	287	-e "$pathcar"`
	288	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" \| $SED \
	289	-e "$pathcdr"`
	290	# Figure out what to do with it
	291	case $func_normal_abspath_tcomponent in
	292	"")
	293	# Trailing empty path component, ignore it.
	294	;;
	295	..)
	296	# Parent dir; strip last assembled component from result.
	297	func_dirname "$func_normal_abspath_result"
	298	func_normal_abspath_result=$func_dirname_result
	299	;;
	300	*)
	301	# Actual path component, append it.
	302	func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
	303	;;
	304	esac
	305	done
	306	# Restore leading double-slash if one was found on entry.
	307	func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
	308	}
	309
	310	# func_relative_path SRCDIR DSTDIR
	311	# generates a relative path from SRCDIR to DSTDIR, with a trailing
	312	# slash if non-empty, suitable for immediately appending a filename
	313	# without needing to append a separator.
	314	# value returned in "$func_relative_path_result"
	315	func_relative_path ()
	316	{
	317	func_relative_path_result=
	318	func_normal_abspath "$1"
	319	func_relative_path_tlibdir=$func_normal_abspath_result
	320	func_normal_abspath "$2"
	321	func_relative_path_tbindir=$func_normal_abspath_result
	322
	323	# Ascend the tree starting from libdir
	324	while :; do
	325	# check if we have found a prefix of bindir
	326	case $func_relative_path_tbindir in
	327	$func_relative_path_tlibdir)
	328	# found an exact match
	329	func_relative_path_tcancelled=
	330	break
	331	;;
	332	$func_relative_path_tlibdir*)
	333	# found a matching prefix
	334	func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
	335	func_relative_path_tcancelled=$func_stripname_result
	336	if test -z "$func_relative_path_result"; then
	337	func_relative_path_result=.
	338	fi
	339	break
	340	;;
	341	*)
	342	func_dirname $func_relative_path_tlibdir
	343	func_relative_path_tlibdir=${func_dirname_result}
	344	if test "x$func_relative_path_tlibdir" = x ; then
	345	# Have to descend all the way to the root!
	346	func_relative_path_result=../$func_relative_path_result
	347	func_relative_path_tcancelled=$func_relative_path_tbindir
	348	break
	349	fi
	350	func_relative_path_result=../$func_relative_path_result
	351	;;
	352	esac
	353	done
	354
	355	# Now calculate path; take care to avoid doubling-up slashes.
	356	func_stripname '' '/' "$func_relative_path_result"
	357	func_relative_path_result=$func_stripname_result
	358	func_stripname '/' '/' "$func_relative_path_tcancelled"
	359	if test "x$func_stripname_result" != x ; then
	360	func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
	361	fi
	362
	363	# Normalisation. If bindir is libdir, return empty string,
	364	# else relative path ending with a slash; either way, target
	365	# file name can be directly appended.
	366	if test ! -z "$func_relative_path_result"; then
	367	func_stripname './' '' "$func_relative_path_result/"
	368	func_relative_path_result=$func_stripname_result
	369	fi
	370	}
	371
	372	# The name of this program:
	373	func_dirname_and_basename "$progpath"
	374	progname=$func_basename_result
	375
	376	# Make sure we have an absolute path for reexecution:
	377	case $progpath in
	378	[\\/]\|[A-Za-z]:\\) ;;
	379	[\\/])
	380	progdir=$func_dirname_result
	381	progdir=`cd "$progdir" && pwd`
	382	progpath="$progdir/$progname"
	383	;;
	384	*)
	385	save_IFS="$IFS"
	386	IFS=${PATH_SEPARATOR-:}
	387	for progdir in $PATH; do
	388	IFS="$save_IFS"
	389	test -x "$progdir/$progname" && break
	390	done
	391	IFS="$save_IFS"
	392	test -n "$progdir" \|\| progdir=`pwd`
	393	progpath="$progdir/$progname"
	394	;;
	395	esac
	396
	397	# Sed substitution that helps us do robust quoting. It backslashifies
	398	# metacharacters that are still active within double-quoted strings.
	399	Xsed="${SED}"' -e 1s/^X//'
	400	sed_quote_subst='s/$[`"$\\]$/\\\1/g'
	401
	402	# Same as above, but do not quote variable references.
	403	double_quote_subst='s/$["`\\]$/\\\1/g'
	404
	405	# Sed substitution that turns a string into a regex matching for the
	406	# string literally.
	407	sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
	408
	409	# Sed substitution that converts a w32 file name or path
	410	# which contains forward slashes, into one that contains
	411	# (escaped) backslashes. A very naive implementation.
	412	lt_sed_naive_backslashify='s\|\\\\*\|\\\|g;s\|/\|\\\|g;s\|\\\|\\\\\|g'
	413
	414	# Re-`\' parameter expansions in output of double_quote_subst that were
	415	# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
	416	# in input to double_quote_subst, that '$' was protected from expansion.
	417	# Since each input `\' is now two `\'s, look for any number of runs of
	418	# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
	419	bs='\\'
	420	bs2='\\\\'
	421	bs4='\\\\\\\\'
	422	dollar='\$'
	423	sed_double_backslash="\
	424	s/$bs4/&\\
	425	/g
	426	s/^$bs2$dollar/$bs&/
	427	s/\$[^$bs]\$$bs2$dollar/\\1$bs2$bs$dollar/g
	428	s/\n//g"
	429
	430	# Standard options:
	431	opt_dry_run=false
	432	opt_help=false
	433	opt_quiet=false
	434	opt_verbose=false
	435	opt_warning=:
	436
	437	# func_echo arg...
	438	# Echo program name prefixed message, along with the current mode
	439	# name if it has been set yet.
	440	func_echo ()
	441	{
	442	$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
	443	}
	444
	445	# func_verbose arg...
	446	# Echo program name prefixed message in verbose mode only.
	447	func_verbose ()
	448	{
	449	$opt_verbose && func_echo ${1+"$@"}
	450
	451	# A bug in bash halts the script if the last line of a function
	452	# fails when set -e is in force, so we need another command to
	453	# work around that:
	454	:
	455	}
	456
	457	# func_echo_all arg...
	458	# Invoke $ECHO with all args, space-separated.
	459	func_echo_all ()
	460	{
	461	$ECHO "$*"
	462	}
	463
	464	# func_error arg...
	465	# Echo program name prefixed message to standard error.
	466	func_error ()
	467	{
	468	$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
	469	}
	470
	471	# func_warning arg...
	472	# Echo program name prefixed warning message to standard error.
	473	func_warning ()
	474	{
	475	$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
	476
	477	# bash bug again:
	478	:
	479	}
	480
	481	# func_fatal_error arg...
	482	# Echo program name prefixed message to standard error, and exit.
	483	func_fatal_error ()
	484	{
	485	func_error ${1+"$@"}
	486	exit $EXIT_FAILURE
	487	}
	488
	489	# func_fatal_help arg...
	490	# Echo program name prefixed message to standard error, followed by
	491	# a help hint, and exit.
	492	func_fatal_help ()
	493	{
	494	func_error ${1+"$@"}
	495	func_fatal_error "$help"
	496	}
	497	help="Try \`$progname --help' for more information." ## default
	498
	499
	500	# func_grep expression filename
	501	# Check whether EXPRESSION matches any line of FILENAME, without output.
	502	func_grep ()
	503	{
	504	$GREP "$1" "$2" >/dev/null 2>&1
	505	}
	506
	507
	508	# func_mkdir_p directory-path
	509	# Make sure the entire path to DIRECTORY-PATH is available.
	510	func_mkdir_p ()
	511	{
	512	my_directory_path="$1"
	513	my_dir_list=
	514
	515	if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
	516
	517	# Protect directory names starting with `-'
	518	case $my_directory_path in
	519	-*) my_directory_path="./$my_directory_path" ;;
	520	esac
	521
	522	# While some portion of DIR does not yet exist...
	523	while test ! -d "$my_directory_path"; do
	524	# ...make a list in topmost first order. Use a colon delimited
	525	# list incase some portion of path contains whitespace.
	526	my_dir_list="$my_directory_path:$my_dir_list"
	527
	528	# If the last portion added has no slash in it, the list is done
	529	case $my_directory_path in /) ;; *) break ;; esac
	530
	531	# ...otherwise throw away the child directory and loop
	532	my_directory_path=`$ECHO "$my_directory_path" \| $SED -e "$dirname"`
	533	done
	534	my_dir_list=`$ECHO "$my_dir_list" \| $SED 's,:*$,,'`
	535
	536	save_mkdir_p_IFS="$IFS"; IFS=':'
	537	for my_dir in $my_dir_list; do
	538	IFS="$save_mkdir_p_IFS"
	539	# mkdir can fail with a `File exist' error if two processes
	540	# try to create one of the directories concurrently. Don't
	541	# stop in that case!
	542	$MKDIR "$my_dir" 2>/dev/null \|\| :
	543	done
	544	IFS="$save_mkdir_p_IFS"
	545
	546	# Bail out if we (or some other process) failed to create a directory.
	547	test -d "$my_directory_path" \|\| \
	548	func_fatal_error "Failed to create \`$1'"
	549	fi
	550	}
	551
	552
	553	# func_mktempdir [string]
	554	# Make a temporary directory that won't clash with other running
	555	# libtool processes, and avoids race conditions if possible. If
	556	# given, STRING is the basename for that directory.
	557	func_mktempdir ()
	558	{
	559	my_template="${TMPDIR-/tmp}/${1-$progname}"
	560
	561	if test "$opt_dry_run" = ":"; then
	562	# Return a directory name, but don't create it in dry-run mode
	563	my_tmpdir="${my_template}-$$"
	564	else
	565
	566	# If mktemp works, use that first and foremost
	567	my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
	568
	569	if test ! -d "$my_tmpdir"; then
	570	# Failing that, at least try and use $RANDOM to avoid a race
	571	my_tmpdir="${my_template}-${RANDOM-0}$$"
	572
	573	save_mktempdir_umask=`umask`
	574	umask 0077
	575	$MKDIR "$my_tmpdir"
	576	umask $save_mktempdir_umask
	577	fi
	578
	579	# If we're not in dry-run mode, bomb out on failure
	580	test -d "$my_tmpdir" \|\| \
	581	func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
	582	fi
	583
	584	$ECHO "$my_tmpdir"
	585	}
	586
	587
	588	# func_quote_for_eval arg
	589	# Aesthetically quote ARG to be evaled later.
	590	# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
	591	# is double-quoted, suitable for a subsequent eval, whereas
	592	# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
	593	# which are still active within double quotes backslashified.
	594	func_quote_for_eval ()
	595	{
	596	case $1 in
	597	[\\\`\"\$])
	598	func_quote_for_eval_unquoted_result=`$ECHO "$1" \| $SED "$sed_quote_subst"` ;;
	599	*)
	600	func_quote_for_eval_unquoted_result="$1" ;;
	601	esac
	602
	603	case $func_quote_for_eval_unquoted_result in
	604	# Double-quote args containing shell metacharacters to delay
	605	# word splitting, command substitution and and variable
	606	# expansion for a subsequent eval.
	607	# Many Bourne shells cannot handle close brackets correctly
	608	# in scan sets, so we specify it separately.
	609	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
	610	func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
	611	;;
	612	*)
	613	func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
	614	esac
	615	}
	616
	617
	618	# func_quote_for_expand arg
	619	# Aesthetically quote ARG to be evaled later; same as above,
	620	# but do not quote variable references.
	621	func_quote_for_expand ()
	622	{
	623	case $1 in
	624	[\\\`\"])
	625	my_arg=`$ECHO "$1" \| $SED \
	626	-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
	627	*)
	628	my_arg="$1" ;;
	629	esac
	630
	631	case $my_arg in
	632	# Double-quote args containing shell metacharacters to delay
	633	# word splitting and command substitution for a subsequent eval.
	634	# Many Bourne shells cannot handle close brackets correctly
	635	# in scan sets, so we specify it separately.
	636	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
	637	my_arg="\"$my_arg\""
	638	;;
	639	esac
	640
	641	func_quote_for_expand_result="$my_arg"
	642	}
	643
	644
	645	# func_show_eval cmd [fail_exp]
	646	# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
	647	# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
	648	# is given, then evaluate it.
	649	func_show_eval ()
	650	{
	651	my_cmd="$1"
	652	my_fail_exp="${2-:}"
	653
	654	${opt_silent-false} \|\| {
	655	func_quote_for_expand "$my_cmd"
	656	eval "func_echo $func_quote_for_expand_result"
	657	}
	658
	659	if ${opt_dry_run-false}; then :; else
	660	eval "$my_cmd"
	661	my_status=$?
	662	if test "$my_status" -eq 0; then :; else
	663	eval "(exit $my_status); $my_fail_exp"
	664	fi
	665	fi
	666	}
	667
	668
	669	# func_show_eval_locale cmd [fail_exp]
	670	# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
	671	# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
	672	# is given, then evaluate it. Use the saved locale for evaluation.
	673	func_show_eval_locale ()
	674	{
	675	my_cmd="$1"
	676	my_fail_exp="${2-:}"
	677
	678	${opt_silent-false} \|\| {
	679	func_quote_for_expand "$my_cmd"
	680	eval "func_echo $func_quote_for_expand_result"
	681	}
	682
	683	if ${opt_dry_run-false}; then :; else
	684	eval "$lt_user_locale
	685	$my_cmd"
	686	my_status=$?
	687	eval "$lt_safe_locale"
	688	if test "$my_status" -eq 0; then :; else
	689	eval "(exit $my_status); $my_fail_exp"
	690	fi
	691	fi
	692	}
	693
	694	# func_tr_sh
	695	# Turn $1 into a string suitable for a shell variable name.
	696	# Result is stored in $func_tr_sh_result. All characters
	697	# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
	698	# if $1 begins with a digit, a '_' is prepended as well.
	699	func_tr_sh ()
	700	{
	701	case $1 in
	702	[0-9]* \| [!a-zA-Z0-9_])
	703	func_tr_sh_result=`$ECHO "$1" \| $SED 's/^$[0-9]$/_\1/; s/[^a-zA-Z0-9_]/_/g'`
	704	;;
	705	* )
	706	func_tr_sh_result=$1
	707	;;
	708	esac
	709	}
	710
	711
	712	# func_version
	713	# Echo version message to standard output and exit.
	714	func_version ()
	715	{
	716	$opt_debug
	717
	718	$SED -n '/(C)/!b go
	719	:more
	720	/\./!{
	721	N
	722	s/\n# / /
	723	b more
	724	}
	725	:go
	726	/^# '$PROGRAM' (GNU /,/# warranty; / {
	727	s/^# //
	728	s/^# *$//
	729	s/$(C)$[ 0-9,-]$ [1-9][0-9]$/\1\2/
	730	p
	731	}' < "$progpath"
	732	exit $?
	733	}
	734
	735	# func_usage
	736	# Echo short help message to standard output and exit.
	737	func_usage ()
	738	{
	739	$opt_debug
	740
	741	$SED -n '/^# Usage:/,/^# .--help/ {
	742	s/^# //
	743	s/^# *$//
	744	s/\$progname/'$progname'/
	745	p
	746	}' < "$progpath"
	747	echo
	748	$ECHO "run \`$progname --help \| more' for full usage"
	749	exit $?
	750	}
	751
	752	# func_help [NOEXIT]
	753	# Echo long help message to standard output and exit,
	754	# unless 'noexit' is passed as argument.
	755	func_help ()
	756	{
	757	$opt_debug
	758
	759	$SED -n '/^# Usage:/,/# Report bugs to/ {
	760	:print
	761	s/^# //
	762	s/^# *$//
	763	s\$progname'$progname'*
	764	s\$host'"$host"'*
	765	s\$SHELL'"$SHELL"'*
	766	s\$LTCC'"$LTCC"'*
	767	s\$LTCFLAGS'"$LTCFLAGS"'*
	768	s\$LD'"$LD"'*
	769	s/\$with_gnu_ld/'"$with_gnu_ld"'/
	770	s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null \|$SED 1q`"'/
	771	s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null \|$SED 1q`"'/
	772	p
	773	d
	774	}
	775	/^# .* home page:/b print
	776	/^# General help using/b print
	777	' < "$progpath"
	778	ret=$?
	779	if test -z "$1"; then
	780	exit $ret
	781	fi
	782	}
	783
	784	# func_missing_arg argname
	785	# Echo program name prefixed message to standard error and set global
	786	# exit_cmd.
	787	func_missing_arg ()
	788	{
	789	$opt_debug
	790
	791	func_error "missing argument for $1."
	792	exit_cmd=exit
	793	}
	794
	795
	796	# func_split_short_opt shortopt
	797	# Set func_split_short_opt_name and func_split_short_opt_arg shell
	798	# variables after splitting SHORTOPT after the 2nd character.
	799	func_split_short_opt ()
	800	{
	801	my_sed_short_opt='1s/^$..$.*$/\1/;q'
	802	my_sed_short_rest='1s/^..$.*$$/\1/;q'
	803
	804	func_split_short_opt_name=`$ECHO "$1" \| $SED "$my_sed_short_opt"`
	805	func_split_short_opt_arg=`$ECHO "$1" \| $SED "$my_sed_short_rest"`
	806	} # func_split_short_opt may be replaced by extended shell implementation
	807
	808
	809	# func_split_long_opt longopt
	810	# Set func_split_long_opt_name and func_split_long_opt_arg shell
	811	# variables after splitting LONGOPT at the `=' sign.
	812	func_split_long_opt ()
	813	{
	814	my_sed_long_opt='1s/^$--[^=]$=./\1/;q'
	815	my_sed_long_arg='1s/^--[^=]*=//'
	816
	817	func_split_long_opt_name=`$ECHO "$1" \| $SED "$my_sed_long_opt"`
	818	func_split_long_opt_arg=`$ECHO "$1" \| $SED "$my_sed_long_arg"`
	819	} # func_split_long_opt may be replaced by extended shell implementation
	820
	821	exit_cmd=:
	822
	823
	824
	825
	826
	827	magic="%%%MAGIC variable%%%"
	828	magic_exe="%%%MAGIC EXE variable%%%"
	829
	830	# Global variables.
	831	nonopt=
	832	preserve_args=
	833	lo2o="s/\\.lo\$/.${objext}/"
	834	o2lo="s/\\.${objext}\$/.lo/"
	835	extracted_archives=
	836	extracted_serial=0
	837
	838	# If this variable is set in any of the actions, the command in it
	839	# will be execed at the end. This prevents here-documents from being
	840	# left over by shells.
	841	exec_cmd=
	842
	843	# func_append var value
	844	# Append VALUE to the end of shell variable VAR.
	845	func_append ()
	846	{
	847	eval "${1}=\$${1}\${2}"
	848	} # func_append may be replaced by extended shell implementation
	849
	850	# func_append_quoted var value
	851	# Quote VALUE and append to the end of shell variable VAR, separated
	852	# by a space.
	853	func_append_quoted ()
	854	{
	855	func_quote_for_eval "${2}"
	856	eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
	857	} # func_append_quoted may be replaced by extended shell implementation
	858
	859
	860	# func_arith arithmetic-term...
	861	func_arith ()
	862	{
	863	func_arith_result=`expr "${@}"`
	864	} # func_arith may be replaced by extended shell implementation
	865
	866
	867	# func_len string
	868	# STRING may not start with a hyphen.
	869	func_len ()
	870	{
	871	func_len_result=`expr "${1}" : ".*" 2>/dev/null \|\| echo $max_cmd_len`
	872	} # func_len may be replaced by extended shell implementation
	873
	874
	875	# func_lo2o object
	876	func_lo2o ()
	877	{
	878	func_lo2o_result=`$ECHO "${1}" \| $SED "$lo2o"`
	879	} # func_lo2o may be replaced by extended shell implementation
	880
	881
	882	# func_xform libobj-or-source
	883	func_xform ()
	884	{
	885	func_xform_result=`$ECHO "${1}" \| $SED 's/\.[^.]*$/.lo/'`
	886	} # func_xform may be replaced by extended shell implementation
	887
	888
	889	# func_fatal_configuration arg...
	890	# Echo program name prefixed message to standard error, followed by
	891	# a configuration failure hint, and exit.
	892	func_fatal_configuration ()
	893	{
	894	func_error ${1+"$@"}
	895	func_error "See the $PACKAGE documentation for more information."
	896	func_fatal_error "Fatal configuration error."
	897	}
	898
	899
	900	# func_config
	901	# Display the configuration for all the tags in this script.
	902	func_config ()
	903	{
	904	re_begincf='^# ### BEGIN LIBTOOL'
	905	re_endcf='^# ### END LIBTOOL'
	906
	907	# Default configuration.
	908	$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
	909
	910	# Now print the configurations for the tags.
	911	for tagname in $taglist; do
	912	$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
	913	done
	914
	915	exit $?
	916	}
	917
	918	# func_features
	919	# Display the features supported by this script.
	920	func_features ()
	921	{
	922	echo "host: $host"
	923	if test "$build_libtool_libs" = yes; then
	924	echo "enable shared libraries"
	925	else
	926	echo "disable shared libraries"
	927	fi
	928	if test "$build_old_libs" = yes; then
	929	echo "enable static libraries"
	930	else
	931	echo "disable static libraries"
	932	fi
	933
	934	exit $?
	935	}
	936
	937	# func_enable_tag tagname
	938	# Verify that TAGNAME is valid, and either flag an error and exit, or
	939	# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
	940	# variable here.
	941	func_enable_tag ()
	942	{
	943	# Global variable:
	944	tagname="$1"
	945
	946	re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
	947	re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
	948	sed_extractcf="/$re_begincf/,/$re_endcf/p"
	949
	950	# Validate tagname.
	951	case $tagname in
	952	[!-_A-Za-z0-9,/])
	953	func_fatal_error "invalid tag name: $tagname"
	954	;;
	955	esac
	956
	957	# Don't test for the "default" C tag, as we know it's
	958	# there but not specially marked.
	959	case $tagname in
	960	CC) ;;
	961	*)
	962	if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
	963	taglist="$taglist $tagname"
	964
	965	# Evaluate the configuration. Be careful to quote the path
	966	# and the sed script, to avoid splitting on whitespace, but
	967	# also don't use non-portable quotes within backquotes within
	968	# quotes we have to do it in 2 steps:
	969	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
	970	eval "$extractedcf"
	971	else
	972	func_error "ignoring unknown tag $tagname"
	973	fi
	974	;;
	975	esac
	976	}
	977
	978	# func_check_version_match
	979	# Ensure that we are using m4 macros, and libtool script from the same
	980	# release of libtool.
	981	func_check_version_match ()
	982	{
	983	if test "$package_revision" != "$macro_revision"; then
	984	if test "$VERSION" != "$macro_version"; then
	985	if test -z "$macro_version"; then
	986	cat >&2 <<_LT_EOF
	987	$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
	988	$progname: definition of this LT_INIT comes from an older release.
	989	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
	990	$progname: and run autoconf again.
	991	_LT_EOF
	992	else
	993	cat >&2 <<_LT_EOF
	994	$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
	995	$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
	996	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
	997	$progname: and run autoconf again.
	998	_LT_EOF
	999	fi
	1000	else
	1001	cat >&2 <<_LT_EOF
	1002	$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
	1003	$progname: but the definition of this LT_INIT comes from revision $macro_revision.
	1004	$progname: You should recreate aclocal.m4 with macros from revision $package_revision
	1005	$progname: of $PACKAGE $VERSION and run autoconf again.
	1006	_LT_EOF
	1007	fi
	1008
	1009	exit $EXIT_MISMATCH
	1010	fi
	1011	}
	1012
	1013
	1014	# Shorthand for --mode=foo, only valid as the first argument
	1015	case $1 in
	1016	clean\|clea\|cle\|cl)
	1017	shift; set dummy --mode clean ${1+"$@"}; shift
	1018	;;
	1019	compile\|compil\|compi\|comp\|com\|co\|c)
	1020	shift; set dummy --mode compile ${1+"$@"}; shift
	1021	;;
	1022	execute\|execut\|execu\|exec\|exe\|ex\|e)
	1023	shift; set dummy --mode execute ${1+"$@"}; shift
	1024	;;
	1025	finish\|finis\|fini\|fin\|fi\|f)
	1026	shift; set dummy --mode finish ${1+"$@"}; shift
	1027	;;
	1028	install\|instal\|insta\|inst\|ins\|in\|i)
	1029	shift; set dummy --mode install ${1+"$@"}; shift
	1030	;;
	1031	link\|lin\|li\|l)
	1032	shift; set dummy --mode link ${1+"$@"}; shift
	1033	;;
	1034	uninstall\|uninstal\|uninsta\|uninst\|unins\|unin\|uni\|un\|u)
	1035	shift; set dummy --mode uninstall ${1+"$@"}; shift
	1036	;;
	1037	esac
	1038
	1039
	1040
	1041	# Option defaults:
	1042	opt_debug=:
	1043	opt_dry_run=false
	1044	opt_config=false
	1045	opt_preserve_dup_deps=false
	1046	opt_features=false
	1047	opt_finish=false
	1048	opt_help=false
	1049	opt_help_all=false
	1050	opt_silent=:
	1051	opt_warning=:
	1052	opt_verbose=:
	1053	opt_silent=false
	1054	opt_verbose=false
	1055
	1056
	1057	# Parse options once, thoroughly. This comes as soon as possible in the
	1058	# script to make things like `--version' happen as quickly as we can.
	1059	{
	1060	# this just eases exit handling
	1061	while test $# -gt 0; do
	1062	opt="$1"
	1063	shift
	1064	case $opt in
	1065	--debug\|-x) opt_debug='set -x'
	1066	func_echo "enabling shell trace mode"
	1067	$opt_debug
	1068	;;
	1069	--dry-run\|--dryrun\|-n)
	1070	opt_dry_run=:
	1071	;;
	1072	--config)
	1073	opt_config=:
	1074	func_config
	1075	;;
	1076	--dlopen\|-dlopen)
	1077	optarg="$1"
	1078	opt_dlopen="${opt_dlopen+$opt_dlopen
	1079	}$optarg"
	1080	shift
	1081	;;
	1082	--preserve-dup-deps)
	1083	opt_preserve_dup_deps=:
	1084	;;
	1085	--features)
	1086	opt_features=:
	1087	func_features
	1088	;;
	1089	--finish)
	1090	opt_finish=:
	1091	set dummy --mode finish ${1+"$@"}; shift
	1092	;;
	1093	--help)
	1094	opt_help=:
	1095	;;
	1096	--help-all)
	1097	opt_help_all=:
	1098	opt_help=': help-all'
	1099	;;
	1100	--mode)
	1101	test $# = 0 && func_missing_arg $opt && break
	1102	optarg="$1"
	1103	opt_mode="$optarg"
	1104	case $optarg in
	1105	# Valid mode arguments:
	1106	clean\|compile\|execute\|finish\|install\|link\|relink\|uninstall) ;;
	1107
	1108	# Catch anything else as an error
	1109	*) func_error "invalid argument for $opt"
	1110	exit_cmd=exit
	1111	break
	1112	;;
	1113	esac
	1114	shift
	1115	;;
	1116	--no-silent\|--no-quiet)
	1117	opt_silent=false
	1118	func_append preserve_args " $opt"
	1119	;;
	1120	--no-warning\|--no-warn)
	1121	opt_warning=false
	1122	func_append preserve_args " $opt"
	1123	;;
	1124	--no-verbose)
	1125	opt_verbose=false
	1126	func_append preserve_args " $opt"
	1127	;;
	1128	--silent\|--quiet)
	1129	opt_silent=:
	1130	func_append preserve_args " $opt"
	1131	opt_verbose=false
	1132	;;
	1133	--verbose\|-v)
	1134	opt_verbose=:
	1135	func_append preserve_args " $opt"
	1136	opt_silent=false
	1137	;;
	1138	--tag)
	1139	test $# = 0 && func_missing_arg $opt && break
	1140	optarg="$1"
	1141	opt_tag="$optarg"
	1142	func_append preserve_args " $opt $optarg"
	1143	func_enable_tag "$optarg"
	1144	shift
	1145	;;
	1146
	1147	-\?\|-h) func_usage ;;
	1148	--help) func_help ;;
	1149	--version) func_version ;;
	1150
	1151	# Separate optargs to long options:
	1152	--=)
	1153	func_split_long_opt "$opt"
	1154	set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
	1155	shift
	1156	;;
	1157
	1158	# Separate non-argument short options:
	1159	-\?\|-h\|-n\|-v)
	1160	func_split_short_opt "$opt"
	1161	set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
	1162	shift
	1163	;;
	1164
	1165	--) break ;;
	1166	-*) func_fatal_help "unrecognized option \`$opt'" ;;
	1167	*) set dummy "$opt" ${1+"$@"}; shift; break ;;
	1168	esac
	1169	done
	1170
	1171	# Validate options:
	1172
	1173	# save first non-option argument
	1174	if test "$#" -gt 0; then
	1175	nonopt="$opt"
	1176	shift
	1177	fi
	1178
	1179	# preserve --debug
	1180	test "$opt_debug" = : \|\| func_append preserve_args " --debug"
	1181
	1182	case $host in
	1183	cygwin \| mingw \| pw32 \| cegcc)
	1184	# don't eliminate duplications in $postdeps and $predeps
	1185	opt_duplicate_compiler_generated_deps=:
	1186	;;
	1187	*)
	1188	opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
	1189	;;
	1190	esac
	1191
	1192	$opt_help \|\| {
	1193	# Sanity checks first:
	1194	func_check_version_match
	1195
	1196	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
	1197	func_fatal_configuration "not configured to build any kind of library"
	1198	fi
	1199
	1200	# Darwin sucks
	1201	eval std_shrext=\"$shrext_cmds\"
	1202
	1203	# Only execute mode is allowed to have -dlopen flags.
	1204	if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
	1205	func_error "unrecognized option \`-dlopen'"
	1206	$ECHO "$help" 1>&2
	1207	exit $EXIT_FAILURE
	1208	fi
	1209
	1210	# Change the help message to a mode-specific one.
	1211	generic_help="$help"
	1212	help="Try \`$progname --help --mode=$opt_mode' for more information."
	1213	}
	1214
	1215
	1216	# Bail if the options were screwed
	1217	$exit_cmd $EXIT_FAILURE
	1218	}
	1219
	1220
	1221
	1222
	1223	## ----------- ##
	1224	## Main. ##
	1225	## ----------- ##
	1226
	1227	# func_lalib_p file
	1228	# True iff FILE is a libtool `.la' library or `.lo' object file.
	1229	# This function is only a basic sanity check; it will hardly flush out
	1230	# determined imposters.
	1231	func_lalib_p ()
	1232	{
	1233	test -f "$1" &&
	1234	$SED -e 4q "$1" 2>/dev/null \
	1235	\| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
	1236	}
	1237
	1238	# func_lalib_unsafe_p file
	1239	# True iff FILE is a libtool `.la' library or `.lo' object file.
	1240	# This function implements the same check as func_lalib_p without
	1241	# resorting to external programs. To this end, it redirects stdin and
	1242	# closes it afterwards, without saving the original file descriptor.
	1243	# As a safety measure, use it only where a negative result would be
	1244	# fatal anyway. Works if `file' does not exist.
	1245	func_lalib_unsafe_p ()
	1246	{
	1247	lalib_p=no
	1248	if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
	1249	for lalib_p_l in 1 2 3 4
	1250	do
	1251	read lalib_p_line
	1252	case "$lalib_p_line" in
	1253	\#\ Generated\ by\ $PACKAGE ) lalib_p=yes; break;;
	1254	esac
	1255	done
	1256	exec 0<&5 5<&-
	1257	fi
	1258	test "$lalib_p" = yes
	1259	}
	1260
	1261	# func_ltwrapper_script_p file
	1262	# True iff FILE is a libtool wrapper script
	1263	# This function is only a basic sanity check; it will hardly flush out
	1264	# determined imposters.
	1265	func_ltwrapper_script_p ()
	1266	{
	1267	func_lalib_p "$1"
	1268	}
	1269
	1270	# func_ltwrapper_executable_p file
	1271	# True iff FILE is a libtool wrapper executable
	1272	# This function is only a basic sanity check; it will hardly flush out
	1273	# determined imposters.
	1274	func_ltwrapper_executable_p ()
	1275	{
	1276	func_ltwrapper_exec_suffix=
	1277	case $1 in
	1278	*.exe) ;;
	1279	*) func_ltwrapper_exec_suffix=.exe ;;
	1280	esac
	1281	$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
	1282	}
	1283
	1284	# func_ltwrapper_scriptname file
	1285	# Assumes file is an ltwrapper_executable
	1286	# uses $file to determine the appropriate filename for a
	1287	# temporary ltwrapper_script.
	1288	func_ltwrapper_scriptname ()
	1289	{
	1290	func_dirname_and_basename "$1" "" "."
	1291	func_stripname '' '.exe' "$func_basename_result"
	1292	func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
	1293	}
	1294
	1295	# func_ltwrapper_p file
	1296	# True iff FILE is a libtool wrapper script or wrapper executable
	1297	# This function is only a basic sanity check; it will hardly flush out
	1298	# determined imposters.
	1299	func_ltwrapper_p ()
	1300	{
	1301	func_ltwrapper_script_p "$1" \|\| func_ltwrapper_executable_p "$1"
	1302	}
	1303
	1304
	1305	# func_execute_cmds commands fail_cmd
	1306	# Execute tilde-delimited COMMANDS.
	1307	# If FAIL_CMD is given, eval that upon failure.
	1308	# FAIL_CMD may read-access the current command in variable CMD!
	1309	func_execute_cmds ()
	1310	{
	1311	$opt_debug
	1312	save_ifs=$IFS; IFS='~'
	1313	for cmd in $1; do
	1314	IFS=$save_ifs
	1315	eval cmd=\"$cmd\"
	1316	func_show_eval "$cmd" "${2-:}"
	1317	done
	1318	IFS=$save_ifs
	1319	}
	1320
	1321
	1322	# func_source file
	1323	# Source FILE, adding directory component if necessary.
	1324	# Note that it is not necessary on cygwin/mingw to append a dot to
	1325	# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
	1326	# behavior happens only for exec(3), not for open(2)! Also, sourcing
	1327	# `FILE.' does not work on cygwin managed mounts.
	1328	func_source ()
	1329	{
	1330	$opt_debug
	1331	case $1 in
	1332	/ \| \\) . "$1" ;;
	1333	*) . "./$1" ;;
	1334	esac
	1335	}
	1336
	1337
	1338	# func_resolve_sysroot PATH
	1339	# Replace a leading = in PATH with a sysroot. Store the result into
	1340	# func_resolve_sysroot_result
	1341	func_resolve_sysroot ()
	1342	{
	1343	func_resolve_sysroot_result=$1
	1344	case $func_resolve_sysroot_result in
	1345	=*)
	1346	func_stripname '=' '' "$func_resolve_sysroot_result"
	1347	func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
	1348	;;
	1349	esac
	1350	}
	1351
	1352	# func_replace_sysroot PATH
	1353	# If PATH begins with the sysroot, replace it with = and
	1354	# store the result into func_replace_sysroot_result.
	1355	func_replace_sysroot ()
	1356	{
	1357	case "$lt_sysroot:$1" in
	1358	?:"$lt_sysroot")
	1359	func_stripname "$lt_sysroot" '' "$1"
	1360	func_replace_sysroot_result="=$func_stripname_result"
	1361	;;
	1362	*)
	1363	# Including no sysroot.
	1364	func_replace_sysroot_result=$1
	1365	;;
	1366	esac
	1367	}
	1368
	1369	# func_infer_tag arg
	1370	# Infer tagged configuration to use if any are available and
	1371	# if one wasn't chosen via the "--tag" command line option.
	1372	# Only attempt this if the compiler in the base compile
	1373	# command doesn't match the default compiler.
	1374	# arg is usually of the form 'gcc ...'
	1375	func_infer_tag ()
	1376	{
	1377	$opt_debug
	1378	if test -n "$available_tags" && test -z "$tagname"; then
	1379	CC_quoted=
	1380	for arg in $CC; do
	1381	func_append_quoted CC_quoted "$arg"
	1382	done
	1383	CC_expanded=`func_echo_all $CC`
	1384	CC_quoted_expanded=`func_echo_all $CC_quoted`
	1385	case $@ in
	1386	# Blanks in the command may have been stripped by the calling shell,
	1387	# but not from the CC environment variable when configure was run.
	1388	" $CC "* \| "$CC "* \| " $CC_expanded "* \| "$CC_expanded "* \| \
	1389	" $CC_quoted"* \| "$CC_quoted "* \| " $CC_quoted_expanded "* \| "$CC_quoted_expanded "*) ;;
	1390	# Blanks at the start of $base_compile will cause this to fail
	1391	# if we don't check for them as well.
	1392	*)
	1393	for z in $available_tags; do
	1394	if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
	1395	# Evaluate the configuration.
	1396	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
	1397	CC_quoted=
	1398	for arg in $CC; do
	1399	# Double-quote args containing other shell metacharacters.
	1400	func_append_quoted CC_quoted "$arg"
	1401	done
	1402	CC_expanded=`func_echo_all $CC`
	1403	CC_quoted_expanded=`func_echo_all $CC_quoted`
	1404	case "$@ " in
	1405	" $CC "* \| "$CC "* \| " $CC_expanded "* \| "$CC_expanded "* \| \
	1406	" $CC_quoted"* \| "$CC_quoted "* \| " $CC_quoted_expanded "* \| "$CC_quoted_expanded "*)
	1407	# The compiler in the base compile command matches
	1408	# the one in the tagged configuration.
	1409	# Assume this is the tagged configuration we want.
	1410	tagname=$z
	1411	break
	1412	;;
	1413	esac
	1414	fi
	1415	done
	1416	# If $tagname still isn't set, then no tagged configuration
	1417	# was found and let the user know that the "--tag" command
	1418	# line option must be used.
	1419	if test -z "$tagname"; then
	1420	func_echo "unable to infer tagged configuration"
	1421	func_fatal_error "specify a tag with \`--tag'"
	1422	# else
	1423	# func_verbose "using $tagname tagged configuration"
	1424	fi
	1425	;;
	1426	esac
	1427	fi
	1428	}
	1429
	1430
	1431
	1432	# func_write_libtool_object output_name pic_name nonpic_name
	1433	# Create a libtool object file (analogous to a ".la" file),
	1434	# but don't create it if we're doing a dry run.
	1435	func_write_libtool_object ()
	1436	{
	1437	write_libobj=${1}
	1438	if test "$build_libtool_libs" = yes; then
	1439	write_lobj=\'${2}\'
	1440	else
	1441	write_lobj=none
	1442	fi
	1443
	1444	if test "$build_old_libs" = yes; then
	1445	write_oldobj=\'${3}\'
	1446	else
	1447	write_oldobj=none
	1448	fi
	1449
	1450	$opt_dry_run \|\| {
	1451	cat >${write_libobj}T <<EOF
	1452	# $write_libobj - a libtool object file
	1453	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
	1454	#
	1455	# Please DO NOT delete this file!
	1456	# It is necessary for linking the library.
	1457
	1458	# Name of the PIC object.
	1459	pic_object=$write_lobj
	1460
	1461	# Name of the non-PIC object
	1462	non_pic_object=$write_oldobj
	1463
	1464	EOF
	1465	$MV "${write_libobj}T" "${write_libobj}"
	1466	}
	1467	}
	1468
	1469
	1470	##################################################
	1471	# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
	1472	##################################################
	1473
	1474	# func_convert_core_file_wine_to_w32 ARG
	1475	# Helper function used by file name conversion functions when $build is *nix,
	1476	# and $host is mingw, cygwin, or some other w32 environment. Relies on a
	1477	# correctly configured wine environment available, with the winepath program
	1478	# in $build's $PATH.
	1479	#
	1480	# ARG is the $build file name to be converted to w32 format.
	1481	# Result is available in $func_convert_core_file_wine_to_w32_result, and will
	1482	# be empty on error (or when ARG is empty)
	1483	func_convert_core_file_wine_to_w32 ()
	1484	{
	1485	$opt_debug
	1486	func_convert_core_file_wine_to_w32_result="$1"
	1487	if test -n "$1"; then
	1488	# Unfortunately, winepath does not exit with a non-zero error code, so we
	1489	# are forced to check the contents of stdout. On the other hand, if the
	1490	# command is not found, the shell will set an exit code of 127 and print
	1491	# an error message to stdout. So we must check for both error code of
	1492	# zero AND non-empty stdout, which explains the odd construction:
	1493	func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
	1494	if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
	1495	func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" \|
	1496	$SED -e "$lt_sed_naive_backslashify"`
	1497	else
	1498	func_convert_core_file_wine_to_w32_result=
	1499	fi
	1500	fi
	1501	}
	1502	# end: func_convert_core_file_wine_to_w32
	1503
	1504
	1505	# func_convert_core_path_wine_to_w32 ARG
	1506	# Helper function used by path conversion functions when $build is *nix, and
	1507	# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
	1508	# configured wine environment available, with the winepath program in $build's
	1509	# $PATH. Assumes ARG has no leading or trailing path separator characters.
	1510	#
	1511	# ARG is path to be converted from $build format to win32.
	1512	# Result is available in $func_convert_core_path_wine_to_w32_result.
	1513	# Unconvertible file (directory) names in ARG are skipped; if no directory names
	1514	# are convertible, then the result may be empty.
	1515	func_convert_core_path_wine_to_w32 ()
	1516	{
	1517	$opt_debug
	1518	# unfortunately, winepath doesn't convert paths, only file names
	1519	func_convert_core_path_wine_to_w32_result=""
	1520	if test -n "$1"; then
	1521	oldIFS=$IFS
	1522	IFS=:
	1523	for func_convert_core_path_wine_to_w32_f in $1; do
	1524	IFS=$oldIFS
	1525	func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
	1526	if test -n "$func_convert_core_file_wine_to_w32_result" ; then
	1527	if test -z "$func_convert_core_path_wine_to_w32_result"; then
	1528	func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
	1529	else
	1530	func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
	1531	fi
	1532	fi
	1533	done
	1534	IFS=$oldIFS
	1535	fi
	1536	}
	1537	# end: func_convert_core_path_wine_to_w32
	1538
	1539
	1540	# func_cygpath ARGS...
	1541	# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
	1542	# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
	1543	# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
	1544	# (2), returns the Cygwin file name or path in func_cygpath_result (input
	1545	# file name or path is assumed to be in w32 format, as previously converted
	1546	# from $build's *nix or MSYS format). In case (3), returns the w32 file name
	1547	# or path in func_cygpath_result (input file name or path is assumed to be in
	1548	# Cygwin format). Returns an empty string on error.
	1549	#
	1550	# ARGS are passed to cygpath, with the last one being the file name or path to
	1551	# be converted.
	1552	#
	1553	# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
	1554	# environment variable; do not put it in $PATH.
	1555	func_cygpath ()
	1556	{
	1557	$opt_debug
	1558	if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
	1559	func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
	1560	if test "$?" -ne 0; then
	1561	# on failure, ensure result is empty
	1562	func_cygpath_result=
	1563	fi
	1564	else
	1565	func_cygpath_result=
	1566	func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
	1567	fi
	1568	}
	1569	#end: func_cygpath
	1570
	1571
	1572	# func_convert_core_msys_to_w32 ARG
	1573	# Convert file name or path ARG from MSYS format to w32 format. Return
	1574	# result in func_convert_core_msys_to_w32_result.
	1575	func_convert_core_msys_to_w32 ()
	1576	{
	1577	$opt_debug
	1578	# awkward: cmd appends spaces to result
	1579	func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null \|
	1580	$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
	1581	}
	1582	#end: func_convert_core_msys_to_w32
	1583
	1584
	1585	# func_convert_file_check ARG1 ARG2
	1586	# Verify that ARG1 (a file name in $build format) was converted to $host
	1587	# format in ARG2. Otherwise, emit an error message, but continue (resetting
	1588	# func_to_host_file_result to ARG1).
	1589	func_convert_file_check ()
	1590	{
	1591	$opt_debug
	1592	if test -z "$2" && test -n "$1" ; then
	1593	func_error "Could not determine host file name corresponding to"
	1594	func_error " \`$1'"
	1595	func_error "Continuing, but uninstalled executables may not work."
	1596	# Fallback:
	1597	func_to_host_file_result="$1"
	1598	fi
	1599	}
	1600	# end func_convert_file_check
	1601
	1602
	1603	# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
	1604	# Verify that FROM_PATH (a path in $build format) was converted to $host
	1605	# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
	1606	# func_to_host_file_result to a simplistic fallback value (see below).
	1607	func_convert_path_check ()
	1608	{
	1609	$opt_debug
	1610	if test -z "$4" && test -n "$3"; then
	1611	func_error "Could not determine the host path corresponding to"
	1612	func_error " \`$3'"
	1613	func_error "Continuing, but uninstalled executables may not work."
	1614	# Fallback. This is a deliberately simplistic "conversion" and
	1615	# should not be "improved". See libtool.info.
	1616	if test "x$1" != "x$2"; then
	1617	lt_replace_pathsep_chars="s\|$1\|$2\|g"
	1618	func_to_host_path_result=`echo "$3" \|
	1619	$SED -e "$lt_replace_pathsep_chars"`
	1620	else
	1621	func_to_host_path_result="$3"
	1622	fi
	1623	fi
	1624	}
	1625	# end func_convert_path_check
	1626
	1627
	1628	# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
	1629	# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
	1630	# and appending REPL if ORIG matches BACKPAT.
	1631	func_convert_path_front_back_pathsep ()
	1632	{
	1633	$opt_debug
	1634	case $4 in
	1635	$1 ) func_to_host_path_result="$3$func_to_host_path_result"
	1636	;;
	1637	esac
	1638	case $4 in
	1639	$2 ) func_append func_to_host_path_result "$3"
	1640	;;
	1641	esac
	1642	}
	1643	# end func_convert_path_front_back_pathsep
	1644
	1645
	1646	##################################################
	1647	# $build to $host FILE NAME CONVERSION FUNCTIONS #
	1648	##################################################
	1649	# invoked via `$to_host_file_cmd ARG'
	1650	#
	1651	# In each case, ARG is the path to be converted from $build to $host format.
	1652	# Result will be available in $func_to_host_file_result.
	1653
	1654
	1655	# func_to_host_file ARG
	1656	# Converts the file name ARG from $build format to $host format. Return result
	1657	# in func_to_host_file_result.
	1658	func_to_host_file ()
	1659	{
	1660	$opt_debug
	1661	$to_host_file_cmd "$1"
	1662	}
	1663	# end func_to_host_file
	1664
	1665
	1666	# func_to_tool_file ARG LAZY
	1667	# converts the file name ARG from $build format to toolchain format. Return
	1668	# result in func_to_tool_file_result. If the conversion in use is listed
	1669	# in (the comma separated) LAZY, no conversion takes place.
	1670	func_to_tool_file ()
	1671	{
	1672	$opt_debug
	1673	case ,$2, in
	1674	,"$to_tool_file_cmd",)
	1675	func_to_tool_file_result=$1
	1676	;;
	1677	*)
	1678	$to_tool_file_cmd "$1"
	1679	func_to_tool_file_result=$func_to_host_file_result
	1680	;;
	1681	esac
	1682	}
	1683	# end func_to_tool_file
	1684
	1685
	1686	# func_convert_file_noop ARG
	1687	# Copy ARG to func_to_host_file_result.
	1688	func_convert_file_noop ()
	1689	{
	1690	func_to_host_file_result="$1"
	1691	}
	1692	# end func_convert_file_noop
	1693
	1694
	1695	# func_convert_file_msys_to_w32 ARG
	1696	# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
	1697	# conversion to w32 is not available inside the cwrapper. Returns result in
	1698	# func_to_host_file_result.
	1699	func_convert_file_msys_to_w32 ()
	1700	{
	1701	$opt_debug
	1702	func_to_host_file_result="$1"
	1703	if test -n "$1"; then
	1704	func_convert_core_msys_to_w32 "$1"
	1705	func_to_host_file_result="$func_convert_core_msys_to_w32_result"
	1706	fi
	1707	func_convert_file_check "$1" "$func_to_host_file_result"
	1708	}
	1709	# end func_convert_file_msys_to_w32
	1710
	1711
	1712	# func_convert_file_cygwin_to_w32 ARG
	1713	# Convert file name ARG from Cygwin to w32 format. Returns result in
	1714	# func_to_host_file_result.
	1715	func_convert_file_cygwin_to_w32 ()
	1716	{
	1717	$opt_debug
	1718	func_to_host_file_result="$1"
	1719	if test -n "$1"; then
	1720	# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
	1721	# LT_CYGPATH in this case.
	1722	func_to_host_file_result=`cygpath -m "$1"`
	1723	fi
	1724	func_convert_file_check "$1" "$func_to_host_file_result"
	1725	}
	1726	# end func_convert_file_cygwin_to_w32
	1727
	1728
	1729	# func_convert_file_nix_to_w32 ARG
	1730	# Convert file name ARG from *nix to w32 format. Requires a wine environment
	1731	# and a working winepath. Returns result in func_to_host_file_result.
	1732	func_convert_file_nix_to_w32 ()
	1733	{
	1734	$opt_debug
	1735	func_to_host_file_result="$1"
	1736	if test -n "$1"; then
	1737	func_convert_core_file_wine_to_w32 "$1"
	1738	func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
	1739	fi
	1740	func_convert_file_check "$1" "$func_to_host_file_result"
	1741	}
	1742	# end func_convert_file_nix_to_w32
	1743
	1744
	1745	# func_convert_file_msys_to_cygwin ARG
	1746	# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
	1747	# Returns result in func_to_host_file_result.
	1748	func_convert_file_msys_to_cygwin ()
	1749	{
	1750	$opt_debug
	1751	func_to_host_file_result="$1"
	1752	if test -n "$1"; then
	1753	func_convert_core_msys_to_w32 "$1"
	1754	func_cygpath -u "$func_convert_core_msys_to_w32_result"
	1755	func_to_host_file_result="$func_cygpath_result"
	1756	fi
	1757	func_convert_file_check "$1" "$func_to_host_file_result"
	1758	}
	1759	# end func_convert_file_msys_to_cygwin
	1760
	1761
	1762	# func_convert_file_nix_to_cygwin ARG
	1763	# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
	1764	# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
	1765	# in func_to_host_file_result.
	1766	func_convert_file_nix_to_cygwin ()
	1767	{
	1768	$opt_debug
	1769	func_to_host_file_result="$1"
	1770	if test -n "$1"; then
	1771	# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
	1772	func_convert_core_file_wine_to_w32 "$1"
	1773	func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
	1774	func_to_host_file_result="$func_cygpath_result"
	1775	fi
	1776	func_convert_file_check "$1" "$func_to_host_file_result"
	1777	}
	1778	# end func_convert_file_nix_to_cygwin
	1779
	1780
	1781	#############################################
	1782	# $build to $host PATH CONVERSION FUNCTIONS #
	1783	#############################################
	1784	# invoked via `$to_host_path_cmd ARG'
	1785	#
	1786	# In each case, ARG is the path to be converted from $build to $host format.
	1787	# The result will be available in $func_to_host_path_result.
	1788	#
	1789	# Path separators are also converted from $build format to $host format. If
	1790	# ARG begins or ends with a path separator character, it is preserved (but
	1791	# converted to $host format) on output.
	1792	#
	1793	# All path conversion functions are named using the following convention:
	1794	# file name conversion function : func_convert_file_X_to_Y ()
	1795	# path conversion function : func_convert_path_X_to_Y ()
	1796	# where, for any given $build/$host combination the 'X_to_Y' value is the
	1797	# same. If conversion functions are added for new $build/$host combinations,
	1798	# the two new functions must follow this pattern, or func_init_to_host_path_cmd
	1799	# will break.
	1800
	1801
	1802	# func_init_to_host_path_cmd
	1803	# Ensures that function "pointer" variable $to_host_path_cmd is set to the
	1804	# appropriate value, based on the value of $to_host_file_cmd.
	1805	to_host_path_cmd=
	1806	func_init_to_host_path_cmd ()
	1807	{
	1808	$opt_debug
	1809	if test -z "$to_host_path_cmd"; then
	1810	func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
	1811	to_host_path_cmd="func_convert_path_${func_stripname_result}"
	1812	fi
	1813	}
	1814
	1815
	1816	# func_to_host_path ARG
	1817	# Converts the path ARG from $build format to $host format. Return result
	1818	# in func_to_host_path_result.
	1819	func_to_host_path ()
	1820	{
	1821	$opt_debug
	1822	func_init_to_host_path_cmd
	1823	$to_host_path_cmd "$1"
	1824	}
	1825	# end func_to_host_path
	1826
	1827
	1828	# func_convert_path_noop ARG
	1829	# Copy ARG to func_to_host_path_result.
	1830	func_convert_path_noop ()
	1831	{
	1832	func_to_host_path_result="$1"
	1833	}
	1834	# end func_convert_path_noop
	1835
	1836
	1837	# func_convert_path_msys_to_w32 ARG
	1838	# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
	1839	# conversion to w32 is not available inside the cwrapper. Returns result in
	1840	# func_to_host_path_result.
	1841	func_convert_path_msys_to_w32 ()
	1842	{
	1843	$opt_debug
	1844	func_to_host_path_result="$1"
	1845	if test -n "$1"; then
	1846	# Remove leading and trailing path separator characters from ARG. MSYS
	1847	# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
	1848	# and winepath ignores them completely.
	1849	func_stripname : : "$1"
	1850	func_to_host_path_tmp1=$func_stripname_result
	1851	func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
	1852	func_to_host_path_result="$func_convert_core_msys_to_w32_result"
	1853	func_convert_path_check : ";" \
	1854	"$func_to_host_path_tmp1" "$func_to_host_path_result"
	1855	func_convert_path_front_back_pathsep ":" ":" ";" "$1"
	1856	fi
	1857	}
	1858	# end func_convert_path_msys_to_w32
	1859
	1860
	1861	# func_convert_path_cygwin_to_w32 ARG
	1862	# Convert path ARG from Cygwin to w32 format. Returns result in
	1863	# func_to_host_file_result.
	1864	func_convert_path_cygwin_to_w32 ()
	1865	{
	1866	$opt_debug
	1867	func_to_host_path_result="$1"
	1868	if test -n "$1"; then
	1869	# See func_convert_path_msys_to_w32:
	1870	func_stripname : : "$1"
	1871	func_to_host_path_tmp1=$func_stripname_result
	1872	func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
	1873	func_convert_path_check : ";" \
	1874	"$func_to_host_path_tmp1" "$func_to_host_path_result"
	1875	func_convert_path_front_back_pathsep ":" ":" ";" "$1"
	1876	fi
	1877	}
	1878	# end func_convert_path_cygwin_to_w32
	1879
	1880
	1881	# func_convert_path_nix_to_w32 ARG
	1882	# Convert path ARG from *nix to w32 format. Requires a wine environment and
	1883	# a working winepath. Returns result in func_to_host_file_result.
	1884	func_convert_path_nix_to_w32 ()
	1885	{
	1886	$opt_debug
	1887	func_to_host_path_result="$1"
	1888	if test -n "$1"; then
	1889	# See func_convert_path_msys_to_w32:
	1890	func_stripname : : "$1"
	1891	func_to_host_path_tmp1=$func_stripname_result
	1892	func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
	1893	func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
	1894	func_convert_path_check : ";" \
	1895	"$func_to_host_path_tmp1" "$func_to_host_path_result"
	1896	func_convert_path_front_back_pathsep ":" ":" ";" "$1"
	1897	fi
	1898	}
	1899	# end func_convert_path_nix_to_w32
	1900
	1901
	1902	# func_convert_path_msys_to_cygwin ARG
	1903	# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
	1904	# Returns result in func_to_host_file_result.
	1905	func_convert_path_msys_to_cygwin ()
	1906	{
	1907	$opt_debug
	1908	func_to_host_path_result="$1"
	1909	if test -n "$1"; then
	1910	# See func_convert_path_msys_to_w32:
	1911	func_stripname : : "$1"
	1912	func_to_host_path_tmp1=$func_stripname_result
	1913	func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
	1914	func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
	1915	func_to_host_path_result="$func_cygpath_result"
	1916	func_convert_path_check : : \
	1917	"$func_to_host_path_tmp1" "$func_to_host_path_result"
	1918	func_convert_path_front_back_pathsep ":" ":" : "$1"
	1919	fi
	1920	}
	1921	# end func_convert_path_msys_to_cygwin
	1922
	1923
	1924	# func_convert_path_nix_to_cygwin ARG
	1925	# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
	1926	# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
	1927	# func_to_host_file_result.
	1928	func_convert_path_nix_to_cygwin ()
	1929	{
	1930	$opt_debug
	1931	func_to_host_path_result="$1"
	1932	if test -n "$1"; then
	1933	# Remove leading and trailing path separator characters from
	1934	# ARG. msys behavior is inconsistent here, cygpath turns them
	1935	# into '.;' and ';.', and winepath ignores them completely.
	1936	func_stripname : : "$1"
	1937	func_to_host_path_tmp1=$func_stripname_result
	1938	func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
	1939	func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
	1940	func_to_host_path_result="$func_cygpath_result"
	1941	func_convert_path_check : : \
	1942	"$func_to_host_path_tmp1" "$func_to_host_path_result"
	1943	func_convert_path_front_back_pathsep ":" ":" : "$1"
	1944	fi
	1945	}
	1946	# end func_convert_path_nix_to_cygwin
	1947
	1948
	1949	# func_mode_compile arg...
	1950	func_mode_compile ()
	1951	{
	1952	$opt_debug
	1953	# Get the compilation command and the source file.
	1954	base_compile=
	1955	srcfile="$nonopt" # always keep a non-empty value in "srcfile"
	1956	suppress_opt=yes
	1957	suppress_output=
	1958	arg_mode=normal
	1959	libobj=
	1960	later=
	1961	pie_flag=
	1962
	1963	for arg
	1964	do
	1965	case $arg_mode in
	1966	arg )
	1967	# do not "continue". Instead, add this to base_compile
	1968	lastarg="$arg"
	1969	arg_mode=normal
	1970	;;
	1971
	1972	target )
	1973	libobj="$arg"
	1974	arg_mode=normal
	1975	continue
	1976	;;
	1977
	1978	normal )
	1979	# Accept any command-line options.
	1980	case $arg in
	1981	-o)
	1982	test -n "$libobj" && \
	1983	func_fatal_error "you cannot specify \`-o' more than once"
	1984	arg_mode=target
	1985	continue
	1986	;;
	1987
	1988	-pie \| -fpie \| -fPIE)
	1989	func_append pie_flag " $arg"
	1990	continue
	1991	;;
	1992
	1993	-shared \| -static \| -prefer-pic \| -prefer-non-pic)
	1994	func_append later " $arg"
	1995	continue
	1996	;;
	1997
	1998	-no-suppress)
	1999	suppress_opt=no
	2000	continue
	2001	;;
	2002
	2003	-Xcompiler)
	2004	arg_mode=arg # the next one goes into the "base_compile" arg list
	2005	continue # The current "srcfile" will either be retained or
	2006	;; # replaced later. I would guess that would be a bug.
	2007
	2008	-Wc,*)
	2009	func_stripname '-Wc,' '' "$arg"
	2010	args=$func_stripname_result
	2011	lastarg=
	2012	save_ifs="$IFS"; IFS=','
	2013	for arg in $args; do
	2014	IFS="$save_ifs"
	2015	func_append_quoted lastarg "$arg"
	2016	done
	2017	IFS="$save_ifs"
	2018	func_stripname ' ' '' "$lastarg"
	2019	lastarg=$func_stripname_result
	2020
	2021	# Add the arguments to base_compile.
	2022	func_append base_compile " $lastarg"
	2023	continue
	2024	;;
	2025
	2026	*)
	2027	# Accept the current argument as the source file.
	2028	# The previous "srcfile" becomes the current argument.
	2029	#
	2030	lastarg="$srcfile"
	2031	srcfile="$arg"
	2032	;;
	2033	esac # case $arg
	2034	;;
	2035	esac # case $arg_mode
	2036
	2037	# Aesthetically quote the previous argument.
	2038	func_append_quoted base_compile "$lastarg"
	2039	done # for arg
	2040
	2041	case $arg_mode in
	2042	arg)
	2043	func_fatal_error "you must specify an argument for -Xcompile"
	2044	;;
	2045	target)
	2046	func_fatal_error "you must specify a target with \`-o'"
	2047	;;
	2048	*)
	2049	# Get the name of the library object.
	2050	test -z "$libobj" && {
	2051	func_basename "$srcfile"
	2052	libobj="$func_basename_result"
	2053	}
	2054	;;
	2055	esac
	2056
	2057	# Recognize several different file suffixes.
	2058	# If the user specifies -o file.o, it is replaced with file.lo
	2059	case $libobj in
	2060	*.[cCFSifmso] \| \
	2061	.ada \| .adb \| .ads \| .asm \| \
	2062	.c++ \| .cc \| .ii \| .class \| .cpp \| .cxx \| \
	2063	.[fF][09]? \| .for \| .java \| .go \| .obj \| .sx \| .cu \| .cup)
	2064	func_xform "$libobj"
	2065	libobj=$func_xform_result
	2066	;;
	2067	esac
	2068
	2069	case $libobj in
	2070	*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
	2071	*)
	2072	func_fatal_error "cannot determine name of library object from \`$libobj'"
	2073	;;
	2074	esac
	2075
	2076	func_infer_tag $base_compile
	2077
	2078	for arg in $later; do
	2079	case $arg in
	2080	-shared)
	2081	test "$build_libtool_libs" != yes && \
	2082	func_fatal_configuration "can not build a shared library"
	2083	build_old_libs=no
	2084	continue
	2085	;;
	2086
	2087	-static)
	2088	build_libtool_libs=no
	2089	build_old_libs=yes
	2090	continue
	2091	;;
	2092
	2093	-prefer-pic)
	2094	pic_mode=yes
	2095	continue
	2096	;;
	2097
	2098	-prefer-non-pic)
	2099	pic_mode=no
	2100	continue
	2101	;;
	2102	esac
	2103	done
	2104
	2105	func_quote_for_eval "$libobj"
	2106	test "X$libobj" != "X$func_quote_for_eval_result" \
	2107	&& $ECHO "X$libobj" \| $GREP '[]~#^*{};<>?"'"'"' &()\|`$[]' \
	2108	&& func_warning "libobj name \`$libobj' may not contain shell special characters."
	2109	func_dirname_and_basename "$obj" "/" ""
	2110	objname="$func_basename_result"
	2111	xdir="$func_dirname_result"
	2112	lobj=${xdir}$objdir/$objname
	2113
	2114	test -z "$base_compile" && \
	2115	func_fatal_help "you must specify a compilation command"
	2116
	2117	# Delete any leftover library objects.
	2118	if test "$build_old_libs" = yes; then
	2119	removelist="$obj $lobj $libobj ${libobj}T"
	2120	else
	2121	removelist="$lobj $libobj ${libobj}T"
	2122	fi
	2123
	2124	# On Cygwin there's no "real" PIC flag so we must build both object types
	2125	case $host_os in
	2126	cygwin* \| mingw* \| pw32* \| os2* \| cegcc*)
	2127	pic_mode=default
	2128	;;
	2129	esac
	2130	if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
	2131	# non-PIC code in shared libraries is not supported
	2132	pic_mode=default
	2133	fi
	2134
	2135	# Calculate the filename of the output object if compiler does
	2136	# not support -o with -c
	2137	if test "$compiler_c_o" = no; then
	2138	output_obj=`$ECHO "$srcfile" \| $SED 's%^./%%; s%\.[^.]$%%'`.${objext}
	2139	lockfile="$output_obj.lock"
	2140	else
	2141	output_obj=
	2142	need_locks=no
	2143	lockfile=
	2144	fi
	2145
	2146	# Lock this critical section if it is needed
	2147	# We use this script file to make the link, it avoids creating a new file
	2148	if test "$need_locks" = yes; then
	2149	until $opt_dry_run \|\| ln "$progpath" "$lockfile" 2>/dev/null; do
	2150	func_echo "Waiting for $lockfile to be removed"
	2151	sleep 2
	2152	done
	2153	elif test "$need_locks" = warn; then
	2154	if test -f "$lockfile"; then
	2155	$ECHO "\
	2156	*** ERROR, $lockfile exists and contains:
	2157	`cat $lockfile 2>/dev/null`
	2158
	2159	This indicates that another process is trying to use the same
	2160	temporary object file, and libtool could not work around it because
	2161	your compiler does not support \`-c' and \`-o' together. If you
	2162	repeat this compilation, it may succeed, by chance, but you had better
	2163	avoid parallel builds (make -j) in this platform, or get a better
	2164	compiler."
	2165
	2166	$opt_dry_run \|\| $RM $removelist
	2167	exit $EXIT_FAILURE
	2168	fi
	2169	func_append removelist " $output_obj"
	2170	$ECHO "$srcfile" > "$lockfile"
	2171	fi
	2172
	2173	$opt_dry_run \|\| $RM $removelist
	2174	func_append removelist " $lockfile"
	2175	trap '$opt_dry_run \|\| $RM $removelist; exit $EXIT_FAILURE' 1 2 15
	2176
	2177	func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
	2178	srcfile=$func_to_tool_file_result
	2179	func_quote_for_eval "$srcfile"
	2180	qsrcfile=$func_quote_for_eval_result
	2181
	2182	# Only build a PIC object if we are building libtool libraries.
	2183	if test "$build_libtool_libs" = yes; then
	2184	# Without this assignment, base_compile gets emptied.
	2185	fbsd_hideous_sh_bug=$base_compile
	2186
	2187	if test "$pic_mode" != no; then
	2188	command="$base_compile $qsrcfile $pic_flag"
	2189	else
	2190	# Don't build PIC code
	2191	command="$base_compile $qsrcfile"
	2192	fi
	2193
	2194	func_mkdir_p "$xdir$objdir"
	2195
	2196	if test -z "$output_obj"; then
	2197	# Place PIC objects in $objdir
	2198	func_append command " -o $lobj"
	2199	fi
	2200
	2201	func_show_eval_locale "$command" \
	2202	'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
	2203
	2204	if test "$need_locks" = warn &&
	2205	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	2206	$ECHO "\
	2207	*** ERROR, $lockfile contains:
	2208	`cat $lockfile 2>/dev/null`
	2209
	2210	but it should contain:
	2211	$srcfile
	2212
	2213	This indicates that another process is trying to use the same
	2214	temporary object file, and libtool could not work around it because
	2215	your compiler does not support \`-c' and \`-o' together. If you
	2216	repeat this compilation, it may succeed, by chance, but you had better
	2217	avoid parallel builds (make -j) in this platform, or get a better
	2218	compiler."
	2219
	2220	$opt_dry_run \|\| $RM $removelist
	2221	exit $EXIT_FAILURE
	2222	fi
	2223
	2224	# Just move the object if needed, then go on to compile the next one
	2225	if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
	2226	func_show_eval '$MV "$output_obj" "$lobj"' \
	2227	'error=$?; $opt_dry_run \|\| $RM $removelist; exit $error'
	2228	fi
	2229
	2230	# Allow error messages only from the first compilation.
	2231	if test "$suppress_opt" = yes; then
	2232	suppress_output=' >/dev/null 2>&1'
	2233	fi
	2234	fi
	2235
	2236	# Only build a position-dependent object if we build old libraries.
	2237	if test "$build_old_libs" = yes; then
	2238	if test "$pic_mode" != yes; then
	2239	# Don't build PIC code
	2240	command="$base_compile $qsrcfile$pie_flag"
	2241	else
	2242	command="$base_compile $qsrcfile $pic_flag"
	2243	fi
	2244	if test "$compiler_c_o" = yes; then
	2245	func_append command " -o $obj"
	2246	fi
	2247
	2248	# Suppress compiler output if we already did a PIC compilation.
	2249	func_append command "$suppress_output"
	2250	func_show_eval_locale "$command" \
	2251	'$opt_dry_run \|\| $RM $removelist; exit $EXIT_FAILURE'
	2252
	2253	if test "$need_locks" = warn &&
	2254	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	2255	$ECHO "\
	2256	*** ERROR, $lockfile contains:
	2257	`cat $lockfile 2>/dev/null`
	2258
	2259	but it should contain:
	2260	$srcfile
	2261
	2262	This indicates that another process is trying to use the same
	2263	temporary object file, and libtool could not work around it because
	2264	your compiler does not support \`-c' and \`-o' together. If you
	2265	repeat this compilation, it may succeed, by chance, but you had better
	2266	avoid parallel builds (make -j) in this platform, or get a better
	2267	compiler."
	2268
	2269	$opt_dry_run \|\| $RM $removelist
	2270	exit $EXIT_FAILURE
	2271	fi
	2272
	2273	# Just move the object if needed
	2274	if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
	2275	func_show_eval '$MV "$output_obj" "$obj"' \
	2276	'error=$?; $opt_dry_run \|\| $RM $removelist; exit $error'
	2277	fi
	2278	fi
	2279
	2280	$opt_dry_run \|\| {
	2281	func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
	2282
	2283	# Unlock the critical section if it was locked
	2284	if test "$need_locks" != no; then
	2285	removelist=$lockfile
	2286	$RM "$lockfile"
	2287	fi
	2288	}
	2289
	2290	exit $EXIT_SUCCESS
	2291	}
	2292
	2293	$opt_help \|\| {
	2294	test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
	2295	}
	2296
	2297	func_mode_help ()
	2298	{
	2299	# We need to display help for each of the modes.
	2300	case $opt_mode in
	2301	"")
	2302	# Generic help is extracted from the usage comments
	2303	# at the start of this file.
	2304	func_help
	2305	;;
	2306
	2307	clean)
	2308	$ECHO \
	2309	"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
	2310
	2311	Remove files from the build directory.
	2312
	2313	RM is the name of the program to use to delete files associated with each FILE
	2314	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
	2315	to RM.
	2316
	2317	If FILE is a libtool library, object or program, all the files associated
	2318	with it are deleted. Otherwise, only FILE itself is deleted using RM."
	2319	;;
	2320
	2321	compile)
	2322	$ECHO \
	2323	"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
	2324
	2325	Compile a source file into a libtool library object.
	2326
	2327	This mode accepts the following additional options:
	2328
	2329	-o OUTPUT-FILE set the output file name to OUTPUT-FILE
	2330	-no-suppress do not suppress compiler output for multiple passes
	2331	-prefer-pic try to build PIC objects only
	2332	-prefer-non-pic try to build non-PIC objects only
	2333	-shared do not build a \`.o' file suitable for static linking
	2334	-static only build a \`.o' file suitable for static linking
	2335	-Wc,FLAG pass FLAG directly to the compiler
	2336
	2337	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
	2338	from the given SOURCEFILE.
	2339
	2340	The output file name is determined by removing the directory component from
	2341	SOURCEFILE, then substituting the C source code suffix \`.c' with the
	2342	library object suffix, \`.lo'."
	2343	;;
	2344
	2345	execute)
	2346	$ECHO \
	2347	"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
	2348
	2349	Automatically set library path, then run a program.
	2350
	2351	This mode accepts the following additional options:
	2352
	2353	-dlopen FILE add the directory containing FILE to the library path
	2354
	2355	This mode sets the library path environment variable according to \`-dlopen'
	2356	flags.
	2357
	2358	If any of the ARGS are libtool executable wrappers, then they are translated
	2359	into their corresponding uninstalled binary, and any of their required library
	2360	directories are added to the library path.
	2361
	2362	Then, COMMAND is executed, with ARGS as arguments."
	2363	;;
	2364
	2365	finish)
	2366	$ECHO \
	2367	"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
	2368
	2369	Complete the installation of libtool libraries.
	2370
	2371	Each LIBDIR is a directory that contains libtool libraries.
	2372
	2373	The commands that this mode executes may require superuser privileges. Use
	2374	the \`--dry-run' option if you just want to see what would be executed."
	2375	;;
	2376
	2377	install)
	2378	$ECHO \
	2379	"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
	2380
	2381	Install executables or libraries.
	2382
	2383	INSTALL-COMMAND is the installation command. The first component should be
	2384	either the \`install' or \`cp' program.
	2385
	2386	The following components of INSTALL-COMMAND are treated specially:
	2387
	2388	-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
	2389
	2390	The rest of the components are interpreted as arguments to that command (only
	2391	BSD-compatible install options are recognized)."
	2392	;;
	2393
	2394	link)
	2395	$ECHO \
	2396	"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
	2397
	2398	Link object files or libraries together to form another library, or to
	2399	create an executable program.
	2400
	2401	LINK-COMMAND is a command using the C compiler that you would use to create
	2402	a program from several object files.
	2403
	2404	The following components of LINK-COMMAND are treated specially:
	2405
	2406	-all-static do not do any dynamic linking at all
	2407	-avoid-version do not add a version suffix if possible
	2408	-bindir BINDIR specify path to binaries directory (for systems where
	2409	libraries must be found in the PATH setting at runtime)
	2410	-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
	2411	-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
	2412	-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
	2413	-export-symbols SYMFILE
	2414	try to export only the symbols listed in SYMFILE
	2415	-export-symbols-regex REGEX
	2416	try to export only the symbols matching REGEX
	2417	-LLIBDIR search LIBDIR for required installed libraries
	2418	-lNAME OUTPUT-FILE requires the installed library libNAME
	2419	-module build a library that can dlopened
	2420	-no-fast-install disable the fast-install mode
	2421	-no-install link a not-installable executable
	2422	-no-undefined declare that a library does not refer to external symbols
	2423	-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
	2424	-objectlist FILE Use a list of object files found in FILE to specify objects
	2425	-precious-files-regex REGEX
	2426	don't remove output files matching REGEX
	2427	-release RELEASE specify package release information
	2428	-rpath LIBDIR the created library will eventually be installed in LIBDIR
	2429	-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
	2430	-shared only do dynamic linking of libtool libraries
	2431	-shrext SUFFIX override the standard shared library file extension
	2432	-static do not do any dynamic linking of uninstalled libtool libraries
	2433	-static-libtool-libs
	2434	do not do any dynamic linking of libtool libraries
	2435	-version-info CURRENT[:REVISION[:AGE]]
	2436	specify library version info [each variable defaults to 0]
	2437	-weak LIBNAME declare that the target provides the LIBNAME interface
	2438	-Wc,FLAG
	2439	-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
	2440	-Wl,FLAG
	2441	-Xlinker FLAG pass linker-specific FLAG directly to the linker
	2442	-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
	2443
	2444	All other options (arguments beginning with \`-') are ignored.
	2445
	2446	Every other argument is treated as a filename. Files ending in \`.la' are
	2447	treated as uninstalled libtool libraries, other files are standard or library
	2448	object files.
	2449
	2450	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
	2451	only library objects (\`.lo' files) may be specified, and \`-rpath' is
	2452	required, except when creating a convenience library.
	2453
	2454	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
	2455	using \`ar' and \`ranlib', or on Windows using \`lib'.
	2456
	2457	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
	2458	is created, otherwise an executable program is created."
	2459	;;
	2460
	2461	uninstall)
	2462	$ECHO \
	2463	"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
	2464
	2465	Remove libraries from an installation directory.
	2466
	2467	RM is the name of the program to use to delete files associated with each FILE
	2468	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
	2469	to RM.
	2470
	2471	If FILE is a libtool library, all the files associated with it are deleted.
	2472	Otherwise, only FILE itself is deleted using RM."
	2473	;;
	2474
	2475	*)
	2476	func_fatal_help "invalid operation mode \`$opt_mode'"
	2477	;;
	2478	esac
	2479
	2480	echo
	2481	$ECHO "Try \`$progname --help' for more information about other modes."
	2482	}
	2483
	2484	# Now that we've collected a possible --mode arg, show help if necessary
	2485	if $opt_help; then
	2486	if test "$opt_help" = :; then
	2487	func_mode_help
	2488	else
	2489	{
	2490	func_help noexit
	2491	for opt_mode in compile link execute install finish uninstall clean; do
	2492	func_mode_help
	2493	done
	2494	} \| sed -n '1p; 2,$s/^Usage:/ or: /p'
	2495	{
	2496	func_help noexit
	2497	for opt_mode in compile link execute install finish uninstall clean; do
	2498	echo
	2499	func_mode_help
	2500	done
	2501	} \|
	2502	sed '1d
	2503	/^When reporting/,/^Report/{
	2504	H
	2505	d
	2506	}
	2507	$x
	2508	/information about other modes/d
	2509	/more detailed .*MODE/d
	2510	s/^Usage:.--mode=$[^ ]$ .*/Description of \1 mode:/'
	2511	fi
	2512	exit $?
	2513	fi
	2514
	2515
	2516	# func_mode_execute arg...
	2517	func_mode_execute ()
	2518	{
	2519	$opt_debug
	2520	# The first argument is the command name.
	2521	cmd="$nonopt"
	2522	test -z "$cmd" && \
	2523	func_fatal_help "you must specify a COMMAND"
	2524
	2525	# Handle -dlopen flags immediately.
	2526	for file in $opt_dlopen; do
	2527	test -f "$file" \
	2528	\|\| func_fatal_help "\`$file' is not a file"
	2529
	2530	dir=
	2531	case $file in
	2532	*.la)
	2533	func_resolve_sysroot "$file"
	2534	file=$func_resolve_sysroot_result
	2535
	2536	# Check to see that this really is a libtool archive.
	2537	func_lalib_unsafe_p "$file" \
	2538	\|\| func_fatal_help "\`$lib' is not a valid libtool archive"
	2539
	2540	# Read the libtool library.
	2541	dlname=
	2542	library_names=
	2543	func_source "$file"
	2544
	2545	# Skip this library if it cannot be dlopened.
	2546	if test -z "$dlname"; then
	2547	# Warn if it was a shared library.
	2548	test -n "$library_names" && \
	2549	func_warning "\`$file' was not linked with \`-export-dynamic'"
	2550	continue
	2551	fi
	2552
	2553	func_dirname "$file" "" "."
	2554	dir="$func_dirname_result"
	2555
	2556	if test -f "$dir/$objdir/$dlname"; then
	2557	func_append dir "/$objdir"
	2558	else
	2559	if test ! -f "$dir/$dlname"; then
	2560	func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
	2561	fi
	2562	fi
	2563	;;
	2564
	2565	*.lo)
	2566	# Just add the directory containing the .lo file.
	2567	func_dirname "$file" "" "."
	2568	dir="$func_dirname_result"
	2569	;;
	2570
	2571	*)
	2572	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
	2573	continue
	2574	;;
	2575	esac
	2576
	2577	# Get the absolute pathname.
	2578	absdir=`cd "$dir" && pwd`
	2579	test -n "$absdir" && dir="$absdir"
	2580
	2581	# Now add the directory to shlibpath_var.
	2582	if eval "test -z \"\$$shlibpath_var\""; then
	2583	eval "$shlibpath_var=\"\$dir\""
	2584	else
	2585	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
	2586	fi
	2587	done
	2588
	2589	# This variable tells wrapper scripts just to set shlibpath_var
	2590	# rather than running their programs.
	2591	libtool_execute_magic="$magic"
	2592
	2593	# Check if any of the arguments is a wrapper script.
	2594	args=
	2595	for file
	2596	do
	2597	case $file in
	2598	-* \| .la \| .lo ) ;;
	2599	*)
	2600	# Do a test to see if this is really a libtool program.
	2601	if func_ltwrapper_script_p "$file"; then
	2602	func_source "$file"
	2603	# Transform arg to wrapped name.
	2604	file="$progdir/$program"
	2605	elif func_ltwrapper_executable_p "$file"; then
	2606	func_ltwrapper_scriptname "$file"
	2607	func_source "$func_ltwrapper_scriptname_result"
	2608	# Transform arg to wrapped name.
	2609	file="$progdir/$program"
	2610	fi
	2611	;;
	2612	esac
	2613	# Quote arguments (to preserve shell metacharacters).
	2614	func_append_quoted args "$file"
	2615	done
	2616
	2617	if test "X$opt_dry_run" = Xfalse; then
	2618	if test -n "$shlibpath_var"; then
	2619	# Export the shlibpath_var.
	2620	eval "export $shlibpath_var"
	2621	fi
	2622
	2623	# Restore saved environment variables
	2624	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
	2625	do
	2626	eval "if test \"\${save_$lt_var+set}\" = set; then
	2627	$lt_var=\$save_$lt_var; export $lt_var
	2628	else
	2629	$lt_unset $lt_var
	2630	fi"
	2631	done
	2632
	2633	# Now prepare to actually exec the command.
	2634	exec_cmd="\$cmd$args"
	2635	else
	2636	# Display what would be done.
	2637	if test -n "$shlibpath_var"; then
	2638	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
	2639	echo "export $shlibpath_var"
	2640	fi
	2641	$ECHO "$cmd$args"
	2642	exit $EXIT_SUCCESS
	2643	fi
	2644	}
	2645
	2646	test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
	2647
	2648
	2649	# func_mode_finish arg...
	2650	func_mode_finish ()
	2651	{
	2652	$opt_debug
	2653	libs=
	2654	libdirs=
	2655	admincmds=
	2656
	2657	for opt in "$nonopt" ${1+"$@"}
	2658	do
	2659	if test -d "$opt"; then
	2660	func_append libdirs " $opt"
	2661
	2662	elif test -f "$opt"; then
	2663	if func_lalib_unsafe_p "$opt"; then
	2664	func_append libs " $opt"
	2665	else
	2666	func_warning "\`$opt' is not a valid libtool archive"
	2667	fi
	2668
	2669	else
	2670	func_fatal_error "invalid argument \`$opt'"
	2671	fi
	2672	done
	2673
	2674	if test -n "$libs"; then
	2675	if test -n "$lt_sysroot"; then
	2676	sysroot_regex=`$ECHO "$lt_sysroot" \| $SED "$sed_make_literal_regex"`
	2677	sysroot_cmd="s/$[ ']$$sysroot_regex/\1/g;"
	2678	else
	2679	sysroot_cmd=
	2680	fi
	2681
	2682	# Remove sysroot references
	2683	if $opt_dry_run; then
	2684	for lib in $libs; do
	2685	echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
	2686	done
	2687	else
	2688	tmpdir=`func_mktempdir`
	2689	for lib in $libs; do
	2690	sed -e "${sysroot_cmd} s/$[ ']-[LR]$=/\1/g; s/$[ ']$=/\1/g" $lib \
	2691	> $tmpdir/tmp-la
	2692	mv -f $tmpdir/tmp-la $lib
	2693	done
	2694	${RM}r "$tmpdir"
	2695	fi
	2696	fi
	2697
	2698	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
	2699	for libdir in $libdirs; do
	2700	if test -n "$finish_cmds"; then
	2701	# Do each command in the finish commands.
	2702	func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
	2703	'"$cmd"'"'
	2704	fi
	2705	if test -n "$finish_eval"; then
	2706	# Do the single finish_eval.
	2707	eval cmds=\"$finish_eval\"
	2708	$opt_dry_run \|\| eval "$cmds" \|\| func_append admincmds "
	2709	$cmds"
	2710	fi
	2711	done
	2712	fi
	2713
	2714	# Exit here if they wanted silent mode.
	2715	$opt_silent && exit $EXIT_SUCCESS
	2716
	2717	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
	2718	echo "----------------------------------------------------------------------"
	2719	echo "Libraries have been installed in:"
	2720	for libdir in $libdirs; do
	2721	$ECHO " $libdir"
	2722	done
	2723	echo
	2724	echo "If you ever happen to want to link against installed libraries"
	2725	echo "in a given directory, LIBDIR, you must either use libtool, and"
	2726	echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
	2727	echo "flag during linking and do at least one of the following:"
	2728	if test -n "$shlibpath_var"; then
	2729	echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
	2730	echo " during execution"
	2731	fi
	2732	if test -n "$runpath_var"; then
	2733	echo " - add LIBDIR to the \`$runpath_var' environment variable"
	2734	echo " during linking"
	2735	fi
	2736	if test -n "$hardcode_libdir_flag_spec"; then
	2737	libdir=LIBDIR
	2738	eval flag=\"$hardcode_libdir_flag_spec\"
	2739
	2740	$ECHO " - use the \`$flag' linker flag"
	2741	fi
	2742	if test -n "$admincmds"; then
	2743	$ECHO " - have your system administrator run these commands:$admincmds"
	2744	fi
	2745	if test -f /etc/ld.so.conf; then
	2746	echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
	2747	fi
	2748	echo
	2749
	2750	echo "See any operating system documentation about shared libraries for"
	2751	case $host in
	2752	solaris2.[6789]\|solaris2.1[0-9])
	2753	echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
	2754	echo "pages."
	2755	;;
	2756	*)
	2757	echo "more information, such as the ld(1) and ld.so(8) manual pages."
	2758	;;
	2759	esac
	2760	echo "----------------------------------------------------------------------"
	2761	fi
	2762	exit $EXIT_SUCCESS
	2763	}
	2764
	2765	test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
	2766
	2767
	2768	# func_mode_install arg...
	2769	func_mode_install ()
	2770	{
	2771	$opt_debug
	2772	# There may be an optional sh(1) argument at the beginning of
	2773	# install_prog (especially on Windows NT).
	2774	if test "$nonopt" = "$SHELL" \|\| test "$nonopt" = /bin/sh \|\|
	2775	# Allow the use of GNU shtool's install command.
	2776	case $nonopt in shtool) :;; *) false;; esac; then
	2777	# Aesthetically quote it.
	2778	func_quote_for_eval "$nonopt"
	2779	install_prog="$func_quote_for_eval_result "
	2780	arg=$1
	2781	shift
	2782	else
	2783	install_prog=
	2784	arg=$nonopt
	2785	fi
	2786
	2787	# The real first argument should be the name of the installation program.
	2788	# Aesthetically quote it.
	2789	func_quote_for_eval "$arg"
	2790	func_append install_prog "$func_quote_for_eval_result"
	2791	install_shared_prog=$install_prog
	2792	case " $install_prog " in
	2793	[\\\ /]cp\ ) install_cp=: ;;
	2794	*) install_cp=false ;;
	2795	esac
	2796
	2797	# We need to accept at least all the BSD install flags.
	2798	dest=
	2799	files=
	2800	opts=
	2801	prev=
	2802	install_type=
	2803	isdir=no
	2804	stripme=
	2805	no_mode=:
	2806	for arg
	2807	do
	2808	arg2=
	2809	if test -n "$dest"; then
	2810	func_append files " $dest"
	2811	dest=$arg
	2812	continue
	2813	fi
	2814
	2815	case $arg in
	2816	-d) isdir=yes ;;
	2817	-f)
	2818	if $install_cp; then :; else
	2819	prev=$arg
	2820	fi
	2821	;;
	2822	-g \| -m \| -o)
	2823	prev=$arg
	2824	;;
	2825	-s)
	2826	stripme=" -s"
	2827	continue
	2828	;;
	2829	-*)
	2830	;;
	2831	*)
	2832	# If the previous option needed an argument, then skip it.
	2833	if test -n "$prev"; then
	2834	if test "x$prev" = x-m && test -n "$install_override_mode"; then
	2835	arg2=$install_override_mode
	2836	no_mode=false
	2837	fi
	2838	prev=
	2839	else
	2840	dest=$arg
	2841	continue
	2842	fi
	2843	;;
	2844	esac
	2845
	2846	# Aesthetically quote the argument.
	2847	func_quote_for_eval "$arg"
	2848	func_append install_prog " $func_quote_for_eval_result"
	2849	if test -n "$arg2"; then
	2850	func_quote_for_eval "$arg2"
	2851	fi
	2852	func_append install_shared_prog " $func_quote_for_eval_result"
	2853	done
	2854
	2855	test -z "$install_prog" && \
	2856	func_fatal_help "you must specify an install program"
	2857
	2858	test -n "$prev" && \
	2859	func_fatal_help "the \`$prev' option requires an argument"
	2860
	2861	if test -n "$install_override_mode" && $no_mode; then
	2862	if $install_cp; then :; else
	2863	func_quote_for_eval "$install_override_mode"
	2864	func_append install_shared_prog " -m $func_quote_for_eval_result"
	2865	fi
	2866	fi
	2867
	2868	if test -z "$files"; then
	2869	if test -z "$dest"; then
	2870	func_fatal_help "no file or destination specified"
	2871	else
	2872	func_fatal_help "you must specify a destination"
	2873	fi
	2874	fi
	2875
	2876	# Strip any trailing slash from the destination.
	2877	func_stripname '' '/' "$dest"
	2878	dest=$func_stripname_result
	2879
	2880	# Check to see that the destination is a directory.
	2881	test -d "$dest" && isdir=yes
	2882	if test "$isdir" = yes; then
	2883	destdir="$dest"
	2884	destname=
	2885	else
	2886	func_dirname_and_basename "$dest" "" "."
	2887	destdir="$func_dirname_result"
	2888	destname="$func_basename_result"
	2889
	2890	# Not a directory, so check to see that there is only one file specified.
	2891	set dummy $files; shift
	2892	test "$#" -gt 1 && \
	2893	func_fatal_help "\`$dest' is not a directory"
	2894	fi
	2895	case $destdir in
	2896	[\\/]* \| [A-Za-z]:[\\/]*) ;;
	2897	*)
	2898	for file in $files; do
	2899	case $file in
	2900	*.lo) ;;
	2901	*)
	2902	func_fatal_help "\`$destdir' must be an absolute directory name"
	2903	;;
	2904	esac
	2905	done
	2906	;;
	2907	esac
	2908
	2909	# This variable tells wrapper scripts just to set variables rather
	2910	# than running their programs.
	2911	libtool_install_magic="$magic"
	2912
	2913	staticlibs=
	2914	future_libdirs=
	2915	current_libdirs=
	2916	for file in $files; do
	2917
	2918	# Do each installation.
	2919	case $file in
	2920	*.$libext)
	2921	# Do the static libraries later.
	2922	func_append staticlibs " $file"
	2923	;;
	2924
	2925	*.la)
	2926	func_resolve_sysroot "$file"
	2927	file=$func_resolve_sysroot_result
	2928
	2929	# Check to see that this really is a libtool archive.
	2930	func_lalib_unsafe_p "$file" \
	2931	\|\| func_fatal_help "\`$file' is not a valid libtool archive"
	2932
	2933	library_names=
	2934	old_library=
	2935	relink_command=
	2936	func_source "$file"
	2937
	2938	# Add the libdir to current_libdirs if it is the destination.
	2939	if test "X$destdir" = "X$libdir"; then
	2940	case "$current_libdirs " in
	2941	" $libdir ") ;;
	2942	*) func_append current_libdirs " $libdir" ;;
	2943	esac
	2944	else
	2945	# Note the libdir as a future libdir.
	2946	case "$future_libdirs " in
	2947	" $libdir ") ;;
	2948	*) func_append future_libdirs " $libdir" ;;
	2949	esac
	2950	fi
	2951
	2952	func_dirname "$file" "/" ""
	2953	dir="$func_dirname_result"
	2954	func_append dir "$objdir"
	2955
	2956	if test -n "$relink_command"; then
	2957	# Determine the prefix the user has applied to our future dir.
	2958	inst_prefix_dir=`$ECHO "$destdir" \| $SED -e "s%$libdir\$%%"`
	2959
	2960	# Don't allow the user to place us outside of our expected
	2961	# location b/c this prevents finding dependent libraries that
	2962	# are installed to the same prefix.
	2963	# At present, this check doesn't affect windows .dll's that
	2964	# are installed into $libdir/../bin (currently, that works fine)
	2965	# but it's something to keep an eye on.
	2966	test "$inst_prefix_dir" = "$destdir" && \
	2967	func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
	2968
	2969	if test -n "$inst_prefix_dir"; then
	2970	# Stick the inst_prefix_dir data into the link command.
	2971	relink_command=`$ECHO "$relink_command" \| $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
	2972	else
	2973	relink_command=`$ECHO "$relink_command" \| $SED "s%@inst_prefix_dir@%%"`
	2974	fi
	2975
	2976	func_warning "relinking \`$file'"
	2977	func_show_eval "$relink_command" \
	2978	'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
	2979	fi
	2980
	2981	# See the names of the shared library.
	2982	set dummy $library_names; shift
	2983	if test -n "$1"; then
	2984	realname="$1"
	2985	shift
	2986
	2987	srcname="$realname"
	2988	test -n "$relink_command" && srcname="$realname"T
	2989
	2990	# Install the shared library and build the symlinks.
	2991	func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
	2992	'exit $?'
	2993	tstripme="$stripme"
	2994	case $host_os in
	2995	cygwin* \| mingw* \| pw32* \| cegcc*)
	2996	case $realname in
	2997	*.dll.a)
	2998	tstripme=""
	2999	;;
	3000	esac
	3001	;;
	3002	esac
	3003	if test -n "$tstripme" && test -n "$striplib"; then
	3004	func_show_eval "$striplib $destdir/$realname" 'exit $?'
	3005	fi
	3006
	3007	if test "$#" -gt 0; then
	3008	# Delete the old symlinks, and create new ones.
	3009	# Try `ln -sf' first, because the `ln' binary might depend on
	3010	# the symlink we replace! Solaris /bin/ln does not understand -f,
	3011	# so we also need to try rm && ln -s.
	3012	for linkname
	3013	do
	3014	test "$linkname" != "$realname" \
	3015	&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $RM $linkname && $LN_S $realname $linkname; }; })"
	3016	done
	3017	fi
	3018
	3019	# Do each command in the postinstall commands.
	3020	lib="$destdir/$realname"
	3021	func_execute_cmds "$postinstall_cmds" 'exit $?'
	3022	fi
	3023
	3024	# Install the pseudo-library for information purposes.
	3025	func_basename "$file"
	3026	name="$func_basename_result"
	3027	instname="$dir/$name"i
	3028	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
	3029
	3030	# Maybe install the static library, too.
	3031	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
	3032	;;
	3033
	3034	*.lo)
	3035	# Install (i.e. copy) a libtool object.
	3036
	3037	# Figure out destination file name, if it wasn't already specified.
	3038	if test -n "$destname"; then
	3039	destfile="$destdir/$destname"
	3040	else
	3041	func_basename "$file"
	3042	destfile="$func_basename_result"
	3043	destfile="$destdir/$destfile"
	3044	fi
	3045
	3046	# Deduce the name of the destination old-style object file.
	3047	case $destfile in
	3048	*.lo)
	3049	func_lo2o "$destfile"
	3050	staticdest=$func_lo2o_result
	3051	;;
	3052	*.$objext)
	3053	staticdest="$destfile"
	3054	destfile=
	3055	;;
	3056	*)
	3057	func_fatal_help "cannot copy a libtool object to \`$destfile'"
	3058	;;
	3059	esac
	3060
	3061	# Install the libtool object if requested.
	3062	test -n "$destfile" && \
	3063	func_show_eval "$install_prog $file $destfile" 'exit $?'
	3064
	3065	# Install the old object if enabled.
	3066	if test "$build_old_libs" = yes; then
	3067	# Deduce the name of the old-style object file.
	3068	func_lo2o "$file"
	3069	staticobj=$func_lo2o_result
	3070	func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
	3071	fi
	3072	exit $EXIT_SUCCESS
	3073	;;
	3074
	3075	*)
	3076	# Figure out destination file name, if it wasn't already specified.
	3077	if test -n "$destname"; then
	3078	destfile="$destdir/$destname"
	3079	else
	3080	func_basename "$file"
	3081	destfile="$func_basename_result"
	3082	destfile="$destdir/$destfile"
	3083	fi
	3084
	3085	# If the file is missing, and there is a .exe on the end, strip it
	3086	# because it is most likely a libtool script we actually want to
	3087	# install
	3088	stripped_ext=""
	3089	case $file in
	3090	*.exe)
	3091	if test ! -f "$file"; then
	3092	func_stripname '' '.exe' "$file"
	3093	file=$func_stripname_result
	3094	stripped_ext=".exe"
	3095	fi
	3096	;;
	3097	esac
	3098
	3099	# Do a test to see if this is really a libtool program.
	3100	case $host in
	3101	cygwin \| mingw)
	3102	if func_ltwrapper_executable_p "$file"; then
	3103	func_ltwrapper_scriptname "$file"
	3104	wrapper=$func_ltwrapper_scriptname_result
	3105	else
	3106	func_stripname '' '.exe' "$file"
	3107	wrapper=$func_stripname_result
	3108	fi
	3109	;;
	3110	*)
	3111	wrapper=$file
	3112	;;
	3113	esac
	3114	if func_ltwrapper_script_p "$wrapper"; then
	3115	notinst_deplibs=
	3116	relink_command=
	3117
	3118	func_source "$wrapper"
	3119
	3120	# Check the variables that should have been set.
	3121	test -z "$generated_by_libtool_version" && \
	3122	func_fatal_error "invalid libtool wrapper script \`$wrapper'"
	3123
	3124	finalize=yes
	3125	for lib in $notinst_deplibs; do
	3126	# Check to see that each library is installed.
	3127	libdir=
	3128	if test -f "$lib"; then
	3129	func_source "$lib"
	3130	fi
	3131	libfile="$libdir/"`$ECHO "$lib" \| $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
	3132	if test -n "$libdir" && test ! -f "$libfile"; then
	3133	func_warning "\`$lib' has not been installed in \`$libdir'"
	3134	finalize=no
	3135	fi
	3136	done
	3137
	3138	relink_command=
	3139	func_source "$wrapper"
	3140
	3141	outputname=
	3142	if test "$fast_install" = no && test -n "$relink_command"; then
	3143	$opt_dry_run \|\| {
	3144	if test "$finalize" = yes; then
	3145	tmpdir=`func_mktempdir`
	3146	func_basename "$file$stripped_ext"
	3147	file="$func_basename_result"
	3148	outputname="$tmpdir/$file"
	3149	# Replace the output file specification.
	3150	relink_command=`$ECHO "$relink_command" \| $SED 's%@OUTPUT@%'"$outputname"'%g'`
	3151
	3152	$opt_silent \|\| {
	3153	func_quote_for_expand "$relink_command"
	3154	eval "func_echo $func_quote_for_expand_result"
	3155	}
	3156	if eval "$relink_command"; then :
	3157	else
	3158	func_error "error: relink \`$file' with the above command before installing it"
	3159	$opt_dry_run \|\| ${RM}r "$tmpdir"
	3160	continue
	3161	fi
	3162	file="$outputname"
	3163	else
	3164	func_warning "cannot relink \`$file'"
	3165	fi
	3166	}
	3167	else
	3168	# Install the binary that we compiled earlier.
	3169	file=`$ECHO "$file$stripped_ext" \| $SED "s%$[^/]*$$%$objdir/\1%"`
	3170	fi
	3171	fi
	3172
	3173	# remove .exe since cygwin /usr/bin/install will append another
	3174	# one anyway
	3175	case $install_prog,$host in
	3176	/usr/bin/install,cygwin)
	3177	case $file:$destfile in
	3178	.exe:.exe)
	3179	# this is ok
	3180	;;
	3181	.exe:)
	3182	destfile=$destfile.exe
	3183	;;
	3184	:.exe)
	3185	func_stripname '' '.exe' "$destfile"
	3186	destfile=$func_stripname_result
	3187	;;
	3188	esac
	3189	;;
	3190	esac
	3191	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
	3192	$opt_dry_run \|\| if test -n "$outputname"; then
	3193	${RM}r "$tmpdir"
	3194	fi
	3195	;;
	3196	esac
	3197	done
	3198
	3199	for file in $staticlibs; do
	3200	func_basename "$file"
	3201	name="$func_basename_result"
	3202
	3203	# Set up the ranlib parameters.
	3204	oldlib="$destdir/$name"
	3205	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
	3206	tool_oldlib=$func_to_tool_file_result
	3207
	3208	func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
	3209
	3210	if test -n "$stripme" && test -n "$old_striplib"; then
	3211	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
	3212	fi
	3213
	3214	# Do each command in the postinstall commands.
	3215	func_execute_cmds "$old_postinstall_cmds" 'exit $?'
	3216	done
	3217
	3218	test -n "$future_libdirs" && \
	3219	func_warning "remember to run \`$progname --finish$future_libdirs'"
	3220
	3221	if test -n "$current_libdirs"; then
	3222	# Maybe just do a dry run.
	3223	$opt_dry_run && current_libdirs=" -n$current_libdirs"
	3224	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
	3225	else
	3226	exit $EXIT_SUCCESS
	3227	fi
	3228	}
	3229
	3230	test "$opt_mode" = install && func_mode_install ${1+"$@"}
	3231
	3232
	3233	# func_generate_dlsyms outputname originator pic_p
	3234	# Extract symbols from dlprefiles and create ${outputname}S.o with
	3235	# a dlpreopen symbol table.
	3236	func_generate_dlsyms ()
	3237	{
	3238	$opt_debug
	3239	my_outputname="$1"
	3240	my_originator="$2"
	3241	my_pic_p="${3-no}"
	3242	my_prefix=`$ECHO "$my_originator" \| sed 's%[^a-zA-Z0-9]%_%g'`
	3243	my_dlsyms=
	3244
	3245	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	3246	if test -n "$NM" && test -n "$global_symbol_pipe"; then
	3247	my_dlsyms="${my_outputname}S.c"
	3248	else
	3249	func_error "not configured to extract global symbols from dlpreopened files"
	3250	fi
	3251	fi
	3252
	3253	if test -n "$my_dlsyms"; then
	3254	case $my_dlsyms in
	3255	"") ;;
	3256	*.c)
	3257	# Discover the nlist of each of the dlfiles.
	3258	nlist="$output_objdir/${my_outputname}.nm"
	3259
	3260	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
	3261
	3262	# Parse the name list into a source file.
	3263	func_verbose "creating $output_objdir/$my_dlsyms"
	3264
	3265	$opt_dry_run \|\| $ECHO > "$output_objdir/$my_dlsyms" "\
	3266	/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
	3267	/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
	3268
	3269	#ifdef __cplusplus
	3270	extern \"C\" {
	3271	#endif
	3272
	3273	#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) \|\| (__GNUC__ > 4))
	3274	#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
	3275	#endif
	3276
	3277	/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
	3278	#if defined(_WIN32) \|\| defined(__CYGWIN__) \|\| defined(_WIN32_WCE)
	3279	/* DATA imports from DLLs on WIN32 con't be const, because runtime
	3280	relocations are performed -- see ld's documentation on pseudo-relocs. */
	3281	# define LT_DLSYM_CONST
	3282	#elif defined(__osf__)
	3283	/* This system does not cope well with relocations in const data. */
	3284	# define LT_DLSYM_CONST
	3285	#else
	3286	# define LT_DLSYM_CONST const
	3287	#endif
	3288
	3289	/* External symbol declarations for the compiler. */\
	3290	"
	3291
	3292	if test "$dlself" = yes; then
	3293	func_verbose "generating symbol list for \`$output'"
	3294
	3295	$opt_dry_run \|\| echo ': @PROGRAM@ ' > "$nlist"
	3296
	3297	# Add our own program objects to the symbol list.
	3298	progfiles=`$ECHO "$objs$old_deplibs" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
	3299	for progfile in $progfiles; do
	3300	func_to_tool_file "$progfile" func_convert_file_msys_to_w32
	3301	func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
	3302	$opt_dry_run \|\| eval "$NM $func_to_tool_file_result \| $global_symbol_pipe >> '$nlist'"
	3303	done
	3304
	3305	if test -n "$exclude_expsyms"; then
	3306	$opt_dry_run \|\| {
	3307	eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
	3308	eval '$MV "$nlist"T "$nlist"'
	3309	}
	3310	fi
	3311
	3312	if test -n "$export_symbols_regex"; then
	3313	$opt_dry_run \|\| {
	3314	eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
	3315	eval '$MV "$nlist"T "$nlist"'
	3316	}
	3317	fi
	3318
	3319	# Prepare the list of exported symbols
	3320	if test -z "$export_symbols"; then
	3321	export_symbols="$output_objdir/$outputname.exp"
	3322	$opt_dry_run \|\| {
	3323	$RM $export_symbols
	3324	eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'
	3325	case $host in
	3326	cygwin \| mingw \| cegcc )
	3327	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
	3328	eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
	3329	;;
	3330	esac
	3331	}
	3332	else
	3333	$opt_dry_run \|\| {
	3334	eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
	3335	eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
	3336	eval '$MV "$nlist"T "$nlist"'
	3337	case $host in
	3338	cygwin \| mingw \| cegcc )
	3339	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
	3340	eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
	3341	;;
	3342	esac
	3343	}
	3344	fi
	3345	fi
	3346
	3347	for dlprefile in $dlprefiles; do
	3348	func_verbose "extracting global C symbols from \`$dlprefile'"
	3349	func_basename "$dlprefile"
	3350	name="$func_basename_result"
	3351	case $host in
	3352	cygwin \| mingw \| cegcc )
	3353	# if an import library, we need to obtain dlname
	3354	if func_win32_import_lib_p "$dlprefile"; then
	3355	func_tr_sh "$dlprefile"
	3356	eval "curr_lafile=\$libfile_$func_tr_sh_result"
	3357	dlprefile_dlbasename=""
	3358	if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
	3359	# Use subshell, to avoid clobbering current variable values
	3360	dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
	3361	if test -n "$dlprefile_dlname" ; then
	3362	func_basename "$dlprefile_dlname"
	3363	dlprefile_dlbasename="$func_basename_result"
	3364	else
	3365	# no lafile. user explicitly requested -dlpreopen <import library>.
	3366	$sharedlib_from_linklib_cmd "$dlprefile"
	3367	dlprefile_dlbasename=$sharedlib_from_linklib_result
	3368	fi
	3369	fi
	3370	$opt_dry_run \|\| {
	3371	if test -n "$dlprefile_dlbasename" ; then
	3372	eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
	3373	else
	3374	func_warning "Could not compute DLL name from $name"
	3375	eval '$ECHO ": $name " >> "$nlist"'
	3376	fi
	3377	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	3378	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null \| $global_symbol_pipe \|
	3379	$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
	3380	}
	3381	else # not an import lib
	3382	$opt_dry_run \|\| {
	3383	eval '$ECHO ": $name " >> "$nlist"'
	3384	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	3385	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null \| $global_symbol_pipe >> '$nlist'"
	3386	}
	3387	fi
	3388	;;
	3389	*)
	3390	$opt_dry_run \|\| {
	3391	eval '$ECHO ": $name " >> "$nlist"'
	3392	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	3393	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null \| $global_symbol_pipe >> '$nlist'"
	3394	}
	3395	;;
	3396	esac
	3397	done
	3398
	3399	$opt_dry_run \|\| {
	3400	# Make sure we have at least an empty file.
	3401	test -f "$nlist" \|\| : > "$nlist"
	3402
	3403	if test -n "$exclude_expsyms"; then
	3404	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
	3405	$MV "$nlist"T "$nlist"
	3406	fi
	3407
	3408	# Try sorting and uniquifying the output.
	3409	if $GREP -v "^: " < "$nlist" \|
	3410	if sort -k 3 </dev/null >/dev/null 2>&1; then
	3411	sort -k 3
	3412	else
	3413	sort +2
	3414	fi \|
	3415	uniq > "$nlist"S; then
	3416	:
	3417	else
	3418	$GREP -v "^: " < "$nlist" > "$nlist"S
	3419	fi
	3420
	3421	if test -f "$nlist"S; then
	3422	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
	3423	else
	3424	echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
	3425	fi
	3426
	3427	echo >> "$output_objdir/$my_dlsyms" "\
	3428
	3429	/* The mapping between symbol names and symbols. */
	3430	typedef struct {
	3431	const char *name;
	3432	void *address;
	3433	} lt_dlsymlist;
	3434	extern LT_DLSYM_CONST lt_dlsymlist
	3435	lt_${my_prefix}_LTX_preloaded_symbols[];
	3436	LT_DLSYM_CONST lt_dlsymlist
	3437	lt_${my_prefix}_LTX_preloaded_symbols[] =
	3438	{\
	3439	{ \"$my_originator\", (void *) 0 },"
	3440
	3441	case $need_lib_prefix in
	3442	no)
	3443	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
	3444	;;
	3445	*)
	3446	eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
	3447	;;
	3448	esac
	3449	echo >> "$output_objdir/$my_dlsyms" "\
	3450	{0, (void *) 0}
	3451	};
	3452
	3453	/* This works around a problem in FreeBSD linker */
	3454	#ifdef FREEBSD_WORKAROUND
	3455	static const void *lt_preloaded_setup() {
	3456	return lt_${my_prefix}_LTX_preloaded_symbols;
	3457	}
	3458	#endif
	3459
	3460	#ifdef __cplusplus
	3461	}
	3462	#endif\
	3463	"
	3464	} # !$opt_dry_run
	3465
	3466	pic_flag_for_symtable=
	3467	case "$compile_command " in
	3468	" -static ") ;;
	3469	*)
	3470	case $host in
	3471	# compiling the symbol table file with pic_flag works around
	3472	# a FreeBSD bug that causes programs to crash when -lm is
	3473	# linked before any other PIC object. But we must not use
	3474	# pic_flag when linking with -static. The problem exists in
	3475	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
	3476	--freebsd2.\|--freebsd3.0\|--freebsdelf3.0*)
	3477	pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
	3478	--hpux*)
	3479	pic_flag_for_symtable=" $pic_flag" ;;
	3480	*)
	3481	if test "X$my_pic_p" != Xno; then
	3482	pic_flag_for_symtable=" $pic_flag"
	3483	fi
	3484	;;
	3485	esac
	3486	;;
	3487	esac
	3488	symtab_cflags=
	3489	for arg in $LTCFLAGS; do
	3490	case $arg in
	3491	-pie \| -fpie \| -fPIE) ;;
	3492	*) func_append symtab_cflags " $arg" ;;
	3493	esac
	3494	done
	3495
	3496	# Now compile the dynamic symbol file.
	3497	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
	3498
	3499	# Clean up the generated files.
	3500	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
	3501
	3502	# Transform the symbol file into the correct name.
	3503	symfileobj="$output_objdir/${my_outputname}S.$objext"
	3504	case $host in
	3505	cygwin \| mingw \| cegcc )
	3506	if test -f "$output_objdir/$my_outputname.def"; then
	3507	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
	3508	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
	3509	else
	3510	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
	3511	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
	3512	fi
	3513	;;
	3514	*)
	3515	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
	3516	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
	3517	;;
	3518	esac
	3519	;;
	3520	*)
	3521	func_fatal_error "unknown suffix for \`$my_dlsyms'"
	3522	;;
	3523	esac
	3524	else
	3525	# We keep going just in case the user didn't refer to
	3526	# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
	3527	# really was required.
	3528
	3529	# Nullify the symbol file.
	3530	compile_command=`$ECHO "$compile_command" \| $SED "s% @SYMFILE@%%"`
	3531	finalize_command=`$ECHO "$finalize_command" \| $SED "s% @SYMFILE@%%"`
	3532	fi
	3533	}
	3534
	3535	# func_win32_libid arg
	3536	# return the library type of file 'arg'
	3537	#
	3538	# Need a lot of goo to handle both DLLs and import libs
	3539	# Has to be a shell function in order to 'eat' the argument
	3540	# that is supplied when $file_magic_command is called.
	3541	# Despite the name, also deal with 64 bit binaries.
	3542	func_win32_libid ()
	3543	{
	3544	$opt_debug
	3545	win32_libid_type="unknown"
	3546	win32_fileres=`file -L $1 2>/dev/null`
	3547	case $win32_fileres in
	3548	ar\ archive\ import\ library) # definitely import
	3549	win32_libid_type="x86 archive import"
	3550	;;
	3551	ar\ archive) # could be an import, or static
	3552	# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
	3553	if eval $OBJDUMP -f $1 \| $SED -e '10q' 2>/dev/null \|
	3554	$EGREP 'file format (pei-i386(.architecture: i386)?\|pe-arm-wince\|pe-x86-64)' >/dev/null; then
	3555	func_to_tool_file "$1" func_convert_file_msys_to_w32
	3556	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" \|
	3557	$SED -n -e '
	3558	1,100{
	3559	/ I /{
	3560	s,.*,import,
	3561	p
	3562	q
	3563	}
	3564	}'`
	3565	case $win32_nmres in
	3566	import*) win32_libid_type="x86 archive import";;
	3567	*) win32_libid_type="x86 archive static";;
	3568	esac
	3569	fi
	3570	;;
	3571	DLL)
	3572	win32_libid_type="x86 DLL"
	3573	;;
	3574	executable) # but shell scripts are "executable" too...
	3575	case $win32_fileres in
	3576	MS\ Windows\ PE\ Intel)
	3577	win32_libid_type="x86 DLL"
	3578	;;
	3579	esac
	3580	;;
	3581	esac
	3582	$ECHO "$win32_libid_type"
	3583	}
	3584
	3585	# func_cygming_dll_for_implib ARG
	3586	#
	3587	# Platform-specific function to extract the
	3588	# name of the DLL associated with the specified
	3589	# import library ARG.
	3590	# Invoked by eval'ing the libtool variable
	3591	# $sharedlib_from_linklib_cmd
	3592	# Result is available in the variable
	3593	# $sharedlib_from_linklib_result
	3594	func_cygming_dll_for_implib ()
	3595	{
	3596	$opt_debug
	3597	sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
	3598	}
	3599
	3600	# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
	3601	#
	3602	# The is the core of a fallback implementation of a
	3603	# platform-specific function to extract the name of the
	3604	# DLL associated with the specified import library LIBNAME.
	3605	#
	3606	# SECTION_NAME is either .idata$6 or .idata$7, depending
	3607	# on the platform and compiler that created the implib.
	3608	#
	3609	# Echos the name of the DLL associated with the
	3610	# specified import library.
	3611	func_cygming_dll_for_implib_fallback_core ()
	3612	{
	3613	$opt_debug
	3614	match_literal=`$ECHO "$1" \| $SED "$sed_make_literal_regex"`
	3615	$OBJDUMP -s --section "$1" "$2" 2>/dev/null \|
	3616	$SED '/^Contents of section '"$match_literal"':/{
	3617	# Place marker at beginning of archive member dllname section
	3618	s/.*/====MARK====/
	3619	p
	3620	d
	3621	}
	3622	# These lines can sometimes be longer than 43 characters, but
	3623	# are always uninteresting
	3624	/:[ ]*file format pe[i]\{,1\}-/d
	3625	/^In archive [^:]*:/d
	3626	# Ensure marker is printed
	3627	/^====MARK====/p
	3628	# Remove all lines with less than 43 characters
	3629	/^.\{43\}/!d
	3630	# From remaining lines, remove first 43 characters
	3631	s/^.\{43\}//' \|
	3632	$SED -n '
	3633	# Join marker and all lines until next marker into a single line
	3634	/^====MARK====/ b para
	3635	H
	3636	$ b para
	3637	b
	3638	:para
	3639	x
	3640	s/\n//g
	3641	# Remove the marker
	3642	s/^====MARK====//
	3643	# Remove trailing dots and whitespace
	3644	s/[\. \t]*$//
	3645	# Print
	3646	/./p' \|
	3647	# we now have a list, one entry per line, of the stringified
	3648	# contents of the appropriate section of all members of the
	3649	# archive which possess that section. Heuristic: eliminate
	3650	# all those which have a first or second character that is
	3651	# a '.' (that is, objdump's representation of an unprintable
	3652	# character.) This should work for all archives with less than
	3653	# 0x302f exports -- but will fail for DLLs whose name actually
	3654	# begins with a literal '.' or a single character followed by
	3655	# a '.'.
	3656	#
	3657	# Of those that remain, print the first one.
	3658	$SED -e '/^\./d;/^.\./d;q'
	3659	}
	3660
	3661	# func_cygming_gnu_implib_p ARG
	3662	# This predicate returns with zero status (TRUE) if
	3663	# ARG is a GNU/binutils-style import library. Returns
	3664	# with nonzero status (FALSE) otherwise.
	3665	func_cygming_gnu_implib_p ()
	3666	{
	3667	$opt_debug
	3668	func_to_tool_file "$1" func_convert_file_msys_to_w32
	3669	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)$'`
	3670	test -n "$func_cygming_gnu_implib_tmp"
	3671	}
	3672
	3673	# func_cygming_ms_implib_p ARG
	3674	# This predicate returns with zero status (TRUE) if
	3675	# ARG is an MS-style import library. Returns
	3676	# with nonzero status (FALSE) otherwise.
	3677	func_cygming_ms_implib_p ()
	3678	{
	3679	$opt_debug
	3680	func_to_tool_file "$1" func_convert_file_msys_to_w32
	3681	func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" \| eval "$global_symbol_pipe" \| $GREP '_NULL_IMPORT_DESCRIPTOR'`
	3682	test -n "$func_cygming_ms_implib_tmp"
	3683	}
	3684
	3685	# func_cygming_dll_for_implib_fallback ARG
	3686	# Platform-specific function to extract the
	3687	# name of the DLL associated with the specified
	3688	# import library ARG.
	3689	#
	3690	# This fallback implementation is for use when $DLLTOOL
	3691	# does not support the --identify-strict option.
	3692	# Invoked by eval'ing the libtool variable
	3693	# $sharedlib_from_linklib_cmd
	3694	# Result is available in the variable
	3695	# $sharedlib_from_linklib_result
	3696	func_cygming_dll_for_implib_fallback ()
	3697	{
	3698	$opt_debug
	3699	if func_cygming_gnu_implib_p "$1" ; then
	3700	# binutils import library
	3701	sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
	3702	elif func_cygming_ms_implib_p "$1" ; then
	3703	# ms-generated import library
	3704	sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
	3705	else
	3706	# unknown
	3707	sharedlib_from_linklib_result=""
	3708	fi
	3709	}
	3710
	3711
	3712	# func_extract_an_archive dir oldlib
	3713	func_extract_an_archive ()
	3714	{
	3715	$opt_debug
	3716	f_ex_an_ar_dir="$1"; shift
	3717	f_ex_an_ar_oldlib="$1"
	3718	if test "$lock_old_archive_extraction" = yes; then
	3719	lockfile=$f_ex_an_ar_oldlib.lock
	3720	until $opt_dry_run \|\| ln "$progpath" "$lockfile" 2>/dev/null; do
	3721	func_echo "Waiting for $lockfile to be removed"
	3722	sleep 2
	3723	done
	3724	fi
	3725	func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
	3726	'stat=$?; rm -f "$lockfile"; exit $stat'
	3727	if test "$lock_old_archive_extraction" = yes; then
	3728	$opt_dry_run \|\| rm -f "$lockfile"
	3729	fi
	3730	if ($AR t "$f_ex_an_ar_oldlib" \| sort \| sort -uc >/dev/null 2>&1); then
	3731	:
	3732	else
	3733	func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
	3734	fi
	3735	}
	3736
	3737
	3738	# func_extract_archives gentop oldlib ...
	3739	func_extract_archives ()
	3740	{
	3741	$opt_debug
	3742	my_gentop="$1"; shift
	3743	my_oldlibs=${1+"$@"}
	3744	my_oldobjs=""
	3745	my_xlib=""
	3746	my_xabs=""
	3747	my_xdir=""
	3748
	3749	for my_xlib in $my_oldlibs; do
	3750	# Extract the objects.
	3751	case $my_xlib in
	3752	[\\/]* \| [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
	3753	*) my_xabs=`pwd`"/$my_xlib" ;;
	3754	esac
	3755	func_basename "$my_xlib"
	3756	my_xlib="$func_basename_result"
	3757	my_xlib_u=$my_xlib
	3758	while :; do
	3759	case " $extracted_archives " in
	3760	" $my_xlib_u ")
	3761	func_arith $extracted_serial + 1
	3762	extracted_serial=$func_arith_result
	3763	my_xlib_u=lt$extracted_serial-$my_xlib ;;
	3764	*) break ;;
	3765	esac
	3766	done
	3767	extracted_archives="$extracted_archives $my_xlib_u"
	3768	my_xdir="$my_gentop/$my_xlib_u"
	3769
	3770	func_mkdir_p "$my_xdir"
	3771
	3772	case $host in
	3773	-darwin)
	3774	func_verbose "Extracting $my_xabs"
	3775	# Do not bother doing anything if just a dry run
	3776	$opt_dry_run \|\| {
	3777	darwin_orig_dir=`pwd`
	3778	cd $my_xdir \|\| exit $?
	3779	darwin_archive=$my_xabs
	3780	darwin_curdir=`pwd`
	3781	darwin_base_archive=`basename "$darwin_archive"`
	3782	darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null \| $GREP Architectures 2>/dev/null \|\| true`
	3783	if test -n "$darwin_arches"; then
	3784	darwin_arches=`$ECHO "$darwin_arches" \| $SED -e 's/.*are://'`
	3785	darwin_arch=
	3786	func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
	3787	for darwin_arch in $darwin_arches ; do
	3788	func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
	3789	$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
	3790	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
	3791	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
	3792	cd "$darwin_curdir"
	3793	$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
	3794	done # $darwin_arches
	3795	## Okay now we've a bunch of thin objects, gotta fatten them up :)
	3796	darwin_filelist=`find unfat-$$ -type f -name \.o -print -o -name \.lo -print \| $SED -e "$basename" \| sort -u`
	3797	darwin_file=
	3798	darwin_files=
	3799	for darwin_file in $darwin_filelist; do
	3800	darwin_files=`find unfat-$$ -name $darwin_file -print \| sort \| $NL2SP`
	3801	$LIPO -create -output "$darwin_file" $darwin_files
	3802	done # $darwin_filelist
	3803	$RM -rf unfat-$$
	3804	cd "$darwin_orig_dir"
	3805	else
	3806	cd $darwin_orig_dir
	3807	func_extract_an_archive "$my_xdir" "$my_xabs"
	3808	fi # $darwin_arches
	3809	} # !$opt_dry_run
	3810	;;
	3811	*)
	3812	func_extract_an_archive "$my_xdir" "$my_xabs"
	3813	;;
	3814	esac
	3815	my_oldobjs="$my_oldobjs "`find $my_xdir -name \.$objext -print -o -name \.lo -print \| sort \| $NL2SP`
	3816	done
	3817
	3818	func_extract_archives_result="$my_oldobjs"
	3819	}
	3820
	3821
	3822	# func_emit_wrapper [arg=no]
	3823	#
	3824	# Emit a libtool wrapper script on stdout.
	3825	# Don't directly open a file because we may want to
	3826	# incorporate the script contents within a cygwin/mingw
	3827	# wrapper executable. Must ONLY be called from within
	3828	# func_mode_link because it depends on a number of variables
	3829	# set therein.
	3830	#
	3831	# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
	3832	# variable will take. If 'yes', then the emitted script
	3833	# will assume that the directory in which it is stored is
	3834	# the $objdir directory. This is a cygwin/mingw-specific
	3835	# behavior.
	3836	func_emit_wrapper ()
	3837	{
	3838	func_emit_wrapper_arg1=${1-no}
	3839
	3840	$ECHO "\
	3841	#! $SHELL
	3842
	3843	# $output - temporary wrapper script for $objdir/$outputname
	3844	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
	3845	#
	3846	# The $output program cannot be directly executed until all the libtool
	3847	# libraries that it depends on are installed.
	3848	#
	3849	# This wrapper script should never be moved out of the build directory.
	3850	# If it is, it will not operate correctly.
	3851
	3852	# Sed substitution that helps us do robust quoting. It backslashifies
	3853	# metacharacters that are still active within double-quoted strings.
	3854	sed_quote_subst='$sed_quote_subst'
	3855
	3856	# Be Bourne compatible
	3857	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
	3858	emulate sh
	3859	NULLCMD=:
	3860	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
	3861	# is contrary to our usage. Disable this feature.
	3862	alias -g '\${1+\"\$@\"}'='\"\$@\"'
	3863	setopt NO_GLOB_SUBST
	3864	else
	3865	case \`(set -o) 2>/dev/null\` in posix) set -o posix;; esac
	3866	fi
	3867	BIN_SH=xpg4; export BIN_SH # for Tru64
	3868	DUALCASE=1; export DUALCASE # for MKS sh
	3869
	3870	# The HP-UX ksh and POSIX shell print the target directory to stdout
	3871	# if CDPATH is set.
	3872	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
	3873
	3874	relink_command=\"$relink_command\"
	3875
	3876	# This environment variable determines our operation mode.
	3877	if test \"\$libtool_install_magic\" = \"$magic\"; then
	3878	# install mode needs the following variables:
	3879	generated_by_libtool_version='$macro_version'
	3880	notinst_deplibs='$notinst_deplibs'
	3881	else
	3882	# When we are sourced in execute mode, \$file and \$ECHO are already set.
	3883	if test \"\$libtool_execute_magic\" != \"$magic\"; then
	3884	file=\"\$0\""
	3885
	3886	qECHO=`$ECHO "$ECHO" \| $SED "$sed_quote_subst"`
	3887	$ECHO "\
	3888
	3889	# A function that is used when there is no print builtin or printf.
	3890	func_fallback_echo ()
	3891	{
	3892	eval 'cat <<_LTECHO_EOF
	3893	\$1
	3894	_LTECHO_EOF'
	3895	}
	3896	ECHO=\"$qECHO\"
	3897	fi
	3898
	3899	# Very basic option parsing. These options are (a) specific to
	3900	# the libtool wrapper, (b) are identical between the wrapper
	3901	# /script/ and the wrapper /executable/ which is used only on
	3902	# windows platforms, and (c) all begin with the string "--lt-"
	3903	# (application programs are unlikely to have options which match
	3904	# this pattern).
	3905	#
	3906	# There are only two supported options: --lt-debug and
	3907	# --lt-dump-script. There is, deliberately, no --lt-help.
	3908	#
	3909	# The first argument to this parsing function should be the
	3910	# script's $0 value, followed by "$@".
	3911	lt_option_debug=
	3912	func_parse_lt_options ()
	3913	{
	3914	lt_script_arg0=\$0
	3915	shift
	3916	for lt_opt
	3917	do
	3918	case \"\$lt_opt\" in
	3919	--lt-debug) lt_option_debug=1 ;;
	3920	--lt-dump-script)
	3921	lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" \| $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
	3922	test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
	3923	lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" \| $SED -e 's/^X//' -e 's%^.*/%%'\`
	3924	cat \"\$lt_dump_D/\$lt_dump_F\"
	3925	exit 0
	3926	;;
	3927	--lt-*)
	3928	\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
	3929	exit 1
	3930	;;
	3931	esac
	3932	done
	3933
	3934	# Print the debug banner immediately:
	3935	if test -n \"\$lt_option_debug\"; then
	3936	echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
	3937	fi
	3938	}
	3939
	3940	# Used when --lt-debug. Prints its arguments to stdout
	3941	# (redirection is the responsibility of the caller)
	3942	func_lt_dump_args ()
	3943	{
	3944	lt_dump_args_N=1;
	3945	for lt_arg
	3946	do
	3947	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
	3948	lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
	3949	done
	3950	}
	3951
	3952	# Core function for launching the target application
	3953	func_exec_program_core ()
	3954	{
	3955	"
	3956	case $host in
	3957	# Backslashes separate directories on plain windows
	3958	--mingw \| --os2* \| -cegcc)
	3959	$ECHO "\
	3960	if test -n \"\$lt_option_debug\"; then
	3961	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
	3962	func_lt_dump_args \${1+\"\$@\"} 1>&2
	3963	fi
	3964	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
	3965	"
	3966	;;
	3967
	3968	*)
	3969	$ECHO "\
	3970	if test -n \"\$lt_option_debug\"; then
	3971	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
	3972	func_lt_dump_args \${1+\"\$@\"} 1>&2
	3973	fi
	3974	exec \"\$progdir/\$program\" \${1+\"\$@\"}
	3975	"
	3976	;;
	3977	esac
	3978	$ECHO "\
	3979	\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
	3980	exit 1
	3981	}
	3982
	3983	# A function to encapsulate launching the target application
	3984	# Strips options in the --lt-* namespace from \$@ and
	3985	# launches target application with the remaining arguments.
	3986	func_exec_program ()
	3987	{
	3988	case \" \$* \" in
	3989	\\ --lt-)
	3990	for lt_wr_arg
	3991	do
	3992	case \$lt_wr_arg in
	3993	--lt-*) ;;
	3994	*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
	3995	esac
	3996	shift
	3997	done ;;
	3998	esac
	3999	func_exec_program_core \${1+\"\$@\"}
	4000	}
	4001
	4002	# Parse options
	4003	func_parse_lt_options \"\$0\" \${1+\"\$@\"}
	4004
	4005	# Find the directory that this script lives in.
	4006	thisdir=\`\$ECHO \"\$file\" \| $SED 's%/[^/]*$%%'\`
	4007	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
	4008
	4009	# Follow symbolic links until we get to the real thisdir.
	4010	file=\`ls -ld \"\$file\" \| $SED -n 's/.*-> //p'\`
	4011	while test -n \"\$file\"; do
	4012	destdir=\`\$ECHO \"\$file\" \| $SED 's%/[^/]*\$%%'\`
	4013
	4014	# If there was a directory component, then change thisdir.
	4015	if test \"x\$destdir\" != \"x\$file\"; then
	4016	case \"\$destdir\" in
	4017	[\\\\/]* \| [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
	4018	*) thisdir=\"\$thisdir/\$destdir\" ;;
	4019	esac
	4020	fi
	4021
	4022	file=\`\$ECHO \"\$file\" \| $SED 's%^.*/%%'\`
	4023	file=\`ls -ld \"\$thisdir/\$file\" \| $SED -n 's/.*-> //p'\`
	4024	done
	4025
	4026	# Usually 'no', except on cygwin/mingw when embedded into
	4027	# the cwrapper.
	4028	WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
	4029	if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
	4030	# special case for '.'
	4031	if test \"\$thisdir\" = \".\"; then
	4032	thisdir=\`pwd\`
	4033	fi
	4034	# remove .libs from thisdir
	4035	case \"\$thisdir\" in
	4036	[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" \| $SED 's%[\\\\/][^\\\\/]$%%'\` ;;
	4037	$objdir ) thisdir=. ;;
	4038	esac
	4039	fi
	4040
	4041	# Try to get the absolute directory name.
	4042	absdir=\`cd \"\$thisdir\" && pwd\`
	4043	test -n \"\$absdir\" && thisdir=\"\$absdir\"
	4044	"
	4045
	4046	if test "$fast_install" = yes; then
	4047	$ECHO "\
	4048	program=lt-'$outputname'$exeext
	4049	progdir=\"\$thisdir/$objdir\"
	4050
	4051	if test ! -f \"\$progdir/\$program\" \|\|
	4052	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null \| ${SED} 1q\`; \\
	4053	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
	4054
	4055	file=\"\$\$-\$program\"
	4056
	4057	if test ! -d \"\$progdir\"; then
	4058	$MKDIR \"\$progdir\"
	4059	else
	4060	$RM \"\$progdir/\$file\"
	4061	fi"
	4062
	4063	$ECHO "\
	4064
	4065	# relink executable if necessary
	4066	if test -n \"\$relink_command\"; then
	4067	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
	4068	else
	4069	$ECHO \"\$relink_command_output\" >&2
	4070	$RM \"\$progdir/\$file\"
	4071	exit 1
	4072	fi
	4073	fi
	4074
	4075	$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null \|\|
	4076	{ $RM \"\$progdir/\$program\";
	4077	$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
	4078	$RM \"\$progdir/\$file\"
	4079	fi"
	4080	else
	4081	$ECHO "\
	4082	program='$outputname'
	4083	progdir=\"\$thisdir/$objdir\"
	4084	"
	4085	fi
	4086
	4087	$ECHO "\
	4088
	4089	if test -f \"\$progdir/\$program\"; then"
	4090
	4091	# fixup the dll searchpath if we need to.
	4092	#
	4093	# Fix the DLL searchpath if we need to. Do this before prepending
	4094	# to shlibpath, because on Windows, both are PATH and uninstalled
	4095	# libraries must come first.
	4096	if test -n "$dllsearchpath"; then
	4097	$ECHO "\
	4098	# Add the dll search path components to the executable PATH
	4099	PATH=$dllsearchpath:\$PATH
	4100	"
	4101	fi
	4102
	4103	# Export our shlibpath_var if we have one.
	4104	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
	4105	$ECHO "\
	4106	# Add our own library path to $shlibpath_var
	4107	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
	4108
	4109	# Some systems cannot cope with colon-terminated $shlibpath_var
	4110	# The second colon is a workaround for a bug in BeOS R4 sed
	4111	$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" \| $SED 's/::*\$//'\`
	4112
	4113	export $shlibpath_var
	4114	"
	4115	fi
	4116
	4117	$ECHO "\
	4118	if test \"\$libtool_execute_magic\" != \"$magic\"; then
	4119	# Run the actual program with our arguments.
	4120	func_exec_program \${1+\"\$@\"}
	4121	fi
	4122	else
	4123	# The program doesn't exist.
	4124	\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
	4125	\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
	4126	\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
	4127	exit 1
	4128	fi
	4129	fi\
	4130	"
	4131	}
	4132
	4133
	4134	# func_emit_cwrapperexe_src
	4135	# emit the source code for a wrapper executable on stdout
	4136	# Must ONLY be called from within func_mode_link because
	4137	# it depends on a number of variable set therein.
	4138	func_emit_cwrapperexe_src ()
	4139	{
	4140	cat <<EOF
	4141
	4142	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
	4143	Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
	4144
	4145	The $output program cannot be directly executed until all the libtool
	4146	libraries that it depends on are installed.
	4147
	4148	This wrapper executable should never be moved out of the build directory.
	4149	If it is, it will not operate correctly.
	4150	*/
	4151	EOF
	4152	cat <<"EOF"
	4153	#ifdef _MSC_VER
	4154	# define _CRT_SECURE_NO_DEPRECATE 1
	4155	#endif
	4156	#include <stdio.h>
	4157	#include <stdlib.h>
	4158	#ifdef _MSC_VER
	4159	# include <direct.h>
	4160	# include <process.h>
	4161	# include <io.h>
	4162	#else
	4163	# include <unistd.h>
	4164	# include <stdint.h>
	4165	# ifdef __CYGWIN__
	4166	# include <io.h>
	4167	# endif
	4168	#endif
	4169	#include <malloc.h>
	4170	#include <stdarg.h>
	4171	#include <assert.h>
	4172	#include <string.h>
	4173	#include <ctype.h>
	4174	#include <errno.h>
	4175	#include <fcntl.h>
	4176	#include <sys/stat.h>
	4177
	4178	/* declarations of non-ANSI functions */
	4179	#if defined(__MINGW32__)
	4180	# ifdef __STRICT_ANSI__
	4181	int _putenv (const char *);
	4182	# endif
	4183	#elif defined(__CYGWIN__)
	4184	# ifdef __STRICT_ANSI__
	4185	char realpath (const char , char *);
	4186	int putenv (char *);
	4187	int setenv (const char , const char , int);
	4188	# endif
	4189	/* #elif defined (other platforms) ... */
	4190	#endif
	4191
	4192	/* portability defines, excluding path handling macros */
	4193	#if defined(_MSC_VER)
	4194	# define setmode _setmode
	4195	# define stat _stat
	4196	# define chmod _chmod
	4197	# define getcwd _getcwd
	4198	# define putenv _putenv
	4199	# define S_IXUSR _S_IEXEC
	4200	# ifndef _INTPTR_T_DEFINED
	4201	# define _INTPTR_T_DEFINED
	4202	# define intptr_t int
	4203	# endif
	4204	#elif defined(__MINGW32__)
	4205	# define setmode _setmode
	4206	# define stat _stat
	4207	# define chmod _chmod
	4208	# define getcwd _getcwd
	4209	# define putenv _putenv
	4210	#elif defined(__CYGWIN__)
	4211	# define HAVE_SETENV
	4212	# define FOPEN_WB "wb"
	4213	/* #elif defined (other platforms) ... */
	4214	#endif
	4215
	4216	#if defined(PATH_MAX)
	4217	# define LT_PATHMAX PATH_MAX
	4218	#elif defined(MAXPATHLEN)
	4219	# define LT_PATHMAX MAXPATHLEN
	4220	#else
	4221	# define LT_PATHMAX 1024
	4222	#endif
	4223
	4224	#ifndef S_IXOTH
	4225	# define S_IXOTH 0
	4226	#endif
	4227	#ifndef S_IXGRP
	4228	# define S_IXGRP 0
	4229	#endif
	4230
	4231	/* path handling portability macros */
	4232	#ifndef DIR_SEPARATOR
	4233	# define DIR_SEPARATOR '/'
	4234	# define PATH_SEPARATOR ':'
	4235	#endif
	4236
	4237	#if defined (_WIN32) \|\| defined (__MSDOS__) \|\| defined (__DJGPP__) \|\| \
	4238	defined (__OS2__)
	4239	# define HAVE_DOS_BASED_FILE_SYSTEM
	4240	# define FOPEN_WB "wb"
	4241	# ifndef DIR_SEPARATOR_2
	4242	# define DIR_SEPARATOR_2 '\\'
	4243	# endif
	4244	# ifndef PATH_SEPARATOR_2
	4245	# define PATH_SEPARATOR_2 ';'
	4246	# endif
	4247	#endif
	4248
	4249	#ifndef DIR_SEPARATOR_2
	4250	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
	4251	#else /* DIR_SEPARATOR_2 */
	4252	# define IS_DIR_SEPARATOR(ch) \
	4253	(((ch) == DIR_SEPARATOR) \|\| ((ch) == DIR_SEPARATOR_2))
	4254	#endif /* DIR_SEPARATOR_2 */
	4255
	4256	#ifndef PATH_SEPARATOR_2
	4257	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
	4258	#else /* PATH_SEPARATOR_2 */
	4259	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
	4260	#endif /* PATH_SEPARATOR_2 */
	4261
	4262	#ifndef FOPEN_WB
	4263	# define FOPEN_WB "w"
	4264	#endif
	4265	#ifndef _O_BINARY
	4266	# define _O_BINARY 0
	4267	#endif
	4268
	4269	#define XMALLOC(type, num) ((type ) xmalloc ((num) sizeof(type)))
	4270	#define XFREE(stale) do { \
	4271	if (stale) { free ((void *) stale); stale = 0; } \
	4272	} while (0)
	4273
	4274	#if defined(LT_DEBUGWRAPPER)
	4275	static int lt_debug = 1;
	4276	#else
	4277	static int lt_debug = 0;
	4278	#endif
	4279
	4280	const char program_name = "libtool-wrapper"; / in case xstrdup fails */
	4281
	4282	void *xmalloc (size_t num);
	4283	char xstrdup (const char string);
	4284	const char base_name (const char name);
	4285	char find_executable (const char wrapper);
	4286	char chase_symlinks (const char pathspec);
	4287	int make_executable (const char *path);
	4288	int check_executable (const char *path);
	4289	char strendzap (char str, const char *pat);
	4290	void lt_debugprintf (const char file, int line, const char fmt, ...);
	4291	void lt_fatal (const char file, int line, const char message, ...);
	4292	static const char nonnull (const char s);
	4293	static const char nonempty (const char s);
	4294	void lt_setenv (const char name, const char value);
	4295	char lt_extend_str (const char orig_value, const char *add, int to_end);
	4296	void lt_update_exe_path (const char name, const char value);
	4297	void lt_update_lib_path (const char name, const char value);
	4298	char prepare_spawn (char argv);
	4299	void lt_dump_script (FILE *f);
	4300	EOF
	4301
	4302	cat <<EOF
	4303	volatile const char * MAGIC_EXE = "$magic_exe";
	4304	const char * LIB_PATH_VARNAME = "$shlibpath_var";
	4305	EOF
	4306
	4307	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
	4308	func_to_host_path "$temp_rpath"
	4309	cat <<EOF
	4310	const char * LIB_PATH_VALUE = "$func_to_host_path_result";
	4311	EOF
	4312	else
	4313	cat <<"EOF"
	4314	const char * LIB_PATH_VALUE = "";
	4315	EOF
	4316	fi
	4317
	4318	if test -n "$dllsearchpath"; then
	4319	func_to_host_path "$dllsearchpath:"
	4320	cat <<EOF
	4321	const char * EXE_PATH_VARNAME = "PATH";
	4322	const char * EXE_PATH_VALUE = "$func_to_host_path_result";
	4323	EOF
	4324	else
	4325	cat <<"EOF"
	4326	const char * EXE_PATH_VARNAME = "";
	4327	const char * EXE_PATH_VALUE = "";
	4328	EOF
	4329	fi
	4330
	4331	if test "$fast_install" = yes; then
	4332	cat <<EOF
	4333	const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
	4334	EOF
	4335	else
	4336	cat <<EOF
	4337	const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
	4338	EOF
	4339	fi
	4340
	4341
	4342	cat <<"EOF"
	4343
	4344	#define LTWRAPPER_OPTION_PREFIX "--lt-"
	4345
	4346	static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
	4347	static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
	4348	static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
	4349
	4350	int
	4351	main (int argc, char *argv[])
	4352	{
	4353	char **newargz;
	4354	int newargc;
	4355	char *tmp_pathspec;
	4356	char *actual_cwrapper_path;
	4357	char *actual_cwrapper_name;
	4358	char *target_name;
	4359	char *lt_argv_zero;
	4360	intptr_t rval = 127;
	4361
	4362	int i;
	4363
	4364	program_name = (char *) xstrdup (base_name (argv[0]));
	4365	newargz = XMALLOC (char *, argc + 1);
	4366
	4367	/* very simple arg parsing; don't want to rely on getopt
	4368	* also, copy all non cwrapper options to newargz, except
	4369	* argz[0], which is handled differently
	4370	*/
	4371	newargc=0;
	4372	for (i = 1; i < argc; i++)
	4373	{
	4374	if (strcmp (argv[i], dumpscript_opt) == 0)
	4375	{
	4376	EOF
	4377	case "$host" in
	4378	mingw \| cygwin )
	4379	# make stdout use "unix" line endings
	4380	echo " setmode(1,_O_BINARY);"
	4381	;;
	4382	esac
	4383
	4384	cat <<"EOF"
	4385	lt_dump_script (stdout);
	4386	return 0;
	4387	}
	4388	if (strcmp (argv[i], debug_opt) == 0)
	4389	{
	4390	lt_debug = 1;
	4391	continue;
	4392	}
	4393	if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
	4394	{
	4395	/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
	4396	namespace, but it is not one of the ones we know about and
	4397	have already dealt with, above (inluding dump-script), then
	4398	report an error. Otherwise, targets might begin to believe
	4399	they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
	4400	namespace. The first time any user complains about this, we'll
	4401	need to make LTWRAPPER_OPTION_PREFIX a configure-time option
	4402	or a configure.ac-settable value.
	4403	*/
	4404	lt_fatal (__FILE__, __LINE__,
	4405	"unrecognized %s option: '%s'",
	4406	ltwrapper_option_prefix, argv[i]);
	4407	}
	4408	/* otherwise ... */
	4409	newargz[++newargc] = xstrdup (argv[i]);
	4410	}
	4411	newargz[++newargc] = NULL;
	4412
	4413	EOF
	4414	cat <<EOF
	4415	/* The GNU banner must be the first non-error debug message */
	4416	lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
	4417	EOF
	4418	cat <<"EOF"
	4419	lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
	4420	lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
	4421
	4422	tmp_pathspec = find_executable (argv[0]);
	4423	if (tmp_pathspec == NULL)
	4424	lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
	4425	lt_debugprintf (__FILE__, __LINE__,
	4426	"(main) found exe (before symlink chase) at: %s\n",
	4427	tmp_pathspec);
	4428
	4429	actual_cwrapper_path = chase_symlinks (tmp_pathspec);
	4430	lt_debugprintf (__FILE__, __LINE__,
	4431	"(main) found exe (after symlink chase) at: %s\n",
	4432	actual_cwrapper_path);
	4433	XFREE (tmp_pathspec);
	4434
	4435	actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
	4436	strendzap (actual_cwrapper_path, actual_cwrapper_name);
	4437
	4438	/* wrapper name transforms */
	4439	strendzap (actual_cwrapper_name, ".exe");
	4440	tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
	4441	XFREE (actual_cwrapper_name);
	4442	actual_cwrapper_name = tmp_pathspec;
	4443	tmp_pathspec = 0;
	4444
	4445	/* target_name transforms -- use actual target program name; might have lt- prefix */
	4446	target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
	4447	strendzap (target_name, ".exe");
	4448	tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
	4449	XFREE (target_name);
	4450	target_name = tmp_pathspec;
	4451	tmp_pathspec = 0;
	4452
	4453	lt_debugprintf (__FILE__, __LINE__,
	4454	"(main) libtool target name: %s\n",
	4455	target_name);
	4456	EOF
	4457
	4458	cat <<EOF
	4459	newargz[0] =
	4460	XMALLOC (char, (strlen (actual_cwrapper_path) +
	4461	strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
	4462	strcpy (newargz[0], actual_cwrapper_path);
	4463	strcat (newargz[0], "$objdir");
	4464	strcat (newargz[0], "/");
	4465	EOF
	4466
	4467	cat <<"EOF"
	4468	/* stop here, and copy so we don't have to do this twice */
	4469	tmp_pathspec = xstrdup (newargz[0]);
	4470
	4471	/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
	4472	strcat (newargz[0], actual_cwrapper_name);
	4473
	4474	/* DO want the lt- prefix here if it exists, so use target_name */
	4475	lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
	4476	XFREE (tmp_pathspec);
	4477	tmp_pathspec = NULL;
	4478	EOF
	4479
	4480	case $host_os in
	4481	mingw*)
	4482	cat <<"EOF"
	4483	{
	4484	char* p;
	4485	while ((p = strchr (newargz[0], '\\')) != NULL)
	4486	{
	4487	*p = '/';
	4488	}
	4489	while ((p = strchr (lt_argv_zero, '\\')) != NULL)
	4490	{
	4491	*p = '/';
	4492	}
	4493	}
	4494	EOF
	4495	;;
	4496	esac
	4497
	4498	cat <<"EOF"
	4499	XFREE (target_name);
	4500	XFREE (actual_cwrapper_path);
	4501	XFREE (actual_cwrapper_name);
	4502
	4503	lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
	4504	lt_setenv ("DUALCASE", "1"); /* for MSK sh */
	4505	/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
	4506	be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
	4507	because on Windows, both *_VARNAMEs are PATH but uninstalled
	4508	libraries must come first. */
	4509	lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
	4510	lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
	4511
	4512	lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
	4513	nonnull (lt_argv_zero));
	4514	for (i = 0; i < newargc; i++)
	4515	{
	4516	lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
	4517	i, nonnull (newargz[i]));
	4518	}
	4519
	4520	EOF
	4521
	4522	case $host_os in
	4523	mingw*)
	4524	cat <<"EOF"
	4525	/* execv doesn't actually work on mingw as expected on unix */
	4526	newargz = prepare_spawn (newargz);
	4527	rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
	4528	if (rval == -1)
	4529	{
	4530	/* failed to start process */
	4531	lt_debugprintf (__FILE__, __LINE__,
	4532	"(main) failed to launch target \"%s\": %s\n",
	4533	lt_argv_zero, nonnull (strerror (errno)));
	4534	return 127;
	4535	}
	4536	return rval;
	4537	EOF
	4538	;;
	4539	*)
	4540	cat <<"EOF"
	4541	execv (lt_argv_zero, newargz);
	4542	return rval; /* =127, but avoids unused variable warning */
	4543	EOF
	4544	;;
	4545	esac
	4546
	4547	cat <<"EOF"
	4548	}
	4549
	4550	void *
	4551	xmalloc (size_t num)
	4552	{
	4553	void p = (void ) malloc (num);
	4554	if (!p)
	4555	lt_fatal (__FILE__, __LINE__, "memory exhausted");
	4556
	4557	return p;
	4558	}
	4559
	4560	char *
	4561	xstrdup (const char *string)
	4562	{
	4563	return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
	4564	string) : NULL;
	4565	}
	4566
	4567	const char *
	4568	base_name (const char *name)
	4569	{
	4570	const char *base;
	4571
	4572	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
	4573	/* Skip over the disk name in MSDOS pathnames. */
	4574	if (isalpha ((unsigned char) name[0]) && name[1] == ':')
	4575	name += 2;
	4576	#endif
	4577
	4578	for (base = name; *name; name++)
	4579	if (IS_DIR_SEPARATOR (*name))
	4580	base = name + 1;
	4581	return base;
	4582	}
	4583
	4584	int
	4585	check_executable (const char *path)
	4586	{
	4587	struct stat st;
	4588
	4589	lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
	4590	nonempty (path));
	4591	if ((!path) \|\| (!*path))
	4592	return 0;
	4593
	4594	if ((stat (path, &st) >= 0)
	4595	&& (st.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH)))
	4596	return 1;
	4597	else
	4598	return 0;
	4599	}
	4600
	4601	int
	4602	make_executable (const char *path)
	4603	{
	4604	int rval = 0;
	4605	struct stat st;
	4606
	4607	lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
	4608	nonempty (path));
	4609	if ((!path) \|\| (!*path))
	4610	return 0;
	4611
	4612	if (stat (path, &st) >= 0)
	4613	{
	4614	rval = chmod (path, st.st_mode \| S_IXOTH \| S_IXGRP \| S_IXUSR);
	4615	}
	4616	return rval;
	4617	}
	4618
	4619	/* Searches for the full path of the wrapper. Returns
	4620	newly allocated full path name if found, NULL otherwise
	4621	Does not chase symlinks, even on platforms that support them.
	4622	*/
	4623	char *
	4624	find_executable (const char *wrapper)
	4625	{
	4626	int has_slash = 0;
	4627	const char *p;
	4628	const char *p_next;
	4629	/* static buffer for getcwd */
	4630	char tmp[LT_PATHMAX + 1];
	4631	int tmp_len;
	4632	char *concat_name;
	4633
	4634	lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
	4635	nonempty (wrapper));
	4636
	4637	if ((wrapper == NULL) \|\| (*wrapper == '\0'))
	4638	return NULL;
	4639
	4640	/* Absolute path? */
	4641	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
	4642	if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
	4643	{
	4644	concat_name = xstrdup (wrapper);
	4645	if (check_executable (concat_name))
	4646	return concat_name;
	4647	XFREE (concat_name);
	4648	}
	4649	else
	4650	{
	4651	#endif
	4652	if (IS_DIR_SEPARATOR (wrapper[0]))
	4653	{
	4654	concat_name = xstrdup (wrapper);
	4655	if (check_executable (concat_name))
	4656	return concat_name;
	4657	XFREE (concat_name);
	4658	}
	4659	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
	4660	}
	4661	#endif
	4662
	4663	for (p = wrapper; *p; p++)
	4664	if (*p == '/')
	4665	{
	4666	has_slash = 1;
	4667	break;
	4668	}
	4669	if (!has_slash)
	4670	{
	4671	/* no slashes; search PATH */
	4672	const char *path = getenv ("PATH");
	4673	if (path != NULL)
	4674	{
	4675	for (p = path; *p; p = p_next)
	4676	{
	4677	const char *q;
	4678	size_t p_len;
	4679	for (q = p; *q; q++)
	4680	if (IS_PATH_SEPARATOR (*q))
	4681	break;
	4682	p_len = q - p;
	4683	p_next = (*q == '\0' ? q : q + 1);
	4684	if (p_len == 0)
	4685	{
	4686	/* empty path: current directory */
	4687	if (getcwd (tmp, LT_PATHMAX) == NULL)
	4688	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
	4689	nonnull (strerror (errno)));
	4690	tmp_len = strlen (tmp);
	4691	concat_name =
	4692	XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
	4693	memcpy (concat_name, tmp, tmp_len);
	4694	concat_name[tmp_len] = '/';
	4695	strcpy (concat_name + tmp_len + 1, wrapper);
	4696	}
	4697	else
	4698	{
	4699	concat_name =
	4700	XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
	4701	memcpy (concat_name, p, p_len);
	4702	concat_name[p_len] = '/';
	4703	strcpy (concat_name + p_len + 1, wrapper);
	4704	}
	4705	if (check_executable (concat_name))
	4706	return concat_name;
	4707	XFREE (concat_name);
	4708	}
	4709	}
	4710	/* not found in PATH; assume curdir */
	4711	}
	4712	/* Relative path \| not found in path: prepend cwd */
	4713	if (getcwd (tmp, LT_PATHMAX) == NULL)
	4714	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
	4715	nonnull (strerror (errno)));
	4716	tmp_len = strlen (tmp);
	4717	concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
	4718	memcpy (concat_name, tmp, tmp_len);
	4719	concat_name[tmp_len] = '/';
	4720	strcpy (concat_name + tmp_len + 1, wrapper);
	4721
	4722	if (check_executable (concat_name))
	4723	return concat_name;
	4724	XFREE (concat_name);
	4725	return NULL;
	4726	}
	4727
	4728	char *
	4729	chase_symlinks (const char *pathspec)
	4730	{
	4731	#ifndef S_ISLNK
	4732	return xstrdup (pathspec);
	4733	#else
	4734	char buf[LT_PATHMAX];
	4735	struct stat s;
	4736	char *tmp_pathspec = xstrdup (pathspec);
	4737	char *p;
	4738	int has_symlinks = 0;
	4739	while (strlen (tmp_pathspec) && !has_symlinks)
	4740	{
	4741	lt_debugprintf (__FILE__, __LINE__,
	4742	"checking path component for symlinks: %s\n",
	4743	tmp_pathspec);
	4744	if (lstat (tmp_pathspec, &s) == 0)
	4745	{
	4746	if (S_ISLNK (s.st_mode) != 0)
	4747	{
	4748	has_symlinks = 1;
	4749	break;
	4750	}
	4751
	4752	/* search backwards for last DIR_SEPARATOR */
	4753	p = tmp_pathspec + strlen (tmp_pathspec) - 1;
	4754	while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
	4755	p--;
	4756	if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
	4757	{
	4758	/* no more DIR_SEPARATORS left */
	4759	break;
	4760	}
	4761	*p = '\0';
	4762	}
	4763	else
	4764	{
	4765	lt_fatal (__FILE__, __LINE__,
	4766	"error accessing file \"%s\": %s",
	4767	tmp_pathspec, nonnull (strerror (errno)));
	4768	}
	4769	}
	4770	XFREE (tmp_pathspec);
	4771
	4772	if (!has_symlinks)
	4773	{
	4774	return xstrdup (pathspec);
	4775	}
	4776
	4777	tmp_pathspec = realpath (pathspec, buf);
	4778	if (tmp_pathspec == 0)
	4779	{
	4780	lt_fatal (__FILE__, __LINE__,
	4781	"could not follow symlinks for %s", pathspec);
	4782	}
	4783	return xstrdup (tmp_pathspec);
	4784	#endif
	4785	}
	4786
	4787	char *
	4788	strendzap (char str, const char pat)
	4789	{
	4790	size_t len, patlen;
	4791
	4792	assert (str != NULL);
	4793	assert (pat != NULL);
	4794
	4795	len = strlen (str);
	4796	patlen = strlen (pat);
	4797
	4798	if (patlen <= len)
	4799	{
	4800	str += len - patlen;
	4801	if (strcmp (str, pat) == 0)
	4802	*str = '\0';
	4803	}
	4804	return str;
	4805	}
	4806
	4807	void
	4808	lt_debugprintf (const char file, int line, const char fmt, ...)
	4809	{
	4810	va_list args;
	4811	if (lt_debug)
	4812	{
	4813	(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
	4814	va_start (args, fmt);
	4815	(void) vfprintf (stderr, fmt, args);
	4816	va_end (args);
	4817	}
	4818	}
	4819
	4820	static void
	4821	lt_error_core (int exit_status, const char *file,
	4822	int line, const char *mode,
	4823	const char *message, va_list ap)
	4824	{
	4825	fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
	4826	vfprintf (stderr, message, ap);
	4827	fprintf (stderr, ".\n");
	4828
	4829	if (exit_status >= 0)
	4830	exit (exit_status);
	4831	}
	4832
	4833	void
	4834	lt_fatal (const char file, int line, const char message, ...)
	4835	{
	4836	va_list ap;
	4837	va_start (ap, message);
	4838	lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
	4839	va_end (ap);
	4840	}
	4841
	4842	static const char *
	4843	nonnull (const char *s)
	4844	{
	4845	return s ? s : "(null)";
	4846	}
	4847
	4848	static const char *
	4849	nonempty (const char *s)
	4850	{
	4851	return (s && !*s) ? "(empty)" : nonnull (s);
	4852	}
	4853
	4854	void
	4855	lt_setenv (const char name, const char value)
	4856	{
	4857	lt_debugprintf (__FILE__, __LINE__,
	4858	"(lt_setenv) setting '%s' to '%s'\n",
	4859	nonnull (name), nonnull (value));
	4860	{
	4861	#ifdef HAVE_SETENV
	4862	/* always make a copy, for consistency with !HAVE_SETENV */
	4863	char *str = xstrdup (value);
	4864	setenv (name, str, 1);
	4865	#else
	4866	int len = strlen (name) + 1 + strlen (value) + 1;
	4867	char *str = XMALLOC (char, len);
	4868	sprintf (str, "%s=%s", name, value);
	4869	if (putenv (str) != EXIT_SUCCESS)
	4870	{
	4871	XFREE (str);
	4872	}
	4873	#endif
	4874	}
	4875	}
	4876
	4877	char *
	4878	lt_extend_str (const char orig_value, const char add, int to_end)
	4879	{
	4880	char *new_value;
	4881	if (orig_value && *orig_value)
	4882	{
	4883	int orig_value_len = strlen (orig_value);
	4884	int add_len = strlen (add);
	4885	new_value = XMALLOC (char, add_len + orig_value_len + 1);
	4886	if (to_end)
	4887	{
	4888	strcpy (new_value, orig_value);
	4889	strcpy (new_value + orig_value_len, add);
	4890	}
	4891	else
	4892	{
	4893	strcpy (new_value, add);
	4894	strcpy (new_value + add_len, orig_value);
	4895	}
	4896	}
	4897	else
	4898	{
	4899	new_value = xstrdup (add);
	4900	}
	4901	return new_value;
	4902	}
	4903
	4904	void
	4905	lt_update_exe_path (const char name, const char value)
	4906	{
	4907	lt_debugprintf (__FILE__, __LINE__,
	4908	"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
	4909	nonnull (name), nonnull (value));
	4910
	4911	if (name && name && value && value)
	4912	{
	4913	char *new_value = lt_extend_str (getenv (name), value, 0);
	4914	/* some systems can't cope with a ':'-terminated path #' */
	4915	int len = strlen (new_value);
	4916	while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
	4917	{
	4918	new_value[len-1] = '\0';
	4919	}
	4920	lt_setenv (name, new_value);
	4921	XFREE (new_value);
	4922	}
	4923	}
	4924
	4925	void
	4926	lt_update_lib_path (const char name, const char value)
	4927	{
	4928	lt_debugprintf (__FILE__, __LINE__,
	4929	"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
	4930	nonnull (name), nonnull (value));
	4931
	4932	if (name && name && value && value)
	4933	{
	4934	char *new_value = lt_extend_str (getenv (name), value, 0);
	4935	lt_setenv (name, new_value);
	4936	XFREE (new_value);
	4937	}
	4938	}
	4939
	4940	EOF
	4941	case $host_os in
	4942	mingw*)
	4943	cat <<"EOF"
	4944
	4945	/* Prepares an argument vector before calling spawn().
	4946	Note that spawn() does not by itself call the command interpreter
	4947	(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
	4948	({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	4949	GetVersionEx(&v);
	4950	v.dwPlatformId == VER_PLATFORM_WIN32_NT;
	4951	}) ? "cmd.exe" : "command.com").
	4952	Instead it simply concatenates the arguments, separated by ' ', and calls
	4953	CreateProcess(). We must quote the arguments since Win32 CreateProcess()
	4954	interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
	4955	special way:
	4956	- Space and tab are interpreted as delimiters. They are not treated as
	4957	delimiters if they are surrounded by double quotes: "...".
	4958	- Unescaped double quotes are removed from the input. Their only effect is
	4959	that within double quotes, space and tab are treated like normal
	4960	characters.
	4961	- Backslashes not followed by double quotes are not special.
	4962	- But 2*n+1 backslashes followed by a double quote become
	4963	n backslashes followed by a double quote (n >= 0):
	4964	\" -> "
	4965	\\\" -> \"
	4966	\\\\\" -> \\"
	4967	*/
	4968	#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
	4969	#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
	4970	char **
	4971	prepare_spawn (char **argv)
	4972	{
	4973	size_t argc;
	4974	char **new_argv;
	4975	size_t i;
	4976
	4977	/* Count number of arguments. */
	4978	for (argc = 0; argv[argc] != NULL; argc++)
	4979	;
	4980
	4981	/* Allocate new argument vector. */
	4982	new_argv = XMALLOC (char *, argc + 1);
	4983
	4984	/* Put quoted arguments into the new argument vector. */
	4985	for (i = 0; i < argc; i++)
	4986	{
	4987	const char *string = argv[i];
	4988
	4989	if (string[0] == '\0')
	4990	new_argv[i] = xstrdup ("\"\"");
	4991	else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
	4992	{
	4993	int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
	4994	size_t length;
	4995	unsigned int backslashes;
	4996	const char *s;
	4997	char *quoted_string;
	4998	char *p;
	4999
	5000	length = 0;
	5001	backslashes = 0;
	5002	if (quote_around)
	5003	length++;
	5004	for (s = string; *s != '\0'; s++)
	5005	{
	5006	char c = *s;
	5007	if (c == '"')
	5008	length += backslashes + 1;
	5009	length++;
	5010	if (c == '\\')
	5011	backslashes++;
	5012	else
	5013	backslashes = 0;
	5014	}
	5015	if (quote_around)
	5016	length += backslashes + 1;
	5017
	5018	quoted_string = XMALLOC (char, length + 1);
	5019
	5020	p = quoted_string;
	5021	backslashes = 0;
	5022	if (quote_around)
	5023	*p++ = '"';
	5024	for (s = string; *s != '\0'; s++)
	5025	{
	5026	char c = *s;
	5027	if (c == '"')
	5028	{
	5029	unsigned int j;
	5030	for (j = backslashes + 1; j > 0; j--)
	5031	*p++ = '\\';
	5032	}
	5033	*p++ = c;
	5034	if (c == '\\')
	5035	backslashes++;
	5036	else
	5037	backslashes = 0;
	5038	}
	5039	if (quote_around)
	5040	{
	5041	unsigned int j;
	5042	for (j = backslashes; j > 0; j--)
	5043	*p++ = '\\';
	5044	*p++ = '"';
	5045	}
	5046	*p = '\0';
	5047
	5048	new_argv[i] = quoted_string;
	5049	}
	5050	else
	5051	new_argv[i] = (char *) string;
	5052	}
	5053	new_argv[argc] = NULL;
	5054
	5055	return new_argv;
	5056	}
	5057	EOF
	5058	;;
	5059	esac
	5060
	5061	cat <<"EOF"
	5062	void lt_dump_script (FILE* f)
	5063	{
	5064	EOF
	5065	func_emit_wrapper yes \|
	5066	$SED -n -e '
	5067	s/^$.\{79\}$$..*$/\1\
	5068	\2/
	5069	h
	5070	s/$[\\"]$/\\\1/g
	5071	s/$/\\n/
	5072	s/$[^\n]$./ fputs ("\1", f);/p
	5073	g
	5074	D'
	5075	cat <<"EOF"
	5076	}
	5077	EOF
	5078	}
	5079	# end: func_emit_cwrapperexe_src
	5080
	5081	# func_win32_import_lib_p ARG
	5082	# True if ARG is an import lib, as indicated by $file_magic_cmd
	5083	func_win32_import_lib_p ()
	5084	{
	5085	$opt_debug
	5086	case `eval $file_magic_cmd \"\$1\" 2>/dev/null \| $SED -e 10q` in
	5087	import) : ;;
	5088	*) false ;;
	5089	esac
	5090	}
	5091
	5092	# func_mode_link arg...
	5093	func_mode_link ()
	5094	{
	5095	$opt_debug
	5096	case $host in
	5097	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
	5098	# It is impossible to link a dll without this setting, and
	5099	# we shouldn't force the makefile maintainer to figure out
	5100	# which system we are compiling for in order to pass an extra
	5101	# flag for every libtool invocation.
	5102	# allow_undefined=no
	5103
	5104	# FIXME: Unfortunately, there are problems with the above when trying
	5105	# to make a dll which has undefined symbols, in which case not
	5106	# even a static library is built. For now, we need to specify
	5107	# -no-undefined on the libtool link line when we can be certain
	5108	# that all symbols are satisfied, otherwise we get a static library.
	5109	allow_undefined=yes
	5110	;;
	5111	*)
	5112	allow_undefined=yes
	5113	;;
	5114	esac
	5115	libtool_args=$nonopt
	5116	base_compile="$nonopt $@"
	5117	compile_command=$nonopt
	5118	finalize_command=$nonopt
	5119
	5120	compile_rpath=
	5121	finalize_rpath=
	5122	compile_shlibpath=
	5123	finalize_shlibpath=
	5124	convenience=
	5125	old_convenience=
	5126	deplibs=
	5127	old_deplibs=
	5128	compiler_flags=
	5129	linker_flags=
	5130	dllsearchpath=
	5131	lib_search_path=`pwd`
	5132	inst_prefix_dir=
	5133	new_inherited_linker_flags=
	5134
	5135	avoid_version=no
	5136	bindir=
	5137	dlfiles=
	5138	dlprefiles=
	5139	dlself=no
	5140	export_dynamic=no
	5141	export_symbols=
	5142	export_symbols_regex=
	5143	generated=
	5144	libobjs=
	5145	ltlibs=
	5146	module=no
	5147	no_install=no
	5148	objs=
	5149	non_pic_objects=
	5150	precious_files_regex=
	5151	prefer_static_libs=no
	5152	preload=no
	5153	prev=
	5154	prevarg=
	5155	release=
	5156	rpath=
	5157	xrpath=
	5158	perm_rpath=
	5159	temp_rpath=
	5160	thread_safe=no
	5161	vinfo=
	5162	vinfo_number=no
	5163	weak_libs=
	5164	single_module="${wl}-single_module"
	5165	func_infer_tag $base_compile
	5166
	5167	# We need to know -static, to get the right output filenames.
	5168	for arg
	5169	do
	5170	case $arg in
	5171	-shared)
	5172	test "$build_libtool_libs" != yes && \
	5173	func_fatal_configuration "can not build a shared library"
	5174	build_old_libs=no
	5175	break
	5176	;;
	5177	-all-static \| -static \| -static-libtool-libs)
	5178	case $arg in
	5179	-all-static)
	5180	if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
	5181	func_warning "complete static linking is impossible in this configuration"
	5182	fi
	5183	if test -n "$link_static_flag"; then
	5184	dlopen_self=$dlopen_self_static
	5185	fi
	5186	prefer_static_libs=yes
	5187	;;
	5188	-static)
	5189	if test -z "$pic_flag" && test -n "$link_static_flag"; then
	5190	dlopen_self=$dlopen_self_static
	5191	fi
	5192	prefer_static_libs=built
	5193	;;
	5194	-static-libtool-libs)
	5195	if test -z "$pic_flag" && test -n "$link_static_flag"; then
	5196	dlopen_self=$dlopen_self_static
	5197	fi
	5198	prefer_static_libs=yes
	5199	;;
	5200	esac
	5201	build_libtool_libs=no
	5202	build_old_libs=yes
	5203	break
	5204	;;
	5205	esac
	5206	done
	5207
	5208	# See if our shared archives depend on static archives.
	5209	test -n "$old_archive_from_new_cmds" && build_old_libs=yes
	5210
	5211	# Go through the arguments, transforming them on the way.
	5212	while test "$#" -gt 0; do
	5213	arg="$1"
	5214	shift
	5215	func_quote_for_eval "$arg"
	5216	qarg=$func_quote_for_eval_unquoted_result
	5217	func_append libtool_args " $func_quote_for_eval_result"
	5218
	5219	# If the previous option needs an argument, assign it.
	5220	if test -n "$prev"; then
	5221	case $prev in
	5222	output)
	5223	func_append compile_command " @OUTPUT@"
	5224	func_append finalize_command " @OUTPUT@"
	5225	;;
	5226	esac
	5227
	5228	case $prev in
	5229	bindir)
	5230	bindir="$arg"
	5231	prev=
	5232	continue
	5233	;;
	5234	dlfiles\|dlprefiles)
	5235	if test "$preload" = no; then
	5236	# Add the symbol object into the linking commands.
	5237	func_append compile_command " @SYMFILE@"
	5238	func_append finalize_command " @SYMFILE@"
	5239	preload=yes
	5240	fi
	5241	case $arg in
	5242	.la \| .lo) ;; # We handle these cases below.
	5243	force)
	5244	if test "$dlself" = no; then
	5245	dlself=needless
	5246	export_dynamic=yes
	5247	fi
	5248	prev=
	5249	continue
	5250	;;
	5251	self)
	5252	if test "$prev" = dlprefiles; then
	5253	dlself=yes
	5254	elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
	5255	dlself=yes
	5256	else
	5257	dlself=needless
	5258	export_dynamic=yes
	5259	fi
	5260	prev=
	5261	continue
	5262	;;
	5263	*)
	5264	if test "$prev" = dlfiles; then
	5265	func_append dlfiles " $arg"
	5266	else
	5267	func_append dlprefiles " $arg"
	5268	fi
	5269	prev=
	5270	continue
	5271	;;
	5272	esac
	5273	;;
	5274	expsyms)
	5275	export_symbols="$arg"
	5276	test -f "$arg" \
	5277	\|\| func_fatal_error "symbol file \`$arg' does not exist"
	5278	prev=
	5279	continue
	5280	;;
	5281	expsyms_regex)
	5282	export_symbols_regex="$arg"
	5283	prev=
	5284	continue
	5285	;;
	5286	framework)
	5287	case $host in
	5288	--darwin*)
	5289	case "$deplibs " in
	5290	" $qarg.ltframework ") ;;
	5291	*) func_append deplibs " $qarg.ltframework" # this is fixed later
	5292	;;
	5293	esac
	5294	;;
	5295	esac
	5296	prev=
	5297	continue
	5298	;;
	5299	inst_prefix)
	5300	inst_prefix_dir="$arg"
	5301	prev=
	5302	continue
	5303	;;
	5304	objectlist)
	5305	if test -f "$arg"; then
	5306	save_arg=$arg
	5307	moreargs=
	5308	for fil in `cat "$save_arg"`
	5309	do
	5310	# func_append moreargs " $fil"
	5311	arg=$fil
	5312	# A libtool-controlled object.
	5313
	5314	# Check to see that this really is a libtool object.
	5315	if func_lalib_unsafe_p "$arg"; then
	5316	pic_object=
	5317	non_pic_object=
	5318
	5319	# Read the .lo file
	5320	func_source "$arg"
	5321
	5322	if test -z "$pic_object" \|\|
	5323	test -z "$non_pic_object" \|\|
	5324	test "$pic_object" = none &&
	5325	test "$non_pic_object" = none; then
	5326	func_fatal_error "cannot find name of object for \`$arg'"
	5327	fi
	5328
	5329	# Extract subdirectory from the argument.
	5330	func_dirname "$arg" "/" ""
	5331	xdir="$func_dirname_result"
	5332
	5333	if test "$pic_object" != none; then
	5334	# Prepend the subdirectory the object is found in.
	5335	pic_object="$xdir$pic_object"
	5336
	5337	if test "$prev" = dlfiles; then
	5338	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
	5339	func_append dlfiles " $pic_object"
	5340	prev=
	5341	continue
	5342	else
	5343	# If libtool objects are unsupported, then we need to preload.
	5344	prev=dlprefiles
	5345	fi
	5346	fi
	5347
	5348	# CHECK ME: I think I busted this. -Ossama
	5349	if test "$prev" = dlprefiles; then
	5350	# Preload the old-style object.
	5351	func_append dlprefiles " $pic_object"
	5352	prev=
	5353	fi
	5354
	5355	# A PIC object.
	5356	func_append libobjs " $pic_object"
	5357	arg="$pic_object"
	5358	fi
	5359
	5360	# Non-PIC object.
	5361	if test "$non_pic_object" != none; then
	5362	# Prepend the subdirectory the object is found in.
	5363	non_pic_object="$xdir$non_pic_object"
	5364
	5365	# A standard non-PIC object
	5366	func_append non_pic_objects " $non_pic_object"
	5367	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
	5368	arg="$non_pic_object"
	5369	fi
	5370	else
	5371	# If the PIC object exists, use it instead.
	5372	# $xdir was prepended to $pic_object above.
	5373	non_pic_object="$pic_object"
	5374	func_append non_pic_objects " $non_pic_object"
	5375	fi
	5376	else
	5377	# Only an error if not doing a dry-run.
	5378	if $opt_dry_run; then
	5379	# Extract subdirectory from the argument.
	5380	func_dirname "$arg" "/" ""
	5381	xdir="$func_dirname_result"
	5382
	5383	func_lo2o "$arg"
	5384	pic_object=$xdir$objdir/$func_lo2o_result
	5385	non_pic_object=$xdir$func_lo2o_result
	5386	func_append libobjs " $pic_object"
	5387	func_append non_pic_objects " $non_pic_object"
	5388	else
	5389	func_fatal_error "\`$arg' is not a valid libtool object"
	5390	fi
	5391	fi
	5392	done
	5393	else
	5394	func_fatal_error "link input file \`$arg' does not exist"
	5395	fi
	5396	arg=$save_arg
	5397	prev=
	5398	continue
	5399	;;
	5400	precious_regex)
	5401	precious_files_regex="$arg"
	5402	prev=
	5403	continue
	5404	;;
	5405	release)
	5406	release="-$arg"
	5407	prev=
	5408	continue
	5409	;;
	5410	rpath \| xrpath)
	5411	# We need an absolute path.
	5412	case $arg in
	5413	[\\/]* \| [A-Za-z]:[\\/]*) ;;
	5414	*)
	5415	func_fatal_error "only absolute run-paths are allowed"
	5416	;;
	5417	esac
	5418	if test "$prev" = rpath; then
	5419	case "$rpath " in
	5420	" $arg ") ;;
	5421	*) func_append rpath " $arg" ;;
	5422	esac
	5423	else
	5424	case "$xrpath " in
	5425	" $arg ") ;;
	5426	*) func_append xrpath " $arg" ;;
	5427	esac
	5428	fi
	5429	prev=
	5430	continue
	5431	;;
	5432	shrext)
	5433	shrext_cmds="$arg"
	5434	prev=
	5435	continue
	5436	;;
	5437	weak)
	5438	func_append weak_libs " $arg"
	5439	prev=
	5440	continue
	5441	;;
	5442	xcclinker)
	5443	func_append linker_flags " $qarg"
	5444	func_append compiler_flags " $qarg"
	5445	prev=
	5446	func_append compile_command " $qarg"
	5447	func_append finalize_command " $qarg"
	5448	continue
	5449	;;
	5450	xcompiler)
	5451	func_append compiler_flags " $qarg"
	5452	prev=
	5453	func_append compile_command " $qarg"
	5454	func_append finalize_command " $qarg"
	5455	continue
	5456	;;
	5457	xlinker)
	5458	func_append linker_flags " $qarg"
	5459	func_append compiler_flags " $wl$qarg"
	5460	prev=
	5461	func_append compile_command " $wl$qarg"
	5462	func_append finalize_command " $wl$qarg"
	5463	continue
	5464	;;
	5465	*)
	5466	eval "$prev=\"\$arg\""
	5467	prev=
	5468	continue
	5469	;;
	5470	esac
	5471	fi # test -n "$prev"
	5472
	5473	prevarg="$arg"
	5474
	5475	case $arg in
	5476	-all-static)
	5477	if test -n "$link_static_flag"; then
	5478	# See comment for -static flag below, for more details.
	5479	func_append compile_command " $link_static_flag"
	5480	func_append finalize_command " $link_static_flag"
	5481	fi
	5482	continue
	5483	;;
	5484
	5485	-allow-undefined)
	5486	# FIXME: remove this flag sometime in the future.
	5487	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
	5488	;;
	5489
	5490	-avoid-version)
	5491	avoid_version=yes
	5492	continue
	5493	;;
	5494
	5495	-bindir)
	5496	prev=bindir
	5497	continue
	5498	;;
	5499
	5500	-dlopen)
	5501	prev=dlfiles
	5502	continue
	5503	;;
	5504
	5505	-dlpreopen)
	5506	prev=dlprefiles
	5507	continue
	5508	;;
	5509
	5510	-export-dynamic)
	5511	export_dynamic=yes
	5512	continue
	5513	;;
	5514
	5515	-export-symbols \| -export-symbols-regex)
	5516	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
	5517	func_fatal_error "more than one -exported-symbols argument is not allowed"
	5518	fi
	5519	if test "X$arg" = "X-export-symbols"; then
	5520	prev=expsyms
	5521	else
	5522	prev=expsyms_regex
	5523	fi
	5524	continue
	5525	;;
	5526
	5527	-framework)
	5528	prev=framework
	5529	continue
	5530	;;
	5531
	5532	-inst-prefix-dir)
	5533	prev=inst_prefix
	5534	continue
	5535	;;
	5536
	5537	# The native IRIX linker understands -LANG:, -LIST: and -LNO:*
	5538	# so, if we see these flags be careful not to treat them like -L
	5539	-L[A-Z][A-Z]:)
	5540	case $with_gcc/$host in
	5541	no/--irix* \| /--irix*)
	5542	func_append compile_command " $arg"
	5543	func_append finalize_command " $arg"
	5544	;;
	5545	esac
	5546	continue
	5547	;;
	5548
	5549	-L*)
	5550	func_stripname "-L" '' "$arg"
	5551	if test -z "$func_stripname_result"; then
	5552	if test "$#" -gt 0; then
	5553	func_fatal_error "require no space between \`-L' and \`$1'"
	5554	else
	5555	func_fatal_error "need path for \`-L' option"
	5556	fi
	5557	fi
	5558	func_resolve_sysroot "$func_stripname_result"
	5559	dir=$func_resolve_sysroot_result
	5560	# We need an absolute path.
	5561	case $dir in
	5562	[\\/]* \| [A-Za-z]:[\\/]*) ;;
	5563	*)
	5564	absdir=`cd "$dir" && pwd`
	5565	test -z "$absdir" && \
	5566	func_fatal_error "cannot determine absolute directory name of \`$dir'"
	5567	dir="$absdir"
	5568	;;
	5569	esac
	5570	case "$deplibs " in
	5571	" -L$dir " \| " $arg ")
	5572	# Will only happen for absolute or sysroot arguments
	5573	;;
	5574	*)
	5575	# Preserve sysroot, but never include relative directories
	5576	case $dir in
	5577	[\\/]* \| [A-Za-z]:[\\/]* \| =*) func_append deplibs " $arg" ;;
	5578	*) func_append deplibs " -L$dir" ;;
	5579	esac
	5580	func_append lib_search_path " $dir"
	5581	;;
	5582	esac
	5583	case $host in
	5584	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
	5585	testbindir=`$ECHO "$dir" \| $SED 's/lib$/bin*'`
	5586	case :$dllsearchpath: in
	5587	":$dir:") ;;
	5588	::) dllsearchpath=$dir;;
	5589	*) func_append dllsearchpath ":$dir";;
	5590	esac
	5591	case :$dllsearchpath: in
	5592	":$testbindir:") ;;
	5593	::) dllsearchpath=$testbindir;;
	5594	*) func_append dllsearchpath ":$testbindir";;
	5595	esac
	5596	;;
	5597	esac
	5598	continue
	5599	;;
	5600
	5601	-l*)
	5602	if test "X$arg" = "X-lc" \|\| test "X$arg" = "X-lm"; then
	5603	case $host in
	5604	--cygwin* \| --mingw* \| --pw32* \| --beos* \| -cegcc \| --haiku*)
	5605	# These systems don't actually have a C or math library (as such)
	5606	continue
	5607	;;
	5608	--os2*)
	5609	# These systems don't actually have a C library (as such)
	5610	test "X$arg" = "X-lc" && continue
	5611	;;
	5612	--openbsd* \| --freebsd* \| --dragonfly*)
	5613	# Do not include libc due to us having libc/libc_r.
	5614	test "X$arg" = "X-lc" && continue
	5615	;;
	5616	--rhapsody* \| --darwin1.[012])
	5617	# Rhapsody C and math libraries are in the System framework
	5618	func_append deplibs " System.ltframework"
	5619	continue
	5620	;;
	5621	--sco3.2v5* \| --sco5v6*)
	5622	# Causes problems with __ctype
	5623	test "X$arg" = "X-lc" && continue
	5624	;;
	5625	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
	5626	# Compiler inserts libc in the correct place for threads to work
	5627	test "X$arg" = "X-lc" && continue
	5628	;;
	5629	esac
	5630	elif test "X$arg" = "X-lc_r"; then
	5631	case $host in
	5632	--openbsd* \| --freebsd* \| --dragonfly*)
	5633	# Do not include libc_r directly, use -pthread flag.
	5634	continue
	5635	;;
	5636	esac
	5637	fi
	5638	func_append deplibs " $arg"
	5639	continue
	5640	;;
	5641
	5642	-module)
	5643	module=yes
	5644	continue
	5645	;;
	5646
	5647	# Tru64 UNIX uses -model [arg] to determine the layout of C++
	5648	# classes, name mangling, and exception handling.
	5649	# Darwin uses the -arch flag to determine output architecture.
	5650	-model\|-arch\|-isysroot\|--sysroot)
	5651	func_append compiler_flags " $arg"
	5652	func_append compile_command " $arg"
	5653	func_append finalize_command " $arg"
	5654	prev=xcompiler
	5655	continue
	5656	;;
	5657
	5658	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe \
	5659	\|-threads\|-fopenmp\|-openmp\|-mp\|-xopenmp\|-omp\|-qsmp=*)
	5660	func_append compiler_flags " $arg"
	5661	func_append compile_command " $arg"
	5662	func_append finalize_command " $arg"
	5663	case "$new_inherited_linker_flags " in
	5664	" $arg ") ;;
	5665	* ) func_append new_inherited_linker_flags " $arg" ;;
	5666	esac
	5667	continue
	5668	;;
	5669
	5670	-multi_module)
	5671	single_module="${wl}-multi_module"
	5672	continue
	5673	;;
	5674
	5675	-no-fast-install)
	5676	fast_install=no
	5677	continue
	5678	;;
	5679
	5680	-no-install)
	5681	case $host in
	5682	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --darwin* \| -cegcc)
	5683	# The PATH hackery in wrapper scripts is required on Windows
	5684	# and Darwin in order for the loader to find any dlls it needs.
	5685	func_warning "\`-no-install' is ignored for $host"
	5686	func_warning "assuming \`-no-fast-install' instead"
	5687	fast_install=no
	5688	;;
	5689	*) no_install=yes ;;
	5690	esac
	5691	continue
	5692	;;
	5693
	5694	-no-undefined)
	5695	allow_undefined=no
	5696	continue
	5697	;;
	5698
	5699	-objectlist)
	5700	prev=objectlist
	5701	continue
	5702	;;
	5703
	5704	-o) prev=output ;;
	5705
	5706	-precious-files-regex)
	5707	prev=precious_regex
	5708	continue
	5709	;;
	5710
	5711	-release)
	5712	prev=release
	5713	continue
	5714	;;
	5715
	5716	-rpath)
	5717	prev=rpath
	5718	continue
	5719	;;
	5720
	5721	-R)
	5722	prev=xrpath
	5723	continue
	5724	;;
	5725
	5726	-R*)
	5727	func_stripname '-R' '' "$arg"
	5728	dir=$func_stripname_result
	5729	# We need an absolute path.
	5730	case $dir in
	5731	[\\/]* \| [A-Za-z]:[\\/]*) ;;
	5732	=*)
	5733	func_stripname '=' '' "$dir"
	5734	dir=$lt_sysroot$func_stripname_result
	5735	;;
	5736	*)
	5737	func_fatal_error "only absolute run-paths are allowed"
	5738	;;
	5739	esac
	5740	case "$xrpath " in
	5741	" $dir ") ;;
	5742	*) func_append xrpath " $dir" ;;
	5743	esac
	5744	continue
	5745	;;
	5746
	5747	-shared)
	5748	# The effects of -shared are defined in a previous loop.
	5749	continue
	5750	;;
	5751
	5752	-shrext)
	5753	prev=shrext
	5754	continue
	5755	;;
	5756
	5757	-static \| -static-libtool-libs)
	5758	# The effects of -static are defined in a previous loop.
	5759	# We used to do the same as -all-static on platforms that
	5760	# didn't have a PIC flag, but the assumption that the effects
	5761	# would be equivalent was wrong. It would break on at least
	5762	# Digital Unix and AIX.
	5763	continue
	5764	;;
	5765
	5766	-thread-safe)
	5767	thread_safe=yes
	5768	continue
	5769	;;
	5770
	5771	-version-info)
	5772	prev=vinfo
	5773	continue
	5774	;;
	5775
	5776	-version-number)
	5777	prev=vinfo
	5778	vinfo_number=yes
	5779	continue
	5780	;;
	5781
	5782	-weak)
	5783	prev=weak
	5784	continue
	5785	;;
	5786
	5787	-Wc,*)
	5788	func_stripname '-Wc,' '' "$arg"
	5789	args=$func_stripname_result
	5790	arg=
	5791	save_ifs="$IFS"; IFS=','
	5792	for flag in $args; do
	5793	IFS="$save_ifs"
	5794	func_quote_for_eval "$flag"
	5795	func_append arg " $func_quote_for_eval_result"
	5796	func_append compiler_flags " $func_quote_for_eval_result"
	5797	done
	5798	IFS="$save_ifs"
	5799	func_stripname ' ' '' "$arg"
	5800	arg=$func_stripname_result
	5801	;;
	5802
	5803	-Wl,*)
	5804	func_stripname '-Wl,' '' "$arg"
	5805	args=$func_stripname_result
	5806	arg=
	5807	save_ifs="$IFS"; IFS=','
	5808	for flag in $args; do
	5809	IFS="$save_ifs"
	5810	func_quote_for_eval "$flag"
	5811	func_append arg " $wl$func_quote_for_eval_result"
	5812	func_append compiler_flags " $wl$func_quote_for_eval_result"
	5813	func_append linker_flags " $func_quote_for_eval_result"
	5814	done
	5815	IFS="$save_ifs"
	5816	func_stripname ' ' '' "$arg"
	5817	arg=$func_stripname_result
	5818	;;
	5819
	5820	-Xcompiler)
	5821	prev=xcompiler
	5822	continue
	5823	;;
	5824
	5825	-Xlinker)
	5826	prev=xlinker
	5827	continue
	5828	;;
	5829
	5830	-XCClinker)
	5831	prev=xcclinker
	5832	continue
	5833	;;
	5834
	5835	# -msg_* for osf cc
	5836	-msg_*)
	5837	func_quote_for_eval "$arg"
	5838	arg="$func_quote_for_eval_result"
	5839	;;
	5840
	5841	# Flags to be passed through unchanged, with rationale:
	5842	# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
	5843	# -r[0-9][0-9]* specify processor for the SGI compiler
	5844	# -xarch=, -xtarget= enable 64-bit mode for the Sun compiler
	5845	# +DA, +DD enable 64-bit mode for the HP compiler
	5846	# -q* compiler args for the IBM compiler
	5847	# -m, -t[45], -txscale* architecture-specific flags for GCC
	5848	# -F/path path to uninstalled frameworks, gcc on darwin
	5849	# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
	5850	# @file GCC response files
	5851	# -tp=* Portland pgcc target processor selection
	5852	# --sysroot=* for sysroot support
	5853	# -O, -flto, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
	5854	-64\|-mips[0-9]\|-r[0-9][0-9]\|-xarch=\|-xtarget=\|+DA\|+DD\|-q\|-m*\| \
	5855	-t[45]\|-txscale\|-p\|-pg\|--coverage\|-fprofile-\|-F\|@\|-tp=\|--sysroot=*\| \
	5856	-O\|-flto\|-fwhopr*\|-fuse-linker-plugin)
	5857	func_quote_for_eval "$arg"
	5858	arg="$func_quote_for_eval_result"
	5859	func_append compile_command " $arg"
	5860	func_append finalize_command " $arg"
	5861	func_append compiler_flags " $arg"
	5862	continue
	5863	;;
	5864
	5865	# Some other compiler flag.
	5866	-* \| +*)
	5867	func_quote_for_eval "$arg"
	5868	arg="$func_quote_for_eval_result"
	5869	;;
	5870
	5871	*.$objext)
	5872	# A standard object.
	5873	func_append objs " $arg"
	5874	;;
	5875
	5876	*.lo)
	5877	# A libtool-controlled object.
	5878
	5879	# Check to see that this really is a libtool object.
	5880	if func_lalib_unsafe_p "$arg"; then
	5881	pic_object=
	5882	non_pic_object=
	5883
	5884	# Read the .lo file
	5885	func_source "$arg"
	5886
	5887	if test -z "$pic_object" \|\|
	5888	test -z "$non_pic_object" \|\|
	5889	test "$pic_object" = none &&
	5890	test "$non_pic_object" = none; then
	5891	func_fatal_error "cannot find name of object for \`$arg'"
	5892	fi
	5893
	5894	# Extract subdirectory from the argument.
	5895	func_dirname "$arg" "/" ""
	5896	xdir="$func_dirname_result"
	5897
	5898	if test "$pic_object" != none; then
	5899	# Prepend the subdirectory the object is found in.
	5900	pic_object="$xdir$pic_object"
	5901
	5902	if test "$prev" = dlfiles; then
	5903	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
	5904	func_append dlfiles " $pic_object"
	5905	prev=
	5906	continue
	5907	else
	5908	# If libtool objects are unsupported, then we need to preload.
	5909	prev=dlprefiles
	5910	fi
	5911	fi
	5912
	5913	# CHECK ME: I think I busted this. -Ossama
	5914	if test "$prev" = dlprefiles; then
	5915	# Preload the old-style object.
	5916	func_append dlprefiles " $pic_object"
	5917	prev=
	5918	fi
	5919
	5920	# A PIC object.
	5921	func_append libobjs " $pic_object"
	5922	arg="$pic_object"
	5923	fi
	5924
	5925	# Non-PIC object.
	5926	if test "$non_pic_object" != none; then
	5927	# Prepend the subdirectory the object is found in.
	5928	non_pic_object="$xdir$non_pic_object"
	5929
	5930	# A standard non-PIC object
	5931	func_append non_pic_objects " $non_pic_object"
	5932	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
	5933	arg="$non_pic_object"
	5934	fi
	5935	else
	5936	# If the PIC object exists, use it instead.
	5937	# $xdir was prepended to $pic_object above.
	5938	non_pic_object="$pic_object"
	5939	func_append non_pic_objects " $non_pic_object"
	5940	fi
	5941	else
	5942	# Only an error if not doing a dry-run.
	5943	if $opt_dry_run; then
	5944	# Extract subdirectory from the argument.
	5945	func_dirname "$arg" "/" ""
	5946	xdir="$func_dirname_result"
	5947
	5948	func_lo2o "$arg"
	5949	pic_object=$xdir$objdir/$func_lo2o_result
	5950	non_pic_object=$xdir$func_lo2o_result
	5951	func_append libobjs " $pic_object"
	5952	func_append non_pic_objects " $non_pic_object"
	5953	else
	5954	func_fatal_error "\`$arg' is not a valid libtool object"
	5955	fi
	5956	fi
	5957	;;
	5958
	5959	*.$libext)
	5960	# An archive.
	5961	func_append deplibs " $arg"
	5962	func_append old_deplibs " $arg"
	5963	continue
	5964	;;
	5965
	5966	*.la)
	5967	# A libtool-controlled library.
	5968
	5969	func_resolve_sysroot "$arg"
	5970	if test "$prev" = dlfiles; then
	5971	# This library was specified with -dlopen.
	5972	func_append dlfiles " $func_resolve_sysroot_result"
	5973	prev=
	5974	elif test "$prev" = dlprefiles; then
	5975	# The library was specified with -dlpreopen.
	5976	func_append dlprefiles " $func_resolve_sysroot_result"
	5977	prev=
	5978	else
	5979	func_append deplibs " $func_resolve_sysroot_result"
	5980	fi
	5981	continue
	5982	;;
	5983
	5984	# Some other compiler argument.
	5985	*)
	5986	# Unknown arguments in both finalize_command and compile_command need
	5987	# to be aesthetically quoted because they are evaled later.
	5988	func_quote_for_eval "$arg"
	5989	arg="$func_quote_for_eval_result"
	5990	;;
	5991	esac # arg
	5992
	5993	# Now actually substitute the argument into the commands.
	5994	if test -n "$arg"; then
	5995	func_append compile_command " $arg"
	5996	func_append finalize_command " $arg"
	5997	fi
	5998	done # argument parsing loop
	5999
	6000	test -n "$prev" && \
	6001	func_fatal_help "the \`$prevarg' option requires an argument"
	6002
	6003	if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
	6004	eval arg=\"$export_dynamic_flag_spec\"
	6005	func_append compile_command " $arg"
	6006	func_append finalize_command " $arg"
	6007	fi
	6008
	6009	oldlibs=
	6010	# calculate the name of the file, without its directory
	6011	func_basename "$output"
	6012	outputname="$func_basename_result"
	6013	libobjs_save="$libobjs"
	6014
	6015	if test -n "$shlibpath_var"; then
	6016	# get the directories listed in $shlibpath_var
	6017	eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \\| \$SED \'s/:/ /g\'\`
	6018	else
	6019	shlib_search_path=
	6020	fi
	6021	eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
	6022	eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
	6023
	6024	func_dirname "$output" "/" ""
	6025	output_objdir="$func_dirname_result$objdir"
	6026	func_to_tool_file "$output_objdir/"
	6027	tool_output_objdir=$func_to_tool_file_result
	6028	# Create the object directory.
	6029	func_mkdir_p "$output_objdir"
	6030
	6031	# Determine the type of output
	6032	case $output in
	6033	"")
	6034	func_fatal_help "you must specify an output file"
	6035	;;
	6036	*.$libext) linkmode=oldlib ;;
	6037	.lo \| .$objext) linkmode=obj ;;
	6038	*.la) linkmode=lib ;;
	6039	*) linkmode=prog ;; # Anything else should be a program.
	6040	esac
	6041
	6042	specialdeplibs=
	6043
	6044	libs=
	6045	# Find all interdependent deplibs by searching for libraries
	6046	# that are linked more than once (e.g. -la -lb -la)
	6047	for deplib in $deplibs; do
	6048	if $opt_preserve_dup_deps ; then
	6049	case "$libs " in
	6050	" $deplib ") func_append specialdeplibs " $deplib" ;;
	6051	esac
	6052	fi
	6053	func_append libs " $deplib"
	6054	done
	6055
	6056	if test "$linkmode" = lib; then
	6057	libs="$predeps $libs $compiler_lib_search_path $postdeps"
	6058
	6059	# Compute libraries that are listed more than once in $predeps
	6060	# $postdeps and mark them as special (i.e., whose duplicates are
	6061	# not to be eliminated).
	6062	pre_post_deps=
	6063	if $opt_duplicate_compiler_generated_deps; then
	6064	for pre_post_dep in $predeps $postdeps; do
	6065	case "$pre_post_deps " in
	6066	" $pre_post_dep ") func_append specialdeplibs " $pre_post_deps" ;;
	6067	esac
	6068	func_append pre_post_deps " $pre_post_dep"
	6069	done
	6070	fi
	6071	pre_post_deps=
	6072	fi
	6073
	6074	deplibs=
	6075	newdependency_libs=
	6076	newlib_search_path=
	6077	need_relink=no # whether we're linking any uninstalled libtool libraries
	6078	notinst_deplibs= # not-installed libtool libraries
	6079	notinst_path= # paths that contain not-installed libtool libraries
	6080
	6081	case $linkmode in
	6082	lib)
	6083	passes="conv dlpreopen link"
	6084	for file in $dlfiles $dlprefiles; do
	6085	case $file in
	6086	*.la) ;;
	6087	*)
	6088	func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
	6089	;;
	6090	esac
	6091	done
	6092	;;
	6093	prog)
	6094	compile_deplibs=
	6095	finalize_deplibs=
	6096	alldeplibs=no
	6097	newdlfiles=
	6098	newdlprefiles=
	6099	passes="conv scan dlopen dlpreopen link"
	6100	;;
	6101	*) passes="conv"
	6102	;;
	6103	esac
	6104
	6105	for pass in $passes; do
	6106	# The preopen pass in lib mode reverses $deplibs; put it back here
	6107	# so that -L comes before libs that need it for instance...
	6108	if test "$linkmode,$pass" = "lib,link"; then
	6109	## FIXME: Find the place where the list is rebuilt in the wrong
	6110	## order, and fix it there properly
	6111	tmp_deplibs=
	6112	for deplib in $deplibs; do
	6113	tmp_deplibs="$deplib $tmp_deplibs"
	6114	done
	6115	deplibs="$tmp_deplibs"
	6116	fi
	6117
	6118	if test "$linkmode,$pass" = "lib,link" \|\|
	6119	test "$linkmode,$pass" = "prog,scan"; then
	6120	libs="$deplibs"
	6121	deplibs=
	6122	fi
	6123	if test "$linkmode" = prog; then
	6124	case $pass in
	6125	dlopen) libs="$dlfiles" ;;
	6126	dlpreopen) libs="$dlprefiles" ;;
	6127	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
	6128	esac
	6129	fi
	6130	if test "$linkmode,$pass" = "lib,dlpreopen"; then
	6131	# Collect and forward deplibs of preopened libtool libs
	6132	for lib in $dlprefiles; do
	6133	# Ignore non-libtool-libs
	6134	dependency_libs=
	6135	func_resolve_sysroot "$lib"
	6136	case $lib in
	6137	*.la) func_source "$func_resolve_sysroot_result" ;;
	6138	esac
	6139
	6140	# Collect preopened libtool deplibs, except any this library
	6141	# has declared as weak libs
	6142	for deplib in $dependency_libs; do
	6143	func_basename "$deplib"
	6144	deplib_base=$func_basename_result
	6145	case " $weak_libs " in
	6146	" $deplib_base ") ;;
	6147	*) func_append deplibs " $deplib" ;;
	6148	esac
	6149	done
	6150	done
	6151	libs="$dlprefiles"
	6152	fi
	6153	if test "$pass" = dlopen; then
	6154	# Collect dlpreopened libraries
	6155	save_deplibs="$deplibs"
	6156	deplibs=
	6157	fi
	6158
	6159	for deplib in $libs; do
	6160	lib=
	6161	found=no
	6162	case $deplib in
	6163	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe \
	6164	\|-threads\|-fopenmp\|-openmp\|-mp\|-xopenmp\|-omp\|-qsmp=*)
	6165	if test "$linkmode,$pass" = "prog,link"; then
	6166	compile_deplibs="$deplib $compile_deplibs"
	6167	finalize_deplibs="$deplib $finalize_deplibs"
	6168	else
	6169	func_append compiler_flags " $deplib"
	6170	if test "$linkmode" = lib ; then
	6171	case "$new_inherited_linker_flags " in
	6172	" $deplib ") ;;
	6173	* ) func_append new_inherited_linker_flags " $deplib" ;;
	6174	esac
	6175	fi
	6176	fi
	6177	continue
	6178	;;
	6179	-l*)
	6180	if test "$linkmode" != lib && test "$linkmode" != prog; then
	6181	func_warning "\`-l' is ignored for archives/objects"
	6182	continue
	6183	fi
	6184	func_stripname '-l' '' "$deplib"
	6185	name=$func_stripname_result
	6186	if test "$linkmode" = lib; then
	6187	searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
	6188	else
	6189	searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
	6190	fi
	6191	for searchdir in $searchdirs; do
	6192	for search_ext in .la $std_shrext .so .a; do
	6193	# Search the libtool library
	6194	lib="$searchdir/lib${name}${search_ext}"
	6195	if test -f "$lib"; then
	6196	if test "$search_ext" = ".la"; then
	6197	found=yes
	6198	else
	6199	found=no
	6200	fi
	6201	break 2
	6202	fi
	6203	done
	6204	done
	6205	if test "$found" != yes; then
	6206	# deplib doesn't seem to be a libtool library
	6207	if test "$linkmode,$pass" = "prog,link"; then
	6208	compile_deplibs="$deplib $compile_deplibs"
	6209	finalize_deplibs="$deplib $finalize_deplibs"
	6210	else
	6211	deplibs="$deplib $deplibs"
	6212	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
	6213	fi
	6214	continue
	6215	else # deplib is a libtool library
	6216	# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
	6217	# We need to do some special things here, and not later.
	6218	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	6219	case " $predeps $postdeps " in
	6220	" $deplib ")
	6221	if func_lalib_p "$lib"; then
	6222	library_names=
	6223	old_library=
	6224	func_source "$lib"
	6225	for l in $old_library $library_names; do
	6226	ll="$l"
	6227	done
	6228	if test "X$ll" = "X$old_library" ; then # only static version available
	6229	found=no
	6230	func_dirname "$lib" "" "."
	6231	ladir="$func_dirname_result"
	6232	lib=$ladir/$old_library
	6233	if test "$linkmode,$pass" = "prog,link"; then
	6234	compile_deplibs="$deplib $compile_deplibs"
	6235	finalize_deplibs="$deplib $finalize_deplibs"
	6236	else
	6237	deplibs="$deplib $deplibs"
	6238	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
	6239	fi
	6240	continue
	6241	fi
	6242	fi
	6243	;;
	6244	*) ;;
	6245	esac
	6246	fi
	6247	fi
	6248	;; # -l
	6249	*.ltframework)
	6250	if test "$linkmode,$pass" = "prog,link"; then
	6251	compile_deplibs="$deplib $compile_deplibs"
	6252	finalize_deplibs="$deplib $finalize_deplibs"
	6253	else
	6254	deplibs="$deplib $deplibs"
	6255	if test "$linkmode" = lib ; then
	6256	case "$new_inherited_linker_flags " in
	6257	" $deplib ") ;;
	6258	* ) func_append new_inherited_linker_flags " $deplib" ;;
	6259	esac
	6260	fi
	6261	fi
	6262	continue
	6263	;;
	6264	-L*)
	6265	case $linkmode in
	6266	lib)
	6267	deplibs="$deplib $deplibs"
	6268	test "$pass" = conv && continue
	6269	newdependency_libs="$deplib $newdependency_libs"
	6270	func_stripname '-L' '' "$deplib"
	6271	func_resolve_sysroot "$func_stripname_result"
	6272	func_append newlib_search_path " $func_resolve_sysroot_result"
	6273	;;
	6274	prog)
	6275	if test "$pass" = conv; then
	6276	deplibs="$deplib $deplibs"
	6277	continue
	6278	fi
	6279	if test "$pass" = scan; then
	6280	deplibs="$deplib $deplibs"
	6281	else
	6282	compile_deplibs="$deplib $compile_deplibs"
	6283	finalize_deplibs="$deplib $finalize_deplibs"
	6284	fi
	6285	func_stripname '-L' '' "$deplib"
	6286	func_resolve_sysroot "$func_stripname_result"
	6287	func_append newlib_search_path " $func_resolve_sysroot_result"
	6288	;;
	6289	*)
	6290	func_warning "\`-L' is ignored for archives/objects"
	6291	;;
	6292	esac # linkmode
	6293	continue
	6294	;; # -L
	6295	-R*)
	6296	if test "$pass" = link; then
	6297	func_stripname '-R' '' "$deplib"
	6298	func_resolve_sysroot "$func_stripname_result"
	6299	dir=$func_resolve_sysroot_result
	6300	# Make sure the xrpath contains only unique directories.
	6301	case "$xrpath " in
	6302	" $dir ") ;;
	6303	*) func_append xrpath " $dir" ;;
	6304	esac
	6305	fi
	6306	deplibs="$deplib $deplibs"
	6307	continue
	6308	;;
	6309	*.la)
	6310	func_resolve_sysroot "$deplib"
	6311	lib=$func_resolve_sysroot_result
	6312	;;
	6313	*.$libext)
	6314	if test "$pass" = conv; then
	6315	deplibs="$deplib $deplibs"
	6316	continue
	6317	fi
	6318	case $linkmode in
	6319	lib)
	6320	# Linking convenience modules into shared libraries is allowed,
	6321	# but linking other static libraries is non-portable.
	6322	case " $dlpreconveniencelibs " in
	6323	" $deplib ") ;;
	6324	*)
	6325	valid_a_lib=no
	6326	case $deplibs_check_method in
	6327	match_pattern*)
	6328	set dummy $deplibs_check_method; shift
	6329	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
	6330	if eval "\$ECHO \"$deplib\"" 2>/dev/null \| $SED 10q \
	6331	\| $EGREP "$match_pattern_regex" > /dev/null; then
	6332	valid_a_lib=yes
	6333	fi
	6334	;;
	6335	pass_all)
	6336	valid_a_lib=yes
	6337	;;
	6338	esac
	6339	if test "$valid_a_lib" != yes; then
	6340	echo
	6341	$ECHO "*** Warning: Trying to link with static lib archive $deplib."
	6342	echo "*** I have the capability to make that library automatically link in when"
	6343	echo "*** you link to this library. But I can only do this if you have a"
	6344	echo "*** shared version of the library, which you do not appear to have"
	6345	echo "*** because the file extensions .$libext of this argument makes me believe"
	6346	echo "*** that it is just a static archive that I should not use here."
	6347	else
	6348	echo
	6349	$ECHO "*** Warning: Linking the shared library $output against the"
	6350	$ECHO "*** static library $deplib is not portable!"
	6351	deplibs="$deplib $deplibs"
	6352	fi
	6353	;;
	6354	esac
	6355	continue
	6356	;;
	6357	prog)
	6358	if test "$pass" != link; then
	6359	deplibs="$deplib $deplibs"
	6360	else
	6361	compile_deplibs="$deplib $compile_deplibs"
	6362	finalize_deplibs="$deplib $finalize_deplibs"
	6363	fi
	6364	continue
	6365	;;
	6366	esac # linkmode
	6367	;; # *.$libext
	6368	.lo \| .$objext)
	6369	if test "$pass" = conv; then
	6370	deplibs="$deplib $deplibs"
	6371	elif test "$linkmode" = prog; then
	6372	if test "$pass" = dlpreopen \|\| test "$dlopen_support" != yes \|\| test "$build_libtool_libs" = no; then
	6373	# If there is no dlopen support or we're linking statically,
	6374	# we need to preload.
	6375	func_append newdlprefiles " $deplib"
	6376	compile_deplibs="$deplib $compile_deplibs"
	6377	finalize_deplibs="$deplib $finalize_deplibs"
	6378	else
	6379	func_append newdlfiles " $deplib"
	6380	fi
	6381	fi
	6382	continue
	6383	;;
	6384	%DEPLIBS%)
	6385	alldeplibs=yes
	6386	continue
	6387	;;
	6388	esac # case $deplib
	6389
	6390	if test "$found" = yes \|\| test -f "$lib"; then :
	6391	else
	6392	func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
	6393	fi
	6394
	6395	# Check to see that this really is a libtool archive.
	6396	func_lalib_unsafe_p "$lib" \
	6397	\|\| func_fatal_error "\`$lib' is not a valid libtool archive"
	6398
	6399	func_dirname "$lib" "" "."
	6400	ladir="$func_dirname_result"
	6401
	6402	dlname=
	6403	dlopen=
	6404	dlpreopen=
	6405	libdir=
	6406	library_names=
	6407	old_library=
	6408	inherited_linker_flags=
	6409	# If the library was installed with an old release of libtool,
	6410	# it will not redefine variables installed, or shouldnotlink
	6411	installed=yes
	6412	shouldnotlink=no
	6413	avoidtemprpath=
	6414
	6415
	6416	# Read the .la file
	6417	func_source "$lib"
	6418
	6419	# Convert "-framework foo" to "foo.ltframework"
	6420	if test -n "$inherited_linker_flags"; then
	6421	tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" \| $SED 's/-framework $[^ $]*$/\1.ltframework/g'`
	6422	for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
	6423	case " $new_inherited_linker_flags " in
	6424	" $tmp_inherited_linker_flag ") ;;
	6425	*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
	6426	esac
	6427	done
	6428	fi
	6429	dependency_libs=`$ECHO " $dependency_libs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	6430	if test "$linkmode,$pass" = "lib,link" \|\|
	6431	test "$linkmode,$pass" = "prog,scan" \|\|
	6432	{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
	6433	test -n "$dlopen" && func_append dlfiles " $dlopen"
	6434	test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
	6435	fi
	6436
	6437	if test "$pass" = conv; then
	6438	# Only check for convenience libraries
	6439	deplibs="$lib $deplibs"
	6440	if test -z "$libdir"; then
	6441	if test -z "$old_library"; then
	6442	func_fatal_error "cannot find name of link library for \`$lib'"
	6443	fi
	6444	# It is a libtool convenience library, so add in its objects.
	6445	func_append convenience " $ladir/$objdir/$old_library"
	6446	func_append old_convenience " $ladir/$objdir/$old_library"
	6447	elif test "$linkmode" != prog && test "$linkmode" != lib; then
	6448	func_fatal_error "\`$lib' is not a convenience library"
	6449	fi
	6450	tmp_libs=
	6451	for deplib in $dependency_libs; do
	6452	deplibs="$deplib $deplibs"
	6453	if $opt_preserve_dup_deps ; then
	6454	case "$tmp_libs " in
	6455	" $deplib ") func_append specialdeplibs " $deplib" ;;
	6456	esac
	6457	fi
	6458	func_append tmp_libs " $deplib"
	6459	done
	6460	continue
	6461	fi # $pass = conv
	6462
	6463
	6464	# Get the name of the library we link against.
	6465	linklib=
	6466	if test -n "$old_library" &&
	6467	{ test "$prefer_static_libs" = yes \|\|
	6468	test "$prefer_static_libs,$installed" = "built,no"; }; then
	6469	linklib=$old_library
	6470	else
	6471	for l in $old_library $library_names; do
	6472	linklib="$l"
	6473	done
	6474	fi
	6475	if test -z "$linklib"; then
	6476	func_fatal_error "cannot find name of link library for \`$lib'"
	6477	fi
	6478
	6479	# This library was specified with -dlopen.
	6480	if test "$pass" = dlopen; then
	6481	if test -z "$libdir"; then
	6482	func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
	6483	fi
	6484	if test -z "$dlname" \|\|
	6485	test "$dlopen_support" != yes \|\|
	6486	test "$build_libtool_libs" = no; then
	6487	# If there is no dlname, no dlopen support or we're linking
	6488	# statically, we need to preload. We also need to preload any
	6489	# dependent libraries so libltdl's deplib preloader doesn't
	6490	# bomb out in the load deplibs phase.
	6491	func_append dlprefiles " $lib $dependency_libs"
	6492	else
	6493	func_append newdlfiles " $lib"
	6494	fi
	6495	continue
	6496	fi # $pass = dlopen
	6497
	6498	# We need an absolute path.
	6499	case $ladir in
	6500	[\\/]* \| [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
	6501	*)
	6502	abs_ladir=`cd "$ladir" && pwd`
	6503	if test -z "$abs_ladir"; then
	6504	func_warning "cannot determine absolute directory name of \`$ladir'"
	6505	func_warning "passing it literally to the linker, although it might fail"
	6506	abs_ladir="$ladir"
	6507	fi
	6508	;;
	6509	esac
	6510	func_basename "$lib"
	6511	laname="$func_basename_result"
	6512
	6513	# Find the relevant object directory and library name.
	6514	if test "X$installed" = Xyes; then
	6515	if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	6516	func_warning "library \`$lib' was moved."
	6517	dir="$ladir"
	6518	absdir="$abs_ladir"
	6519	libdir="$abs_ladir"
	6520	else
	6521	dir="$lt_sysroot$libdir"
	6522	absdir="$lt_sysroot$libdir"
	6523	fi
	6524	test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
	6525	else
	6526	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	6527	dir="$ladir"
	6528	absdir="$abs_ladir"
	6529	# Remove this search path later
	6530	func_append notinst_path " $abs_ladir"
	6531	else
	6532	dir="$ladir/$objdir"
	6533	absdir="$abs_ladir/$objdir"
	6534	# Remove this search path later
	6535	func_append notinst_path " $abs_ladir"
	6536	fi
	6537	fi # $installed = yes
	6538	func_stripname 'lib' '.la' "$laname"
	6539	name=$func_stripname_result
	6540
	6541	# This library was specified with -dlpreopen.
	6542	if test "$pass" = dlpreopen; then
	6543	if test -z "$libdir" && test "$linkmode" = prog; then
	6544	func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
	6545	fi
	6546	case "$host" in
	6547	# special handling for platforms with PE-DLLs.
	6548	cygwin \| mingw \| cegcc )
	6549	# Linker will automatically link against shared library if both
	6550	# static and shared are present. Therefore, ensure we extract
	6551	# symbols from the import library if a shared library is present
	6552	# (otherwise, the dlopen module name will be incorrect). We do
	6553	# this by putting the import library name into $newdlprefiles.
	6554	# We recover the dlopen module name by 'saving' the la file
	6555	# name in a special purpose variable, and (later) extracting the
	6556	# dlname from the la file.
	6557	if test -n "$dlname"; then
	6558	func_tr_sh "$dir/$linklib"
	6559	eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
	6560	func_append newdlprefiles " $dir/$linklib"
	6561	else
	6562	func_append newdlprefiles " $dir/$old_library"
	6563	# Keep a list of preopened convenience libraries to check
	6564	# that they are being used correctly in the link pass.
	6565	test -z "$libdir" && \
	6566	func_append dlpreconveniencelibs " $dir/$old_library"
	6567	fi
	6568	;;
	6569	* )
	6570	# Prefer using a static library (so that no silly _DYNAMIC symbols
	6571	# are required to link).
	6572	if test -n "$old_library"; then
	6573	func_append newdlprefiles " $dir/$old_library"
	6574	# Keep a list of preopened convenience libraries to check
	6575	# that they are being used correctly in the link pass.
	6576	test -z "$libdir" && \
	6577	func_append dlpreconveniencelibs " $dir/$old_library"
	6578	# Otherwise, use the dlname, so that lt_dlopen finds it.
	6579	elif test -n "$dlname"; then
	6580	func_append newdlprefiles " $dir/$dlname"
	6581	else
	6582	func_append newdlprefiles " $dir/$linklib"
	6583	fi
	6584	;;
	6585	esac
	6586	fi # $pass = dlpreopen
	6587
	6588	if test -z "$libdir"; then
	6589	# Link the convenience library
	6590	if test "$linkmode" = lib; then
	6591	deplibs="$dir/$old_library $deplibs"
	6592	elif test "$linkmode,$pass" = "prog,link"; then
	6593	compile_deplibs="$dir/$old_library $compile_deplibs"
	6594	finalize_deplibs="$dir/$old_library $finalize_deplibs"
	6595	else
	6596	deplibs="$lib $deplibs" # used for prog,scan pass
	6597	fi
	6598	continue
	6599	fi
	6600
	6601
	6602	if test "$linkmode" = prog && test "$pass" != link; then
	6603	func_append newlib_search_path " $ladir"
	6604	deplibs="$lib $deplibs"
	6605
	6606	linkalldeplibs=no
	6607	if test "$link_all_deplibs" != no \|\| test -z "$library_names" \|\|
	6608	test "$build_libtool_libs" = no; then
	6609	linkalldeplibs=yes
	6610	fi
	6611
	6612	tmp_libs=
	6613	for deplib in $dependency_libs; do
	6614	case $deplib in
	6615	-L*) func_stripname '-L' '' "$deplib"
	6616	func_resolve_sysroot "$func_stripname_result"
	6617	func_append newlib_search_path " $func_resolve_sysroot_result"
	6618	;;
	6619	esac
	6620	# Need to link against all dependency_libs?
	6621	if test "$linkalldeplibs" = yes; then
	6622	deplibs="$deplib $deplibs"
	6623	else
	6624	# Need to hardcode shared library paths
	6625	# or/and link against static libraries
	6626	newdependency_libs="$deplib $newdependency_libs"
	6627	fi
	6628	if $opt_preserve_dup_deps ; then
	6629	case "$tmp_libs " in
	6630	" $deplib ") func_append specialdeplibs " $deplib" ;;
	6631	esac
	6632	fi
	6633	func_append tmp_libs " $deplib"
	6634	done # for deplib
	6635	continue
	6636	fi # $linkmode = prog...
	6637
	6638	if test "$linkmode,$pass" = "prog,link"; then
	6639	if test -n "$library_names" &&
	6640	{ { test "$prefer_static_libs" = no \|\|
	6641	test "$prefer_static_libs,$installed" = "built,yes"; } \|\|
	6642	test -z "$old_library"; }; then
	6643	# We need to hardcode the library path
	6644	if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
	6645	# Make sure the rpath contains only unique directories.
	6646	case "$temp_rpath:" in
	6647	"$absdir:") ;;
	6648	*) func_append temp_rpath "$absdir:" ;;
	6649	esac
	6650	fi
	6651
	6652	# Hardcode the library path.
	6653	# Skip directories that are in the system default run-time
	6654	# search path.
	6655	case " $sys_lib_dlsearch_path " in
	6656	" $absdir ") ;;
	6657	*)
	6658	case "$compile_rpath " in
	6659	" $absdir ") ;;
	6660	*) func_append compile_rpath " $absdir" ;;
	6661	esac
	6662	;;
	6663	esac
	6664	case " $sys_lib_dlsearch_path " in
	6665	" $libdir ") ;;
	6666	*)
	6667	case "$finalize_rpath " in
	6668	" $libdir ") ;;
	6669	*) func_append finalize_rpath " $libdir" ;;
	6670	esac
	6671	;;
	6672	esac
	6673	fi # $linkmode,$pass = prog,link...
	6674
	6675	if test "$alldeplibs" = yes &&
	6676	{ test "$deplibs_check_method" = pass_all \|\|
	6677	{ test "$build_libtool_libs" = yes &&
	6678	test -n "$library_names"; }; }; then
	6679	# We only need to search for static libraries
	6680	continue
	6681	fi
	6682	fi
	6683
	6684	link_static=no # Whether the deplib will be linked statically
	6685	use_static_libs=$prefer_static_libs
	6686	if test "$use_static_libs" = built && test "$installed" = yes; then
	6687	use_static_libs=no
	6688	fi
	6689	if test -n "$library_names" &&
	6690	{ test "$use_static_libs" = no \|\| test -z "$old_library"; }; then
	6691	case $host in
	6692	cygwin \| mingw \| cegcc)
	6693	# No point in relinking DLLs because paths are not encoded
	6694	func_append notinst_deplibs " $lib"
	6695	need_relink=no
	6696	;;
	6697	*)
	6698	if test "$installed" = no; then
	6699	func_append notinst_deplibs " $lib"
	6700	need_relink=yes
	6701	fi
	6702	;;
	6703	esac
	6704	# This is a shared library
	6705
	6706	# Warn about portability, can't link against -module's on some
	6707	# systems (darwin). Don't bleat about dlopened modules though!
	6708	dlopenmodule=""
	6709	for dlpremoduletest in $dlprefiles; do
	6710	if test "X$dlpremoduletest" = "X$lib"; then
	6711	dlopenmodule="$dlpremoduletest"
	6712	break
	6713	fi
	6714	done
	6715	if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
	6716	echo
	6717	if test "$linkmode" = prog; then
	6718	$ECHO "*** Warning: Linking the executable $output against the loadable module"
	6719	else
	6720	$ECHO "*** Warning: Linking the shared library $output against the loadable module"
	6721	fi
	6722	$ECHO "*** $linklib is not portable!"
	6723	fi
	6724	if test "$linkmode" = lib &&
	6725	test "$hardcode_into_libs" = yes; then
	6726	# Hardcode the library path.
	6727	# Skip directories that are in the system default run-time
	6728	# search path.
	6729	case " $sys_lib_dlsearch_path " in
	6730	" $absdir ") ;;
	6731	*)
	6732	case "$compile_rpath " in
	6733	" $absdir ") ;;
	6734	*) func_append compile_rpath " $absdir" ;;
	6735	esac
	6736	;;
	6737	esac
	6738	case " $sys_lib_dlsearch_path " in
	6739	" $libdir ") ;;
	6740	*)
	6741	case "$finalize_rpath " in
	6742	" $libdir ") ;;
	6743	*) func_append finalize_rpath " $libdir" ;;
	6744	esac
	6745	;;
	6746	esac
	6747	fi
	6748
	6749	if test -n "$old_archive_from_expsyms_cmds"; then
	6750	# figure out the soname
	6751	set dummy $library_names
	6752	shift
	6753	realname="$1"
	6754	shift
	6755	libname=`eval "\\$ECHO \"$libname_spec\""`
	6756	# use dlname if we got it. it's perfectly good, no?
	6757	if test -n "$dlname"; then
	6758	soname="$dlname"
	6759	elif test -n "$soname_spec"; then
	6760	# bleh windows
	6761	case $host in
	6762	cygwin \| mingw* \| cegcc)
	6763	func_arith $current - $age
	6764	major=$func_arith_result
	6765	versuffix="-$major"
	6766	;;
	6767	esac
	6768	eval soname=\"$soname_spec\"
	6769	else
	6770	soname="$realname"
	6771	fi
	6772
	6773	# Make a new name for the extract_expsyms_cmds to use
	6774	soroot="$soname"
	6775	func_basename "$soroot"
	6776	soname="$func_basename_result"
	6777	func_stripname 'lib' '.dll' "$soname"
	6778	newlib=libimp-$func_stripname_result.a
	6779
	6780	# If the library has no export list, then create one now
	6781	if test -f "$output_objdir/$soname-def"; then :
	6782	else
	6783	func_verbose "extracting exported symbol list from \`$soname'"
	6784	func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
	6785	fi
	6786
	6787	# Create $newlib
	6788	if test -f "$output_objdir/$newlib"; then :; else
	6789	func_verbose "generating import library for \`$soname'"
	6790	func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
	6791	fi
	6792	# make sure the library variables are pointing to the new library
	6793	dir=$output_objdir
	6794	linklib=$newlib
	6795	fi # test -n "$old_archive_from_expsyms_cmds"
	6796
	6797	if test "$linkmode" = prog \|\| test "$opt_mode" != relink; then
	6798	add_shlibpath=
	6799	add_dir=
	6800	add=
	6801	lib_linked=yes
	6802	case $hardcode_action in
	6803	immediate \| unsupported)
	6804	if test "$hardcode_direct" = no; then
	6805	add="$dir/$linklib"
	6806	case $host in
	6807	--sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
	6808	--sysv4uw2) add_dir="-L$dir" ;;
	6809	--sysv5OpenUNIX* \| --sysv5UnixWare7.[01].[10]* \| \
	6810	--unixware7*) add_dir="-L$dir" ;;
	6811	--darwin* )
	6812	# if the lib is a (non-dlopened) module then we can not
	6813	# link against it, someone is ignoring the earlier warnings
	6814	if /usr/bin/file -L $add 2> /dev/null \|
	6815	$GREP ": [^:]* bundle" >/dev/null ; then
	6816	if test "X$dlopenmodule" != "X$lib"; then
	6817	$ECHO "*** Warning: lib $linklib is a module, not a shared library"
	6818	if test -z "$old_library" ; then
	6819	echo
	6820	echo "*** And there doesn't seem to be a static archive available"
	6821	echo "*** The link will probably fail, sorry"
	6822	else
	6823	add="$dir/$old_library"
	6824	fi
	6825	elif test -n "$old_library"; then
	6826	add="$dir/$old_library"
	6827	fi
	6828	fi
	6829	esac
	6830	elif test "$hardcode_minus_L" = no; then
	6831	case $host in
	6832	--sunos*) add_shlibpath="$dir" ;;
	6833	esac
	6834	add_dir="-L$dir"
	6835	add="-l$name"
	6836	elif test "$hardcode_shlibpath_var" = no; then
	6837	add_shlibpath="$dir"
	6838	add="-l$name"
	6839	else
	6840	lib_linked=no
	6841	fi
	6842	;;
	6843	relink)
	6844	if test "$hardcode_direct" = yes &&
	6845	test "$hardcode_direct_absolute" = no; then
	6846	add="$dir/$linklib"
	6847	elif test "$hardcode_minus_L" = yes; then
	6848	add_dir="-L$absdir"
	6849	# Try looking first in the location we're being installed to.
	6850	if test -n "$inst_prefix_dir"; then
	6851	case $libdir in
	6852	[\\/]*)
	6853	func_append add_dir " -L$inst_prefix_dir$libdir"
	6854	;;
	6855	esac
	6856	fi
	6857	add="-l$name"
	6858	elif test "$hardcode_shlibpath_var" = yes; then
	6859	add_shlibpath="$dir"
	6860	add="-l$name"
	6861	else
	6862	lib_linked=no
	6863	fi
	6864	;;
	6865	*) lib_linked=no ;;
	6866	esac
	6867
	6868	if test "$lib_linked" != yes; then
	6869	func_fatal_configuration "unsupported hardcode properties"
	6870	fi
	6871
	6872	if test -n "$add_shlibpath"; then
	6873	case :$compile_shlibpath: in
	6874	":$add_shlibpath:") ;;
	6875	*) func_append compile_shlibpath "$add_shlibpath:" ;;
	6876	esac
	6877	fi
	6878	if test "$linkmode" = prog; then
	6879	test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
	6880	test -n "$add" && compile_deplibs="$add $compile_deplibs"
	6881	else
	6882	test -n "$add_dir" && deplibs="$add_dir $deplibs"
	6883	test -n "$add" && deplibs="$add $deplibs"
	6884	if test "$hardcode_direct" != yes &&
	6885	test "$hardcode_minus_L" != yes &&
	6886	test "$hardcode_shlibpath_var" = yes; then
	6887	case :$finalize_shlibpath: in
	6888	":$libdir:") ;;
	6889	*) func_append finalize_shlibpath "$libdir:" ;;
	6890	esac
	6891	fi
	6892	fi
	6893	fi
	6894
	6895	if test "$linkmode" = prog \|\| test "$opt_mode" = relink; then
	6896	add_shlibpath=
	6897	add_dir=
	6898	add=
	6899	# Finalize command for both is simple: just hardcode it.
	6900	if test "$hardcode_direct" = yes &&
	6901	test "$hardcode_direct_absolute" = no; then
	6902	add="$libdir/$linklib"
	6903	elif test "$hardcode_minus_L" = yes; then
	6904	add_dir="-L$libdir"
	6905	add="-l$name"
	6906	elif test "$hardcode_shlibpath_var" = yes; then
	6907	case :$finalize_shlibpath: in
	6908	":$libdir:") ;;
	6909	*) func_append finalize_shlibpath "$libdir:" ;;
	6910	esac
	6911	add="-l$name"
	6912	elif test "$hardcode_automatic" = yes; then
	6913	if test -n "$inst_prefix_dir" &&
	6914	test -f "$inst_prefix_dir$libdir/$linklib" ; then
	6915	add="$inst_prefix_dir$libdir/$linklib"
	6916	else
	6917	add="$libdir/$linklib"
	6918	fi
	6919	else
	6920	# We cannot seem to hardcode it, guess we'll fake it.
	6921	add_dir="-L$libdir"
	6922	# Try looking first in the location we're being installed to.
	6923	if test -n "$inst_prefix_dir"; then
	6924	case $libdir in
	6925	[\\/]*)
	6926	func_append add_dir " -L$inst_prefix_dir$libdir"
	6927	;;
	6928	esac
	6929	fi
	6930	add="-l$name"
	6931	fi
	6932
	6933	if test "$linkmode" = prog; then
	6934	test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
	6935	test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
	6936	else
	6937	test -n "$add_dir" && deplibs="$add_dir $deplibs"
	6938	test -n "$add" && deplibs="$add $deplibs"
	6939	fi
	6940	fi
	6941	elif test "$linkmode" = prog; then
	6942	# Here we assume that one of hardcode_direct or hardcode_minus_L
	6943	# is not unsupported. This is valid on all known static and
	6944	# shared platforms.
	6945	if test "$hardcode_direct" != unsupported; then
	6946	test -n "$old_library" && linklib="$old_library"
	6947	compile_deplibs="$dir/$linklib $compile_deplibs"
	6948	finalize_deplibs="$dir/$linklib $finalize_deplibs"
	6949	else
	6950	compile_deplibs="-l$name -L$dir $compile_deplibs"
	6951	finalize_deplibs="-l$name -L$dir $finalize_deplibs"
	6952	fi
	6953	elif test "$build_libtool_libs" = yes; then
	6954	# Not a shared library
	6955	if test "$deplibs_check_method" != pass_all; then
	6956	# We're trying link a shared library against a static one
	6957	# but the system doesn't support it.
	6958
	6959	# Just print a warning and add the library to dependency_libs so
	6960	# that the program can be linked against the static library.
	6961	echo
	6962	$ECHO "*** Warning: This system can not link to static lib archive $lib."
	6963	echo "*** I have the capability to make that library automatically link in when"
	6964	echo "*** you link to this library. But I can only do this if you have a"
	6965	echo "*** shared version of the library, which you do not appear to have."
	6966	if test "$module" = yes; then
	6967	echo "*** But as you try to build a module library, libtool will still create "
	6968	echo "*** a static module, that should work as long as the dlopening application"
	6969	echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
	6970	if test -z "$global_symbol_pipe"; then
	6971	echo
	6972	echo "*** However, this would only work if libtool was able to extract symbol"
	6973	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	6974	echo "*** not find such a program. So, this module is probably useless."
	6975	echo "*** \`nm' from GNU binutils and a full rebuild may help."
	6976	fi
	6977	if test "$build_old_libs" = no; then
	6978	build_libtool_libs=module
	6979	build_old_libs=yes
	6980	else
	6981	build_libtool_libs=no
	6982	fi
	6983	fi
	6984	else
	6985	deplibs="$dir/$old_library $deplibs"
	6986	link_static=yes
	6987	fi
	6988	fi # link shared/static library?
	6989
	6990	if test "$linkmode" = lib; then
	6991	if test -n "$dependency_libs" &&
	6992	{ test "$hardcode_into_libs" != yes \|\|
	6993	test "$build_old_libs" = yes \|\|
	6994	test "$link_static" = yes; }; then
	6995	# Extract -R from dependency_libs
	6996	temp_deplibs=
	6997	for libdir in $dependency_libs; do
	6998	case $libdir in
	6999	-R*) func_stripname '-R' '' "$libdir"
	7000	temp_xrpath=$func_stripname_result
	7001	case " $xrpath " in
	7002	" $temp_xrpath ") ;;
	7003	*) func_append xrpath " $temp_xrpath";;
	7004	esac;;
	7005	*) func_append temp_deplibs " $libdir";;
	7006	esac
	7007	done
	7008	dependency_libs="$temp_deplibs"
	7009	fi
	7010
	7011	func_append newlib_search_path " $absdir"
	7012	# Link against this library
	7013	test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
	7014	# ... and its dependency_libs
	7015	tmp_libs=
	7016	for deplib in $dependency_libs; do
	7017	newdependency_libs="$deplib $newdependency_libs"
	7018	case $deplib in
	7019	-L*) func_stripname '-L' '' "$deplib"
	7020	func_resolve_sysroot "$func_stripname_result";;
	7021	*) func_resolve_sysroot "$deplib" ;;
	7022	esac
	7023	if $opt_preserve_dup_deps ; then
	7024	case "$tmp_libs " in
	7025	" $func_resolve_sysroot_result ")
	7026	func_append specialdeplibs " $func_resolve_sysroot_result" ;;
	7027	esac
	7028	fi
	7029	func_append tmp_libs " $func_resolve_sysroot_result"
	7030	done
	7031
	7032	if test "$link_all_deplibs" != no; then
	7033	# Add the search paths of all dependency libraries
	7034	for deplib in $dependency_libs; do
	7035	path=
	7036	case $deplib in
	7037	-L*) path="$deplib" ;;
	7038	*.la)
	7039	func_resolve_sysroot "$deplib"
	7040	deplib=$func_resolve_sysroot_result
	7041	func_dirname "$deplib" "" "."
	7042	dir=$func_dirname_result
	7043	# We need an absolute path.
	7044	case $dir in
	7045	[\\/]* \| [A-Za-z]:[\\/]*) absdir="$dir" ;;
	7046	*)
	7047	absdir=`cd "$dir" && pwd`
	7048	if test -z "$absdir"; then
	7049	func_warning "cannot determine absolute directory name of \`$dir'"
	7050	absdir="$dir"
	7051	fi
	7052	;;
	7053	esac
	7054	if $GREP "^installed=no" $deplib > /dev/null; then
	7055	case $host in
	7056	--darwin*)
	7057	depdepl=
	7058	eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`
	7059	if test -n "$deplibrary_names" ; then
	7060	for tmp in $deplibrary_names ; do
	7061	depdepl=$tmp
	7062	done
	7063	if test -f "$absdir/$objdir/$depdepl" ; then
	7064	depdepl="$absdir/$objdir/$depdepl"
	7065	darwin_install_name=`${OTOOL} -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
	7066	if test -z "$darwin_install_name"; then
	7067	darwin_install_name=`${OTOOL64} -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
	7068	fi
	7069	func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
	7070	func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
	7071	path=
	7072	fi
	7073	fi
	7074	;;
	7075	*)
	7076	path="-L$absdir/$objdir"
	7077	;;
	7078	esac
	7079	else
	7080	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`
	7081	test -z "$libdir" && \
	7082	func_fatal_error "\`$deplib' is not a valid libtool archive"
	7083	test "$absdir" != "$libdir" && \
	7084	func_warning "\`$deplib' seems to be moved"
	7085
	7086	path="-L$absdir"
	7087	fi
	7088	;;
	7089	esac
	7090	case " $deplibs " in
	7091	" $path ") ;;
	7092	*) deplibs="$path $deplibs" ;;
	7093	esac
	7094	done
	7095	fi # link_all_deplibs != no
	7096	fi # linkmode = lib
	7097	done # for deplib in $libs
	7098	if test "$pass" = link; then
	7099	if test "$linkmode" = "prog"; then
	7100	compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
	7101	finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
	7102	else
	7103	compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	7104	fi
	7105	fi
	7106	dependency_libs="$newdependency_libs"
	7107	if test "$pass" = dlpreopen; then
	7108	# Link the dlpreopened libraries before other libraries
	7109	for deplib in $save_deplibs; do
	7110	deplibs="$deplib $deplibs"
	7111	done
	7112	fi
	7113	if test "$pass" != dlopen; then
	7114	if test "$pass" != conv; then
	7115	# Make sure lib_search_path contains only unique directories.
	7116	lib_search_path=
	7117	for dir in $newlib_search_path; do
	7118	case "$lib_search_path " in
	7119	" $dir ") ;;
	7120	*) func_append lib_search_path " $dir" ;;
	7121	esac
	7122	done
	7123	newlib_search_path=
	7124	fi
	7125
	7126	if test "$linkmode,$pass" != "prog,link"; then
	7127	vars="deplibs"
	7128	else
	7129	vars="compile_deplibs finalize_deplibs"
	7130	fi
	7131	for var in $vars dependency_libs; do
	7132	# Add libraries to $var in reverse order
	7133	eval tmp_libs=\"\$$var\"
	7134	new_libs=
	7135	for deplib in $tmp_libs; do
	7136	# FIXME: Pedantically, this is the right thing to do, so
	7137	# that some nasty dependency loop isn't accidentally
	7138	# broken:
	7139	#new_libs="$deplib $new_libs"
	7140	# Pragmatically, this seems to cause very few problems in
	7141	# practice:
	7142	case $deplib in
	7143	-L*) new_libs="$deplib $new_libs" ;;
	7144	-R*) ;;
	7145	*)
	7146	# And here is the reason: when a library appears more
	7147	# than once as an explicit dependence of a library, or
	7148	# is implicitly linked in more than once by the
	7149	# compiler, it is considered special, and multiple
	7150	# occurrences thereof are not removed. Compare this
	7151	# with having the same library being listed as a
	7152	# dependency of multiple other libraries: in this case,
	7153	# we know (pedantically, we assume) the library does not
	7154	# need to be listed more than once, so we keep only the
	7155	# last copy. This is not always right, but it is rare
	7156	# enough that we require users that really mean to play
	7157	# such unportable linking tricks to link the library
	7158	# using -Wl,-lname, so that libtool does not consider it
	7159	# for duplicate removal.
	7160	case " $specialdeplibs " in
	7161	" $deplib ") new_libs="$deplib $new_libs" ;;
	7162	*)
	7163	case " $new_libs " in
	7164	" $deplib ") ;;
	7165	*) new_libs="$deplib $new_libs" ;;
	7166	esac
	7167	;;
	7168	esac
	7169	;;
	7170	esac
	7171	done
	7172	tmp_libs=
	7173	for deplib in $new_libs; do
	7174	case $deplib in
	7175	-L*)
	7176	case " $tmp_libs " in
	7177	" $deplib ") ;;
	7178	*) func_append tmp_libs " $deplib" ;;
	7179	esac
	7180	;;
	7181	*) func_append tmp_libs " $deplib" ;;
	7182	esac
	7183	done
	7184	eval $var=\"$tmp_libs\"
	7185	done # for var
	7186	fi
	7187	# Last step: remove runtime libs from dependency_libs
	7188	# (they stay in deplibs)
	7189	tmp_libs=
	7190	for i in $dependency_libs ; do
	7191	case " $predeps $postdeps $compiler_lib_search_path " in
	7192	" $i ")
	7193	i=""
	7194	;;
	7195	esac
	7196	if test -n "$i" ; then
	7197	func_append tmp_libs " $i"
	7198	fi
	7199	done
	7200	dependency_libs=$tmp_libs
	7201	done # for pass
	7202	if test "$linkmode" = prog; then
	7203	dlfiles="$newdlfiles"
	7204	fi
	7205	if test "$linkmode" = prog \|\| test "$linkmode" = lib; then
	7206	dlprefiles="$newdlprefiles"
	7207	fi
	7208
	7209	case $linkmode in
	7210	oldlib)
	7211	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	7212	func_warning "\`-dlopen' is ignored for archives"
	7213	fi
	7214
	7215	case " $deplibs" in
	7216	\ -l \| \ -L)
	7217	func_warning "\`-l' and \`-L' are ignored for archives" ;;
	7218	esac
	7219
	7220	test -n "$rpath" && \
	7221	func_warning "\`-rpath' is ignored for archives"
	7222
	7223	test -n "$xrpath" && \
	7224	func_warning "\`-R' is ignored for archives"
	7225
	7226	test -n "$vinfo" && \
	7227	func_warning "\`-version-info/-version-number' is ignored for archives"
	7228
	7229	test -n "$release" && \
	7230	func_warning "\`-release' is ignored for archives"
	7231
	7232	test -n "$export_symbols$export_symbols_regex" && \
	7233	func_warning "\`-export-symbols' is ignored for archives"
	7234
	7235	# Now set the variables for building old libraries.
	7236	build_libtool_libs=no
	7237	oldlibs="$output"
	7238	func_append objs "$old_deplibs"
	7239	;;
	7240
	7241	lib)
	7242	# Make sure we only generate libraries of the form `libNAME.la'.
	7243	case $outputname in
	7244	lib*)
	7245	func_stripname 'lib' '.la' "$outputname"
	7246	name=$func_stripname_result
	7247	eval shared_ext=\"$shrext_cmds\"
	7248	eval libname=\"$libname_spec\"
	7249	;;
	7250	*)
	7251	test "$module" = no && \
	7252	func_fatal_help "libtool library \`$output' must begin with \`lib'"
	7253
	7254	if test "$need_lib_prefix" != no; then
	7255	# Add the "lib" prefix for modules if required
	7256	func_stripname '' '.la' "$outputname"
	7257	name=$func_stripname_result
	7258	eval shared_ext=\"$shrext_cmds\"
	7259	eval libname=\"$libname_spec\"
	7260	else
	7261	func_stripname '' '.la' "$outputname"
	7262	libname=$func_stripname_result
	7263	fi
	7264	;;
	7265	esac
	7266
	7267	if test -n "$objs"; then
	7268	if test "$deplibs_check_method" != pass_all; then
	7269	func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
	7270	else
	7271	echo
	7272	$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
	7273	$ECHO "*** objects $objs is not portable!"
	7274	func_append libobjs " $objs"
	7275	fi
	7276	fi
	7277
	7278	test "$dlself" != no && \
	7279	func_warning "\`-dlopen self' is ignored for libtool libraries"
	7280
	7281	set dummy $rpath
	7282	shift
	7283	test "$#" -gt 1 && \
	7284	func_warning "ignoring multiple \`-rpath's for a libtool library"
	7285
	7286	install_libdir="$1"
	7287
	7288	oldlibs=
	7289	if test -z "$rpath"; then
	7290	if test "$build_libtool_libs" = yes; then
	7291	# Building a libtool convenience library.
	7292	# Some compilers have problems with a `.al' extension so
	7293	# convenience libraries should have the same extension an
	7294	# archive normally would.
	7295	oldlibs="$output_objdir/$libname.$libext $oldlibs"
	7296	build_libtool_libs=convenience
	7297	build_old_libs=yes
	7298	fi
	7299
	7300	test -n "$vinfo" && \
	7301	func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
	7302
	7303	test -n "$release" && \
	7304	func_warning "\`-release' is ignored for convenience libraries"
	7305	else
	7306
	7307	# Parse the version information argument.
	7308	save_ifs="$IFS"; IFS=':'
	7309	set dummy $vinfo 0 0 0
	7310	shift
	7311	IFS="$save_ifs"
	7312
	7313	test -n "$7" && \
	7314	func_fatal_help "too many parameters to \`-version-info'"
	7315
	7316	# convert absolute version numbers to libtool ages
	7317	# this retains compatibility with .la files and attempts
	7318	# to make the code below a bit more comprehensible
	7319
	7320	case $vinfo_number in
	7321	yes)
	7322	number_major="$1"
	7323	number_minor="$2"
	7324	number_revision="$3"
	7325	#
	7326	# There are really only two kinds -- those that
	7327	# use the current revision as the major version
	7328	# and those that subtract age and use age as
	7329	# a minor version. But, then there is irix
	7330	# which has an extra 1 added just for fun
	7331	#
	7332	case $version_type in
	7333	# correct linux to gnu/linux during the next big refactor
	7334	darwin\|linux\|osf\|windows\|none)
	7335	func_arith $number_major + $number_minor
	7336	current=$func_arith_result
	7337	age="$number_minor"
	7338	revision="$number_revision"
	7339	;;
	7340	freebsd-aout\|freebsd-elf\|qnx\|sunos)
	7341	current="$number_major"
	7342	revision="$number_minor"
	7343	age="0"
	7344	;;
	7345	irix\|nonstopux)
	7346	func_arith $number_major + $number_minor
	7347	current=$func_arith_result
	7348	age="$number_minor"
	7349	revision="$number_minor"
	7350	lt_irix_increment=no
	7351	;;
	7352	esac
	7353	;;
	7354	no)
	7355	current="$1"
	7356	revision="$2"
	7357	age="$3"
	7358	;;
	7359	esac
	7360
	7361	# Check that each of the things are valid numbers.
	7362	case $current in
	7363	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]) ;;
	7364	*)
	7365	func_error "CURRENT \`$current' must be a nonnegative integer"
	7366	func_fatal_error "\`$vinfo' is not valid version information"
	7367	;;
	7368	esac
	7369
	7370	case $revision in
	7371	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]) ;;
	7372	*)
	7373	func_error "REVISION \`$revision' must be a nonnegative integer"
	7374	func_fatal_error "\`$vinfo' is not valid version information"
	7375	;;
	7376	esac
	7377
	7378	case $age in
	7379	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]) ;;
	7380	*)
	7381	func_error "AGE \`$age' must be a nonnegative integer"
	7382	func_fatal_error "\`$vinfo' is not valid version information"
	7383	;;
	7384	esac
	7385
	7386	if test "$age" -gt "$current"; then
	7387	func_error "AGE \`$age' is greater than the current interface number \`$current'"
	7388	func_fatal_error "\`$vinfo' is not valid version information"
	7389	fi
	7390
	7391	# Calculate the version variables.
	7392	major=
	7393	versuffix=
	7394	verstring=
	7395	case $version_type in
	7396	none) ;;
	7397
	7398	darwin)
	7399	# Like Linux, but with the current version available in
	7400	# verstring for coding it into the library header
	7401	func_arith $current - $age
	7402	major=.$func_arith_result
	7403	versuffix="$major.$age.$revision"
	7404	# Darwin ld doesn't like 0 for these options...
	7405	func_arith $current + 1
	7406	minor_current=$func_arith_result
	7407	xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
	7408	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
	7409	;;
	7410
	7411	freebsd-aout)
	7412	major=".$current"
	7413	versuffix=".$current.$revision";
	7414	;;
	7415
	7416	freebsd-elf)
	7417	major=".$current"
	7418	versuffix=".$current"
	7419	;;
	7420
	7421	irix \| nonstopux)
	7422	if test "X$lt_irix_increment" = "Xno"; then
	7423	func_arith $current - $age
	7424	else
	7425	func_arith $current - $age + 1
	7426	fi
	7427	major=$func_arith_result
	7428
	7429	case $version_type in
	7430	nonstopux) verstring_prefix=nonstopux ;;
	7431	*) verstring_prefix=sgi ;;
	7432	esac
	7433	verstring="$verstring_prefix$major.$revision"
	7434
	7435	# Add in all the interfaces that we are compatible with.
	7436	loop=$revision
	7437	while test "$loop" -ne 0; do
	7438	func_arith $revision - $loop
	7439	iface=$func_arith_result
	7440	func_arith $loop - 1
	7441	loop=$func_arith_result
	7442	verstring="$verstring_prefix$major.$iface:$verstring"
	7443	done
	7444
	7445	# Before this point, $major must not contain `.'.
	7446	major=.$major
	7447	versuffix="$major.$revision"
	7448	;;
	7449
	7450	linux) # correct to gnu/linux during the next big refactor
	7451	func_arith $current - $age
	7452	major=.$func_arith_result
	7453	versuffix="$major.$age.$revision"
	7454	;;
	7455
	7456	osf)
	7457	func_arith $current - $age
	7458	major=.$func_arith_result
	7459	versuffix=".$current.$age.$revision"
	7460	verstring="$current.$age.$revision"
	7461
	7462	# Add in all the interfaces that we are compatible with.
	7463	loop=$age
	7464	while test "$loop" -ne 0; do
	7465	func_arith $current - $loop
	7466	iface=$func_arith_result
	7467	func_arith $loop - 1
	7468	loop=$func_arith_result
	7469	verstring="$verstring:${iface}.0"
	7470	done
	7471
	7472	# Make executables depend on our current version.
	7473	func_append verstring ":${current}.0"
	7474	;;
	7475
	7476	qnx)
	7477	major=".$current"
	7478	versuffix=".$current"
	7479	;;
	7480
	7481	sunos)
	7482	major=".$current"
	7483	versuffix=".$current.$revision"
	7484	;;
	7485
	7486	windows)
	7487	# Use '-' rather than '.', since we only want one
	7488	# extension on DOS 8.3 filesystems.
	7489	func_arith $current - $age
	7490	major=$func_arith_result
	7491	versuffix="-$major"
	7492	;;
	7493
	7494	*)
	7495	func_fatal_configuration "unknown library version type \`$version_type'"
	7496	;;
	7497	esac
	7498
	7499	# Clear the version info if we defaulted, and they specified a release.
	7500	if test -z "$vinfo" && test -n "$release"; then
	7501	major=
	7502	case $version_type in
	7503	darwin)
	7504	# we can't check for "0.0" in archive_cmds due to quoting
	7505	# problems, so we reset it completely
	7506	verstring=
	7507	;;
	7508	*)
	7509	verstring="0.0"
	7510	;;
	7511	esac
	7512	if test "$need_version" = no; then
	7513	versuffix=
	7514	else
	7515	versuffix=".0.0"
	7516	fi
	7517	fi
	7518
	7519	# Remove version info from name if versioning should be avoided
	7520	if test "$avoid_version" = yes && test "$need_version" = no; then
	7521	major=
	7522	versuffix=
	7523	verstring=""
	7524	fi
	7525
	7526	# Check to see if the archive will have undefined symbols.
	7527	if test "$allow_undefined" = yes; then
	7528	if test "$allow_undefined_flag" = unsupported; then
	7529	func_warning "undefined symbols not allowed in $host shared libraries"
	7530	build_libtool_libs=no
	7531	build_old_libs=yes
	7532	fi
	7533	else
	7534	# Don't allow undefined symbols.
	7535	allow_undefined_flag="$no_undefined_flag"
	7536	fi
	7537
	7538	fi
	7539
	7540	func_generate_dlsyms "$libname" "$libname" "yes"
	7541	func_append libobjs " $symfileobj"
	7542	test "X$libobjs" = "X " && libobjs=
	7543
	7544	if test "$opt_mode" != relink; then
	7545	# Remove our outputs, but don't remove object files since they
	7546	# may have been created when compiling PIC objects.
	7547	removelist=
	7548	tempremovelist=`$ECHO "$output_objdir/*"`
	7549	for p in $tempremovelist; do
	7550	case $p in
	7551	.$objext \| .gcno)
	7552	;;
	7553	$output_objdir/$outputname \| $output_objdir/$libname.* \| $output_objdir/${libname}${release}.*)
	7554	if test "X$precious_files_regex" != "X"; then
	7555	if $ECHO "$p" \| $EGREP -e "$precious_files_regex" >/dev/null 2>&1
	7556	then
	7557	continue
	7558	fi
	7559	fi
	7560	func_append removelist " $p"
	7561	;;
	7562	*) ;;
	7563	esac
	7564	done
	7565	test -n "$removelist" && \
	7566	func_show_eval "${RM}r \$removelist"
	7567	fi
	7568
	7569	# Now set the variables for building old libraries.
	7570	if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
	7571	func_append oldlibs " $output_objdir/$libname.$libext"
	7572
	7573	# Transform .lo files to .o files.
	7574	oldobjs="$objs "`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.${libext}$/d; $lo2o" \| $NL2SP`
	7575	fi
	7576
	7577	# Eliminate all temporary directories.
	7578	#for path in $notinst_path; do
	7579	# lib_search_path=`$ECHO "$lib_search_path " \| $SED "s% $path % %g"`
	7580	# deplibs=`$ECHO "$deplibs " \| $SED "s% -L$path % %g"`
	7581	# dependency_libs=`$ECHO "$dependency_libs " \| $SED "s% -L$path % %g"`
	7582	#done
	7583
	7584	if test -n "$xrpath"; then
	7585	# If the user specified any rpath flags, then add them.
	7586	temp_xrpath=
	7587	for libdir in $xrpath; do
	7588	func_replace_sysroot "$libdir"
	7589	func_append temp_xrpath " -R$func_replace_sysroot_result"
	7590	case "$finalize_rpath " in
	7591	" $libdir ") ;;
	7592	*) func_append finalize_rpath " $libdir" ;;
	7593	esac
	7594	done
	7595	if test "$hardcode_into_libs" != yes \|\| test "$build_old_libs" = yes; then
	7596	dependency_libs="$temp_xrpath $dependency_libs"
	7597	fi
	7598	fi
	7599
	7600	# Make sure dlfiles contains only unique files that won't be dlpreopened
	7601	old_dlfiles="$dlfiles"
	7602	dlfiles=
	7603	for lib in $old_dlfiles; do
	7604	case " $dlprefiles $dlfiles " in
	7605	" $lib ") ;;
	7606	*) func_append dlfiles " $lib" ;;
	7607	esac
	7608	done
	7609
	7610	# Make sure dlprefiles contains only unique files
	7611	old_dlprefiles="$dlprefiles"
	7612	dlprefiles=
	7613	for lib in $old_dlprefiles; do
	7614	case "$dlprefiles " in
	7615	" $lib ") ;;
	7616	*) func_append dlprefiles " $lib" ;;
	7617	esac
	7618	done
	7619
	7620	if test "$build_libtool_libs" = yes; then
	7621	if test -n "$rpath"; then
	7622	case $host in
	7623	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --beos* \| -cegcc \| --haiku*)
	7624	# these systems don't actually have a c library (as such)!
	7625	;;
	7626	--rhapsody* \| --darwin1.[012])
	7627	# Rhapsody C library is in the System framework
	7628	func_append deplibs " System.ltframework"
	7629	;;
	7630	--netbsd*)
	7631	# Don't link with libc until the a.out ld.so is fixed.
	7632	;;
	7633	--openbsd* \| --freebsd* \| --dragonfly*)
	7634	# Do not include libc due to us having libc/libc_r.
	7635	;;
	7636	--sco3.2v5* \| --sco5v6*)
	7637	# Causes problems with __ctype
	7638	;;
	7639	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
	7640	# Compiler inserts libc in the correct place for threads to work
	7641	;;
	7642	*)
	7643	# Add libc to deplibs on all other systems if necessary.
	7644	if test "$build_libtool_need_lc" = "yes"; then
	7645	func_append deplibs " -lc"
	7646	fi
	7647	;;
	7648	esac
	7649	fi
	7650
	7651	# Transform deplibs into only deplibs that can be linked in shared.
	7652	name_save=$name
	7653	libname_save=$libname
	7654	release_save=$release
	7655	versuffix_save=$versuffix
	7656	major_save=$major
	7657	# I'm not sure if I'm treating the release correctly. I think
	7658	# release should show up in the -l (ie -lgmp5) so we don't want to
	7659	# add it in twice. Is that correct?
	7660	release=""
	7661	versuffix=""
	7662	major=""
	7663	newdeplibs=
	7664	droppeddeps=no
	7665	case $deplibs_check_method in
	7666	pass_all)
	7667	# Don't check for shared/static. Everything works.
	7668	# This might be a little naive. We might want to check
	7669	# whether the library exists or not. But this is on
	7670	# osf3 & osf4 and I'm not really sure... Just
	7671	# implementing what was already the behavior.
	7672	newdeplibs=$deplibs
	7673	;;
	7674	test_compile)
	7675	# This code stresses the "libraries are programs" paradigm to its
	7676	# limits. Maybe even breaks it. We compile a program, linking it
	7677	# against the deplibs as a proxy for the library. Then we can check
	7678	# whether they linked in statically or dynamically with ldd.
	7679	$opt_dry_run \|\| $RM conftest.c
	7680	cat > conftest.c <<EOF
	7681	int main() { return 0; }
	7682	EOF
	7683	$opt_dry_run \|\| $RM conftest
	7684	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
	7685	ldd_output=`ldd conftest`
	7686	for i in $deplibs; do
	7687	case $i in
	7688	-l*)
	7689	func_stripname -l '' "$i"
	7690	name=$func_stripname_result
	7691	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	7692	case " $predeps $postdeps " in
	7693	" $i ")
	7694	func_append newdeplibs " $i"
	7695	i=""
	7696	;;
	7697	esac
	7698	fi
	7699	if test -n "$i" ; then
	7700	libname=`eval "\\$ECHO \"$libname_spec\""`
	7701	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
	7702	set dummy $deplib_matches; shift
	7703	deplib_match=$1
	7704	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
	7705	func_append newdeplibs " $i"
	7706	else
	7707	droppeddeps=yes
	7708	echo
	7709	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
	7710	echo "*** I have the capability to make that library automatically link in when"
	7711	echo "*** you link to this library. But I can only do this if you have a"
	7712	echo "*** shared version of the library, which I believe you do not have"
	7713	echo "*** because a test_compile did reveal that the linker did not use it for"
	7714	echo "*** its dynamic dependency list that programs get resolved with at runtime."
	7715	fi
	7716	fi
	7717	;;
	7718	*)
	7719	func_append newdeplibs " $i"
	7720	;;
	7721	esac
	7722	done
	7723	else
	7724	# Error occurred in the first compile. Let's try to salvage
	7725	# the situation: Compile a separate program for each library.
	7726	for i in $deplibs; do
	7727	case $i in
	7728	-l*)
	7729	func_stripname -l '' "$i"
	7730	name=$func_stripname_result
	7731	$opt_dry_run \|\| $RM conftest
	7732	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
	7733	ldd_output=`ldd conftest`
	7734	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	7735	case " $predeps $postdeps " in
	7736	" $i ")
	7737	func_append newdeplibs " $i"
	7738	i=""
	7739	;;
	7740	esac
	7741	fi
	7742	if test -n "$i" ; then
	7743	libname=`eval "\\$ECHO \"$libname_spec\""`
	7744	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
	7745	set dummy $deplib_matches; shift
	7746	deplib_match=$1
	7747	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
	7748	func_append newdeplibs " $i"
	7749	else
	7750	droppeddeps=yes
	7751	echo
	7752	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
	7753	echo "*** I have the capability to make that library automatically link in when"
	7754	echo "*** you link to this library. But I can only do this if you have a"
	7755	echo "*** shared version of the library, which you do not appear to have"
	7756	echo "*** because a test_compile did reveal that the linker did not use this one"
	7757	echo "*** as a dynamic dependency that programs can get resolved with at runtime."
	7758	fi
	7759	fi
	7760	else
	7761	droppeddeps=yes
	7762	echo
	7763	$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
	7764	echo "*** make it link in! You will probably need to install it or some"
	7765	echo "*** library that it depends on before this library will be fully"
	7766	echo "*** functional. Installing it before continuing would be even better."
	7767	fi
	7768	;;
	7769	*)
	7770	func_append newdeplibs " $i"
	7771	;;
	7772	esac
	7773	done
	7774	fi
	7775	;;
	7776	file_magic*)
	7777	set dummy $deplibs_check_method; shift
	7778	file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
	7779	for a_deplib in $deplibs; do
	7780	case $a_deplib in
	7781	-l*)
	7782	func_stripname -l '' "$a_deplib"
	7783	name=$func_stripname_result
	7784	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	7785	case " $predeps $postdeps " in
	7786	" $a_deplib ")
	7787	func_append newdeplibs " $a_deplib"
	7788	a_deplib=""
	7789	;;
	7790	esac
	7791	fi
	7792	if test -n "$a_deplib" ; then
	7793	libname=`eval "\\$ECHO \"$libname_spec\""`
	7794	if test -n "$file_magic_glob"; then
	7795	libnameglob=`func_echo_all "$libname" \| $SED -e $file_magic_glob`
	7796	else
	7797	libnameglob=$libname
	7798	fi
	7799	test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
	7800	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
	7801	if test "$want_nocaseglob" = yes; then
	7802	shopt -s nocaseglob
	7803	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
	7804	$nocaseglob
	7805	else
	7806	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
	7807	fi
	7808	for potent_lib in $potential_libs; do
	7809	# Follow soft links.
	7810	if ls -lLd "$potent_lib" 2>/dev/null \|
	7811	$GREP " -> " >/dev/null; then
	7812	continue
	7813	fi
	7814	# The statement above tries to avoid entering an
	7815	# endless loop below, in case of cyclic links.
	7816	# We might still enter an endless loop, since a link
	7817	# loop can be closed while we follow links,
	7818	# but so what?
	7819	potlib="$potent_lib"
	7820	while test -h "$potlib" 2>/dev/null; do
	7821	potliblink=`ls -ld $potlib \| ${SED} 's/.* -> //'`
	7822	case $potliblink in
	7823	[\\/]* \| [A-Za-z]:[\\/]*) potlib="$potliblink";;
	7824	) potlib=`$ECHO "$potlib" \| $SED 's,[^/]$,,'`"$potliblink";;
	7825	esac
	7826	done
	7827	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \|
	7828	$SED -e 10q \|
	7829	$EGREP "$file_magic_regex" > /dev/null; then
	7830	func_append newdeplibs " $a_deplib"
	7831	a_deplib=""
	7832	break 2
	7833	fi
	7834	done
	7835	done
	7836	fi
	7837	if test -n "$a_deplib" ; then
	7838	droppeddeps=yes
	7839	echo
	7840	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
	7841	echo "*** I have the capability to make that library automatically link in when"
	7842	echo "*** you link to this library. But I can only do this if you have a"
	7843	echo "*** shared version of the library, which you do not appear to have"
	7844	echo "*** because I did check the linker path looking for a file starting"
	7845	if test -z "$potlib" ; then
	7846	$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
	7847	else
	7848	$ECHO "*** with $libname and none of the candidates passed a file format test"
	7849	$ECHO "*** using a file magic. Last file checked: $potlib"
	7850	fi
	7851	fi
	7852	;;
	7853	*)
	7854	# Add a -L argument.
	7855	func_append newdeplibs " $a_deplib"
	7856	;;
	7857	esac
	7858	done # Gone through all deplibs.
	7859	;;
	7860	match_pattern*)
	7861	set dummy $deplibs_check_method; shift
	7862	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
	7863	for a_deplib in $deplibs; do
	7864	case $a_deplib in
	7865	-l*)
	7866	func_stripname -l '' "$a_deplib"
	7867	name=$func_stripname_result
	7868	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	7869	case " $predeps $postdeps " in
	7870	" $a_deplib ")
	7871	func_append newdeplibs " $a_deplib"
	7872	a_deplib=""
	7873	;;
	7874	esac
	7875	fi
	7876	if test -n "$a_deplib" ; then
	7877	libname=`eval "\\$ECHO \"$libname_spec\""`
	7878	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
	7879	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
	7880	for potent_lib in $potential_libs; do
	7881	potlib="$potent_lib" # see symlink-check above in file_magic test
	7882	if eval "\$ECHO \"$potent_lib\"" 2>/dev/null \| $SED 10q \| \
	7883	$EGREP "$match_pattern_regex" > /dev/null; then
	7884	func_append newdeplibs " $a_deplib"
	7885	a_deplib=""
	7886	break 2
	7887	fi
	7888	done
	7889	done
	7890	fi
	7891	if test -n "$a_deplib" ; then
	7892	droppeddeps=yes
	7893	echo
	7894	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
	7895	echo "*** I have the capability to make that library automatically link in when"
	7896	echo "*** you link to this library. But I can only do this if you have a"
	7897	echo "*** shared version of the library, which you do not appear to have"
	7898	echo "*** because I did check the linker path looking for a file starting"
	7899	if test -z "$potlib" ; then
	7900	$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
	7901	else
	7902	$ECHO "*** with $libname and none of the candidates passed a file format test"
	7903	$ECHO "*** using a regex pattern. Last file checked: $potlib"
	7904	fi
	7905	fi
	7906	;;
	7907	*)
	7908	# Add a -L argument.
	7909	func_append newdeplibs " $a_deplib"
	7910	;;
	7911	esac
	7912	done # Gone through all deplibs.
	7913	;;
	7914	none \| unknown \| *)
	7915	newdeplibs=""
	7916	tmp_deplibs=`$ECHO " $deplibs" \| $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
	7917	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	7918	for i in $predeps $postdeps ; do
	7919	# can't use Xsed below, because $i might contain '/'
	7920	tmp_deplibs=`$ECHO " $tmp_deplibs" \| $SED "s,$i,,"`
	7921	done
	7922	fi
	7923	case $tmp_deplibs in
	7924	[!\ \ ])
	7925	echo
	7926	if test "X$deplibs_check_method" = "Xnone"; then
	7927	echo "*** Warning: inter-library dependencies are not supported in this platform."
	7928	else
	7929	echo "*** Warning: inter-library dependencies are not known to be supported."
	7930	fi
	7931	echo "*** All declared inter-library dependencies are being dropped."
	7932	droppeddeps=yes
	7933	;;
	7934	esac
	7935	;;
	7936	esac
	7937	versuffix=$versuffix_save
	7938	major=$major_save
	7939	release=$release_save
	7940	libname=$libname_save
	7941	name=$name_save
	7942
	7943	case $host in
	7944	--rhapsody* \| --darwin1.[012])
	7945	# On Rhapsody replace the C library with the System framework
	7946	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's/ -lc / System.ltframework /'`
	7947	;;
	7948	esac
	7949
	7950	if test "$droppeddeps" = yes; then
	7951	if test "$module" = yes; then
	7952	echo
	7953	echo "*** Warning: libtool could not satisfy all declared inter-library"
	7954	$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
	7955	echo "*** a static module, that should work as long as the dlopening"
	7956	echo "*** application is linked with the -dlopen flag."
	7957	if test -z "$global_symbol_pipe"; then
	7958	echo
	7959	echo "*** However, this would only work if libtool was able to extract symbol"
	7960	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	7961	echo "*** not find such a program. So, this module is probably useless."
	7962	echo "*** \`nm' from GNU binutils and a full rebuild may help."
	7963	fi
	7964	if test "$build_old_libs" = no; then
	7965	oldlibs="$output_objdir/$libname.$libext"
	7966	build_libtool_libs=module
	7967	build_old_libs=yes
	7968	else
	7969	build_libtool_libs=no
	7970	fi
	7971	else
	7972	echo "*** The inter-library dependencies that have been dropped here will be"
	7973	echo "*** automatically added whenever a program is linked with this library"
	7974	echo "*** or is declared to -dlopen it."
	7975
	7976	if test "$allow_undefined" = no; then
	7977	echo
	7978	echo "*** Since this library must not contain undefined symbols,"
	7979	echo "*** because either the platform does not support them or"
	7980	echo "*** it was explicitly requested with -no-undefined,"
	7981	echo "*** libtool will only create a static version of it."
	7982	if test "$build_old_libs" = no; then
	7983	oldlibs="$output_objdir/$libname.$libext"
	7984	build_libtool_libs=module
	7985	build_old_libs=yes
	7986	else
	7987	build_libtool_libs=no
	7988	fi
	7989	fi
	7990	fi
	7991	fi
	7992	# Done checking deplibs!
	7993	deplibs=$newdeplibs
	7994	fi
	7995	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
	7996	case $host in
	7997	--darwin*)
	7998	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	7999	new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	8000	deplibs=`$ECHO " $deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	8001	;;
	8002	esac
	8003
	8004	# move library search paths that coincide with paths to not yet
	8005	# installed libraries to the beginning of the library search list
	8006	new_libs=
	8007	for path in $notinst_path; do
	8008	case " $new_libs " in
	8009	" -L$path/$objdir ") ;;
	8010	*)
	8011	case " $deplibs " in
	8012	" -L$path/$objdir ")
	8013	func_append new_libs " -L$path/$objdir" ;;
	8014	esac
	8015	;;
	8016	esac
	8017	done
	8018	for deplib in $deplibs; do
	8019	case $deplib in
	8020	-L*)
	8021	case " $new_libs " in
	8022	" $deplib ") ;;
	8023	*) func_append new_libs " $deplib" ;;
	8024	esac
	8025	;;
	8026	*) func_append new_libs " $deplib" ;;
	8027	esac
	8028	done
	8029	deplibs="$new_libs"
	8030
	8031	# All the library-specific variables (install_libdir is set above).
	8032	library_names=
	8033	old_library=
	8034	dlname=
	8035
	8036	# Test again, we may have decided not to build it any more
	8037	if test "$build_libtool_libs" = yes; then
	8038	# Remove ${wl} instances when linking with ld.
	8039	# FIXME: should test the right _cmds variable.
	8040	case $archive_cmds in
	8041	\$LD\ ) wl= ;;
	8042	esac
	8043	if test "$hardcode_into_libs" = yes; then
	8044	# Hardcode the library paths
	8045	hardcode_libdirs=
	8046	dep_rpath=
	8047	rpath="$finalize_rpath"
	8048	test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
	8049	for libdir in $rpath; do
	8050	if test -n "$hardcode_libdir_flag_spec"; then
	8051	if test -n "$hardcode_libdir_separator"; then
	8052	func_replace_sysroot "$libdir"
	8053	libdir=$func_replace_sysroot_result
	8054	if test -z "$hardcode_libdirs"; then
	8055	hardcode_libdirs="$libdir"
	8056	else
	8057	# Just accumulate the unique libdirs.
	8058	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	8059	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	8060	;;
	8061	*)
	8062	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
	8063	;;
	8064	esac
	8065	fi
	8066	else
	8067	eval flag=\"$hardcode_libdir_flag_spec\"
	8068	func_append dep_rpath " $flag"
	8069	fi
	8070	elif test -n "$runpath_var"; then
	8071	case "$perm_rpath " in
	8072	" $libdir ") ;;
	8073	*) func_append perm_rpath " $libdir" ;;
	8074	esac
	8075	fi
	8076	done
	8077	# Substitute the hardcoded libdirs into the rpath.
	8078	if test -n "$hardcode_libdir_separator" &&
	8079	test -n "$hardcode_libdirs"; then
	8080	libdir="$hardcode_libdirs"
	8081	eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
	8082	fi
	8083	if test -n "$runpath_var" && test -n "$perm_rpath"; then
	8084	# We should set the runpath_var.
	8085	rpath=
	8086	for dir in $perm_rpath; do
	8087	func_append rpath "$dir:"
	8088	done
	8089	eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
	8090	fi
	8091	test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
	8092	fi
	8093
	8094	shlibpath="$finalize_shlibpath"
	8095	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
	8096	if test -n "$shlibpath"; then
	8097	eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
	8098	fi
	8099
	8100	# Get the real and link names of the library.
	8101	eval shared_ext=\"$shrext_cmds\"
	8102	eval library_names=\"$library_names_spec\"
	8103	set dummy $library_names
	8104	shift
	8105	realname="$1"
	8106	shift
	8107
	8108	if test -n "$soname_spec"; then
	8109	eval soname=\"$soname_spec\"
	8110	else
	8111	soname="$realname"
	8112	fi
	8113	if test -z "$dlname"; then
	8114	dlname=$soname
	8115	fi
	8116
	8117	lib="$output_objdir/$realname"
	8118	linknames=
	8119	for link
	8120	do
	8121	func_append linknames " $link"
	8122	done
	8123
	8124	# Use standard objects if they are pic
	8125	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
	8126	test "X$libobjs" = "X " && libobjs=
	8127
	8128	delfiles=
	8129	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	8130	$opt_dry_run \|\| cp "$export_symbols" "$output_objdir/$libname.uexp"
	8131	export_symbols="$output_objdir/$libname.uexp"
	8132	func_append delfiles " $export_symbols"
	8133	fi
	8134
	8135	orig_export_symbols=
	8136	case $host_os in
	8137	cygwin* \| mingw* \| cegcc*)
	8138	if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
	8139	# exporting using user supplied symfile
	8140	if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
	8141	# and it's NOT already a .def file. Must figure out
	8142	# which of the given symbols are data symbols and tag
	8143	# them as such. So, trigger use of export_symbols_cmds.
	8144	# export_symbols gets reassigned inside the "prepare
	8145	# the list of exported symbols" if statement, so the
	8146	# include_expsyms logic still works.
	8147	orig_export_symbols="$export_symbols"
	8148	export_symbols=
	8149	always_export_symbols=yes
	8150	fi
	8151	fi
	8152	;;
	8153	esac
	8154
	8155	# Prepare the list of exported symbols
	8156	if test -z "$export_symbols"; then
	8157	if test "$always_export_symbols" = yes \|\| test -n "$export_symbols_regex"; then
	8158	func_verbose "generating symbol list for \`$libname.la'"
	8159	export_symbols="$output_objdir/$libname.exp"
	8160	$opt_dry_run \|\| $RM $export_symbols
	8161	cmds=$export_symbols_cmds
	8162	save_ifs="$IFS"; IFS='~'
	8163	for cmd1 in $cmds; do
	8164	IFS="$save_ifs"
	8165	# Take the normal branch if the nm_file_list_spec branch
	8166	# doesn't work or if tool conversion is not needed.
	8167	case $nm_file_list_spec~$to_tool_file_cmd in
	8168	~func_convert_file_noop \| ~func_convert_file_msys_to_w32 \| ~*)
	8169	try_normal_branch=yes
	8170	eval cmd=\"$cmd1\"
	8171	func_len " $cmd"
	8172	len=$func_len_result
	8173	;;
	8174	*)
	8175	try_normal_branch=no
	8176	;;
	8177	esac
	8178	if test "$try_normal_branch" = yes \
	8179	&& { test "$len" -lt "$max_cmd_len" \
	8180	\|\| test "$max_cmd_len" -le -1; }
	8181	then
	8182	func_show_eval "$cmd" 'exit $?'
	8183	skipped_export=false
	8184	elif test -n "$nm_file_list_spec"; then
	8185	func_basename "$output"
	8186	output_la=$func_basename_result
	8187	save_libobjs=$libobjs
	8188	save_output=$output
	8189	output=${output_objdir}/${output_la}.nm
	8190	func_to_tool_file "$output"
	8191	libobjs=$nm_file_list_spec$func_to_tool_file_result
	8192	func_append delfiles " $output"
	8193	func_verbose "creating $NM input file list: $output"
	8194	for obj in $save_libobjs; do
	8195	func_to_tool_file "$obj"
	8196	$ECHO "$func_to_tool_file_result"
	8197	done > "$output"
	8198	eval cmd=\"$cmd1\"
	8199	func_show_eval "$cmd" 'exit $?'
	8200	output=$save_output
	8201	libobjs=$save_libobjs
	8202	skipped_export=false
	8203	else
	8204	# The command line is too long to execute in one step.
	8205	func_verbose "using reloadable object file for export list..."
	8206	skipped_export=:
	8207	# Break out early, otherwise skipped_export may be
	8208	# set to false by a later but shorter cmd.
	8209	break
	8210	fi
	8211	done
	8212	IFS="$save_ifs"
	8213	if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
	8214	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
	8215	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
	8216	fi
	8217	fi
	8218	fi
	8219
	8220	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	8221	tmp_export_symbols="$export_symbols"
	8222	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
	8223	$opt_dry_run \|\| eval '$ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"'
	8224	fi
	8225
	8226	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
	8227	# The given exports_symbols file has to be filtered, so filter it.
	8228	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
	8229	# FIXME: $output_objdir/$libname.filter potentially contains lots of
	8230	# 's' commands which not all seds can handle. GNU sed should be fine
	8231	# though. Also, the filter scales superlinearly with the number of
	8232	# global variables. join(1) would be nice here, but unfortunately
	8233	# isn't a blessed tool.
	8234	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
	8235	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
	8236	export_symbols=$output_objdir/$libname.def
	8237	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
	8238	fi
	8239
	8240	tmp_deplibs=
	8241	for test_deplib in $deplibs; do
	8242	case " $convenience " in
	8243	" $test_deplib ") ;;
	8244	*)
	8245	func_append tmp_deplibs " $test_deplib"
	8246	;;
	8247	esac
	8248	done
	8249	deplibs="$tmp_deplibs"
	8250
	8251	if test -n "$convenience"; then
	8252	if test -n "$whole_archive_flag_spec" &&
	8253	test "$compiler_needs_object" = yes &&
	8254	test -z "$libobjs"; then
	8255	# extract the archives, so we have objects to list.
	8256	# TODO: could optimize this to just extract one archive.
	8257	whole_archive_flag_spec=
	8258	fi
	8259	if test -n "$whole_archive_flag_spec"; then
	8260	save_libobjs=$libobjs
	8261	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	8262	test "X$libobjs" = "X " && libobjs=
	8263	else
	8264	gentop="$output_objdir/${outputname}x"
	8265	func_append generated " $gentop"
	8266
	8267	func_extract_archives $gentop $convenience
	8268	func_append libobjs " $func_extract_archives_result"
	8269	test "X$libobjs" = "X " && libobjs=
	8270	fi
	8271	fi
	8272
	8273	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
	8274	eval flag=\"$thread_safe_flag_spec\"
	8275	func_append linker_flags " $flag"
	8276	fi
	8277
	8278	# Make a backup of the uninstalled library when relinking
	8279	if test "$opt_mode" = relink; then
	8280	$opt_dry_run \|\| eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' \|\| exit $?
	8281	fi
	8282
	8283	# Do each of the archive commands.
	8284	if test "$module" = yes && test -n "$module_cmds" ; then
	8285	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	8286	eval test_cmds=\"$module_expsym_cmds\"
	8287	cmds=$module_expsym_cmds
	8288	else
	8289	eval test_cmds=\"$module_cmds\"
	8290	cmds=$module_cmds
	8291	fi
	8292	else
	8293	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	8294	eval test_cmds=\"$archive_expsym_cmds\"
	8295	cmds=$archive_expsym_cmds
	8296	else
	8297	eval test_cmds=\"$archive_cmds\"
	8298	cmds=$archive_cmds
	8299	fi
	8300	fi
	8301
	8302	if test "X$skipped_export" != "X:" &&
	8303	func_len " $test_cmds" &&
	8304	len=$func_len_result &&
	8305	test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
	8306	:
	8307	else
	8308	# The command line is too long to link in one step, link piecewise
	8309	# or, if using GNU ld and skipped_export is not :, use a linker
	8310	# script.
	8311
	8312	# Save the value of $output and $libobjs because we want to
	8313	# use them later. If we have whole_archive_flag_spec, we
	8314	# want to use save_libobjs as it was before
	8315	# whole_archive_flag_spec was expanded, because we can't
	8316	# assume the linker understands whole_archive_flag_spec.
	8317	# This may have to be revisited, in case too many
	8318	# convenience libraries get linked in and end up exceeding
	8319	# the spec.
	8320	if test -z "$convenience" \|\| test -z "$whole_archive_flag_spec"; then
	8321	save_libobjs=$libobjs
	8322	fi
	8323	save_output=$output
	8324	func_basename "$output"
	8325	output_la=$func_basename_result
	8326
	8327	# Clear the reloadable object creation command queue and
	8328	# initialize k to one.
	8329	test_cmds=
	8330	concat_cmds=
	8331	objlist=
	8332	last_robj=
	8333	k=1
	8334
	8335	if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
	8336	output=${output_objdir}/${output_la}.lnkscript
	8337	func_verbose "creating GNU ld script: $output"
	8338	echo 'INPUT (' > $output
	8339	for obj in $save_libobjs
	8340	do
	8341	func_to_tool_file "$obj"
	8342	$ECHO "$func_to_tool_file_result" >> $output
	8343	done
	8344	echo ')' >> $output
	8345	func_append delfiles " $output"
	8346	func_to_tool_file "$output"
	8347	output=$func_to_tool_file_result
	8348	elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
	8349	output=${output_objdir}/${output_la}.lnk
	8350	func_verbose "creating linker input file list: $output"
	8351	: > $output
	8352	set x $save_libobjs
	8353	shift
	8354	firstobj=
	8355	if test "$compiler_needs_object" = yes; then
	8356	firstobj="$1 "
	8357	shift
	8358	fi
	8359	for obj
	8360	do
	8361	func_to_tool_file "$obj"
	8362	$ECHO "$func_to_tool_file_result" >> $output
	8363	done
	8364	func_append delfiles " $output"
	8365	func_to_tool_file "$output"
	8366	output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
	8367	else
	8368	if test -n "$save_libobjs"; then
	8369	func_verbose "creating reloadable object files..."
	8370	output=$output_objdir/$output_la-${k}.$objext
	8371	eval test_cmds=\"$reload_cmds\"
	8372	func_len " $test_cmds"
	8373	len0=$func_len_result
	8374	len=$len0
	8375
	8376	# Loop over the list of objects to be linked.
	8377	for obj in $save_libobjs
	8378	do
	8379	func_len " $obj"
	8380	func_arith $len + $func_len_result
	8381	len=$func_arith_result
	8382	if test "X$objlist" = X \|\|
	8383	test "$len" -lt "$max_cmd_len"; then
	8384	func_append objlist " $obj"
	8385	else
	8386	# The command $test_cmds is almost too long, add a
	8387	# command to the queue.
	8388	if test "$k" -eq 1 ; then
	8389	# The first file doesn't have a previous command to add.
	8390	reload_objs=$objlist
	8391	eval concat_cmds=\"$reload_cmds\"
	8392	else
	8393	# All subsequent reloadable object files will link in
	8394	# the last one created.
	8395	reload_objs="$objlist $last_robj"
	8396	eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
	8397	fi
	8398	last_robj=$output_objdir/$output_la-${k}.$objext
	8399	func_arith $k + 1
	8400	k=$func_arith_result
	8401	output=$output_objdir/$output_la-${k}.$objext
	8402	objlist=" $obj"
	8403	func_len " $last_robj"
	8404	func_arith $len0 + $func_len_result
	8405	len=$func_arith_result
	8406	fi
	8407	done
	8408	# Handle the remaining objects by creating one last
	8409	# reloadable object file. All subsequent reloadable object
	8410	# files will link in the last one created.
	8411	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
	8412	reload_objs="$objlist $last_robj"
	8413	eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
	8414	if test -n "$last_robj"; then
	8415	eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
	8416	fi
	8417	func_append delfiles " $output"
	8418
	8419	else
	8420	output=
	8421	fi
	8422
	8423	if ${skipped_export-false}; then
	8424	func_verbose "generating symbol list for \`$libname.la'"
	8425	export_symbols="$output_objdir/$libname.exp"
	8426	$opt_dry_run \|\| $RM $export_symbols
	8427	libobjs=$output
	8428	# Append the command to create the export file.
	8429	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
	8430	eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
	8431	if test -n "$last_robj"; then
	8432	eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
	8433	fi
	8434	fi
	8435
	8436	test -n "$save_libobjs" &&
	8437	func_verbose "creating a temporary reloadable object file: $output"
	8438
	8439	# Loop through the commands generated above and execute them.
	8440	save_ifs="$IFS"; IFS='~'
	8441	for cmd in $concat_cmds; do
	8442	IFS="$save_ifs"
	8443	$opt_silent \|\| {
	8444	func_quote_for_expand "$cmd"
	8445	eval "func_echo $func_quote_for_expand_result"
	8446	}
	8447	$opt_dry_run \|\| eval "$cmd" \|\| {
	8448	lt_exit=$?
	8449
	8450	# Restore the uninstalled library and exit
	8451	if test "$opt_mode" = relink; then
	8452	( cd "$output_objdir" && \
	8453	$RM "${realname}T" && \
	8454	$MV "${realname}U" "$realname" )
	8455	fi
	8456
	8457	exit $lt_exit
	8458	}
	8459	done
	8460	IFS="$save_ifs"
	8461
	8462	if test -n "$export_symbols_regex" && ${skipped_export-false}; then
	8463	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
	8464	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
	8465	fi
	8466	fi
	8467
	8468	if ${skipped_export-false}; then
	8469	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	8470	tmp_export_symbols="$export_symbols"
	8471	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
	8472	$opt_dry_run \|\| eval '$ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"'
	8473	fi
	8474
	8475	if test -n "$orig_export_symbols"; then
	8476	# The given exports_symbols file has to be filtered, so filter it.
	8477	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
	8478	# FIXME: $output_objdir/$libname.filter potentially contains lots of
	8479	# 's' commands which not all seds can handle. GNU sed should be fine
	8480	# though. Also, the filter scales superlinearly with the number of
	8481	# global variables. join(1) would be nice here, but unfortunately
	8482	# isn't a blessed tool.
	8483	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
	8484	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
	8485	export_symbols=$output_objdir/$libname.def
	8486	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
	8487	fi
	8488	fi
	8489
	8490	libobjs=$output
	8491	# Restore the value of output.
	8492	output=$save_output
	8493
	8494	if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
	8495	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	8496	test "X$libobjs" = "X " && libobjs=
	8497	fi
	8498	# Expand the library linking commands again to reset the
	8499	# value of $libobjs for piecewise linking.
	8500
	8501	# Do each of the archive commands.
	8502	if test "$module" = yes && test -n "$module_cmds" ; then
	8503	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	8504	cmds=$module_expsym_cmds
	8505	else
	8506	cmds=$module_cmds
	8507	fi
	8508	else
	8509	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	8510	cmds=$archive_expsym_cmds
	8511	else
	8512	cmds=$archive_cmds
	8513	fi
	8514	fi
	8515	fi
	8516
	8517	if test -n "$delfiles"; then
	8518	# Append the command to remove temporary files to $cmds.
	8519	eval cmds=\"\$cmds~\$RM $delfiles\"
	8520	fi
	8521
	8522	# Add any objects from preloaded convenience libraries
	8523	if test -n "$dlprefiles"; then
	8524	gentop="$output_objdir/${outputname}x"
	8525	func_append generated " $gentop"
	8526
	8527	func_extract_archives $gentop $dlprefiles
	8528	func_append libobjs " $func_extract_archives_result"
	8529	test "X$libobjs" = "X " && libobjs=
	8530	fi
	8531
	8532	save_ifs="$IFS"; IFS='~'
	8533	for cmd in $cmds; do
	8534	IFS="$save_ifs"
	8535	eval cmd=\"$cmd\"
	8536	$opt_silent \|\| {
	8537	func_quote_for_expand "$cmd"
	8538	eval "func_echo $func_quote_for_expand_result"
	8539	}
	8540	$opt_dry_run \|\| eval "$cmd" \|\| {
	8541	lt_exit=$?
	8542
	8543	# Restore the uninstalled library and exit
	8544	if test "$opt_mode" = relink; then
	8545	( cd "$output_objdir" && \
	8546	$RM "${realname}T" && \
	8547	$MV "${realname}U" "$realname" )
	8548	fi
	8549
	8550	exit $lt_exit
	8551	}
	8552	done
	8553	IFS="$save_ifs"
	8554
	8555	# Restore the uninstalled library and exit
	8556	if test "$opt_mode" = relink; then
	8557	$opt_dry_run \|\| eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' \|\| exit $?
	8558
	8559	if test -n "$convenience"; then
	8560	if test -z "$whole_archive_flag_spec"; then
	8561	func_show_eval '${RM}r "$gentop"'
	8562	fi
	8563	fi
	8564
	8565	exit $EXIT_SUCCESS
	8566	fi
	8567
	8568	# Create links to the real library.
	8569	for linkname in $linknames; do
	8570	if test "$realname" != "$linkname"; then
	8571	func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
	8572	fi
	8573	done
	8574
	8575	# If -module or -export-dynamic was specified, set the dlname.
	8576	if test "$module" = yes \|\| test "$export_dynamic" = yes; then
	8577	# On all known operating systems, these are identical.
	8578	dlname="$soname"
	8579	fi
	8580	fi
	8581	;;
	8582
	8583	obj)
	8584	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	8585	func_warning "\`-dlopen' is ignored for objects"
	8586	fi
	8587
	8588	case " $deplibs" in
	8589	\ -l \| \ -L)
	8590	func_warning "\`-l' and \`-L' are ignored for objects" ;;
	8591	esac
	8592
	8593	test -n "$rpath" && \
	8594	func_warning "\`-rpath' is ignored for objects"
	8595
	8596	test -n "$xrpath" && \
	8597	func_warning "\`-R' is ignored for objects"
	8598
	8599	test -n "$vinfo" && \
	8600	func_warning "\`-version-info' is ignored for objects"
	8601
	8602	test -n "$release" && \
	8603	func_warning "\`-release' is ignored for objects"
	8604
	8605	case $output in
	8606	*.lo)
	8607	test -n "$objs$old_deplibs" && \
	8608	func_fatal_error "cannot build library object \`$output' from non-libtool objects"
	8609
	8610	libobj=$output
	8611	func_lo2o "$libobj"
	8612	obj=$func_lo2o_result
	8613	;;
	8614	*)
	8615	libobj=
	8616	obj="$output"
	8617	;;
	8618	esac
	8619
	8620	# Delete the old objects.
	8621	$opt_dry_run \|\| $RM $obj $libobj
	8622
	8623	# Objects from convenience libraries. This assumes
	8624	# single-version convenience libraries. Whenever we create
	8625	# different ones for PIC/non-PIC, this we'll have to duplicate
	8626	# the extraction.
	8627	reload_conv_objs=
	8628	gentop=
	8629	# reload_cmds runs $LD directly, so let us get rid of
	8630	# -Wl from whole_archive_flag_spec and hope we can get by with
	8631	# turning comma into space..
	8632	wl=
	8633
	8634	if test -n "$convenience"; then
	8635	if test -n "$whole_archive_flag_spec"; then
	8636	eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
	8637	reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" \| $SED 's\|,\| \|g'`
	8638	else
	8639	gentop="$output_objdir/${obj}x"
	8640	func_append generated " $gentop"
	8641
	8642	func_extract_archives $gentop $convenience
	8643	reload_conv_objs="$reload_objs $func_extract_archives_result"
	8644	fi
	8645	fi
	8646
	8647	# If we're not building shared, we need to use non_pic_objs
	8648	test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
	8649
	8650	# Create the old-style object.
	8651	reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" \| $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
	8652
	8653	output="$obj"
	8654	func_execute_cmds "$reload_cmds" 'exit $?'
	8655
	8656	# Exit if we aren't doing a library object file.
	8657	if test -z "$libobj"; then
	8658	if test -n "$gentop"; then
	8659	func_show_eval '${RM}r "$gentop"'
	8660	fi
	8661
	8662	exit $EXIT_SUCCESS
	8663	fi
	8664
	8665	if test "$build_libtool_libs" != yes; then
	8666	if test -n "$gentop"; then
	8667	func_show_eval '${RM}r "$gentop"'
	8668	fi
	8669
	8670	# Create an invalid libtool object if no PIC, so that we don't
	8671	# accidentally link it into a program.
	8672	# $show "echo timestamp > $libobj"
	8673	# $opt_dry_run \|\| eval "echo timestamp > $libobj" \|\| exit $?
	8674	exit $EXIT_SUCCESS
	8675	fi
	8676
	8677	if test -n "$pic_flag" \|\| test "$pic_mode" != default; then
	8678	# Only do commands if we really have different PIC objects.
	8679	reload_objs="$libobjs $reload_conv_objs"
	8680	output="$libobj"
	8681	func_execute_cmds "$reload_cmds" 'exit $?'
	8682	fi
	8683
	8684	if test -n "$gentop"; then
	8685	func_show_eval '${RM}r "$gentop"'
	8686	fi
	8687
	8688	exit $EXIT_SUCCESS
	8689	;;
	8690
	8691	prog)
	8692	case $host in
	8693	cygwin) func_stripname '' '.exe' "$output"
	8694	output=$func_stripname_result.exe;;
	8695	esac
	8696	test -n "$vinfo" && \
	8697	func_warning "\`-version-info' is ignored for programs"
	8698
	8699	test -n "$release" && \
	8700	func_warning "\`-release' is ignored for programs"
	8701
	8702	test "$preload" = yes \
	8703	&& test "$dlopen_support" = unknown \
	8704	&& test "$dlopen_self" = unknown \
	8705	&& test "$dlopen_self_static" = unknown && \
	8706	func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
	8707
	8708	case $host in
	8709	--rhapsody* \| --darwin1.[012])
	8710	# On Rhapsody replace the C library is the System framework
	8711	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's/ -lc / System.ltframework /'`
	8712	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's/ -lc / System.ltframework /'`
	8713	;;
	8714	esac
	8715
	8716	case $host in
	8717	--darwin*)
	8718	# Don't allow lazy linking, it breaks C++ global constructors
	8719	# But is supposedly fixed on 10.4 or later (yay!).
	8720	if test "$tagname" = CXX ; then
	8721	case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
	8722	10.[0123])
	8723	func_append compile_command " ${wl}-bind_at_load"
	8724	func_append finalize_command " ${wl}-bind_at_load"
	8725	;;
	8726	esac
	8727	fi
	8728	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
	8729	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	8730	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
	8731	;;
	8732	esac
	8733
	8734
	8735	# move library search paths that coincide with paths to not yet
	8736	# installed libraries to the beginning of the library search list
	8737	new_libs=
	8738	for path in $notinst_path; do
	8739	case " $new_libs " in
	8740	" -L$path/$objdir ") ;;
	8741	*)
	8742	case " $compile_deplibs " in
	8743	" -L$path/$objdir ")
	8744	func_append new_libs " -L$path/$objdir" ;;
	8745	esac
	8746	;;
	8747	esac
	8748	done
	8749	for deplib in $compile_deplibs; do
	8750	case $deplib in
	8751	-L*)
	8752	case " $new_libs " in
	8753	" $deplib ") ;;
	8754	*) func_append new_libs " $deplib" ;;
	8755	esac
	8756	;;
	8757	*) func_append new_libs " $deplib" ;;
	8758	esac
	8759	done
	8760	compile_deplibs="$new_libs"
	8761
	8762
	8763	func_append compile_command " $compile_deplibs"
	8764	func_append finalize_command " $finalize_deplibs"
	8765
	8766	if test -n "$rpath$xrpath"; then
	8767	# If the user specified any rpath flags, then add them.
	8768	for libdir in $rpath $xrpath; do
	8769	# This is the magic to use -rpath.
	8770	case "$finalize_rpath " in
	8771	" $libdir ") ;;
	8772	*) func_append finalize_rpath " $libdir" ;;
	8773	esac
	8774	done
	8775	fi
	8776
	8777	# Now hardcode the library paths
	8778	rpath=
	8779	hardcode_libdirs=
	8780	for libdir in $compile_rpath $finalize_rpath; do
	8781	if test -n "$hardcode_libdir_flag_spec"; then
	8782	if test -n "$hardcode_libdir_separator"; then
	8783	if test -z "$hardcode_libdirs"; then
	8784	hardcode_libdirs="$libdir"
	8785	else
	8786	# Just accumulate the unique libdirs.
	8787	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	8788	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	8789	;;
	8790	*)
	8791	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
	8792	;;
	8793	esac
	8794	fi
	8795	else
	8796	eval flag=\"$hardcode_libdir_flag_spec\"
	8797	func_append rpath " $flag"
	8798	fi
	8799	elif test -n "$runpath_var"; then
	8800	case "$perm_rpath " in
	8801	" $libdir ") ;;
	8802	*) func_append perm_rpath " $libdir" ;;
	8803	esac
	8804	fi
	8805	case $host in
	8806	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
	8807	testbindir=`${ECHO} "$libdir" \| ${SED} -e 's/lib$/bin*'`
	8808	case :$dllsearchpath: in
	8809	":$libdir:") ;;
	8810	::) dllsearchpath=$libdir;;
	8811	*) func_append dllsearchpath ":$libdir";;
	8812	esac
	8813	case :$dllsearchpath: in
	8814	":$testbindir:") ;;
	8815	::) dllsearchpath=$testbindir;;
	8816	*) func_append dllsearchpath ":$testbindir";;
	8817	esac
	8818	;;
	8819	esac
	8820	done
	8821	# Substitute the hardcoded libdirs into the rpath.
	8822	if test -n "$hardcode_libdir_separator" &&
	8823	test -n "$hardcode_libdirs"; then
	8824	libdir="$hardcode_libdirs"
	8825	eval rpath=\" $hardcode_libdir_flag_spec\"
	8826	fi
	8827	compile_rpath="$rpath"
	8828
	8829	rpath=
	8830	hardcode_libdirs=
	8831	for libdir in $finalize_rpath; do
	8832	if test -n "$hardcode_libdir_flag_spec"; then
	8833	if test -n "$hardcode_libdir_separator"; then
	8834	if test -z "$hardcode_libdirs"; then
	8835	hardcode_libdirs="$libdir"
	8836	else
	8837	# Just accumulate the unique libdirs.
	8838	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	8839	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	8840	;;
	8841	*)
	8842	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
	8843	;;
	8844	esac
	8845	fi
	8846	else
	8847	eval flag=\"$hardcode_libdir_flag_spec\"
	8848	func_append rpath " $flag"
	8849	fi
	8850	elif test -n "$runpath_var"; then
	8851	case "$finalize_perm_rpath " in
	8852	" $libdir ") ;;
	8853	*) func_append finalize_perm_rpath " $libdir" ;;
	8854	esac
	8855	fi
	8856	done
	8857	# Substitute the hardcoded libdirs into the rpath.
	8858	if test -n "$hardcode_libdir_separator" &&
	8859	test -n "$hardcode_libdirs"; then
	8860	libdir="$hardcode_libdirs"
	8861	eval rpath=\" $hardcode_libdir_flag_spec\"
	8862	fi
	8863	finalize_rpath="$rpath"
	8864
	8865	if test -n "$libobjs" && test "$build_old_libs" = yes; then
	8866	# Transform all the library objects into standard objects.
	8867	compile_command=`$ECHO "$compile_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
	8868	finalize_command=`$ECHO "$finalize_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
	8869	fi
	8870
	8871	func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
	8872
	8873	# template prelinking step
	8874	if test -n "$prelink_cmds"; then
	8875	func_execute_cmds "$prelink_cmds" 'exit $?'
	8876	fi
	8877
	8878	wrappers_required=yes
	8879	case $host in
	8880	cegcc \| mingw32ce)
	8881	# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
	8882	wrappers_required=no
	8883	;;
	8884	cygwin \| mingw )
	8885	if test "$build_libtool_libs" != yes; then
	8886	wrappers_required=no
	8887	fi
	8888	;;
	8889	*)
	8890	if test "$need_relink" = no \|\| test "$build_libtool_libs" != yes; then
	8891	wrappers_required=no
	8892	fi
	8893	;;
	8894	esac
	8895	if test "$wrappers_required" = no; then
	8896	# Replace the output file specification.
	8897	compile_command=`$ECHO "$compile_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
	8898	link_command="$compile_command$compile_rpath"
	8899
	8900	# We have no uninstalled library dependencies, so finalize right now.
	8901	exit_status=0
	8902	func_show_eval "$link_command" 'exit_status=$?'
	8903
	8904	if test -n "$postlink_cmds"; then
	8905	func_to_tool_file "$output"
	8906	postlink_cmds=`func_echo_all "$postlink_cmds" \| $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	8907	func_execute_cmds "$postlink_cmds" 'exit $?'
	8908	fi
	8909
	8910	# Delete the generated files.
	8911	if test -f "$output_objdir/${outputname}S.${objext}"; then
	8912	func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
	8913	fi
	8914
	8915	exit $exit_status
	8916	fi
	8917
	8918	if test -n "$compile_shlibpath$finalize_shlibpath"; then
	8919	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
	8920	fi
	8921	if test -n "$finalize_shlibpath"; then
	8922	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
	8923	fi
	8924
	8925	compile_var=
	8926	finalize_var=
	8927	if test -n "$runpath_var"; then
	8928	if test -n "$perm_rpath"; then
	8929	# We should set the runpath_var.
	8930	rpath=
	8931	for dir in $perm_rpath; do
	8932	func_append rpath "$dir:"
	8933	done
	8934	compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
	8935	fi
	8936	if test -n "$finalize_perm_rpath"; then
	8937	# We should set the runpath_var.
	8938	rpath=
	8939	for dir in $finalize_perm_rpath; do
	8940	func_append rpath "$dir:"
	8941	done
	8942	finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
	8943	fi
	8944	fi
	8945
	8946	if test "$no_install" = yes; then
	8947	# We don't need to create a wrapper script.
	8948	link_command="$compile_var$compile_command$compile_rpath"
	8949	# Replace the output file specification.
	8950	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
	8951	# Delete the old output file.
	8952	$opt_dry_run \|\| $RM $output
	8953	# Link the executable and exit
	8954	func_show_eval "$link_command" 'exit $?'
	8955
	8956	if test -n "$postlink_cmds"; then
	8957	func_to_tool_file "$output"
	8958	postlink_cmds=`func_echo_all "$postlink_cmds" \| $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	8959	func_execute_cmds "$postlink_cmds" 'exit $?'
	8960	fi
	8961
	8962	exit $EXIT_SUCCESS
	8963	fi
	8964
	8965	if test "$hardcode_action" = relink; then
	8966	# Fast installation is not supported
	8967	link_command="$compile_var$compile_command$compile_rpath"
	8968	relink_command="$finalize_var$finalize_command$finalize_rpath"
	8969
	8970	func_warning "this platform does not like uninstalled shared libraries"
	8971	func_warning "\`$output' will be relinked during installation"
	8972	else
	8973	if test "$fast_install" != no; then
	8974	link_command="$finalize_var$compile_command$finalize_rpath"
	8975	if test "$fast_install" = yes; then
	8976	relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" \| $SED 's%@OUTPUT@%\$progdir/\$file%g'`
	8977	else
	8978	# fast_install is set to needless
	8979	relink_command=
	8980	fi
	8981	else
	8982	link_command="$compile_var$compile_command$compile_rpath"
	8983	relink_command="$finalize_var$finalize_command$finalize_rpath"
	8984	fi
	8985	fi
	8986
	8987	# Replace the output file specification.
	8988	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
	8989
	8990	# Delete the old output files.
	8991	$opt_dry_run \|\| $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
	8992
	8993	func_show_eval "$link_command" 'exit $?'
	8994
	8995	if test -n "$postlink_cmds"; then
	8996	func_to_tool_file "$output_objdir/$outputname"
	8997	postlink_cmds=`func_echo_all "$postlink_cmds" \| $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	8998	func_execute_cmds "$postlink_cmds" 'exit $?'
	8999	fi
	9000
	9001	# Now create the wrapper script.
	9002	func_verbose "creating $output"
	9003
	9004	# Quote the relink command for shipping.
	9005	if test -n "$relink_command"; then
	9006	# Preserve any variables that may affect compiler behavior
	9007	for var in $variables_saved_for_relink; do
	9008	if eval test -z \"\${$var+set}\"; then
	9009	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
	9010	elif eval var_value=\$$var; test -z "$var_value"; then
	9011	relink_command="$var=; export $var; $relink_command"
	9012	else
	9013	func_quote_for_eval "$var_value"
	9014	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
	9015	fi
	9016	done
	9017	relink_command="(cd `pwd`; $relink_command)"
	9018	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
	9019	fi
	9020
	9021	# Only actually do things if not in dry run mode.
	9022	$opt_dry_run \|\| {
	9023	# win32 will think the script is a binary if it has
	9024	# a .exe suffix, so we strip it off here.
	9025	case $output in
	9026	*.exe) func_stripname '' '.exe' "$output"
	9027	output=$func_stripname_result ;;
	9028	esac
	9029	# test for cygwin because mv fails w/o .exe extensions
	9030	case $host in
	9031	cygwin)
	9032	exeext=.exe
	9033	func_stripname '' '.exe' "$outputname"
	9034	outputname=$func_stripname_result ;;
	9035	*) exeext= ;;
	9036	esac
	9037	case $host in
	9038	cygwin \| mingw )
	9039	func_dirname_and_basename "$output" "" "."
	9040	output_name=$func_basename_result
	9041	output_path=$func_dirname_result
	9042	cwrappersource="$output_path/$objdir/lt-$output_name.c"
	9043	cwrapper="$output_path/$output_name.exe"
	9044	$RM $cwrappersource $cwrapper
	9045	trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
	9046
	9047	func_emit_cwrapperexe_src > $cwrappersource
	9048
	9049	# The wrapper executable is built using the $host compiler,
	9050	# because it contains $host paths and files. If cross-
	9051	# compiling, it, like the target executable, must be
	9052	# executed on the $host or under an emulation environment.
	9053	$opt_dry_run \|\| {
	9054	$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
	9055	$STRIP $cwrapper
	9056	}
	9057
	9058	# Now, create the wrapper script for func_source use:
	9059	func_ltwrapper_scriptname $cwrapper
	9060	$RM $func_ltwrapper_scriptname_result
	9061	trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
	9062	$opt_dry_run \|\| {
	9063	# note: this script will not be executed, so do not chmod.
	9064	if test "x$build" = "x$host" ; then
	9065	$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
	9066	else
	9067	func_emit_wrapper no > $func_ltwrapper_scriptname_result
	9068	fi
	9069	}
	9070	;;
	9071	* )
	9072	$RM $output
	9073	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
	9074
	9075	func_emit_wrapper no > $output
	9076	chmod +x $output
	9077	;;
	9078	esac
	9079	}
	9080	exit $EXIT_SUCCESS
	9081	;;
	9082	esac
	9083
	9084	# See if we need to build an old-fashioned archive.
	9085	for oldlib in $oldlibs; do
	9086
	9087	if test "$build_libtool_libs" = convenience; then
	9088	oldobjs="$libobjs_save $symfileobj"
	9089	addlibs="$convenience"
	9090	build_libtool_libs=no
	9091	else
	9092	if test "$build_libtool_libs" = module; then
	9093	oldobjs="$libobjs_save"
	9094	build_libtool_libs=no
	9095	else
	9096	oldobjs="$old_deplibs $non_pic_objects"
	9097	if test "$preload" = yes && test -f "$symfileobj"; then
	9098	func_append oldobjs " $symfileobj"
	9099	fi
	9100	fi
	9101	addlibs="$old_convenience"
	9102	fi
	9103
	9104	if test -n "$addlibs"; then
	9105	gentop="$output_objdir/${outputname}x"
	9106	func_append generated " $gentop"
	9107
	9108	func_extract_archives $gentop $addlibs
	9109	func_append oldobjs " $func_extract_archives_result"
	9110	fi
	9111
	9112	# Do each command in the archive commands.
	9113	if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
	9114	cmds=$old_archive_from_new_cmds
	9115	else
	9116
	9117	# Add any objects from preloaded convenience libraries
	9118	if test -n "$dlprefiles"; then
	9119	gentop="$output_objdir/${outputname}x"
	9120	func_append generated " $gentop"
	9121
	9122	func_extract_archives $gentop $dlprefiles
	9123	func_append oldobjs " $func_extract_archives_result"
	9124	fi
	9125
	9126	# POSIX demands no paths to be encoded in archives. We have
	9127	# to avoid creating archives with duplicate basenames if we
	9128	# might have to extract them afterwards, e.g., when creating a
	9129	# static archive out of a convenience library, or when linking
	9130	# the entirety of a libtool archive into another (currently
	9131	# not supported by libtool).
	9132	if (for obj in $oldobjs
	9133	do
	9134	func_basename "$obj"
	9135	$ECHO "$func_basename_result"
	9136	done \| sort \| sort -uc >/dev/null 2>&1); then
	9137	:
	9138	else
	9139	echo "copying selected object files to avoid basename conflicts..."
	9140	gentop="$output_objdir/${outputname}x"
	9141	func_append generated " $gentop"
	9142	func_mkdir_p "$gentop"
	9143	save_oldobjs=$oldobjs
	9144	oldobjs=
	9145	counter=1
	9146	for obj in $save_oldobjs
	9147	do
	9148	func_basename "$obj"
	9149	objbase="$func_basename_result"
	9150	case " $oldobjs " in
	9151	" ") oldobjs=$obj ;;
	9152	[\ /]"$objbase ")
	9153	while :; do
	9154	# Make sure we don't pick an alternate name that also
	9155	# overlaps.
	9156	newobj=lt$counter-$objbase
	9157	func_arith $counter + 1
	9158	counter=$func_arith_result
	9159	case " $oldobjs " in
	9160	[\ /]"$newobj ") ;;
	9161	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
	9162	esac
	9163	done
	9164	func_show_eval "ln $obj $gentop/$newobj \|\| cp $obj $gentop/$newobj"
	9165	func_append oldobjs " $gentop/$newobj"
	9166	;;
	9167	*) func_append oldobjs " $obj" ;;
	9168	esac
	9169	done
	9170	fi
	9171	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
	9172	tool_oldlib=$func_to_tool_file_result
	9173	eval cmds=\"$old_archive_cmds\"
	9174
	9175	func_len " $cmds"
	9176	len=$func_len_result
	9177	if test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
	9178	cmds=$old_archive_cmds
	9179	elif test -n "$archiver_list_spec"; then
	9180	func_verbose "using command file archive linking..."
	9181	for obj in $oldobjs
	9182	do
	9183	func_to_tool_file "$obj"
	9184	$ECHO "$func_to_tool_file_result"
	9185	done > $output_objdir/$libname.libcmd
	9186	func_to_tool_file "$output_objdir/$libname.libcmd"
	9187	oldobjs=" $archiver_list_spec$func_to_tool_file_result"
	9188	cmds=$old_archive_cmds
	9189	else
	9190	# the command line is too long to link in one step, link in parts
	9191	func_verbose "using piecewise archive linking..."
	9192	save_RANLIB=$RANLIB
	9193	RANLIB=:
	9194	objlist=
	9195	concat_cmds=
	9196	save_oldobjs=$oldobjs
	9197	oldobjs=
	9198	# Is there a better way of finding the last object in the list?
	9199	for obj in $save_oldobjs
	9200	do
	9201	last_oldobj=$obj
	9202	done
	9203	eval test_cmds=\"$old_archive_cmds\"
	9204	func_len " $test_cmds"
	9205	len0=$func_len_result
	9206	len=$len0
	9207	for obj in $save_oldobjs
	9208	do
	9209	func_len " $obj"
	9210	func_arith $len + $func_len_result
	9211	len=$func_arith_result
	9212	func_append objlist " $obj"
	9213	if test "$len" -lt "$max_cmd_len"; then
	9214	:
	9215	else
	9216	# the above command should be used before it gets too long
	9217	oldobjs=$objlist
	9218	if test "$obj" = "$last_oldobj" ; then
	9219	RANLIB=$save_RANLIB
	9220	fi
	9221	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
	9222	eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
	9223	objlist=
	9224	len=$len0
	9225	fi
	9226	done
	9227	RANLIB=$save_RANLIB
	9228	oldobjs=$objlist
	9229	if test "X$oldobjs" = "X" ; then
	9230	eval cmds=\"\$concat_cmds\"
	9231	else
	9232	eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
	9233	fi
	9234	fi
	9235	fi
	9236	func_execute_cmds "$cmds" 'exit $?'
	9237	done
	9238
	9239	test -n "$generated" && \
	9240	func_show_eval "${RM}r$generated"
	9241
	9242	# Now create the libtool archive.
	9243	case $output in
	9244	*.la)
	9245	old_library=
	9246	test "$build_old_libs" = yes && old_library="$libname.$libext"
	9247	func_verbose "creating $output"
	9248
	9249	# Preserve any variables that may affect compiler behavior
	9250	for var in $variables_saved_for_relink; do
	9251	if eval test -z \"\${$var+set}\"; then
	9252	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
	9253	elif eval var_value=\$$var; test -z "$var_value"; then
	9254	relink_command="$var=; export $var; $relink_command"
	9255	else
	9256	func_quote_for_eval "$var_value"
	9257	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
	9258	fi
	9259	done
	9260	# Quote the link command for shipping.
	9261	relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
	9262	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
	9263	if test "$hardcode_automatic" = yes ; then
	9264	relink_command=
	9265	fi
	9266
	9267	# Only create the output if not a dry run.
	9268	$opt_dry_run \|\| {
	9269	for installed in no yes; do
	9270	if test "$installed" = yes; then
	9271	if test -z "$install_libdir"; then
	9272	break
	9273	fi
	9274	output="$output_objdir/$outputname"i
	9275	# Replace all uninstalled libtool libraries with the installed ones
	9276	newdependency_libs=
	9277	for deplib in $dependency_libs; do
	9278	case $deplib in
	9279	*.la)
	9280	func_basename "$deplib"
	9281	name="$func_basename_result"
	9282	func_resolve_sysroot "$deplib"
	9283	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $func_resolve_sysroot_result`
	9284	test -z "$libdir" && \
	9285	func_fatal_error "\`$deplib' is not a valid libtool archive"
	9286	func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
	9287	;;
	9288	-L*)
	9289	func_stripname -L '' "$deplib"
	9290	func_replace_sysroot "$func_stripname_result"
	9291	func_append newdependency_libs " -L$func_replace_sysroot_result"
	9292	;;
	9293	-R*)
	9294	func_stripname -R '' "$deplib"
	9295	func_replace_sysroot "$func_stripname_result"
	9296	func_append newdependency_libs " -R$func_replace_sysroot_result"
	9297	;;
	9298	*) func_append newdependency_libs " $deplib" ;;
	9299	esac
	9300	done
	9301	dependency_libs="$newdependency_libs"
	9302	newdlfiles=
	9303
	9304	for lib in $dlfiles; do
	9305	case $lib in
	9306	*.la)
	9307	func_basename "$lib"
	9308	name="$func_basename_result"
	9309	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
	9310	test -z "$libdir" && \
	9311	func_fatal_error "\`$lib' is not a valid libtool archive"
	9312	func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
	9313	;;
	9314	*) func_append newdlfiles " $lib" ;;
	9315	esac
	9316	done
	9317	dlfiles="$newdlfiles"
	9318	newdlprefiles=
	9319	for lib in $dlprefiles; do
	9320	case $lib in
	9321	*.la)
	9322	# Only pass preopened files to the pseudo-archive (for
	9323	# eventual linking with the app. that links it) if we
	9324	# didn't already link the preopened objects directly into
	9325	# the library:
	9326	func_basename "$lib"
	9327	name="$func_basename_result"
	9328	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
	9329	test -z "$libdir" && \
	9330	func_fatal_error "\`$lib' is not a valid libtool archive"
	9331	func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
	9332	;;
	9333	esac
	9334	done
	9335	dlprefiles="$newdlprefiles"
	9336	else
	9337	newdlfiles=
	9338	for lib in $dlfiles; do
	9339	case $lib in
	9340	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
	9341	*) abs=`pwd`"/$lib" ;;
	9342	esac
	9343	func_append newdlfiles " $abs"
	9344	done
	9345	dlfiles="$newdlfiles"
	9346	newdlprefiles=
	9347	for lib in $dlprefiles; do
	9348	case $lib in
	9349	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
	9350	*) abs=`pwd`"/$lib" ;;
	9351	esac
	9352	func_append newdlprefiles " $abs"
	9353	done
	9354	dlprefiles="$newdlprefiles"
	9355	fi
	9356	$RM $output
	9357	# place dlname in correct position for cygwin
	9358	# In fact, it would be nice if we could use this code for all target
	9359	# systems that can't hard-code library paths into their executables
	9360	# and that have no shared library path variable independent of PATH,
	9361	# but it turns out we can't easily determine that from inspecting
	9362	# libtool variables, so we have to hard-code the OSs to which it
	9363	# applies here; at the moment, that means platforms that use the PE
	9364	# object format with DLL files. See the long comment at the top of
	9365	# tests/bindir.at for full details.
	9366	tdlname=$dlname
	9367	case $host,$output,$installed,$module,$dlname in
	9368	cygwin,lai,yes,no,.dll \| mingw,lai,yes,no,.dll \| cegcc,lai,yes,no,.dll)
	9369	# If a -bindir argument was supplied, place the dll there.
	9370	if test "x$bindir" != x ;
	9371	then
	9372	func_relative_path "$install_libdir" "$bindir"
	9373	tdlname=$func_relative_path_result$dlname
	9374	else
	9375	# Otherwise fall back on heuristic.
	9376	tdlname=../bin/$dlname
	9377	fi
	9378	;;
	9379	esac
	9380	$ECHO > $output "\
	9381	# $outputname - a libtool library file
	9382	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
	9383	#
	9384	# Please DO NOT delete this file!
	9385	# It is necessary for linking the library.
	9386
	9387	# The name that we can dlopen(3).
	9388	dlname='$tdlname'
	9389
	9390	# Names of this library.
	9391	library_names='$library_names'
	9392
	9393	# The name of the static archive.
	9394	old_library='$old_library'
	9395
	9396	# Linker flags that can not go in dependency_libs.
	9397	inherited_linker_flags='$new_inherited_linker_flags'
	9398
	9399	# Libraries that this one depends upon.
	9400	dependency_libs='$dependency_libs'
	9401
	9402	# Names of additional weak libraries provided by this library
	9403	weak_library_names='$weak_libs'
	9404
	9405	# Version information for $libname.
	9406	current=$current
	9407	age=$age
	9408	revision=$revision
	9409
	9410	# Is this an already installed library?
	9411	installed=$installed
	9412
	9413	# Should we warn about portability when linking against -modules?
	9414	shouldnotlink=$module
	9415
	9416	# Files to dlopen/dlpreopen
	9417	dlopen='$dlfiles'
	9418	dlpreopen='$dlprefiles'
	9419
	9420	# Directory that this library needs to be installed in:
	9421	libdir='$install_libdir'"
	9422	if test "$installed" = no && test "$need_relink" = yes; then
	9423	$ECHO >> $output "\
	9424	relink_command=\"$relink_command\""
	9425	fi
	9426	done
	9427	}
	9428
	9429	# Do a symbolic link so that the libtool archive can be found in
	9430	# LD_LIBRARY_PATH before the program is installed.
	9431	func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
	9432	;;
	9433	esac
	9434	exit $EXIT_SUCCESS
	9435	}
	9436
	9437	{ test "$opt_mode" = link \|\| test "$opt_mode" = relink; } &&
	9438	func_mode_link ${1+"$@"}
	9439
	9440
	9441	# func_mode_uninstall arg...
	9442	func_mode_uninstall ()
	9443	{
	9444	$opt_debug
	9445	RM="$nonopt"
	9446	files=
	9447	rmforce=
	9448	exit_status=0
	9449
	9450	# This variable tells wrapper scripts just to set variables rather
	9451	# than running their programs.
	9452	libtool_install_magic="$magic"
	9453
	9454	for arg
	9455	do
	9456	case $arg in
	9457	-f) func_append RM " $arg"; rmforce=yes ;;
	9458	-*) func_append RM " $arg" ;;
	9459	*) func_append files " $arg" ;;
	9460	esac
	9461	done
	9462
	9463	test -z "$RM" && \
	9464	func_fatal_help "you must specify an RM program"
	9465
	9466	rmdirs=
	9467
	9468	for file in $files; do
	9469	func_dirname "$file" "" "."
	9470	dir="$func_dirname_result"
	9471	if test "X$dir" = X.; then
	9472	odir="$objdir"
	9473	else
	9474	odir="$dir/$objdir"
	9475	fi
	9476	func_basename "$file"
	9477	name="$func_basename_result"
	9478	test "$opt_mode" = uninstall && odir="$dir"
	9479
	9480	# Remember odir for removal later, being careful to avoid duplicates
	9481	if test "$opt_mode" = clean; then
	9482	case " $rmdirs " in
	9483	" $odir ") ;;
	9484	*) func_append rmdirs " $odir" ;;
	9485	esac
	9486	fi
	9487
	9488	# Don't error if the file doesn't exist and rm -f was used.
	9489	if { test -L "$file"; } >/dev/null 2>&1 \|\|
	9490	{ test -h "$file"; } >/dev/null 2>&1 \|\|
	9491	test -f "$file"; then
	9492	:
	9493	elif test -d "$file"; then
	9494	exit_status=1
	9495	continue
	9496	elif test "$rmforce" = yes; then
	9497	continue
	9498	fi
	9499
	9500	rmfiles="$file"
	9501
	9502	case $name in
	9503	*.la)
	9504	# Possibly a libtool archive, so verify it.
	9505	if func_lalib_p "$file"; then
	9506	func_source $dir/$name
	9507
	9508	# Delete the libtool libraries and symlinks.
	9509	for n in $library_names; do
	9510	func_append rmfiles " $odir/$n"
	9511	done
	9512	test -n "$old_library" && func_append rmfiles " $odir/$old_library"
	9513
	9514	case "$opt_mode" in
	9515	clean)
	9516	case " $library_names " in
	9517	" $dlname ") ;;
	9518	*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
	9519	esac
	9520	test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
	9521	;;
	9522	uninstall)
	9523	if test -n "$library_names"; then
	9524	# Do each command in the postuninstall commands.
	9525	func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes \|\| exit_status=1'
	9526	fi
	9527
	9528	if test -n "$old_library"; then
	9529	# Do each command in the old_postuninstall commands.
	9530	func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes \|\| exit_status=1'
	9531	fi
	9532	# FIXME: should reinstall the best remaining shared library.
	9533	;;
	9534	esac
	9535	fi
	9536	;;
	9537
	9538	*.lo)
	9539	# Possibly a libtool object, so verify it.
	9540	if func_lalib_p "$file"; then
	9541
	9542	# Read the .lo file
	9543	func_source $dir/$name
	9544
	9545	# Add PIC object to the list of files to remove.
	9546	if test -n "$pic_object" &&
	9547	test "$pic_object" != none; then
	9548	func_append rmfiles " $dir/$pic_object"
	9549	fi
	9550
	9551	# Add non-PIC object to the list of files to remove.
	9552	if test -n "$non_pic_object" &&
	9553	test "$non_pic_object" != none; then
	9554	func_append rmfiles " $dir/$non_pic_object"
	9555	fi
	9556	fi
	9557	;;
	9558
	9559	*)
	9560	if test "$opt_mode" = clean ; then
	9561	noexename=$name
	9562	case $file in
	9563	*.exe)
	9564	func_stripname '' '.exe' "$file"
	9565	file=$func_stripname_result
	9566	func_stripname '' '.exe' "$name"
	9567	noexename=$func_stripname_result
	9568	# $file with .exe has already been added to rmfiles,
	9569	# add $file without .exe
	9570	func_append rmfiles " $file"
	9571	;;
	9572	esac
	9573	# Do a test to see if this is a libtool program.
	9574	if func_ltwrapper_p "$file"; then
	9575	if func_ltwrapper_executable_p "$file"; then
	9576	func_ltwrapper_scriptname "$file"
	9577	relink_command=
	9578	func_source $func_ltwrapper_scriptname_result
	9579	func_append rmfiles " $func_ltwrapper_scriptname_result"
	9580	else
	9581	relink_command=
	9582	func_source $dir/$noexename
	9583	fi
	9584
	9585	# note $name still contains .exe if it was in $file originally
	9586	# as does the version of $file that was added into $rmfiles
	9587	func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
	9588	if test "$fast_install" = yes && test -n "$relink_command"; then
	9589	func_append rmfiles " $odir/lt-$name"
	9590	fi
	9591	if test "X$noexename" != "X$name" ; then
	9592	func_append rmfiles " $odir/lt-${noexename}.c"
	9593	fi
	9594	fi
	9595	fi
	9596	;;
	9597	esac
	9598	func_show_eval "$RM $rmfiles" 'exit_status=1'
	9599	done
	9600
	9601	# Try to remove the ${objdir}s in the directories where we deleted files
	9602	for dir in $rmdirs; do
	9603	if test -d "$dir"; then
	9604	func_show_eval "rmdir $dir >/dev/null 2>&1"
	9605	fi
	9606	done
	9607
	9608	exit $exit_status
	9609	}
	9610
	9611	{ test "$opt_mode" = uninstall \|\| test "$opt_mode" = clean; } &&
	9612	func_mode_uninstall ${1+"$@"}
	9613
	9614	test -z "$opt_mode" && {
	9615	help="$generic_help"
	9616	func_fatal_help "you must specify a MODE"
	9617	}
	9618
	9619	test -z "$exec_cmd" && \
	9620	func_fatal_help "invalid operation mode \`$opt_mode'"
	9621
	9622	if test -n "$exec_cmd"; then
	9623	eval exec "$exec_cmd"
	9624	exit $EXIT_FAILURE
	9625	fi
	9626
	9627	exit $exit_status
	9628
	9629
	9630	# The TAGs below are defined such that we never get into a situation
	9631	# in which we disable both kinds of libraries. Given conflicting
	9632	# choices, we go for a static library, that is the most portable,
	9633	# since we can't tell whether shared libraries were disabled because
	9634	# the user asked for that or because the platform doesn't support
	9635	# them. This is particularly important on AIX, because we don't
	9636	# support having both static and shared libraries enabled at the same
	9637	# time on that platform, so we default to a shared-only configuration.
	9638	# If a disable-shared tag is given, we'll fallback to a static-only
	9639	# configuration. But we'll never go from static-only to shared-only.
	9640
	9641	# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
	9642	build_libtool_libs=no
	9643	build_old_libs=yes
	9644	# ### END LIBTOOL TAG CONFIG: disable-shared
	9645
	9646	# ### BEGIN LIBTOOL TAG CONFIG: disable-static
	9647	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
	9648	# ### END LIBTOOL TAG CONFIG: disable-static
	9649
	9650	# Local Variables:
	9651	# mode:shell-script
	9652	# sh-indentation:2
	9653	# End:
	9654	# vi:sw=2
	9655