Please file new bugs on Launchpad: Invirt or XVM (if you're not sure which, just pick one)

Context Navigation

source: trunk/packages/libyaml/config/ltmain.sh @ 1556

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

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

Download in other formats: