Context Navigation

ltmain.sh @ 20776

Visit:

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

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

Context Navigation

source: trunk/third/atk/ltmain.sh @ 20776

Download in other formats: