Context Navigation

source: trunk/binutils/ltmain.sh@ 3875

Visit:

Last change on this file since 3875 was 1136, checked in by bird, 22 years ago
No freaking relinking on OS/2 please (it never works and shouldn't be needed!).
Property cvs2svn:cvs-rev set to `1.2` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 152.8 KB

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

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

Download in other formats: