Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/Taper/admin/ltmain.sh@ 7764

Visit:

Last change on this file since 7764 was 4307, checked in by merck, 20 years ago
new project
File size: 178.0 KB

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

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

Download in other formats: