Please file new bugs on Launchpad: Invirt or XVM (if you're not sure which, just pick one)

Context Navigation

source: trunk/packages/libyaml/config/ltmain.sh @ 1157

Last change on this file since 1157 was 898, checked in by hartmans, 16 years ago
Add pyyaml and libyaml packages backported from lenny. There is discussion about how these should go in the repository; these are added in this form in order to make forward progress.
File size: 192.1 KB

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

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

Download in other formats: