Context Navigation

Back to Ticket #1057

Ticket #1057: ltmain.sh

File ltmain.sh, 191.8 KB (added by Michael Wood-Vasey, 18 years ago)
Updated ltmain.sh for libtool configuration

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

Download in other formats:

Original Format