Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/ogre/ltmain.sh @ 44

Last change on this file since 44 was 11, checked in by landauf, 17 years ago

File size: 194.3 KB

Rev	Line
[5]	1	# ltmain.sh - Provide generalized library-building support services.
	2	# NOTE: Changing this file will not affect anything until you rerun configure.
	3	#
[6]	4	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
	5	# 2007 Free Software Foundation, Inc.
[5]	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
[6]	46	VERSION=1.5.24
	47	TIMESTAMP=" (1.1220.2.455 2007/06/24 02:13:29)"
[5]	48
[6]	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+"$@"}'='"$@"'
[5]	56	setopt NO_GLOB_SUBST
[6]	57	else
	58	case `(set -o) 2>/dev/null` in posix) set -o posix;; esac
[5]	59	fi
[6]	60	BIN_SH=xpg4; export BIN_SH # for Tru64
	61	DUALCASE=1; export DUALCASE # for MKS sh
[5]	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.
[6]	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
[5]	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=
[6]	145	duplicate_deps=no
	146	preserve_args=
[5]	147	lo2o="s/\\.lo\$/.${objext}/"
	148	o2lo="s/\\.${objext}\$/.lo/"
[6]	149	extracted_archives=
	150	extracted_serial=0
[5]	151
	152	#####################################
	153	# Shell function definitions:
	154	# This seems to be the best place for them
	155
[6]	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
[5]	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 \| \
[6]	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
[5]	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%^.*/%%'`
[6]	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"
[5]	359
	360	$show "${rm}r $my_xdir"
	361	$run ${rm}r "$my_xdir"
	362	$show "$mkdir $my_xdir"
	363	$run $mkdir "$my_xdir"
[6]	364	exit_status=$?
	365	if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
	366	exit $exit_status
[5]	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
[6]	421	disable_libs=no
	422
[5]	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)
[6]	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."
[5]	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
[6]	540	--tag)
	541	prevopt="--tag"
	542	prev=tag
	543	preserve_args="$preserve_args --tag"
	544	;;
[5]	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
[6]	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
[5]	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 ;;
[6]	787	*.[fF][09]?) xform=[fF][09]. ;;
[5]	788	*.for) xform=for ;;
	789	*.java) xform=java ;;
[6]	790	*.obj) xform=obj ;;
[5]	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
[6]	945	exit_status=$?
	946	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
	947	exit $exit_status
[5]	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=
[6]	1150	notinst_path= # paths that contain not-installed libtool libraries
[5]	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
[6]	1171	-all-static \| -static \| -static-libtool-libs)
	1172	case $arg in
	1173	-all-static)
[5]	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
[6]	1180	prefer_static_libs=yes
	1181	;;
	1182	-static)
[5]	1183	if test -z "$pic_flag" && test -n "$link_static_flag"; then
	1184	dlopen_self=$dlopen_self_static
	1185	fi
[6]	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
[5]	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
[6]	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"
[5]	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	;;
[6]	1459	darwin_framework\|darwin_framework_skip)
	1460	test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
[5]	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
[6]	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
[5]	1531	compile_command="$compile_command $arg"
	1532	finalize_command="$finalize_command $arg"
[6]	1533	continue
	1534	;;
[5]	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
[6]	1562	absdir="$dir"
	1563	notinst_path="$notinst_path $dir"
[5]	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*)
[6]	1577	testbindir=`$echo "X$dir" \| $Xsed -e 's/lib$/bin*'`
[5]	1578	case :$dllsearchpath: in
	1579	":$dir:") ;;
	1580	*) dllsearchpath="$dllsearchpath:$dir";;
	1581	esac
[6]	1582	case :$dllsearchpath: in
	1583	":$testbindir:") ;;
	1584	*) dllsearchpath="$dllsearchpath:$testbindir";;
	1585	esac
[5]	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
[6]	1594	--cygwin* \| --mingw* \| --pw32* \| --beos*)
[5]	1595	# These systems don't actually have a C or math library (as such)
	1596	continue
	1597	;;
[6]	1598	--os2*)
[5]	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
[6]	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	;;
[5]	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
[6]	1642	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
[5]	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
[6]	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\|@*)
[5]	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"
[6]	1678	compiler_flags="$compiler_flags $arg"
[5]	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
[6]	1694	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --darwin*)
[5]	1695	# The PATH hackery in wrapper scripts is required on Windows
[6]	1696	# and Darwin in order for the loader to find any dlls it needs.
[5]	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
[6]	1755	-static \| -static-libtool-libs)
[5]	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
[6]	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"
[5]	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
[6]	2026	exit_status=$?
	2027	if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
	2028	exit $exit_status
[5]	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) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
	2126	esac
	2127	fi
	2128	if test "$pass" = dlopen; then
	2129	# Collect dlpreopened libraries
	2130	save_deplibs="$deplibs"
	2131	deplibs=
	2132	fi
	2133	for deplib in $libs; do
	2134	lib=
	2135	found=no
	2136	case $deplib in
[6]	2137	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
[5]	2138	if test "$linkmode,$pass" = "prog,link"; then
	2139	compile_deplibs="$deplib $compile_deplibs"
	2140	finalize_deplibs="$deplib $finalize_deplibs"
	2141	else
	2142	compiler_flags="$compiler_flags $deplib"
	2143	fi
	2144	continue
	2145	;;
	2146	-l*)
	2147	if test "$linkmode" != lib && test "$linkmode" != prog; then
	2148	$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
	2149	continue
	2150	fi
	2151	name=`$echo "X$deplib" \| $Xsed -e 's/^-l//'`
	2152	for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
	2153	for search_ext in .la $std_shrext .so .a; do
	2154	# Search the libtool library
	2155	lib="$searchdir/lib${name}${search_ext}"
	2156	if test -f "$lib"; then
	2157	if test "$search_ext" = ".la"; then
	2158	found=yes
	2159	else
	2160	found=no
	2161	fi
	2162	break 2
	2163	fi
	2164	done
	2165	done
	2166	if test "$found" != yes; then
	2167	# deplib doesn't seem to be a libtool library
	2168	if test "$linkmode,$pass" = "prog,link"; then
	2169	compile_deplibs="$deplib $compile_deplibs"
	2170	finalize_deplibs="$deplib $finalize_deplibs"
	2171	else
	2172	deplibs="$deplib $deplibs"
	2173	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
	2174	fi
	2175	continue
	2176	else # deplib is a libtool library
	2177	# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
	2178	# We need to do some special things here, and not later.
	2179	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	2180	case " $predeps $postdeps " in
	2181	" $deplib ")
	2182	if (${SED} -e '2q' $lib \|
	2183	grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	2184	library_names=
	2185	old_library=
	2186	case $lib in
	2187	/ \| \\) . $lib ;;
	2188	*) . ./$lib ;;
	2189	esac
	2190	for l in $old_library $library_names; do
	2191	ll="$l"
	2192	done
	2193	if test "X$ll" = "X$old_library" ; then # only static version available
	2194	found=no
	2195	ladir=`$echo "X$lib" \| $Xsed -e 's%/[^/]*$%%'`
	2196	test "X$ladir" = "X$lib" && ladir="."
	2197	lib=$ladir/$old_library
	2198	if test "$linkmode,$pass" = "prog,link"; then
	2199	compile_deplibs="$deplib $compile_deplibs"
	2200	finalize_deplibs="$deplib $finalize_deplibs"
	2201	else
	2202	deplibs="$deplib $deplibs"
	2203	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
	2204	fi
	2205	continue
	2206	fi
	2207	fi
	2208	;;
	2209	*) ;;
	2210	esac
	2211	fi
	2212	fi
	2213	;; # -l
	2214	-L*)
	2215	case $linkmode in
	2216	lib)
	2217	deplibs="$deplib $deplibs"
	2218	test "$pass" = conv && continue
	2219	newdependency_libs="$deplib $newdependency_libs"
	2220	newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`
	2221	;;
	2222	prog)
	2223	if test "$pass" = conv; then
	2224	deplibs="$deplib $deplibs"
	2225	continue
	2226	fi
	2227	if test "$pass" = scan; then
	2228	deplibs="$deplib $deplibs"
	2229	else
	2230	compile_deplibs="$deplib $compile_deplibs"
	2231	finalize_deplibs="$deplib $finalize_deplibs"
	2232	fi
	2233	newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`
	2234	;;
	2235	*)
	2236	$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
	2237	;;
	2238	esac # linkmode
	2239	continue
	2240	;; # -L
	2241	-R*)
	2242	if test "$pass" = link; then
	2243	dir=`$echo "X$deplib" \| $Xsed -e 's/^-R//'`
	2244	# Make sure the xrpath contains only unique directories.
	2245	case "$xrpath " in
	2246	" $dir ") ;;
	2247	*) xrpath="$xrpath $dir" ;;
	2248	esac
	2249	fi
	2250	deplibs="$deplib $deplibs"
	2251	continue
	2252	;;
	2253	*.la) lib="$deplib" ;;
	2254	*.$libext)
	2255	if test "$pass" = conv; then
	2256	deplibs="$deplib $deplibs"
	2257	continue
	2258	fi
	2259	case $linkmode in
	2260	lib)
	2261	valid_a_lib=no
	2262	case $deplibs_check_method in
	2263	match_pattern*)
	2264	set dummy $deplibs_check_method
	2265	match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
	2266	if eval $echo \"$deplib\" 2>/dev/null \
	2267	\| $SED 10q \
	2268	\| $EGREP "$match_pattern_regex" > /dev/null; then
	2269	valid_a_lib=yes
	2270	fi
	2271	;;
	2272	pass_all)
	2273	valid_a_lib=yes
	2274	;;
	2275	esac
	2276	if test "$valid_a_lib" != yes; then
	2277	$echo
	2278	$echo "*** Warning: Trying to link with static lib archive $deplib."
	2279	$echo "*** I have the capability to make that library automatically link in when"
	2280	$echo "*** you link to this library. But I can only do this if you have a"
	2281	$echo "*** shared version of the library, which you do not appear to have"
	2282	$echo "*** because the file extensions .$libext of this argument makes me believe"
	2283	$echo "*** that it is just a static archive that I should not used here."
	2284	else
	2285	$echo
	2286	$echo "*** Warning: Linking the shared library $output against the"
	2287	$echo "*** static library $deplib is not portable!"
	2288	deplibs="$deplib $deplibs"
	2289	fi
	2290	continue
	2291	;;
	2292	prog)
	2293	if test "$pass" != link; then
	2294	deplibs="$deplib $deplibs"
	2295	else
	2296	compile_deplibs="$deplib $compile_deplibs"
	2297	finalize_deplibs="$deplib $finalize_deplibs"
	2298	fi
	2299	continue
	2300	;;
	2301	esac # linkmode
	2302	;; # *.$libext
	2303	.lo \| .$objext)
	2304	if test "$pass" = conv; then
	2305	deplibs="$deplib $deplibs"
	2306	elif test "$linkmode" = prog; then
	2307	if test "$pass" = dlpreopen \|\| test "$dlopen_support" != yes \|\| test "$build_libtool_libs" = no; then
	2308	# If there is no dlopen support or we're linking statically,
	2309	# we need to preload.
	2310	newdlprefiles="$newdlprefiles $deplib"
	2311	compile_deplibs="$deplib $compile_deplibs"
	2312	finalize_deplibs="$deplib $finalize_deplibs"
	2313	else
	2314	newdlfiles="$newdlfiles $deplib"
	2315	fi
	2316	fi
	2317	continue
	2318	;;
	2319	%DEPLIBS%)
	2320	alldeplibs=yes
	2321	continue
	2322	;;
	2323	esac # case $deplib
	2324	if test "$found" = yes \|\| test -f "$lib"; then :
	2325	else
[6]	2326	$echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
[5]	2327	exit $EXIT_FAILURE
	2328	fi
	2329
	2330	# Check to see that this really is a libtool archive.
	2331	if (${SED} -e '2q' $lib \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
	2332	else
	2333	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
	2334	exit $EXIT_FAILURE
	2335	fi
	2336
	2337	ladir=`$echo "X$lib" \| $Xsed -e 's%/[^/]*$%%'`
	2338	test "X$ladir" = "X$lib" && ladir="."
	2339
	2340	dlname=
	2341	dlopen=
	2342	dlpreopen=
	2343	libdir=
	2344	library_names=
	2345	old_library=
	2346	# If the library was installed with an old release of libtool,
	2347	# it will not redefine variables installed, or shouldnotlink
	2348	installed=yes
	2349	shouldnotlink=no
	2350	avoidtemprpath=
	2351
	2352
	2353	# Read the .la file
	2354	case $lib in
	2355	/ \| \\) . $lib ;;
	2356	*) . ./$lib ;;
	2357	esac
	2358
	2359	if test "$linkmode,$pass" = "lib,link" \|\|
	2360	test "$linkmode,$pass" = "prog,scan" \|\|
	2361	{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
	2362	test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
	2363	test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
	2364	fi
	2365
	2366	if test "$pass" = conv; then
	2367	# Only check for convenience libraries
	2368	deplibs="$lib $deplibs"
	2369	if test -z "$libdir"; then
	2370	if test -z "$old_library"; then
	2371	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
	2372	exit $EXIT_FAILURE
	2373	fi
	2374	# It is a libtool convenience library, so add in its objects.
	2375	convenience="$convenience $ladir/$objdir/$old_library"
	2376	old_convenience="$old_convenience $ladir/$objdir/$old_library"
	2377	tmp_libs=
	2378	for deplib in $dependency_libs; do
	2379	deplibs="$deplib $deplibs"
	2380	if test "X$duplicate_deps" = "Xyes" ; then
	2381	case "$tmp_libs " in
	2382	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
	2383	esac
	2384	fi
	2385	tmp_libs="$tmp_libs $deplib"
	2386	done
	2387	elif test "$linkmode" != prog && test "$linkmode" != lib; then
	2388	$echo "$modename: \`$lib' is not a convenience library" 1>&2
	2389	exit $EXIT_FAILURE
	2390	fi
	2391	continue
	2392	fi # $pass = conv
	2393
	2394
	2395	# Get the name of the library we link against.
	2396	linklib=
	2397	for l in $old_library $library_names; do
	2398	linklib="$l"
	2399	done
	2400	if test -z "$linklib"; then
	2401	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
	2402	exit $EXIT_FAILURE
	2403	fi
	2404
	2405	# This library was specified with -dlopen.
	2406	if test "$pass" = dlopen; then
	2407	if test -z "$libdir"; then
	2408	$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
	2409	exit $EXIT_FAILURE
	2410	fi
	2411	if test -z "$dlname" \|\|
	2412	test "$dlopen_support" != yes \|\|
	2413	test "$build_libtool_libs" = no; then
	2414	# If there is no dlname, no dlopen support or we're linking
	2415	# statically, we need to preload. We also need to preload any
	2416	# dependent libraries so libltdl's deplib preloader doesn't
	2417	# bomb out in the load deplibs phase.
	2418	dlprefiles="$dlprefiles $lib $dependency_libs"
	2419	else
	2420	newdlfiles="$newdlfiles $lib"
	2421	fi
	2422	continue
	2423	fi # $pass = dlopen
	2424
	2425	# We need an absolute path.
	2426	case $ladir in
	2427	[\\/]* \| [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
	2428	*)
	2429	abs_ladir=`cd "$ladir" && pwd`
	2430	if test -z "$abs_ladir"; then
	2431	$echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
	2432	$echo "$modename: passing it literally to the linker, although it might fail" 1>&2
	2433	abs_ladir="$ladir"
	2434	fi
	2435	;;
	2436	esac
	2437	laname=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
	2438
	2439	# Find the relevant object directory and library name.
	2440	if test "X$installed" = Xyes; then
	2441	if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	2442	$echo "$modename: warning: library \`$lib' was moved." 1>&2
	2443	dir="$ladir"
	2444	absdir="$abs_ladir"
	2445	libdir="$abs_ladir"
	2446	else
	2447	dir="$libdir"
	2448	absdir="$libdir"
	2449	fi
	2450	test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
	2451	else
	2452	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	2453	dir="$ladir"
	2454	absdir="$abs_ladir"
	2455	# Remove this search path later
	2456	notinst_path="$notinst_path $abs_ladir"
	2457	else
	2458	dir="$ladir/$objdir"
	2459	absdir="$abs_ladir/$objdir"
	2460	# Remove this search path later
	2461	notinst_path="$notinst_path $abs_ladir"
	2462	fi
	2463	fi # $installed = yes
	2464	name=`$echo "X$laname" \| $Xsed -e 's/\.la$//' -e 's/^lib//'`
	2465
	2466	# This library was specified with -dlpreopen.
	2467	if test "$pass" = dlpreopen; then
	2468	if test -z "$libdir"; then
	2469	$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
	2470	exit $EXIT_FAILURE
	2471	fi
	2472	# Prefer using a static library (so that no silly _DYNAMIC symbols
	2473	# are required to link).
	2474	if test -n "$old_library"; then
	2475	newdlprefiles="$newdlprefiles $dir/$old_library"
	2476	# Otherwise, use the dlname, so that lt_dlopen finds it.
	2477	elif test -n "$dlname"; then
	2478	newdlprefiles="$newdlprefiles $dir/$dlname"
	2479	else
	2480	newdlprefiles="$newdlprefiles $dir/$linklib"
	2481	fi
	2482	fi # $pass = dlpreopen
	2483
	2484	if test -z "$libdir"; then
	2485	# Link the convenience library
	2486	if test "$linkmode" = lib; then
	2487	deplibs="$dir/$old_library $deplibs"
	2488	elif test "$linkmode,$pass" = "prog,link"; then
	2489	compile_deplibs="$dir/$old_library $compile_deplibs"
	2490	finalize_deplibs="$dir/$old_library $finalize_deplibs"
	2491	else
	2492	deplibs="$lib $deplibs" # used for prog,scan pass
	2493	fi
	2494	continue
	2495	fi
	2496
	2497
	2498	if test "$linkmode" = prog && test "$pass" != link; then
	2499	newlib_search_path="$newlib_search_path $ladir"
	2500	deplibs="$lib $deplibs"
	2501
	2502	linkalldeplibs=no
	2503	if test "$link_all_deplibs" != no \|\| test -z "$library_names" \|\|
	2504	test "$build_libtool_libs" = no; then
	2505	linkalldeplibs=yes
	2506	fi
	2507
	2508	tmp_libs=
	2509	for deplib in $dependency_libs; do
	2510	case $deplib in
	2511	-L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" \| $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
	2512	esac
	2513	# Need to link against all dependency_libs?
	2514	if test "$linkalldeplibs" = yes; then
	2515	deplibs="$deplib $deplibs"
	2516	else
	2517	# Need to hardcode shared library paths
	2518	# or/and link against static libraries
	2519	newdependency_libs="$deplib $newdependency_libs"
	2520	fi
	2521	if test "X$duplicate_deps" = "Xyes" ; then
	2522	case "$tmp_libs " in
	2523	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
	2524	esac
	2525	fi
	2526	tmp_libs="$tmp_libs $deplib"
	2527	done # for deplib
	2528	continue
	2529	fi # $linkmode = prog...
	2530
	2531	if test "$linkmode,$pass" = "prog,link"; then
	2532	if test -n "$library_names" &&
[6]	2533	{ { test "$prefer_static_libs" = no \|\|
	2534	test "$prefer_static_libs,$installed" = "built,yes"; } \|\|
	2535	test -z "$old_library"; }; then
[5]	2536	# We need to hardcode the library path
	2537	if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
	2538	# Make sure the rpath contains only unique directories.
	2539	case "$temp_rpath " in
	2540	" $dir ") ;;
	2541	" $absdir ") ;;
	2542	*) temp_rpath="$temp_rpath $absdir" ;;
	2543	esac
	2544	fi
	2545
	2546	# Hardcode the library path.
	2547	# Skip directories that are in the system default run-time
	2548	# search path.
	2549	case " $sys_lib_dlsearch_path " in
	2550	" $absdir ") ;;
	2551	*)
	2552	case "$compile_rpath " in
	2553	" $absdir ") ;;
	2554	*) compile_rpath="$compile_rpath $absdir"
	2555	esac
	2556	;;
	2557	esac
	2558	case " $sys_lib_dlsearch_path " in
	2559	" $libdir ") ;;
	2560	*)
	2561	case "$finalize_rpath " in
	2562	" $libdir ") ;;
	2563	*) finalize_rpath="$finalize_rpath $libdir"
	2564	esac
	2565	;;
	2566	esac
	2567	fi # $linkmode,$pass = prog,link...
	2568
	2569	if test "$alldeplibs" = yes &&
	2570	{ test "$deplibs_check_method" = pass_all \|\|
	2571	{ test "$build_libtool_libs" = yes &&
	2572	test -n "$library_names"; }; }; then
	2573	# We only need to search for static libraries
	2574	continue
	2575	fi
	2576	fi
	2577
	2578	link_static=no # Whether the deplib will be linked statically
[6]	2579	use_static_libs=$prefer_static_libs
	2580	if test "$use_static_libs" = built && test "$installed" = yes ; then
	2581	use_static_libs=no
	2582	fi
[5]	2583	if test -n "$library_names" &&
[6]	2584	{ test "$use_static_libs" = no \|\| test -z "$old_library"; }; then
[5]	2585	if test "$installed" = no; then
	2586	notinst_deplibs="$notinst_deplibs $lib"
	2587	need_relink=yes
	2588	fi
	2589	# This is a shared library
	2590
	2591	# Warn about portability, can't link against -module's on
	2592	# some systems (darwin)
	2593	if test "$shouldnotlink" = yes && test "$pass" = link ; then
	2594	$echo
	2595	if test "$linkmode" = prog; then
	2596	$echo "*** Warning: Linking the executable $output against the loadable module"
	2597	else
	2598	$echo "*** Warning: Linking the shared library $output against the loadable module"
	2599	fi
	2600	$echo "*** $linklib is not portable!"
	2601	fi
	2602	if test "$linkmode" = lib &&
	2603	test "$hardcode_into_libs" = yes; then
	2604	# Hardcode the library path.
	2605	# Skip directories that are in the system default run-time
	2606	# search path.
	2607	case " $sys_lib_dlsearch_path " in
	2608	" $absdir ") ;;
	2609	*)
	2610	case "$compile_rpath " in
	2611	" $absdir ") ;;
	2612	*) compile_rpath="$compile_rpath $absdir"
	2613	esac
	2614	;;
	2615	esac
	2616	case " $sys_lib_dlsearch_path " in
	2617	" $libdir ") ;;
	2618	*)
	2619	case "$finalize_rpath " in
	2620	" $libdir ") ;;
	2621	*) finalize_rpath="$finalize_rpath $libdir"
	2622	esac
	2623	;;
	2624	esac
	2625	fi
	2626
	2627	if test -n "$old_archive_from_expsyms_cmds"; then
	2628	# figure out the soname
	2629	set dummy $library_names
	2630	realname="$2"
	2631	shift; shift
	2632	libname=`eval \\$echo \"$libname_spec\"`
	2633	# use dlname if we got it. it's perfectly good, no?
	2634	if test -n "$dlname"; then
	2635	soname="$dlname"
	2636	elif test -n "$soname_spec"; then
	2637	# bleh windows
	2638	case $host in
	2639	cygwin \| mingw*)
	2640	major=`expr $current - $age`
	2641	versuffix="-$major"
	2642	;;
	2643	esac
	2644	eval soname=\"$soname_spec\"
	2645	else
	2646	soname="$realname"
	2647	fi
	2648
	2649	# Make a new name for the extract_expsyms_cmds to use
	2650	soroot="$soname"
	2651	soname=`$echo $soroot \| ${SED} -e 's/^.*\///'`
	2652	newlib="libimp-`$echo $soname \| ${SED} 's/^lib//;s/\.dll$//'`.a"
	2653
	2654	# If the library has no export list, then create one now
	2655	if test -f "$output_objdir/$soname-def"; then :
	2656	else
	2657	$show "extracting exported symbol list from \`$soname'"
	2658	save_ifs="$IFS"; IFS='~'
	2659	cmds=$extract_expsyms_cmds
	2660	for cmd in $cmds; do
	2661	IFS="$save_ifs"
	2662	eval cmd=\"$cmd\"
	2663	$show "$cmd"
	2664	$run eval "$cmd" \|\| exit $?
	2665	done
	2666	IFS="$save_ifs"
	2667	fi
	2668
	2669	# Create $newlib
	2670	if test -f "$output_objdir/$newlib"; then :; else
	2671	$show "generating import library for \`$soname'"
	2672	save_ifs="$IFS"; IFS='~'
	2673	cmds=$old_archive_from_expsyms_cmds
	2674	for cmd in $cmds; do
	2675	IFS="$save_ifs"
	2676	eval cmd=\"$cmd\"
	2677	$show "$cmd"
	2678	$run eval "$cmd" \|\| exit $?
	2679	done
	2680	IFS="$save_ifs"
	2681	fi
	2682	# make sure the library variables are pointing to the new library
	2683	dir=$output_objdir
	2684	linklib=$newlib
	2685	fi # test -n "$old_archive_from_expsyms_cmds"
	2686
	2687	if test "$linkmode" = prog \|\| test "$mode" != relink; then
	2688	add_shlibpath=
	2689	add_dir=
	2690	add=
	2691	lib_linked=yes
	2692	case $hardcode_action in
	2693	immediate \| unsupported)
	2694	if test "$hardcode_direct" = no; then
	2695	add="$dir/$linklib"
	2696	case $host in
[6]	2697	--sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
	2698	--sysv4uw2) add_dir="-L$dir" ;;
	2699	--sysv5OpenUNIX* \| --sysv5UnixWare7.[01].[10]* \| \
	2700	--unixware7*) add_dir="-L$dir" ;;
[5]	2701	--darwin* )
	2702	# if the lib is a module then we can not link against
	2703	# it, someone is ignoring the new warnings I added
[6]	2704	if /usr/bin/file -L $add 2> /dev/null \|
	2705	$EGREP ": [^:]* bundle" >/dev/null ; then
[5]	2706	$echo "** Warning, lib $linklib is a module, not a shared library"
	2707	if test -z "$old_library" ; then
	2708	$echo
	2709	$echo "** And there doesn't seem to be a static archive available"
	2710	$echo "** The link will probably fail, sorry"
	2711	else
	2712	add="$dir/$old_library"
	2713	fi
	2714	fi
	2715	esac
	2716	elif test "$hardcode_minus_L" = no; then
	2717	case $host in
	2718	--sunos*) add_shlibpath="$dir" ;;
	2719	esac
	2720	add_dir="-L$dir"
	2721	add="-l$name"
	2722	elif test "$hardcode_shlibpath_var" = no; then
	2723	add_shlibpath="$dir"
	2724	add="-l$name"
	2725	else
	2726	lib_linked=no
	2727	fi
	2728	;;
	2729	relink)
	2730	if test "$hardcode_direct" = yes; then
	2731	add="$dir/$linklib"
	2732	elif test "$hardcode_minus_L" = yes; then
	2733	add_dir="-L$dir"
	2734	# Try looking first in the location we're being installed to.
	2735	if test -n "$inst_prefix_dir"; then
	2736	case $libdir in
	2737	[\\/]*)
	2738	add_dir="$add_dir -L$inst_prefix_dir$libdir"
	2739	;;
	2740	esac
	2741	fi
	2742	add="-l$name"
	2743	elif test "$hardcode_shlibpath_var" = yes; then
	2744	add_shlibpath="$dir"
	2745	add="-l$name"
	2746	else
	2747	lib_linked=no
	2748	fi
	2749	;;
	2750	*) lib_linked=no ;;
	2751	esac
	2752
	2753	if test "$lib_linked" != yes; then
	2754	$echo "$modename: configuration error: unsupported hardcode properties"
	2755	exit $EXIT_FAILURE
	2756	fi
	2757
	2758	if test -n "$add_shlibpath"; then
	2759	case :$compile_shlibpath: in
	2760	":$add_shlibpath:") ;;
	2761	*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
	2762	esac
	2763	fi
	2764	if test "$linkmode" = prog; then
	2765	test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
	2766	test -n "$add" && compile_deplibs="$add $compile_deplibs"
	2767	else
	2768	test -n "$add_dir" && deplibs="$add_dir $deplibs"
	2769	test -n "$add" && deplibs="$add $deplibs"
	2770	if test "$hardcode_direct" != yes && \
	2771	test "$hardcode_minus_L" != yes && \
	2772	test "$hardcode_shlibpath_var" = yes; then
	2773	case :$finalize_shlibpath: in
	2774	":$libdir:") ;;
	2775	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
	2776	esac
	2777	fi
	2778	fi
	2779	fi
	2780
	2781	if test "$linkmode" = prog \|\| test "$mode" = relink; then
	2782	add_shlibpath=
	2783	add_dir=
	2784	add=
	2785	# Finalize command for both is simple: just hardcode it.
	2786	if test "$hardcode_direct" = yes; then
	2787	add="$libdir/$linklib"
	2788	elif test "$hardcode_minus_L" = yes; then
	2789	add_dir="-L$libdir"
	2790	add="-l$name"
	2791	elif test "$hardcode_shlibpath_var" = yes; then
	2792	case :$finalize_shlibpath: in
	2793	":$libdir:") ;;
	2794	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
	2795	esac
	2796	add="-l$name"
	2797	elif test "$hardcode_automatic" = yes; then
	2798	if test -n "$inst_prefix_dir" &&
	2799	test -f "$inst_prefix_dir$libdir/$linklib" ; then
	2800	add="$inst_prefix_dir$libdir/$linklib"
	2801	else
	2802	add="$libdir/$linklib"
	2803	fi
	2804	else
	2805	# We cannot seem to hardcode it, guess we'll fake it.
	2806	add_dir="-L$libdir"
	2807	# Try looking first in the location we're being installed to.
	2808	if test -n "$inst_prefix_dir"; then
	2809	case $libdir in
	2810	[\\/]*)
	2811	add_dir="$add_dir -L$inst_prefix_dir$libdir"
	2812	;;
	2813	esac
	2814	fi
	2815	add="-l$name"
	2816	fi
	2817
	2818	if test "$linkmode" = prog; then
	2819	test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
	2820	test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
	2821	else
	2822	test -n "$add_dir" && deplibs="$add_dir $deplibs"
	2823	test -n "$add" && deplibs="$add $deplibs"
	2824	fi
	2825	fi
	2826	elif test "$linkmode" = prog; then
	2827	# Here we assume that one of hardcode_direct or hardcode_minus_L
	2828	# is not unsupported. This is valid on all known static and
	2829	# shared platforms.
	2830	if test "$hardcode_direct" != unsupported; then
	2831	test -n "$old_library" && linklib="$old_library"
	2832	compile_deplibs="$dir/$linklib $compile_deplibs"
	2833	finalize_deplibs="$dir/$linklib $finalize_deplibs"
	2834	else
	2835	compile_deplibs="-l$name -L$dir $compile_deplibs"
	2836	finalize_deplibs="-l$name -L$dir $finalize_deplibs"
	2837	fi
	2838	elif test "$build_libtool_libs" = yes; then
	2839	# Not a shared library
	2840	if test "$deplibs_check_method" != pass_all; then
	2841	# We're trying link a shared library against a static one
	2842	# but the system doesn't support it.
	2843
	2844	# Just print a warning and add the library to dependency_libs so
	2845	# that the program can be linked against the static library.
	2846	$echo
	2847	$echo "*** Warning: This system can not link to static lib archive $lib."
	2848	$echo "*** I have the capability to make that library automatically link in when"
	2849	$echo "*** you link to this library. But I can only do this if you have a"
	2850	$echo "*** shared version of the library, which you do not appear to have."
	2851	if test "$module" = yes; then
	2852	$echo "*** But as you try to build a module library, libtool will still create "
	2853	$echo "*** a static module, that should work as long as the dlopening application"
	2854	$echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
	2855	if test -z "$global_symbol_pipe"; then
	2856	$echo
	2857	$echo "*** However, this would only work if libtool was able to extract symbol"
	2858	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	2859	$echo "*** not find such a program. So, this module is probably useless."
	2860	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
	2861	fi
	2862	if test "$build_old_libs" = no; then
	2863	build_libtool_libs=module
	2864	build_old_libs=yes
	2865	else
	2866	build_libtool_libs=no
	2867	fi
	2868	fi
	2869	else
	2870	deplibs="$dir/$old_library $deplibs"
	2871	link_static=yes
	2872	fi
	2873	fi # link shared/static library?
	2874
	2875	if test "$linkmode" = lib; then
	2876	if test -n "$dependency_libs" &&
	2877	{ test "$hardcode_into_libs" != yes \|\|
	2878	test "$build_old_libs" = yes \|\|
	2879	test "$link_static" = yes; }; then
	2880	# Extract -R from dependency_libs
	2881	temp_deplibs=
	2882	for libdir in $dependency_libs; do
	2883	case $libdir in
	2884	-R*) temp_xrpath=`$echo "X$libdir" \| $Xsed -e 's/^-R//'`
	2885	case " $xrpath " in
	2886	" $temp_xrpath ") ;;
	2887	*) xrpath="$xrpath $temp_xrpath";;
	2888	esac;;
	2889	*) temp_deplibs="$temp_deplibs $libdir";;
	2890	esac
	2891	done
	2892	dependency_libs="$temp_deplibs"
	2893	fi
	2894
	2895	newlib_search_path="$newlib_search_path $absdir"
	2896	# Link against this library
	2897	test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
	2898	# ... and its dependency_libs
	2899	tmp_libs=
	2900	for deplib in $dependency_libs; do
	2901	newdependency_libs="$deplib $newdependency_libs"
	2902	if test "X$duplicate_deps" = "Xyes" ; then
	2903	case "$tmp_libs " in
	2904	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
	2905	esac
	2906	fi
	2907	tmp_libs="$tmp_libs $deplib"
	2908	done
	2909
	2910	if test "$link_all_deplibs" != no; then
	2911	# Add the search paths of all dependency libraries
	2912	for deplib in $dependency_libs; do
	2913	case $deplib in
	2914	-L*) path="$deplib" ;;
	2915	*.la)
	2916	dir=`$echo "X$deplib" \| $Xsed -e 's%/[^/]*$%%'`
	2917	test "X$dir" = "X$deplib" && dir="."
	2918	# We need an absolute path.
	2919	case $dir in
	2920	[\\/]* \| [A-Za-z]:[\\/]*) absdir="$dir" ;;
	2921	*)
	2922	absdir=`cd "$dir" && pwd`
	2923	if test -z "$absdir"; then
	2924	$echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
	2925	absdir="$dir"
	2926	fi
	2927	;;
	2928	esac
	2929	if grep "^installed=no" $deplib > /dev/null; then
	2930	path="$absdir/$objdir"
	2931	else
	2932	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
	2933	if test -z "$libdir"; then
	2934	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
	2935	exit $EXIT_FAILURE
	2936	fi
	2937	if test "$absdir" != "$libdir"; then
	2938	$echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
	2939	fi
	2940	path="$absdir"
	2941	fi
	2942	depdepl=
	2943	case $host in
	2944	--darwin*)
	2945	# we do not want to link against static libs,
	2946	# but need to link against shared
	2947	eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
	2948	if test -n "$deplibrary_names" ; then
	2949	for tmp in $deplibrary_names ; do
	2950	depdepl=$tmp
	2951	done
	2952	if test -f "$path/$depdepl" ; then
	2953	depdepl="$path/$depdepl"
	2954	fi
	2955	# do not add paths which are already there
	2956	case " $newlib_search_path " in
	2957	" $path ") ;;
	2958	*) newlib_search_path="$newlib_search_path $path";;
	2959	esac
	2960	fi
	2961	path=""
	2962	;;
	2963	*)
	2964	path="-L$path"
	2965	;;
	2966	esac
	2967	;;
	2968	-l*)
	2969	case $host in
	2970	--darwin*)
	2971	# Again, we only want to link against shared libraries
	2972	eval tmp_libs=`$echo "X$deplib" \| $Xsed -e "s,^\-l,,"`
	2973	for tmp in $newlib_search_path ; do
	2974	if test -f "$tmp/lib$tmp_libs.dylib" ; then
	2975	eval depdepl="$tmp/lib$tmp_libs.dylib"
	2976	break
	2977	fi
	2978	done
	2979	path=""
	2980	;;
	2981	*) continue ;;
	2982	esac
	2983	;;
	2984	*) continue ;;
	2985	esac
	2986	case " $deplibs " in
	2987	" $path ") ;;
	2988	*) deplibs="$path $deplibs" ;;
	2989	esac
	2990	case " $deplibs " in
	2991	" $depdepl ") ;;
	2992	*) deplibs="$depdepl $deplibs" ;;
	2993	esac
	2994	done
	2995	fi # link_all_deplibs != no
	2996	fi # linkmode = lib
	2997	done # for deplib in $libs
	2998	dependency_libs="$newdependency_libs"
	2999	if test "$pass" = dlpreopen; then
	3000	# Link the dlpreopened libraries before other libraries
	3001	for deplib in $save_deplibs; do
	3002	deplibs="$deplib $deplibs"
	3003	done
	3004	fi
	3005	if test "$pass" != dlopen; then
	3006	if test "$pass" != conv; then
	3007	# Make sure lib_search_path contains only unique directories.
	3008	lib_search_path=
	3009	for dir in $newlib_search_path; do
	3010	case "$lib_search_path " in
	3011	" $dir ") ;;
	3012	*) lib_search_path="$lib_search_path $dir" ;;
	3013	esac
	3014	done
	3015	newlib_search_path=
	3016	fi
	3017
	3018	if test "$linkmode,$pass" != "prog,link"; then
	3019	vars="deplibs"
	3020	else
	3021	vars="compile_deplibs finalize_deplibs"
	3022	fi
	3023	for var in $vars dependency_libs; do
	3024	# Add libraries to $var in reverse order
	3025	eval tmp_libs=\"\$$var\"
	3026	new_libs=
	3027	for deplib in $tmp_libs; do
	3028	# FIXME: Pedantically, this is the right thing to do, so
	3029	# that some nasty dependency loop isn't accidentally
	3030	# broken:
	3031	#new_libs="$deplib $new_libs"
	3032	# Pragmatically, this seems to cause very few problems in
	3033	# practice:
	3034	case $deplib in
	3035	-L*) new_libs="$deplib $new_libs" ;;
	3036	-R*) ;;
	3037	*)
	3038	# And here is the reason: when a library appears more
	3039	# than once as an explicit dependence of a library, or
	3040	# is implicitly linked in more than once by the
	3041	# compiler, it is considered special, and multiple
	3042	# occurrences thereof are not removed. Compare this
	3043	# with having the same library being listed as a
	3044	# dependency of multiple other libraries: in this case,
	3045	# we know (pedantically, we assume) the library does not
	3046	# need to be listed more than once, so we keep only the
	3047	# last copy. This is not always right, but it is rare
	3048	# enough that we require users that really mean to play
	3049	# such unportable linking tricks to link the library
	3050	# using -Wl,-lname, so that libtool does not consider it
	3051	# for duplicate removal.
	3052	case " $specialdeplibs " in
	3053	" $deplib ") new_libs="$deplib $new_libs" ;;
	3054	*)
	3055	case " $new_libs " in
	3056	" $deplib ") ;;
	3057	*) new_libs="$deplib $new_libs" ;;
	3058	esac
	3059	;;
	3060	esac
	3061	;;
	3062	esac
	3063	done
	3064	tmp_libs=
	3065	for deplib in $new_libs; do
	3066	case $deplib in
	3067	-L*)
	3068	case " $tmp_libs " in
	3069	" $deplib ") ;;
	3070	*) tmp_libs="$tmp_libs $deplib" ;;
	3071	esac
	3072	;;
	3073	*) tmp_libs="$tmp_libs $deplib" ;;
	3074	esac
	3075	done
	3076	eval $var=\"$tmp_libs\"
	3077	done # for var
	3078	fi
	3079	# Last step: remove runtime libs from dependency_libs
	3080	# (they stay in deplibs)
	3081	tmp_libs=
	3082	for i in $dependency_libs ; do
	3083	case " $predeps $postdeps $compiler_lib_search_path " in
	3084	" $i ")
	3085	i=""
	3086	;;
	3087	esac
	3088	if test -n "$i" ; then
	3089	tmp_libs="$tmp_libs $i"
	3090	fi
	3091	done
	3092	dependency_libs=$tmp_libs
	3093	done # for pass
	3094	if test "$linkmode" = prog; then
	3095	dlfiles="$newdlfiles"
	3096	dlprefiles="$newdlprefiles"
	3097	fi
	3098
	3099	case $linkmode in
	3100	oldlib)
	3101	if test -n "$deplibs"; then
	3102	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
	3103	fi
	3104
	3105	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	3106	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
	3107	fi
	3108
	3109	if test -n "$rpath"; then
	3110	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
	3111	fi
	3112
	3113	if test -n "$xrpath"; then
	3114	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
	3115	fi
	3116
	3117	if test -n "$vinfo"; then
	3118	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
	3119	fi
	3120
	3121	if test -n "$release"; then
	3122	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
	3123	fi
	3124
	3125	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
	3126	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
	3127	fi
	3128
	3129	# Now set the variables for building old libraries.
	3130	build_libtool_libs=no
	3131	oldlibs="$output"
	3132	objs="$objs$old_deplibs"
	3133	;;
	3134
	3135	lib)
	3136	# Make sure we only generate libraries of the form `libNAME.la'.
	3137	case $outputname in
	3138	lib*)
	3139	name=`$echo "X$outputname" \| $Xsed -e 's/\.la$//' -e 's/^lib//'`
	3140	eval shared_ext=\"$shrext_cmds\"
	3141	eval libname=\"$libname_spec\"
	3142	;;
	3143	*)
	3144	if test "$module" = no; then
	3145	$echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
	3146	$echo "$help" 1>&2
	3147	exit $EXIT_FAILURE
	3148	fi
	3149	if test "$need_lib_prefix" != no; then
	3150	# Add the "lib" prefix for modules if required
	3151	name=`$echo "X$outputname" \| $Xsed -e 's/\.la$//'`
	3152	eval shared_ext=\"$shrext_cmds\"
	3153	eval libname=\"$libname_spec\"
	3154	else
	3155	libname=`$echo "X$outputname" \| $Xsed -e 's/\.la$//'`
	3156	fi
	3157	;;
	3158	esac
	3159
	3160	if test -n "$objs"; then
	3161	if test "$deplibs_check_method" != pass_all; then
	3162	$echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
	3163	exit $EXIT_FAILURE
	3164	else
	3165	$echo
	3166	$echo "*** Warning: Linking the shared library $output against the non-libtool"
	3167	$echo "*** objects $objs is not portable!"
	3168	libobjs="$libobjs $objs"
	3169	fi
	3170	fi
	3171
	3172	if test "$dlself" != no; then
	3173	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
	3174	fi
	3175
	3176	set dummy $rpath
	3177	if test "$#" -gt 2; then
	3178	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
	3179	fi
	3180	install_libdir="$2"
	3181
	3182	oldlibs=
	3183	if test -z "$rpath"; then
	3184	if test "$build_libtool_libs" = yes; then
	3185	# Building a libtool convenience library.
	3186	# Some compilers have problems with a `.al' extension so
	3187	# convenience libraries should have the same extension an
	3188	# archive normally would.
	3189	oldlibs="$output_objdir/$libname.$libext $oldlibs"
	3190	build_libtool_libs=convenience
	3191	build_old_libs=yes
	3192	fi
	3193
	3194	if test -n "$vinfo"; then
	3195	$echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
	3196	fi
	3197
	3198	if test -n "$release"; then
	3199	$echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
	3200	fi
	3201	else
	3202
	3203	# Parse the version information argument.
	3204	save_ifs="$IFS"; IFS=':'
	3205	set dummy $vinfo 0 0 0
	3206	IFS="$save_ifs"
	3207
	3208	if test -n "$8"; then
	3209	$echo "$modename: too many parameters to \`-version-info'" 1>&2
	3210	$echo "$help" 1>&2
	3211	exit $EXIT_FAILURE
	3212	fi
	3213
	3214	# convert absolute version numbers to libtool ages
	3215	# this retains compatibility with .la files and attempts
	3216	# to make the code below a bit more comprehensible
	3217
	3218	case $vinfo_number in
	3219	yes)
	3220	number_major="$2"
	3221	number_minor="$3"
	3222	number_revision="$4"
	3223	#
	3224	# There are really only two kinds -- those that
	3225	# use the current revision as the major version
	3226	# and those that subtract age and use age as
	3227	# a minor version. But, then there is irix
	3228	# which has an extra 1 added just for fun
	3229	#
	3230	case $version_type in
[6]	3231	darwin\|linux\|osf\|windows\|none)
[5]	3232	current=`expr $number_major + $number_minor`
	3233	age="$number_minor"
	3234	revision="$number_revision"
	3235	;;
	3236	freebsd-aout\|freebsd-elf\|sunos)
	3237	current="$number_major"
	3238	revision="$number_minor"
	3239	age="0"
	3240	;;
	3241	irix\|nonstopux)
[6]	3242	current=`expr $number_major + $number_minor`
[5]	3243	age="$number_minor"
	3244	revision="$number_minor"
[6]	3245	lt_irix_increment=no
[5]	3246	;;
	3247	esac
	3248	;;
	3249	no)
	3250	current="$2"
	3251	revision="$3"
	3252	age="$4"
	3253	;;
	3254	esac
	3255
	3256	# Check that each of the things are valid numbers.
	3257	case $current in
	3258	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]) ;;
	3259	*)
	3260	$echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
	3261	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
	3262	exit $EXIT_FAILURE
	3263	;;
	3264	esac
	3265
	3266	case $revision in
	3267	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]) ;;
	3268	*)
	3269	$echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
	3270	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
	3271	exit $EXIT_FAILURE
	3272	;;
	3273	esac
	3274
	3275	case $age in
	3276	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]) ;;
	3277	*)
	3278	$echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
	3279	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
	3280	exit $EXIT_FAILURE
	3281	;;
	3282	esac
	3283
	3284	if test "$age" -gt "$current"; then
	3285	$echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
	3286	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
	3287	exit $EXIT_FAILURE
	3288	fi
	3289
	3290	# Calculate the version variables.
	3291	major=
	3292	versuffix=
	3293	verstring=
	3294	case $version_type in
	3295	none) ;;
	3296
	3297	darwin)
	3298	# Like Linux, but with the current version available in
	3299	# verstring for coding it into the library header
	3300	major=.`expr $current - $age`
	3301	versuffix="$major.$age.$revision"
	3302	# Darwin ld doesn't like 0 for these options...
	3303	minor_current=`expr $current + 1`
[6]	3304	xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
	3305	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
[5]	3306	;;
	3307
	3308	freebsd-aout)
	3309	major=".$current"
	3310	versuffix=".$current.$revision";
	3311	;;
	3312
	3313	freebsd-elf)
	3314	major=".$current"
	3315	versuffix=".$current";
	3316	;;
	3317
	3318	irix \| nonstopux)
[6]	3319	if test "X$lt_irix_increment" = "Xno"; then
	3320	major=`expr $current - $age`
	3321	else
	3322	major=`expr $current - $age + 1`
	3323	fi
[5]	3324	case $version_type in
	3325	nonstopux) verstring_prefix=nonstopux ;;
	3326	*) verstring_prefix=sgi ;;
	3327	esac
	3328	verstring="$verstring_prefix$major.$revision"
	3329
	3330	# Add in all the interfaces that we are compatible with.
	3331	loop=$revision
	3332	while test "$loop" -ne 0; do
	3333	iface=`expr $revision - $loop`
	3334	loop=`expr $loop - 1`
	3335	verstring="$verstring_prefix$major.$iface:$verstring"
	3336	done
	3337
	3338	# Before this point, $major must not contain `.'.
	3339	major=.$major
	3340	versuffix="$major.$revision"
	3341	;;
	3342
	3343	linux)
	3344	major=.`expr $current - $age`
	3345	versuffix="$major.$age.$revision"
	3346	;;
	3347
	3348	osf)
	3349	major=.`expr $current - $age`
	3350	versuffix=".$current.$age.$revision"
	3351	verstring="$current.$age.$revision"
	3352
	3353	# Add in all the interfaces that we are compatible with.
	3354	loop=$age
	3355	while test "$loop" -ne 0; do
	3356	iface=`expr $current - $loop`
	3357	loop=`expr $loop - 1`
	3358	verstring="$verstring:${iface}.0"
	3359	done
	3360
	3361	# Make executables depend on our current version.
	3362	verstring="$verstring:${current}.0"
	3363	;;
	3364
	3365	sunos)
	3366	major=".$current"
	3367	versuffix=".$current.$revision"
	3368	;;
	3369
	3370	windows)
	3371	# Use '-' rather than '.', since we only want one
	3372	# extension on DOS 8.3 filesystems.
	3373	major=`expr $current - $age`
	3374	versuffix="-$major"
	3375	;;
	3376
	3377	*)
	3378	$echo "$modename: unknown library version type \`$version_type'" 1>&2
	3379	$echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2
	3380	exit $EXIT_FAILURE
	3381	;;
	3382	esac
	3383
	3384	# Clear the version info if we defaulted, and they specified a release.
	3385	if test -z "$vinfo" && test -n "$release"; then
	3386	major=
	3387	case $version_type in
	3388	darwin)
	3389	# we can't check for "0.0" in archive_cmds due to quoting
	3390	# problems, so we reset it completely
	3391	verstring=
	3392	;;
	3393	*)
	3394	verstring="0.0"
	3395	;;
	3396	esac
	3397	if test "$need_version" = no; then
	3398	versuffix=
	3399	else
	3400	versuffix=".0.0"
	3401	fi
	3402	fi
	3403
	3404	# Remove version info from name if versioning should be avoided
	3405	if test "$avoid_version" = yes && test "$need_version" = no; then
	3406	major=
	3407	versuffix=
	3408	verstring=""
	3409	fi
	3410
	3411	# Check to see if the archive will have undefined symbols.
	3412	if test "$allow_undefined" = yes; then
	3413	if test "$allow_undefined_flag" = unsupported; then
	3414	$echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
	3415	build_libtool_libs=no
	3416	build_old_libs=yes
	3417	fi
	3418	else
	3419	# Don't allow undefined symbols.
	3420	allow_undefined_flag="$no_undefined_flag"
	3421	fi
	3422	fi
	3423
	3424	if test "$mode" != relink; then
	3425	# Remove our outputs, but don't remove object files since they
	3426	# may have been created when compiling PIC objects.
	3427	removelist=
	3428	tempremovelist=`$echo "$output_objdir/*"`
	3429	for p in $tempremovelist; do
	3430	case $p in
	3431	*.$objext)
	3432	;;
	3433	$output_objdir/$outputname \| $output_objdir/$libname.* \| $output_objdir/${libname}${release}.*)
	3434	if test "X$precious_files_regex" != "X"; then
	3435	if echo $p \| $EGREP -e "$precious_files_regex" >/dev/null 2>&1
	3436	then
	3437	continue
	3438	fi
	3439	fi
	3440	removelist="$removelist $p"
	3441	;;
	3442	*) ;;
	3443	esac
	3444	done
	3445	if test -n "$removelist"; then
	3446	$show "${rm}r $removelist"
	3447	$run ${rm}r $removelist
	3448	fi
	3449	fi
	3450
	3451	# Now set the variables for building old libraries.
	3452	if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
	3453	oldlibs="$oldlibs $output_objdir/$libname.$libext"
	3454
	3455	# Transform .lo files to .o files.
	3456	oldobjs="$objs "`$echo "X$libobjs" \| $SP2NL \| $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" \| $NL2SP`
	3457	fi
	3458
	3459	# Eliminate all temporary directories.
[6]	3460	#for path in $notinst_path; do
	3461	# lib_search_path=`$echo "$lib_search_path " \| ${SED} -e "s% $path % %g"`
	3462	# deplibs=`$echo "$deplibs " \| ${SED} -e "s% -L$path % %g"`
	3463	# dependency_libs=`$echo "$dependency_libs " \| ${SED} -e "s% -L$path % %g"`
	3464	#done
[5]	3465
	3466	if test -n "$xrpath"; then
	3467	# If the user specified any rpath flags, then add them.
	3468	temp_xrpath=
	3469	for libdir in $xrpath; do
	3470	temp_xrpath="$temp_xrpath -R$libdir"
	3471	case "$finalize_rpath " in
	3472	" $libdir ") ;;
	3473	*) finalize_rpath="$finalize_rpath $libdir" ;;
	3474	esac
	3475	done
	3476	if test "$hardcode_into_libs" != yes \|\| test "$build_old_libs" = yes; then
	3477	dependency_libs="$temp_xrpath $dependency_libs"
	3478	fi
	3479	fi
	3480
	3481	# Make sure dlfiles contains only unique files that won't be dlpreopened
	3482	old_dlfiles="$dlfiles"
	3483	dlfiles=
	3484	for lib in $old_dlfiles; do
	3485	case " $dlprefiles $dlfiles " in
	3486	" $lib ") ;;
	3487	*) dlfiles="$dlfiles $lib" ;;
	3488	esac
	3489	done
	3490
	3491	# Make sure dlprefiles contains only unique files
	3492	old_dlprefiles="$dlprefiles"
	3493	dlprefiles=
	3494	for lib in $old_dlprefiles; do
	3495	case "$dlprefiles " in
	3496	" $lib ") ;;
	3497	*) dlprefiles="$dlprefiles $lib" ;;
	3498	esac
	3499	done
	3500
	3501	if test "$build_libtool_libs" = yes; then
	3502	if test -n "$rpath"; then
	3503	case $host in
	3504	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --beos*)
	3505	# these systems don't actually have a c library (as such)!
	3506	;;
	3507	--rhapsody* \| --darwin1.[012])
	3508	# Rhapsody C library is in the System framework
	3509	deplibs="$deplibs -framework System"
	3510	;;
	3511	--netbsd*)
	3512	# Don't link with libc until the a.out ld.so is fixed.
	3513	;;
	3514	--openbsd* \| --freebsd* \| --dragonfly*)
	3515	# Do not include libc due to us having libc/libc_r.
	3516	;;
[6]	3517	--sco3.2v5* \| --sco5v6*)
	3518	# Causes problems with __ctype
	3519	;;
	3520	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
	3521	# Compiler inserts libc in the correct place for threads to work
	3522	;;
[5]	3523	*)
	3524	# Add libc to deplibs on all other systems if necessary.
	3525	if test "$build_libtool_need_lc" = "yes"; then
	3526	deplibs="$deplibs -lc"
	3527	fi
	3528	;;
	3529	esac
	3530	fi
	3531
	3532	# Transform deplibs into only deplibs that can be linked in shared.
	3533	name_save=$name
	3534	libname_save=$libname
	3535	release_save=$release
	3536	versuffix_save=$versuffix
	3537	major_save=$major
	3538	# I'm not sure if I'm treating the release correctly. I think
	3539	# release should show up in the -l (ie -lgmp5) so we don't want to
	3540	# add it in twice. Is that correct?
	3541	release=""
	3542	versuffix=""
	3543	major=""
	3544	newdeplibs=
	3545	droppeddeps=no
	3546	case $deplibs_check_method in
	3547	pass_all)
	3548	# Don't check for shared/static. Everything works.
	3549	# This might be a little naive. We might want to check
	3550	# whether the library exists or not. But this is on
	3551	# osf3 & osf4 and I'm not really sure... Just
	3552	# implementing what was already the behavior.
	3553	newdeplibs=$deplibs
	3554	;;
	3555	test_compile)
	3556	# This code stresses the "libraries are programs" paradigm to its
	3557	# limits. Maybe even breaks it. We compile a program, linking it
	3558	# against the deplibs as a proxy for the library. Then we can check
	3559	# whether they linked in statically or dynamically with ldd.
	3560	$rm conftest.c
	3561	cat > conftest.c <<EOF
	3562	int main() { return 0; }
	3563	EOF
	3564	$rm conftest
[6]	3565	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
[5]	3566	ldd_output=`ldd conftest`
	3567	for i in $deplibs; do
	3568	name=`expr $i : '-l\(.*\)'`
	3569	# If $name is empty we are operating on a -L argument.
[6]	3570	if test "$name" != "" && test "$name" != "0"; then
[5]	3571	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	3572	case " $predeps $postdeps " in
	3573	" $i ")
	3574	newdeplibs="$newdeplibs $i"
	3575	i=""
	3576	;;
	3577	esac
	3578	fi
	3579	if test -n "$i" ; then
	3580	libname=`eval \\$echo \"$libname_spec\"`
	3581	deplib_matches=`eval \\$echo \"$library_names_spec\"`
	3582	set dummy $deplib_matches
	3583	deplib_match=$2
	3584	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
	3585	newdeplibs="$newdeplibs $i"
	3586	else
	3587	droppeddeps=yes
	3588	$echo
	3589	$echo "*** Warning: dynamic linker does not accept needed library $i."
	3590	$echo "*** I have the capability to make that library automatically link in when"
	3591	$echo "*** you link to this library. But I can only do this if you have a"
	3592	$echo "*** shared version of the library, which I believe you do not have"
	3593	$echo "*** because a test_compile did reveal that the linker did not use it for"
	3594	$echo "*** its dynamic dependency list that programs get resolved with at runtime."
	3595	fi
	3596	fi
	3597	else
	3598	newdeplibs="$newdeplibs $i"
	3599	fi
	3600	done
	3601	else
	3602	# Error occurred in the first compile. Let's try to salvage
	3603	# the situation: Compile a separate program for each library.
	3604	for i in $deplibs; do
	3605	name=`expr $i : '-l\(.*\)'`
	3606	# If $name is empty we are operating on a -L argument.
	3607	if test "$name" != "" && test "$name" != "0"; then
	3608	$rm conftest
[6]	3609	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
[5]	3610	ldd_output=`ldd conftest`
	3611	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	3612	case " $predeps $postdeps " in
	3613	" $i ")
	3614	newdeplibs="$newdeplibs $i"
	3615	i=""
	3616	;;
	3617	esac
	3618	fi
	3619	if test -n "$i" ; then
	3620	libname=`eval \\$echo \"$libname_spec\"`
	3621	deplib_matches=`eval \\$echo \"$library_names_spec\"`
	3622	set dummy $deplib_matches
	3623	deplib_match=$2
	3624	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
	3625	newdeplibs="$newdeplibs $i"
	3626	else
	3627	droppeddeps=yes
	3628	$echo
	3629	$echo "*** Warning: dynamic linker does not accept needed library $i."
	3630	$echo "*** I have the capability to make that library automatically link in when"
	3631	$echo "*** you link to this library. But I can only do this if you have a"
	3632	$echo "*** shared version of the library, which you do not appear to have"
	3633	$echo "*** because a test_compile did reveal that the linker did not use this one"
	3634	$echo "*** as a dynamic dependency that programs can get resolved with at runtime."
	3635	fi
	3636	fi
	3637	else
	3638	droppeddeps=yes
	3639	$echo
	3640	$echo "*** Warning! Library $i is needed by this library but I was not able to"
[6]	3641	$echo "*** make it link in! You will probably need to install it or some"
[5]	3642	$echo "*** library that it depends on before this library will be fully"
	3643	$echo "*** functional. Installing it before continuing would be even better."
	3644	fi
	3645	else
	3646	newdeplibs="$newdeplibs $i"
	3647	fi
	3648	done
	3649	fi
	3650	;;
	3651	file_magic*)
	3652	set dummy $deplibs_check_method
	3653	file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
	3654	for a_deplib in $deplibs; do
	3655	name=`expr $a_deplib : '-l\(.*\)'`
	3656	# If $name is empty we are operating on a -L argument.
	3657	if test "$name" != "" && test "$name" != "0"; then
	3658	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	3659	case " $predeps $postdeps " in
	3660	" $a_deplib ")
	3661	newdeplibs="$newdeplibs $a_deplib"
	3662	a_deplib=""
	3663	;;
	3664	esac
	3665	fi
	3666	if test -n "$a_deplib" ; then
	3667	libname=`eval \\$echo \"$libname_spec\"`
	3668	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
	3669	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
	3670	for potent_lib in $potential_libs; do
	3671	# Follow soft links.
	3672	if ls -lLd "$potent_lib" 2>/dev/null \
	3673	\| grep " -> " >/dev/null; then
	3674	continue
	3675	fi
	3676	# The statement above tries to avoid entering an
	3677	# endless loop below, in case of cyclic links.
	3678	# We might still enter an endless loop, since a link
	3679	# loop can be closed while we follow links,
	3680	# but so what?
	3681	potlib="$potent_lib"
	3682	while test -h "$potlib" 2>/dev/null; do
	3683	potliblink=`ls -ld $potlib \| ${SED} 's/.* -> //'`
	3684	case $potliblink in
	3685	[\\/]* \| [A-Za-z]:[\\/]*) potlib="$potliblink";;
	3686	) potlib=`$echo "X$potlib" \| $Xsed -e 's,[^/]$,,'`"$potliblink";;
	3687	esac
	3688	done
	3689	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
	3690	\| ${SED} 10q \
	3691	\| $EGREP "$file_magic_regex" > /dev/null; then
	3692	newdeplibs="$newdeplibs $a_deplib"
	3693	a_deplib=""
	3694	break 2
	3695	fi
	3696	done
	3697	done
	3698	fi
	3699	if test -n "$a_deplib" ; then
	3700	droppeddeps=yes
	3701	$echo
	3702	$echo "*** Warning: linker path does not have real file for library $a_deplib."
	3703	$echo "*** I have the capability to make that library automatically link in when"
	3704	$echo "*** you link to this library. But I can only do this if you have a"
	3705	$echo "*** shared version of the library, which you do not appear to have"
	3706	$echo "*** because I did check the linker path looking for a file starting"
	3707	if test -z "$potlib" ; then
	3708	$echo "*** with $libname but no candidates were found. (...for file magic test)"
	3709	else
	3710	$echo "*** with $libname and none of the candidates passed a file format test"
	3711	$echo "*** using a file magic. Last file checked: $potlib"
	3712	fi
	3713	fi
	3714	else
	3715	# Add a -L argument.
	3716	newdeplibs="$newdeplibs $a_deplib"
	3717	fi
	3718	done # Gone through all deplibs.
	3719	;;
	3720	match_pattern*)
	3721	set dummy $deplibs_check_method
	3722	match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
	3723	for a_deplib in $deplibs; do
	3724	name=`expr $a_deplib : '-l\(.*\)'`
	3725	# If $name is empty we are operating on a -L argument.
	3726	if test -n "$name" && test "$name" != "0"; then
	3727	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	3728	case " $predeps $postdeps " in
	3729	" $a_deplib ")
	3730	newdeplibs="$newdeplibs $a_deplib"
	3731	a_deplib=""
	3732	;;
	3733	esac
	3734	fi
	3735	if test -n "$a_deplib" ; then
	3736	libname=`eval \\$echo \"$libname_spec\"`
	3737	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
	3738	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
	3739	for potent_lib in $potential_libs; do
	3740	potlib="$potent_lib" # see symlink-check above in file_magic test
	3741	if eval $echo \"$potent_lib\" 2>/dev/null \
	3742	\| ${SED} 10q \
	3743	\| $EGREP "$match_pattern_regex" > /dev/null; then
	3744	newdeplibs="$newdeplibs $a_deplib"
	3745	a_deplib=""
	3746	break 2
	3747	fi
	3748	done
	3749	done
	3750	fi
	3751	if test -n "$a_deplib" ; then
	3752	droppeddeps=yes
	3753	$echo
	3754	$echo "*** Warning: linker path does not have real file for library $a_deplib."
	3755	$echo "*** I have the capability to make that library automatically link in when"
	3756	$echo "*** you link to this library. But I can only do this if you have a"
	3757	$echo "*** shared version of the library, which you do not appear to have"
	3758	$echo "*** because I did check the linker path looking for a file starting"
	3759	if test -z "$potlib" ; then
	3760	$echo "*** with $libname but no candidates were found. (...for regex pattern test)"
	3761	else
	3762	$echo "*** with $libname and none of the candidates passed a file format test"
	3763	$echo "*** using a regex pattern. Last file checked: $potlib"
	3764	fi
	3765	fi
	3766	else
	3767	# Add a -L argument.
	3768	newdeplibs="$newdeplibs $a_deplib"
	3769	fi
	3770	done # Gone through all deplibs.
	3771	;;
	3772	none \| unknown \| *)
	3773	newdeplibs=""
	3774	tmp_deplibs=`$echo "X $deplibs" \| $Xsed -e 's/ -lc$//' \
	3775	-e 's/ -[LR][^ ]*//g'`
	3776	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	3777	for i in $predeps $postdeps ; do
	3778	# can't use Xsed below, because $i might contain '/'
	3779	tmp_deplibs=`$echo "X $tmp_deplibs" \| ${SED} -e "1s,^X,," -e "s,$i,,"`
	3780	done
	3781	fi
	3782	if $echo "X $tmp_deplibs" \| $Xsed -e 's/[ ]//g' \
	3783	\| grep . >/dev/null; then
	3784	$echo
	3785	if test "X$deplibs_check_method" = "Xnone"; then
	3786	$echo "*** Warning: inter-library dependencies are not supported in this platform."
	3787	else
	3788	$echo "*** Warning: inter-library dependencies are not known to be supported."
	3789	fi
	3790	$echo "*** All declared inter-library dependencies are being dropped."
	3791	droppeddeps=yes
	3792	fi
	3793	;;
	3794	esac
	3795	versuffix=$versuffix_save
	3796	major=$major_save
	3797	release=$release_save
	3798	libname=$libname_save
	3799	name=$name_save
	3800
	3801	case $host in
	3802	--rhapsody* \| --darwin1.[012])
	3803	# On Rhapsody replace the C library is the System framework
	3804	newdeplibs=`$echo "X $newdeplibs" \| $Xsed -e 's/ -lc / -framework System /'`
	3805	;;
	3806	esac
	3807
	3808	if test "$droppeddeps" = yes; then
	3809	if test "$module" = yes; then
	3810	$echo
	3811	$echo "*** Warning: libtool could not satisfy all declared inter-library"
	3812	$echo "*** dependencies of module $libname. Therefore, libtool will create"
	3813	$echo "*** a static module, that should work as long as the dlopening"
	3814	$echo "*** application is linked with the -dlopen flag."
	3815	if test -z "$global_symbol_pipe"; then
	3816	$echo
	3817	$echo "*** However, this would only work if libtool was able to extract symbol"
	3818	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	3819	$echo "*** not find such a program. So, this module is probably useless."
	3820	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
	3821	fi
	3822	if test "$build_old_libs" = no; then
	3823	oldlibs="$output_objdir/$libname.$libext"
	3824	build_libtool_libs=module
	3825	build_old_libs=yes
	3826	else
	3827	build_libtool_libs=no
	3828	fi
	3829	else
	3830	$echo "*** The inter-library dependencies that have been dropped here will be"
	3831	$echo "*** automatically added whenever a program is linked with this library"
	3832	$echo "*** or is declared to -dlopen it."
	3833
	3834	if test "$allow_undefined" = no; then
	3835	$echo
	3836	$echo "*** Since this library must not contain undefined symbols,"
	3837	$echo "*** because either the platform does not support them or"
	3838	$echo "*** it was explicitly requested with -no-undefined,"
	3839	$echo "*** libtool will only create a static version of it."
	3840	if test "$build_old_libs" = no; then
	3841	oldlibs="$output_objdir/$libname.$libext"
	3842	build_libtool_libs=module
	3843	build_old_libs=yes
	3844	else
	3845	build_libtool_libs=no
	3846	fi
	3847	fi
	3848	fi
	3849	fi
	3850	# Done checking deplibs!
	3851	deplibs=$newdeplibs
	3852	fi
	3853
[6]	3854
	3855	# move library search paths that coincide with paths to not yet
	3856	# installed libraries to the beginning of the library search list
	3857	new_libs=
	3858	for path in $notinst_path; do
	3859	case " $new_libs " in
	3860	" -L$path/$objdir ") ;;
	3861	*)
	3862	case " $deplibs " in
	3863	" -L$path/$objdir ")
	3864	new_libs="$new_libs -L$path/$objdir" ;;
	3865	esac
	3866	;;
	3867	esac
	3868	done
	3869	for deplib in $deplibs; do
	3870	case $deplib in
	3871	-L*)
	3872	case " $new_libs " in
	3873	" $deplib ") ;;
	3874	*) new_libs="$new_libs $deplib" ;;
	3875	esac
	3876	;;
	3877	*) new_libs="$new_libs $deplib" ;;
	3878	esac
	3879	done
	3880	deplibs="$new_libs"
	3881
	3882
[5]	3883	# All the library-specific variables (install_libdir is set above).
	3884	library_names=
	3885	old_library=
	3886	dlname=
	3887
	3888	# Test again, we may have decided not to build it any more
	3889	if test "$build_libtool_libs" = yes; then
	3890	if test "$hardcode_into_libs" = yes; then
	3891	# Hardcode the library paths
	3892	hardcode_libdirs=
	3893	dep_rpath=
	3894	rpath="$finalize_rpath"
	3895	test "$mode" != relink && rpath="$compile_rpath$rpath"
	3896	for libdir in $rpath; do
	3897	if test -n "$hardcode_libdir_flag_spec"; then
	3898	if test -n "$hardcode_libdir_separator"; then
	3899	if test -z "$hardcode_libdirs"; then
	3900	hardcode_libdirs="$libdir"
	3901	else
	3902	# Just accumulate the unique libdirs.
	3903	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	3904	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	3905	;;
	3906	*)
	3907	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
	3908	;;
	3909	esac
	3910	fi
	3911	else
	3912	eval flag=\"$hardcode_libdir_flag_spec\"
	3913	dep_rpath="$dep_rpath $flag"
	3914	fi
	3915	elif test -n "$runpath_var"; then
	3916	case "$perm_rpath " in
	3917	" $libdir ") ;;
	3918	*) perm_rpath="$perm_rpath $libdir" ;;
	3919	esac
	3920	fi
	3921	done
	3922	# Substitute the hardcoded libdirs into the rpath.
	3923	if test -n "$hardcode_libdir_separator" &&
	3924	test -n "$hardcode_libdirs"; then
	3925	libdir="$hardcode_libdirs"
	3926	if test -n "$hardcode_libdir_flag_spec_ld"; then
[6]	3927	case $archive_cmds in
	3928	\$LD) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
	3929	*) eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
	3930	esac
[5]	3931	else
	3932	eval dep_rpath=\"$hardcode_libdir_flag_spec\"
	3933	fi
	3934	fi
	3935	if test -n "$runpath_var" && test -n "$perm_rpath"; then
	3936	# We should set the runpath_var.
	3937	rpath=
	3938	for dir in $perm_rpath; do
	3939	rpath="$rpath$dir:"
	3940	done
	3941	eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
	3942	fi
	3943	test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
	3944	fi
	3945
	3946	shlibpath="$finalize_shlibpath"
	3947	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
	3948	if test -n "$shlibpath"; then
	3949	eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
	3950	fi
	3951
	3952	# Get the real and link names of the library.
	3953	eval shared_ext=\"$shrext_cmds\"
	3954	eval library_names=\"$library_names_spec\"
	3955	set dummy $library_names
	3956	realname="$2"
	3957	shift; shift
	3958
	3959	if test -n "$soname_spec"; then
	3960	eval soname=\"$soname_spec\"
	3961	else
	3962	soname="$realname"
	3963	fi
	3964	if test -z "$dlname"; then
	3965	dlname=$soname
	3966	fi
	3967
	3968	lib="$output_objdir/$realname"
[6]	3969	linknames=
[5]	3970	for link
	3971	do
	3972	linknames="$linknames $link"
	3973	done
	3974
	3975	# Use standard objects if they are pic
	3976	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
	3977
	3978	# Prepare the list of exported symbols
	3979	if test -z "$export_symbols"; then
	3980	if test "$always_export_symbols" = yes \|\| test -n "$export_symbols_regex"; then
	3981	$show "generating symbol list for \`$libname.la'"
	3982	export_symbols="$output_objdir/$libname.exp"
	3983	$run $rm $export_symbols
	3984	cmds=$export_symbols_cmds
	3985	save_ifs="$IFS"; IFS='~'
	3986	for cmd in $cmds; do
	3987	IFS="$save_ifs"
	3988	eval cmd=\"$cmd\"
	3989	if len=`expr "X$cmd" : ".*"` &&
	3990	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
	3991	$show "$cmd"
	3992	$run eval "$cmd" \|\| exit $?
	3993	skipped_export=false
	3994	else
	3995	# The command line is too long to execute in one step.
	3996	$show "using reloadable object file for export list..."
	3997	skipped_export=:
	3998	# Break out early, otherwise skipped_export may be
	3999	# set to false by a later but shorter cmd.
	4000	break
	4001	fi
	4002	done
	4003	IFS="$save_ifs"
	4004	if test -n "$export_symbols_regex"; then
	4005	$show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
	4006	$run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
	4007	$show "$mv \"${export_symbols}T\" \"$export_symbols\""
	4008	$run eval '$mv "${export_symbols}T" "$export_symbols"'
	4009	fi
	4010	fi
	4011	fi
	4012
	4013	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	4014	$run eval '$echo "X$include_expsyms" \| $SP2NL >> "$export_symbols"'
	4015	fi
	4016
	4017	tmp_deplibs=
	4018	for test_deplib in $deplibs; do
	4019	case " $convenience " in
	4020	" $test_deplib ") ;;
	4021	*)
	4022	tmp_deplibs="$tmp_deplibs $test_deplib"
	4023	;;
	4024	esac
	4025	done
	4026	deplibs="$tmp_deplibs"
	4027
	4028	if test -n "$convenience"; then
	4029	if test -n "$whole_archive_flag_spec"; then
	4030	save_libobjs=$libobjs
	4031	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	4032	else
	4033	gentop="$output_objdir/${outputname}x"
	4034	generated="$generated $gentop"
	4035
	4036	func_extract_archives $gentop $convenience
	4037	libobjs="$libobjs $func_extract_archives_result"
	4038	fi
	4039	fi
	4040
	4041	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
	4042	eval flag=\"$thread_safe_flag_spec\"
	4043	linker_flags="$linker_flags $flag"
	4044	fi
	4045
	4046	# Make a backup of the uninstalled library when relinking
	4047	if test "$mode" = relink; then
	4048	$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' \|\| exit $?
	4049	fi
	4050
	4051	# Do each of the archive commands.
	4052	if test "$module" = yes && test -n "$module_cmds" ; then
	4053	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	4054	eval test_cmds=\"$module_expsym_cmds\"
	4055	cmds=$module_expsym_cmds
	4056	else
	4057	eval test_cmds=\"$module_cmds\"
	4058	cmds=$module_cmds
	4059	fi
	4060	else
	4061	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	4062	eval test_cmds=\"$archive_expsym_cmds\"
	4063	cmds=$archive_expsym_cmds
	4064	else
	4065	eval test_cmds=\"$archive_cmds\"
	4066	cmds=$archive_cmds
	4067	fi
	4068	fi
	4069
	4070	if test "X$skipped_export" != "X:" &&
	4071	len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
	4072	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
	4073	:
	4074	else
	4075	# The command line is too long to link in one step, link piecewise.
	4076	$echo "creating reloadable object files..."
	4077
	4078	# Save the value of $output and $libobjs because we want to
	4079	# use them later. If we have whole_archive_flag_spec, we
	4080	# want to use save_libobjs as it was before
	4081	# whole_archive_flag_spec was expanded, because we can't
	4082	# assume the linker understands whole_archive_flag_spec.
	4083	# This may have to be revisited, in case too many
	4084	# convenience libraries get linked in and end up exceeding
	4085	# the spec.
	4086	if test -z "$convenience" \|\| test -z "$whole_archive_flag_spec"; then
	4087	save_libobjs=$libobjs
	4088	fi
	4089	save_output=$output
	4090	output_la=`$echo "X$output" \| $Xsed -e "$basename"`
	4091
	4092	# Clear the reloadable object creation command queue and
	4093	# initialize k to one.
	4094	test_cmds=
	4095	concat_cmds=
	4096	objlist=
	4097	delfiles=
	4098	last_robj=
	4099	k=1
	4100	output=$output_objdir/$output_la-${k}.$objext
	4101	# Loop over the list of objects to be linked.
	4102	for obj in $save_libobjs
	4103	do
	4104	eval test_cmds=\"$reload_cmds $objlist $last_robj\"
	4105	if test "X$objlist" = X \|\|
	4106	{ len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
	4107	test "$len" -le "$max_cmd_len"; }; then
	4108	objlist="$objlist $obj"
	4109	else
	4110	# The command $test_cmds is almost too long, add a
	4111	# command to the queue.
	4112	if test "$k" -eq 1 ; then
	4113	# The first file doesn't have a previous command to add.
	4114	eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
	4115	else
	4116	# All subsequent reloadable object files will link in
	4117	# the last one created.
	4118	eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
	4119	fi
	4120	last_robj=$output_objdir/$output_la-${k}.$objext
	4121	k=`expr $k + 1`
	4122	output=$output_objdir/$output_la-${k}.$objext
	4123	objlist=$obj
	4124	len=1
	4125	fi
	4126	done
	4127	# Handle the remaining objects by creating one last
	4128	# reloadable object file. All subsequent reloadable object
	4129	# files will link in the last one created.
	4130	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
	4131	eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
	4132
	4133	if ${skipped_export-false}; then
	4134	$show "generating symbol list for \`$libname.la'"
	4135	export_symbols="$output_objdir/$libname.exp"
	4136	$run $rm $export_symbols
	4137	libobjs=$output
	4138	# Append the command to create the export file.
	4139	eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
	4140	fi
	4141
	4142	# Set up a command to remove the reloadable object files
	4143	# after they are used.
	4144	i=0
	4145	while test "$i" -lt "$k"
	4146	do
	4147	i=`expr $i + 1`
	4148	delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
	4149	done
	4150
	4151	$echo "creating a temporary reloadable object file: $output"
	4152
	4153	# Loop through the commands generated above and execute them.
	4154	save_ifs="$IFS"; IFS='~'
	4155	for cmd in $concat_cmds; do
	4156	IFS="$save_ifs"
	4157	$show "$cmd"
	4158	$run eval "$cmd" \|\| exit $?
	4159	done
	4160	IFS="$save_ifs"
	4161
	4162	libobjs=$output
	4163	# Restore the value of output.
	4164	output=$save_output
	4165
	4166	if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
	4167	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	4168	fi
	4169	# Expand the library linking commands again to reset the
	4170	# value of $libobjs for piecewise linking.
	4171
	4172	# Do each of the archive commands.
	4173	if test "$module" = yes && test -n "$module_cmds" ; then
	4174	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	4175	cmds=$module_expsym_cmds
	4176	else
	4177	cmds=$module_cmds
	4178	fi
	4179	else
	4180	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	4181	cmds=$archive_expsym_cmds
	4182	else
	4183	cmds=$archive_cmds
	4184	fi
	4185	fi
	4186
	4187	# Append the command to remove the reloadable object files
	4188	# to the just-reset $cmds.
	4189	eval cmds=\"\$cmds~\$rm $delfiles\"
	4190	fi
	4191	save_ifs="$IFS"; IFS='~'
	4192	for cmd in $cmds; do
	4193	IFS="$save_ifs"
	4194	eval cmd=\"$cmd\"
	4195	$show "$cmd"
	4196	$run eval "$cmd" \|\| {
	4197	lt_exit=$?
	4198
	4199	# Restore the uninstalled library and exit
	4200	if test "$mode" = relink; then
	4201	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
	4202	fi
	4203
	4204	exit $lt_exit
	4205	}
	4206	done
	4207	IFS="$save_ifs"
	4208
	4209	# Restore the uninstalled library and exit
	4210	if test "$mode" = relink; then
	4211	$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' \|\| exit $?
	4212
	4213	if test -n "$convenience"; then
	4214	if test -z "$whole_archive_flag_spec"; then
	4215	$show "${rm}r $gentop"
	4216	$run ${rm}r "$gentop"
	4217	fi
	4218	fi
	4219
	4220	exit $EXIT_SUCCESS
	4221	fi
	4222
	4223	# Create links to the real library.
	4224	for linkname in $linknames; do
	4225	if test "$realname" != "$linkname"; then
	4226	$show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
	4227	$run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' \|\| exit $?
	4228	fi
	4229	done
	4230
	4231	# If -module or -export-dynamic was specified, set the dlname.
	4232	if test "$module" = yes \|\| test "$export_dynamic" = yes; then
	4233	# On all known operating systems, these are identical.
	4234	dlname="$soname"
	4235	fi
	4236	fi
	4237	;;
	4238
	4239	obj)
	4240	if test -n "$deplibs"; then
	4241	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
	4242	fi
	4243
	4244	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	4245	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
	4246	fi
	4247
	4248	if test -n "$rpath"; then
	4249	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
	4250	fi
	4251
	4252	if test -n "$xrpath"; then
	4253	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
	4254	fi
	4255
	4256	if test -n "$vinfo"; then
	4257	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
	4258	fi
	4259
	4260	if test -n "$release"; then
	4261	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
	4262	fi
	4263
	4264	case $output in
	4265	*.lo)
	4266	if test -n "$objs$old_deplibs"; then
	4267	$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
	4268	exit $EXIT_FAILURE
	4269	fi
	4270	libobj="$output"
	4271	obj=`$echo "X$output" \| $Xsed -e "$lo2o"`
	4272	;;
	4273	*)
	4274	libobj=
	4275	obj="$output"
	4276	;;
	4277	esac
	4278
	4279	# Delete the old objects.
	4280	$run $rm $obj $libobj
	4281
	4282	# Objects from convenience libraries. This assumes
	4283	# single-version convenience libraries. Whenever we create
	4284	# different ones for PIC/non-PIC, this we'll have to duplicate
	4285	# the extraction.
	4286	reload_conv_objs=
	4287	gentop=
	4288	# reload_cmds runs $LD directly, so let us get rid of
[6]	4289	# -Wl from whole_archive_flag_spec and hope we can get by with
	4290	# turning comma into space..
[5]	4291	wl=
	4292
	4293	if test -n "$convenience"; then
	4294	if test -n "$whole_archive_flag_spec"; then
[6]	4295	eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
	4296	reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" \| $Xsed -e 's\|,\| \|g'`
[5]	4297	else
	4298	gentop="$output_objdir/${obj}x"
	4299	generated="$generated $gentop"
	4300
	4301	func_extract_archives $gentop $convenience
	4302	reload_conv_objs="$reload_objs $func_extract_archives_result"
	4303	fi
	4304	fi
	4305
	4306	# Create the old-style object.
	4307	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
	4308
	4309	output="$obj"
	4310	cmds=$reload_cmds
	4311	save_ifs="$IFS"; IFS='~'
	4312	for cmd in $cmds; do
	4313	IFS="$save_ifs"
	4314	eval cmd=\"$cmd\"
	4315	$show "$cmd"
	4316	$run eval "$cmd" \|\| exit $?
	4317	done
	4318	IFS="$save_ifs"
	4319
	4320	# Exit if we aren't doing a library object file.
	4321	if test -z "$libobj"; then
	4322	if test -n "$gentop"; then
	4323	$show "${rm}r $gentop"
	4324	$run ${rm}r $gentop
	4325	fi
	4326
	4327	exit $EXIT_SUCCESS
	4328	fi
	4329
	4330	if test "$build_libtool_libs" != yes; then
	4331	if test -n "$gentop"; then
	4332	$show "${rm}r $gentop"
	4333	$run ${rm}r $gentop
	4334	fi
	4335
	4336	# Create an invalid libtool object if no PIC, so that we don't
	4337	# accidentally link it into a program.
	4338	# $show "echo timestamp > $libobj"
	4339	# $run eval "echo timestamp > $libobj" \|\| exit $?
	4340	exit $EXIT_SUCCESS
	4341	fi
	4342
	4343	if test -n "$pic_flag" \|\| test "$pic_mode" != default; then
	4344	# Only do commands if we really have different PIC objects.
	4345	reload_objs="$libobjs $reload_conv_objs"
	4346	output="$libobj"
	4347	cmds=$reload_cmds
	4348	save_ifs="$IFS"; IFS='~'
	4349	for cmd in $cmds; do
	4350	IFS="$save_ifs"
	4351	eval cmd=\"$cmd\"
	4352	$show "$cmd"
	4353	$run eval "$cmd" \|\| exit $?
	4354	done
	4355	IFS="$save_ifs"
	4356	fi
	4357
	4358	if test -n "$gentop"; then
	4359	$show "${rm}r $gentop"
	4360	$run ${rm}r $gentop
	4361	fi
	4362
	4363	exit $EXIT_SUCCESS
	4364	;;
	4365
	4366	prog)
	4367	case $host in
	4368	cygwin) output=`$echo $output \| ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
	4369	esac
	4370	if test -n "$vinfo"; then
	4371	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
	4372	fi
	4373
	4374	if test -n "$release"; then
	4375	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
	4376	fi
	4377
	4378	if test "$preload" = yes; then
	4379	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
	4380	test "$dlopen_self_static" = unknown; then
	4381	$echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
	4382	fi
	4383	fi
	4384
	4385	case $host in
	4386	--rhapsody* \| --darwin1.[012])
	4387	# On Rhapsody replace the C library is the System framework
	4388	compile_deplibs=`$echo "X $compile_deplibs" \| $Xsed -e 's/ -lc / -framework System /'`
	4389	finalize_deplibs=`$echo "X $finalize_deplibs" \| $Xsed -e 's/ -lc / -framework System /'`
	4390	;;
	4391	esac
	4392
	4393	case $host in
	4394	darwin)
	4395	# Don't allow lazy linking, it breaks C++ global constructors
	4396	if test "$tagname" = CXX ; then
	4397	compile_command="$compile_command ${wl}-bind_at_load"
	4398	finalize_command="$finalize_command ${wl}-bind_at_load"
	4399	fi
	4400	;;
	4401	esac
	4402
[6]	4403
	4404	# move library search paths that coincide with paths to not yet
	4405	# installed libraries to the beginning of the library search list
	4406	new_libs=
	4407	for path in $notinst_path; do
	4408	case " $new_libs " in
	4409	" -L$path/$objdir ") ;;
	4410	*)
	4411	case " $compile_deplibs " in
	4412	" -L$path/$objdir ")
	4413	new_libs="$new_libs -L$path/$objdir" ;;
	4414	esac
	4415	;;
	4416	esac
	4417	done
	4418	for deplib in $compile_deplibs; do
	4419	case $deplib in
	4420	-L*)
	4421	case " $new_libs " in
	4422	" $deplib ") ;;
	4423	*) new_libs="$new_libs $deplib" ;;
	4424	esac
	4425	;;
	4426	*) new_libs="$new_libs $deplib" ;;
	4427	esac
	4428	done
	4429	compile_deplibs="$new_libs"
	4430
	4431
[5]	4432	compile_command="$compile_command $compile_deplibs"
	4433	finalize_command="$finalize_command $finalize_deplibs"
	4434
	4435	if test -n "$rpath$xrpath"; then
	4436	# If the user specified any rpath flags, then add them.
	4437	for libdir in $rpath $xrpath; do
	4438	# This is the magic to use -rpath.
	4439	case "$finalize_rpath " in
	4440	" $libdir ") ;;
	4441	*) finalize_rpath="$finalize_rpath $libdir" ;;
	4442	esac
	4443	done
	4444	fi
	4445
	4446	# Now hardcode the library paths
	4447	rpath=
	4448	hardcode_libdirs=
	4449	for libdir in $compile_rpath $finalize_rpath; do
	4450	if test -n "$hardcode_libdir_flag_spec"; then
	4451	if test -n "$hardcode_libdir_separator"; then
	4452	if test -z "$hardcode_libdirs"; then
	4453	hardcode_libdirs="$libdir"
	4454	else
	4455	# Just accumulate the unique libdirs.
	4456	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	4457	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	4458	;;
	4459	*)
	4460	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
	4461	;;
	4462	esac
	4463	fi
	4464	else
	4465	eval flag=\"$hardcode_libdir_flag_spec\"
	4466	rpath="$rpath $flag"
	4467	fi
	4468	elif test -n "$runpath_var"; then
	4469	case "$perm_rpath " in
	4470	" $libdir ") ;;
	4471	*) perm_rpath="$perm_rpath $libdir" ;;
	4472	esac
	4473	fi
	4474	case $host in
	4475	--cygwin* \| --mingw* \| --pw32* \| --os2*)
[6]	4476	testbindir=`$echo "X$libdir" \| $Xsed -e 's/lib$/bin*'`
[5]	4477	case :$dllsearchpath: in
	4478	":$libdir:") ;;
	4479	*) dllsearchpath="$dllsearchpath:$libdir";;
	4480	esac
[6]	4481	case :$dllsearchpath: in
	4482	":$testbindir:") ;;
	4483	*) dllsearchpath="$dllsearchpath:$testbindir";;
	4484	esac
[5]	4485	;;
	4486	esac
	4487	done
	4488	# Substitute the hardcoded libdirs into the rpath.
	4489	if test -n "$hardcode_libdir_separator" &&
	4490	test -n "$hardcode_libdirs"; then
	4491	libdir="$hardcode_libdirs"
	4492	eval rpath=\" $hardcode_libdir_flag_spec\"
	4493	fi
	4494	compile_rpath="$rpath"
	4495
	4496	rpath=
	4497	hardcode_libdirs=
	4498	for libdir in $finalize_rpath; do
	4499	if test -n "$hardcode_libdir_flag_spec"; then
	4500	if test -n "$hardcode_libdir_separator"; then
	4501	if test -z "$hardcode_libdirs"; then
	4502	hardcode_libdirs="$libdir"
	4503	else
	4504	# Just accumulate the unique libdirs.
	4505	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	4506	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
	4507	;;
	4508	*)
	4509	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
	4510	;;
	4511	esac
	4512	fi
	4513	else
	4514	eval flag=\"$hardcode_libdir_flag_spec\"
	4515	rpath="$rpath $flag"
	4516	fi
	4517	elif test -n "$runpath_var"; then
	4518	case "$finalize_perm_rpath " in
	4519	" $libdir ") ;;
	4520	*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
	4521	esac
	4522	fi
	4523	done
	4524	# Substitute the hardcoded libdirs into the rpath.
	4525	if test -n "$hardcode_libdir_separator" &&
	4526	test -n "$hardcode_libdirs"; then
	4527	libdir="$hardcode_libdirs"
	4528	eval rpath=\" $hardcode_libdir_flag_spec\"
	4529	fi
	4530	finalize_rpath="$rpath"
	4531
	4532	if test -n "$libobjs" && test "$build_old_libs" = yes; then
	4533	# Transform all the library objects into standard objects.
	4534	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
	4535	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
	4536	fi
	4537
	4538	dlsyms=
	4539	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
	4540	if test -n "$NM" && test -n "$global_symbol_pipe"; then
	4541	dlsyms="${outputname}S.c"
	4542	else
	4543	$echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
	4544	fi
	4545	fi
	4546
	4547	if test -n "$dlsyms"; then
	4548	case $dlsyms in
	4549	"") ;;
	4550	*.c)
	4551	# Discover the nlist of each of the dlfiles.
	4552	nlist="$output_objdir/${outputname}.nm"
	4553
	4554	$show "$rm $nlist ${nlist}S ${nlist}T"
	4555	$run $rm "$nlist" "${nlist}S" "${nlist}T"
	4556
	4557	# Parse the name list into a source file.
	4558	$show "creating $output_objdir/$dlsyms"
	4559
	4560	test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
	4561	/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
	4562	/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
	4563
	4564	#ifdef __cplusplus
	4565	extern \"C\" {
	4566	#endif
	4567
	4568	/* Prevent the only kind of declaration conflicts we can make. */
	4569	#define lt_preloaded_symbols some_other_symbol
	4570
	4571	/* External symbol declarations for the compiler. */\
	4572	"
	4573
	4574	if test "$dlself" = yes; then
	4575	$show "generating symbol list for \`$output'"
	4576
	4577	test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
	4578
	4579	# Add our own program objects to the symbol list.
	4580	progfiles=`$echo "X$objs$old_deplibs" \| $SP2NL \| $Xsed -e "$lo2o" \| $NL2SP`
	4581	for arg in $progfiles; do
	4582	$show "extracting global C symbols from \`$arg'"
	4583	$run eval "$NM $arg \| $global_symbol_pipe >> '$nlist'"
	4584	done
	4585
	4586	if test -n "$exclude_expsyms"; then
	4587	$run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
	4588	$run eval '$mv "$nlist"T "$nlist"'
	4589	fi
	4590
	4591	if test -n "$export_symbols_regex"; then
	4592	$run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
	4593	$run eval '$mv "$nlist"T "$nlist"'
	4594	fi
	4595
	4596	# Prepare the list of exported symbols
	4597	if test -z "$export_symbols"; then
	4598	export_symbols="$output_objdir/$outputname.exp"
	4599	$run $rm $export_symbols
	4600	$run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
[6]	4601	case $host in
	4602	cygwin \| mingw )
	4603	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
	4604	$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
	4605	;;
	4606	esac
[5]	4607	else
[6]	4608	$run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
[5]	4609	$run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
	4610	$run eval 'mv "$nlist"T "$nlist"'
[6]	4611	case $host in
	4612	cygwin \| mingw )
	4613	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
	4614	$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
	4615	;;
	4616	esac
[5]	4617	fi
	4618	fi
	4619
	4620	for arg in $dlprefiles; do
	4621	$show "extracting global C symbols from \`$arg'"
	4622	name=`$echo "$arg" \| ${SED} -e 's%^.*/%%'`
	4623	$run eval '$echo ": $name " >> "$nlist"'
	4624	$run eval "$NM $arg \| $global_symbol_pipe >> '$nlist'"
	4625	done
	4626
	4627	if test -z "$run"; then
	4628	# Make sure we have at least an empty file.
	4629	test -f "$nlist" \|\| : > "$nlist"
	4630
	4631	if test -n "$exclude_expsyms"; then
	4632	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
	4633	$mv "$nlist"T "$nlist"
	4634	fi
	4635
	4636	# Try sorting and uniquifying the output.
	4637	if grep -v "^: " < "$nlist" \|
	4638	if sort -k 3 </dev/null >/dev/null 2>&1; then
	4639	sort -k 3
	4640	else
	4641	sort +2
	4642	fi \|
	4643	uniq > "$nlist"S; then
	4644	:
	4645	else
	4646	grep -v "^: " < "$nlist" > "$nlist"S
	4647	fi
	4648
	4649	if test -f "$nlist"S; then
	4650	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
	4651	else
	4652	$echo '/* NONE */' >> "$output_objdir/$dlsyms"
	4653	fi
	4654
	4655	$echo >> "$output_objdir/$dlsyms" "\
	4656
	4657	#undef lt_preloaded_symbols
	4658
	4659	#if defined (__STDC__) && __STDC__
	4660	# define lt_ptr void *
	4661	#else
	4662	# define lt_ptr char *
	4663	# define const
	4664	#endif
	4665
	4666	/* The mapping between symbol names and symbols. */
	4667	"
	4668
	4669	case $host in
	4670	cygwin \| mingw )
	4671	$echo >> "$output_objdir/$dlsyms" "\
	4672	/* DATA imports from DLLs on WIN32 can't be const, because
	4673	runtime relocations are performed -- see ld's documentation
	4674	on pseudo-relocs */
	4675	struct {
	4676	"
	4677	;;
	4678	* )
	4679	$echo >> "$output_objdir/$dlsyms" "\
	4680	const struct {
	4681	"
	4682	;;
	4683	esac
	4684
	4685
	4686	$echo >> "$output_objdir/$dlsyms" "\
	4687	const char *name;
	4688	lt_ptr address;
	4689	}
	4690	lt_preloaded_symbols[] =
	4691	{\
	4692	"
	4693
	4694	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
	4695
	4696	$echo >> "$output_objdir/$dlsyms" "\
	4697	{0, (lt_ptr) 0}
	4698	};
	4699
	4700	/* This works around a problem in FreeBSD linker */
	4701	#ifdef FREEBSD_WORKAROUND
	4702	static const void *lt_preloaded_setup() {
	4703	return lt_preloaded_symbols;
	4704	}
	4705	#endif
	4706
	4707	#ifdef __cplusplus
	4708	}
	4709	#endif\
	4710	"
	4711	fi
	4712
	4713	pic_flag_for_symtable=
	4714	case $host in
	4715	# compiling the symbol table file with pic_flag works around
	4716	# a FreeBSD bug that causes programs to crash when -lm is
	4717	# linked before any other PIC object. But we must not use
	4718	# pic_flag when linking with -static. The problem exists in
	4719	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
	4720	--freebsd2\|--freebsd3.0\|--freebsdelf3.0*)
	4721	case "$compile_command " in
	4722	" -static ") ;;
	4723	*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
	4724	esac;;
	4725	--hpux*)
	4726	case "$compile_command " in
	4727	" -static ") ;;
	4728	*) pic_flag_for_symtable=" $pic_flag";;
	4729	esac
	4730	esac
	4731
	4732	# Now compile the dynamic symbol file.
[6]	4733	$show "(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
	4734	$run eval '(cd $output_objdir && $LTCC $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' \|\| exit $?
[5]	4735
	4736	# Clean up the generated files.
	4737	$show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
	4738	$run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
	4739
	4740	# Transform the symbol file into the correct name.
[6]	4741	case $host in
	4742	cygwin \| mingw )
	4743	if test -f "$output_objdir/${outputname}.def" ; then
	4744	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4745	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4746	else
	4747	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4748	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4749	fi
	4750	;;
	4751	* )
	4752	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4753	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" \| $NL2SP`
	4754	;;
	4755	esac
[5]	4756	;;
	4757	*)
	4758	$echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
	4759	exit $EXIT_FAILURE
	4760	;;
	4761	esac
	4762	else
	4763	# We keep going just in case the user didn't refer to
	4764	# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
	4765	# really was required.
	4766
	4767	# Nullify the symbol file.
[6]	4768	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e "s% @SYMFILE@%%" \| $NL2SP`
	4769	finalize_command=`$echo "X$finalize_command" \| $SP2NL \| $Xsed -e "s% @SYMFILE@%%" \| $NL2SP`
[5]	4770	fi
	4771
	4772	if test "$need_relink" = no \|\| test "$build_libtool_libs" != yes; then
	4773	# Replace the output file specification.
[6]	4774	compile_command=`$echo "X$compile_command" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%'"$output"'%g' \| $NL2SP`
[5]	4775	link_command="$compile_command$compile_rpath"
	4776
	4777	# We have no uninstalled library dependencies, so finalize right now.
	4778	$show "$link_command"
	4779	$run eval "$link_command"
[6]	4780	exit_status=$?
[5]	4781
	4782	# Delete the generated files.
	4783	if test -n "$dlsyms"; then
	4784	$show "$rm $output_objdir/${outputname}S.${objext}"
	4785	$run $rm "$output_objdir/${outputname}S.${objext}"
	4786	fi
	4787
[6]	4788	exit $exit_status
[5]	4789	fi
	4790
	4791	if test -n "$shlibpath_var"; then
	4792	# We should set the shlibpath_var
	4793	rpath=
	4794	for dir in $temp_rpath; do
	4795	case $dir in
	4796	[\\/]* \| [A-Za-z]:[\\/]*)
	4797	# Absolute path.
	4798	rpath="$rpath$dir:"
	4799	;;
	4800	*)
	4801	# Relative path: add a thisdir entry.
	4802	rpath="$rpath\$thisdir/$dir:"
	4803	;;
	4804	esac
	4805	done
	4806	temp_rpath="$rpath"
	4807	fi
	4808
	4809	if test -n "$compile_shlibpath$finalize_shlibpath"; then
	4810	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
	4811	fi
	4812	if test -n "$finalize_shlibpath"; then
	4813	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
	4814	fi
	4815
	4816	compile_var=
	4817	finalize_var=
	4818	if test -n "$runpath_var"; then
	4819	if test -n "$perm_rpath"; then
	4820	# We should set the runpath_var.
	4821	rpath=
	4822	for dir in $perm_rpath; do
	4823	rpath="$rpath$dir:"
	4824	done
	4825	compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
	4826	fi
	4827	if test -n "$finalize_perm_rpath"; then
	4828	# We should set the runpath_var.
	4829	rpath=
	4830	for dir in $finalize_perm_rpath; do
	4831	rpath="$rpath$dir:"
	4832	done
	4833	finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
	4834	fi
	4835	fi
	4836
	4837	if test "$no_install" = yes; then
	4838	# We don't need to create a wrapper script.
	4839	link_command="$compile_var$compile_command$compile_rpath"
	4840	# Replace the output file specification.
	4841	link_command=`$echo "X$link_command" \| $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
	4842	# Delete the old output file.
	4843	$run $rm $output
	4844	# Link the executable and exit
	4845	$show "$link_command"
	4846	$run eval "$link_command" \|\| exit $?
	4847	exit $EXIT_SUCCESS
	4848	fi
	4849
	4850	if test "$hardcode_action" = relink; then
	4851	# Fast installation is not supported
	4852	link_command="$compile_var$compile_command$compile_rpath"
	4853	relink_command="$finalize_var$finalize_command$finalize_rpath"
	4854
	4855	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
	4856	$echo "$modename: \`$output' will be relinked during installation" 1>&2
	4857	else
	4858	if test "$fast_install" != no; then
	4859	link_command="$finalize_var$compile_command$finalize_rpath"
	4860	if test "$fast_install" = yes; then
[6]	4861	relink_command=`$echo "X$compile_var$compile_command$compile_rpath" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' \| $NL2SP`
[5]	4862	else
	4863	# fast_install is set to needless
	4864	relink_command=
	4865	fi
	4866	else
	4867	link_command="$compile_var$compile_command$compile_rpath"
	4868	relink_command="$finalize_var$finalize_command$finalize_rpath"
	4869	fi
	4870	fi
	4871
	4872	# Replace the output file specification.
	4873	link_command=`$echo "X$link_command" \| $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
	4874
	4875	# Delete the old output files.
	4876	$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
	4877
	4878	$show "$link_command"
	4879	$run eval "$link_command" \|\| exit $?
	4880
	4881	# Now create the wrapper script.
	4882	$show "creating $output"
	4883
	4884	# Quote the relink command for shipping.
	4885	if test -n "$relink_command"; then
	4886	# Preserve any variables that may affect compiler behavior
	4887	for var in $variables_saved_for_relink; do
	4888	if eval test -z \"\${$var+set}\"; then
	4889	relink_command="{ test -z \"\${$var+set}\" \|\| unset $var \|\| { $var=; export $var; }; }; $relink_command"
	4890	elif eval var_value=\$$var; test -z "$var_value"; then
	4891	relink_command="$var=; export $var; $relink_command"
	4892	else
	4893	var_value=`$echo "X$var_value" \| $Xsed -e "$sed_quote_subst"`
	4894	relink_command="$var=\"$var_value\"; export $var; $relink_command"
	4895	fi
	4896	done
	4897	relink_command="(cd `pwd`; $relink_command)"
[6]	4898	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e "$sed_quote_subst" \| $NL2SP`
[5]	4899	fi
	4900
	4901	# Quote $echo for shipping.
	4902	if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
	4903	case $progpath in
	4904	[\\/]* \| [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
	4905	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
	4906	esac
	4907	qecho=`$echo "X$qecho" \| $Xsed -e "$sed_quote_subst"`
	4908	else
	4909	qecho=`$echo "X$echo" \| $Xsed -e "$sed_quote_subst"`
	4910	fi
	4911
	4912	# Only actually do things if our run command is non-null.
	4913	if test -z "$run"; then
	4914	# win32 will think the script is a binary if it has
	4915	# a .exe suffix, so we strip it off here.
	4916	case $output in
	4917	*.exe) output=`$echo $output\|${SED} 's,.exe$,,'` ;;
	4918	esac
	4919	# test for cygwin because mv fails w/o .exe extensions
	4920	case $host in
	4921	cygwin)
	4922	exeext=.exe
	4923	outputname=`$echo $outputname\|${SED} 's,.exe$,,'` ;;
	4924	*) exeext= ;;
	4925	esac
	4926	case $host in
	4927	cygwin \| mingw )
[6]	4928	output_name=`basename $output`
	4929	output_path=`dirname $output`
	4930	cwrappersource="$output_path/$objdir/lt-$output_name.c"
	4931	cwrapper="$output_path/$output_name.exe"
	4932	$rm $cwrappersource $cwrapper
	4933	trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
[5]	4934
	4935	cat > $cwrappersource <<EOF
	4936
	4937	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
	4938	Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
	4939
	4940	The $output program cannot be directly executed until all the libtool
	4941	libraries that it depends on are installed.
	4942
	4943	This wrapper executable should never be moved out of the build directory.
	4944	If it is, it will not operate correctly.
	4945
	4946	Currently, it simply execs the wrapper script "/bin/sh $output",
	4947	but could eventually absorb all of the scripts functionality and
	4948	exec $objdir/$outputname directly.
	4949	*/
	4950	EOF
	4951	cat >> $cwrappersource<<"EOF"
	4952	#include <stdio.h>
	4953	#include <stdlib.h>
	4954	#include <unistd.h>
	4955	#include <malloc.h>
	4956	#include <stdarg.h>
	4957	#include <assert.h>
[6]	4958	#include <string.h>
	4959	#include <ctype.h>
	4960	#include <sys/stat.h>
[5]	4961
	4962	#if defined(PATH_MAX)
	4963	# define LT_PATHMAX PATH_MAX
	4964	#elif defined(MAXPATHLEN)
	4965	# define LT_PATHMAX MAXPATHLEN
	4966	#else
	4967	# define LT_PATHMAX 1024
	4968	#endif
	4969
	4970	#ifndef DIR_SEPARATOR
[6]	4971	# define DIR_SEPARATOR '/'
	4972	# define PATH_SEPARATOR ':'
[5]	4973	#endif
	4974
	4975	#if defined (_WIN32) \|\| defined (__MSDOS__) \|\| defined (__DJGPP__) \|\| \
	4976	defined (__OS2__)
[6]	4977	# define HAVE_DOS_BASED_FILE_SYSTEM
	4978	# ifndef DIR_SEPARATOR_2
	4979	# define DIR_SEPARATOR_2 '\\'
	4980	# endif
	4981	# ifndef PATH_SEPARATOR_2
	4982	# define PATH_SEPARATOR_2 ';'
	4983	# endif
[5]	4984	#endif
	4985
	4986	#ifndef DIR_SEPARATOR_2
	4987	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
	4988	#else /* DIR_SEPARATOR_2 */
	4989	# define IS_DIR_SEPARATOR(ch) \
	4990	(((ch) == DIR_SEPARATOR) \|\| ((ch) == DIR_SEPARATOR_2))
	4991	#endif /* DIR_SEPARATOR_2 */
	4992
[6]	4993	#ifndef PATH_SEPARATOR_2
	4994	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
	4995	#else /* PATH_SEPARATOR_2 */
	4996	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
	4997	#endif /* PATH_SEPARATOR_2 */
	4998
[5]	4999	#define XMALLOC(type, num) ((type ) xmalloc ((num) sizeof(type)))
	5000	#define XFREE(stale) do { \
	5001	if (stale) { free ((void *) stale); stale = 0; } \
	5002	} while (0)
	5003
[6]	5004	/* -DDEBUG is fairly common in CFLAGS. */
	5005	#undef DEBUG
	5006	#if defined DEBUGWRAPPER
	5007	# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
	5008	#else
	5009	# define DEBUG(format, ...)
	5010	#endif
	5011
[5]	5012	const char *program_name = NULL;
	5013
	5014	void * xmalloc (size_t num);
	5015	char * xstrdup (const char *string);
[6]	5016	const char * base_name (const char *name);
	5017	char * find_executable(const char *wrapper);
	5018	int check_executable(const char *path);
[5]	5019	char * strendzap(char str, const char pat);
	5020	void lt_fatal (const char *message, ...);
	5021
	5022	int
	5023	main (int argc, char *argv[])
	5024	{
	5025	char **newargz;
	5026	int i;
	5027
[6]	5028	program_name = (char *) xstrdup (base_name (argv[0]));
	5029	DEBUG("(main) argv[0] : %s\n",argv[0]);
	5030	DEBUG("(main) program_name : %s\n",program_name);
[5]	5031	newargz = XMALLOC(char *, argc+2);
	5032	EOF
	5033
[6]	5034	cat >> $cwrappersource <<EOF
	5035	newargz[0] = (char *) xstrdup("$SHELL");
[5]	5036	EOF
	5037
[6]	5038	cat >> $cwrappersource <<"EOF"
	5039	newargz[1] = find_executable(argv[0]);
	5040	if (newargz[1] == NULL)
	5041	lt_fatal("Couldn't find %s", argv[0]);
	5042	DEBUG("(main) found exe at : %s\n",newargz[1]);
[5]	5043	/* we know the script has the same name, without the .exe */
	5044	/* so make sure newargz[1] doesn't end in .exe */
	5045	strendzap(newargz[1],".exe");
	5046	for (i = 1; i < argc; i++)
	5047	newargz[i+1] = xstrdup(argv[i]);
	5048	newargz[argc+1] = NULL;
[6]	5049
	5050	for (i=0; i<argc+1; i++)
	5051	{
	5052	DEBUG("(main) newargz[%d] : %s\n",i,newargz[i]);
	5053	;
	5054	}
	5055
[5]	5056	EOF
	5057
[6]	5058	case $host_os in
	5059	mingw*)
	5060	cat >> $cwrappersource <<EOF
	5061	execv("$SHELL",(char const **)newargz);
	5062	EOF
	5063	;;
	5064	*)
	5065	cat >> $cwrappersource <<EOF
[5]	5066	execv("$SHELL",newargz);
	5067	EOF
[6]	5068	;;
	5069	esac
[5]	5070
[6]	5071	cat >> $cwrappersource <<"EOF"
[5]	5072	return 127;
	5073	}
	5074
	5075	void *
	5076	xmalloc (size_t num)
	5077	{
	5078	void * p = (void *) malloc (num);
	5079	if (!p)
	5080	lt_fatal ("Memory exhausted");
	5081
	5082	return p;
	5083	}
	5084
	5085	char *
	5086	xstrdup (const char *string)
	5087	{
	5088	return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
	5089	;
	5090	}
	5091
[6]	5092	const char *
	5093	base_name (const char *name)
[5]	5094	{
	5095	const char *base;
	5096
	5097	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
	5098	/* Skip over the disk name in MSDOS pathnames. */
[6]	5099	if (isalpha ((unsigned char)name[0]) && name[1] == ':')
[5]	5100	name += 2;
	5101	#endif
	5102
	5103	for (base = name; *name; name++)
	5104	if (IS_DIR_SEPARATOR (*name))
	5105	base = name + 1;
[6]	5106	return base;
[5]	5107	}
	5108
[6]	5109	int
	5110	check_executable(const char * path)
	5111	{
	5112	struct stat st;
	5113
	5114	DEBUG("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
	5115	if ((!path) \|\| (!*path))
	5116	return 0;
	5117
	5118	if ((stat (path, &st) >= 0) &&
	5119	(
	5120	/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
	5121	#if defined (S_IXOTH)
	5122	((st.st_mode & S_IXOTH) == S_IXOTH) \|\|
	5123	#endif
	5124	#if defined (S_IXGRP)
	5125	((st.st_mode & S_IXGRP) == S_IXGRP) \|\|
	5126	#endif
	5127	((st.st_mode & S_IXUSR) == S_IXUSR))
	5128	)
	5129	return 1;
	5130	else
	5131	return 0;
	5132	}
	5133
	5134	/* Searches for the full path of the wrapper. Returns
	5135	newly allocated full path name if found, NULL otherwise */
[5]	5136	char *
[6]	5137	find_executable (const char* wrapper)
[5]	5138	{
[6]	5139	int has_slash = 0;
	5140	const char* p;
	5141	const char* p_next;
	5142	/* static buffer for getcwd */
[5]	5143	char tmp[LT_PATHMAX + 1];
[6]	5144	int tmp_len;
	5145	char* concat_name;
[5]	5146
[6]	5147	DEBUG("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
[5]	5148
[6]	5149	if ((wrapper == NULL) \|\| (*wrapper == '\0'))
	5150	return NULL;
	5151
	5152	/* Absolute path? */
[5]	5153	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
[6]	5154	if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
	5155	{
	5156	concat_name = xstrdup (wrapper);
	5157	if (check_executable(concat_name))
	5158	return concat_name;
	5159	XFREE(concat_name);
	5160	}
	5161	else
	5162	{
[5]	5163	#endif
[6]	5164	if (IS_DIR_SEPARATOR (wrapper[0]))
	5165	{
	5166	concat_name = xstrdup (wrapper);
	5167	if (check_executable(concat_name))
	5168	return concat_name;
	5169	XFREE(concat_name);
	5170	}
	5171	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
	5172	}
	5173	#endif
[5]	5174
[6]	5175	for (p = wrapper; *p; p++)
	5176	if (*p == '/')
	5177	{
	5178	has_slash = 1;
	5179	break;
	5180	}
	5181	if (!has_slash)
	5182	{
	5183	/* no slashes; search PATH */
	5184	const char* path = getenv ("PATH");
	5185	if (path != NULL)
	5186	{
	5187	for (p = path; *p; p = p_next)
	5188	{
	5189	const char* q;
	5190	size_t p_len;
	5191	for (q = p; *q; q++)
	5192	if (IS_PATH_SEPARATOR(*q))
	5193	break;
	5194	p_len = q - p;
	5195	p_next = (*q == '\0' ? q : q + 1);
	5196	if (p_len == 0)
	5197	{
	5198	/* empty path: current directory */
	5199	if (getcwd (tmp, LT_PATHMAX) == NULL)
	5200	lt_fatal ("getcwd failed");
	5201	tmp_len = strlen(tmp);
	5202	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
	5203	memcpy (concat_name, tmp, tmp_len);
	5204	concat_name[tmp_len] = '/';
	5205	strcpy (concat_name + tmp_len + 1, wrapper);
	5206	}
	5207	else
	5208	{
	5209	concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
	5210	memcpy (concat_name, p, p_len);
	5211	concat_name[p_len] = '/';
	5212	strcpy (concat_name + p_len + 1, wrapper);
	5213	}
	5214	if (check_executable(concat_name))
	5215	return concat_name;
	5216	XFREE(concat_name);
	5217	}
	5218	}
	5219	/* not found in PATH; assume curdir */
	5220	}
	5221	/* Relative path \| not found in path: prepend cwd */
[5]	5222	if (getcwd (tmp, LT_PATHMAX) == NULL)
	5223	lt_fatal ("getcwd failed");
[6]	5224	tmp_len = strlen(tmp);
	5225	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
	5226	memcpy (concat_name, tmp, tmp_len);
	5227	concat_name[tmp_len] = '/';
	5228	strcpy (concat_name + tmp_len + 1, wrapper);
	5229
	5230	if (check_executable(concat_name))
	5231	return concat_name;
	5232	XFREE(concat_name);
	5233	return NULL;
[5]	5234	}
	5235
	5236	char *
	5237	strendzap(char str, const char pat)
	5238	{
	5239	size_t len, patlen;
	5240
	5241	assert(str != NULL);
	5242	assert(pat != NULL);
	5243
	5244	len = strlen(str);
	5245	patlen = strlen(pat);
	5246
	5247	if (patlen <= len)
	5248	{
	5249	str += len - patlen;
	5250	if (strcmp(str, pat) == 0)
	5251	*str = '\0';
	5252	}
	5253	return str;
	5254	}
	5255
	5256	static void
	5257	lt_error_core (int exit_status, const char * mode,
	5258	const char * message, va_list ap)
	5259	{
	5260	fprintf (stderr, "%s: %s: ", program_name, mode);
	5261	vfprintf (stderr, message, ap);
	5262	fprintf (stderr, ".\n");
	5263
	5264	if (exit_status >= 0)
	5265	exit (exit_status);
	5266	}
	5267
	5268	void
	5269	lt_fatal (const char *message, ...)
	5270	{
	5271	va_list ap;
	5272	va_start (ap, message);
	5273	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
	5274	va_end (ap);
	5275	}
	5276	EOF
[6]	5277	# we should really use a build-platform specific compiler
	5278	# here, but OTOH, the wrappers (shell script and this C one)
	5279	# are only useful if you want to execute the "real" binary.
	5280	# Since the "real" binary is built for $host, then this
	5281	# wrapper might as well be built for $host, too.
	5282	$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
	5283	;;
	5284	esac
	5285	$rm $output
	5286	trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
[5]	5287
	5288	$echo > $output "\
	5289	#! $SHELL
	5290
	5291	# $output - temporary wrapper script for $objdir/$outputname
	5292	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
	5293	#
	5294	# The $output program cannot be directly executed until all the libtool
	5295	# libraries that it depends on are installed.
	5296	#
	5297	# This wrapper script should never be moved out of the build directory.
	5298	# If it is, it will not operate correctly.
	5299
	5300	# Sed substitution that helps us do robust quoting. It backslashifies
	5301	# metacharacters that are still active within double-quoted strings.
	5302	Xsed='${SED} -e 1s/^X//'
	5303	sed_quote_subst='$sed_quote_subst'
	5304
[6]	5305	# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
	5306	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
	5307	emulate sh
	5308	NULLCMD=:
	5309	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
	5310	# is contrary to our usage. Disable this feature.
	5311	alias -g '\${1+\"\$@\"}'='\"\$@\"'
	5312	setopt NO_GLOB_SUBST
	5313	else
	5314	case \`(set -o) 2>/dev/null\` in posix) set -o posix;; esac
	5315	fi
	5316	BIN_SH=xpg4; export BIN_SH # for Tru64
	5317	DUALCASE=1; export DUALCASE # for MKS sh
	5318
[5]	5319	# The HP-UX ksh and POSIX shell print the target directory to stdout
	5320	# if CDPATH is set.
	5321	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
	5322
	5323	relink_command=\"$relink_command\"
	5324
	5325	# This environment variable determines our operation mode.
	5326	if test \"\$libtool_install_magic\" = \"$magic\"; then
	5327	# install mode needs the following variable:
	5328	notinst_deplibs='$notinst_deplibs'
	5329	else
	5330	# When we are sourced in execute mode, \$file and \$echo are already set.
	5331	if test \"\$libtool_execute_magic\" != \"$magic\"; then
	5332	echo=\"$qecho\"
	5333	file=\"\$0\"
	5334	# Make sure echo works.
	5335	if test \"X\$1\" = X--no-reexec; then
	5336	# Discard the --no-reexec flag, and continue.
	5337	shift
	5338	elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
	5339	# Yippee, \$echo works!
	5340	:
	5341	else
	5342	# Restart under the correct shell, and then maybe \$echo will work.
	5343	exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
	5344	fi
	5345	fi\
	5346	"
	5347	$echo >> $output "\
	5348
	5349	# Find the directory that this script lives in.
	5350	thisdir=\`\$echo \"X\$file\" \| \$Xsed -e 's%/[^/]*$%%'\`
	5351	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
	5352
	5353	# Follow symbolic links until we get to the real thisdir.
	5354	file=\`ls -ld \"\$file\" \| ${SED} -n 's/.*-> //p'\`
	5355	while test -n \"\$file\"; do
	5356	destdir=\`\$echo \"X\$file\" \| \$Xsed -e 's%/[^/]*\$%%'\`
	5357
	5358	# If there was a directory component, then change thisdir.
	5359	if test \"x\$destdir\" != \"x\$file\"; then
	5360	case \"\$destdir\" in
	5361	[\\\\/]* \| [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
	5362	*) thisdir=\"\$thisdir/\$destdir\" ;;
	5363	esac
	5364	fi
	5365
	5366	file=\`\$echo \"X\$file\" \| \$Xsed -e 's%^.*/%%'\`
	5367	file=\`ls -ld \"\$thisdir/\$file\" \| ${SED} -n 's/.*-> //p'\`
	5368	done
	5369
	5370	# Try to get the absolute directory name.
	5371	absdir=\`cd \"\$thisdir\" && pwd\`
	5372	test -n \"\$absdir\" && thisdir=\"\$absdir\"
	5373	"
	5374
	5375	if test "$fast_install" = yes; then
	5376	$echo >> $output "\
	5377	program=lt-'$outputname'$exeext
	5378	progdir=\"\$thisdir/$objdir\"
	5379
	5380	if test ! -f \"\$progdir/\$program\" \|\| \\
	5381	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null \| ${SED} 1q\`; \\
	5382	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
	5383
	5384	file=\"\$\$-\$program\"
	5385
	5386	if test ! -d \"\$progdir\"; then
	5387	$mkdir \"\$progdir\"
	5388	else
	5389	$rm \"\$progdir/\$file\"
	5390	fi"
	5391
	5392	$echo >> $output "\
	5393
	5394	# relink executable if necessary
	5395	if test -n \"\$relink_command\"; then
	5396	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
	5397	else
	5398	$echo \"\$relink_command_output\" >&2
	5399	$rm \"\$progdir/\$file\"
	5400	exit $EXIT_FAILURE
	5401	fi
	5402	fi
	5403
	5404	$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null \|\|
	5405	{ $rm \"\$progdir/\$program\";
	5406	$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
	5407	$rm \"\$progdir/\$file\"
	5408	fi"
	5409	else
	5410	$echo >> $output "\
	5411	program='$outputname'
	5412	progdir=\"\$thisdir/$objdir\"
	5413	"
	5414	fi
	5415
	5416	$echo >> $output "\
	5417
	5418	if test -f \"\$progdir/\$program\"; then"
	5419
	5420	# Export our shlibpath_var if we have one.
	5421	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
	5422	$echo >> $output "\
	5423	# Add our own library path to $shlibpath_var
	5424	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
	5425
	5426	# Some systems cannot cope with colon-terminated $shlibpath_var
	5427	# The second colon is a workaround for a bug in BeOS R4 sed
	5428	$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" \| \$Xsed -e 's/::*\$//'\`
	5429
	5430	export $shlibpath_var
	5431	"
	5432	fi
	5433
	5434	# fixup the dll searchpath if we need to.
	5435	if test -n "$dllsearchpath"; then
	5436	$echo >> $output "\
	5437	# Add the dll search path components to the executable PATH
	5438	PATH=$dllsearchpath:\$PATH
	5439	"
	5440	fi
	5441
	5442	$echo >> $output "\
	5443	if test \"\$libtool_execute_magic\" != \"$magic\"; then
	5444	# Run the actual program with our arguments.
	5445	"
	5446	case $host in
	5447	# Backslashes separate directories on plain windows
	5448	--mingw \| --os2*)
	5449	$echo >> $output "\
	5450	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
	5451	"
	5452	;;
	5453
	5454	*)
	5455	$echo >> $output "\
	5456	exec \"\$progdir/\$program\" \${1+\"\$@\"}
	5457	"
	5458	;;
	5459	esac
	5460	$echo >> $output "\
[6]	5461	\$echo \"\$0: cannot exec \$program \$*\"
[5]	5462	exit $EXIT_FAILURE
	5463	fi
	5464	else
	5465	# The program doesn't exist.
	5466	\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
	5467	\$echo \"This script is just a wrapper for \$program.\" 1>&2
	5468	$echo \"See the $PACKAGE documentation for more information.\" 1>&2
	5469	exit $EXIT_FAILURE
	5470	fi
	5471	fi\
	5472	"
	5473	chmod +x $output
	5474	fi
	5475	exit $EXIT_SUCCESS
	5476	;;
	5477	esac
	5478
	5479	# See if we need to build an old-fashioned archive.
	5480	for oldlib in $oldlibs; do
	5481
	5482	if test "$build_libtool_libs" = convenience; then
	5483	oldobjs="$libobjs_save"
	5484	addlibs="$convenience"
	5485	build_libtool_libs=no
	5486	else
	5487	if test "$build_libtool_libs" = module; then
	5488	oldobjs="$libobjs_save"
	5489	build_libtool_libs=no
	5490	else
	5491	oldobjs="$old_deplibs $non_pic_objects"
	5492	fi
	5493	addlibs="$old_convenience"
	5494	fi
	5495
	5496	if test -n "$addlibs"; then
	5497	gentop="$output_objdir/${outputname}x"
	5498	generated="$generated $gentop"
	5499
	5500	func_extract_archives $gentop $addlibs
	5501	oldobjs="$oldobjs $func_extract_archives_result"
	5502	fi
	5503
	5504	# Do each command in the archive commands.
	5505	if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
	5506	cmds=$old_archive_from_new_cmds
	5507	else
	5508	# POSIX demands no paths to be encoded in archives. We have
	5509	# to avoid creating archives with duplicate basenames if we
	5510	# might have to extract them afterwards, e.g., when creating a
	5511	# static archive out of a convenience library, or when linking
	5512	# the entirety of a libtool archive into another (currently
	5513	# not supported by libtool).
	5514	if (for obj in $oldobjs
	5515	do
	5516	$echo "X$obj" \| $Xsed -e 's%^.*/%%'
	5517	done \| sort \| sort -uc >/dev/null 2>&1); then
	5518	:
	5519	else
	5520	$echo "copying selected object files to avoid basename conflicts..."
	5521
	5522	if test -z "$gentop"; then
	5523	gentop="$output_objdir/${outputname}x"
	5524	generated="$generated $gentop"
	5525
	5526	$show "${rm}r $gentop"
	5527	$run ${rm}r "$gentop"
	5528	$show "$mkdir $gentop"
	5529	$run $mkdir "$gentop"
[6]	5530	exit_status=$?
	5531	if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
	5532	exit $exit_status
[5]	5533	fi
	5534	fi
	5535
	5536	save_oldobjs=$oldobjs
	5537	oldobjs=
	5538	counter=1
	5539	for obj in $save_oldobjs
	5540	do
	5541	objbase=`$echo "X$obj" \| $Xsed -e 's%^.*/%%'`
	5542	case " $oldobjs " in
	5543	" ") oldobjs=$obj ;;
	5544	[\ /]"$objbase ")
	5545	while :; do
	5546	# Make sure we don't pick an alternate name that also
	5547	# overlaps.
	5548	newobj=lt$counter-$objbase
	5549	counter=`expr $counter + 1`
	5550	case " $oldobjs " in
	5551	[\ /]"$newobj ") ;;
	5552	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
	5553	esac
	5554	done
	5555	$show "ln $obj $gentop/$newobj \|\| cp $obj $gentop/$newobj"
	5556	$run ln "$obj" "$gentop/$newobj" \|\|
	5557	$run cp "$obj" "$gentop/$newobj"
	5558	oldobjs="$oldobjs $gentop/$newobj"
	5559	;;
	5560	*) oldobjs="$oldobjs $obj" ;;
	5561	esac
	5562	done
	5563	fi
	5564
	5565	eval cmds=\"$old_archive_cmds\"
	5566
	5567	if len=`expr "X$cmds" : ".*"` &&
	5568	test "$len" -le "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
	5569	cmds=$old_archive_cmds
	5570	else
	5571	# the command line is too long to link in one step, link in parts
	5572	$echo "using piecewise archive linking..."
	5573	save_RANLIB=$RANLIB
	5574	RANLIB=:
	5575	objlist=
	5576	concat_cmds=
	5577	save_oldobjs=$oldobjs
	5578
	5579	# Is there a better way of finding the last object in the list?
	5580	for obj in $save_oldobjs
	5581	do
	5582	last_oldobj=$obj
	5583	done
	5584	for obj in $save_oldobjs
	5585	do
	5586	oldobjs="$objlist $obj"
	5587	objlist="$objlist $obj"
	5588	eval test_cmds=\"$old_archive_cmds\"
	5589	if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
	5590	test "$len" -le "$max_cmd_len"; then
	5591	:
	5592	else
	5593	# the above command should be used before it gets too long
	5594	oldobjs=$objlist
	5595	if test "$obj" = "$last_oldobj" ; then
	5596	RANLIB=$save_RANLIB
	5597	fi
	5598	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
	5599	eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
	5600	objlist=
	5601	fi
	5602	done
	5603	RANLIB=$save_RANLIB
	5604	oldobjs=$objlist
	5605	if test "X$oldobjs" = "X" ; then
	5606	eval cmds=\"\$concat_cmds\"
	5607	else
	5608	eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
	5609	fi
	5610	fi
	5611	fi
	5612	save_ifs="$IFS"; IFS='~'
	5613	for cmd in $cmds; do
	5614	eval cmd=\"$cmd\"
	5615	IFS="$save_ifs"
	5616	$show "$cmd"
	5617	$run eval "$cmd" \|\| exit $?
	5618	done
	5619	IFS="$save_ifs"
	5620	done
	5621
	5622	if test -n "$generated"; then
	5623	$show "${rm}r$generated"
	5624	$run ${rm}r$generated
	5625	fi
	5626
	5627	# Now create the libtool archive.
	5628	case $output in
	5629	*.la)
	5630	old_library=
	5631	test "$build_old_libs" = yes && old_library="$libname.$libext"
	5632	$show "creating $output"
	5633
	5634	# Preserve any variables that may affect compiler behavior
	5635	for var in $variables_saved_for_relink; do
	5636	if eval test -z \"\${$var+set}\"; then
	5637	relink_command="{ test -z \"\${$var+set}\" \|\| unset $var \|\| { $var=; export $var; }; }; $relink_command"
	5638	elif eval var_value=\$$var; test -z "$var_value"; then
	5639	relink_command="$var=; export $var; $relink_command"
	5640	else
	5641	var_value=`$echo "X$var_value" \| $Xsed -e "$sed_quote_subst"`
	5642	relink_command="$var=\"$var_value\"; export $var; $relink_command"
	5643	fi
	5644	done
	5645	# Quote the link command for shipping.
	5646	relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
[6]	5647	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e "$sed_quote_subst" \| $NL2SP`
[5]	5648	if test "$hardcode_automatic" = yes ; then
	5649	relink_command=
	5650	fi
	5651
	5652
	5653	# Only create the output if not a dry run.
	5654	if test -z "$run"; then
	5655	for installed in no yes; do
	5656	if test "$installed" = yes; then
	5657	if test -z "$install_libdir"; then
	5658	break
	5659	fi
	5660	output="$output_objdir/$outputname"i
	5661	# Replace all uninstalled libtool libraries with the installed ones
	5662	newdependency_libs=
	5663	for deplib in $dependency_libs; do
	5664	case $deplib in
	5665	*.la)
	5666	name=`$echo "X$deplib" \| $Xsed -e 's%^.*/%%'`
	5667	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
	5668	if test -z "$libdir"; then
	5669	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
	5670	exit $EXIT_FAILURE
	5671	fi
	5672	newdependency_libs="$newdependency_libs $libdir/$name"
	5673	;;
	5674	*) newdependency_libs="$newdependency_libs $deplib" ;;
	5675	esac
	5676	done
	5677	dependency_libs="$newdependency_libs"
	5678	newdlfiles=
	5679	for lib in $dlfiles; do
	5680	name=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
	5681	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
	5682	if test -z "$libdir"; then
	5683	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
	5684	exit $EXIT_FAILURE
	5685	fi
	5686	newdlfiles="$newdlfiles $libdir/$name"
	5687	done
	5688	dlfiles="$newdlfiles"
	5689	newdlprefiles=
	5690	for lib in $dlprefiles; do
	5691	name=`$echo "X$lib" \| $Xsed -e 's%^.*/%%'`
	5692	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
	5693	if test -z "$libdir"; then
	5694	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
	5695	exit $EXIT_FAILURE
	5696	fi
	5697	newdlprefiles="$newdlprefiles $libdir/$name"
	5698	done
	5699	dlprefiles="$newdlprefiles"
	5700	else
	5701	newdlfiles=
	5702	for lib in $dlfiles; do
	5703	case $lib in
	5704	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
	5705	*) abs=`pwd`"/$lib" ;;
	5706	esac
	5707	newdlfiles="$newdlfiles $abs"
	5708	done
	5709	dlfiles="$newdlfiles"
	5710	newdlprefiles=
	5711	for lib in $dlprefiles; do
	5712	case $lib in
	5713	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
	5714	*) abs=`pwd`"/$lib" ;;
	5715	esac
	5716	newdlprefiles="$newdlprefiles $abs"
	5717	done
	5718	dlprefiles="$newdlprefiles"
	5719	fi
	5720	$rm $output
	5721	# place dlname in correct position for cygwin
	5722	tdlname=$dlname
	5723	case $host,$output,$installed,$module,$dlname in
	5724	cygwin,lai,yes,no,.dll \| mingw,lai,yes,no,.dll) tdlname=../bin/$dlname ;;
	5725	esac
	5726	$echo > $output "\
	5727	# $outputname - a libtool library file
	5728	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
	5729	#
	5730	# Please DO NOT delete this file!
	5731	# It is necessary for linking the library.
	5732
	5733	# The name that we can dlopen(3).
	5734	dlname='$tdlname'
	5735
	5736	# Names of this library.
	5737	library_names='$library_names'
	5738
	5739	# The name of the static archive.
	5740	old_library='$old_library'
	5741
	5742	# Libraries that this one depends upon.
	5743	dependency_libs='$dependency_libs'
	5744
	5745	# Version information for $libname.
	5746	current=$current
	5747	age=$age
	5748	revision=$revision
	5749
	5750	# Is this an already installed library?
	5751	installed=$installed
	5752
	5753	# Should we warn about portability when linking against -modules?
	5754	shouldnotlink=$module
	5755
	5756	# Files to dlopen/dlpreopen
	5757	dlopen='$dlfiles'
	5758	dlpreopen='$dlprefiles'
	5759
	5760	# Directory that this library needs to be installed in:
	5761	libdir='$install_libdir'"
	5762	if test "$installed" = no && test "$need_relink" = yes; then
	5763	$echo >> $output "\
	5764	relink_command=\"$relink_command\""
	5765	fi
	5766	done
	5767	fi
	5768
	5769	# Do a symbolic link so that the libtool archive can be found in
	5770	# LD_LIBRARY_PATH before the program is installed.
	5771	$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
	5772	$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' \|\| exit $?
	5773	;;
	5774	esac
	5775	exit $EXIT_SUCCESS
	5776	;;
	5777
	5778	# libtool install mode
	5779	install)
	5780	modename="$modename: install"
	5781
	5782	# There may be an optional sh(1) argument at the beginning of
	5783	# install_prog (especially on Windows NT).
	5784	if test "$nonopt" = "$SHELL" \|\| test "$nonopt" = /bin/sh \|\|
	5785	# Allow the use of GNU shtool's install command.
	5786	$echo "X$nonopt" \| grep shtool > /dev/null; then
	5787	# Aesthetically quote it.
	5788	arg=`$echo "X$nonopt" \| $Xsed -e "$sed_quote_subst"`
	5789	case $arg in
	5790	[\[\~\#\^\&\\(\)\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
	5791	arg="\"$arg\""
	5792	;;
	5793	esac
	5794	install_prog="$arg "
	5795	arg="$1"
	5796	shift
	5797	else
	5798	install_prog=
	5799	arg=$nonopt
	5800	fi
	5801
	5802	# The real first argument should be the name of the installation program.
	5803	# Aesthetically quote it.
	5804	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
	5805	case $arg in
	5806	[\[\~\#\^\&\\(\)\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
	5807	arg="\"$arg\""
	5808	;;
	5809	esac
	5810	install_prog="$install_prog$arg"
	5811
	5812	# We need to accept at least all the BSD install flags.
	5813	dest=
	5814	files=
	5815	opts=
	5816	prev=
	5817	install_type=
	5818	isdir=no
	5819	stripme=
	5820	for arg
	5821	do
	5822	if test -n "$dest"; then
	5823	files="$files $dest"
	5824	dest=$arg
	5825	continue
	5826	fi
	5827
	5828	case $arg in
	5829	-d) isdir=yes ;;
	5830	-f)
	5831	case " $install_prog " in
	5832	[\\\ /]cp\ ) ;;
	5833	*) prev=$arg ;;
	5834	esac
	5835	;;
	5836	-g \| -m \| -o) prev=$arg ;;
	5837	-s)
	5838	stripme=" -s"
	5839	continue
	5840	;;
	5841	-*)
	5842	;;
	5843	*)
	5844	# If the previous option needed an argument, then skip it.
	5845	if test -n "$prev"; then
	5846	prev=
	5847	else
	5848	dest=$arg
	5849	continue
	5850	fi
	5851	;;
	5852	esac
	5853
	5854	# Aesthetically quote the argument.
	5855	arg=`$echo "X$arg" \| $Xsed -e "$sed_quote_subst"`
	5856	case $arg in
	5857	[\[\~\#\^\&\\(\)\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
	5858	arg="\"$arg\""
	5859	;;
	5860	esac
	5861	install_prog="$install_prog $arg"
	5862	done
	5863
	5864	if test -z "$install_prog"; then
	5865	$echo "$modename: you must specify an install program" 1>&2
	5866	$echo "$help" 1>&2
	5867	exit $EXIT_FAILURE
	5868	fi
	5869
	5870	if test -n "$prev"; then
	5871	$echo "$modename: the \`$prev' option requires an argument" 1>&2
	5872	$echo "$help" 1>&2
	5873	exit $EXIT_FAILURE
	5874	fi
	5875
	5876	if test -z "$files"; then
	5877	if test -z "$dest"; then
	5878	$echo "$modename: no file or destination specified" 1>&2
	5879	else
	5880	$echo "$modename: you must specify a destination" 1>&2
	5881	fi
	5882	$echo "$help" 1>&2
	5883	exit $EXIT_FAILURE
	5884	fi
	5885
	5886	# Strip any trailing slash from the destination.
	5887	dest=`$echo "X$dest" \| $Xsed -e 's%/$%%'`
	5888
	5889	# Check to see that the destination is a directory.
	5890	test -d "$dest" && isdir=yes
	5891	if test "$isdir" = yes; then
	5892	destdir="$dest"
	5893	destname=
	5894	else
	5895	destdir=`$echo "X$dest" \| $Xsed -e 's%/[^/]*$%%'`
	5896	test "X$destdir" = "X$dest" && destdir=.
	5897	destname=`$echo "X$dest" \| $Xsed -e 's%^.*/%%'`
	5898
	5899	# Not a directory, so check to see that there is only one file specified.
	5900	set dummy $files
	5901	if test "$#" -gt 2; then
	5902	$echo "$modename: \`$dest' is not a directory" 1>&2
	5903	$echo "$help" 1>&2
	5904	exit $EXIT_FAILURE
	5905	fi
	5906	fi
	5907	case $destdir in
	5908	[\\/]* \| [A-Za-z]:[\\/]*) ;;
	5909	*)
	5910	for file in $files; do
	5911	case $file in
	5912	*.lo) ;;
	5913	*)
	5914	$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
	5915	$echo "$help" 1>&2
	5916	exit $EXIT_FAILURE
	5917	;;
	5918	esac
	5919	done
	5920	;;
	5921	esac
	5922
	5923	# This variable tells wrapper scripts just to set variables rather
	5924	# than running their programs.
	5925	libtool_install_magic="$magic"
	5926
	5927	staticlibs=
	5928	future_libdirs=
	5929	current_libdirs=
	5930	for file in $files; do
	5931
	5932	# Do each installation.
	5933	case $file in
	5934	*.$libext)
	5935	# Do the static libraries later.
	5936	staticlibs="$staticlibs $file"
	5937	;;
	5938
	5939	*.la)
	5940	# Check to see that this really is a libtool archive.
	5941	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
	5942	else
	5943	$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
	5944	$echo "$help" 1>&2
	5945	exit $EXIT_FAILURE
	5946	fi
	5947
	5948	library_names=
	5949	old_library=
	5950	relink_command=
	5951	# If there is no directory component, then add one.
	5952	case $file in
	5953	/ \| \\) . $file ;;
	5954	*) . ./$file ;;
	5955	esac
	5956
	5957	# Add the libdir to current_libdirs if it is the destination.
	5958	if test "X$destdir" = "X$libdir"; then
	5959	case "$current_libdirs " in
	5960	" $libdir ") ;;
	5961	*) current_libdirs="$current_libdirs $libdir" ;;
	5962	esac
	5963	else
	5964	# Note the libdir as a future libdir.
	5965	case "$future_libdirs " in
	5966	" $libdir ") ;;
	5967	*) future_libdirs="$future_libdirs $libdir" ;;
	5968	esac
	5969	fi
	5970
	5971	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`/
	5972	test "X$dir" = "X$file/" && dir=
	5973	dir="$dir$objdir"
	5974
	5975	if test -n "$relink_command"; then
	5976	# Determine the prefix the user has applied to our future dir.
	5977	inst_prefix_dir=`$echo "$destdir" \| $SED "s%$libdir\$%%"`
	5978
	5979	# Don't allow the user to place us outside of our expected
	5980	# location b/c this prevents finding dependent libraries that
	5981	# are installed to the same prefix.
	5982	# At present, this check doesn't affect windows .dll's that
	5983	# are installed into $libdir/../bin (currently, that works fine)
	5984	# but it's something to keep an eye on.
	5985	if test "$inst_prefix_dir" = "$destdir"; then
	5986	$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
	5987	exit $EXIT_FAILURE
	5988	fi
	5989
	5990	if test -n "$inst_prefix_dir"; then
	5991	# Stick the inst_prefix_dir data into the link command.
[6]	5992	relink_command=`$echo "$relink_command" \| $SP2NL \| $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" \| $NL2SP`
[5]	5993	else
[6]	5994	relink_command=`$echo "$relink_command" \| $SP2NL \| $SED "s%@inst_prefix_dir@%%" \| $NL2SP`
[5]	5995	fi
	5996
	5997	$echo "$modename: warning: relinking \`$file'" 1>&2
	5998	$show "$relink_command"
	5999	if $run eval "$relink_command"; then :
	6000	else
	6001	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
	6002	exit $EXIT_FAILURE
	6003	fi
	6004	fi
	6005
	6006	# See the names of the shared library.
	6007	set dummy $library_names
	6008	if test -n "$2"; then
	6009	realname="$2"
	6010	shift
	6011	shift
	6012
	6013	srcname="$realname"
	6014	test -n "$relink_command" && srcname="$realname"T
	6015
	6016	# Install the shared library and build the symlinks.
	6017	$show "$install_prog $dir/$srcname $destdir/$realname"
	6018	$run eval "$install_prog $dir/$srcname $destdir/$realname" \|\| exit $?
	6019	if test -n "$stripme" && test -n "$striplib"; then
	6020	$show "$striplib $destdir/$realname"
	6021	$run eval "$striplib $destdir/$realname" \|\| exit $?
	6022	fi
	6023
	6024	if test "$#" -gt 0; then
	6025	# Delete the old symlinks, and create new ones.
	6026	# Try `ln -sf' first, because the `ln' binary might depend on
	6027	# the symlink we replace! Solaris /bin/ln does not understand -f,
	6028	# so we also need to try rm && ln -s.
	6029	for linkname
	6030	do
	6031	if test "$linkname" != "$realname"; then
	6032	$show "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $rm $linkname && $LN_S $realname $linkname; }; })"
	6033	$run eval "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $rm $linkname && $LN_S $realname $linkname; }; })"
	6034	fi
	6035	done
	6036	fi
	6037
	6038	# Do each command in the postinstall commands.
	6039	lib="$destdir/$realname"
	6040	cmds=$postinstall_cmds
	6041	save_ifs="$IFS"; IFS='~'
	6042	for cmd in $cmds; do
	6043	IFS="$save_ifs"
	6044	eval cmd=\"$cmd\"
	6045	$show "$cmd"
	6046	$run eval "$cmd" \|\| {
	6047	lt_exit=$?
	6048
	6049	# Restore the uninstalled library and exit
	6050	if test "$mode" = relink; then
	6051	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
	6052	fi
	6053
	6054	exit $lt_exit
	6055	}
	6056	done
	6057	IFS="$save_ifs"
	6058	fi
	6059
	6060	# Install the pseudo-library for information purposes.
	6061	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
	6062	instname="$dir/$name"i
	6063	$show "$install_prog $instname $destdir/$name"
	6064	$run eval "$install_prog $instname $destdir/$name" \|\| exit $?
	6065
	6066	# Maybe install the static library, too.
	6067	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
	6068	;;
	6069
	6070	*.lo)
	6071	# Install (i.e. copy) a libtool object.
	6072
	6073	# Figure out destination file name, if it wasn't already specified.
	6074	if test -n "$destname"; then
	6075	destfile="$destdir/$destname"
	6076	else
	6077	destfile=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
	6078	destfile="$destdir/$destfile"
	6079	fi
	6080
	6081	# Deduce the name of the destination old-style object file.
	6082	case $destfile in
	6083	*.lo)
	6084	staticdest=`$echo "X$destfile" \| $Xsed -e "$lo2o"`
	6085	;;
	6086	*.$objext)
	6087	staticdest="$destfile"
	6088	destfile=
	6089	;;
	6090	*)
	6091	$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
	6092	$echo "$help" 1>&2
	6093	exit $EXIT_FAILURE
	6094	;;
	6095	esac
	6096
	6097	# Install the libtool object if requested.
	6098	if test -n "$destfile"; then
	6099	$show "$install_prog $file $destfile"
	6100	$run eval "$install_prog $file $destfile" \|\| exit $?
	6101	fi
	6102
	6103	# Install the old object if enabled.
	6104	if test "$build_old_libs" = yes; then
	6105	# Deduce the name of the old-style object file.
	6106	staticobj=`$echo "X$file" \| $Xsed -e "$lo2o"`
	6107
	6108	$show "$install_prog $staticobj $staticdest"
	6109	$run eval "$install_prog \$staticobj \$staticdest" \|\| exit $?
	6110	fi
	6111	exit $EXIT_SUCCESS
	6112	;;
	6113
	6114	*)
	6115	# Figure out destination file name, if it wasn't already specified.
	6116	if test -n "$destname"; then
	6117	destfile="$destdir/$destname"
	6118	else
	6119	destfile=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
	6120	destfile="$destdir/$destfile"
	6121	fi
	6122
	6123	# If the file is missing, and there is a .exe on the end, strip it
	6124	# because it is most likely a libtool script we actually want to
	6125	# install
	6126	stripped_ext=""
	6127	case $file in
	6128	*.exe)
	6129	if test ! -f "$file"; then
	6130	file=`$echo $file\|${SED} 's,.exe$,,'`
	6131	stripped_ext=".exe"
	6132	fi
	6133	;;
	6134	esac
	6135
	6136	# Do a test to see if this is really a libtool program.
	6137	case $host in
	6138	cygwin\|mingw)
	6139	wrapper=`$echo $file \| ${SED} -e 's,.exe$,,'`
	6140	;;
	6141	*)
	6142	wrapper=$file
	6143	;;
	6144	esac
	6145	if (${SED} -e '4q' $wrapper \| grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
	6146	notinst_deplibs=
	6147	relink_command=
	6148
	6149	# Note that it is not necessary on cygwin/mingw to append a dot to
	6150	# foo even if both foo and FILE.exe exist: automatic-append-.exe
	6151	# behavior happens only for exec(3), not for open(2)! Also, sourcing
	6152	# `FILE.' does not work on cygwin managed mounts.
	6153	#
	6154	# If there is no directory component, then add one.
	6155	case $wrapper in
	6156	/ \| \\) . ${wrapper} ;;
	6157	*) . ./${wrapper} ;;
	6158	esac
	6159
	6160	# Check the variables that should have been set.
	6161	if test -z "$notinst_deplibs"; then
	6162	$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
	6163	exit $EXIT_FAILURE
	6164	fi
	6165
	6166	finalize=yes
	6167	for lib in $notinst_deplibs; do
	6168	# Check to see that each library is installed.
	6169	libdir=
	6170	if test -f "$lib"; then
	6171	# If there is no directory component, then add one.
	6172	case $lib in
	6173	/ \| \\) . $lib ;;
	6174	*) . ./$lib ;;
	6175	esac
	6176	fi
	6177	libfile="$libdir/"`$echo "X$lib" \| $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
	6178	if test -n "$libdir" && test ! -f "$libfile"; then
	6179	$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
	6180	finalize=no
	6181	fi
	6182	done
	6183
	6184	relink_command=
	6185	# Note that it is not necessary on cygwin/mingw to append a dot to
	6186	# foo even if both foo and FILE.exe exist: automatic-append-.exe
	6187	# behavior happens only for exec(3), not for open(2)! Also, sourcing
	6188	# `FILE.' does not work on cygwin managed mounts.
	6189	#
	6190	# If there is no directory component, then add one.
	6191	case $wrapper in
	6192	/ \| \\) . ${wrapper} ;;
	6193	*) . ./${wrapper} ;;
	6194	esac
	6195
	6196	outputname=
	6197	if test "$fast_install" = no && test -n "$relink_command"; then
	6198	if test "$finalize" = yes && test -z "$run"; then
[6]	6199	tmpdir=`func_mktempdir`
[5]	6200	file=`$echo "X$file$stripped_ext" \| $Xsed -e 's%^.*/%%'`
	6201	outputname="$tmpdir/$file"
	6202	# Replace the output file specification.
[6]	6203	relink_command=`$echo "X$relink_command" \| $SP2NL \| $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' \| $NL2SP`
[5]	6204
	6205	$show "$relink_command"
	6206	if $run eval "$relink_command"; then :
	6207	else
	6208	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
	6209	${rm}r "$tmpdir"
	6210	continue
	6211	fi
	6212	file="$outputname"
	6213	else
	6214	$echo "$modename: warning: cannot relink \`$file'" 1>&2
	6215	fi
	6216	else
	6217	# Install the binary that we compiled earlier.
	6218	file=`$echo "X$file$stripped_ext" \| $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
	6219	fi
	6220	fi
	6221
	6222	# remove .exe since cygwin /usr/bin/install will append another
	6223	# one anyway
	6224	case $install_prog,$host in
	6225	/usr/bin/install,cygwin)
	6226	case $file:$destfile in
	6227	.exe:.exe)
	6228	# this is ok
	6229	;;
	6230	.exe:)
	6231	destfile=$destfile.exe
	6232	;;
	6233	:.exe)
	6234	destfile=`$echo $destfile \| ${SED} -e 's,.exe$,,'`
	6235	;;
	6236	esac
	6237	;;
	6238	esac
	6239	$show "$install_prog$stripme $file $destfile"
	6240	$run eval "$install_prog\$stripme \$file \$destfile" \|\| exit $?
	6241	test -n "$outputname" && ${rm}r "$tmpdir"
	6242	;;
	6243	esac
	6244	done
	6245
	6246	for file in $staticlibs; do
	6247	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
	6248
	6249	# Set up the ranlib parameters.
	6250	oldlib="$destdir/$name"
	6251
	6252	$show "$install_prog $file $oldlib"
	6253	$run eval "$install_prog \$file \$oldlib" \|\| exit $?
	6254
	6255	if test -n "$stripme" && test -n "$old_striplib"; then
	6256	$show "$old_striplib $oldlib"
	6257	$run eval "$old_striplib $oldlib" \|\| exit $?
	6258	fi
	6259
	6260	# Do each command in the postinstall commands.
	6261	cmds=$old_postinstall_cmds
	6262	save_ifs="$IFS"; IFS='~'
	6263	for cmd in $cmds; do
	6264	IFS="$save_ifs"
	6265	eval cmd=\"$cmd\"
	6266	$show "$cmd"
	6267	$run eval "$cmd" \|\| exit $?
	6268	done
	6269	IFS="$save_ifs"
	6270	done
	6271
	6272	if test -n "$future_libdirs"; then
	6273	$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
	6274	fi
	6275
	6276	if test -n "$current_libdirs"; then
	6277	# Maybe just do a dry run.
	6278	test -n "$run" && current_libdirs=" -n$current_libdirs"
	6279	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
	6280	else
	6281	exit $EXIT_SUCCESS
	6282	fi
	6283	;;
	6284
	6285	# libtool finish mode
	6286	finish)
	6287	modename="$modename: finish"
	6288	libdirs="$nonopt"
	6289	admincmds=
	6290
	6291	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
	6292	for dir
	6293	do
	6294	libdirs="$libdirs $dir"
	6295	done
	6296
	6297	for libdir in $libdirs; do
	6298	if test -n "$finish_cmds"; then
	6299	# Do each command in the finish commands.
	6300	cmds=$finish_cmds
	6301	save_ifs="$IFS"; IFS='~'
	6302	for cmd in $cmds; do
	6303	IFS="$save_ifs"
	6304	eval cmd=\"$cmd\"
	6305	$show "$cmd"
	6306	$run eval "$cmd" \|\| admincmds="$admincmds
	6307	$cmd"
	6308	done
	6309	IFS="$save_ifs"
	6310	fi
	6311	if test -n "$finish_eval"; then
	6312	# Do the single finish_eval.
	6313	eval cmds=\"$finish_eval\"
	6314	$run eval "$cmds" \|\| admincmds="$admincmds
	6315	$cmds"
	6316	fi
	6317	done
	6318	fi
	6319
	6320	# Exit here if they wanted silent mode.
	6321	test "$show" = : && exit $EXIT_SUCCESS
	6322
[6]	6323	$echo "X----------------------------------------------------------------------" \| $Xsed
[5]	6324	$echo "Libraries have been installed in:"
	6325	for libdir in $libdirs; do
	6326	$echo " $libdir"
	6327	done
	6328	$echo
	6329	$echo "If you ever happen to want to link against installed libraries"
	6330	$echo "in a given directory, LIBDIR, you must either use libtool, and"
	6331	$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
	6332	$echo "flag during linking and do at least one of the following:"
	6333	if test -n "$shlibpath_var"; then
	6334	$echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
	6335	$echo " during execution"
	6336	fi
	6337	if test -n "$runpath_var"; then
	6338	$echo " - add LIBDIR to the \`$runpath_var' environment variable"
	6339	$echo " during linking"
	6340	fi
	6341	if test -n "$hardcode_libdir_flag_spec"; then
	6342	libdir=LIBDIR
	6343	eval flag=\"$hardcode_libdir_flag_spec\"
	6344
	6345	$echo " - use the \`$flag' linker flag"
	6346	fi
	6347	if test -n "$admincmds"; then
	6348	$echo " - have your system administrator run these commands:$admincmds"
	6349	fi
	6350	if test -f /etc/ld.so.conf; then
	6351	$echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
	6352	fi
	6353	$echo
	6354	$echo "See any operating system documentation about shared libraries for"
	6355	$echo "more information, such as the ld(1) and ld.so(8) manual pages."
[6]	6356	$echo "X----------------------------------------------------------------------" \| $Xsed
[5]	6357	exit $EXIT_SUCCESS
	6358	;;
	6359
	6360	# libtool execute mode
	6361	execute)
	6362	modename="$modename: execute"
	6363
	6364	# The first argument is the command name.
	6365	cmd="$nonopt"
	6366	if test -z "$cmd"; then
	6367	$echo "$modename: you must specify a COMMAND" 1>&2
	6368	$echo "$help"
	6369	exit $EXIT_FAILURE
	6370	fi
	6371
	6372	# Handle -dlopen flags immediately.
	6373	for file in $execute_dlfiles; do
	6374	if test ! -f "$file"; then
	6375	$echo "$modename: \`$file' is not a file" 1>&2
	6376	$echo "$help" 1>&2
	6377	exit $EXIT_FAILURE
	6378	fi
	6379
	6380	dir=
	6381	case $file in
	6382	*.la)
	6383	# Check to see that this really is a libtool archive.
	6384	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
	6385	else
	6386	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
	6387	$echo "$help" 1>&2
	6388	exit $EXIT_FAILURE
	6389	fi
	6390
	6391	# Read the libtool library.
	6392	dlname=
	6393	library_names=
	6394
	6395	# If there is no directory component, then add one.
	6396	case $file in
	6397	/ \| \\) . $file ;;
	6398	*) . ./$file ;;
	6399	esac
	6400
	6401	# Skip this library if it cannot be dlopened.
	6402	if test -z "$dlname"; then
	6403	# Warn if it was a shared library.
	6404	test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
	6405	continue
	6406	fi
	6407
	6408	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
	6409	test "X$dir" = "X$file" && dir=.
	6410
	6411	if test -f "$dir/$objdir/$dlname"; then
	6412	dir="$dir/$objdir"
	6413	else
[6]	6414	if test ! -f "$dir/$dlname"; then
	6415	$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
	6416	exit $EXIT_FAILURE
	6417	fi
[5]	6418	fi
	6419	;;
	6420
	6421	*.lo)
	6422	# Just add the directory containing the .lo file.
	6423	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
	6424	test "X$dir" = "X$file" && dir=.
	6425	;;
	6426
	6427	*)
	6428	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
	6429	continue
	6430	;;
	6431	esac
	6432
	6433	# Get the absolute pathname.
	6434	absdir=`cd "$dir" && pwd`
	6435	test -n "$absdir" && dir="$absdir"
	6436
	6437	# Now add the directory to shlibpath_var.
	6438	if eval "test -z \"\$$shlibpath_var\""; then
	6439	eval "$shlibpath_var=\"\$dir\""
	6440	else
	6441	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
	6442	fi
	6443	done
	6444
	6445	# This variable tells wrapper scripts just to set shlibpath_var
	6446	# rather than running their programs.
	6447	libtool_execute_magic="$magic"
	6448
	6449	# Check if any of the arguments is a wrapper script.
	6450	args=
	6451	for file
	6452	do
	6453	case $file in
	6454	-*) ;;
	6455	*)
	6456	# Do a test to see if this is really a libtool program.
	6457	if (${SED} -e '4q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	6458	# If there is no directory component, then add one.
	6459	case $file in
	6460	/ \| \\) . $file ;;
	6461	*) . ./$file ;;
	6462	esac
	6463
	6464	# Transform arg to wrapped name.
	6465	file="$progdir/$program"
	6466	fi
	6467	;;
	6468	esac
	6469	# Quote arguments (to preserve shell metacharacters).
	6470	file=`$echo "X$file" \| $Xsed -e "$sed_quote_subst"`
	6471	args="$args \"$file\""
	6472	done
	6473
	6474	if test -z "$run"; then
	6475	if test -n "$shlibpath_var"; then
	6476	# Export the shlibpath_var.
	6477	eval "export $shlibpath_var"
	6478	fi
	6479
	6480	# Restore saved environment variables
[6]	6481	for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
	6482	do
	6483	eval "if test \"\${save_$lt_var+set}\" = set; then
	6484	$lt_var=\$save_$lt_var; export $lt_var
	6485	fi"
	6486	done
[5]	6487
	6488	# Now prepare to actually exec the command.
	6489	exec_cmd="\$cmd$args"
	6490	else
	6491	# Display what would be done.
	6492	if test -n "$shlibpath_var"; then
	6493	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
	6494	$echo "export $shlibpath_var"
	6495	fi
	6496	$echo "$cmd$args"
	6497	exit $EXIT_SUCCESS
	6498	fi
	6499	;;
	6500
	6501	# libtool clean and uninstall mode
	6502	clean \| uninstall)
	6503	modename="$modename: $mode"
	6504	rm="$nonopt"
	6505	files=
	6506	rmforce=
	6507	exit_status=0
	6508
	6509	# This variable tells wrapper scripts just to set variables rather
	6510	# than running their programs.
	6511	libtool_install_magic="$magic"
	6512
	6513	for arg
	6514	do
	6515	case $arg in
	6516	-f) rm="$rm $arg"; rmforce=yes ;;
	6517	-*) rm="$rm $arg" ;;
	6518	*) files="$files $arg" ;;
	6519	esac
	6520	done
	6521
	6522	if test -z "$rm"; then
	6523	$echo "$modename: you must specify an RM program" 1>&2
	6524	$echo "$help" 1>&2
	6525	exit $EXIT_FAILURE
	6526	fi
	6527
	6528	rmdirs=
	6529
	6530	origobjdir="$objdir"
	6531	for file in $files; do
	6532	dir=`$echo "X$file" \| $Xsed -e 's%/[^/]*$%%'`
	6533	if test "X$dir" = "X$file"; then
	6534	dir=.
	6535	objdir="$origobjdir"
	6536	else
	6537	objdir="$dir/$origobjdir"
	6538	fi
	6539	name=`$echo "X$file" \| $Xsed -e 's%^.*/%%'`
	6540	test "$mode" = uninstall && objdir="$dir"
	6541
	6542	# Remember objdir for removal later, being careful to avoid duplicates
	6543	if test "$mode" = clean; then
	6544	case " $rmdirs " in
	6545	" $objdir ") ;;
	6546	*) rmdirs="$rmdirs $objdir" ;;
	6547	esac
	6548	fi
	6549
	6550	# Don't error if the file doesn't exist and rm -f was used.
	6551	if (test -L "$file") >/dev/null 2>&1 \
	6552	\|\| (test -h "$file") >/dev/null 2>&1 \
	6553	\|\| test -f "$file"; then
	6554	:
	6555	elif test -d "$file"; then
	6556	exit_status=1
	6557	continue
	6558	elif test "$rmforce" = yes; then
	6559	continue
	6560	fi
	6561
	6562	rmfiles="$file"
	6563
	6564	case $name in
	6565	*.la)
	6566	# Possibly a libtool archive, so verify it.
	6567	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	6568	. $dir/$name
	6569
	6570	# Delete the libtool libraries and symlinks.
	6571	for n in $library_names; do
	6572	rmfiles="$rmfiles $objdir/$n"
	6573	done
	6574	test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
	6575
[6]	6576	case "$mode" in
	6577	clean)
	6578	case " $library_names " in
	6579	# " " in the beginning catches empty $dlname
	6580	" $dlname ") ;;
	6581	*) rmfiles="$rmfiles $objdir/$dlname" ;;
	6582	esac
	6583	test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
	6584	;;
	6585	uninstall)
[5]	6586	if test -n "$library_names"; then
	6587	# Do each command in the postuninstall commands.
	6588	cmds=$postuninstall_cmds
	6589	save_ifs="$IFS"; IFS='~'
	6590	for cmd in $cmds; do
	6591	IFS="$save_ifs"
	6592	eval cmd=\"$cmd\"
	6593	$show "$cmd"
	6594	$run eval "$cmd"
	6595	if test "$?" -ne 0 && test "$rmforce" != yes; then
	6596	exit_status=1
	6597	fi
	6598	done
	6599	IFS="$save_ifs"
	6600	fi
	6601
	6602	if test -n "$old_library"; then
	6603	# Do each command in the old_postuninstall commands.
	6604	cmds=$old_postuninstall_cmds
	6605	save_ifs="$IFS"; IFS='~'
	6606	for cmd in $cmds; do
	6607	IFS="$save_ifs"
	6608	eval cmd=\"$cmd\"
	6609	$show "$cmd"
	6610	$run eval "$cmd"
	6611	if test "$?" -ne 0 && test "$rmforce" != yes; then
	6612	exit_status=1
	6613	fi
	6614	done
	6615	IFS="$save_ifs"
	6616	fi
	6617	# FIXME: should reinstall the best remaining shared library.
[6]	6618	;;
	6619	esac
[5]	6620	fi
	6621	;;
	6622
	6623	*.lo)
	6624	# Possibly a libtool object, so verify it.
	6625	if (${SED} -e '2q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	6626
	6627	# Read the .lo file
	6628	. $dir/$name
	6629
	6630	# Add PIC object to the list of files to remove.
	6631	if test -n "$pic_object" \
	6632	&& test "$pic_object" != none; then
	6633	rmfiles="$rmfiles $dir/$pic_object"
	6634	fi
	6635
	6636	# Add non-PIC object to the list of files to remove.
	6637	if test -n "$non_pic_object" \
	6638	&& test "$non_pic_object" != none; then
	6639	rmfiles="$rmfiles $dir/$non_pic_object"
	6640	fi
	6641	fi
	6642	;;
	6643
	6644	*)
	6645	if test "$mode" = clean ; then
	6646	noexename=$name
	6647	case $file in
	6648	*.exe)
	6649	file=`$echo $file\|${SED} 's,.exe$,,'`
	6650	noexename=`$echo $name\|${SED} 's,.exe$,,'`
	6651	# $file with .exe has already been added to rmfiles,
	6652	# add $file without .exe
	6653	rmfiles="$rmfiles $file"
	6654	;;
	6655	esac
	6656	# Do a test to see if this is a libtool program.
	6657	if (${SED} -e '4q' $file \| grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
	6658	relink_command=
	6659	. $dir/$noexename
	6660
	6661	# note $name still contains .exe if it was in $file originally
	6662	# as does the version of $file that was added into $rmfiles
	6663	rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
	6664	if test "$fast_install" = yes && test -n "$relink_command"; then
	6665	rmfiles="$rmfiles $objdir/lt-$name"
	6666	fi
	6667	if test "X$noexename" != "X$name" ; then
	6668	rmfiles="$rmfiles $objdir/lt-${noexename}.c"
	6669	fi
	6670	fi
	6671	fi
	6672	;;
	6673	esac
	6674	$show "$rm $rmfiles"
	6675	$run $rm $rmfiles \|\| exit_status=1
	6676	done
	6677	objdir="$origobjdir"
	6678
	6679	# Try to remove the ${objdir}s in the directories where we deleted files
	6680	for dir in $rmdirs; do
	6681	if test -d "$dir"; then
	6682	$show "rmdir $dir"
	6683	$run rmdir $dir >/dev/null 2>&1
	6684	fi
	6685	done
	6686
	6687	exit $exit_status
	6688	;;
	6689
	6690	"")
	6691	$echo "$modename: you must specify a MODE" 1>&2
	6692	$echo "$generic_help" 1>&2
	6693	exit $EXIT_FAILURE
	6694	;;
	6695	esac
	6696
	6697	if test -z "$exec_cmd"; then
	6698	$echo "$modename: invalid operation mode \`$mode'" 1>&2
	6699	$echo "$generic_help" 1>&2
	6700	exit $EXIT_FAILURE
	6701	fi
	6702	fi # test -z "$show_help"
	6703
	6704	if test -n "$exec_cmd"; then
	6705	eval exec $exec_cmd
	6706	exit $EXIT_FAILURE
	6707	fi
	6708
	6709	# We need to display help for each of the modes.
	6710	case $mode in
	6711	"") $echo \
	6712	"Usage: $modename [OPTION]... [MODE-ARG]...
	6713
	6714	Provide generalized library-building support services.
	6715
	6716	--config show all configuration variables
	6717	--debug enable verbose shell tracing
	6718	-n, --dry-run display commands without modifying any files
	6719	--features display basic configuration information and exit
	6720	--finish same as \`--mode=finish'
	6721	--help display this help message and exit
	6722	--mode=MODE use operation mode MODE [default=inferred from MODE-ARGS]
	6723	--quiet same as \`--silent'
	6724	--silent don't print informational messages
	6725	--tag=TAG use configuration variables from tag TAG
	6726	--version print version information
	6727
	6728	MODE must be one of the following:
	6729
	6730	clean remove files from the build directory
	6731	compile compile a source file into a libtool object
	6732	execute automatically set library path, then run a program
	6733	finish complete the installation of libtool libraries
	6734	install install libraries or executables
	6735	link create a library or an executable
	6736	uninstall remove libraries from an installed directory
	6737
	6738	MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for
	6739	a more detailed description of MODE.
	6740
	6741	Report bugs to <bug-libtool@gnu.org>."
	6742	exit $EXIT_SUCCESS
	6743	;;
	6744
	6745	clean)
	6746	$echo \
	6747	"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
	6748
	6749	Remove files from the build directory.
	6750
	6751	RM is the name of the program to use to delete files associated with each FILE
	6752	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
	6753	to RM.
	6754
	6755	If FILE is a libtool library, object or program, all the files associated
	6756	with it are deleted. Otherwise, only FILE itself is deleted using RM."
	6757	;;
	6758
	6759	compile)
	6760	$echo \
	6761	"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
	6762
	6763	Compile a source file into a libtool library object.
	6764
	6765	This mode accepts the following additional options:
	6766
	6767	-o OUTPUT-FILE set the output file name to OUTPUT-FILE
	6768	-prefer-pic try to building PIC objects only
	6769	-prefer-non-pic try to building non-PIC objects only
	6770	-static always build a \`.o' file suitable for static linking
	6771
	6772	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
	6773	from the given SOURCEFILE.
	6774
	6775	The output file name is determined by removing the directory component from
	6776	SOURCEFILE, then substituting the C source code suffix \`.c' with the
	6777	library object suffix, \`.lo'."
	6778	;;
	6779
	6780	execute)
	6781	$echo \
	6782	"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
	6783
	6784	Automatically set library path, then run a program.
	6785
	6786	This mode accepts the following additional options:
	6787
	6788	-dlopen FILE add the directory containing FILE to the library path
	6789
	6790	This mode sets the library path environment variable according to \`-dlopen'
	6791	flags.
	6792
	6793	If any of the ARGS are libtool executable wrappers, then they are translated
	6794	into their corresponding uninstalled binary, and any of their required library
	6795	directories are added to the library path.
	6796
	6797	Then, COMMAND is executed, with ARGS as arguments."
	6798	;;
	6799
	6800	finish)
	6801	$echo \
	6802	"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
	6803
	6804	Complete the installation of libtool libraries.
	6805
	6806	Each LIBDIR is a directory that contains libtool libraries.
	6807
	6808	The commands that this mode executes may require superuser privileges. Use
	6809	the \`--dry-run' option if you just want to see what would be executed."
	6810	;;
	6811
	6812	install)
	6813	$echo \
	6814	"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
	6815
	6816	Install executables or libraries.
	6817
	6818	INSTALL-COMMAND is the installation command. The first component should be
	6819	either the \`install' or \`cp' program.
	6820
	6821	The rest of the components are interpreted as arguments to that command (only
	6822	BSD-compatible install options are recognized)."
	6823	;;
	6824
	6825	link)
	6826	$echo \
	6827	"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
	6828
	6829	Link object files or libraries together to form another library, or to
	6830	create an executable program.
	6831
	6832	LINK-COMMAND is a command using the C compiler that you would use to create
	6833	a program from several object files.
	6834
	6835	The following components of LINK-COMMAND are treated specially:
	6836
	6837	-all-static do not do any dynamic linking at all
	6838	-avoid-version do not add a version suffix if possible
	6839	-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
	6840	-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
	6841	-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
	6842	-export-symbols SYMFILE
[6]	6843	try to export only the symbols listed in SYMFILE
[5]	6844	-export-symbols-regex REGEX
[6]	6845	try to export only the symbols matching REGEX
[5]	6846	-LLIBDIR search LIBDIR for required installed libraries
	6847	-lNAME OUTPUT-FILE requires the installed library libNAME
	6848	-module build a library that can dlopened
	6849	-no-fast-install disable the fast-install mode
	6850	-no-install link a not-installable executable
	6851	-no-undefined declare that a library does not refer to external symbols
	6852	-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
	6853	-objectlist FILE Use a list of object files found in FILE to specify objects
	6854	-precious-files-regex REGEX
	6855	don't remove output files matching REGEX
	6856	-release RELEASE specify package release information
	6857	-rpath LIBDIR the created library will eventually be installed in LIBDIR
	6858	-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
[6]	6859	-static do not do any dynamic linking of uninstalled libtool libraries
	6860	-static-libtool-libs
	6861	do not do any dynamic linking of libtool libraries
[5]	6862	-version-info CURRENT[:REVISION[:AGE]]
[6]	6863	specify library version info [each variable defaults to 0]
[5]	6864
	6865	All other options (arguments beginning with \`-') are ignored.
	6866
	6867	Every other argument is treated as a filename. Files ending in \`.la' are
	6868	treated as uninstalled libtool libraries, other files are standard or library
	6869	object files.
	6870
	6871	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
	6872	only library objects (\`.lo' files) may be specified, and \`-rpath' is
	6873	required, except when creating a convenience library.
	6874
	6875	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
	6876	using \`ar' and \`ranlib', or on Windows using \`lib'.
	6877
	6878	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
	6879	is created, otherwise an executable program is created."
	6880	;;
	6881
	6882	uninstall)
	6883	$echo \
	6884	"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
	6885
	6886	Remove libraries from an installation directory.
	6887
	6888	RM is the name of the program to use to delete files associated with each FILE
	6889	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
	6890	to RM.
	6891
	6892	If FILE is a libtool library, all the files associated with it are deleted.
	6893	Otherwise, only FILE itself is deleted using RM."
	6894	;;
	6895
	6896	*)
	6897	$echo "$modename: invalid operation mode \`$mode'" 1>&2
	6898	$echo "$help" 1>&2
	6899	exit $EXIT_FAILURE
	6900	;;
	6901	esac
	6902
	6903	$echo
	6904	$echo "Try \`$modename --help' for more information about other modes."
	6905
	6906	exit $?
	6907
	6908	# The TAGs below are defined such that we never get into a situation
	6909	# in which we disable both kinds of libraries. Given conflicting
	6910	# choices, we go for a static library, that is the most portable,
	6911	# since we can't tell whether shared libraries were disabled because
	6912	# the user asked for that or because the platform doesn't support
	6913	# them. This is particularly important on AIX, because we don't
	6914	# support having both static and shared libraries enabled at the same
	6915	# time on that platform, so we default to a shared-only configuration.
	6916	# If a disable-shared tag is given, we'll fallback to a static-only
	6917	# configuration. But we'll never go from static-only to shared-only.
	6918
	6919	# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
[6]	6920	disable_libs=shared
[5]	6921	# ### END LIBTOOL TAG CONFIG: disable-shared
	6922
	6923	# ### BEGIN LIBTOOL TAG CONFIG: disable-static
[6]	6924	disable_libs=static
[5]	6925	# ### END LIBTOOL TAG CONFIG: disable-static
	6926
	6927	# Local Variables:
	6928	# mode:shell-script
	6929	# sh-indentation:2
	6930	# End:

Note: See TracBrowser for help on using the repository browser.

Download in other formats: