Context Navigation

source: ltmain.sh @ 77494e7

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+

Last change on this file since 77494e7 was d17f63e, checked in by Paul Brossier <piem@altern.org>, 20 years ago
added -lmx on macosx
Property mode set to `100644`
File size: 179.6 KB

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

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

Download in other formats: