Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

pikeyd165 – Blame information for rev 1

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