Context Navigation

ltmain.sh @ 21744

Visit:

Revision 21744, 179.1 KB checked in by ghudson, 20 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r21743, which included commits to RCS files with non-trunk default branches.

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

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

Context Navigation

source: trunk/third/bind/ltmain.sh @ 21744

Download in other formats: