ltmain.sh@ 21747

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

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

source: vbox/trunk/src/libs/libxslt-1.1.22/ltmain.sh@ 21747

Download in other formats: