WebSVN - Blame - Rev 3 - /trunk/ltmain.sh

Rev	Author	Line No.	Line
3	magnus	1	# ltmain.sh - Provide generalized library-building support services.
		2	# NOTE: Changing this file will not affect anything until you rerun configure.
		3	#
		4	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
		5	# 2007 Free Software Foundation, Inc.
		6	# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
		7	#
		8	# This program is free software; you can redistribute it and/or modify
		9	# it under the terms of the GNU General Public License as published by
		10	# the Free Software Foundation; either version 2 of the License, or
		11	# (at your option) any later version.
		12	#
		13	# This program is distributed in the hope that it will be useful, but
		14	# WITHOUT ANY WARRANTY; without even the implied warranty of
		15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		16	# General Public License for more details.
		17	#
		18	# You should have received a copy of the GNU General Public License
		19	# along with this program; if not, write to the Free Software
		20	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
		21	#
		22	# As a special exception to the GNU General Public License, if you
		23	# distribute this file as part of a program that contains a
		24	# configuration script generated by Autoconf, you may include it under
		25	# the same distribution terms that you use for the rest of that program.
		26
		27	basename="s,^.*/,,g"
		28
		29	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
		30	# is ksh but when the shell is invoked as "sh" and the current value of
		31	# the _XPG environment variable is not equal to 1 (one), the special
		32	# positional parameter $0, within a function call, is the name of the
		33	# function.
		34	progpath="$0"
		35
		36	# The name of this program:
		37	progname=`echo "$progpath" \| $SED $basename`
		38	modename="$progname"
		39
		40	# Global variables:
		41	EXIT_SUCCESS=0
		42	EXIT_FAILURE=1
		43
		44	PROGRAM=ltmain.sh
		45	PACKAGE=libtool
		46	VERSION="1.5.24 Debian 1.5.24-2"
		47	TIMESTAMP=" (1.1220.2.456 2007/06/24 02:25:32)"
		48
		49	# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
		50	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
		51	emulate sh
		52	NULLCMD=:
		53	# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
		54	# is contrary to our usage. Disable this feature.
		55	alias -g '${1+"$@"}'='"$@"'
		56	setopt NO_GLOB_SUBST
		57	else
		58	case `(set -o) 2>/dev/null` in posix) set -o posix;; esac
		59	fi
		60	BIN_SH=xpg4; export BIN_SH # for Tru64
		61	DUALCASE=1; export DUALCASE # for MKS sh
		62
		63	# Check that we have a working $echo.
		64	if test "X$1" = X--no-reexec; then
		65	# Discard the --no-reexec flag, and continue.
		66	shift
		67	elif test "X$1" = X--fallback-echo; then
		68	# Avoid inline document here, it may be left over
		69	:
		70	elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
		71	# Yippee, $echo works!
		72	:
		73	else
		74	# Restart under the correct shell, and then maybe $echo will work.
		75	exec $SHELL "$progpath" --no-reexec ${1+"$@"}
		76	fi
		77
		78	if test "X$1" = X--fallback-echo; then
		79	# used as fallback echo
		80	shift
		81	cat <<EOF
		82	$*
		83	EOF
		84	exit $EXIT_SUCCESS
		85	fi
		86
		87	default_mode=
		88	help="Try \`$progname --help' for more information."
		89	magic="%%%MAGIC variable%%%"
		90	mkdir="mkdir"
		91	mv="mv -f"
		92	rm="rm -f"
		93
		94	# Sed substitution that helps us do robust quoting. It backslashifies
		95	# metacharacters that are still active within double-quoted strings.
		96	Xsed="${SED}"' -e 1s/^X//'
		97	sed_quote_subst='s/$[\\`\\"$\\\\]$/\\\1/g'
		98	# test EBCDIC or ASCII
		99	case `echo X\|tr X '\101'` in
		100	A) # ASCII based system
		101	# \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
		102	SP2NL='tr \040 \012'
		103	NL2SP='tr \015\012 \040\040'
		104	;;
		105	*) # EBCDIC based system
		106	SP2NL='tr \100 \n'
		107	NL2SP='tr \r\n \100\100'
		108	;;
		109	esac
		110
		111	# NLS nuisances.
		112	# Only set LANG and LC_ALL to C if already set.
		113	# These must not be set unconditionally because not all systems understand
		114	# e.g. LANG=C (notably SCO).
		115	# We save the old values to restore during execute mode.
		116	for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
		117	do
		118	eval "if test \"\${$lt_var+set}\" = set; then
		119	save_$lt_var=\$$lt_var
		120	$lt_var=C
		121	export $lt_var
		122	fi"
		123	done
		124
		125	# Make sure IFS has a sensible default
		126	lt_nl='
		127	'
		128	IFS=" $lt_nl"
		129
		130	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
		131	$echo "$modename: not configured to build any kind of library" 1>&2
		132	$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
		133	exit $EXIT_FAILURE
		134	fi
		135
		136	# Global variables.
		137	mode=$default_mode
		138	nonopt=
		139	prev=
		140	prevopt=
		141	run=
		142	show="$echo"
		143	show_help=
		144	execute_dlfiles=
		145	duplicate_deps=no
		146	preserve_args=
		147	lo2o="s/\\.lo\$/.${objext}/"
		148	o2lo="s/\\.${objext}\$/.lo/"
		149	extracted_archives=
		150	extracted_serial=0
		151
		152	#####################################
		153	# Shell function definitions:
		154	# This seems to be the best place for them
		155
		156	# func_mktempdir [string]
		157	# Make a temporary directory that won't clash with other running
		158	# libtool processes, and avoids race conditions if possible. If
		159	# given, STRING is the basename for that directory.
		160	func_mktempdir ()
		161	{
		162	my_template="${TMPDIR-/tmp}/${1-$progname}"
		163
		164	if test "$run" = ":"; then
		165	# Return a directory name, but don't create it in dry-run mode
		166	my_tmpdir="${my_template}-$$"
		167	else
		168
		169	# If mktemp works, use that first and foremost
		170	my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
		171
		172	if test ! -d "$my_tmpdir"; then
		173	# Failing that, at least try and use $RANDOM to avoid a race
		174	my_tmpdir="${my_template}-${RANDOM-0}$$"
		175
		176	save_mktempdir_umask=`umask`
		177	umask 0077
		178	$mkdir "$my_tmpdir"
		179	umask $save_mktempdir_umask
		180	fi
		181
		182	# If we're not in dry-run mode, bomb out on failure
		183	test -d "$my_tmpdir" \|\| {
		184	$echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
		185	exit $EXIT_FAILURE
		186	}
		187	fi
		188
		189	$echo "X$my_tmpdir" \| $Xsed
		190	}
		191
		192
		193	# func_win32_libid arg
		194	# return the library type of file 'arg'
		195	#
		196	# Need a lot of goo to handle both DLLs and import libs
		197	# Has to be a shell function in order to 'eat' the argument
		198	# that is supplied when $file_magic_command is called.
		199	func_win32_libid ()
		200	{
		201	win32_libid_type="unknown"
		202	win32_fileres=`file -L $1 2>/dev/null`
		203	case $win32_fileres in
		204	ar\ archive\ import\ library) # definitely import
		205	win32_libid_type="x86 archive import"
		206	;;
		207	ar\ archive) # could be an import, or static
		208	if eval $OBJDUMP -f $1 \| $SED -e '10q' 2>/dev/null \| \
		209	$EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
		210	win32_nmres=`eval $NM -f posix -A $1 \| \
		211	$SED -n -e '1,100{
		212	/ I /{
		213	s,.*,import,
		214	p
		215	q
		216	}
		217	}'`
		218	case $win32_nmres in
		219	import*) win32_libid_type="x86 archive import";;
		220	*) win32_libid_type="x86 archive static";;
		221	esac
		222	fi
		223	;;
		224	DLL)
		225	win32_libid_type="x86 DLL"
		226	;;
		227	executable) # but shell scripts are "executable" too...
		228	case $win32_fileres in
		229	MS\ Windows\ PE\ Intel)
		230	win32_libid_type="x86 DLL"
		231	;;
		232	esac
		233	;;
		234	esac
		235	$echo $win32_libid_type
		236	}
		237
		238
		239	# func_infer_tag arg
		240	# Infer tagged configuration to use if any are available and
		241	# if one wasn't chosen via the "--tag" command line option.
		242	# Only attempt this if the compiler in the base compile
		243	# command doesn't match the default compiler.
		244	# arg is usually of the form 'gcc ...'
		245	func_infer_tag ()
		246	{
		247	if test -n "$available_tags" && test -z "$tagname"; then
		248	CC_quoted=
		249	for arg in $CC; do
		250	case $arg in
		251	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		252	arg="\"$arg\""
		253	;;
		254	esac
		255	CC_quoted="$CC_quoted $arg"
		256	done
		257	case $@ in
		258	# Blanks in the command may have been stripped by the calling shell,
		259	# but not from the CC environment variable when configure was run.
		260	" $CC "* \| "$CC "* \| " `$echo $CC` "* \| "`$echo $CC` "* \| " $CC_quoted"* \| "$CC_quoted "* \| " `$echo $CC_quoted` "* \| "`$echo $CC_quoted` "*) ;;
		261	# Blanks at the start of $base_compile will cause this to fail
		262	# if we don't check for them as well.
		263	*)
		264	for z in $available_tags; do
		265	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
		266	# Evaluate the configuration.
		267	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
		268	CC_quoted=
		269	for arg in $CC; do
		270	# Double-quote args containing other shell metacharacters.
		271	case $arg in
		272	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		273	arg="\"$arg\""
		274	;;
		275	esac
		276	CC_quoted="$CC_quoted $arg"
		277	done
		278	case "$@ " in
		279	" $CC "* \| "$CC "* \| " `$echo $CC` "* \| "`$echo $CC` "* \| " $CC_quoted"* \| "$CC_quoted "* \| " `$echo $CC_quoted` "* \| "`$echo $CC_quoted` "*)
		280	# The compiler in the base compile command matches
		281	# the one in the tagged configuration.
		282	# Assume this is the tagged configuration we want.
		283	tagname=$z
		284	break
		285	;;
		286	esac
		287	fi
		288	done
		289	# If $tagname still isn't set, then no tagged configuration
		290	# was found and let the user know that the "--tag" command
		291	# line option must be used.
		292	if test -z "$tagname"; then
		293	$echo "$modename: unable to infer tagged configuration"
		294	$echo "$modename: specify a tag with \`--tag'" 1>&2
		295	exit $EXIT_FAILURE
		296	# else
		297	# $echo "$modename: using $tagname tagged configuration"
		298	fi
		299	;;
		300	esac
		301	fi
		302	}
		303
		304
		305	# func_extract_an_archive dir oldlib
		306	func_extract_an_archive ()
		307	{
		308	f_ex_an_ar_dir="$1"; shift
		309	f_ex_an_ar_oldlib="$1"
		310
		311	$show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
		312	$run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" \|\| exit $?
		313	if ($AR t "$f_ex_an_ar_oldlib" \| sort \| sort -uc >/dev/null 2>&1); then
		314	:
		315	else
		316	$echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
		317	exit $EXIT_FAILURE
		318	fi
		319	}
		320
		321	# func_extract_archives gentop oldlib ...
		322	func_extract_archives ()
		323	{
		324	my_gentop="$1"; shift
		325	my_oldlibs=${1+"$@"}
		326	my_oldobjs=""
		327	my_xlib=""
		328	my_xabs=""
		329	my_xdir=""
		330	my_status=""
		331
		332	$show "${rm}r $my_gentop"
		333	$run ${rm}r "$my_gentop"
		334	$show "$mkdir $my_gentop"
		335	$run $mkdir "$my_gentop"
		336	my_status=$?
		337	if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
		338	exit $my_status
		339	fi
		340
		341	for my_xlib in $my_oldlibs; do
		342	# Extract the objects.
		343	case $my_xlib in
		344	[\\/]* \| [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
		345	*) my_xabs=`pwd`"/$my_xlib" ;;
		346	esac
		347	my_xlib=`$echo "X$my_xlib" \| $Xsed -e 's%^.*/%%'`
		348	my_xlib_u=$my_xlib
		349	while :; do
		350	case " $extracted_archives " in
		351	" $my_xlib_u ")
		352	extracted_serial=`expr $extracted_serial + 1`
		353	my_xlib_u=lt$extracted_serial-$my_xlib ;;
		354	*) break ;;
		355	esac
		356	done
		357	extracted_archives="$extracted_archives $my_xlib_u"
		358	my_xdir="$my_gentop/$my_xlib_u"
		359
		360	$show "${rm}r $my_xdir"
		361	$run ${rm}r "$my_xdir"
		362	$show "$mkdir $my_xdir"
		363	$run $mkdir "$my_xdir"
		364	exit_status=$?
		365	if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
		366	exit $exit_status
		367	fi
		368	case $host in
		369	-darwin)
		370	$show "Extracting $my_xabs"
		371	# Do not bother doing anything if just a dry run
		372	if test -z "$run"; then
		373	darwin_orig_dir=`pwd`
		374	cd $my_xdir \|\| exit $?
		375	darwin_archive=$my_xabs
		376	darwin_curdir=`pwd`
		377	darwin_base_archive=`$echo "X$darwin_archive" \| $Xsed -e 's%^.*/%%'`
		378	darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null \| $EGREP Architectures 2>/dev/null`
		379	if test -n "$darwin_arches"; then
		380	darwin_arches=`echo "$darwin_arches" \| $SED -e 's/.*are://'`
		381	darwin_arch=
		382	$show "$darwin_base_archive has multiple architectures $darwin_arches"
		383	for darwin_arch in $darwin_arches ; do
		384	mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
		385	lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
		386	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
		387	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
		388	cd "$darwin_curdir"
		389	$rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
		390	done # $darwin_arches
		391	## Okay now we have a bunch of thin objects, gotta fatten them up :)
		392	darwin_filelist=`find unfat-$$ -type f -name \.o -print -o -name \.lo -print\| xargs basename \| sort -u \| $NL2SP`
		393	darwin_file=
		394	darwin_files=
		395	for darwin_file in $darwin_filelist; do
		396	darwin_files=`find unfat-$$ -name $darwin_file -print \| $NL2SP`
		397	lipo -create -output "$darwin_file" $darwin_files
		398	done # $darwin_filelist
		399	${rm}r unfat-$$
		400	cd "$darwin_orig_dir"
		401	else
		402	cd "$darwin_orig_dir"
		403	func_extract_an_archive "$my_xdir" "$my_xabs"
		404	fi # $darwin_arches
		405	fi # $run
		406	;;
		407	*)
		408	func_extract_an_archive "$my_xdir" "$my_xabs"
		409	;;
		410	esac
		411	my_oldobjs="$my_oldobjs "`find $my_xdir -name \.$objext -print -o -name \.lo -print \| $NL2SP`
		412	done
		413	func_extract_archives_result="$my_oldobjs"
		414	}
		415	# End of Shell function definitions
		416	#####################################
		417
		418	# Darwin sucks
		419	eval std_shrext=\"$shrext_cmds\"
		420
		421	disable_libs=no
		422
		423	# Parse our command line options once, thoroughly.
		424	while test "$#" -gt 0
		425	do
		426	arg="$1"
		427	shift
		428
		429	case $arg in
		430	-=) optarg=`$echo "X$arg" \| $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
		431	*) optarg= ;;
		432	esac
		433
		434	# If the previous option needs an argument, assign it.
		435	if test -n "$prev"; then
		436	case $prev in
		437	execute_dlfiles)
		438	execute_dlfiles="$execute_dlfiles $arg"
		439	;;
		440	tag)
		441	tagname="$arg"
		442	preserve_args="${preserve_args}=$arg"
		443
		444	# Check whether tagname contains only valid characters
		445	case $tagname in
		446	[!-_A-Za-z0-9,/])
		447	$echo "$progname: invalid tag name: $tagname" 1>&2
		448	exit $EXIT_FAILURE
		449	;;
		450	esac
		451
		452	case $tagname in
		453	CC)
		454	# Don't test for the "default" C tag, as we know, it's there, but
		455	# not specially marked.
		456	;;
		457	*)
		458	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
		459	taglist="$taglist $tagname"
		460	# Evaluate the configuration.
		461	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
		462	else
		463	$echo "$progname: ignoring unknown tag $tagname" 1>&2
		464	fi
		465	;;
		466	esac
		467	;;
		468	*)
		469	eval "$prev=\$arg"
		470	;;
		471	esac
		472
		473	prev=
		474	prevopt=
		475	continue
		476	fi
		477
		478	# Have we seen a non-optional argument yet?
		479	case $arg in
		480	--help)
		481	show_help=yes
		482	;;
		483
		484	--version)
		485	echo "\
		486	$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
		487
		488	Copyright (C) 2007 Free Software Foundation, Inc.
		489	This is free software; see the source for copying conditions. There is NO
		490	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
		491	exit $?
		492	;;
		493
		494	--config)
		495	${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
		496	# Now print the configurations for the tags.
		497	for tagname in $taglist; do
		498	${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
		499	done
		500	exit $?
		501	;;
		502
		503	--debug)
		504	$echo "$progname: enabling shell trace mode"
		505	set -x
		506	preserve_args="$preserve_args $arg"
		507	;;
		508
		509	--dry-run \| -n)
		510	run=:
		511	;;
		512
		513	--features)
		514	$echo "host: $host"
		515	if test "$build_libtool_libs" = yes; then
		516	$echo "enable shared libraries"
		517	else
		518	$echo "disable shared libraries"
		519	fi
		520	if test "$build_old_libs" = yes; then
		521	$echo "enable static libraries"
		522	else
		523	$echo "disable static libraries"
		524	fi
		525	exit $?
		526	;;
		527
		528	--finish) mode="finish" ;;
		529
		530	--mode) prevopt="--mode" prev=mode ;;
		531	--mode=*) mode="$optarg" ;;
		532
		533	--preserve-dup-deps) duplicate_deps="yes" ;;
		534
		535	--quiet \| --silent)
		536	show=:
		537	preserve_args="$preserve_args $arg"
		538	;;
		539
		540	--tag)
		541	prevopt="--tag"
		542	prev=tag
		543	preserve_args="$preserve_args --tag"
		544	;;
		545	--tag=*)
		546	set tag "$optarg" ${1+"$@"}
		547	shift
		548	prev=tag
		549	preserve_args="$preserve_args --tag"
		550	;;
		551
		552	-dlopen)
		553	prevopt="-dlopen"
		554	prev=execute_dlfiles
		555	;;
		556
		557	-*)
		558	$echo "$modename: unrecognized option \`$arg'" 1>&2
		559	$echo "$help" 1>&2
		560	exit $EXIT_FAILURE
		561	;;
		562
		563	*)
		564	nonopt="$arg"
		565	break
		566	;;
		567	esac
		568	done
		569
		570	if test -n "$prevopt"; then
		571	$echo "$modename: option \`$prevopt' requires an argument" 1>&2
		572	$echo "$help" 1>&2
		573	exit $EXIT_FAILURE
		574	fi
		575
		576	case $disable_libs in
		577	no)
		578	;;
		579	shared)
		580	build_libtool_libs=no
		581	build_old_libs=yes
		582	;;
		583	static)
		584	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
		585	;;
		586	esac
		587
		588	# If this variable is set in any of the actions, the command in it
		589	# will be execed at the end. This prevents here-documents from being
		590	# left over by shells.
		591	exec_cmd=
		592
		593	if test -z "$show_help"; then
		594
		595	# Infer the operation mode.
		596	if test -z "$mode"; then
		597	$echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
		598	$echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
		599	case $nonopt in
		600	cc \| cc \| ++ \| gcc \| -gcc \| g++* \| xlc*)
		601	mode=link
		602	for arg
		603	do
		604	case $arg in
		605	-c)
		606	mode=compile
		607	break
		608	;;
		609	esac
		610	done
		611	;;
		612	db \| dbx \| strace \| truss)
		613	mode=execute
		614	;;
		615	install\|cp\|mv)
		616	mode=install
		617	;;
		618	*rm)
		619	mode=uninstall
		620	;;
		621	*)
		622	# If we have no mode, but dlfiles were specified, then do execute mode.
		623	test -n "$execute_dlfiles" && mode=execute
		624
		625	# Just use the default operation mode.
		626	if test -z "$mode"; then
		627	if test -n "$nonopt"; then
		628	$echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
		629	else
		630	$echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
		631	fi
		632	fi
		633	;;
		634	esac
		635	fi
		636
		637	# Only execute mode is allowed to have -dlopen flags.
		638	if test -n "$execute_dlfiles" && test "$mode" != execute; then
		639	$echo "$modename: unrecognized option \`-dlopen'" 1>&2
		640	$echo "$help" 1>&2
		641	exit $EXIT_FAILURE
		642	fi
		643
		644	# Change the help message to a mode-specific one.
		645	generic_help="$help"
		646	help="Try \`$modename --help --mode=$mode' for more information."
		647
		648	# These modes are in order of execution frequency so that they run quickly.
		649	case $mode in
		650	# libtool compile mode
		651	compile)
		652	modename="$modename: compile"
		653	# Get the compilation command and the source file.
		654	base_compile=
		655	srcfile="$nonopt" # always keep a non-empty value in "srcfile"
		656	suppress_opt=yes
		657	suppress_output=
		658	arg_mode=normal
		659	libobj=
		660	later=
		661
		662	for arg
		663	do
		664	case $arg_mode in
		665	arg )
		666	# do not "continue". Instead, add this to base_compile
		667	lastarg="$arg"
		668	arg_mode=normal
		669	;;
		670
		671	target )
		672	libobj="$arg"
		673	arg_mode=normal
		674	continue
		675	;;
		676
		677	normal )
		678	# Accept any command-line options.
		679	case $arg in
		680	-o)
		681	if test -n "$libobj" ; then
		682	$echo "$modename: you cannot specify \`-o' more than once" 1>&2
		683	exit $EXIT_FAILURE
		684	fi
		685	arg_mode=target
		686	continue
		687	;;
		688
		689	-static \| -prefer-pic \| -prefer-non-pic)
		690	later="$later $arg"
		691	continue
		692	;;
		693
		694	-no-suppress)
		695	suppress_opt=no
		696	continue
		697	;;
		698
		699	-Xcompiler)
		700	arg_mode=arg # the next one goes into the "base_compile" arg list
		701	continue # The current "srcfile" will either be retained or
		702	;; # replaced later. I would guess that would be a bug.
		703
		704	-Wc,*)
		705	args=`$echo "X$arg" \| $Xsed -e "s/^-Wc,//"`
		706	lastarg=
		707	save_ifs="$IFS"; IFS=','
		708	for arg in $args; do
		709	IFS="$save_ifs"
		710
		711	# Double-quote args containing other shell metacharacters.
		712	# Many Bourne shells cannot handle close brackets correctly
		713	# in scan sets, so we specify it separately.
		714	case $arg in
		715	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		716	arg="\"$arg\""
		717	;;
		718	esac
		719	lastarg="$lastarg $arg"
		720	done
		721	IFS="$save_ifs"
		722	lastarg=`$echo "X$lastarg" \| $Xsed -e "s/^ //"`
		723
		724	# Add the arguments to base_compile.
		725	base_compile="$base_compile $lastarg"
		726	continue
		727	;;
		728
		729	* )
		730	# Accept the current argument as the source file.
		731	# The previous "srcfile" becomes the current argument.
		732	#
		733	lastarg="$srcfile"
		734	srcfile="$arg"
		735	;;
		736	esac # case $arg
		737	;;
		738	esac # case $arg_mode
		739
		740	# Aesthetically quote the previous argument.
		741	lastarg=`$echo "X$lastarg" \| $Xsed -e "$sed_quote_subst"`
		742
		743	case $lastarg in
		744	# Double-quote args containing other shell metacharacters.
		745	# Many Bourne shells cannot handle close brackets correctly
		746	# in scan sets, and some SunOS ksh mistreat backslash-escaping
		747	# in scan sets (worked around with variable expansion),
		748	# and furthermore cannot handle '\|' '&' '(' ')' in scan sets
		749	# at all, so we specify them separately.
		750	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		751	lastarg="\"$lastarg\""
		752	;;
		753	esac
		754
		755	base_compile="$base_compile $lastarg"
		756	done # for arg
		757
		758	case $arg_mode in
		759	arg)
		760	$echo "$modename: you must specify an argument for -Xcompile"
		761	exit $EXIT_FAILURE
		762	;;
		763	target)
		764	$echo "$modename: you must specify a target with \`-o'" 1>&2
		765	exit $EXIT_FAILURE
		766	;;
		767	*)
		768	# Get the name of the library object.
		769	[ -z "$libobj" ] && libobj=`$echo "X$srcfile" \| $Xsed -e 's%^.*/%%'`
		770	;;
		771	esac
		772
		773	# Recognize several different file suffixes.
		774	# If the user specifies -o file.o, it is replaced with file.lo
		775	xform='[cCFSifmso]'
		776	case $libobj in
		777	*.ada) xform=ada ;;
		778	*.adb) xform=adb ;;
		779	*.ads) xform=ads ;;
		780	*.asm) xform=asm ;;
		781	*.c++) xform=c++ ;;
		782	*.cc) xform=cc ;;
		783	*.ii) xform=ii ;;
		784	*.class) xform=class ;;
		785	*.cpp) xform=cpp ;;
		786	*.cxx) xform=cxx ;;
		787	*.[fF][09]?) xform=[fF][09]. ;;
		788	*.for) xform=for ;;
		789	*.java) xform=java ;;
		790	*.obj) xform=obj ;;
		791	esac
		792
		793	libobj=`$echo "X$libobj" \| $Xsed -e "s/\.$xform$/.lo/"`
		794
		795	case $libobj in
		796	*.lo) obj=`$echo "X$libobj" \| $Xsed -e "$lo2o"` ;;
		797	*)
		798	$echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
		799	exit $EXIT_FAILURE
		800	;;
		801	esac
		802
		803	func_infer_tag $base_compile
		804
		805	for arg in $later; do
		806	case $arg in
		807	-static)
		808	build_old_libs=yes
		809	continue
		810	;;
		811
		812	-prefer-pic)
		813	pic_mode=yes
		814	continue
		815	;;
		816
		817	-prefer-non-pic)
		818	pic_mode=no
		819	continue
		820	;;
		821	esac
		822	done
		823
		824	qlibobj=`$echo "X$libobj" \| $Xsed -e "$sed_quote_subst"`
		825	case $qlibobj in
		826	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		827	qlibobj="\"$qlibobj\"" ;;
		828	esac
		829	test "X$libobj" != "X$qlibobj" \
		830	&& $echo "X$libobj" \| grep '[]~#^*{};<>?"'"'"' &()\|`$[]' \
		831	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
		832	objname=`$echo "X$obj" \| $Xsed -e 's%^.*/%%'`
		833	xdir=`$echo "X$obj" \| $Xsed -e 's%/[^/]*$%%'`
		834	if test "X$xdir" = "X$obj"; then
		835	xdir=
		836	else
		837	xdir=$xdir/
		838	fi
		839	lobj=${xdir}$objdir/$objname
		840
		841	if test -z "$base_compile"; then
		842	$echo "$modename: you must specify a compilation command" 1>&2
		843	$echo "$help" 1>&2
		844	exit $EXIT_FAILURE
		845	fi
		846
		847	# Delete any leftover library objects.
		848	if test "$build_old_libs" = yes; then
		849	removelist="$obj $lobj $libobj ${libobj}T"
		850	else
		851	removelist="$lobj $libobj ${libobj}T"
		852	fi
		853
		854	$run $rm $removelist
		855	trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
		856
		857	# On Cygwin there's no "real" PIC flag so we must build both object types
		858	case $host_os in
		859	cygwin* \| mingw* \| pw32* \| os2*)
		860	pic_mode=default
		861	;;
		862	esac
		863	if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
		864	# non-PIC code in shared libraries is not supported
		865	pic_mode=default
		866	fi
		867
		868	# Calculate the filename of the output object if compiler does
		869	# not support -o with -c
		870	if test "$compiler_c_o" = no; then
		871	output_obj=`$echo "X$srcfile" \| $Xsed -e 's%^./%%' -e 's%\.[^.]$%%'`.${objext}
		872	lockfile="$output_obj.lock"
		873	removelist="$removelist $output_obj $lockfile"
		874	trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
		875	else
		876	output_obj=
		877	need_locks=no
		878	lockfile=
		879	fi
		880
		881	# Lock this critical section if it is needed
		882	# We use this script file to make the link, it avoids creating a new file
		883	if test "$need_locks" = yes; then
		884	until $run ln "$progpath" "$lockfile" 2>/dev/null; do
		885	$show "Waiting for $lockfile to be removed"
		886	sleep 2
		887	done
		888	elif test "$need_locks" = warn; then
		889	if test -f "$lockfile"; then
		890	$echo "\
		891	*** ERROR, $lockfile exists and contains:
		892	`cat $lockfile 2>/dev/null`
		893
		894	This indicates that another process is trying to use the same
		895	temporary object file, and libtool could not work around it because
		896	your compiler does not support \`-c' and \`-o' together. If you
		897	repeat this compilation, it may succeed, by chance, but you had better
		898	avoid parallel builds (make -j) in this platform, or get a better
		899	compiler."
		900
		901	$run $rm $removelist
		902	exit $EXIT_FAILURE
		903	fi
		904	$echo "$srcfile" > "$lockfile"
		905	fi
		906
		907	if test -n "$fix_srcfile_path"; then
		908	eval srcfile=\"$fix_srcfile_path\"
		909	fi
		910	qsrcfile=`$echo "X$srcfile" \| $Xsed -e "$sed_quote_subst"`
		911	case $qsrcfile in
		912	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		913	qsrcfile="\"$qsrcfile\"" ;;
		914	esac
		915
		916	$run $rm "$libobj" "${libobj}T"
		917
		918	# Create a libtool object file (analogous to a ".la" file),
		919	# but don't create it if we're doing a dry run.
		920	test -z "$run" && cat > ${libobj}T <<EOF
		921	# $libobj - a libtool object file
		922	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
		923	#
		924	# Please DO NOT delete this file!
		925	# It is necessary for linking the library.
		926
		927	# Name of the PIC object.
		928	EOF
		929
		930	# Only build a PIC object if we are building libtool libraries.
		931	if test "$build_libtool_libs" = yes; then
		932	# Without this assignment, base_compile gets emptied.
		933	fbsd_hideous_sh_bug=$base_compile
		934
		935	if test "$pic_mode" != no; then
		936	command="$base_compile $qsrcfile $pic_flag"
		937	else
		938	# Don't build PIC code
		939	command="$base_compile $qsrcfile"
		940	fi
		941
		942	if test ! -d "${xdir}$objdir"; then
		943	$show "$mkdir ${xdir}$objdir"
		944	$run $mkdir ${xdir}$objdir
		945	exit_status=$?
		946	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
		947	exit $exit_status
		948	fi
		949	fi
		950
		951	if test -z "$output_obj"; then
		952	# Place PIC objects in $objdir
		953	command="$command -o $lobj"
		954	fi
		955
		956	$run $rm "$lobj" "$output_obj"
		957
		958	$show "$command"
		959	if $run eval "$command"; then :
		960	else
		961	test -n "$output_obj" && $run $rm $removelist
		962	exit $EXIT_FAILURE
		963	fi
		964
		965	if test "$need_locks" = warn &&
		966	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
		967	$echo "\
		968	*** ERROR, $lockfile contains:
		969	`cat $lockfile 2>/dev/null`
		970
		971	but it should contain:
		972	$srcfile
		973
		974	This indicates that another process is trying to use the same
		975	temporary object file, and libtool could not work around it because
		976	your compiler does not support \`-c' and \`-o' together. If you
		977	repeat this compilation, it may succeed, by chance, but you had better
		978	avoid parallel builds (make -j) in this platform, or get a better
		979	compiler."
		980
		981	$run $rm $removelist
		982	exit $EXIT_FAILURE
		983	fi
		984
		985	# Just move the object if needed, then go on to compile the next one
		986	if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
		987	$show "$mv $output_obj $lobj"
		988	if $run $mv $output_obj $lobj; then :
		989	else
		990	error=$?
		991	$run $rm $removelist
		992	exit $error
		993	fi
		994	fi
		995
		996	# Append the name of the PIC object to the libtool object file.
		997	test -z "$run" && cat >> ${libobj}T <<EOF
		998	pic_object='$objdir/$objname'
		999
		1000	EOF
		1001
		1002	# Allow error messages only from the first compilation.
		1003	if test "$suppress_opt" = yes; then
		1004	suppress_output=' >/dev/null 2>&1'
		1005	fi
		1006	else
		1007	# No PIC object so indicate it doesn't exist in the libtool
		1008	# object file.
		1009	test -z "$run" && cat >> ${libobj}T <<EOF
		1010	pic_object=none
		1011
		1012	EOF
		1013	fi
		1014
		1015	# Only build a position-dependent object if we build old libraries.
		1016	if test "$build_old_libs" = yes; then
		1017	if test "$pic_mode" != yes; then
		1018	# Don't build PIC code
		1019	command="$base_compile $qsrcfile"
		1020	else
		1021	command="$base_compile $qsrcfile $pic_flag"
		1022	fi
		1023	if test "$compiler_c_o" = yes; then
		1024	command="$command -o $obj"
		1025	fi
		1026
		1027	# Suppress compiler output if we already did a PIC compilation.
		1028	command="$command$suppress_output"
		1029	$run $rm "$obj" "$output_obj"
		1030	$show "$command"
		1031	if $run eval "$command"; then :
		1032	else
		1033	$run $rm $removelist
		1034	exit $EXIT_FAILURE
		1035	fi
		1036
		1037	if test "$need_locks" = warn &&
		1038	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
		1039	$echo "\
		1040	*** ERROR, $lockfile contains:
		1041	`cat $lockfile 2>/dev/null`
		1042
		1043	but it should contain:
		1044	$srcfile
		1045
		1046	This indicates that another process is trying to use the same
		1047	temporary object file, and libtool could not work around it because
		1048	your compiler does not support \`-c' and \`-o' together. If you
		1049	repeat this compilation, it may succeed, by chance, but you had better
		1050	avoid parallel builds (make -j) in this platform, or get a better
		1051	compiler."
		1052
		1053	$run $rm $removelist
		1054	exit $EXIT_FAILURE
		1055	fi
		1056
		1057	# Just move the object if needed
		1058	if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
		1059	$show "$mv $output_obj $obj"
		1060	if $run $mv $output_obj $obj; then :
		1061	else
		1062	error=$?
		1063	$run $rm $removelist
		1064	exit $error
		1065	fi
		1066	fi
		1067
		1068	# Append the name of the non-PIC object the libtool object file.
		1069	# Only append if the libtool object file exists.
		1070	test -z "$run" && cat >> ${libobj}T <<EOF
		1071	# Name of the non-PIC object.
		1072	non_pic_object='$objname'
		1073
		1074	EOF
		1075	else
		1076	# Append the name of the non-PIC object the libtool object file.
		1077	# Only append if the libtool object file exists.
		1078	test -z "$run" && cat >> ${libobj}T <<EOF
		1079	# Name of the non-PIC object.
		1080	non_pic_object=none
		1081
		1082	EOF
		1083	fi
		1084
		1085	$run $mv "${libobj}T" "${libobj}"
		1086
		1087	# Unlock the critical section if it was locked
		1088	if test "$need_locks" != no; then
		1089	$run $rm "$lockfile"
		1090	fi
		1091
		1092	exit $EXIT_SUCCESS
		1093	;;
		1094
		1095	# libtool link mode
		1096	link \| relink)
		1097	modename="$modename: link"
		1098	case $host in
		1099	--cygwin* \| --mingw* \| --pw32* \| --os2*)
		1100	# It is impossible to link a dll without this setting, and
		1101	# we shouldn't force the makefile maintainer to figure out
		1102	# which system we are compiling for in order to pass an extra
		1103	# flag for every libtool invocation.
		1104	# allow_undefined=no
		1105
		1106	# FIXME: Unfortunately, there are problems with the above when trying
		1107	# to make a dll which has undefined symbols, in which case not
		1108	# even a static library is built. For now, we need to specify
		1109	# -no-undefined on the libtool link line when we can be certain
		1110	# that all symbols are satisfied, otherwise we get a static library.
		1111	allow_undefined=yes
		1112	;;
		1113	*)
		1114	allow_undefined=yes
		1115	;;
		1116	esac
		1117	libtool_args="$nonopt"
		1118	base_compile="$nonopt $@"
		1119	compile_command="$nonopt"
		1120	finalize_command="$nonopt"
		1121
		1122	compile_rpath=
		1123	finalize_rpath=
		1124	compile_shlibpath=
		1125	finalize_shlibpath=
		1126	convenience=
		1127	old_convenience=
		1128	deplibs=
		1129	old_deplibs=
		1130	compiler_flags=
		1131	linker_flags=
		1132	dllsearchpath=
		1133	lib_search_path=`pwd`
		1134	inst_prefix_dir=
		1135
		1136	avoid_version=no
		1137	dlfiles=
		1138	dlprefiles=
		1139	dlself=no
		1140	export_dynamic=no
		1141	export_symbols=
		1142	export_symbols_regex=
		1143	generated=
		1144	libobjs=
		1145	ltlibs=
		1146	module=no
		1147	no_install=no
		1148	objs=
		1149	non_pic_objects=
		1150	notinst_path= # paths that contain not-installed libtool libraries
		1151	precious_files_regex=
		1152	prefer_static_libs=no
		1153	preload=no
		1154	prev=
		1155	prevarg=
		1156	release=
		1157	rpath=
		1158	xrpath=
		1159	perm_rpath=
		1160	temp_rpath=
		1161	thread_safe=no
		1162	vinfo=
		1163	vinfo_number=no
		1164
		1165	func_infer_tag $base_compile
		1166
		1167	# We need to know -static, to get the right output filenames.
		1168	for arg
		1169	do
		1170	case $arg in
		1171	-all-static \| -static \| -static-libtool-libs)
		1172	case $arg in
		1173	-all-static)
		1174	if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
		1175	$echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
		1176	fi
		1177	if test -n "$link_static_flag"; then
		1178	dlopen_self=$dlopen_self_static
		1179	fi
		1180	prefer_static_libs=yes
		1181	;;
		1182	-static)
		1183	if test -z "$pic_flag" && test -n "$link_static_flag"; then
		1184	dlopen_self=$dlopen_self_static
		1185	fi
		1186	prefer_static_libs=built
		1187	;;
		1188	-static-libtool-libs)
		1189	if test -z "$pic_flag" && test -n "$link_static_flag"; then
		1190	dlopen_self=$dlopen_self_static
		1191	fi
		1192	prefer_static_libs=yes
		1193	;;
		1194	esac
		1195	build_libtool_libs=no
		1196	build_old_libs=yes
		1197	break
		1198	;;
		1199	esac
		1200	done
		1201
		1202	# See if our shared archives depend on static archives.
		1203	test -n "$old_archive_from_new_cmds" && build_old_libs=yes
		1204
		1205	# Go through the arguments, transforming them on the way.
		1206	while test "$#" -gt 0; do
		1207	arg="$1"
		1208	shift
		1209	case $arg in
		1210	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1211	qarg=\"`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
		1212	;;
		1213	*) qarg=$arg ;;
		1214	esac
		1215	libtool_args="$libtool_args $qarg"
		1216
		1217	# If the previous option needs an argument, assign it.
		1218	if test -n "$prev"; then
		1219	case $prev in
		1220	output)
		1221	compile_command="$compile_command @OUTPUT@"
		1222	finalize_command="$finalize_command @OUTPUT@"
		1223	;;
		1224	esac
		1225
		1226	case $prev in
		1227	dlfiles\|dlprefiles)
		1228	if test "$preload" = no; then
		1229	# Add the symbol object into the linking commands.
		1230	compile_command="$compile_command @SYMFILE@"
		1231	finalize_command="$finalize_command @SYMFILE@"
		1232	preload=yes
		1233	fi
		1234	case $arg in
		1235	.la \| .lo) ;; # We handle these cases below.
		1236	force)
		1237	if test "$dlself" = no; then
		1238	dlself=needless
		1239	export_dynamic=yes
		1240	fi
		1241	prev=
		1242	continue
		1243	;;
		1244	self)
		1245	if test "$prev" = dlprefiles; then
		1246	dlself=yes
		1247	elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
		1248	dlself=yes
		1249	else
		1250	dlself=needless
		1251	export_dynamic=yes
		1252	fi
		1253	prev=
		1254	continue
		1255	;;
		1256	*)
		1257	if test "$prev" = dlfiles; then
		1258	dlfiles="$dlfiles $arg"
		1259	else
		1260	dlprefiles="$dlprefiles $arg"
		1261	fi
		1262	prev=
		1263	continue
		1264	;;
		1265	esac
		1266	;;
		1267	expsyms)
		1268	export_symbols="$arg"
		1269	if test ! -f "$arg"; then
		1270	$echo "$modename: symbol file \`$arg' does not exist"
		1271	exit $EXIT_FAILURE
		1272	fi
		1273	prev=
		1274	continue
		1275	;;
		1276	expsyms_regex)
		1277	export_symbols_regex="$arg"
		1278	prev=
		1279	continue
		1280	;;
		1281	inst_prefix)
		1282	inst_prefix_dir="$arg"
		1283	prev=
		1284	continue
		1285	;;
		1286	precious_regex)
		1287	precious_files_regex="$arg"
		1288	prev=
		1289	continue
		1290	;;
		1291	release)
		1292	release="-$arg"
		1293	prev=
		1294	continue
		1295	;;
		1296	objectlist)
		1297	if test -f "$arg"; then
		1298	save_arg=$arg
		1299	moreargs=
		1300	for fil in `cat $save_arg`
		1301	do
		1302	# moreargs="$moreargs $fil"
		1303	arg=$fil
		1304	# A libtool-controlled object.
		1305
		1306	# Check to see that this really is a libtool object.
		1307	if (${SED} -e '2q' $arg \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		1308	pic_object=
		1309	non_pic_object=
		1310
		1311	# Read the .lo file
		1312	# If there is no directory component, then add one.
		1313	case $arg in
		1314	/ \| \\) . $arg ;;
		1315	*) . ./$arg ;;
		1316	esac
		1317
		1318	if test -z "$pic_object" \|\| \
		1319	test -z "$non_pic_object" \|\|
		1320	test "$pic_object" = none && \
		1321	test "$non_pic_object" = none; then
		1322	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
		1323	exit $EXIT_FAILURE
		1324	fi
		1325
		1326	# Extract subdirectory from the argument.
		1327	xdir=`$echo "X$arg" \| $Xsed -e 's%/[^/]*$%%'`
		1328	if test "X$xdir" = "X$arg"; then
		1329	xdir=
		1330	else
		1331	xdir="$xdir/"
		1332	fi
		1333
		1334	if test "$pic_object" != none; then
		1335	# Prepend the subdirectory the object is found in.
		1336	pic_object="$xdir$pic_object"
		1337
		1338	if test "$prev" = dlfiles; then
		1339	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		1340	dlfiles="$dlfiles $pic_object"
		1341	prev=
		1342	continue
		1343	else
		1344	# If libtool objects are unsupported, then we need to preload.
		1345	prev=dlprefiles
		1346	fi
		1347	fi
		1348
		1349	# CHECK ME: I think I busted this. -Ossama
		1350	if test "$prev" = dlprefiles; then
		1351	# Preload the old-style object.
		1352	dlprefiles="$dlprefiles $pic_object"
		1353	prev=
		1354	fi
		1355
		1356	# A PIC object.
		1357	libobjs="$libobjs $pic_object"
		1358	arg="$pic_object"
		1359	fi
		1360
		1361	# Non-PIC object.
		1362	if test "$non_pic_object" != none; then
		1363	# Prepend the subdirectory the object is found in.
		1364	non_pic_object="$xdir$non_pic_object"
		1365
		1366	# A standard non-PIC object
		1367	non_pic_objects="$non_pic_objects $non_pic_object"
		1368	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
		1369	arg="$non_pic_object"
		1370	fi
		1371	else
		1372	# If the PIC object exists, use it instead.
		1373	# $xdir was prepended to $pic_object above.
		1374	non_pic_object="$pic_object"
		1375	non_pic_objects="$non_pic_objects $non_pic_object"
		1376	fi
		1377	else
		1378	# Only an error if not doing a dry-run.
		1379	if test -z "$run"; then
		1380	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
		1381	exit $EXIT_FAILURE
		1382	else
		1383	# Dry-run case.
		1384
		1385	# Extract subdirectory from the argument.
		1386	xdir=`$echo "X$arg" \| $Xsed -e 's%/[^/]*$%%'`
		1387	if test "X$xdir" = "X$arg"; then
		1388	xdir=
		1389	else
		1390	xdir="$xdir/"
		1391	fi
		1392
		1393	pic_object=`$echo "X${xdir}${objdir}/${arg}" \| $Xsed -e "$lo2o"`
		1394	non_pic_object=`$echo "X${xdir}${arg}" \| $Xsed -e "$lo2o"`
		1395	libobjs="$libobjs $pic_object"
		1396	non_pic_objects="$non_pic_objects $non_pic_object"
		1397	fi
		1398	fi
		1399	done
		1400	else
		1401	$echo "$modename: link input file \`$save_arg' does not exist"
		1402	exit $EXIT_FAILURE
		1403	fi
		1404	arg=$save_arg
		1405	prev=
		1406	continue
		1407	;;
		1408	rpath \| xrpath)
		1409	# We need an absolute path.
		1410	case $arg in
		1411	[\\/]* \| [A-Za-z]:[\\/]*) ;;
		1412	*)
		1413	$echo "$modename: only absolute run-paths are allowed" 1>&2
		1414	exit $EXIT_FAILURE
		1415	;;
		1416	esac
		1417	if test "$prev" = rpath; then
		1418	case "$rpath " in
		1419	" $arg ") ;;
		1420	*) rpath="$rpath $arg" ;;
		1421	esac
		1422	else
		1423	case "$xrpath " in
		1424	" $arg ") ;;
		1425	*) xrpath="$xrpath $arg" ;;
		1426	esac
		1427	fi
		1428	prev=
		1429	continue
		1430	;;
		1431	xcompiler)
		1432	compiler_flags="$compiler_flags $qarg"
		1433	prev=
		1434	compile_command="$compile_command $qarg"
		1435	finalize_command="$finalize_command $qarg"
		1436	continue
		1437	;;
		1438	xlinker)
		1439	linker_flags="$linker_flags $qarg"
		1440	compiler_flags="$compiler_flags $wl$qarg"
		1441	prev=
		1442	compile_command="$compile_command $wl$qarg"
		1443	finalize_command="$finalize_command $wl$qarg"
		1444	continue
		1445	;;
		1446	xcclinker)
		1447	linker_flags="$linker_flags $qarg"
		1448	compiler_flags="$compiler_flags $qarg"
		1449	prev=
		1450	compile_command="$compile_command $qarg"
		1451	finalize_command="$finalize_command $qarg"
		1452	continue
		1453	;;
		1454	shrext)
		1455	shrext_cmds="$arg"
		1456	prev=
		1457	continue
		1458	;;
		1459	darwin_framework\|darwin_framework_skip)
		1460	test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
		1461	compile_command="$compile_command $arg"
		1462	finalize_command="$finalize_command $arg"
		1463	prev=
		1464	continue
		1465	;;
		1466	*)
		1467	eval "$prev=\"\$arg\""
		1468	prev=
		1469	continue
		1470	;;
		1471	esac
		1472	fi # test -n "$prev"
		1473
		1474	prevarg="$arg"
		1475
		1476	case $arg in
		1477	-all-static)
		1478	if test -n "$link_static_flag"; then
		1479	compile_command="$compile_command $link_static_flag"
		1480	finalize_command="$finalize_command $link_static_flag"
		1481	fi
		1482	continue
		1483	;;
		1484
		1485	-allow-undefined)
		1486	# FIXME: remove this flag sometime in the future.
		1487	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
		1488	continue
		1489	;;
		1490
		1491	-avoid-version)
		1492	avoid_version=yes
		1493	continue
		1494	;;
		1495
		1496	-dlopen)
		1497	prev=dlfiles
		1498	continue
		1499	;;
		1500
		1501	-dlpreopen)
		1502	prev=dlprefiles
		1503	continue
		1504	;;
		1505
		1506	-export-dynamic)
		1507	export_dynamic=yes
		1508	continue
		1509	;;
		1510
		1511	-export-symbols \| -export-symbols-regex)
		1512	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
		1513	$echo "$modename: more than one -exported-symbols argument is not allowed"
		1514	exit $EXIT_FAILURE
		1515	fi
		1516	if test "X$arg" = "X-export-symbols"; then
		1517	prev=expsyms
		1518	else
		1519	prev=expsyms_regex
		1520	fi
		1521	continue
		1522	;;
		1523
		1524	-framework\|-arch\|-isysroot)
		1525	case " $CC " in
		1526	" ${arg} ${1} " \| " ${arg} ${1} ")
		1527	prev=darwin_framework_skip ;;
		1528	*) compiler_flags="$compiler_flags $arg"
		1529	prev=darwin_framework ;;
		1530	esac
		1531	compile_command="$compile_command $arg"
		1532	finalize_command="$finalize_command $arg"
		1533	continue
		1534	;;
		1535
		1536	-inst-prefix-dir)
		1537	prev=inst_prefix
		1538	continue
		1539	;;
		1540
		1541	# The native IRIX linker understands -LANG:, -LIST: and -LNO:*
		1542	# so, if we see these flags be careful not to treat them like -L
		1543	-L[A-Z][A-Z]:)
		1544	case $with_gcc/$host in
		1545	no/--irix* \| /--irix*)
		1546	compile_command="$compile_command $arg"
		1547	finalize_command="$finalize_command $arg"
		1548	;;
		1549	esac
		1550	continue
		1551	;;
		1552
		1553	-L*)
		1554	dir=`$echo "X$arg" \| $Xsed -e 's/^-L//'`
		1555	# We need an absolute path.
		1556	case $dir in
		1557	[\\/]* \| [A-Za-z]:[\\/]*) ;;
		1558	*)
		1559	absdir=`cd "$dir" && pwd`
		1560	if test -z "$absdir"; then
		1561	$echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
		1562	absdir="$dir"
		1563	notinst_path="$notinst_path $dir"
		1564	fi
		1565	dir="$absdir"
		1566	;;
		1567	esac
		1568	case "$deplibs " in
		1569	" -L$dir ") ;;
		1570	*)
		1571	deplibs="$deplibs -L$dir"
		1572	lib_search_path="$lib_search_path $dir"
		1573	;;
		1574	esac
		1575	case $host in
		1576	--cygwin* \| --mingw* \| --pw32* \| --os2*)
		1577	testbindir=`$echo "X$dir" \| $Xsed -e 's/lib$/bin*'`
		1578	case :$dllsearchpath: in
		1579	":$dir:") ;;
		1580	*) dllsearchpath="$dllsearchpath:$dir";;
		1581	esac
		1582	case :$dllsearchpath: in
		1583	":$testbindir:") ;;
		1584	*) dllsearchpath="$dllsearchpath:$testbindir";;
		1585	esac
		1586	;;
		1587	esac
		1588	continue
		1589	;;
		1590
		1591	-l*)
		1592	if test "X$arg" = "X-lc" \|\| test "X$arg" = "X-lm"; then
		1593	case $host in
		1594	--cygwin* \| --mingw* \| --pw32* \| --beos*)
		1595	# These systems don't actually have a C or math library (as such)
		1596	continue
		1597	;;
		1598	--os2*)
		1599	# These systems don't actually have a C library (as such)
		1600	test "X$arg" = "X-lc" && continue
		1601	;;
		1602	--openbsd* \| --freebsd* \| --dragonfly*)
		1603	# Do not include libc due to us having libc/libc_r.
		1604	test "X$arg" = "X-lc" && continue
		1605	;;
		1606	--rhapsody* \| --darwin1.[012])
		1607	# Rhapsody C and math libraries are in the System framework
		1608	deplibs="$deplibs -framework System"
		1609	continue
		1610	;;
		1611	--sco3.2v5* \| --sco5v6*)
		1612	# Causes problems with __ctype
		1613	test "X$arg" = "X-lc" && continue
		1614	;;
		1615	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
		1616	# Compiler inserts libc in the correct place for threads to work
		1617	test "X$arg" = "X-lc" && continue
		1618	;;
		1619	esac
		1620	elif test "X$arg" = "X-lc_r"; then
		1621	case $host in
		1622	--openbsd* \| --freebsd* \| --dragonfly*)
		1623	# Do not include libc_r directly, use -pthread flag.
		1624	continue
		1625	;;
		1626	esac
		1627	fi
		1628	deplibs="$deplibs $arg"
		1629	continue
		1630	;;
		1631
		1632	# Tru64 UNIX uses -model [arg] to determine the layout of C++
		1633	# classes, name mangling, and exception handling.
		1634	-model)
		1635	compile_command="$compile_command $arg"
		1636	compiler_flags="$compiler_flags $arg"
		1637	finalize_command="$finalize_command $arg"
		1638	prev=xcompiler
		1639	continue
		1640	;;
		1641
		1642	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
		1643	compiler_flags="$compiler_flags $arg"
		1644	compile_command="$compile_command $arg"
		1645	finalize_command="$finalize_command $arg"
		1646	continue
		1647	;;
		1648
		1649	-module)
		1650	module=yes
		1651	continue
		1652	;;
		1653
		1654	# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
		1655	# -r[0-9][0-9]* specifies the processor on the SGI compiler
		1656	# -xarch=, -xtarget= enable 64-bit mode on the Sun compiler
		1657	# +DA, +DD enable 64-bit mode on the HP compiler
		1658	# -q* pass through compiler args for the IBM compiler
		1659	# -m* pass through architecture-specific compiler args for GCC
		1660	# -m, -t[45], -txscale* pass through architecture-specific
		1661	# compiler args for GCC
		1662	# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
		1663	# -F/path gives path to uninstalled frameworks, gcc on darwin
		1664	# @file GCC response files
		1665	-64\|-mips[0-9]\|-r[0-9][0-9]\|-xarch=\|-xtarget=\|+DA\|+DD\|-q\|-m*\| \
		1666	-t[45]\|-txscale\|-p\|-pg\|--coverage\|-fprofile-\|-F\|@*)
		1667
		1668	# Unknown arguments in both finalize_command and compile_command need
		1669	# to be aesthetically quoted because they are evaled later.
		1670	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
		1671	case $arg in
		1672	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1673	arg="\"$arg\""
		1674	;;
		1675	esac
		1676	compile_command="$compile_command $arg"
		1677	finalize_command="$finalize_command $arg"
		1678	compiler_flags="$compiler_flags $arg"
		1679	continue
		1680	;;
		1681
		1682	-shrext)
		1683	prev=shrext
		1684	continue
		1685	;;
		1686
		1687	-no-fast-install)
		1688	fast_install=no
		1689	continue
		1690	;;
		1691
		1692	-no-install)
		1693	case $host in
		1694	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --darwin*)
		1695	# The PATH hackery in wrapper scripts is required on Windows
		1696	# and Darwin in order for the loader to find any dlls it needs.
		1697	$echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
		1698	$echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
		1699	fast_install=no
		1700	;;
		1701	*) no_install=yes ;;
		1702	esac
		1703	continue
		1704	;;
		1705
		1706	-no-undefined)
		1707	allow_undefined=no
		1708	continue
		1709	;;
		1710
		1711	-objectlist)
		1712	prev=objectlist
		1713	continue
		1714	;;
		1715
		1716	-o) prev=output ;;
		1717
		1718	-precious-files-regex)
		1719	prev=precious_regex
		1720	continue
		1721	;;
		1722
		1723	-release)
		1724	prev=release
		1725	continue
		1726	;;
		1727
		1728	-rpath)
		1729	prev=rpath
		1730	continue
		1731	;;
		1732
		1733	-R)
		1734	prev=xrpath
		1735	continue
		1736	;;
		1737
		1738	-R*)
		1739	dir=`$echo "X$arg" \| $Xsed -e 's/^-R//'`
		1740	# We need an absolute path.
		1741	case $dir in
		1742	[\\/]* \| [A-Za-z]:[\\/]*) ;;
		1743	*)
		1744	$echo "$modename: only absolute run-paths are allowed" 1>&2
		1745	exit $EXIT_FAILURE
		1746	;;
		1747	esac
		1748	case "$xrpath " in
		1749	" $dir ") ;;
		1750	*) xrpath="$xrpath $dir" ;;
		1751	esac
		1752	continue
		1753	;;
		1754
		1755	-static \| -static-libtool-libs)
		1756	# The effects of -static are defined in a previous loop.
		1757	# We used to do the same as -all-static on platforms that
		1758	# didn't have a PIC flag, but the assumption that the effects
		1759	# would be equivalent was wrong. It would break on at least
		1760	# Digital Unix and AIX.
		1761	continue
		1762	;;
		1763
		1764	-thread-safe)
		1765	thread_safe=yes
		1766	continue
		1767	;;
		1768
		1769	-version-info)
		1770	prev=vinfo
		1771	continue
		1772	;;
		1773	-version-number)
		1774	prev=vinfo
		1775	vinfo_number=yes
		1776	continue
		1777	;;
		1778
		1779	-Wc,*)
		1780	args=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
		1781	arg=
		1782	save_ifs="$IFS"; IFS=','
		1783	for flag in $args; do
		1784	IFS="$save_ifs"
		1785	case $flag in
		1786	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1787	flag="\"$flag\""
		1788	;;
		1789	esac
		1790	arg="$arg $wl$flag"
		1791	compiler_flags="$compiler_flags $flag"
		1792	done
		1793	IFS="$save_ifs"
		1794	arg=`$echo "X$arg" \| $Xsed -e "s/^ //"`
		1795	;;
		1796
		1797	-Wl,*)
		1798	args=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
		1799	arg=
		1800	save_ifs="$IFS"; IFS=','
		1801	for flag in $args; do
		1802	IFS="$save_ifs"
		1803	case $flag in
		1804	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1805	flag="\"$flag\""
		1806	;;
		1807	esac
		1808	arg="$arg $wl$flag"
		1809	compiler_flags="$compiler_flags $wl$flag"
		1810	linker_flags="$linker_flags $flag"
		1811	done
		1812	IFS="$save_ifs"
		1813	arg=`$echo "X$arg" \| $Xsed -e "s/^ //"`
		1814	;;
		1815
		1816	-Xcompiler)
		1817	prev=xcompiler
		1818	continue
		1819	;;
		1820
		1821	-Xlinker)
		1822	prev=xlinker
		1823	continue
		1824	;;
		1825
		1826	-XCClinker)
		1827	prev=xcclinker
		1828	continue
		1829	;;
		1830
		1831	# Some other compiler flag.
		1832	-* \| +*)
		1833	# Unknown arguments in both finalize_command and compile_command need
		1834	# to be aesthetically quoted because they are evaled later.
		1835	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
		1836	case $arg in
		1837	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1838	arg="\"$arg\""
		1839	;;
		1840	esac
		1841	;;
		1842
		1843	*.$objext)
		1844	# A standard object.
		1845	objs="$objs $arg"
		1846	;;
		1847
		1848	*.lo)
		1849	# A libtool-controlled object.
		1850
		1851	# Check to see that this really is a libtool object.
		1852	if (${SED} -e '2q' $arg \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		1853	pic_object=
		1854	non_pic_object=
		1855
		1856	# Read the .lo file
		1857	# If there is no directory component, then add one.
		1858	case $arg in
		1859	/ \| \\) . $arg ;;
		1860	*) . ./$arg ;;
		1861	esac
		1862
		1863	if test -z "$pic_object" \|\| \
		1864	test -z "$non_pic_object" \|\|
		1865	test "$pic_object" = none && \
		1866	test "$non_pic_object" = none; then
		1867	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
		1868	exit $EXIT_FAILURE
		1869	fi
		1870
		1871	# Extract subdirectory from the argument.
		1872	xdir=`$echo "X$arg" \| $Xsed -e 's%/[^/]*$%%'`
		1873	if test "X$xdir" = "X$arg"; then
		1874	xdir=
		1875	else
		1876	xdir="$xdir/"
		1877	fi
		1878
		1879	if test "$pic_object" != none; then
		1880	# Prepend the subdirectory the object is found in.
		1881	pic_object="$xdir$pic_object"
		1882
		1883	if test "$prev" = dlfiles; then
		1884	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		1885	dlfiles="$dlfiles $pic_object"
		1886	prev=
		1887	continue
		1888	else
		1889	# If libtool objects are unsupported, then we need to preload.
		1890	prev=dlprefiles
		1891	fi
		1892	fi
		1893
		1894	# CHECK ME: I think I busted this. -Ossama
		1895	if test "$prev" = dlprefiles; then
		1896	# Preload the old-style object.
		1897	dlprefiles="$dlprefiles $pic_object"
		1898	prev=
		1899	fi
		1900
		1901	# A PIC object.
		1902	libobjs="$libobjs $pic_object"
		1903	arg="$pic_object"
		1904	fi
		1905
		1906	# Non-PIC object.
		1907	if test "$non_pic_object" != none; then
		1908	# Prepend the subdirectory the object is found in.
		1909	non_pic_object="$xdir$non_pic_object"
		1910
		1911	# A standard non-PIC object
		1912	non_pic_objects="$non_pic_objects $non_pic_object"
		1913	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
		1914	arg="$non_pic_object"
		1915	fi
		1916	else
		1917	# If the PIC object exists, use it instead.
		1918	# $xdir was prepended to $pic_object above.
		1919	non_pic_object="$pic_object"
		1920	non_pic_objects="$non_pic_objects $non_pic_object"
		1921	fi
		1922	else
		1923	# Only an error if not doing a dry-run.
		1924	if test -z "$run"; then
		1925	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
		1926	exit $EXIT_FAILURE
		1927	else
		1928	# Dry-run case.
		1929
		1930	# Extract subdirectory from the argument.
		1931	xdir=`$echo "X$arg" \| $Xsed -e 's%/[^/]*$%%'`
		1932	if test "X$xdir" = "X$arg"; then
		1933	xdir=
		1934	else
		1935	xdir="$xdir/"
		1936	fi
		1937
		1938	pic_object=`$echo "X${xdir}${objdir}/${arg}" \| $Xsed -e "$lo2o"`
		1939	non_pic_object=`$echo "X${xdir}${arg}" \| $Xsed -e "$lo2o"`
		1940	libobjs="$libobjs $pic_object"
		1941	non_pic_objects="$non_pic_objects $non_pic_object"
		1942	fi
		1943	fi
		1944	;;
		1945
		1946	*.$libext)
		1947	# An archive.
		1948	deplibs="$deplibs $arg"
		1949	old_deplibs="$old_deplibs $arg"
		1950	continue
		1951	;;
		1952
		1953	*.la)
		1954	# A libtool-controlled library.
		1955
		1956	if test "$prev" = dlfiles; then
		1957	# This library was specified with -dlopen.
		1958	dlfiles="$dlfiles $arg"
		1959	prev=
		1960	elif test "$prev" = dlprefiles; then
		1961	# The library was specified with -dlpreopen.
		1962	dlprefiles="$dlprefiles $arg"
		1963	prev=
		1964	else
		1965	deplibs="$deplibs $arg"
		1966	fi
		1967	continue
		1968	;;
		1969
		1970	# Some other compiler argument.
		1971	*)
		1972	# Unknown arguments in both finalize_command and compile_command need
		1973	# to be aesthetically quoted because they are evaled later.
		1974	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
		1975	case $arg in
		1976	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		1977	arg="\"$arg\""
		1978	;;
		1979	esac
		1980	;;
		1981	esac # arg
		1982
		1983	# Now actually substitute the argument into the commands.
		1984	if test -n "$arg"; then
		1985	compile_command="$compile_command $arg"
		1986	finalize_command="$finalize_command $arg"
		1987	fi
		1988	done # argument parsing loop
		1989
		1990	if test -n "$prev"; then
		1991	$echo "$modename: the \`$prevarg' option requires an argument" 1>&2
		1992	$echo "$help" 1>&2
		1993	exit $EXIT_FAILURE
		1994	fi
		1995
		1996	if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
		1997	eval arg=\"$export_dynamic_flag_spec\"
		1998	compile_command="$compile_command $arg"
		1999	finalize_command="$finalize_command $arg"
		2000	fi
		2001
		2002	oldlibs=
		2003	# calculate the name of the file, without its directory
		2004	outputname=`$echo "X$output" \| $Xsed -e 's%^.*/%%'`
		2005	libobjs_save="$libobjs"
		2006
		2007	if test -n "$shlibpath_var"; then
		2008	# get the directories listed in $shlibpath_var
		2009	eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \\| \$Xsed -e \'s/:/ /g\'\`
		2010	else
		2011	shlib_search_path=
		2012	fi
		2013	eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
		2014	eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
		2015
		2016	output_objdir=`$echo "X$output" \| $Xsed -e 's%/[^/]*$%%'`
		2017	if test "X$output_objdir" = "X$output"; then
		2018	output_objdir="$objdir"
		2019	else
		2020	output_objdir="$output_objdir/$objdir"
		2021	fi
		2022	# Create the object directory.
		2023	if test ! -d "$output_objdir"; then
		2024	$show "$mkdir $output_objdir"
		2025	$run $mkdir $output_objdir
		2026	exit_status=$?
		2027	if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
		2028	exit $exit_status
		2029	fi
		2030	fi
		2031
		2032	# Determine the type of output
		2033	case $output in
		2034	"")
		2035	$echo "$modename: you must specify an output file" 1>&2
		2036	$echo "$help" 1>&2
		2037	exit $EXIT_FAILURE
		2038	;;
		2039	*.$libext) linkmode=oldlib ;;
		2040	.lo \| .$objext) linkmode=obj ;;
		2041	*.la) linkmode=lib ;;
		2042	*) linkmode=prog ;; # Anything else should be a program.
		2043	esac
		2044
		2045	case $host in
		2046	cygwin \| mingw \| pw32)
		2047	# don't eliminate duplications in $postdeps and $predeps
		2048	duplicate_compiler_generated_deps=yes
		2049	;;
		2050	*)
		2051	duplicate_compiler_generated_deps=$duplicate_deps
		2052	;;
		2053	esac
		2054	specialdeplibs=
		2055
		2056	libs=
		2057	# Find all interdependent deplibs by searching for libraries
		2058	# that are linked more than once (e.g. -la -lb -la)
		2059	for deplib in $deplibs; do
		2060	if test "X$duplicate_deps" = "Xyes" ; then
		2061	case "$libs " in
		2062	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
		2063	esac
		2064	fi
		2065	libs="$libs $deplib"
		2066	done
		2067
		2068	if test "$linkmode" = lib; then
		2069	libs="$predeps $libs $compiler_lib_search_path $postdeps"
		2070
		2071	# Compute libraries that are listed more than once in $predeps
		2072	# $postdeps and mark them as special (i.e., whose duplicates are
		2073	# not to be eliminated).
		2074	pre_post_deps=
		2075	if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
		2076	for pre_post_dep in $predeps $postdeps; do
		2077	case "$pre_post_deps " in
		2078	" $pre_post_dep ") specialdeplibs="$specialdeplibs $pre_post_deps" ;;
		2079	esac
		2080	pre_post_deps="$pre_post_deps $pre_post_dep"
		2081	done
		2082	fi
		2083	pre_post_deps=
		2084	fi
		2085
		2086	deplibs=
		2087	newdependency_libs=
		2088	newlib_search_path=
		2089	need_relink=no # whether we're linking any uninstalled libtool libraries
		2090	notinst_deplibs= # not-installed libtool libraries
		2091	case $linkmode in
		2092	lib)
		2093	passes="conv link"
		2094	for file in $dlfiles $dlprefiles; do
		2095	case $file in
		2096	*.la) ;;
		2097	*)
		2098	$echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
		2099	exit $EXIT_FAILURE
		2100	;;
		2101	esac
		2102	done
		2103	;;
		2104	prog)
		2105	compile_deplibs=
		2106	finalize_deplibs=
		2107	alldeplibs=no
		2108	newdlfiles=
		2109	newdlprefiles=
		2110	passes="conv scan dlopen dlpreopen link"
		2111	;;
		2112	*) passes="conv"
		2113	;;
		2114	esac
		2115	for pass in $passes; do
		2116	if test "$linkmode,$pass" = "lib,link" \|\|
		2117	test "$linkmode,$pass" = "prog,scan"; then
		2118	libs="$deplibs"
		2119	deplibs=
		2120	fi
		2121	if test "$linkmode" = prog; then
		2122	case $pass in
		2123	dlopen) libs="$dlfiles" ;;
		2124	dlpreopen) libs="$dlprefiles" ;;
		2125	link)
		2126	libs="$deplibs %DEPLIBS%"
		2127	test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
		2128	;;
		2129	esac
		2130	fi
		2131	if test "$pass" = dlopen; then
		2132	# Collect dlpreopened libraries
		2133	save_deplibs="$deplibs"
		2134	deplibs=
		2135	fi
		2136	for deplib in $libs; do
		2137	lib=
		2138	found=no
		2139	case $deplib in
		2140	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
		2141	if test "$linkmode,$pass" = "prog,link"; then
		2142	compile_deplibs="$deplib $compile_deplibs"
		2143	finalize_deplibs="$deplib $finalize_deplibs"
		2144	else
		2145	compiler_flags="$compiler_flags $deplib"
		2146	fi
		2147	continue
		2148	;;
		2149	-l*)
		2150	if test "$linkmode" != lib && test "$linkmode" != prog; then
		2151	$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
		2152	continue
		2153	fi
		2154	name=`$echo "X$deplib" \| $Xsed -e 's/^-l//'`
		2155	for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
		2156	for search_ext in .la $std_shrext .so .a; do
		2157	# Search the libtool library
		2158	lib="$searchdir/lib${name}${search_ext}"
		2159	if test -f "$lib"; then
		2160	if test "$search_ext" = ".la"; then
		2161	found=yes
		2162	else
		2163	found=no
		2164	fi
		2165	break 2
		2166	fi
		2167	done
		2168	done
		2169	if test "$found" != yes; then
		2170	# deplib doesn't seem to be a libtool library
		2171	if test "$linkmode,$pass" = "prog,link"; then
		2172	compile_deplibs="$deplib $compile_deplibs"
		2173	finalize_deplibs="$deplib $finalize_deplibs"
		2174	else
		2175	deplibs="$deplib $deplibs"
		2176	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
		2177	fi
		2178	continue
		2179	else # deplib is a libtool library
		2180	# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
		2181	# We need to do some special things here, and not later.
		2182	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		2183	case " $predeps $postdeps " in
		2184	" $deplib ")
		2185	if (${SED} -e '2q' $lib \|
		2186	grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		2187	library_names=
		2188	old_library=
		2189	case $lib in
		2190	/ \| \\) . $lib ;;
		2191	*) . ./$lib ;;
		2192	esac
		2193	for l in $old_library $library_names; do
		2194	ll="$l"
		2195	done
		2196	if test "X$ll" = "X$old_library" ; then # only static version available
		2197	found=no
		2198	ladir=`$echo "X$lib" \| $Xsed -e 's%/[^/]*$%%'`
		2199	test "X$ladir" = "X$lib" && ladir="."
		2200	lib=$ladir/$old_library
		2201	if test "$linkmode,$pass" = "prog,link"; then
		2202	compile_deplibs="$deplib $compile_deplibs"
		2203	finalize_deplibs="$deplib $finalize_deplibs"
		2204	else
		2205	deplibs="$deplib $deplibs"
		2206	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
		2207	fi
		2208	continue
		2209	fi
		2210	fi
		2211	;;
		2212	*) ;;
		2213	esac
		2214	fi
		2215	fi
		2216	;; # -l
		2217	-L*)
		2218	case $linkmode in
		2219	lib)
		2220	deplibs="$deplib $deplibs"
		2221	test "$pass" = conv && continue
		2222	newdependency_libs="$deplib $newdependency_libs"
		2223	newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`
		2224	;;
		2225	prog)
		2226	if test "$pass" = conv; then
		2227	deplibs="$deplib $deplibs"
		2228	continue
		2229	fi
		2230	if test "$pass" = scan; then
		2231	deplibs="$deplib $deplibs"
		2232	else
		2233	compile_deplibs="$deplib $compile_deplibs"
		2234	finalize_deplibs="$deplib $finalize_deplibs"
		2235	fi
		2236	newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`
		2237	;;
		2238	*)
		2239	$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
		2240	;;
		2241	esac # linkmode
		2242	continue
		2243	;; # -L
		2244	-R*)
		2245	if test "$pass" = link; then
		2246	dir=`$echo "X$deplib" \| $Xsed -e 's/^-R//'`
		2247	# Make sure the xrpath contains only unique directories.
		2248	case "$xrpath " in
		2249	" $dir ") ;;
		2250	*) xrpath="$xrpath $dir" ;;
		2251	esac
		2252	fi
		2253	deplibs="$deplib $deplibs"
		2254	continue
		2255	;;
		2256	*.la) lib="$deplib" ;;
		2257	*.$libext)
		2258	if test "$pass" = conv; then
		2259	deplibs="$deplib $deplibs"
		2260	continue
		2261	fi
		2262	case $linkmode in
		2263	lib)
		2264	valid_a_lib=no
		2265	case $deplibs_check_method in
		2266	match_pattern*)
		2267	set dummy $deplibs_check_method
		2268	match_pattern_regex=`expr "$deplibs_check_method" : "$2 $.*$"`
		2269	if eval $echo \"$deplib\" 2>/dev/null \
		2270	\| $SED 10q \
		2271	\| $EGREP "$match_pattern_regex" > /dev/null; then
		2272	valid_a_lib=yes
		2273	fi
		2274	;;
		2275	pass_all)
		2276	valid_a_lib=yes
		2277	;;
		2278	esac
		2279	if test "$valid_a_lib" != yes; then
		2280	$echo
		2281	$echo "*** Warning: Trying to link with static lib archive $deplib."
		2282	$echo "*** I have the capability to make that library automatically link in when"
		2283	$echo "*** you link to this library. But I can only do this if you have a"
		2284	$echo "*** shared version of the library, which you do not appear to have"
		2285	$echo "*** because the file extensions .$libext of this argument makes me believe"
		2286	$echo "*** that it is just a static archive that I should not used here."
		2287	else
		2288	$echo
		2289	$echo "*** Warning: Linking the shared library $output against the"
		2290	$echo "*** static library $deplib is not portable!"
		2291	deplibs="$deplib $deplibs"
		2292	fi
		2293	continue
		2294	;;
		2295	prog)
		2296	if test "$pass" != link; then
		2297	deplibs="$deplib $deplibs"
		2298	else
		2299	compile_deplibs="$deplib $compile_deplibs"
		2300	finalize_deplibs="$deplib $finalize_deplibs"
		2301	fi
		2302	continue
		2303	;;
		2304	esac # linkmode
		2305	;; # *.$libext
		2306	.lo \| .$objext)
		2307	if test "$pass" = conv; then
		2308	deplibs="$deplib $deplibs"
		2309	elif test "$linkmode" = prog; then
		2310	if test "$pass" = dlpreopen \|\| test "$dlopen_support" != yes \|\| test "$build_libtool_libs" = no; then
		2311	# If there is no dlopen support or we're linking statically,
		2312	# we need to preload.
		2313	newdlprefiles="$newdlprefiles $deplib"
		2314	compile_deplibs="$deplib $compile_deplibs"
		2315	finalize_deplibs="$deplib $finalize_deplibs"
		2316	else
		2317	newdlfiles="$newdlfiles $deplib"
		2318	fi
		2319	fi
		2320	continue
		2321	;;
		2322	%DEPLIBS%)
		2323	alldeplibs=yes
		2324	continue
		2325	;;
		2326	esac # case $deplib
		2327	if test "$found" = yes \|\| test -f "$lib"; then :
		2328	else
		2329	$echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
		2330	exit $EXIT_FAILURE
		2331	fi
		2332
		2333	# Check to see that this really is a libtool archive.
		2334	if (${SED} -e '2q' $lib \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
		2335	else
		2336	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		2337	exit $EXIT_FAILURE
		2338	fi
		2339
		2340	ladir=`$echo "X$lib" \| $Xsed -e 's%/[^/]*$%%'`
		2341	test "X$ladir" = "X$lib" && ladir="."
		2342
		2343	dlname=
		2344	dlopen=
		2345	dlpreopen=
		2346	libdir=
		2347	library_names=
		2348	old_library=
		2349	# If the library was installed with an old release of libtool,
		2350	# it will not redefine variables installed, or shouldnotlink
		2351	installed=yes
		2352	shouldnotlink=no
		2353	avoidtemprpath=
		2354
		2355
		2356	# Read the .la file
		2357	case $lib in
		2358	/ \| \\) . $lib ;;
		2359	*) . ./$lib ;;
		2360	esac
		2361
		2362	if test "$linkmode,$pass" = "lib,link" \|\|
		2363	test "$linkmode,$pass" = "prog,scan" \|\|
		2364	{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
		2365	test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
		2366	test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
		2367	fi
		2368
		2369	if test "$pass" = conv; then
		2370	# Only check for convenience libraries
		2371	deplibs="$lib $deplibs"
		2372	if test -z "$libdir"; then
		2373	if test -z "$old_library"; then
		2374	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
		2375	exit $EXIT_FAILURE
		2376	fi
		2377	# It is a libtool convenience library, so add in its objects.
		2378	convenience="$convenience $ladir/$objdir/$old_library"
		2379	old_convenience="$old_convenience $ladir/$objdir/$old_library"
		2380	tmp_libs=
		2381	for deplib in $dependency_libs; do
		2382	deplibs="$deplib $deplibs"
		2383	if test "X$duplicate_deps" = "Xyes" ; then
		2384	case "$tmp_libs " in
		2385	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
		2386	esac
		2387	fi
		2388	tmp_libs="$tmp_libs $deplib"
		2389	done
		2390	elif test "$linkmode" != prog && test "$linkmode" != lib; then
		2391	$echo "$modename: \`$lib' is not a convenience library" 1>&2
		2392	exit $EXIT_FAILURE
		2393	fi
		2394	continue
		2395	fi # $pass = conv
		2396
		2397
		2398	# Get the name of the library we link against.
		2399	linklib=
		2400	for l in $old_library $library_names; do
		2401	linklib="$l"
		2402	done
		2403	if test -z "$linklib"; then
		2404	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
		2405	exit $EXIT_FAILURE
		2406	fi
		2407
		2408	# This library was specified with -dlopen.
		2409	if test "$pass" = dlopen; then
		2410	if test -z "$libdir"; then
		2411	$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
		2412	exit $EXIT_FAILURE
		2413	fi
		2414	if test -z "$dlname" \|\|
		2415	test "$dlopen_support" != yes \|\|
		2416	test "$build_libtool_libs" = no; then
		2417	# If there is no dlname, no dlopen support or we're linking
		2418	# statically, we need to preload. We also need to preload any
		2419	# dependent libraries so libltdl's deplib preloader doesn't
		2420	# bomb out in the load deplibs phase.
		2421	dlprefiles="$dlprefiles $lib $dependency_libs"
		2422	else
		2423	newdlfiles="$newdlfiles $lib"
		2424	fi
		2425	continue
		2426	fi # $pass = dlopen
		2427
		2428	# We need an absolute path.
		2429	case $ladir in
		2430	[\\/]* \| [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
		2431	*)
		2432	abs_ladir=`cd "$ladir" && pwd`
		2433	if test -z "$abs_ladir"; then
		2434	$echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
		2435	$echo "$modename: passing it literally to the linker, although it might fail" 1>&2
		2436	abs_ladir="$ladir"
		2437	fi
		2438	;;
		2439	esac
		2440	laname=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
		2441
		2442	# Find the relevant object directory and library name.
		2443	if test "X$installed" = Xyes; then
		2444	if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
		2445	$echo "$modename: warning: library \`$lib' was moved." 1>&2
		2446	dir="$ladir"
		2447	absdir="$abs_ladir"
		2448	libdir="$abs_ladir"
		2449	else
		2450	dir="$libdir"
		2451	absdir="$libdir"
		2452	fi
		2453	test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
		2454	else
		2455	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
		2456	dir="$ladir"
		2457	absdir="$abs_ladir"
		2458	# Remove this search path later
		2459	notinst_path="$notinst_path $abs_ladir"
		2460	else
		2461	dir="$ladir/$objdir"
		2462	absdir="$abs_ladir/$objdir"
		2463	# Remove this search path later
		2464	notinst_path="$notinst_path $abs_ladir"
		2465	fi
		2466	fi # $installed = yes
		2467	name=`$echo "X$laname" \| $Xsed -e 's/\.la$//' -e 's/^lib//'`
		2468
		2469	# This library was specified with -dlpreopen.
		2470	if test "$pass" = dlpreopen; then
		2471	if test -z "$libdir"; then
		2472	$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
		2473	exit $EXIT_FAILURE
		2474	fi
		2475	# Prefer using a static library (so that no silly _DYNAMIC symbols
		2476	# are required to link).
		2477	if test -n "$old_library"; then
		2478	newdlprefiles="$newdlprefiles $dir/$old_library"
		2479	# Otherwise, use the dlname, so that lt_dlopen finds it.
		2480	elif test -n "$dlname"; then
		2481	newdlprefiles="$newdlprefiles $dir/$dlname"
		2482	else
		2483	newdlprefiles="$newdlprefiles $dir/$linklib"
		2484	fi
		2485	fi # $pass = dlpreopen
		2486
		2487	if test -z "$libdir"; then
		2488	# Link the convenience library
		2489	if test "$linkmode" = lib; then
		2490	deplibs="$dir/$old_library $deplibs"
		2491	elif test "$linkmode,$pass" = "prog,link"; then
		2492	compile_deplibs="$dir/$old_library $compile_deplibs"
		2493	finalize_deplibs="$dir/$old_library $finalize_deplibs"
		2494	else
		2495	deplibs="$lib $deplibs" # used for prog,scan pass
		2496	fi
		2497	continue
		2498	fi
		2499
		2500
		2501	if test "$linkmode" = prog && test "$pass" != link; then
		2502	newlib_search_path="$newlib_search_path $ladir"
		2503	deplibs="$lib $deplibs"
		2504
		2505	linkalldeplibs=no
		2506	if test "$link_all_deplibs" != no \|\| test -z "$library_names" \|\|
		2507	test "$build_libtool_libs" = no; then
		2508	linkalldeplibs=yes
		2509	fi
		2510
		2511	tmp_libs=
		2512	for deplib in $dependency_libs; do
		2513	case $deplib in
		2514	-L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
		2515	esac
		2516	# Need to link against all dependency_libs?
		2517	if test "$linkalldeplibs" = yes; then
		2518	deplibs="$deplib $deplibs"
		2519	else
		2520	# Need to hardcode shared library paths
		2521	# or/and link against static libraries
		2522	newdependency_libs="$deplib $newdependency_libs"
		2523	fi
		2524	if test "X$duplicate_deps" = "Xyes" ; then
		2525	case "$tmp_libs " in
		2526	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
		2527	esac
		2528	fi
		2529	tmp_libs="$tmp_libs $deplib"
		2530	done # for deplib
		2531	continue
		2532	fi # $linkmode = prog...
		2533
		2534	if test "$linkmode,$pass" = "prog,link"; then
		2535	if test -n "$library_names" &&
		2536	{ { test "$prefer_static_libs" = no \|\|
		2537	test "$prefer_static_libs,$installed" = "built,yes"; } \|\|
		2538	test -z "$old_library"; }; then
		2539	# We need to hardcode the library path
		2540	if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
		2541	# Make sure the rpath contains only unique directories.
		2542	case "$temp_rpath " in
		2543	" $dir ") ;;
		2544	" $absdir ") ;;
		2545	*) temp_rpath="$temp_rpath $absdir" ;;
		2546	esac
		2547	fi
		2548
		2549	# Hardcode the library path.
		2550	# Skip directories that are in the system default run-time
		2551	# search path.
		2552	case " $sys_lib_dlsearch_path " in
		2553	" $absdir ") ;;
		2554	*)
		2555	case "$compile_rpath " in
		2556	" $absdir ") ;;
		2557	*) compile_rpath="$compile_rpath $absdir"
		2558	esac
		2559	;;
		2560	esac
		2561	case " $sys_lib_dlsearch_path " in
		2562	" $libdir ") ;;
		2563	*)
		2564	case "$finalize_rpath " in
		2565	" $libdir ") ;;
		2566	*) finalize_rpath="$finalize_rpath $libdir"
		2567	esac
		2568	;;
		2569	esac
		2570	fi # $linkmode,$pass = prog,link...
		2571
		2572	if test "$alldeplibs" = yes &&
		2573	{ test "$deplibs_check_method" = pass_all \|\|
		2574	{ test "$build_libtool_libs" = yes &&
		2575	test -n "$library_names"; }; }; then
		2576	# We only need to search for static libraries
		2577	continue
		2578	fi
		2579	fi
		2580
		2581	link_static=no # Whether the deplib will be linked statically
		2582	use_static_libs=$prefer_static_libs
		2583	if test "$use_static_libs" = built && test "$installed" = yes ; then
		2584	use_static_libs=no
		2585	fi
		2586	if test -n "$library_names" &&
		2587	{ test "$use_static_libs" = no \|\| test -z "$old_library"; }; then
		2588	if test "$installed" = no; then
		2589	notinst_deplibs="$notinst_deplibs $lib"
		2590	need_relink=yes
		2591	fi
		2592	# This is a shared library
		2593
		2594	# Warn about portability, can't link against -module's on
		2595	# some systems (darwin)
		2596	if test "$shouldnotlink" = yes && test "$pass" = link ; then
		2597	$echo
		2598	if test "$linkmode" = prog; then
		2599	$echo "*** Warning: Linking the executable $output against the loadable module"
		2600	else
		2601	$echo "*** Warning: Linking the shared library $output against the loadable module"
		2602	fi
		2603	$echo "*** $linklib is not portable!"
		2604	fi
		2605	if test "$linkmode" = lib &&
		2606	test "$hardcode_into_libs" = yes; then
		2607	# Hardcode the library path.
		2608	# Skip directories that are in the system default run-time
		2609	# search path.
		2610	case " $sys_lib_dlsearch_path " in
		2611	" $absdir ") ;;
		2612	*)
		2613	case "$compile_rpath " in
		2614	" $absdir ") ;;
		2615	*) compile_rpath="$compile_rpath $absdir"
		2616	esac
		2617	;;
		2618	esac
		2619	case " $sys_lib_dlsearch_path " in
		2620	" $libdir ") ;;
		2621	*)
		2622	case "$finalize_rpath " in
		2623	" $libdir ") ;;
		2624	*) finalize_rpath="$finalize_rpath $libdir"
		2625	esac
		2626	;;
		2627	esac
		2628	fi
		2629
		2630	if test -n "$old_archive_from_expsyms_cmds"; then
		2631	# figure out the soname
		2632	set dummy $library_names
		2633	realname="$2"
		2634	shift; shift
		2635	libname=`eval \\$echo \"$libname_spec\"`
		2636	# use dlname if we got it. it's perfectly good, no?
		2637	if test -n "$dlname"; then
		2638	soname="$dlname"
		2639	elif test -n "$soname_spec"; then
		2640	# bleh windows
		2641	case $host in
		2642	cygwin \| mingw*)
		2643	major=`expr $current - $age`
		2644	versuffix="-$major"
		2645	;;
		2646	esac
		2647	eval soname=\"$soname_spec\"
		2648	else
		2649	soname="$realname"
		2650	fi
		2651
		2652	# Make a new name for the extract_expsyms_cmds to use
		2653	soroot="$soname"
		2654	soname=`$echo $soroot \| ${SED} -e 's/^.*\///'`
		2655	newlib="libimp-`$echo $soname \| ${SED} 's/^lib//;s/\.dll$//'`.a"
		2656
		2657	# If the library has no export list, then create one now
		2658	if test -f "$output_objdir/$soname-def"; then :
		2659	else
		2660	$show "extracting exported symbol list from \`$soname'"
		2661	save_ifs="$IFS"; IFS='~'
		2662	cmds=$extract_expsyms_cmds
		2663	for cmd in $cmds; do
		2664	IFS="$save_ifs"
		2665	eval cmd=\"$cmd\"
		2666	$show "$cmd"
		2667	$run eval "$cmd" \|\| exit $?
		2668	done
		2669	IFS="$save_ifs"
		2670	fi
		2671
		2672	# Create $newlib
		2673	if test -f "$output_objdir/$newlib"; then :; else
		2674	$show "generating import library for \`$soname'"
		2675	save_ifs="$IFS"; IFS='~'
		2676	cmds=$old_archive_from_expsyms_cmds
		2677	for cmd in $cmds; do
		2678	IFS="$save_ifs"
		2679	eval cmd=\"$cmd\"
		2680	$show "$cmd"
		2681	$run eval "$cmd" \|\| exit $?
		2682	done
		2683	IFS="$save_ifs"
		2684	fi
		2685	# make sure the library variables are pointing to the new library
		2686	dir=$output_objdir
		2687	linklib=$newlib
		2688	fi # test -n "$old_archive_from_expsyms_cmds"
		2689
		2690	if test "$linkmode" = prog \|\| test "$mode" != relink; then
		2691	add_shlibpath=
		2692	add_dir=
		2693	add=
		2694	lib_linked=yes
		2695	case $hardcode_action in
		2696	immediate \| unsupported)
		2697	if test "$hardcode_direct" = no; then
		2698	add="$dir/$linklib"
		2699	case $host in
		2700	--sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
		2701	--sysv4uw2) add_dir="-L$dir" ;;
		2702	--sysv5OpenUNIX* \| --sysv5UnixWare7.[01].[10]* \| \
		2703	--unixware7*) add_dir="-L$dir" ;;
		2704	--darwin* )
		2705	# if the lib is a module then we can not link against
		2706	# it, someone is ignoring the new warnings I added
		2707	if /usr/bin/file -L $add 2> /dev/null \|
		2708	$EGREP ": [^:]* bundle" >/dev/null ; then
		2709	$echo "** Warning, lib $linklib is a module, not a shared library"
		2710	if test -z "$old_library" ; then
		2711	$echo
		2712	$echo "** And there doesn't seem to be a static archive available"
		2713	$echo "** The link will probably fail, sorry"
		2714	else
		2715	add="$dir/$old_library"
		2716	fi
		2717	fi
		2718	esac
		2719	elif test "$hardcode_minus_L" = no; then
		2720	case $host in
		2721	--sunos*) add_shlibpath="$dir" ;;
		2722	esac
		2723	add_dir="-L$dir"
		2724	add="-l$name"
		2725	elif test "$hardcode_shlibpath_var" = no; then
		2726	add_shlibpath="$dir"
		2727	add="-l$name"
		2728	else
		2729	lib_linked=no
		2730	fi
		2731	;;
		2732	relink)
		2733	if test "$hardcode_direct" = yes; then
		2734	add="$dir/$linklib"
		2735	elif test "$hardcode_minus_L" = yes; then
		2736	add_dir="-L$dir"
		2737	# Try looking first in the location we're being installed to.
		2738	if test -n "$inst_prefix_dir"; then
		2739	case $libdir in
		2740	[\\/]*)
		2741	add_dir="$add_dir -L$inst_prefix_dir$libdir"
		2742	;;
		2743	esac
		2744	fi
		2745	add="-l$name"
		2746	elif test "$hardcode_shlibpath_var" = yes; then
		2747	add_shlibpath="$dir"
		2748	add="-l$name"
		2749	else
		2750	lib_linked=no
		2751	fi
		2752	;;
		2753	*) lib_linked=no ;;
		2754	esac
		2755
		2756	if test "$lib_linked" != yes; then
		2757	$echo "$modename: configuration error: unsupported hardcode properties"
		2758	exit $EXIT_FAILURE
		2759	fi
		2760
		2761	if test -n "$add_shlibpath"; then
		2762	case :$compile_shlibpath: in
		2763	":$add_shlibpath:") ;;
		2764	*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
		2765	esac
		2766	fi
		2767	if test "$linkmode" = prog; then
		2768	test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
		2769	test -n "$add" && compile_deplibs="$add $compile_deplibs"
		2770	else
		2771	test -n "$add_dir" && deplibs="$add_dir $deplibs"
		2772	test -n "$add" && deplibs="$add $deplibs"
		2773	if test "$hardcode_direct" != yes && \
		2774	test "$hardcode_minus_L" != yes && \
		2775	test "$hardcode_shlibpath_var" = yes; then
		2776	case :$finalize_shlibpath: in
		2777	":$libdir:") ;;
		2778	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
		2779	esac
		2780	fi
		2781	fi
		2782	fi
		2783
		2784	if test "$linkmode" = prog \|\| test "$mode" = relink; then
		2785	add_shlibpath=
		2786	add_dir=
		2787	add=
		2788	# Finalize command for both is simple: just hardcode it.
		2789	if test "$hardcode_direct" = yes; then
		2790	add="$libdir/$linklib"
		2791	elif test "$hardcode_minus_L" = yes; then
		2792	add_dir="-L$libdir"
		2793	add="-l$name"
		2794	elif test "$hardcode_shlibpath_var" = yes; then
		2795	case :$finalize_shlibpath: in
		2796	":$libdir:") ;;
		2797	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
		2798	esac
		2799	add="-l$name"
		2800	elif test "$hardcode_automatic" = yes; then
		2801	if test -n "$inst_prefix_dir" &&
		2802	test -f "$inst_prefix_dir$libdir/$linklib" ; then
		2803	add="$inst_prefix_dir$libdir/$linklib"
		2804	else
		2805	add="$libdir/$linklib"
		2806	fi
		2807	else
		2808	# We cannot seem to hardcode it, guess we'll fake it.
		2809	add_dir="-L$libdir"
		2810	# Try looking first in the location we're being installed to.
		2811	if test -n "$inst_prefix_dir"; then
		2812	case $libdir in
		2813	[\\/]*)
		2814	add_dir="$add_dir -L$inst_prefix_dir$libdir"
		2815	;;
		2816	esac
		2817	fi
		2818	add="-l$name"
		2819	fi
		2820
		2821	if test "$linkmode" = prog; then
		2822	test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
		2823	test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
		2824	else
		2825	test -n "$add_dir" && deplibs="$add_dir $deplibs"
		2826	test -n "$add" && deplibs="$add $deplibs"
		2827	fi
		2828	fi
		2829	elif test "$linkmode" = prog; then
		2830	# Here we assume that one of hardcode_direct or hardcode_minus_L
		2831	# is not unsupported. This is valid on all known static and
		2832	# shared platforms.
		2833	if test "$hardcode_direct" != unsupported; then
		2834	test -n "$old_library" && linklib="$old_library"
		2835	compile_deplibs="$dir/$linklib $compile_deplibs"
		2836	finalize_deplibs="$dir/$linklib $finalize_deplibs"
		2837	else
		2838	compile_deplibs="-l$name -L$dir $compile_deplibs"
		2839	finalize_deplibs="-l$name -L$dir $finalize_deplibs"
		2840	fi
		2841	elif test "$build_libtool_libs" = yes; then
		2842	# Not a shared library
		2843	if test "$deplibs_check_method" != pass_all; then
		2844	# We're trying link a shared library against a static one
		2845	# but the system doesn't support it.
		2846
		2847	# Just print a warning and add the library to dependency_libs so
		2848	# that the program can be linked against the static library.
		2849	$echo
		2850	$echo "*** Warning: This system can not link to static lib archive $lib."
		2851	$echo "*** I have the capability to make that library automatically link in when"
		2852	$echo "*** you link to this library. But I can only do this if you have a"
		2853	$echo "*** shared version of the library, which you do not appear to have."
		2854	if test "$module" = yes; then
		2855	$echo "*** But as you try to build a module library, libtool will still create "
		2856	$echo "*** a static module, that should work as long as the dlopening application"
		2857	$echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
		2858	if test -z "$global_symbol_pipe"; then
		2859	$echo
		2860	$echo "*** However, this would only work if libtool was able to extract symbol"
		2861	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
		2862	$echo "*** not find such a program. So, this module is probably useless."
		2863	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
		2864	fi
		2865	if test "$build_old_libs" = no; then
		2866	build_libtool_libs=module
		2867	build_old_libs=yes
		2868	else
		2869	build_libtool_libs=no
		2870	fi
		2871	fi
		2872	else
		2873	deplibs="$dir/$old_library $deplibs"
		2874	link_static=yes
		2875	fi
		2876	fi # link shared/static library?
		2877
		2878	if test "$linkmode" = lib; then
		2879	if test -n "$dependency_libs" &&
		2880	{ test "$hardcode_into_libs" != yes \|\|
		2881	test "$build_old_libs" = yes \|\|
		2882	test "$link_static" = yes; }; then
		2883	# Extract -R from dependency_libs
		2884	temp_deplibs=
		2885	for libdir in $dependency_libs; do
		2886	case $libdir in
		2887	-R*) temp_xrpath=`$echo "X$libdir" \| $Xsed -e 's/^-R//'`
		2888	case " $xrpath " in
		2889	" $temp_xrpath ") ;;
		2890	*) xrpath="$xrpath $temp_xrpath";;
		2891	esac;;
		2892	*) temp_deplibs="$temp_deplibs $libdir";;
		2893	esac
		2894	done
		2895	dependency_libs="$temp_deplibs"
		2896	fi
		2897
		2898	newlib_search_path="$newlib_search_path $absdir"
		2899	# Link against this library
		2900	test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
		2901	# ... and its dependency_libs
		2902	tmp_libs=
		2903	for deplib in $dependency_libs; do
		2904	newdependency_libs="$deplib $newdependency_libs"
		2905	if test "X$duplicate_deps" = "Xyes" ; then
		2906	case "$tmp_libs " in
		2907	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
		2908	esac
		2909	fi
		2910	tmp_libs="$tmp_libs $deplib"
		2911	done
		2912
		2913	if test "$link_all_deplibs" != no; then
		2914	# Add the search paths of all dependency libraries
		2915	for deplib in $dependency_libs; do
		2916	case $deplib in
		2917	-L*) path="$deplib" ;;
		2918	*.la)
		2919	dir=`$echo "X$deplib" \| $Xsed -e 's%/[^/]*$%%'`
		2920	test "X$dir" = "X$deplib" && dir="."
		2921	# We need an absolute path.
		2922	case $dir in
		2923	[\\/]* \| [A-Za-z]:[\\/]*) absdir="$dir" ;;
		2924	*)
		2925	absdir=`cd "$dir" && pwd`
		2926	if test -z "$absdir"; then
		2927	$echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
		2928	absdir="$dir"
		2929	fi
		2930	;;
		2931	esac
		2932	if grep "^installed=no" $deplib > /dev/null; then
		2933	path="$absdir/$objdir"
		2934	else
		2935	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`
		2936	if test -z "$libdir"; then
		2937	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
		2938	exit $EXIT_FAILURE
		2939	fi
		2940	if test "$absdir" != "$libdir"; then
		2941	$echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
		2942	fi
		2943	path="$absdir"
		2944	fi
		2945	depdepl=
		2946	case $host in
		2947	--darwin*)
		2948	# we do not want to link against static libs,
		2949	# but need to link against shared
		2950	eval deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`
		2951	if test -n "$deplibrary_names" ; then
		2952	for tmp in $deplibrary_names ; do
		2953	depdepl=$tmp
		2954	done
		2955	if test -f "$path/$depdepl" ; then
		2956	depdepl="$path/$depdepl"
		2957	fi
		2958	# do not add paths which are already there
		2959	case " $newlib_search_path " in
		2960	" $path ") ;;
		2961	*) newlib_search_path="$newlib_search_path $path";;
		2962	esac
		2963	fi
		2964	path=""
		2965	;;
		2966	*)
		2967	path="-L$path"
		2968	;;
		2969	esac
		2970	;;
		2971	-l*)
		2972	case $host in
		2973	--darwin*)
		2974	# Again, we only want to link against shared libraries
		2975	eval tmp_libs=`$echo "X$deplib" \| $Xsed -e "s,^\-l,,"`
		2976	for tmp in $newlib_search_path ; do
		2977	if test -f "$tmp/lib$tmp_libs.dylib" ; then
		2978	eval depdepl="$tmp/lib$tmp_libs.dylib"
		2979	break
		2980	fi
		2981	done
		2982	path=""
		2983	;;
		2984	*) continue ;;
		2985	esac
		2986	;;
		2987	*) continue ;;
		2988	esac
		2989	case " $deplibs " in
		2990	" $path ") ;;
		2991	*) deplibs="$path $deplibs" ;;
		2992	esac
		2993	case " $deplibs " in
		2994	" $depdepl ") ;;
		2995	*) deplibs="$depdepl $deplibs" ;;
		2996	esac
		2997	done
		2998	fi # link_all_deplibs != no
		2999	fi # linkmode = lib
		3000	done # for deplib in $libs
		3001	dependency_libs="$newdependency_libs"
		3002	if test "$pass" = dlpreopen; then
		3003	# Link the dlpreopened libraries before other libraries
		3004	for deplib in $save_deplibs; do
		3005	deplibs="$deplib $deplibs"
		3006	done
		3007	fi
		3008	if test "$pass" != dlopen; then
		3009	if test "$pass" != conv; then
		3010	# Make sure lib_search_path contains only unique directories.
		3011	lib_search_path=
		3012	for dir in $newlib_search_path; do
		3013	case "$lib_search_path " in
		3014	" $dir ") ;;
		3015	*) lib_search_path="$lib_search_path $dir" ;;
		3016	esac
		3017	done
		3018	newlib_search_path=
		3019	fi
		3020
		3021	if test "$linkmode,$pass" != "prog,link"; then
		3022	vars="deplibs"
		3023	else
		3024	vars="compile_deplibs finalize_deplibs"
		3025	fi
		3026	for var in $vars dependency_libs; do
		3027	# Add libraries to $var in reverse order
		3028	eval tmp_libs=\"\$$var\"
		3029	new_libs=
		3030	for deplib in $tmp_libs; do
		3031	# FIXME: Pedantically, this is the right thing to do, so
		3032	# that some nasty dependency loop isn't accidentally
		3033	# broken:
		3034	#new_libs="$deplib $new_libs"
		3035	# Pragmatically, this seems to cause very few problems in
		3036	# practice:
		3037	case $deplib in
		3038	-L*) new_libs="$deplib $new_libs" ;;
		3039	-R*) ;;
		3040	*)
		3041	# And here is the reason: when a library appears more
		3042	# than once as an explicit dependence of a library, or
		3043	# is implicitly linked in more than once by the
		3044	# compiler, it is considered special, and multiple
		3045	# occurrences thereof are not removed. Compare this
		3046	# with having the same library being listed as a
		3047	# dependency of multiple other libraries: in this case,
		3048	# we know (pedantically, we assume) the library does not
		3049	# need to be listed more than once, so we keep only the
		3050	# last copy. This is not always right, but it is rare
		3051	# enough that we require users that really mean to play
		3052	# such unportable linking tricks to link the library
		3053	# using -Wl,-lname, so that libtool does not consider it
		3054	# for duplicate removal.
		3055	case " $specialdeplibs " in
		3056	" $deplib ") new_libs="$deplib $new_libs" ;;
		3057	*)
		3058	case " $new_libs " in
		3059	" $deplib ") ;;
		3060	*) new_libs="$deplib $new_libs" ;;
		3061	esac
		3062	;;
		3063	esac
		3064	;;
		3065	esac
		3066	done
		3067	tmp_libs=
		3068	for deplib in $new_libs; do
		3069	case $deplib in
		3070	-L*)
		3071	case " $tmp_libs " in
		3072	" $deplib ") ;;
		3073	*) tmp_libs="$tmp_libs $deplib" ;;
		3074	esac
		3075	;;
		3076	*) tmp_libs="$tmp_libs $deplib" ;;
		3077	esac
		3078	done
		3079	eval $var=\"$tmp_libs\"
		3080	done # for var
		3081	fi
		3082	# Last step: remove runtime libs from dependency_libs
		3083	# (they stay in deplibs)
		3084	tmp_libs=
		3085	for i in $dependency_libs ; do
		3086	case " $predeps $postdeps $compiler_lib_search_path " in
		3087	" $i ")
		3088	i=""
		3089	;;
		3090	esac
		3091	if test -n "$i" ; then
		3092	tmp_libs="$tmp_libs $i"
		3093	fi
		3094	done
		3095	dependency_libs=$tmp_libs
		3096	done # for pass
		3097	if test "$linkmode" = prog; then
		3098	dlfiles="$newdlfiles"
		3099	dlprefiles="$newdlprefiles"
		3100	fi
		3101
		3102	case $linkmode in
		3103	oldlib)
		3104	if test -n "$deplibs"; then
		3105	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
		3106	fi
		3107
		3108	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
		3109	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
		3110	fi
		3111
		3112	if test -n "$rpath"; then
		3113	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
		3114	fi
		3115
		3116	if test -n "$xrpath"; then
		3117	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
		3118	fi
		3119
		3120	if test -n "$vinfo"; then
		3121	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
		3122	fi
		3123
		3124	if test -n "$release"; then
		3125	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
		3126	fi
		3127
		3128	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
		3129	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
		3130	fi
		3131
		3132	# Now set the variables for building old libraries.
		3133	build_libtool_libs=no
		3134	oldlibs="$output"
		3135	objs="$objs$old_deplibs"
		3136	;;
		3137
		3138	lib)
		3139	# Make sure we only generate libraries of the form `libNAME.la'.
		3140	case $outputname in
		3141	lib*)
		3142	name=`$echo "X$outputname" \| $Xsed -e 's/\.la$//' -e 's/^lib//'`
		3143	eval shared_ext=\"$shrext_cmds\"
		3144	eval libname=\"$libname_spec\"
		3145	;;
		3146	*)
		3147	if test "$module" = no; then
		3148	$echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
		3149	$echo "$help" 1>&2
		3150	exit $EXIT_FAILURE
		3151	fi
		3152	if test "$need_lib_prefix" != no; then
		3153	# Add the "lib" prefix for modules if required
		3154	name=`$echo "X$outputname" \| $Xsed -e 's/\.la$//'`
		3155	eval shared_ext=\"$shrext_cmds\"
		3156	eval libname=\"$libname_spec\"
		3157	else
		3158	libname=`$echo "X$outputname" \| $Xsed -e 's/\.la$//'`
		3159	fi
		3160	;;
		3161	esac
		3162
		3163	if test -n "$objs"; then
		3164	if test "$deplibs_check_method" != pass_all; then
		3165	$echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
		3166	exit $EXIT_FAILURE
		3167	else
		3168	$echo
		3169	$echo "*** Warning: Linking the shared library $output against the non-libtool"
		3170	$echo "*** objects $objs is not portable!"
		3171	libobjs="$libobjs $objs"
		3172	fi
		3173	fi
		3174
		3175	if test "$dlself" != no; then
		3176	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
		3177	fi
		3178
		3179	set dummy $rpath
		3180	if test "$#" -gt 2; then
		3181	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
		3182	fi
		3183	install_libdir="$2"
		3184
		3185	oldlibs=
		3186	if test -z "$rpath"; then
		3187	if test "$build_libtool_libs" = yes; then
		3188	# Building a libtool convenience library.
		3189	# Some compilers have problems with a `.al' extension so
		3190	# convenience libraries should have the same extension an
		3191	# archive normally would.
		3192	oldlibs="$output_objdir/$libname.$libext $oldlibs"
		3193	build_libtool_libs=convenience
		3194	build_old_libs=yes
		3195	fi
		3196
		3197	if test -n "$vinfo"; then
		3198	$echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
		3199	fi
		3200
		3201	if test -n "$release"; then
		3202	$echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
		3203	fi
		3204	else
		3205
		3206	# Parse the version information argument.
		3207	save_ifs="$IFS"; IFS=':'
		3208	set dummy $vinfo 0 0 0
		3209	IFS="$save_ifs"
		3210
		3211	if test -n "$8"; then
		3212	$echo "$modename: too many parameters to \`-version-info'" 1>&2
		3213	$echo "$help" 1>&2
		3214	exit $EXIT_FAILURE
		3215	fi
		3216
		3217	# convert absolute version numbers to libtool ages
		3218	# this retains compatibility with .la files and attempts
		3219	# to make the code below a bit more comprehensible
		3220
		3221	case $vinfo_number in
		3222	yes)
		3223	number_major="$2"
		3224	number_minor="$3"
		3225	number_revision="$4"
		3226	#
		3227	# There are really only two kinds -- those that
		3228	# use the current revision as the major version
		3229	# and those that subtract age and use age as
		3230	# a minor version. But, then there is irix
		3231	# which has an extra 1 added just for fun
		3232	#
		3233	case $version_type in
		3234	darwin\|linux\|osf\|windows\|none)
		3235	current=`expr $number_major + $number_minor`
		3236	age="$number_minor"
		3237	revision="$number_revision"
		3238	;;
		3239	freebsd-aout\|freebsd-elf\|sunos)
		3240	current="$number_major"
		3241	revision="$number_minor"
		3242	age="0"
		3243	;;
		3244	irix\|nonstopux)
		3245	current=`expr $number_major + $number_minor`
		3246	age="$number_minor"
		3247	revision="$number_minor"
		3248	lt_irix_increment=no
		3249	;;
		3250	*)
		3251	$echo "$modename: unknown library version type \`$version_type'" 1>&2
		3252	$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
		3253	exit $EXIT_FAILURE
		3254	;;
		3255	esac
		3256	;;
		3257	no)
		3258	current="$2"
		3259	revision="$3"
		3260	age="$4"
		3261	;;
		3262	esac
		3263
		3264	# Check that each of the things are valid numbers.
		3265	case $current in
		3266	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]) ;;
		3267	*)
		3268	$echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
		3269	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
		3270	exit $EXIT_FAILURE
		3271	;;
		3272	esac
		3273
		3274	case $revision in
		3275	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]) ;;
		3276	*)
		3277	$echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
		3278	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
		3279	exit $EXIT_FAILURE
		3280	;;
		3281	esac
		3282
		3283	case $age in
		3284	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]) ;;
		3285	*)
		3286	$echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
		3287	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
		3288	exit $EXIT_FAILURE
		3289	;;
		3290	esac
		3291
		3292	if test "$age" -gt "$current"; then
		3293	$echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
		3294	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
		3295	exit $EXIT_FAILURE
		3296	fi
		3297
		3298	# Calculate the version variables.
		3299	major=
		3300	versuffix=
		3301	verstring=
		3302	case $version_type in
		3303	none) ;;
		3304
		3305	darwin)
		3306	# Like Linux, but with the current version available in
		3307	# verstring for coding it into the library header
		3308	major=.`expr $current - $age`
		3309	versuffix="$major.$age.$revision"
		3310	# Darwin ld doesn't like 0 for these options...
		3311	minor_current=`expr $current + 1`
		3312	xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
		3313	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
		3314	;;
		3315
		3316	freebsd-aout)
		3317	major=".$current"
		3318	versuffix=".$current.$revision";
		3319	;;
		3320
		3321	freebsd-elf)
		3322	major=".$current"
		3323	versuffix=".$current";
		3324	;;
		3325
		3326	irix \| nonstopux)
		3327	if test "X$lt_irix_increment" = "Xno"; then
		3328	major=`expr $current - $age`
		3329	else
		3330	major=`expr $current - $age + 1`
		3331	fi
		3332	case $version_type in
		3333	nonstopux) verstring_prefix=nonstopux ;;
		3334	*) verstring_prefix=sgi ;;
		3335	esac
		3336	verstring="$verstring_prefix$major.$revision"
		3337
		3338	# Add in all the interfaces that we are compatible with.
		3339	loop=$revision
		3340	while test "$loop" -ne 0; do
		3341	iface=`expr $revision - $loop`
		3342	loop=`expr $loop - 1`
		3343	verstring="$verstring_prefix$major.$iface:$verstring"
		3344	done
		3345
		3346	# Before this point, $major must not contain `.'.
		3347	major=.$major
		3348	versuffix="$major.$revision"
		3349	;;
		3350
		3351	linux)
		3352	major=.`expr $current - $age`
		3353	versuffix="$major.$age.$revision"
		3354	;;
		3355
		3356	osf)
		3357	major=.`expr $current - $age`
		3358	versuffix=".$current.$age.$revision"
		3359	verstring="$current.$age.$revision"
		3360
		3361	# Add in all the interfaces that we are compatible with.
		3362	loop=$age
		3363	while test "$loop" -ne 0; do
		3364	iface=`expr $current - $loop`
		3365	loop=`expr $loop - 1`
		3366	verstring="$verstring:${iface}.0"
		3367	done
		3368
		3369	# Make executables depend on our current version.
		3370	verstring="$verstring:${current}.0"
		3371	;;
		3372
		3373	sunos)
		3374	major=".$current"
		3375	versuffix=".$current.$revision"
		3376	;;
		3377
		3378	windows)
		3379	# Use '-' rather than '.', since we only want one
		3380	# extension on DOS 8.3 filesystems.
		3381	major=`expr $current - $age`
		3382	versuffix="-$major"
		3383	;;
		3384
		3385	*)
		3386	$echo "$modename: unknown library version type \`$version_type'" 1>&2
		3387	$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
		3388	exit $EXIT_FAILURE
		3389	;;
		3390	esac
		3391
		3392	# Clear the version info if we defaulted, and they specified a release.
		3393	if test -z "$vinfo" && test -n "$release"; then
		3394	major=
		3395	case $version_type in
		3396	darwin)
		3397	# we can't check for "0.0" in archive_cmds due to quoting
		3398	# problems, so we reset it completely
		3399	verstring=
		3400	;;
		3401	*)
		3402	verstring="0.0"
		3403	;;
		3404	esac
		3405	if test "$need_version" = no; then
		3406	versuffix=
		3407	else
		3408	versuffix=".0.0"
		3409	fi
		3410	fi
		3411
		3412	# Remove version info from name if versioning should be avoided
		3413	if test "$avoid_version" = yes && test "$need_version" = no; then
		3414	major=
		3415	versuffix=
		3416	verstring=""
		3417	fi
		3418
		3419	# Check to see if the archive will have undefined symbols.
		3420	if test "$allow_undefined" = yes; then
		3421	if test "$allow_undefined_flag" = unsupported; then
		3422	$echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
		3423	build_libtool_libs=no
		3424	build_old_libs=yes
		3425	fi
		3426	else
		3427	# Don't allow undefined symbols.
		3428	allow_undefined_flag="$no_undefined_flag"
		3429	fi
		3430	fi
		3431
		3432	if test "$mode" != relink; then
		3433	# Remove our outputs, but don't remove object files since they
		3434	# may have been created when compiling PIC objects.
		3435	removelist=
		3436	tempremovelist=`$echo "$output_objdir/*"`
		3437	for p in $tempremovelist; do
		3438	case $p in
		3439	*.$objext)
		3440	;;
		3441	$output_objdir/$outputname \| $output_objdir/$libname.* \| $output_objdir/${libname}${release}.*)
		3442	if test "X$precious_files_regex" != "X"; then
		3443	if echo $p \| $EGREP -e "$precious_files_regex" >/dev/null 2>&1
		3444	then
		3445	continue
		3446	fi
		3447	fi
		3448	removelist="$removelist $p"
		3449	;;
		3450	*) ;;
		3451	esac
		3452	done
		3453	if test -n "$removelist"; then
		3454	$show "${rm}r $removelist"
		3455	$run ${rm}r $removelist
		3456	fi
		3457	fi
		3458
		3459	# Now set the variables for building old libraries.
		3460	if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
		3461	oldlibs="$oldlibs $output_objdir/$libname.$libext"
		3462
		3463	# Transform .lo files to .o files.
		3464	oldobjs="$objs "`$echo "X$libobjs" \| $SP2NL \| $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" \| $NL2SP`
		3465	fi
		3466
		3467	# Eliminate all temporary directories.
		3468	#for path in $notinst_path; do
		3469	# lib_search_path=`$echo "$lib_search_path " \| ${SED} -e "s% $path % %g"`
		3470	# deplibs=`$echo "$deplibs " \| ${SED} -e "s% -L$path % %g"`
		3471	# dependency_libs=`$echo "$dependency_libs " \| ${SED} -e "s% -L$path % %g"`
		3472	#done
		3473
		3474	if test -n "$xrpath"; then
		3475	# If the user specified any rpath flags, then add them.
		3476	temp_xrpath=
		3477	for libdir in $xrpath; do
		3478	temp_xrpath="$temp_xrpath -R$libdir"
		3479	case "$finalize_rpath " in
		3480	" $libdir ") ;;
		3481	*) finalize_rpath="$finalize_rpath $libdir" ;;
		3482	esac
		3483	done
		3484	if test "$hardcode_into_libs" != yes \|\| test "$build_old_libs" = yes; then
		3485	dependency_libs="$temp_xrpath $dependency_libs"
		3486	fi
		3487	fi
		3488
		3489	# Make sure dlfiles contains only unique files that won't be dlpreopened
		3490	old_dlfiles="$dlfiles"
		3491	dlfiles=
		3492	for lib in $old_dlfiles; do
		3493	case " $dlprefiles $dlfiles " in
		3494	" $lib ") ;;
		3495	*) dlfiles="$dlfiles $lib" ;;
		3496	esac
		3497	done
		3498
		3499	# Make sure dlprefiles contains only unique files
		3500	old_dlprefiles="$dlprefiles"
		3501	dlprefiles=
		3502	for lib in $old_dlprefiles; do
		3503	case "$dlprefiles " in
		3504	" $lib ") ;;
		3505	*) dlprefiles="$dlprefiles $lib" ;;
		3506	esac
		3507	done
		3508
		3509	if test "$build_libtool_libs" = yes; then
		3510	if test -n "$rpath"; then
		3511	case $host in
		3512	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --beos*)
		3513	# these systems don't actually have a c library (as such)!
		3514	;;
		3515	--rhapsody* \| --darwin1.[012])
		3516	# Rhapsody C library is in the System framework
		3517	deplibs="$deplibs -framework System"
		3518	;;
		3519	--netbsd*)
		3520	# Don't link with libc until the a.out ld.so is fixed.
		3521	;;
		3522	--openbsd* \| --freebsd* \| --dragonfly*)
		3523	# Do not include libc due to us having libc/libc_r.
		3524	;;
		3525	--sco3.2v5* \| --sco5v6*)
		3526	# Causes problems with __ctype
		3527	;;
		3528	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
		3529	# Compiler inserts libc in the correct place for threads to work
		3530	;;
		3531	*)
		3532	# Add libc to deplibs on all other systems if necessary.
		3533	if test "$build_libtool_need_lc" = "yes"; then
		3534	deplibs="$deplibs -lc"
		3535	fi
		3536	;;
		3537	esac
		3538	fi
		3539
		3540	# Transform deplibs into only deplibs that can be linked in shared.
		3541	name_save=$name
		3542	libname_save=$libname
		3543	release_save=$release
		3544	versuffix_save=$versuffix
		3545	major_save=$major
		3546	# I'm not sure if I'm treating the release correctly. I think
		3547	# release should show up in the -l (ie -lgmp5) so we don't want to
		3548	# add it in twice. Is that correct?
		3549	release=""
		3550	versuffix=""
		3551	major=""
		3552	newdeplibs=
		3553	droppeddeps=no
		3554	case $deplibs_check_method in
		3555	pass_all)
		3556	# Don't check for shared/static. Everything works.
		3557	# This might be a little naive. We might want to check
		3558	# whether the library exists or not. But this is on
		3559	# osf3 & osf4 and I'm not really sure... Just
		3560	# implementing what was already the behavior.
		3561	newdeplibs=$deplibs
		3562	;;
		3563	test_compile)
		3564	# This code stresses the "libraries are programs" paradigm to its
		3565	# limits. Maybe even breaks it. We compile a program, linking it
		3566	# against the deplibs as a proxy for the library. Then we can check
		3567	# whether they linked in statically or dynamically with ldd.
		3568	$rm conftest.c
		3569	cat > conftest.c <<EOF
		3570	int main() { return 0; }
		3571	EOF
		3572	$rm conftest
		3573	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
		3574	ldd_output=`ldd conftest`
		3575	for i in $deplibs; do
		3576	name=`expr $i : '-l$.*$'`
		3577	# If $name is empty we are operating on a -L argument.
		3578	if test "$name" != "" && test "$name" != "0"; then
		3579	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		3580	case " $predeps $postdeps " in
		3581	" $i ")
		3582	newdeplibs="$newdeplibs $i"
		3583	i=""
		3584	;;
		3585	esac
		3586	fi
		3587	if test -n "$i" ; then
		3588	libname=`eval \\$echo \"$libname_spec\"`
		3589	deplib_matches=`eval \\$echo \"$library_names_spec\"`
		3590	set dummy $deplib_matches
		3591	deplib_match=$2
		3592	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
		3593	newdeplibs="$newdeplibs $i"
		3594	else
		3595	droppeddeps=yes
		3596	$echo
		3597	$echo "*** Warning: dynamic linker does not accept needed library $i."
		3598	$echo "*** I have the capability to make that library automatically link in when"
		3599	$echo "*** you link to this library. But I can only do this if you have a"
		3600	$echo "*** shared version of the library, which I believe you do not have"
		3601	$echo "*** because a test_compile did reveal that the linker did not use it for"
		3602	$echo "*** its dynamic dependency list that programs get resolved with at runtime."
		3603	fi
		3604	fi
		3605	else
		3606	newdeplibs="$newdeplibs $i"
		3607	fi
		3608	done
		3609	else
		3610	# Error occurred in the first compile. Let's try to salvage
		3611	# the situation: Compile a separate program for each library.
		3612	for i in $deplibs; do
		3613	name=`expr $i : '-l$.*$'`
		3614	# If $name is empty we are operating on a -L argument.
		3615	if test "$name" != "" && test "$name" != "0"; then
		3616	$rm conftest
		3617	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
		3618	ldd_output=`ldd conftest`
		3619	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		3620	case " $predeps $postdeps " in
		3621	" $i ")
		3622	newdeplibs="$newdeplibs $i"
		3623	i=""
		3624	;;
		3625	esac
		3626	fi
		3627	if test -n "$i" ; then
		3628	libname=`eval \\$echo \"$libname_spec\"`
		3629	deplib_matches=`eval \\$echo \"$library_names_spec\"`
		3630	set dummy $deplib_matches
		3631	deplib_match=$2
		3632	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
		3633	newdeplibs="$newdeplibs $i"
		3634	else
		3635	droppeddeps=yes
		3636	$echo
		3637	$echo "*** Warning: dynamic linker does not accept needed library $i."
		3638	$echo "*** I have the capability to make that library automatically link in when"
		3639	$echo "*** you link to this library. But I can only do this if you have a"
		3640	$echo "*** shared version of the library, which you do not appear to have"
		3641	$echo "*** because a test_compile did reveal that the linker did not use this one"
		3642	$echo "*** as a dynamic dependency that programs can get resolved with at runtime."
		3643	fi
		3644	fi
		3645	else
		3646	droppeddeps=yes
		3647	$echo
		3648	$echo "*** Warning! Library $i is needed by this library but I was not able to"
		3649	$echo "*** make it link in! You will probably need to install it or some"
		3650	$echo "*** library that it depends on before this library will be fully"
		3651	$echo "*** functional. Installing it before continuing would be even better."
		3652	fi
		3653	else
		3654	newdeplibs="$newdeplibs $i"
		3655	fi
		3656	done
		3657	fi
		3658	;;
		3659	file_magic*)
		3660	set dummy $deplibs_check_method
		3661	file_magic_regex=`expr "$deplibs_check_method" : "$2 $.*$"`
		3662	for a_deplib in $deplibs; do
		3663	name=`expr $a_deplib : '-l$.*$'`
		3664	# If $name is empty we are operating on a -L argument.
		3665	if test "$name" != "" && test "$name" != "0"; then
		3666	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		3667	case " $predeps $postdeps " in
		3668	" $a_deplib ")
		3669	newdeplibs="$newdeplibs $a_deplib"
		3670	a_deplib=""
		3671	;;
		3672	esac
		3673	fi
		3674	if test -n "$a_deplib" ; then
		3675	libname=`eval \\$echo \"$libname_spec\"`
		3676	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
		3677	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
		3678	for potent_lib in $potential_libs; do
		3679	# Follow soft links.
		3680	if ls -lLd "$potent_lib" 2>/dev/null \
		3681	\| grep " -> " >/dev/null; then
		3682	continue
		3683	fi
		3684	# The statement above tries to avoid entering an
		3685	# endless loop below, in case of cyclic links.
		3686	# We might still enter an endless loop, since a link
		3687	# loop can be closed while we follow links,
		3688	# but so what?
		3689	potlib="$potent_lib"
		3690	while test -h "$potlib" 2>/dev/null; do
		3691	potliblink=`ls -ld $potlib \| ${SED} 's/.* -> //'`
		3692	case $potliblink in
		3693	[\\/]* \| [A-Za-z]:[\\/]*) potlib="$potliblink";;
		3694	) potlib=`$echo "X$potlib" \| $Xsed -e 's,[^/]$,,'`"$potliblink";;
		3695	esac
		3696	done
		3697	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
		3698	\| ${SED} 10q \
		3699	\| $EGREP "$file_magic_regex" > /dev/null; then
		3700	newdeplibs="$newdeplibs $a_deplib"
		3701	a_deplib=""
		3702	break 2
		3703	fi
		3704	done
		3705	done
		3706	fi
		3707	if test -n "$a_deplib" ; then
		3708	droppeddeps=yes
		3709	$echo
		3710	$echo "*** Warning: linker path does not have real file for library $a_deplib."
		3711	$echo "*** I have the capability to make that library automatically link in when"
		3712	$echo "*** you link to this library. But I can only do this if you have a"
		3713	$echo "*** shared version of the library, which you do not appear to have"
		3714	$echo "*** because I did check the linker path looking for a file starting"
		3715	if test -z "$potlib" ; then
		3716	$echo "*** with $libname but no candidates were found. (...for file magic test)"
		3717	else
		3718	$echo "*** with $libname and none of the candidates passed a file format test"
		3719	$echo "*** using a file magic. Last file checked: $potlib"
		3720	fi
		3721	fi
		3722	else
		3723	# Add a -L argument.
		3724	newdeplibs="$newdeplibs $a_deplib"
		3725	fi
		3726	done # Gone through all deplibs.
		3727	;;
		3728	match_pattern*)
		3729	set dummy $deplibs_check_method
		3730	match_pattern_regex=`expr "$deplibs_check_method" : "$2 $.*$"`
		3731	for a_deplib in $deplibs; do
		3732	name=`expr $a_deplib : '-l$.*$'`
		3733	# If $name is empty we are operating on a -L argument.
		3734	if test -n "$name" && test "$name" != "0"; then
		3735	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		3736	case " $predeps $postdeps " in
		3737	" $a_deplib ")
		3738	newdeplibs="$newdeplibs $a_deplib"
		3739	a_deplib=""
		3740	;;
		3741	esac
		3742	fi
		3743	if test -n "$a_deplib" ; then
		3744	libname=`eval \\$echo \"$libname_spec\"`
		3745	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
		3746	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
		3747	for potent_lib in $potential_libs; do
		3748	potlib="$potent_lib" # see symlink-check above in file_magic test
		3749	if eval $echo \"$potent_lib\" 2>/dev/null \
		3750	\| ${SED} 10q \
		3751	\| $EGREP "$match_pattern_regex" > /dev/null; then
		3752	newdeplibs="$newdeplibs $a_deplib"
		3753	a_deplib=""
		3754	break 2
		3755	fi
		3756	done
		3757	done
		3758	fi
		3759	if test -n "$a_deplib" ; then
		3760	droppeddeps=yes
		3761	$echo
		3762	$echo "*** Warning: linker path does not have real file for library $a_deplib."
		3763	$echo "*** I have the capability to make that library automatically link in when"
		3764	$echo "*** you link to this library. But I can only do this if you have a"
		3765	$echo "*** shared version of the library, which you do not appear to have"
		3766	$echo "*** because I did check the linker path looking for a file starting"
		3767	if test -z "$potlib" ; then
		3768	$echo "*** with $libname but no candidates were found. (...for regex pattern test)"
		3769	else
		3770	$echo "*** with $libname and none of the candidates passed a file format test"
		3771	$echo "*** using a regex pattern. Last file checked: $potlib"
		3772	fi
		3773	fi
		3774	else
		3775	# Add a -L argument.
		3776	newdeplibs="$newdeplibs $a_deplib"
		3777	fi
		3778	done # Gone through all deplibs.
		3779	;;
		3780	none \| unknown \| *)
		3781	newdeplibs=""
		3782	tmp_deplibs=`$echo "X $deplibs" \| $Xsed -e 's/ -lc$//' \
		3783	-e 's/ -[LR][^ ]*//g'`
		3784	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		3785	for i in $predeps $postdeps ; do
		3786	# can't use Xsed below, because $i might contain '/'
		3787	tmp_deplibs=`$echo "X $tmp_deplibs" \| ${SED} -e "1s,^X,," -e "s,$i,,"`
		3788	done
		3789	fi
		3790	if $echo "X $tmp_deplibs" \| $Xsed -e 's/[ ]//g' \
		3791	\| grep . >/dev/null; then
		3792	$echo
		3793	if test "X$deplibs_check_method" = "Xnone"; then
		3794	$echo "*** Warning: inter-library dependencies are not supported in this platform."
		3795	else
		3796	$echo "*** Warning: inter-library dependencies are not known to be supported."
		3797	fi
		3798	$echo "*** All declared inter-library dependencies are being dropped."
		3799	droppeddeps=yes
		3800	fi
		3801	;;
		3802	esac
		3803	versuffix=$versuffix_save
		3804	major=$major_save
		3805	release=$release_save
		3806	libname=$libname_save
		3807	name=$name_save
		3808
		3809	case $host in
		3810	--rhapsody* \| --darwin1.[012])
		3811	# On Rhapsody replace the C library is the System framework
		3812	newdeplibs=`$echo "X $newdeplibs" \| $Xsed -e 's/ -lc / -framework System /'`
		3813	;;
		3814	esac
		3815
		3816	if test "$droppeddeps" = yes; then
		3817	if test "$module" = yes; then
		3818	$echo
		3819	$echo "*** Warning: libtool could not satisfy all declared inter-library"
		3820	$echo "*** dependencies of module $libname. Therefore, libtool will create"
		3821	$echo "*** a static module, that should work as long as the dlopening"
		3822	$echo "*** application is linked with the -dlopen flag."
		3823	if test -z "$global_symbol_pipe"; then
		3824	$echo
		3825	$echo "*** However, this would only work if libtool was able to extract symbol"
		3826	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
		3827	$echo "*** not find such a program. So, this module is probably useless."
		3828	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
		3829	fi
		3830	if test "$build_old_libs" = no; then
		3831	oldlibs="$output_objdir/$libname.$libext"
		3832	build_libtool_libs=module
		3833	build_old_libs=yes
		3834	else
		3835	build_libtool_libs=no
		3836	fi
		3837	else
		3838	$echo "*** The inter-library dependencies that have been dropped here will be"
		3839	$echo "*** automatically added whenever a program is linked with this library"
		3840	$echo "*** or is declared to -dlopen it."
		3841
		3842	if test "$allow_undefined" = no; then
		3843	$echo
		3844	$echo "*** Since this library must not contain undefined symbols,"
		3845	$echo "*** because either the platform does not support them or"
		3846	$echo "*** it was explicitly requested with -no-undefined,"
		3847	$echo "*** libtool will only create a static version of it."
		3848	if test "$build_old_libs" = no; then
		3849	oldlibs="$output_objdir/$libname.$libext"
		3850	build_libtool_libs=module
		3851	build_old_libs=yes
		3852	else
		3853	build_libtool_libs=no
		3854	fi
		3855	fi
		3856	fi
		3857	fi
		3858	# Done checking deplibs!
		3859	deplibs=$newdeplibs
		3860	fi
		3861
		3862
		3863	# move library search paths that coincide with paths to not yet
		3864	# installed libraries to the beginning of the library search list
		3865	new_libs=
		3866	for path in $notinst_path; do
		3867	case " $new_libs " in
		3868	" -L$path/$objdir ") ;;
		3869	*)
		3870	case " $deplibs " in
		3871	" -L$path/$objdir ")
		3872	new_libs="$new_libs -L$path/$objdir" ;;
		3873	esac
		3874	;;
		3875	esac
		3876	done
		3877	for deplib in $deplibs; do
		3878	case $deplib in
		3879	-L*)
		3880	case " $new_libs " in
		3881	" $deplib ") ;;
		3882	*) new_libs="$new_libs $deplib" ;;
		3883	esac
		3884	;;
		3885	*) new_libs="$new_libs $deplib" ;;
		3886	esac
		3887	done
		3888	deplibs="$new_libs"
		3889
		3890
		3891	# All the library-specific variables (install_libdir is set above).
		3892	library_names=
		3893	old_library=
		3894	dlname=
		3895
		3896	# Test again, we may have decided not to build it any more
		3897	if test "$build_libtool_libs" = yes; then
		3898	if test "$hardcode_into_libs" = yes; then
		3899	# Hardcode the library paths
		3900	hardcode_libdirs=
		3901	dep_rpath=
		3902	rpath="$finalize_rpath"
		3903	test "$mode" != relink && rpath="$compile_rpath$rpath"
		3904	for libdir in $rpath; do
		3905	if test -n "$hardcode_libdir_flag_spec"; then
		3906	if test -n "$hardcode_libdir_separator"; then
		3907	if test -z "$hardcode_libdirs"; then
		3908	hardcode_libdirs="$libdir"
		3909	else
		3910	# Just accumulate the unique libdirs.
		3911	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
		3912	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
		3913	;;
		3914	*)
		3915	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		3916	;;
		3917	esac
		3918	fi
		3919	else
		3920	eval flag=\"$hardcode_libdir_flag_spec\"
		3921	dep_rpath="$dep_rpath $flag"
		3922	fi
		3923	elif test -n "$runpath_var"; then
		3924	case "$perm_rpath " in
		3925	" $libdir ") ;;
		3926	*) perm_rpath="$perm_rpath $libdir" ;;
		3927	esac
		3928	fi
		3929	done
		3930	# Substitute the hardcoded libdirs into the rpath.
		3931	if test -n "$hardcode_libdir_separator" &&
		3932	test -n "$hardcode_libdirs"; then
		3933	libdir="$hardcode_libdirs"
		3934	if test -n "$hardcode_libdir_flag_spec_ld"; then
		3935	case $archive_cmds in
		3936	\$LD) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
		3937	*) eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
		3938	esac
		3939	else
		3940	eval dep_rpath=\"$hardcode_libdir_flag_spec\"
		3941	fi
		3942	fi
		3943	if test -n "$runpath_var" && test -n "$perm_rpath"; then
		3944	# We should set the runpath_var.
		3945	rpath=
		3946	for dir in $perm_rpath; do
		3947	rpath="$rpath$dir:"
		3948	done
		3949	eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
		3950	fi
		3951	test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
		3952	fi
		3953
		3954	shlibpath="$finalize_shlibpath"
		3955	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
		3956	if test -n "$shlibpath"; then
		3957	eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
		3958	fi
		3959
		3960	# Get the real and link names of the library.
		3961	eval shared_ext=\"$shrext_cmds\"
		3962	eval library_names=\"$library_names_spec\"
		3963	set dummy $library_names
		3964	realname="$2"
		3965	shift; shift
		3966
		3967	if test -n "$soname_spec"; then
		3968	eval soname=\"$soname_spec\"
		3969	else
		3970	soname="$realname"
		3971	fi
		3972	if test -z "$dlname"; then
		3973	dlname=$soname
		3974	fi
		3975
		3976	lib="$output_objdir/$realname"
		3977	linknames=
		3978	for link
		3979	do
		3980	linknames="$linknames $link"
		3981	done
		3982
		3983	# Use standard objects if they are pic
		3984	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
		3985
		3986	# Prepare the list of exported symbols
		3987	if test -z "$export_symbols"; then
		3988	if test "$always_export_symbols" = yes \|\| test -n "$export_symbols_regex"; then
		3989	$show "generating symbol list for \`$libname.la'"
		3990	export_symbols="$output_objdir/$libname.exp"
		3991	$run $rm $export_symbols
		3992	cmds=$export_symbols_cmds
		3993	save_ifs="$IFS"; IFS='~'
		3994	for cmd in $cmds; do
		3995	IFS="$save_ifs"
		3996	eval cmd=\"$cmd\"
		3997	if len=`expr "X$cmd" : ".*"` &&
		3998	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
		3999	$show "$cmd"
		4000	$run eval "$cmd" \|\| exit $?
		4001	skipped_export=false
		4002	else
		4003	# The command line is too long to execute in one step.
		4004	$show "using reloadable object file for export list..."
		4005	skipped_export=:
		4006	# Break out early, otherwise skipped_export may be
		4007	# set to false by a later but shorter cmd.
		4008	break
		4009	fi
		4010	done
		4011	IFS="$save_ifs"
		4012	if test -n "$export_symbols_regex"; then
		4013	$show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
		4014	$run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
		4015	$show "$mv \"${export_symbols}T\" \"$export_symbols\""
		4016	$run eval '$mv "${export_symbols}T" "$export_symbols"'
		4017	fi
		4018	fi
		4019	fi
		4020
		4021	if test -n "$export_symbols" && test -n "$include_expsyms"; then
		4022	$run eval '$echo "X$include_expsyms" \| $SP2NL >> "$export_symbols"'
		4023	fi
		4024
		4025	tmp_deplibs=
		4026	for test_deplib in $deplibs; do
		4027	case " $convenience " in
		4028	" $test_deplib ") ;;
		4029	*)
		4030	tmp_deplibs="$tmp_deplibs $test_deplib"
		4031	;;
		4032	esac
		4033	done
		4034	deplibs="$tmp_deplibs"
		4035
		4036	if test -n "$convenience"; then
		4037	if test -n "$whole_archive_flag_spec"; then
		4038	save_libobjs=$libobjs
		4039	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
		4040	else
		4041	gentop="$output_objdir/${outputname}x"
		4042	generated="$generated $gentop"
		4043
		4044	func_extract_archives $gentop $convenience
		4045	libobjs="$libobjs $func_extract_archives_result"
		4046	fi
		4047	fi
		4048
		4049	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
		4050	eval flag=\"$thread_safe_flag_spec\"
		4051	linker_flags="$linker_flags $flag"
		4052	fi
		4053
		4054	# Make a backup of the uninstalled library when relinking
		4055	if test "$mode" = relink; then
		4056	$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' \|\| exit $?
		4057	fi
		4058
		4059	# Do each of the archive commands.
		4060	if test "$module" = yes && test -n "$module_cmds" ; then
		4061	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
		4062	eval test_cmds=\"$module_expsym_cmds\"
		4063	cmds=$module_expsym_cmds
		4064	else
		4065	eval test_cmds=\"$module_cmds\"
		4066	cmds=$module_cmds
		4067	fi
		4068	else
		4069	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
		4070	eval test_cmds=\"$archive_expsym_cmds\"
		4071	cmds=$archive_expsym_cmds
		4072	else
		4073	eval test_cmds=\"$archive_cmds\"
		4074	cmds=$archive_cmds
		4075	fi
		4076	fi
		4077
		4078	if test "X$skipped_export" != "X:" &&
		4079	len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
		4080	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
		4081	:
		4082	else
		4083	# The command line is too long to link in one step, link piecewise.
		4084	$echo "creating reloadable object files..."
		4085
		4086	# Save the value of $output and $libobjs because we want to
		4087	# use them later. If we have whole_archive_flag_spec, we
		4088	# want to use save_libobjs as it was before
		4089	# whole_archive_flag_spec was expanded, because we can't
		4090	# assume the linker understands whole_archive_flag_spec.
		4091	# This may have to be revisited, in case too many
		4092	# convenience libraries get linked in and end up exceeding
		4093	# the spec.
		4094	if test -z "$convenience" \|\| test -z "$whole_archive_flag_spec"; then
		4095	save_libobjs=$libobjs
		4096	fi
		4097	save_output=$output
		4098	output_la=`$echo "X$output" \| $Xsed -e "$basename"`
		4099
		4100	# Clear the reloadable object creation command queue and
		4101	# initialize k to one.
		4102	test_cmds=
		4103	concat_cmds=
		4104	objlist=
		4105	delfiles=
		4106	last_robj=
		4107	k=1
		4108	output=$output_objdir/$output_la-${k}.$objext
		4109	# Loop over the list of objects to be linked.
		4110	for obj in $save_libobjs
		4111	do
		4112	eval test_cmds=\"$reload_cmds $objlist $last_robj\"
		4113	if test "X$objlist" = X \|\|
		4114	{ len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
		4115	test "$len" -le "$max_cmd_len"; }; then
		4116	objlist="$objlist $obj"
		4117	else
		4118	# The command $test_cmds is almost too long, add a
		4119	# command to the queue.
		4120	if test "$k" -eq 1 ; then
		4121	# The first file doesn't have a previous command to add.
		4122	eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
		4123	else
		4124	# All subsequent reloadable object files will link in
		4125	# the last one created.
		4126	eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
		4127	fi
		4128	last_robj=$output_objdir/$output_la-${k}.$objext
		4129	k=`expr $k + 1`
		4130	output=$output_objdir/$output_la-${k}.$objext
		4131	objlist=$obj
		4132	len=1
		4133	fi
		4134	done
		4135	# Handle the remaining objects by creating one last
		4136	# reloadable object file. All subsequent reloadable object
		4137	# files will link in the last one created.
		4138	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
		4139	eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
		4140
		4141	if ${skipped_export-false}; then
		4142	$show "generating symbol list for \`$libname.la'"
		4143	export_symbols="$output_objdir/$libname.exp"
		4144	$run $rm $export_symbols
		4145	libobjs=$output
		4146	# Append the command to create the export file.
		4147	eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
		4148	fi
		4149
		4150	# Set up a command to remove the reloadable object files
		4151	# after they are used.
		4152	i=0
		4153	while test "$i" -lt "$k"
		4154	do
		4155	i=`expr $i + 1`
		4156	delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
		4157	done
		4158
		4159	$echo "creating a temporary reloadable object file: $output"
		4160
		4161	# Loop through the commands generated above and execute them.
		4162	save_ifs="$IFS"; IFS='~'
		4163	for cmd in $concat_cmds; do
		4164	IFS="$save_ifs"
		4165	$show "$cmd"
		4166	$run eval "$cmd" \|\| exit $?
		4167	done
		4168	IFS="$save_ifs"
		4169
		4170	libobjs=$output
		4171	# Restore the value of output.
		4172	output=$save_output
		4173
		4174	if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
		4175	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
		4176	fi
		4177	# Expand the library linking commands again to reset the
		4178	# value of $libobjs for piecewise linking.
		4179
		4180	# Do each of the archive commands.
		4181	if test "$module" = yes && test -n "$module_cmds" ; then
		4182	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
		4183	cmds=$module_expsym_cmds
		4184	else
		4185	cmds=$module_cmds
		4186	fi
		4187	else
		4188	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
		4189	cmds=$archive_expsym_cmds
		4190	else
		4191	cmds=$archive_cmds
		4192	fi
		4193	fi
		4194
		4195	# Append the command to remove the reloadable object files
		4196	# to the just-reset $cmds.
		4197	eval cmds=\"\$cmds~\$rm $delfiles\"
		4198	fi
		4199	save_ifs="$IFS"; IFS='~'
		4200	for cmd in $cmds; do
		4201	IFS="$save_ifs"
		4202	eval cmd=\"$cmd\"
		4203	$show "$cmd"
		4204	$run eval "$cmd" \|\| {
		4205	lt_exit=$?
		4206
		4207	# Restore the uninstalled library and exit
		4208	if test "$mode" = relink; then
		4209	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
		4210	fi
		4211
		4212	exit $lt_exit
		4213	}
		4214	done
		4215	IFS="$save_ifs"
		4216
		4217	# Restore the uninstalled library and exit
		4218	if test "$mode" = relink; then
		4219	$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' \|\| exit $?
		4220
		4221	if test -n "$convenience"; then
		4222	if test -z "$whole_archive_flag_spec"; then
		4223	$show "${rm}r $gentop"
		4224	$run ${rm}r "$gentop"
		4225	fi
		4226	fi
		4227
		4228	exit $EXIT_SUCCESS
		4229	fi
		4230
		4231	# Create links to the real library.
		4232	for linkname in $linknames; do
		4233	if test "$realname" != "$linkname"; then
		4234	$show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
		4235	$run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' \|\| exit $?
		4236	fi
		4237	done
		4238
		4239	# If -module or -export-dynamic was specified, set the dlname.
		4240	if test "$module" = yes \|\| test "$export_dynamic" = yes; then
		4241	# On all known operating systems, these are identical.
		4242	dlname="$soname"
		4243	fi
		4244	fi
		4245	;;
		4246
		4247	obj)
		4248	if test -n "$deplibs"; then
		4249	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
		4250	fi
		4251
		4252	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
		4253	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
		4254	fi
		4255
		4256	if test -n "$rpath"; then
		4257	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
		4258	fi
		4259
		4260	if test -n "$xrpath"; then
		4261	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
		4262	fi
		4263
		4264	if test -n "$vinfo"; then
		4265	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
		4266	fi
		4267
		4268	if test -n "$release"; then
		4269	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
		4270	fi
		4271
		4272	case $output in
		4273	*.lo)
		4274	if test -n "$objs$old_deplibs"; then
		4275	$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
		4276	exit $EXIT_FAILURE
		4277	fi
		4278	libobj="$output"
		4279	obj=`$echo "X$output" \| $Xsed -e "$lo2o"`
		4280	;;
		4281	*)
		4282	libobj=
		4283	obj="$output"
		4284	;;
		4285	esac
		4286
		4287	# Delete the old objects.
		4288	$run $rm $obj $libobj
		4289
		4290	# Objects from convenience libraries. This assumes
		4291	# single-version convenience libraries. Whenever we create
		4292	# different ones for PIC/non-PIC, this we'll have to duplicate
		4293	# the extraction.
		4294	reload_conv_objs=
		4295	gentop=
		4296	# reload_cmds runs $LD directly, so let us get rid of
		4297	# -Wl from whole_archive_flag_spec and hope we can get by with
		4298	# turning comma into space..
		4299	wl=
		4300
		4301	if test -n "$convenience"; then
		4302	if test -n "$whole_archive_flag_spec"; then
		4303	eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
		4304	reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" \| $Xsed -e 's\|,\| \|g'`
		4305	else
		4306	gentop="$output_objdir/${obj}x"
		4307	generated="$generated $gentop"
		4308
		4309	func_extract_archives $gentop $convenience
		4310	reload_conv_objs="$reload_objs $func_extract_archives_result"
		4311	fi
		4312	fi
		4313
		4314	# Create the old-style object.
		4315	reload_objs="$objs$old_deplibs "`$echo "X$libobjs" \| $SP2NL \| $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" \| $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
		4316
		4317	output="$obj"
		4318	cmds=$reload_cmds
		4319	save_ifs="$IFS"; IFS='~'
		4320	for cmd in $cmds; do
		4321	IFS="$save_ifs"
		4322	eval cmd=\"$cmd\"
		4323	$show "$cmd"
		4324	$run eval "$cmd" \|\| exit $?
		4325	done
		4326	IFS="$save_ifs"
		4327
		4328	# Exit if we aren't doing a library object file.
		4329	if test -z "$libobj"; then
		4330	if test -n "$gentop"; then
		4331	$show "${rm}r $gentop"
		4332	$run ${rm}r $gentop
		4333	fi
		4334
		4335	exit $EXIT_SUCCESS
		4336	fi
		4337
		4338	if test "$build_libtool_libs" != yes; then
		4339	if test -n "$gentop"; then
		4340	$show "${rm}r $gentop"
		4341	$run ${rm}r $gentop
		4342	fi
		4343
		4344	# Create an invalid libtool object if no PIC, so that we don't
		4345	# accidentally link it into a program.
		4346	# $show "echo timestamp > $libobj"
		4347	# $run eval "echo timestamp > $libobj" \|\| exit $?
		4348	exit $EXIT_SUCCESS
		4349	fi
		4350
		4351	if test -n "$pic_flag" \|\| test "$pic_mode" != default; then
		4352	# Only do commands if we really have different PIC objects.
		4353	reload_objs="$libobjs $reload_conv_objs"
		4354	output="$libobj"
		4355	cmds=$reload_cmds
		4356	save_ifs="$IFS"; IFS='~'
		4357	for cmd in $cmds; do
		4358	IFS="$save_ifs"
		4359	eval cmd=\"$cmd\"
		4360	$show "$cmd"
		4361	$run eval "$cmd" \|\| exit $?
		4362	done
		4363	IFS="$save_ifs"
		4364	fi
		4365
		4366	if test -n "$gentop"; then
		4367	$show "${rm}r $gentop"
		4368	$run ${rm}r $gentop
		4369	fi
		4370
		4371	exit $EXIT_SUCCESS
		4372	;;
		4373
		4374	prog)
		4375	case $host in
		4376	cygwin) output=`$echo $output \| ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
		4377	esac
		4378	if test -n "$vinfo"; then
		4379	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
		4380	fi
		4381
		4382	if test -n "$release"; then
		4383	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
		4384	fi
		4385
		4386	if test "$preload" = yes; then
		4387	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
		4388	test "$dlopen_self_static" = unknown; then
		4389	$echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
		4390	fi
		4391	fi
		4392
		4393	case $host in
		4394	--rhapsody* \| --darwin1.[012])
		4395	# On Rhapsody replace the C library is the System framework
		4396	compile_deplibs=`$echo "X $compile_deplibs" \| $Xsed -e 's/ -lc / -framework System /'`
		4397	finalize_deplibs=`$echo "X $finalize_deplibs" \| $Xsed -e 's/ -lc / -framework System /'`
		4398	;;
		4399	esac
		4400
		4401	case $host in
		4402	darwin)
		4403	# Don't allow lazy linking, it breaks C++ global constructors
		4404	if test "$tagname" = CXX ; then
		4405	compile_command="$compile_command ${wl}-bind_at_load"
		4406	finalize_command="$finalize_command ${wl}-bind_at_load"
		4407	fi
		4408	;;
		4409	esac
		4410
		4411
		4412	# move library search paths that coincide with paths to not yet
		4413	# installed libraries to the beginning of the library search list
		4414	new_libs=
		4415	for path in $notinst_path; do
		4416	case " $new_libs " in
		4417	" -L$path/$objdir ") ;;
		4418	*)
		4419	case " $compile_deplibs " in
		4420	" -L$path/$objdir ")
		4421	new_libs="$new_libs -L$path/$objdir" ;;
		4422	esac
		4423	;;
		4424	esac
		4425	done
		4426	for deplib in $compile_deplibs; do
		4427	case $deplib in
		4428	-L*)
		4429	case " $new_libs " in
		4430	" $deplib ") ;;
		4431	*) new_libs="$new_libs $deplib" ;;
		4432	esac
		4433	;;
		4434	*) new_libs="$new_libs $deplib" ;;
		4435	esac
		4436	done
		4437	compile_deplibs="$new_libs"
		4438
		4439
		4440	compile_command="$compile_command $compile_deplibs"
		4441	finalize_command="$finalize_command $finalize_deplibs"
		4442
		4443	if test -n "$rpath$xrpath"; then
		4444	# If the user specified any rpath flags, then add them.
		4445	for libdir in $rpath $xrpath; do
		4446	# This is the magic to use -rpath.
		4447	case "$finalize_rpath " in
		4448	" $libdir ") ;;
		4449	*) finalize_rpath="$finalize_rpath $libdir" ;;
		4450	esac
		4451	done
		4452	fi
		4453
		4454	# Now hardcode the library paths
		4455	rpath=
		4456	hardcode_libdirs=
		4457	for libdir in $compile_rpath $finalize_rpath; do
		4458	if test -n "$hardcode_libdir_flag_spec"; then
		4459	if test -n "$hardcode_libdir_separator"; then
		4460	if test -z "$hardcode_libdirs"; then
		4461	hardcode_libdirs="$libdir"
		4462	else
		4463	# Just accumulate the unique libdirs.
		4464	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
		4465	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
		4466	;;
		4467	*)
		4468	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		4469	;;
		4470	esac
		4471	fi
		4472	else
		4473	eval flag=\"$hardcode_libdir_flag_spec\"
		4474	rpath="$rpath $flag"
		4475	fi
		4476	elif test -n "$runpath_var"; then
		4477	case "$perm_rpath " in
		4478	" $libdir ") ;;
		4479	*) perm_rpath="$perm_rpath $libdir" ;;
		4480	esac
		4481	fi
		4482	case $host in
		4483	--cygwin* \| --mingw* \| --pw32* \| --os2*)
		4484	testbindir=`$echo "X$libdir" \| $Xsed -e 's/lib$/bin*'`
		4485	case :$dllsearchpath: in
		4486	":$libdir:") ;;
		4487	*) dllsearchpath="$dllsearchpath:$libdir";;
		4488	esac
		4489	case :$dllsearchpath: in
		4490	":$testbindir:") ;;
		4491	*) dllsearchpath="$dllsearchpath:$testbindir";;
		4492	esac
		4493	;;
		4494	esac
		4495	done
		4496	# Substitute the hardcoded libdirs into the rpath.
		4497	if test -n "$hardcode_libdir_separator" &&
		4498	test -n "$hardcode_libdirs"; then
		4499	libdir="$hardcode_libdirs"
		4500	eval rpath=\" $hardcode_libdir_flag_spec\"
		4501	fi
		4502	compile_rpath="$rpath"
		4503
		4504	rpath=
		4505	hardcode_libdirs=
		4506	for libdir in $finalize_rpath; do
		4507	if test -n "$hardcode_libdir_flag_spec"; then
		4508	if test -n "$hardcode_libdir_separator"; then
		4509	if test -z "$hardcode_libdirs"; then
		4510	hardcode_libdirs="$libdir"
		4511	else
		4512	# Just accumulate the unique libdirs.
		4513	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
		4514	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
		4515	;;
		4516	*)
		4517	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
		4518	;;
		4519	esac
		4520	fi
		4521	else
		4522	eval flag=\"$hardcode_libdir_flag_spec\"
		4523	rpath="$rpath $flag"
		4524	fi
		4525	elif test -n "$runpath_var"; then
		4526	case "$finalize_perm_rpath " in
		4527	" $libdir ") ;;
		4528	*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
		4529	esac
		4530	fi
		4531	done
		4532	# Substitute the hardcoded libdirs into the rpath.
		4533	if test -n "$hardcode_libdir_separator" &&
		4534	test -n "$hardcode_libdirs"; then
		4535	libdir="$hardcode_libdirs"
		4536	eval rpath=\" $hardcode_libdir_flag_spec\"
		4537	fi
		4538	finalize_rpath="$rpath"
		4539
		4540	if test -n "$libobjs" && test "$build_old_libs" = yes; then
		4541	# Transform all the library objects into standard objects.
		4542	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
		4543	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
		4544	fi
		4545
		4546	dlsyms=
		4547	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
		4548	if test -n "$NM" && test -n "$global_symbol_pipe"; then
		4549	dlsyms="${outputname}S.c"
		4550	else
		4551	$echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
		4552	fi
		4553	fi
		4554
		4555	if test -n "$dlsyms"; then
		4556	case $dlsyms in
		4557	"") ;;
		4558	*.c)
		4559	# Discover the nlist of each of the dlfiles.
		4560	nlist="$output_objdir/${outputname}.nm"
		4561
		4562	$show "$rm $nlist ${nlist}S ${nlist}T"
		4563	$run $rm "$nlist" "${nlist}S" "${nlist}T"
		4564
		4565	# Parse the name list into a source file.
		4566	$show "creating $output_objdir/$dlsyms"
		4567
		4568	test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
		4569	/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
		4570	/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
		4571
		4572	#ifdef __cplusplus
		4573	extern \"C\" {
		4574	#endif
		4575
		4576	/* Prevent the only kind of declaration conflicts we can make. */
		4577	#define lt_preloaded_symbols some_other_symbol
		4578
		4579	/* External symbol declarations for the compiler. */\
		4580	"
		4581
		4582	if test "$dlself" = yes; then
		4583	$show "generating symbol list for \`$output'"
		4584
		4585	test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
		4586
		4587	# Add our own program objects to the symbol list.
		4588	progfiles=`$echo "X$objs$old_deplibs" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
		4589	for arg in $progfiles; do
		4590	$show "extracting global C symbols from \`$arg'"
		4591	$run eval "$NM $arg \| $global_symbol_pipe >> '$nlist'"
		4592	done
		4593
		4594	if test -n "$exclude_expsyms"; then
		4595	$run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
		4596	$run eval '$mv "$nlist"T "$nlist"'
		4597	fi
		4598
		4599	if test -n "$export_symbols_regex"; then
		4600	$run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
		4601	$run eval '$mv "$nlist"T "$nlist"'
		4602	fi
		4603
		4604	# Prepare the list of exported symbols
		4605	if test -z "$export_symbols"; then
		4606	export_symbols="$output_objdir/$outputname.exp"
		4607	$run $rm $export_symbols
		4608	$run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'
		4609	case $host in
		4610	cygwin \| mingw )
		4611	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
		4612	$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
		4613	;;
		4614	esac
		4615	else
		4616	$run eval "${SED} -e 's/$[].[*^$]$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
		4617	$run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
		4618	$run eval 'mv "$nlist"T "$nlist"'
		4619	case $host in
		4620	cygwin \| mingw )
		4621	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
		4622	$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
		4623	;;
		4624	esac
		4625	fi
		4626	fi
		4627
		4628	for arg in $dlprefiles; do
		4629	$show "extracting global C symbols from \`$arg'"
		4630	name=`$echo "$arg" \| ${SED} -e 's%^.*/%%'`
		4631	$run eval '$echo ": $name " >> "$nlist"'
		4632	$run eval "$NM $arg \| $global_symbol_pipe >> '$nlist'"
		4633	done
		4634
		4635	if test -z "$run"; then
		4636	# Make sure we have at least an empty file.
		4637	test -f "$nlist" \|\| : > "$nlist"
		4638
		4639	if test -n "$exclude_expsyms"; then
		4640	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
		4641	$mv "$nlist"T "$nlist"
		4642	fi
		4643
		4644	# Try sorting and uniquifying the output.
		4645	if grep -v "^: " < "$nlist" \|
		4646	if sort -k 3 </dev/null >/dev/null 2>&1; then
		4647	sort -k 3
		4648	else
		4649	sort +2
		4650	fi \|
		4651	uniq > "$nlist"S; then
		4652	:
		4653	else
		4654	grep -v "^: " < "$nlist" > "$nlist"S
		4655	fi
		4656
		4657	if test -f "$nlist"S; then
		4658	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
		4659	else
		4660	$echo '/* NONE */' >> "$output_objdir/$dlsyms"
		4661	fi
		4662
		4663	$echo >> "$output_objdir/$dlsyms" "\
		4664
		4665	#undef lt_preloaded_symbols
		4666
		4667	#if defined (__STDC__) && __STDC__
		4668	# define lt_ptr void *
		4669	#else
		4670	# define lt_ptr char *
		4671	# define const
		4672	#endif
		4673
		4674	/* The mapping between symbol names and symbols. */
		4675	"
		4676
		4677	case $host in
		4678	cygwin \| mingw )
		4679	$echo >> "$output_objdir/$dlsyms" "\
		4680	/* DATA imports from DLLs on WIN32 can't be const, because
		4681	runtime relocations are performed -- see ld's documentation
		4682	on pseudo-relocs */
		4683	struct {
		4684	"
		4685	;;
		4686	* )
		4687	$echo >> "$output_objdir/$dlsyms" "\
		4688	const struct {
		4689	"
		4690	;;
		4691	esac
		4692
		4693
		4694	$echo >> "$output_objdir/$dlsyms" "\
		4695	const char *name;
		4696	lt_ptr address;
		4697	}
		4698	lt_preloaded_symbols[] =
		4699	{\
		4700	"
		4701
		4702	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
		4703
		4704	$echo >> "$output_objdir/$dlsyms" "\
		4705	{0, (lt_ptr) 0}
		4706	};
		4707
		4708	/* This works around a problem in FreeBSD linker */
		4709	#ifdef FREEBSD_WORKAROUND
		4710	static const void *lt_preloaded_setup() {
		4711	return lt_preloaded_symbols;
		4712	}
		4713	#endif
		4714
		4715	#ifdef __cplusplus
		4716	}
		4717	#endif\
		4718	"
		4719	fi
		4720
		4721	pic_flag_for_symtable=
		4722	case $host in
		4723	# compiling the symbol table file with pic_flag works around
		4724	# a FreeBSD bug that causes programs to crash when -lm is
		4725	# linked before any other PIC object. But we must not use
		4726	# pic_flag when linking with -static. The problem exists in
		4727	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
		4728	--freebsd2\|--freebsd3.0\|--freebsdelf3.0*)
		4729	case "$compile_command " in
		4730	" -static ") ;;
		4731	*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
		4732	esac;;
		4733	--hpux*)
		4734	case "$compile_command " in
		4735	" -static ") ;;
		4736	*) pic_flag_for_symtable=" $pic_flag";;
		4737	esac
		4738	esac
		4739
		4740	# Now compile the dynamic symbol file.
		4741	$show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
		4742	$run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' \|\| exit $?
		4743
		4744	# Clean up the generated files.
		4745	$show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
		4746	$run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
		4747
		4748	# Transform the symbol file into the correct name.
		4749	case $host in
		4750	cygwin \| mingw )
		4751	if test -f "$output_objdir/${outputname}.def" ; then
		4752	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4753	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4754	else
		4755	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4756	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4757	fi
		4758	;;
		4759	* )
		4760	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4761	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
		4762	;;
		4763	esac
		4764	;;
		4765	*)
		4766	$echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
		4767	exit $EXIT_FAILURE
		4768	;;
		4769	esac
		4770	else
		4771	# We keep going just in case the user didn't refer to
		4772	# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
		4773	# really was required.
		4774
		4775	# Nullify the symbol file.
		4776	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s% @SYMFILE@%%" \| $NL2SP`
		4777	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s% @SYMFILE@%%" \| $NL2SP`
		4778	fi
		4779
		4780	if test "$need_relink" = no \|\| test "$build_libtool_libs" != yes; then
		4781	# Replace the output file specification.
		4782	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%'"$output"'%g' \| $NL2SP`
		4783	link_command="$compile_command$compile_rpath"
		4784
		4785	# We have no uninstalled library dependencies, so finalize right now.
		4786	$show "$link_command"
		4787	$run eval "$link_command"
		4788	exit_status=$?
		4789
		4790	# Delete the generated files.
		4791	if test -n "$dlsyms"; then
		4792	$show "$rm $output_objdir/${outputname}S.${objext}"
		4793	$run $rm "$output_objdir/${outputname}S.${objext}"
		4794	fi
		4795
		4796	exit $exit_status
		4797	fi
		4798
		4799	if test -n "$shlibpath_var"; then
		4800	# We should set the shlibpath_var
		4801	rpath=
		4802	for dir in $temp_rpath; do
		4803	case $dir in
		4804	[\\/]* \| [A-Za-z]:[\\/]*)
		4805	# Absolute path.
		4806	rpath="$rpath$dir:"
		4807	;;
		4808	*)
		4809	# Relative path: add a thisdir entry.
		4810	rpath="$rpath\$thisdir/$dir:"
		4811	;;
		4812	esac
		4813	done
		4814	temp_rpath="$rpath"
		4815	fi
		4816
		4817	if test -n "$compile_shlibpath$finalize_shlibpath"; then
		4818	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
		4819	fi
		4820	if test -n "$finalize_shlibpath"; then
		4821	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
		4822	fi
		4823
		4824	compile_var=
		4825	finalize_var=
		4826	if test -n "$runpath_var"; then
		4827	if test -n "$perm_rpath"; then
		4828	# We should set the runpath_var.
		4829	rpath=
		4830	for dir in $perm_rpath; do
		4831	rpath="$rpath$dir:"
		4832	done
		4833	compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
		4834	fi
		4835	if test -n "$finalize_perm_rpath"; then
		4836	# We should set the runpath_var.
		4837	rpath=
		4838	for dir in $finalize_perm_rpath; do
		4839	rpath="$rpath$dir:"
		4840	done
		4841	finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
		4842	fi
		4843	fi
		4844
		4845	if test "$no_install" = yes; then
		4846	# We don't need to create a wrapper script.
		4847	link_command="$compile_var$compile_command$compile_rpath"
		4848	# Replace the output file specification.
		4849	link_command=`$echo "X$link_command" \| $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
		4850	# Delete the old output file.
		4851	$run $rm $output
		4852	# Link the executable and exit
		4853	$show "$link_command"
		4854	$run eval "$link_command" \|\| exit $?
		4855	exit $EXIT_SUCCESS
		4856	fi
		4857
		4858	if test "$hardcode_action" = relink; then
		4859	# Fast installation is not supported
		4860	link_command="$compile_var$compile_command$compile_rpath"
		4861	relink_command="$finalize_var$finalize_command$finalize_rpath"
		4862
		4863	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
		4864	$echo "$modename: \`$output' will be relinked during installation" 1>&2
		4865	else
		4866	if test "$fast_install" != no; then
		4867	link_command="$finalize_var$compile_command$finalize_rpath"
		4868	if test "$fast_install" = yes; then
		4869	relink_command=`$echo "X$compile_var$compile_command$compile_rpath" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' \| $NL2SP`
		4870	else
		4871	# fast_install is set to needless
		4872	relink_command=
		4873	fi
		4874	else
		4875	link_command="$compile_var$compile_command$compile_rpath"
		4876	relink_command="$finalize_var$finalize_command$finalize_rpath"
		4877	fi
		4878	fi
		4879
		4880	# Replace the output file specification.
		4881	link_command=`$echo "X$link_command" \| $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
		4882
		4883	# Delete the old output files.
		4884	$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
		4885
		4886	$show "$link_command"
		4887	$run eval "$link_command" \|\| exit $?
		4888
		4889	# Now create the wrapper script.
		4890	$show "creating $output"
		4891
		4892	# Quote the relink command for shipping.
		4893	if test -n "$relink_command"; then
		4894	# Preserve any variables that may affect compiler behavior
		4895	for var in $variables_saved_for_relink; do
		4896	if eval test -z \"\${$var+set}\"; then
		4897	relink_command="{ test -z \"\${$var+set}\" \|\| unset $var \|\| { $var=; export $var; }; }; $relink_command"
		4898	elif eval var_value=\$$var; test -z "$var_value"; then
		4899	relink_command="$var=; export $var; $relink_command"
		4900	else
		4901	var_value=`$echo "X$var_value" \| $Xsed -e "$sed_quote_subst"`
		4902	relink_command="$var=\"$var_value\"; export $var; $relink_command"
		4903	fi
		4904	done
		4905	relink_command="(cd `pwd`; $relink_command)"
		4906	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e "$sed_quote_subst" \| $NL2SP`
		4907	fi
		4908
		4909	# Quote $echo for shipping.
		4910	if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
		4911	case $progpath in
		4912	[\\/]* \| [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
		4913	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
		4914	esac
		4915	qecho=`$echo "X$qecho" \| $Xsed -e "$sed_quote_subst"`
		4916	else
		4917	qecho=`$echo "X$echo" \| $Xsed -e "$sed_quote_subst"`
		4918	fi
		4919
		4920	# Only actually do things if our run command is non-null.
		4921	if test -z "$run"; then
		4922	# win32 will think the script is a binary if it has
		4923	# a .exe suffix, so we strip it off here.
		4924	case $output in
		4925	*.exe) output=`$echo $output\|${SED} 's,.exe$,,'` ;;
		4926	esac
		4927	# test for cygwin because mv fails w/o .exe extensions
		4928	case $host in
		4929	cygwin)
		4930	exeext=.exe
		4931	outputname=`$echo $outputname\|${SED} 's,.exe$,,'` ;;
		4932	*) exeext= ;;
		4933	esac
		4934	case $host in
		4935	cygwin \| mingw )
		4936	output_name=`basename $output`
		4937	output_path=`dirname $output`
		4938	cwrappersource="$output_path/$objdir/lt-$output_name.c"
		4939	cwrapper="$output_path/$output_name.exe"
		4940	$rm $cwrappersource $cwrapper
		4941	trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
		4942
		4943	cat > $cwrappersource <<EOF
		4944
		4945	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
		4946	Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
		4947
		4948	The $output program cannot be directly executed until all the libtool
		4949	libraries that it depends on are installed.
		4950
		4951	This wrapper executable should never be moved out of the build directory.
		4952	If it is, it will not operate correctly.
		4953
		4954	Currently, it simply execs the wrapper script "/bin/sh $output",
		4955	but could eventually absorb all of the scripts functionality and
		4956	exec $objdir/$outputname directly.
		4957	*/
		4958	EOF
		4959	cat >> $cwrappersource<<"EOF"
		4960	#include <stdio.h>
		4961	#include <stdlib.h>
		4962	#include <unistd.h>
		4963	#include <malloc.h>
		4964	#include <stdarg.h>
		4965	#include <assert.h>
		4966	#include <string.h>
		4967	#include <ctype.h>
		4968	#include <sys/stat.h>
		4969
		4970	#if defined(PATH_MAX)
		4971	# define LT_PATHMAX PATH_MAX
		4972	#elif defined(MAXPATHLEN)
		4973	# define LT_PATHMAX MAXPATHLEN
		4974	#else
		4975	# define LT_PATHMAX 1024
		4976	#endif
		4977
		4978	#ifndef DIR_SEPARATOR
		4979	# define DIR_SEPARATOR '/'
		4980	# define PATH_SEPARATOR ':'
		4981	#endif
		4982
		4983	#if defined (_WIN32) \|\| defined (__MSDOS__) \|\| defined (__DJGPP__) \|\| \
		4984	defined (__OS2__)
		4985	# define HAVE_DOS_BASED_FILE_SYSTEM
		4986	# ifndef DIR_SEPARATOR_2
		4987	# define DIR_SEPARATOR_2 '\\'
		4988	# endif
		4989	# ifndef PATH_SEPARATOR_2
		4990	# define PATH_SEPARATOR_2 ';'
		4991	# endif
		4992	#endif
		4993
		4994	#ifndef DIR_SEPARATOR_2
		4995	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
		4996	#else /* DIR_SEPARATOR_2 */
		4997	# define IS_DIR_SEPARATOR(ch) \
		4998	(((ch) == DIR_SEPARATOR) \|\| ((ch) == DIR_SEPARATOR_2))
		4999	#endif /* DIR_SEPARATOR_2 */
		5000
		5001	#ifndef PATH_SEPARATOR_2
		5002	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
		5003	#else /* PATH_SEPARATOR_2 */
		5004	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
		5005	#endif /* PATH_SEPARATOR_2 */
		5006
		5007	#define XMALLOC(type, num) ((type ) xmalloc ((num) sizeof(type)))
		5008	#define XFREE(stale) do { \
		5009	if (stale) { free ((void *) stale); stale = 0; } \
		5010	} while (0)
		5011
		5012	/* -DDEBUG is fairly common in CFLAGS. */
		5013	#undef DEBUG
		5014	#if defined DEBUGWRAPPER
		5015	# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
		5016	#else
		5017	# define DEBUG(format, ...)
		5018	#endif
		5019
		5020	const char *program_name = NULL;
		5021
		5022	void * xmalloc (size_t num);
		5023	char * xstrdup (const char *string);
		5024	const char * base_name (const char *name);
		5025	char * find_executable(const char *wrapper);
		5026	int check_executable(const char *path);
		5027	char * strendzap(char str, const char pat);
		5028	void lt_fatal (const char *message, ...);
		5029
		5030	int
		5031	main (int argc, char *argv[])
		5032	{
		5033	char **newargz;
		5034	int i;
		5035
		5036	program_name = (char *) xstrdup (base_name (argv[0]));
		5037	DEBUG("(main) argv[0] : %s\n",argv[0]);
		5038	DEBUG("(main) program_name : %s\n",program_name);
		5039	newargz = XMALLOC(char *, argc+2);
		5040	EOF
		5041
		5042	cat >> $cwrappersource <<EOF
		5043	newargz[0] = (char *) xstrdup("$SHELL");
		5044	EOF
		5045
		5046	cat >> $cwrappersource <<"EOF"
		5047	newargz[1] = find_executable(argv[0]);
		5048	if (newargz[1] == NULL)
		5049	lt_fatal("Couldn't find %s", argv[0]);
		5050	DEBUG("(main) found exe at : %s\n",newargz[1]);
		5051	/* we know the script has the same name, without the .exe */
		5052	/* so make sure newargz[1] doesn't end in .exe */
		5053	strendzap(newargz[1],".exe");
		5054	for (i = 1; i < argc; i++)
		5055	newargz[i+1] = xstrdup(argv[i]);
		5056	newargz[argc+1] = NULL;
		5057
		5058	for (i=0; i<argc+1; i++)
		5059	{
		5060	DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
		5061	;
		5062	}
		5063
		5064	EOF
		5065
		5066	case $host_os in
		5067	mingw*)
		5068	cat >> $cwrappersource <<EOF
		5069	execv("$SHELL",(char const **)newargz);
		5070	EOF
		5071	;;
		5072	*)
		5073	cat >> $cwrappersource <<EOF
		5074	execv("$SHELL",newargz);
		5075	EOF
		5076	;;
		5077	esac
		5078
		5079	cat >> $cwrappersource <<"EOF"
		5080	return 127;
		5081	}
		5082
		5083	void *
		5084	xmalloc (size_t num)
		5085	{
		5086	void * p = (void *) malloc (num);
		5087	if (!p)
		5088	lt_fatal ("Memory exhausted");
		5089
		5090	return p;
		5091	}
		5092
		5093	char *
		5094	xstrdup (const char *string)
		5095	{
		5096	return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
		5097	;
		5098	}
		5099
		5100	const char *
		5101	base_name (const char *name)
		5102	{
		5103	const char *base;
		5104
		5105	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
		5106	/* Skip over the disk name in MSDOS pathnames. */
		5107	if (isalpha ((unsigned char)name[0]) && name[1] == ':')
		5108	name += 2;
		5109	#endif
		5110
		5111	for (base = name; *name; name++)
		5112	if (IS_DIR_SEPARATOR (*name))
		5113	base = name + 1;
		5114	return base;
		5115	}
		5116
		5117	int
		5118	check_executable(const char * path)
		5119	{
		5120	struct stat st;
		5121
		5122	DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
		5123	if ((!path) \|\| (!*path))
		5124	return 0;
		5125
		5126	if ((stat (path, &st) >= 0) &&
		5127	(
		5128	/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
		5129	#if defined (S_IXOTH)
		5130	((st.st_mode & S_IXOTH) == S_IXOTH) \|\|
		5131	#endif
		5132	#if defined (S_IXGRP)
		5133	((st.st_mode & S_IXGRP) == S_IXGRP) \|\|
		5134	#endif
		5135	((st.st_mode & S_IXUSR) == S_IXUSR))
		5136	)
		5137	return 1;
		5138	else
		5139	return 0;
		5140	}
		5141
		5142	/* Searches for the full path of the wrapper. Returns
		5143	newly allocated full path name if found, NULL otherwise */
		5144	char *
		5145	find_executable (const char* wrapper)
		5146	{
		5147	int has_slash = 0;
		5148	const char* p;
		5149	const char* p_next;
		5150	/* static buffer for getcwd */
		5151	char tmp[LT_PATHMAX + 1];
		5152	int tmp_len;
		5153	char* concat_name;
		5154
		5155	DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
		5156
		5157	if ((wrapper == NULL) \|\| (*wrapper == '\0'))
		5158	return NULL;
		5159
		5160	/* Absolute path? */
		5161	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
		5162	if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
		5163	{
		5164	concat_name = xstrdup (wrapper);
		5165	if (check_executable(concat_name))
		5166	return concat_name;
		5167	XFREE(concat_name);
		5168	}
		5169	else
		5170	{
		5171	#endif
		5172	if (IS_DIR_SEPARATOR (wrapper[0]))
		5173	{
		5174	concat_name = xstrdup (wrapper);
		5175	if (check_executable(concat_name))
		5176	return concat_name;
		5177	XFREE(concat_name);
		5178	}
		5179	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
		5180	}
		5181	#endif
		5182
		5183	for (p = wrapper; *p; p++)
		5184	if (*p == '/')
		5185	{
		5186	has_slash = 1;
		5187	break;
		5188	}
		5189	if (!has_slash)
		5190	{
		5191	/* no slashes; search PATH */
		5192	const char* path = getenv ("PATH");
		5193	if (path != NULL)
		5194	{
		5195	for (p = path; *p; p = p_next)
		5196	{
		5197	const char* q;
		5198	size_t p_len;
		5199	for (q = p; *q; q++)
		5200	if (IS_PATH_SEPARATOR(*q))
		5201	break;
		5202	p_len = q - p;
		5203	p_next = (*q == '\0' ? q : q + 1);
		5204	if (p_len == 0)
		5205	{
		5206	/* empty path: current directory */
		5207	if (getcwd (tmp, LT_PATHMAX) == NULL)
		5208	lt_fatal ("getcwd failed");
		5209	tmp_len = strlen(tmp);
		5210	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
		5211	memcpy (concat_name, tmp, tmp_len);
		5212	concat_name[tmp_len] = '/';
		5213	strcpy (concat_name + tmp_len + 1, wrapper);
		5214	}
		5215	else
		5216	{
		5217	concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
		5218	memcpy (concat_name, p, p_len);
		5219	concat_name[p_len] = '/';
		5220	strcpy (concat_name + p_len + 1, wrapper);
		5221	}
		5222	if (check_executable(concat_name))
		5223	return concat_name;
		5224	XFREE(concat_name);
		5225	}
		5226	}
		5227	/* not found in PATH; assume curdir */
		5228	}
		5229	/* Relative path \| not found in path: prepend cwd */
		5230	if (getcwd (tmp, LT_PATHMAX) == NULL)
		5231	lt_fatal ("getcwd failed");
		5232	tmp_len = strlen(tmp);
		5233	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
		5234	memcpy (concat_name, tmp, tmp_len);
		5235	concat_name[tmp_len] = '/';
		5236	strcpy (concat_name + tmp_len + 1, wrapper);
		5237
		5238	if (check_executable(concat_name))
		5239	return concat_name;
		5240	XFREE(concat_name);
		5241	return NULL;
		5242	}
		5243
		5244	char *
		5245	strendzap(char str, const char pat)
		5246	{
		5247	size_t len, patlen;
		5248
		5249	assert(str != NULL);
		5250	assert(pat != NULL);
		5251
		5252	len = strlen(str);
		5253	patlen = strlen(pat);
		5254
		5255	if (patlen <= len)
		5256	{
		5257	str += len - patlen;
		5258	if (strcmp(str, pat) == 0)
		5259	*str = '\0';
		5260	}
		5261	return str;
		5262	}
		5263
		5264	static void
		5265	lt_error_core (int exit_status, const char * mode,
		5266	const char * message, va_list ap)
		5267	{
		5268	fprintf (stderr, "%s: %s: ", program_name, mode);
		5269	vfprintf (stderr, message, ap);
		5270	fprintf (stderr, ".\n");
		5271
		5272	if (exit_status >= 0)
		5273	exit (exit_status);
		5274	}
		5275
		5276	void
		5277	lt_fatal (const char *message, ...)
		5278	{
		5279	va_list ap;
		5280	va_start (ap, message);
		5281	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
		5282	va_end (ap);
		5283	}
		5284	EOF
		5285	# we should really use a build-platform specific compiler
		5286	# here, but OTOH, the wrappers (shell script and this C one)
		5287	# are only useful if you want to execute the "real" binary.
		5288	# Since the "real" binary is built for $host, then this
		5289	# wrapper might as well be built for $host, too.
		5290	$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
		5291	;;
		5292	esac
		5293	$rm $output
		5294	trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
		5295
		5296	$echo > $output "\
		5297	#! $SHELL
		5298
		5299	# $output - temporary wrapper script for $objdir/$outputname
		5300	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
		5301	#
		5302	# The $output program cannot be directly executed until all the libtool
		5303	# libraries that it depends on are installed.
		5304	#
		5305	# This wrapper script should never be moved out of the build directory.
		5306	# If it is, it will not operate correctly.
		5307
		5308	# Sed substitution that helps us do robust quoting. It backslashifies
		5309	# metacharacters that are still active within double-quoted strings.
		5310	Xsed='${SED} -e 1s/^X//'
		5311	sed_quote_subst='$sed_quote_subst'
		5312
		5313	# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
		5314	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
		5315	emulate sh
		5316	NULLCMD=:
		5317	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
		5318	# is contrary to our usage. Disable this feature.
		5319	alias -g '\${1+\"\$@\"}'='\"\$@\"'
		5320	setopt NO_GLOB_SUBST
		5321	else
		5322	case \`(set -o) 2>/dev/null\` in posix) set -o posix;; esac
		5323	fi
		5324	BIN_SH=xpg4; export BIN_SH # for Tru64
		5325	DUALCASE=1; export DUALCASE # for MKS sh
		5326
		5327	# The HP-UX ksh and POSIX shell print the target directory to stdout
		5328	# if CDPATH is set.
		5329	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
		5330
		5331	relink_command=\"$relink_command\"
		5332
		5333	# This environment variable determines our operation mode.
		5334	if test \"\$libtool_install_magic\" = \"$magic\"; then
		5335	# install mode needs the following variable:
		5336	notinst_deplibs='$notinst_deplibs'
		5337	else
		5338	# When we are sourced in execute mode, \$file and \$echo are already set.
		5339	if test \"\$libtool_execute_magic\" != \"$magic\"; then
		5340	echo=\"$qecho\"
		5341	file=\"\$0\"
		5342	# Make sure echo works.
		5343	if test \"X\$1\" = X--no-reexec; then
		5344	# Discard the --no-reexec flag, and continue.
		5345	shift
		5346	elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
		5347	# Yippee, \$echo works!
		5348	:
		5349	else
		5350	# Restart under the correct shell, and then maybe \$echo will work.
		5351	exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
		5352	fi
		5353	fi\
		5354	"
		5355	$echo >> $output "\
		5356
		5357	# Find the directory that this script lives in.
		5358	thisdir=\`\$echo \"X\$file\" \| \$Xsed -e 's%/[^/]*$%%'\`
		5359	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
		5360
		5361	# Follow symbolic links until we get to the real thisdir.
		5362	file=\`ls -ld \"\$file\" \| ${SED} -n 's/.*-> //p'\`
		5363	while test -n \"\$file\"; do
		5364	destdir=\`\$echo \"X\$file\" \| \$Xsed -e 's%/[^/]*\$%%'\`
		5365
		5366	# If there was a directory component, then change thisdir.
		5367	if test \"x\$destdir\" != \"x\$file\"; then
		5368	case \"\$destdir\" in
		5369	[\\\\/]* \| [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
		5370	*) thisdir=\"\$thisdir/\$destdir\" ;;
		5371	esac
		5372	fi
		5373
		5374	file=\`\$echo \"X\$file\" \| \$Xsed -e 's%^.*/%%'\`
		5375	file=\`ls -ld \"\$thisdir/\$file\" \| ${SED} -n 's/.*-> //p'\`
		5376	done
		5377
		5378	# Try to get the absolute directory name.
		5379	absdir=\`cd \"\$thisdir\" && pwd\`
		5380	test -n \"\$absdir\" && thisdir=\"\$absdir\"
		5381	"
		5382
		5383	if test "$fast_install" = yes; then
		5384	$echo >> $output "\
		5385	program=lt-'$outputname'$exeext
		5386	progdir=\"\$thisdir/$objdir\"
		5387
		5388	if test ! -f \"\$progdir/\$program\" \|\| \\
		5389	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null \| ${SED} 1q\`; \\
		5390	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
		5391
		5392	file=\"\$\$-\$program\"
		5393
		5394	if test ! -d \"\$progdir\"; then
		5395	$mkdir \"\$progdir\"
		5396	else
		5397	$rm \"\$progdir/\$file\"
		5398	fi"
		5399
		5400	$echo >> $output "\
		5401
		5402	# relink executable if necessary
		5403	if test -n \"\$relink_command\"; then
		5404	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
		5405	else
		5406	$echo \"\$relink_command_output\" >&2
		5407	$rm \"\$progdir/\$file\"
		5408	exit $EXIT_FAILURE
		5409	fi
		5410	fi
		5411
		5412	$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null \|\|
		5413	{ $rm \"\$progdir/\$program\";
		5414	$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
		5415	$rm \"\$progdir/\$file\"
		5416	fi"
		5417	else
		5418	$echo >> $output "\
		5419	program='$outputname'
		5420	progdir=\"\$thisdir/$objdir\"
		5421	"
		5422	fi
		5423
		5424	$echo >> $output "\
		5425
		5426	if test -f \"\$progdir/\$program\"; then"
		5427
		5428	# Export our shlibpath_var if we have one.
		5429	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
		5430	$echo >> $output "\
		5431	# Add our own library path to $shlibpath_var
		5432	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
		5433
		5434	# Some systems cannot cope with colon-terminated $shlibpath_var
		5435	# The second colon is a workaround for a bug in BeOS R4 sed
		5436	$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" \| \$Xsed -e 's/::*\$//'\`
		5437
		5438	export $shlibpath_var
		5439	"
		5440	fi
		5441
		5442	# fixup the dll searchpath if we need to.
		5443	if test -n "$dllsearchpath"; then
		5444	$echo >> $output "\
		5445	# Add the dll search path components to the executable PATH
		5446	PATH=$dllsearchpath:\$PATH
		5447	"
		5448	fi
		5449
		5450	$echo >> $output "\
		5451	if test \"\$libtool_execute_magic\" != \"$magic\"; then
		5452	# Run the actual program with our arguments.
		5453	"
		5454	case $host in
		5455	# Backslashes separate directories on plain windows
		5456	--mingw \| --os2*)
		5457	$echo >> $output "\
		5458	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
		5459	"
		5460	;;
		5461
		5462	*)
		5463	$echo >> $output "\
		5464	exec \"\$progdir/\$program\" \${1+\"\$@\"}
		5465	"
		5466	;;
		5467	esac
		5468	$echo >> $output "\
		5469	\$echo \"\$0: cannot exec \$program \$*\"
		5470	exit $EXIT_FAILURE
		5471	fi
		5472	else
		5473	# The program doesn't exist.
		5474	\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
		5475	\$echo \"This script is just a wrapper for \$program.\" 1>&2
		5476	$echo \"See the $PACKAGE documentation for more information.\" 1>&2
		5477	exit $EXIT_FAILURE
		5478	fi
		5479	fi\
		5480	"
		5481	chmod +x $output
		5482	fi
		5483	exit $EXIT_SUCCESS
		5484	;;
		5485	esac
		5486
		5487	# See if we need to build an old-fashioned archive.
		5488	for oldlib in $oldlibs; do
		5489
		5490	if test "$build_libtool_libs" = convenience; then
		5491	oldobjs="$libobjs_save"
		5492	addlibs="$convenience"
		5493	build_libtool_libs=no
		5494	else
		5495	if test "$build_libtool_libs" = module; then
		5496	oldobjs="$libobjs_save"
		5497	build_libtool_libs=no
		5498	else
		5499	oldobjs="$old_deplibs $non_pic_objects"
		5500	fi
		5501	addlibs="$old_convenience"
		5502	fi
		5503
		5504	if test -n "$addlibs"; then
		5505	gentop="$output_objdir/${outputname}x"
		5506	generated="$generated $gentop"
		5507
		5508	func_extract_archives $gentop $addlibs
		5509	oldobjs="$oldobjs $func_extract_archives_result"
		5510	fi
		5511
		5512	# Do each command in the archive commands.
		5513	if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
		5514	cmds=$old_archive_from_new_cmds
		5515	else
		5516	# POSIX demands no paths to be encoded in archives. We have
		5517	# to avoid creating archives with duplicate basenames if we
		5518	# might have to extract them afterwards, e.g., when creating a
		5519	# static archive out of a convenience library, or when linking
		5520	# the entirety of a libtool archive into another (currently
		5521	# not supported by libtool).
		5522	if (for obj in $oldobjs
		5523	do
		5524	$echo "X$obj" \| $Xsed -e 's%^.*/%%'
		5525	done \| sort \| sort -uc >/dev/null 2>&1); then
		5526	:
		5527	else
		5528	$echo "copying selected object files to avoid basename conflicts..."
		5529
		5530	if test -z "$gentop"; then
		5531	gentop="$output_objdir/${outputname}x"
		5532	generated="$generated $gentop"
		5533
		5534	$show "${rm}r $gentop"
		5535	$run ${rm}r "$gentop"
		5536	$show "$mkdir $gentop"
		5537	$run $mkdir "$gentop"
		5538	exit_status=$?
		5539	if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
		5540	exit $exit_status
		5541	fi
		5542	fi
		5543
		5544	save_oldobjs=$oldobjs
		5545	oldobjs=
		5546	counter=1
		5547	for obj in $save_oldobjs
		5548	do
		5549	objbase=`$echo "X$obj" \| $Xsed -e 's%^.*/%%'`
		5550	case " $oldobjs " in
		5551	" ") oldobjs=$obj ;;
		5552	[\ /]"$objbase ")
		5553	while :; do
		5554	# Make sure we don't pick an alternate name that also
		5555	# overlaps.
		5556	newobj=lt$counter-$objbase
		5557	counter=`expr $counter + 1`
		5558	case " $oldobjs " in
		5559	[\ /]"$newobj ") ;;
		5560	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
		5561	esac
		5562	done
		5563	$show "ln $obj $gentop/$newobj \|\| cp $obj $gentop/$newobj"
		5564	$run ln "$obj" "$gentop/$newobj" \|\|
		5565	$run cp "$obj" "$gentop/$newobj"
		5566	oldobjs="$oldobjs $gentop/$newobj"
		5567	;;
		5568	*) oldobjs="$oldobjs $obj" ;;
		5569	esac
		5570	done
		5571	fi
		5572
		5573	eval cmds=\"$old_archive_cmds\"
		5574
		5575	if len=`expr "X$cmds" : ".*"` &&
		5576	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
		5577	cmds=$old_archive_cmds
		5578	else
		5579	# the command line is too long to link in one step, link in parts
		5580	$echo "using piecewise archive linking..."
		5581	save_RANLIB=$RANLIB
		5582	RANLIB=:
		5583	objlist=
		5584	concat_cmds=
		5585	save_oldobjs=$oldobjs
		5586
		5587	# Is there a better way of finding the last object in the list?
		5588	for obj in $save_oldobjs
		5589	do
		5590	last_oldobj=$obj
		5591	done
		5592	for obj in $save_oldobjs
		5593	do
		5594	oldobjs="$objlist $obj"
		5595	objlist="$objlist $obj"
		5596	eval test_cmds=\"$old_archive_cmds\"
		5597	if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
		5598	test "$len" -le "$max_cmd_len"; then
		5599	:
		5600	else
		5601	# the above command should be used before it gets too long
		5602	oldobjs=$objlist
		5603	if test "$obj" = "$last_oldobj" ; then
		5604	RANLIB=$save_RANLIB
		5605	fi
		5606	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
		5607	eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
		5608	objlist=
		5609	fi
		5610	done
		5611	RANLIB=$save_RANLIB
		5612	oldobjs=$objlist
		5613	if test "X$oldobjs" = "X" ; then
		5614	eval cmds=\"\$concat_cmds\"
		5615	else
		5616	eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
		5617	fi
		5618	fi
		5619	fi
		5620	save_ifs="$IFS"; IFS='~'
		5621	for cmd in $cmds; do
		5622	eval cmd=\"$cmd\"
		5623	IFS="$save_ifs"
		5624	$show "$cmd"
		5625	$run eval "$cmd" \|\| exit $?
		5626	done
		5627	IFS="$save_ifs"
		5628	done
		5629
		5630	if test -n "$generated"; then
		5631	$show "${rm}r$generated"
		5632	$run ${rm}r$generated
		5633	fi
		5634
		5635	# Now create the libtool archive.
		5636	case $output in
		5637	*.la)
		5638	old_library=
		5639	test "$build_old_libs" = yes && old_library="$libname.$libext"
		5640	$show "creating $output"
		5641
		5642	# Preserve any variables that may affect compiler behavior
		5643	for var in $variables_saved_for_relink; do
		5644	if eval test -z \"\${$var+set}\"; then
		5645	relink_command="{ test -z \"\${$var+set}\" \|\| unset $var \|\| { $var=; export $var; }; }; $relink_command"
		5646	elif eval var_value=\$$var; test -z "$var_value"; then
		5647	relink_command="$var=; export $var; $relink_command"
		5648	else
		5649	var_value=`$echo "X$var_value" \| $Xsed -e "$sed_quote_subst"`
		5650	relink_command="$var=\"$var_value\"; export $var; $relink_command"
		5651	fi
		5652	done
		5653	# Quote the link command for shipping.
		5654	relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
		5655	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e "$sed_quote_subst" \| $NL2SP`
		5656	if test "$hardcode_automatic" = yes ; then
		5657	relink_command=
		5658	fi
		5659
		5660
		5661	# Only create the output if not a dry run.
		5662	if test -z "$run"; then
		5663	for installed in no yes; do
		5664	if test "$installed" = yes; then
		5665	if test -z "$install_libdir"; then
		5666	break
		5667	fi
		5668	output="$output_objdir/$outputname"i
		5669	# Replace all uninstalled libtool libraries with the installed ones
		5670	newdependency_libs=
		5671	for deplib in $dependency_libs; do
		5672	case $deplib in
		5673	*.la)
		5674	name=`$echo "X$deplib" \| $Xsed -e 's%^.*/%%'`
		5675	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`
		5676	if test -z "$libdir"; then
		5677	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
		5678	exit $EXIT_FAILURE
		5679	fi
		5680	newdependency_libs="$newdependency_libs $libdir/$name"
		5681	;;
		5682	*) newdependency_libs="$newdependency_libs $deplib" ;;
		5683	esac
		5684	done
		5685	dependency_libs="$newdependency_libs"
		5686	newdlfiles=
		5687	for lib in $dlfiles; do
		5688	name=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
		5689	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
		5690	if test -z "$libdir"; then
		5691	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		5692	exit $EXIT_FAILURE
		5693	fi
		5694	newdlfiles="$newdlfiles $libdir/$name"
		5695	done
		5696	dlfiles="$newdlfiles"
		5697	newdlprefiles=
		5698	for lib in $dlprefiles; do
		5699	name=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
		5700	eval libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
		5701	if test -z "$libdir"; then
		5702	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		5703	exit $EXIT_FAILURE
		5704	fi
		5705	newdlprefiles="$newdlprefiles $libdir/$name"
		5706	done
		5707	dlprefiles="$newdlprefiles"
		5708	else
		5709	newdlfiles=
		5710	for lib in $dlfiles; do
		5711	case $lib in
		5712	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
		5713	*) abs=`pwd`"/$lib" ;;
		5714	esac
		5715	newdlfiles="$newdlfiles $abs"
		5716	done
		5717	dlfiles="$newdlfiles"
		5718	newdlprefiles=
		5719	for lib in $dlprefiles; do
		5720	case $lib in
		5721	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
		5722	*) abs=`pwd`"/$lib" ;;
		5723	esac
		5724	newdlprefiles="$newdlprefiles $abs"
		5725	done
		5726	dlprefiles="$newdlprefiles"
		5727	fi
		5728	$rm $output
		5729	# place dlname in correct position for cygwin
		5730	tdlname=$dlname
		5731	case $host,$output,$installed,$module,$dlname in
		5732	cygwin,lai,yes,no,.dll \| mingw,lai,yes,no,.dll) tdlname=../bin/$dlname ;;
		5733	esac
		5734	$echo > $output "\
		5735	# $outputname - a libtool library file
		5736	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
		5737	#
		5738	# Please DO NOT delete this file!
		5739	# It is necessary for linking the library.
		5740
		5741	# The name that we can dlopen(3).
		5742	dlname='$tdlname'
		5743
		5744	# Names of this library.
		5745	library_names='$library_names'
		5746
		5747	# The name of the static archive.
		5748	old_library='$old_library'
		5749
		5750	# Libraries that this one depends upon.
		5751	dependency_libs='$dependency_libs'
		5752
		5753	# Version information for $libname.
		5754	current=$current
		5755	age=$age
		5756	revision=$revision
		5757
		5758	# Is this an already installed library?
		5759	installed=$installed
		5760
		5761	# Should we warn about portability when linking against -modules?
		5762	shouldnotlink=$module
		5763
		5764	# Files to dlopen/dlpreopen
		5765	dlopen='$dlfiles'
		5766	dlpreopen='$dlprefiles'
		5767
		5768	# Directory that this library needs to be installed in:
		5769	libdir='$install_libdir'"
		5770	if test "$installed" = no && test "$need_relink" = yes; then
		5771	$echo >> $output "\
		5772	relink_command=\"$relink_command\""
		5773	fi
		5774	done
		5775	fi
		5776
		5777	# Do a symbolic link so that the libtool archive can be found in
		5778	# LD_LIBRARY_PATH before the program is installed.
		5779	$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
		5780	$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' \|\| exit $?
		5781	;;
		5782	esac
		5783	exit $EXIT_SUCCESS
		5784	;;
		5785
		5786	# libtool install mode
		5787	install)
		5788	modename="$modename: install"
		5789
		5790	# There may be an optional sh(1) argument at the beginning of
		5791	# install_prog (especially on Windows NT).
		5792	if test "$nonopt" = "$SHELL" \|\| test "$nonopt" = /bin/sh \|\|
		5793	# Allow the use of GNU shtool's install command.
		5794	$echo "X$nonopt" \| grep shtool > /dev/null; then
		5795	# Aesthetically quote it.
		5796	arg=`$echo "X$nonopt" \| $Xsed -e "$sed_quote_subst"`
		5797	case $arg in
		5798	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		5799	arg="\"$arg\""
		5800	;;
		5801	esac
		5802	install_prog="$arg "
		5803	arg="$1"
		5804	shift
		5805	else
		5806	install_prog=
		5807	arg=$nonopt
		5808	fi
		5809
		5810	# The real first argument should be the name of the installation program.
		5811	# Aesthetically quote it.
		5812	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
		5813	case $arg in
		5814	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		5815	arg="\"$arg\""
		5816	;;
		5817	esac
		5818	install_prog="$install_prog$arg"
		5819
		5820	# We need to accept at least all the BSD install flags.
		5821	dest=
		5822	files=
		5823	opts=
		5824	prev=
		5825	install_type=
		5826	isdir=no
		5827	stripme=
		5828	for arg
		5829	do
		5830	if test -n "$dest"; then
		5831	files="$files $dest"
		5832	dest=$arg
		5833	continue
		5834	fi
		5835
		5836	case $arg in
		5837	-d) isdir=yes ;;
		5838	-f)
		5839	case " $install_prog " in
		5840	[\\\ /]cp\ ) ;;
		5841	*) prev=$arg ;;
		5842	esac
		5843	;;
		5844	-g \| -m \| -o) prev=$arg ;;
		5845	-s)
		5846	stripme=" -s"
		5847	continue
		5848	;;
		5849	-*)
		5850	;;
		5851	*)
		5852	# If the previous option needed an argument, then skip it.
		5853	if test -n "$prev"; then
		5854	prev=
		5855	else
		5856	dest=$arg
		5857	continue
		5858	fi
		5859	;;
		5860	esac
		5861
		5862	# Aesthetically quote the argument.
		5863	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
		5864	case $arg in
		5865	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
		5866	arg="\"$arg\""
		5867	;;
		5868	esac
		5869	install_prog="$install_prog $arg"
		5870	done
		5871
		5872	if test -z "$install_prog"; then
		5873	$echo "$modename: you must specify an install program" 1>&2
		5874	$echo "$help" 1>&2
		5875	exit $EXIT_FAILURE
		5876	fi
		5877
		5878	if test -n "$prev"; then
		5879	$echo "$modename: the \`$prev' option requires an argument" 1>&2
		5880	$echo "$help" 1>&2
		5881	exit $EXIT_FAILURE
		5882	fi
		5883
		5884	if test -z "$files"; then
		5885	if test -z "$dest"; then
		5886	$echo "$modename: no file or destination specified" 1>&2
		5887	else
		5888	$echo "$modename: you must specify a destination" 1>&2
		5889	fi
		5890	$echo "$help" 1>&2
		5891	exit $EXIT_FAILURE
		5892	fi
		5893
		5894	# Strip any trailing slash from the destination.
		5895	dest=`$echo "X$dest" \| $Xsed -e 's%/$%%'`
		5896
		5897	# Check to see that the destination is a directory.
		5898	test -d "$dest" && isdir=yes
		5899	if test "$isdir" = yes; then
		5900	destdir="$dest"
		5901	destname=
		5902	else
		5903	destdir=`$echo "X$dest" \| $Xsed -e 's%/[^/]*$%%'`
		5904	test "X$destdir" = "X$dest" && destdir=.
		5905	destname=`$echo "X$dest" \| $Xsed -e 's%^.*/%%'`
		5906
		5907	# Not a directory, so check to see that there is only one file specified.
		5908	set dummy $files
		5909	if test "$#" -gt 2; then
		5910	$echo "$modename: \`$dest' is not a directory" 1>&2
		5911	$echo "$help" 1>&2
		5912	exit $EXIT_FAILURE
		5913	fi
		5914	fi
		5915	case $destdir in
		5916	[\\/]* \| [A-Za-z]:[\\/]*) ;;
		5917	*)
		5918	for file in $files; do
		5919	case $file in
		5920	*.lo) ;;
		5921	*)
		5922	$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
		5923	$echo "$help" 1>&2
		5924	exit $EXIT_FAILURE
		5925	;;
		5926	esac
		5927	done
		5928	;;
		5929	esac
		5930
		5931	# This variable tells wrapper scripts just to set variables rather
		5932	# than running their programs.
		5933	libtool_install_magic="$magic"
		5934
		5935	staticlibs=
		5936	future_libdirs=
		5937	current_libdirs=
		5938	for file in $files; do
		5939
		5940	# Do each installation.
		5941	case $file in
		5942	*.$libext)
		5943	# Do the static libraries later.
		5944	staticlibs="$staticlibs $file"
		5945	;;
		5946
		5947	*.la)
		5948	# Check to see that this really is a libtool archive.
		5949	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
		5950	else
		5951	$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
		5952	$echo "$help" 1>&2
		5953	exit $EXIT_FAILURE
		5954	fi
		5955
		5956	library_names=
		5957	old_library=
		5958	relink_command=
		5959	# If there is no directory component, then add one.
		5960	case $file in
		5961	/ \| \\) . $file ;;
		5962	*) . ./$file ;;
		5963	esac
		5964
		5965	# Add the libdir to current_libdirs if it is the destination.
		5966	if test "X$destdir" = "X$libdir"; then
		5967	case "$current_libdirs " in
		5968	" $libdir ") ;;
		5969	*) current_libdirs="$current_libdirs $libdir" ;;
		5970	esac
		5971	else
		5972	# Note the libdir as a future libdir.
		5973	case "$future_libdirs " in
		5974	" $libdir ") ;;
		5975	*) future_libdirs="$future_libdirs $libdir" ;;
		5976	esac
		5977	fi
		5978
		5979	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`/
		5980	test "X$dir" = "X$file/" && dir=
		5981	dir="$dir$objdir"
		5982
		5983	if test -n "$relink_command"; then
		5984	# Determine the prefix the user has applied to our future dir.
		5985	inst_prefix_dir=`$echo "$destdir" \| $SED "s%$libdir\$%%"`
		5986
		5987	# Don't allow the user to place us outside of our expected
		5988	# location b/c this prevents finding dependent libraries that
		5989	# are installed to the same prefix.
		5990	# At present, this check doesn't affect windows .dll's that
		5991	# are installed into $libdir/../bin (currently, that works fine)
		5992	# but it's something to keep an eye on.
		5993	if test "$inst_prefix_dir" = "$destdir"; then
		5994	$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
		5995	exit $EXIT_FAILURE
		5996	fi
		5997
		5998	if test -n "$inst_prefix_dir"; then
		5999	# Stick the inst_prefix_dir data into the link command.
		6000	relink_command=`$echo "$relink_command" \| $SP2NL \| $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" \| $NL2SP`
		6001	else
		6002	relink_command=`$echo "$relink_command" \| $SP2NL \| $SED "s%@inst_prefix_dir@%%" \| $NL2SP`
		6003	fi
		6004
		6005	$echo "$modename: warning: relinking \`$file'" 1>&2
		6006	$show "$relink_command"
		6007	if $run eval "$relink_command"; then :
		6008	else
		6009	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
		6010	exit $EXIT_FAILURE
		6011	fi
		6012	fi
		6013
		6014	# See the names of the shared library.
		6015	set dummy $library_names
		6016	if test -n "$2"; then
		6017	realname="$2"
		6018	shift
		6019	shift
		6020
		6021	srcname="$realname"
		6022	test -n "$relink_command" && srcname="$realname"T
		6023
		6024	# Install the shared library and build the symlinks.
		6025	$show "$install_prog $dir/$srcname $destdir/$realname"
		6026	$run eval "$install_prog $dir/$srcname $destdir/$realname" \|\| exit $?
		6027	if test -n "$stripme" && test -n "$striplib"; then
		6028	$show "$striplib $destdir/$realname"
		6029	$run eval "$striplib $destdir/$realname" \|\| exit $?
		6030	fi
		6031
		6032	if test "$#" -gt 0; then
		6033	# Delete the old symlinks, and create new ones.
		6034	# Try `ln -sf' first, because the `ln' binary might depend on
		6035	# the symlink we replace! Solaris /bin/ln does not understand -f,
		6036	# so we also need to try rm && ln -s.
		6037	for linkname
		6038	do
		6039	if test "$linkname" != "$realname"; then
		6040	$show "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $rm $linkname && $LN_S $realname $linkname; }; })"
		6041	$run eval "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $rm $linkname && $LN_S $realname $linkname; }; })"
		6042	fi
		6043	done
		6044	fi
		6045
		6046	# Do each command in the postinstall commands.
		6047	lib="$destdir/$realname"
		6048	cmds=$postinstall_cmds
		6049	save_ifs="$IFS"; IFS='~'
		6050	for cmd in $cmds; do
		6051	IFS="$save_ifs"
		6052	eval cmd=\"$cmd\"
		6053	$show "$cmd"
		6054	$run eval "$cmd" \|\| {
		6055	lt_exit=$?
		6056
		6057	# Restore the uninstalled library and exit
		6058	if test "$mode" = relink; then
		6059	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
		6060	fi
		6061
		6062	exit $lt_exit
		6063	}
		6064	done
		6065	IFS="$save_ifs"
		6066	fi
		6067
		6068	# Install the pseudo-library for information purposes.
		6069	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
		6070	instname="$dir/$name"i
		6071	$show "$install_prog $instname $destdir/$name"
		6072	$run eval "$install_prog $instname $destdir/$name" \|\| exit $?
		6073
		6074	# Maybe install the static library, too.
		6075	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
		6076	;;
		6077
		6078	*.lo)
		6079	# Install (i.e. copy) a libtool object.
		6080
		6081	# Figure out destination file name, if it wasn't already specified.
		6082	if test -n "$destname"; then
		6083	destfile="$destdir/$destname"
		6084	else
		6085	destfile=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
		6086	destfile="$destdir/$destfile"
		6087	fi
		6088
		6089	# Deduce the name of the destination old-style object file.
		6090	case $destfile in
		6091	*.lo)
		6092	staticdest=`$echo "X$destfile" \| $Xsed -e "$lo2o"`
		6093	;;
		6094	*.$objext)
		6095	staticdest="$destfile"
		6096	destfile=
		6097	;;
		6098	*)
		6099	$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
		6100	$echo "$help" 1>&2
		6101	exit $EXIT_FAILURE
		6102	;;
		6103	esac
		6104
		6105	# Install the libtool object if requested.
		6106	if test -n "$destfile"; then
		6107	$show "$install_prog $file $destfile"
		6108	$run eval "$install_prog $file $destfile" \|\| exit $?
		6109	fi
		6110
		6111	# Install the old object if enabled.
		6112	if test "$build_old_libs" = yes; then
		6113	# Deduce the name of the old-style object file.
		6114	staticobj=`$echo "X$file" \| $Xsed -e "$lo2o"`
		6115
		6116	$show "$install_prog $staticobj $staticdest"
		6117	$run eval "$install_prog \$staticobj \$staticdest" \|\| exit $?
		6118	fi
		6119	exit $EXIT_SUCCESS
		6120	;;
		6121
		6122	*)
		6123	# Figure out destination file name, if it wasn't already specified.
		6124	if test -n "$destname"; then
		6125	destfile="$destdir/$destname"
		6126	else
		6127	destfile=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
		6128	destfile="$destdir/$destfile"
		6129	fi
		6130
		6131	# If the file is missing, and there is a .exe on the end, strip it
		6132	# because it is most likely a libtool script we actually want to
		6133	# install
		6134	stripped_ext=""
		6135	case $file in
		6136	*.exe)
		6137	if test ! -f "$file"; then
		6138	file=`$echo $file\|${SED} 's,.exe$,,'`
		6139	stripped_ext=".exe"
		6140	fi
		6141	;;
		6142	esac
		6143
		6144	# Do a test to see if this is really a libtool program.
		6145	case $host in
		6146	cygwin\|mingw)
		6147	wrapper=`$echo $file \| ${SED} -e 's,.exe$,,'`
		6148	;;
		6149	*)
		6150	wrapper=$file
		6151	;;
		6152	esac
		6153	if (${SED} -e '4q' $wrapper \| grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
		6154	notinst_deplibs=
		6155	relink_command=
		6156
		6157	# Note that it is not necessary on cygwin/mingw to append a dot to
		6158	# foo even if both foo and FILE.exe exist: automatic-append-.exe
		6159	# behavior happens only for exec(3), not for open(2)! Also, sourcing
		6160	# `FILE.' does not work on cygwin managed mounts.
		6161	#
		6162	# If there is no directory component, then add one.
		6163	case $wrapper in
		6164	/ \| \\) . ${wrapper} ;;
		6165	*) . ./${wrapper} ;;
		6166	esac
		6167
		6168	# Check the variables that should have been set.
		6169	if test -z "$notinst_deplibs"; then
		6170	$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
		6171	exit $EXIT_FAILURE
		6172	fi
		6173
		6174	finalize=yes
		6175	for lib in $notinst_deplibs; do
		6176	# Check to see that each library is installed.
		6177	libdir=
		6178	if test -f "$lib"; then
		6179	# If there is no directory component, then add one.
		6180	case $lib in
		6181	/ \| \\) . $lib ;;
		6182	*) . ./$lib ;;
		6183	esac
		6184	fi
		6185	libfile="$libdir/"`$echo "X$lib" \| $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
		6186	if test -n "$libdir" && test ! -f "$libfile"; then
		6187	$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
		6188	finalize=no
		6189	fi
		6190	done
		6191
		6192	relink_command=
		6193	# Note that it is not necessary on cygwin/mingw to append a dot to
		6194	# foo even if both foo and FILE.exe exist: automatic-append-.exe
		6195	# behavior happens only for exec(3), not for open(2)! Also, sourcing
		6196	# `FILE.' does not work on cygwin managed mounts.
		6197	#
		6198	# If there is no directory component, then add one.
		6199	case $wrapper in
		6200	/ \| \\) . ${wrapper} ;;
		6201	*) . ./${wrapper} ;;
		6202	esac
		6203
		6204	outputname=
		6205	if test "$fast_install" = no && test -n "$relink_command"; then
		6206	if test "$finalize" = yes && test -z "$run"; then
		6207	tmpdir=`func_mktempdir`
		6208	file=`$echo "X$file$stripped_ext" \| $Xsed -e 's%^.*/%%'`
		6209	outputname="$tmpdir/$file"
		6210	# Replace the output file specification.
		6211	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' \| $NL2SP`
		6212
		6213	$show "$relink_command"
		6214	if $run eval "$relink_command"; then :
		6215	else
		6216	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
		6217	${rm}r "$tmpdir"
		6218	continue
		6219	fi
		6220	file="$outputname"
		6221	else
		6222	$echo "$modename: warning: cannot relink \`$file'" 1>&2
		6223	fi
		6224	else
		6225	# Install the binary that we compiled earlier.
		6226	file=`$echo "X$file$stripped_ext" \| $Xsed -e "s%$[^/]*$$%$objdir/\1%"`
		6227	fi
		6228	fi
		6229
		6230	# remove .exe since cygwin /usr/bin/install will append another
		6231	# one anyway
		6232	case $install_prog,$host in
		6233	/usr/bin/install,cygwin)
		6234	case $file:$destfile in
		6235	.exe:.exe)
		6236	# this is ok
		6237	;;
		6238	.exe:)
		6239	destfile=$destfile.exe
		6240	;;
		6241	:.exe)
		6242	destfile=`$echo $destfile \| ${SED} -e 's,.exe$,,'`
		6243	;;
		6244	esac
		6245	;;
		6246	esac
		6247	$show "$install_prog$stripme $file $destfile"
		6248	$run eval "$install_prog\$stripme \$file \$destfile" \|\| exit $?
		6249	test -n "$outputname" && ${rm}r "$tmpdir"
		6250	;;
		6251	esac
		6252	done
		6253
		6254	for file in $staticlibs; do
		6255	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
		6256
		6257	# Set up the ranlib parameters.
		6258	oldlib="$destdir/$name"
		6259
		6260	$show "$install_prog $file $oldlib"
		6261	$run eval "$install_prog \$file \$oldlib" \|\| exit $?
		6262
		6263	if test -n "$stripme" && test -n "$old_striplib"; then
		6264	$show "$old_striplib $oldlib"
		6265	$run eval "$old_striplib $oldlib" \|\| exit $?
		6266	fi
		6267
		6268	# Do each command in the postinstall commands.
		6269	cmds=$old_postinstall_cmds
		6270	save_ifs="$IFS"; IFS='~'
		6271	for cmd in $cmds; do
		6272	IFS="$save_ifs"
		6273	eval cmd=\"$cmd\"
		6274	$show "$cmd"
		6275	$run eval "$cmd" \|\| exit $?
		6276	done
		6277	IFS="$save_ifs"
		6278	done
		6279
		6280	if test -n "$future_libdirs"; then
		6281	$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
		6282	fi
		6283
		6284	if test -n "$current_libdirs"; then
		6285	# Maybe just do a dry run.
		6286	test -n "$run" && current_libdirs=" -n$current_libdirs"
		6287	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
		6288	else
		6289	exit $EXIT_SUCCESS
		6290	fi
		6291	;;
		6292
		6293	# libtool finish mode
		6294	finish)
		6295	modename="$modename: finish"
		6296	libdirs="$nonopt"
		6297	admincmds=
		6298
		6299	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
		6300	for dir
		6301	do
		6302	libdirs="$libdirs $dir"
		6303	done
		6304
		6305	for libdir in $libdirs; do
		6306	if test -n "$finish_cmds"; then
		6307	# Do each command in the finish commands.
		6308	cmds=$finish_cmds
		6309	save_ifs="$IFS"; IFS='~'
		6310	for cmd in $cmds; do
		6311	IFS="$save_ifs"
		6312	eval cmd=\"$cmd\"
		6313	$show "$cmd"
		6314	$run eval "$cmd" \|\| admincmds="$admincmds
		6315	$cmd"
		6316	done
		6317	IFS="$save_ifs"
		6318	fi
		6319	if test -n "$finish_eval"; then
		6320	# Do the single finish_eval.
		6321	eval cmds=\"$finish_eval\"
		6322	$run eval "$cmds" \|\| admincmds="$admincmds
		6323	$cmds"
		6324	fi
		6325	done
		6326	fi
		6327
		6328	# Exit here if they wanted silent mode.
		6329	test "$show" = : && exit $EXIT_SUCCESS
		6330
		6331	$echo "X----------------------------------------------------------------------" \| $Xsed
		6332	$echo "Libraries have been installed in:"
		6333	for libdir in $libdirs; do
		6334	$echo " $libdir"
		6335	done
		6336	$echo
		6337	$echo "If you ever happen to want to link against installed libraries"
		6338	$echo "in a given directory, LIBDIR, you must either use libtool, and"
		6339	$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
		6340	$echo "flag during linking and do at least one of the following:"
		6341	if test -n "$shlibpath_var"; then
		6342	$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
		6343	$echo " during execution"
		6344	fi
		6345	if test -n "$runpath_var"; then
		6346	$echo " - add LIBDIR to the \`$runpath_var' environment variable"
		6347	$echo " during linking"
		6348	fi
		6349	if test -n "$hardcode_libdir_flag_spec"; then
		6350	libdir=LIBDIR
		6351	eval flag=\"$hardcode_libdir_flag_spec\"
		6352
		6353	$echo " - use the \`$flag' linker flag"
		6354	fi
		6355	if test -n "$admincmds"; then
		6356	$echo " - have your system administrator run these commands:$admincmds"
		6357	fi
		6358	if test -f /etc/ld.so.conf; then
		6359	$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
		6360	fi
		6361	$echo
		6362	$echo "See any operating system documentation about shared libraries for"
		6363	$echo "more information, such as the ld(1) and ld.so(8) manual pages."
		6364	$echo "X----------------------------------------------------------------------" \| $Xsed
		6365	exit $EXIT_SUCCESS
		6366	;;
		6367
		6368	# libtool execute mode
		6369	execute)
		6370	modename="$modename: execute"
		6371
		6372	# The first argument is the command name.
		6373	cmd="$nonopt"
		6374	if test -z "$cmd"; then
		6375	$echo "$modename: you must specify a COMMAND" 1>&2
		6376	$echo "$help"
		6377	exit $EXIT_FAILURE
		6378	fi
		6379
		6380	# Handle -dlopen flags immediately.
		6381	for file in $execute_dlfiles; do
		6382	if test ! -f "$file"; then
		6383	$echo "$modename: \`$file' is not a file" 1>&2
		6384	$echo "$help" 1>&2
		6385	exit $EXIT_FAILURE
		6386	fi
		6387
		6388	dir=
		6389	case $file in
		6390	*.la)
		6391	# Check to see that this really is a libtool archive.
		6392	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
		6393	else
		6394	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
		6395	$echo "$help" 1>&2
		6396	exit $EXIT_FAILURE
		6397	fi
		6398
		6399	# Read the libtool library.
		6400	dlname=
		6401	library_names=
		6402
		6403	# If there is no directory component, then add one.
		6404	case $file in
		6405	/ \| \\) . $file ;;
		6406	*) . ./$file ;;
		6407	esac
		6408
		6409	# Skip this library if it cannot be dlopened.
		6410	if test -z "$dlname"; then
		6411	# Warn if it was a shared library.
		6412	test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
		6413	continue
		6414	fi
		6415
		6416	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
		6417	test "X$dir" = "X$file" && dir=.
		6418
		6419	if test -f "$dir/$objdir/$dlname"; then
		6420	dir="$dir/$objdir"
		6421	else
		6422	if test ! -f "$dir/$dlname"; then
		6423	$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
		6424	exit $EXIT_FAILURE
		6425	fi
		6426	fi
		6427	;;
		6428
		6429	*.lo)
		6430	# Just add the directory containing the .lo file.
		6431	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
		6432	test "X$dir" = "X$file" && dir=.
		6433	;;
		6434
		6435	*)
		6436	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
		6437	continue
		6438	;;
		6439	esac
		6440
		6441	# Get the absolute pathname.
		6442	absdir=`cd "$dir" && pwd`
		6443	test -n "$absdir" && dir="$absdir"
		6444
		6445	# Now add the directory to shlibpath_var.
		6446	if eval "test -z \"\$$shlibpath_var\""; then
		6447	eval "$shlibpath_var=\"\$dir\""
		6448	else
		6449	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
		6450	fi
		6451	done
		6452
		6453	# This variable tells wrapper scripts just to set shlibpath_var
		6454	# rather than running their programs.
		6455	libtool_execute_magic="$magic"
		6456
		6457	# Check if any of the arguments is a wrapper script.
		6458	args=
		6459	for file
		6460	do
		6461	case $file in
		6462	-*) ;;
		6463	*)
		6464	# Do a test to see if this is really a libtool program.
		6465	if (${SED} -e '4q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		6466	# If there is no directory component, then add one.
		6467	case $file in
		6468	/ \| \\) . $file ;;
		6469	*) . ./$file ;;
		6470	esac
		6471
		6472	# Transform arg to wrapped name.
		6473	file="$progdir/$program"
		6474	fi
		6475	;;
		6476	esac
		6477	# Quote arguments (to preserve shell metacharacters).
		6478	file=`$echo "X$file" \| $Xsed -e "$sed_quote_subst"`
		6479	args="$args \"$file\""
		6480	done
		6481
		6482	if test -z "$run"; then
		6483	if test -n "$shlibpath_var"; then
		6484	# Export the shlibpath_var.
		6485	eval "export $shlibpath_var"
		6486	fi
		6487
		6488	# Restore saved environment variables
		6489	for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
		6490	do
		6491	eval "if test \"\${save_$lt_var+set}\" = set; then
		6492	$lt_var=\$save_$lt_var; export $lt_var
		6493	fi"
		6494	done
		6495
		6496	# Now prepare to actually exec the command.
		6497	exec_cmd="\$cmd$args"
		6498	else
		6499	# Display what would be done.
		6500	if test -n "$shlibpath_var"; then
		6501	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
		6502	$echo "export $shlibpath_var"
		6503	fi
		6504	$echo "$cmd$args"
		6505	exit $EXIT_SUCCESS
		6506	fi
		6507	;;
		6508
		6509	# libtool clean and uninstall mode
		6510	clean \| uninstall)
		6511	modename="$modename: $mode"
		6512	rm="$nonopt"
		6513	files=
		6514	rmforce=
		6515	exit_status=0
		6516
		6517	# This variable tells wrapper scripts just to set variables rather
		6518	# than running their programs.
		6519	libtool_install_magic="$magic"
		6520
		6521	for arg
		6522	do
		6523	case $arg in
		6524	-f) rm="$rm $arg"; rmforce=yes ;;
		6525	-*) rm="$rm $arg" ;;
		6526	*) files="$files $arg" ;;
		6527	esac
		6528	done
		6529
		6530	if test -z "$rm"; then
		6531	$echo "$modename: you must specify an RM program" 1>&2
		6532	$echo "$help" 1>&2
		6533	exit $EXIT_FAILURE
		6534	fi
		6535
		6536	rmdirs=
		6537
		6538	origobjdir="$objdir"
		6539	for file in $files; do
		6540	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
		6541	if test "X$dir" = "X$file"; then
		6542	dir=.
		6543	objdir="$origobjdir"
		6544	else
		6545	objdir="$dir/$origobjdir"
		6546	fi
		6547	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
		6548	test "$mode" = uninstall && objdir="$dir"
		6549
		6550	# Remember objdir for removal later, being careful to avoid duplicates
		6551	if test "$mode" = clean; then
		6552	case " $rmdirs " in
		6553	" $objdir ") ;;
		6554	*) rmdirs="$rmdirs $objdir" ;;
		6555	esac
		6556	fi
		6557
		6558	# Don't error if the file doesn't exist and rm -f was used.
		6559	if (test -L "$file") >/dev/null 2>&1 \
		6560	\|\| (test -h "$file") >/dev/null 2>&1 \
		6561	\|\| test -f "$file"; then
		6562	:
		6563	elif test -d "$file"; then
		6564	exit_status=1
		6565	continue
		6566	elif test "$rmforce" = yes; then
		6567	continue
		6568	fi
		6569
		6570	rmfiles="$file"
		6571
		6572	case $name in
		6573	*.la)
		6574	# Possibly a libtool archive, so verify it.
		6575	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		6576	. $dir/$name
		6577
		6578	# Delete the libtool libraries and symlinks.
		6579	for n in $library_names; do
		6580	rmfiles="$rmfiles $objdir/$n"
		6581	done
		6582	test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
		6583
		6584	case "$mode" in
		6585	clean)
		6586	case " $library_names " in
		6587	# " " in the beginning catches empty $dlname
		6588	" $dlname ") ;;
		6589	*) rmfiles="$rmfiles $objdir/$dlname" ;;
		6590	esac
		6591	test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
		6592	;;
		6593	uninstall)
		6594	if test -n "$library_names"; then
		6595	# Do each command in the postuninstall commands.
		6596	cmds=$postuninstall_cmds
		6597	save_ifs="$IFS"; IFS='~'
		6598	for cmd in $cmds; do
		6599	IFS="$save_ifs"
		6600	eval cmd=\"$cmd\"
		6601	$show "$cmd"
		6602	$run eval "$cmd"
		6603	if test "$?" -ne 0 && test "$rmforce" != yes; then
		6604	exit_status=1
		6605	fi
		6606	done
		6607	IFS="$save_ifs"
		6608	fi
		6609
		6610	if test -n "$old_library"; then
		6611	# Do each command in the old_postuninstall commands.
		6612	cmds=$old_postuninstall_cmds
		6613	save_ifs="$IFS"; IFS='~'
		6614	for cmd in $cmds; do
		6615	IFS="$save_ifs"
		6616	eval cmd=\"$cmd\"
		6617	$show "$cmd"
		6618	$run eval "$cmd"
		6619	if test "$?" -ne 0 && test "$rmforce" != yes; then
		6620	exit_status=1
		6621	fi
		6622	done
		6623	IFS="$save_ifs"
		6624	fi
		6625	# FIXME: should reinstall the best remaining shared library.
		6626	;;
		6627	esac
		6628	fi
		6629	;;
		6630
		6631	*.lo)
		6632	# Possibly a libtool object, so verify it.
		6633	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		6634
		6635	# Read the .lo file
		6636	. $dir/$name
		6637
		6638	# Add PIC object to the list of files to remove.
		6639	if test -n "$pic_object" \
		6640	&& test "$pic_object" != none; then
		6641	rmfiles="$rmfiles $dir/$pic_object"
		6642	fi
		6643
		6644	# Add non-PIC object to the list of files to remove.
		6645	if test -n "$non_pic_object" \
		6646	&& test "$non_pic_object" != none; then
		6647	rmfiles="$rmfiles $dir/$non_pic_object"
		6648	fi
		6649	fi
		6650	;;
		6651
		6652	*)
		6653	if test "$mode" = clean ; then
		6654	noexename=$name
		6655	case $file in
		6656	*.exe)
		6657	file=`$echo $file\|${SED} 's,.exe$,,'`
		6658	noexename=`$echo $name\|${SED} 's,.exe$,,'`
		6659	# $file with .exe has already been added to rmfiles,
		6660	# add $file without .exe
		6661	rmfiles="$rmfiles $file"
		6662	;;
		6663	esac
		6664	# Do a test to see if this is a libtool program.
		6665	if (${SED} -e '4q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
		6666	relink_command=
		6667	. $dir/$noexename
		6668
		6669	# note $name still contains .exe if it was in $file originally
		6670	# as does the version of $file that was added into $rmfiles
		6671	rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
		6672	if test "$fast_install" = yes && test -n "$relink_command"; then
		6673	rmfiles="$rmfiles $objdir/lt-$name"
		6674	fi
		6675	if test "X$noexename" != "X$name" ; then
		6676	rmfiles="$rmfiles $objdir/lt-${noexename}.c"
		6677	fi
		6678	fi
		6679	fi
		6680	;;
		6681	esac
		6682	$show "$rm $rmfiles"
		6683	$run $rm $rmfiles \|\| exit_status=1
		6684	done
		6685	objdir="$origobjdir"
		6686
		6687	# Try to remove the ${objdir}s in the directories where we deleted files
		6688	for dir in $rmdirs; do
		6689	if test -d "$dir"; then
		6690	$show "rmdir $dir"
		6691	$run rmdir $dir >/dev/null 2>&1
		6692	fi
		6693	done
		6694
		6695	exit $exit_status
		6696	;;
		6697
		6698	"")
		6699	$echo "$modename: you must specify a MODE" 1>&2
		6700	$echo "$generic_help" 1>&2
		6701	exit $EXIT_FAILURE
		6702	;;
		6703	esac
		6704
		6705	if test -z "$exec_cmd"; then
		6706	$echo "$modename: invalid operation mode \`$mode'" 1>&2
		6707	$echo "$generic_help" 1>&2
		6708	exit $EXIT_FAILURE
		6709	fi
		6710	fi # test -z "$show_help"
		6711
		6712	if test -n "$exec_cmd"; then
		6713	eval exec $exec_cmd
		6714	exit $EXIT_FAILURE
		6715	fi
		6716
		6717	# We need to display help for each of the modes.
		6718	case $mode in
		6719	"") $echo \
		6720	"Usage: $modename [OPTION]... [MODE-ARG]...
		6721
		6722	Provide generalized library-building support services.
		6723
		6724	--config show all configuration variables
		6725	--debug enable verbose shell tracing
		6726	-n, --dry-run display commands without modifying any files
		6727	--features display basic configuration information and exit
		6728	--finish same as \`--mode=finish'
		6729	--help display this help message and exit
		6730	--mode=MODE use operation mode MODE [default=inferred from MODE-ARGS]
		6731	--quiet same as \`--silent'
		6732	--silent don't print informational messages
		6733	--tag=TAG use configuration variables from tag TAG
		6734	--version print version information
		6735
		6736	MODE must be one of the following:
		6737
		6738	clean remove files from the build directory
		6739	compile compile a source file into a libtool object
		6740	execute automatically set library path, then run a program
		6741	finish complete the installation of libtool libraries
		6742	install install libraries or executables
		6743	link create a library or an executable
		6744	uninstall remove libraries from an installed directory
		6745
		6746	MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for
		6747	a more detailed description of MODE.
		6748
		6749	Report bugs to <bug-libtool@gnu.org>."
		6750	exit $EXIT_SUCCESS
		6751	;;
		6752
		6753	clean)
		6754	$echo \
		6755	"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
		6756
		6757	Remove files from the build directory.
		6758
		6759	RM is the name of the program to use to delete files associated with each FILE
		6760	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
		6761	to RM.
		6762
		6763	If FILE is a libtool library, object or program, all the files associated
		6764	with it are deleted. Otherwise, only FILE itself is deleted using RM."
		6765	;;
		6766
		6767	compile)
		6768	$echo \
		6769	"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
		6770
		6771	Compile a source file into a libtool library object.
		6772
		6773	This mode accepts the following additional options:
		6774
		6775	-o OUTPUT-FILE set the output file name to OUTPUT-FILE
		6776	-prefer-pic try to building PIC objects only
		6777	-prefer-non-pic try to building non-PIC objects only
		6778	-static always build a \`.o' file suitable for static linking
		6779
		6780	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
		6781	from the given SOURCEFILE.
		6782
		6783	The output file name is determined by removing the directory component from
		6784	SOURCEFILE, then substituting the C source code suffix \`.c' with the
		6785	library object suffix, \`.lo'."
		6786	;;
		6787
		6788	execute)
		6789	$echo \
		6790	"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
		6791
		6792	Automatically set library path, then run a program.
		6793
		6794	This mode accepts the following additional options:
		6795
		6796	-dlopen FILE add the directory containing FILE to the library path
		6797
		6798	This mode sets the library path environment variable according to \`-dlopen'
		6799	flags.
		6800
		6801	If any of the ARGS are libtool executable wrappers, then they are translated
		6802	into their corresponding uninstalled binary, and any of their required library
		6803	directories are added to the library path.
		6804
		6805	Then, COMMAND is executed, with ARGS as arguments."
		6806	;;
		6807
		6808	finish)
		6809	$echo \
		6810	"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
		6811
		6812	Complete the installation of libtool libraries.
		6813
		6814	Each LIBDIR is a directory that contains libtool libraries.
		6815
		6816	The commands that this mode executes may require superuser privileges. Use
		6817	the \`--dry-run' option if you just want to see what would be executed."
		6818	;;
		6819
		6820	install)
		6821	$echo \
		6822	"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
		6823
		6824	Install executables or libraries.
		6825
		6826	INSTALL-COMMAND is the installation command. The first component should be
		6827	either the \`install' or \`cp' program.
		6828
		6829	The rest of the components are interpreted as arguments to that command (only
		6830	BSD-compatible install options are recognized)."
		6831	;;
		6832
		6833	link)
		6834	$echo \
		6835	"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
		6836
		6837	Link object files or libraries together to form another library, or to
		6838	create an executable program.
		6839
		6840	LINK-COMMAND is a command using the C compiler that you would use to create
		6841	a program from several object files.
		6842
		6843	The following components of LINK-COMMAND are treated specially:
		6844
		6845	-all-static do not do any dynamic linking at all
		6846	-avoid-version do not add a version suffix if possible
		6847	-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
		6848	-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
		6849	-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
		6850	-export-symbols SYMFILE
		6851	try to export only the symbols listed in SYMFILE
		6852	-export-symbols-regex REGEX
		6853	try to export only the symbols matching REGEX
		6854	-LLIBDIR search LIBDIR for required installed libraries
		6855	-lNAME OUTPUT-FILE requires the installed library libNAME
		6856	-module build a library that can dlopened
		6857	-no-fast-install disable the fast-install mode
		6858	-no-install link a not-installable executable
		6859	-no-undefined declare that a library does not refer to external symbols
		6860	-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
		6861	-objectlist FILE Use a list of object files found in FILE to specify objects
		6862	-precious-files-regex REGEX
		6863	don't remove output files matching REGEX
		6864	-release RELEASE specify package release information
		6865	-rpath LIBDIR the created library will eventually be installed in LIBDIR
		6866	-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
		6867	-static do not do any dynamic linking of uninstalled libtool libraries
		6868	-static-libtool-libs
		6869	do not do any dynamic linking of libtool libraries
		6870	-version-info CURRENT[:REVISION[:AGE]]
		6871	specify library version info [each variable defaults to 0]
		6872
		6873	All other options (arguments beginning with \`-') are ignored.
		6874
		6875	Every other argument is treated as a filename. Files ending in \`.la' are
		6876	treated as uninstalled libtool libraries, other files are standard or library
		6877	object files.
		6878
		6879	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
		6880	only library objects (\`.lo' files) may be specified, and \`-rpath' is
		6881	required, except when creating a convenience library.
		6882
		6883	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
		6884	using \`ar' and \`ranlib', or on Windows using \`lib'.
		6885
		6886	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
		6887	is created, otherwise an executable program is created."
		6888	;;
		6889
		6890	uninstall)
		6891	$echo \
		6892	"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
		6893
		6894	Remove libraries from an installation directory.
		6895
		6896	RM is the name of the program to use to delete files associated with each FILE
		6897	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
		6898	to RM.
		6899
		6900	If FILE is a libtool library, all the files associated with it are deleted.
		6901	Otherwise, only FILE itself is deleted using RM."
		6902	;;
		6903
		6904	*)
		6905	$echo "$modename: invalid operation mode \`$mode'" 1>&2
		6906	$echo "$help" 1>&2
		6907	exit $EXIT_FAILURE
		6908	;;
		6909	esac
		6910
		6911	$echo
		6912	$echo "Try \`$modename --help' for more information about other modes."
		6913
		6914	exit $?
		6915
		6916	# The TAGs below are defined such that we never get into a situation
		6917	# in which we disable both kinds of libraries. Given conflicting
		6918	# choices, we go for a static library, that is the most portable,
		6919	# since we can't tell whether shared libraries were disabled because
		6920	# the user asked for that or because the platform doesn't support
		6921	# them. This is particularly important on AIX, because we don't
		6922	# support having both static and shared libraries enabled at the same
		6923	# time on that platform, so we default to a shared-only configuration.
		6924	# If a disable-shared tag is given, we'll fallback to a static-only
		6925	# configuration. But we'll never go from static-only to shared-only.
		6926
		6927	# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
		6928	disable_libs=shared
		6929	# ### END LIBTOOL TAG CONFIG: disable-shared
		6930
		6931	# ### BEGIN LIBTOOL TAG CONFIG: disable-static
		6932	disable_libs=static
		6933	# ### END LIBTOOL TAG CONFIG: disable-static
		6934
		6935	# Local Variables:
		6936	# mode:shell-script
		6937	# sh-indentation:2
		6938	# End:

Subversion Repositories

(root)/trunk/ltmain.sh @ 5 - Rev 3