Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

ltmain.sh @ 21079

Visit:

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

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

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

Context Navigation

source: trunk/third/gnome-nettool/ltmain.sh @ 21079

Download in other formats: