Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/ogre/ltmain.sh @ 44

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

File size: 194.3 KB

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

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

Download in other formats: