Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

ltmain.sh @ 458

Last change on this file since 458 was 444, checked in by satin@…, 7 years ago
add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc
File size: 243.9 KB

Line
1	# Generated from ltmain.m4sh.
2
3	# libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
4	# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5
6	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
7	# 2007, 2008, 2009 Free Software Foundation, Inc.
8	# This is free software; see the source for copying conditions. There is NO
9	# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10
11	# GNU Libtool is free software; you can redistribute it and/or modify
12	# it under the terms of the GNU General Public License as published by
13	# the Free Software Foundation; either version 2 of the License, or
14	# (at your option) any later version.
15	#
16	# As a special exception to the GNU General Public License,
17	# if you distribute this file as part of a program or library that
18	# is built using GNU Libtool, you may include this file under the
19	# same distribution terms that you use for the rest of that program.
20	#
21	# GNU Libtool is distributed in the hope that it will be useful, but
22	# WITHOUT ANY WARRANTY; without even the implied warranty of
23	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24	# General Public License for more details.
25	#
26	# You should have received a copy of the GNU General Public License
27	# along with GNU Libtool; see the file COPYING. If not, a copy
28	# can be downloaded from http://www.gnu.org/licenses/gpl.html,
29	# or obtained by writing to the Free Software Foundation, Inc.,
30	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31
32	# Usage: $progname [OPTION]... [MODE-ARG]...
33	#
34	# Provide generalized library-building support services.
35	#
36	# --config show all configuration variables
37	# --debug enable verbose shell tracing
38	# -n, --dry-run display commands without modifying any files
39	# --features display basic configuration information and exit
40	# --mode=MODE use operation mode MODE
41	# --no-finish let install mode avoid finish commands
42	# --preserve-dup-deps don't remove duplicate dependency libraries
43	# --quiet, --silent don't print informational messages
44	# --no-quiet, --no-silent
45	# print informational messages (default)
46	# --tag=TAG use configuration variables from tag TAG
47	# -v, --verbose print more informational messages than default
48	# --no-verbose don't print the extra informational messages
49	# --version print version information
50	# -h, --help, --help-all print short, long, or detailed help message
51	#
52	# MODE must be one of the following:
53	#
54	# clean remove files from the build directory
55	# compile compile a source file into a libtool object
56	# execute automatically set library path, then run a program
57	# finish complete the installation of libtool libraries
58	# install install libraries or executables
59	# link create a library or an executable
60	# uninstall remove libraries from an installed directory
61	#
62	# MODE-ARGS vary depending on the MODE. When passed as first option,
63	# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
64	# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
65	#
66	# When reporting a bug, please describe a test case to reproduce it and
67	# include the following information:
68	#
69	# host-triplet: $host
70	# shell: $SHELL
71	# compiler: $LTCC
72	# compiler flags: $LTCFLAGS
73	# linker: $LD (gnu? $with_gnu_ld)
74	# $progname: (GNU libtool 1.3134 2009-11-29) 2.2.7a
75	# automake: $automake_version
76	# autoconf: $autoconf_version
77	#
78	# Report bugs to <bug-libtool@gnu.org>.
79
80	PROGRAM=libtool
81	PACKAGE=libtool
82	VERSION=2.2.7a
83	TIMESTAMP=" 1.3134 2009-11-29"
84	package_revision=1.3134
85
86	# Be Bourne compatible
87	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
88	emulate sh
89	NULLCMD=:
90	# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91	# is contrary to our usage. Disable this feature.
92	alias -g '${1+"$@"}'='"$@"'
93	setopt NO_GLOB_SUBST
94	else
95	case `(set -o) 2>/dev/null` in posix) set -o posix;; esac
96	fi
97	BIN_SH=xpg4; export BIN_SH # for Tru64
98	DUALCASE=1; export DUALCASE # for MKS sh
99
100	# A function that is used when there is no print builtin or printf.
101	func_fallback_echo ()
102	{
103	eval 'cat <<_LTECHO_EOF
104	$1
105	_LTECHO_EOF'
106	}
107
108	# NLS nuisances: We save the old values to restore during execute mode.
109	# Only set LANG and LC_ALL to C if already set.
110	# These must not be set unconditionally because not all systems understand
111	# e.g. LANG=C (notably SCO).
112	lt_user_locale=
113	lt_safe_locale=
114	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
115	do
116	eval "if test \"\${$lt_var+set}\" = set; then
117	save_$lt_var=\$$lt_var
118	$lt_var=C
119	export $lt_var
120	lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
121	lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
122	fi"
123	done
124
125	$lt_unset CDPATH
126
127
128
129
130
131
132
133	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
134	# is ksh but when the shell is invoked as "sh" and the current value of
135	# the _XPG environment variable is not equal to 1 (one), the special
136	# positional parameter $0, within a function call, is the name of the
137	# function.
138	progpath="$0"
139
140
141
142	: ${CP="cp -f"}
143	: ${ECHO=$as_echo}
144	: ${EGREP="/bin/grep -E"}
145	: ${FGREP="/bin/grep -F"}
146	: ${GREP="/bin/grep"}
147	: ${LN_S="ln -s"}
148	: ${MAKE="make"}
149	: ${MKDIR="mkdir"}
150	: ${MV="mv -f"}
151	: ${RM="rm -f"}
152	: ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"}
153	: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
154	: ${Xsed="$SED -e 1s/^X//"}
155
156	# Global variables:
157	EXIT_SUCCESS=0
158	EXIT_FAILURE=1
159	EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
160	EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
161
162	exit_status=$EXIT_SUCCESS
163
164	# Make sure IFS has a sensible default
165	lt_nl='
166	'
167	IFS=" $lt_nl"
168
169	dirname="s,/[^/]*$,,"
170	basename="s,^.*/,,"
171
172	# func_dirname_and_basename file append nondir_replacement
173	# perform func_basename and func_dirname in a single function
174	# call:
175	# dirname: Compute the dirname of FILE. If nonempty,
176	# add APPEND to the result, otherwise set result
177	# to NONDIR_REPLACEMENT.
178	# value returned in "$func_dirname_result"
179	# basename: Compute filename of FILE.
180	# value retuned in "$func_basename_result"
181	# Implementation must be kept synchronized with func_dirname
182	# and func_basename. For efficiency, we do not delegate to
183	# those functions but instead duplicate the functionality here.
184	func_dirname_and_basename ()
185	{
186	# Extract subdirectory from the argument.
187	func_dirname_result=`$ECHO "${1}" \| $SED -e "$dirname"`
188	if test "X$func_dirname_result" = "X${1}"; then
189	func_dirname_result="${3}"
190	else
191	func_dirname_result="$func_dirname_result${2}"
192	fi
193	func_basename_result=`$ECHO "${1}" \| $SED -e "$basename"`
194	}
195
196	# Generated shell functions inserted here.
197
198	# These SED scripts presuppose an absolute path with a trailing slash.
199	pathcar='s,^/$[^/]$.$,\1,'
200	pathcdr='s,^/[^/]*,,'
201	removedotparts=':dotsl
202	s@/\./@/@g
203	t dotsl
204	s,/\.$,/,'
205	collapseslashes='s@/\{1,\}@/@g'
206	finalslash='s,/*$,/,'
207
208	# func_normal_abspath PATH
209	# Remove doubled-up and trailing slashes, "." path components,
210	# and cancel out any ".." path components in PATH after making
211	# it an absolute path.
212	# value returned in "$func_normal_abspath_result"
213	func_normal_abspath ()
214	{
215	# Start from root dir and reassemble the path.
216	func_normal_abspath_result=
217	func_normal_abspath_tpath=$1
218	func_normal_abspath_altnamespace=
219	case $func_normal_abspath_tpath in
220	"")
221	# Empty path, that just means $cwd.
222	func_stripname '' '/' "`pwd`"
223	func_normal_abspath_result=$func_stripname_result
224	return
225	;;
226	# The next three entries are used to spot a run of precisely
227	# two leading slashes without using negated character classes;
228	# we take advantage of case's first-match behaviour.
229	///*)
230	# Unusual form of absolute path, do nothing.
231	;;
232	//*)
233	# Not necessarily an ordinary path; POSIX reserves leading '//'
234	# and for example Cygwin uses it to access remote file shares
235	# over CIFS/SMB, so we conserve a leading double slash if found.
236	func_normal_abspath_altnamespace=/
237	;;
238	/*)
239	# Absolute path, do nothing.
240	;;
241	*)
242	# Relative path, prepend $cwd.
243	func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
244	;;
245	esac
246	# Cancel out all the simple stuff to save iterations. We also want
247	# the path to end with a slash for ease of parsing, so make sure
248	# there is one (and only one) here.
249	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" \| $SED \
250	-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
251	while :; do
252	# Processed it all yet?
253	if test "$func_normal_abspath_tpath" = / ; then
254	# If we ascended to the root using ".." the result may be empty now.
255	if test -z "$func_normal_abspath_result" ; then
256	func_normal_abspath_result=/
257	fi
258	break
259	fi
260	func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" \| $SED \
261	-e "$pathcar"`
262	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" \| $SED \
263	-e "$pathcdr"`
264	# Figure out what to do with it
265	case $func_normal_abspath_tcomponent in
266	"")
267	# Trailing empty path component, ignore it.
268	;;
269	..)
270	# Parent dir; strip last assembled component from result.
271	func_dirname "$func_normal_abspath_result"
272	func_normal_abspath_result=$func_dirname_result
273	;;
274	*)
275	# Actual path component, append it.
276	func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
277	;;
278	esac
279	done
280	# Restore leading double-slash if one was found on entry.
281	func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
282	}
283
284	# func_relative_path SRCDIR DSTDIR
285	# generates a relative path from SRCDIR to DSTDIR, with a trailing
286	# slash if non-empty, suitable for immediately appending a filename
287	# without needing to append a separator.
288	# value returned in "$func_relative_path_result"
289	func_relative_path ()
290	{
291	func_relative_path_result=
292	func_normal_abspath "$1"
293	func_relative_path_tlibdir=$func_normal_abspath_result
294	func_normal_abspath "$2"
295	func_relative_path_tbindir=$func_normal_abspath_result
296
297	# Ascend the tree starting from libdir
298	while :; do
299	# check if we have found a prefix of bindir
300	case $func_relative_path_tbindir in
301	$func_relative_path_tlibdir)
302	# found an exact match
303	func_relative_path_tcancelled=
304	break
305	;;
306	$func_relative_path_tlibdir*)
307	# found a matching prefix
308	func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
309	func_relative_path_tcancelled=$func_stripname_result
310	if test -z "$func_relative_path_result"; then
311	func_relative_path_result=.
312	fi
313	break
314	;;
315	*)
316	func_dirname $func_relative_path_tlibdir
317	func_relative_path_tlibdir=${func_dirname_result}
318	if test "x$func_relative_path_tlibdir" = x ; then
319	# Have to descend all the way to the root!
320	func_relative_path_result=../$func_relative_path_result
321	func_relative_path_tcancelled=$func_relative_path_tbindir
322	break
323	fi
324	func_relative_path_result=../$func_relative_path_result
325	;;
326	esac
327	done
328
329	# Now calculate path; take care to avoid doubling-up slashes.
330	func_stripname '' '/' "$func_relative_path_result"
331	func_relative_path_result=$func_stripname_result
332	func_stripname '/' '/' "$func_relative_path_tcancelled"
333	if test "x$func_stripname_result" != x ; then
334	func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
335	fi
336
337	# Normalisation. If bindir is libdir, return empty string,
338	# else relative path ending with a slash; either way, target
339	# file name can be directly appended.
340	if test ! -z "$func_relative_path_result"; then
341	func_stripname './' '' "$func_relative_path_result/"
342	func_relative_path_result=$func_stripname_result
343	fi
344	}
345
346	# The name of this program:
347	func_dirname_and_basename "$progpath"
348	progname=$func_basename_result
349
350	# Make sure we have an absolute path for reexecution:
351	case $progpath in
352	[\\/]\|[A-Za-z]:\\) ;;
353	[\\/])
354	progdir=$func_dirname_result
355	progdir=`cd "$progdir" && pwd`
356	progpath="$progdir/$progname"
357	;;
358	*)
359	save_IFS="$IFS"
360	IFS=:
361	for progdir in $PATH; do
362	IFS="$save_IFS"
363	test -x "$progdir/$progname" && break
364	done
365	IFS="$save_IFS"
366	test -n "$progdir" \|\| progdir=`pwd`
367	progpath="$progdir/$progname"
368	;;
369	esac
370
371	# Sed substitution that helps us do robust quoting. It backslashifies
372	# metacharacters that are still active within double-quoted strings.
373	Xsed="${SED}"' -e 1s/^X//'
374	sed_quote_subst='s/$[`"$\\]$/\\\1/g'
375
376	# Same as above, but do not quote variable references.
377	double_quote_subst='s/$["`\\]$/\\\1/g'
378
379	# Re-`\' parameter expansions in output of double_quote_subst that were
380	# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
381	# in input to double_quote_subst, that '$' was protected from expansion.
382	# Since each input `\' is now two `\'s, look for any number of runs of
383	# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
384	bs='\\'
385	bs2='\\\\'
386	bs4='\\\\\\\\'
387	dollar='\$'
388	sed_double_backslash="\
389	s/$bs4/&\\
390	/g
391	s/^$bs2$dollar/$bs&/
392	s/\$[^$bs]\$$bs2$dollar/\\1$bs2$bs$dollar/g
393	s/\n//g"
394
395	# Standard options:
396	opt_dry_run=false
397	opt_help=false
398	opt_quiet=false
399	opt_verbose=false
400	opt_warning=:
401
402	# func_echo arg...
403	# Echo program name prefixed message, along with the current mode
404	# name if it has been set yet.
405	func_echo ()
406	{
407	$ECHO "$progname${mode+: }$mode: $*"
408	}
409
410	# func_verbose arg...
411	# Echo program name prefixed message in verbose mode only.
412	func_verbose ()
413	{
414	$opt_verbose && func_echo ${1+"$@"}
415
416	# A bug in bash halts the script if the last line of a function
417	# fails when set -e is in force, so we need another command to
418	# work around that:
419	:
420	}
421
422	# func_echo_all arg...
423	# Invoke $ECHO with all args, space-separated.
424	func_echo_all ()
425	{
426	$ECHO "$*"
427	}
428
429	# func_error arg...
430	# Echo program name prefixed message to standard error.
431	func_error ()
432	{
433	$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
434	}
435
436	# func_warning arg...
437	# Echo program name prefixed warning message to standard error.
438	func_warning ()
439	{
440	$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
441
442	# bash bug again:
443	:
444	}
445
446	# func_fatal_error arg...
447	# Echo program name prefixed message to standard error, and exit.
448	func_fatal_error ()
449	{
450	func_error ${1+"$@"}
451	exit $EXIT_FAILURE
452	}
453
454	# func_fatal_help arg...
455	# Echo program name prefixed message to standard error, followed by
456	# a help hint, and exit.
457	func_fatal_help ()
458	{
459	func_error ${1+"$@"}
460	func_fatal_error "$help"
461	}
462	help="Try \`$progname --help' for more information." ## default
463
464
465	# func_grep expression filename
466	# Check whether EXPRESSION matches any line of FILENAME, without output.
467	func_grep ()
468	{
469	$GREP "$1" "$2" >/dev/null 2>&1
470	}
471
472
473	# func_mkdir_p directory-path
474	# Make sure the entire path to DIRECTORY-PATH is available.
475	func_mkdir_p ()
476	{
477	my_directory_path="$1"
478	my_dir_list=
479
480	if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
481
482	# Protect directory names starting with `-'
483	case $my_directory_path in
484	-*) my_directory_path="./$my_directory_path" ;;
485	esac
486
487	# While some portion of DIR does not yet exist...
488	while test ! -d "$my_directory_path"; do
489	# ...make a list in topmost first order. Use a colon delimited
490	# list incase some portion of path contains whitespace.
491	my_dir_list="$my_directory_path:$my_dir_list"
492
493	# If the last portion added has no slash in it, the list is done
494	case $my_directory_path in /) ;; *) break ;; esac
495
496	# ...otherwise throw away the child directory and loop
497	my_directory_path=`$ECHO "$my_directory_path" \| $SED -e "$dirname"`
498	done
499	my_dir_list=`$ECHO "$my_dir_list" \| $SED 's,:*$,,'`
500
501	save_mkdir_p_IFS="$IFS"; IFS=':'
502	for my_dir in $my_dir_list; do
503	IFS="$save_mkdir_p_IFS"
504	# mkdir can fail with a `File exist' error if two processes
505	# try to create one of the directories concurrently. Don't
506	# stop in that case!
507	$MKDIR "$my_dir" 2>/dev/null \|\| :
508	done
509	IFS="$save_mkdir_p_IFS"
510
511	# Bail out if we (or some other process) failed to create a directory.
512	test -d "$my_directory_path" \|\| \
513	func_fatal_error "Failed to create \`$1'"
514	fi
515	}
516
517
518	# func_mktempdir [string]
519	# Make a temporary directory that won't clash with other running
520	# libtool processes, and avoids race conditions if possible. If
521	# given, STRING is the basename for that directory.
522	func_mktempdir ()
523	{
524	my_template="${TMPDIR-/tmp}/${1-$progname}"
525
526	if test "$opt_dry_run" = ":"; then
527	# Return a directory name, but don't create it in dry-run mode
528	my_tmpdir="${my_template}-$$"
529	else
530
531	# If mktemp works, use that first and foremost
532	my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
533
534	if test ! -d "$my_tmpdir"; then
535	# Failing that, at least try and use $RANDOM to avoid a race
536	my_tmpdir="${my_template}-${RANDOM-0}$$"
537
538	save_mktempdir_umask=`umask`
539	umask 0077
540	$MKDIR "$my_tmpdir"
541	umask $save_mktempdir_umask
542	fi
543
544	# If we're not in dry-run mode, bomb out on failure
545	test -d "$my_tmpdir" \|\| \
546	func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
547	fi
548
549	$ECHO "$my_tmpdir"
550	}
551
552
553	# func_quote_for_eval arg
554	# Aesthetically quote ARG to be evaled later.
555	# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
556	# is double-quoted, suitable for a subsequent eval, whereas
557	# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
558	# which are still active within double quotes backslashified.
559	func_quote_for_eval ()
560	{
561	case $1 in
562	[\\\`\"\$])
563	func_quote_for_eval_unquoted_result=`$ECHO "$1" \| $SED "$sed_quote_subst"` ;;
564	*)
565	func_quote_for_eval_unquoted_result="$1" ;;
566	esac
567
568	case $func_quote_for_eval_unquoted_result in
569	# Double-quote args containing shell metacharacters to delay
570	# word splitting, command substitution and and variable
571	# expansion for a subsequent eval.
572	# Many Bourne shells cannot handle close brackets correctly
573	# in scan sets, so we specify it separately.
574	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
575	func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
576	;;
577	*)
578	func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
579	esac
580	}
581
582
583	# func_quote_for_expand arg
584	# Aesthetically quote ARG to be evaled later; same as above,
585	# but do not quote variable references.
586	func_quote_for_expand ()
587	{
588	case $1 in
589	[\\\`\"])
590	my_arg=`$ECHO "$1" \| $SED \
591	-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
592	*)
593	my_arg="$1" ;;
594	esac
595
596	case $my_arg in
597	# Double-quote args containing shell metacharacters to delay
598	# word splitting and command substitution for a subsequent eval.
599	# Many Bourne shells cannot handle close brackets correctly
600	# in scan sets, so we specify it separately.
601	[\[\~\#\^\&\\{\}\\|\;\<\>\?\'\ \ ]\|]*\|"")
602	my_arg="\"$my_arg\""
603	;;
604	esac
605
606	func_quote_for_expand_result="$my_arg"
607	}
608
609
610	# func_show_eval cmd [fail_exp]
611	# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
612	# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
613	# is given, then evaluate it.
614	func_show_eval ()
615	{
616	my_cmd="$1"
617	my_fail_exp="${2-:}"
618
619	${opt_silent-false} \|\| {
620	func_quote_for_expand "$my_cmd"
621	eval "func_echo $func_quote_for_expand_result"
622	}
623
624	if ${opt_dry_run-false}; then :; else
625	eval "$my_cmd"
626	my_status=$?
627	if test "$my_status" -eq 0; then :; else
628	eval "(exit $my_status); $my_fail_exp"
629	fi
630	fi
631	}
632
633
634	# func_show_eval_locale cmd [fail_exp]
635	# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
636	# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
637	# is given, then evaluate it. Use the saved locale for evaluation.
638	func_show_eval_locale ()
639	{
640	my_cmd="$1"
641	my_fail_exp="${2-:}"
642
643	${opt_silent-false} \|\| {
644	func_quote_for_expand "$my_cmd"
645	eval "func_echo $func_quote_for_expand_result"
646	}
647
648	if ${opt_dry_run-false}; then :; else
649	eval "$lt_user_locale
650	$my_cmd"
651	my_status=$?
652	eval "$lt_safe_locale"
653	if test "$my_status" -eq 0; then :; else
654	eval "(exit $my_status); $my_fail_exp"
655	fi
656	fi
657	}
658
659
660
661
662
663	# func_version
664	# Echo version message to standard output and exit.
665	func_version ()
666	{
667	$SED -n '/(C)/!b go
668	:more
669	/\./!{
670	N
671	s/\n# //
672	b more
673	}
674	:go
675	/^# '$PROGRAM' (GNU /,/# warranty; / {
676	s/^# //
677	s/^# *$//
678	s/$(C)$[ 0-9,-]$ [1-9][0-9]$/\1\2/
679	p
680	}' < "$progpath"
681	exit $?
682	}
683
684	# func_usage
685	# Echo short help message to standard output and exit.
686	func_usage ()
687	{
688	$SED -n '/^# Usage:/,/^# *-h/ {
689	s/^# //
690	s/^# *$//
691	s/\$progname/'$progname'/
692	p
693	}' < "$progpath"
694	echo
695	$ECHO "run \`$progname --help \| more' for full usage"
696	exit $?
697	}
698
699	# func_help [NOEXIT]
700	# Echo long help message to standard output and exit,
701	# unless 'noexit' is passed as argument.
702	func_help ()
703	{
704	$SED -n '/^# Usage:/,/# Report bugs to/ {
705	s/^# //
706	s/^# *$//
707	s\$progname'$progname'*
708	s\$host'"$host"'*
709	s\$SHELL'"$SHELL"'*
710	s\$LTCC'"$LTCC"'*
711	s\$LTCFLAGS'"$LTCFLAGS"'*
712	s\$LD'"$LD"'*
713	s/\$with_gnu_ld/'"$with_gnu_ld"'/
714	s/\$automake_version/'"`(automake --version) 2>/dev/null \|$SED 1q`"'/
715	s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null \|$SED 1q`"'/
716	p
717	}' < "$progpath"
718	ret=$?
719	if test -z "$1"; then
720	exit $ret
721	fi
722	}
723
724	# func_missing_arg argname
725	# Echo program name prefixed message to standard error and set global
726	# exit_cmd.
727	func_missing_arg ()
728	{
729	func_error "missing argument for $1"
730	exit_cmd=exit
731	}
732
733	exit_cmd=:
734
735
736
737
738
739
740	magic="%%%MAGIC variable%%%"
741	magic_exe="%%%MAGIC EXE variable%%%"
742
743	# Global variables.
744	# $mode is unset
745	nonopt=
746	execute_dlfiles=
747	preserve_args=
748	lo2o="s/\\.lo\$/.${objext}/"
749	o2lo="s/\\.${objext}\$/.lo/"
750	extracted_archives=
751	extracted_serial=0
752
753	opt_dry_run=false
754	opt_finish=:
755	opt_duplicate_deps=false
756	opt_silent=false
757	opt_debug=:
758
759	# If this variable is set in any of the actions, the command in it
760	# will be execed at the end. This prevents here-documents from being
761	# left over by shells.
762	exec_cmd=
763
764	# func_fatal_configuration arg...
765	# Echo program name prefixed message to standard error, followed by
766	# a configuration failure hint, and exit.
767	func_fatal_configuration ()
768	{
769	func_error ${1+"$@"}
770	func_error "See the $PACKAGE documentation for more information."
771	func_fatal_error "Fatal configuration error."
772	}
773
774
775	# func_config
776	# Display the configuration for all the tags in this script.
777	func_config ()
778	{
779	re_begincf='^# ### BEGIN LIBTOOL'
780	re_endcf='^# ### END LIBTOOL'
781
782	# Default configuration.
783	$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
784
785	# Now print the configurations for the tags.
786	for tagname in $taglist; do
787	$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
788	done
789
790	exit $?
791	}
792
793	# func_features
794	# Display the features supported by this script.
795	func_features ()
796	{
797	echo "host: $host"
798	if test "$build_libtool_libs" = yes; then
799	echo "enable shared libraries"
800	else
801	echo "disable shared libraries"
802	fi
803	if test "$build_old_libs" = yes; then
804	echo "enable static libraries"
805	else
806	echo "disable static libraries"
807	fi
808
809	exit $?
810	}
811
812	# func_enable_tag tagname
813	# Verify that TAGNAME is valid, and either flag an error and exit, or
814	# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
815	# variable here.
816	func_enable_tag ()
817	{
818	# Global variable:
819	tagname="$1"
820
821	re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
822	re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
823	sed_extractcf="/$re_begincf/,/$re_endcf/p"
824
825	# Validate tagname.
826	case $tagname in
827	[!-_A-Za-z0-9,/])
828	func_fatal_error "invalid tag name: $tagname"
829	;;
830	esac
831
832	# Don't test for the "default" C tag, as we know it's
833	# there but not specially marked.
834	case $tagname in
835	CC) ;;
836	*)
837	if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
838	taglist="$taglist $tagname"
839
840	# Evaluate the configuration. Be careful to quote the path
841	# and the sed script, to avoid splitting on whitespace, but
842	# also don't use non-portable quotes within backquotes within
843	# quotes we have to do it in 2 steps:
844	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
845	eval "$extractedcf"
846	else
847	func_error "ignoring unknown tag $tagname"
848	fi
849	;;
850	esac
851	}
852
853	# Parse options once, thoroughly. This comes as soon as possible in
854	# the script to make things like `libtool --version' happen quickly.
855	{
856
857	# Shorthand for --mode=foo, only valid as the first argument
858	case $1 in
859	clean\|clea\|cle\|cl)
860	shift; set dummy --mode clean ${1+"$@"}; shift
861	;;
862	compile\|compil\|compi\|comp\|com\|co\|c)
863	shift; set dummy --mode compile ${1+"$@"}; shift
864	;;
865	execute\|execut\|execu\|exec\|exe\|ex\|e)
866	shift; set dummy --mode execute ${1+"$@"}; shift
867	;;
868	finish\|finis\|fini\|fin\|fi\|f)
869	shift; set dummy --mode finish ${1+"$@"}; shift
870	;;
871	install\|instal\|insta\|inst\|ins\|in\|i)
872	shift; set dummy --mode install ${1+"$@"}; shift
873	;;
874	link\|lin\|li\|l)
875	shift; set dummy --mode link ${1+"$@"}; shift
876	;;
877	uninstall\|uninstal\|uninsta\|uninst\|unins\|unin\|uni\|un\|u)
878	shift; set dummy --mode uninstall ${1+"$@"}; shift
879	;;
880	esac
881
882	# Parse non-mode specific arguments:
883	while test "$#" -gt 0; do
884	opt="$1"
885	shift
886
887	case $opt in
888	--config) func_config ;;
889
890	--debug) preserve_args="$preserve_args $opt"
891	func_echo "enabling shell trace mode"
892	opt_debug='set -x'
893	$opt_debug
894	;;
895
896	-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
897	execute_dlfiles="$execute_dlfiles $1"
898	shift
899	;;
900
901	--dry-run \| -n) opt_dry_run=: ;;
902	--features) func_features ;;
903	--finish) mode="finish" ;;
904	--no-finish) opt_finish=false ;;
905
906	--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
907	case $1 in
908	# Valid mode arguments:
909	clean) ;;
910	compile) ;;
911	execute) ;;
912	finish) ;;
913	install) ;;
914	link) ;;
915	relink) ;;
916	uninstall) ;;
917
918	# Catch anything else as an error
919	*) func_error "invalid argument for $opt"
920	exit_cmd=exit
921	break
922	;;
923	esac
924
925	mode="$1"
926	shift
927	;;
928
929	--preserve-dup-deps)
930	opt_duplicate_deps=: ;;
931
932	--quiet\|--silent) preserve_args="$preserve_args $opt"
933	opt_silent=:
934	opt_verbose=false
935	;;
936
937	--no-quiet\|--no-silent)
938	preserve_args="$preserve_args $opt"
939	opt_silent=false
940	;;
941
942	--verbose\| -v) preserve_args="$preserve_args $opt"
943	opt_silent=false
944	opt_verbose=:
945	;;
946
947	--no-verbose) preserve_args="$preserve_args $opt"
948	opt_verbose=false
949	;;
950
951	--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
952	preserve_args="$preserve_args $opt $1"
953	func_enable_tag "$1" # tagname is set here
954	shift
955	;;
956
957	# Separate optargs to long options:
958	-dlopen=\|--mode=\|--tag=*)
959	func_opt_split "$opt"
960	set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
961	shift
962	;;
963
964	-\?\|-h) func_usage ;;
965	--help) opt_help=: ;;
966	--help-all) opt_help=': help-all' ;;
967	--version) func_version ;;
968
969	-*) func_fatal_help "unrecognized option \`$opt'" ;;
970
971	*) nonopt="$opt"
972	break
973	;;
974	esac
975	done
976
977
978	case $host in
979	cygwin \| mingw \| pw32 \| cegcc \| solaris2 )
980	# don't eliminate duplications in $postdeps and $predeps
981	opt_duplicate_compiler_generated_deps=:
982	;;
983	*)
984	opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
985	;;
986	esac
987
988	# Having warned about all mis-specified options, bail out if
989	# anything was wrong.
990	$exit_cmd $EXIT_FAILURE
991	}
992
993	# func_check_version_match
994	# Ensure that we are using m4 macros, and libtool script from the same
995	# release of libtool.
996	func_check_version_match ()
997	{
998	if test "$package_revision" != "$macro_revision"; then
999	if test "$VERSION" != "$macro_version"; then
1000	if test -z "$macro_version"; then
1001	cat >&2 <<_LT_EOF
1002	$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1003	$progname: definition of this LT_INIT comes from an older release.
1004	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1005	$progname: and run autoconf again.
1006	_LT_EOF
1007	else
1008	cat >&2 <<_LT_EOF
1009	$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1010	$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1011	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1012	$progname: and run autoconf again.
1013	_LT_EOF
1014	fi
1015	else
1016	cat >&2 <<_LT_EOF
1017	$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1018	$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1019	$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1020	$progname: of $PACKAGE $VERSION and run autoconf again.
1021	_LT_EOF
1022	fi
1023
1024	exit $EXIT_MISMATCH
1025	fi
1026	}
1027
1028
1029	## ----------- ##
1030	## Main. ##
1031	## ----------- ##
1032
1033	$opt_help \|\| {
1034	# Sanity checks first:
1035	func_check_version_match
1036
1037	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1038	func_fatal_configuration "not configured to build any kind of library"
1039	fi
1040
1041	test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1042
1043
1044	# Darwin sucks
1045	eval "std_shrext=\"$shrext_cmds\""
1046
1047
1048	# Only execute mode is allowed to have -dlopen flags.
1049	if test -n "$execute_dlfiles" && test "$mode" != execute; then
1050	func_error "unrecognized option \`-dlopen'"
1051	$ECHO "$help" 1>&2
1052	exit $EXIT_FAILURE
1053	fi
1054
1055	# Change the help message to a mode-specific one.
1056	generic_help="$help"
1057	help="Try \`$progname --help --mode=$mode' for more information."
1058	}
1059
1060
1061	# func_lalib_p file
1062	# True iff FILE is a libtool `.la' library or `.lo' object file.
1063	# This function is only a basic sanity check; it will hardly flush out
1064	# determined imposters.
1065	func_lalib_p ()
1066	{
1067	test -f "$1" &&
1068	$SED -e 4q "$1" 2>/dev/null \
1069	\| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1070	}
1071
1072	# func_lalib_unsafe_p file
1073	# True iff FILE is a libtool `.la' library or `.lo' object file.
1074	# This function implements the same check as func_lalib_p without
1075	# resorting to external programs. To this end, it redirects stdin and
1076	# closes it afterwards, without saving the original file descriptor.
1077	# As a safety measure, use it only where a negative result would be
1078	# fatal anyway. Works if `file' does not exist.
1079	func_lalib_unsafe_p ()
1080	{
1081	lalib_p=no
1082	if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1083	for lalib_p_l in 1 2 3 4
1084	do
1085	read lalib_p_line
1086	case "$lalib_p_line" in
1087	\#\ Generated\ by\ $PACKAGE ) lalib_p=yes; break;;
1088	esac
1089	done
1090	exec 0<&5 5<&-
1091	fi
1092	test "$lalib_p" = yes
1093	}
1094
1095	# func_ltwrapper_script_p file
1096	# True iff FILE is a libtool wrapper script
1097	# This function is only a basic sanity check; it will hardly flush out
1098	# determined imposters.
1099	func_ltwrapper_script_p ()
1100	{
1101	func_lalib_p "$1"
1102	}
1103
1104	# func_ltwrapper_executable_p file
1105	# True iff FILE is a libtool wrapper executable
1106	# This function is only a basic sanity check; it will hardly flush out
1107	# determined imposters.
1108	func_ltwrapper_executable_p ()
1109	{
1110	func_ltwrapper_exec_suffix=
1111	case $1 in
1112	*.exe) ;;
1113	*) func_ltwrapper_exec_suffix=.exe ;;
1114	esac
1115	$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1116	}
1117
1118	# func_ltwrapper_scriptname file
1119	# Assumes file is an ltwrapper_executable
1120	# uses $file to determine the appropriate filename for a
1121	# temporary ltwrapper_script.
1122	func_ltwrapper_scriptname ()
1123	{
1124	func_ltwrapper_scriptname_result=""
1125	if func_ltwrapper_executable_p "$1"; then
1126	func_dirname_and_basename "$1" "" "."
1127	func_stripname '' '.exe' "$func_basename_result"
1128	func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1129	fi
1130	}
1131
1132	# func_ltwrapper_p file
1133	# True iff FILE is a libtool wrapper script or wrapper executable
1134	# This function is only a basic sanity check; it will hardly flush out
1135	# determined imposters.
1136	func_ltwrapper_p ()
1137	{
1138	func_ltwrapper_script_p "$1" \|\| func_ltwrapper_executable_p "$1"
1139	}
1140
1141
1142	# func_execute_cmds commands fail_cmd
1143	# Execute tilde-delimited COMMANDS.
1144	# If FAIL_CMD is given, eval that upon failure.
1145	# FAIL_CMD may read-access the current command in variable CMD!
1146	func_execute_cmds ()
1147	{
1148	$opt_debug
1149	save_ifs=$IFS; IFS='~'
1150	for cmd in $1; do
1151	IFS=$save_ifs
1152	eval "cmd=\"$cmd\""
1153	func_show_eval "$cmd" "${2-:}"
1154	done
1155	IFS=$save_ifs
1156	}
1157
1158
1159	# func_source file
1160	# Source FILE, adding directory component if necessary.
1161	# Note that it is not necessary on cygwin/mingw to append a dot to
1162	# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1163	# behavior happens only for exec(3), not for open(2)! Also, sourcing
1164	# `FILE.' does not work on cygwin managed mounts.
1165	func_source ()
1166	{
1167	$opt_debug
1168	case $1 in
1169	/ \| \\) . "$1" ;;
1170	*) . "./$1" ;;
1171	esac
1172	}
1173
1174
1175	# func_infer_tag arg
1176	# Infer tagged configuration to use if any are available and
1177	# if one wasn't chosen via the "--tag" command line option.
1178	# Only attempt this if the compiler in the base compile
1179	# command doesn't match the default compiler.
1180	# arg is usually of the form 'gcc ...'
1181	func_infer_tag ()
1182	{
1183	$opt_debug
1184	if test -n "$available_tags" && test -z "$tagname"; then
1185	CC_quoted=
1186	for arg in $CC; do
1187	func_quote_for_eval "$arg"
1188	CC_quoted="$CC_quoted $func_quote_for_eval_result"
1189	done
1190	CC_expanded=`func_echo_all $CC`
1191	CC_quoted_expanded=`func_echo_all $CC_quoted`
1192	case $@ in
1193	# Blanks in the command may have been stripped by the calling shell,
1194	# but not from the CC environment variable when configure was run.
1195	" $CC "* \| "$CC "* \| " $CC_expanded "* \| "$CC_expanded "* \| \
1196	" $CC_quoted"* \| "$CC_quoted "* \| " $CC_quoted_expanded "* \| "$CC_quoted_expanded "*) ;;
1197	# Blanks at the start of $base_compile will cause this to fail
1198	# if we don't check for them as well.
1199	*)
1200	for z in $available_tags; do
1201	if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1202	# Evaluate the configuration.
1203	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1204	CC_quoted=
1205	for arg in $CC; do
1206	# Double-quote args containing other shell metacharacters.
1207	func_quote_for_eval "$arg"
1208	CC_quoted="$CC_quoted $func_quote_for_eval_result"
1209	done
1210	CC_expanded=`func_echo_all $CC`
1211	CC_quoted_expanded=`func_echo_all $CC_quoted`
1212	case "$@ " in
1213	" $CC "* \| "$CC "* \| " $CC_expanded "* \| "$CC_expanded "* \| \
1214	" $CC_quoted"* \| "$CC_quoted "* \| " $CC_quoted_expanded "* \| "$CC_quoted_expanded "*)
1215	# The compiler in the base compile command matches
1216	# the one in the tagged configuration.
1217	# Assume this is the tagged configuration we want.
1218	tagname=$z
1219	break
1220	;;
1221	esac
1222	fi
1223	done
1224	# If $tagname still isn't set, then no tagged configuration
1225	# was found and let the user know that the "--tag" command
1226	# line option must be used.
1227	if test -z "$tagname"; then
1228	func_echo "unable to infer tagged configuration"
1229	func_fatal_error "specify a tag with \`--tag'"
1230	# else
1231	# func_verbose "using $tagname tagged configuration"
1232	fi
1233	;;
1234	esac
1235	fi
1236	}
1237
1238
1239
1240	# func_write_libtool_object output_name pic_name nonpic_name
1241	# Create a libtool object file (analogous to a ".la" file),
1242	# but don't create it if we're doing a dry run.
1243	func_write_libtool_object ()
1244	{
1245	write_libobj=${1}
1246	if test "$build_libtool_libs" = yes; then
1247	write_lobj=\'${2}\'
1248	else
1249	write_lobj=none
1250	fi
1251
1252	if test "$build_old_libs" = yes; then
1253	write_oldobj=\'${3}\'
1254	else
1255	write_oldobj=none
1256	fi
1257
1258	$opt_dry_run \|\| {
1259	cat >${write_libobj}T <<EOF
1260	# $write_libobj - a libtool object file
1261	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1262	#
1263	# Please DO NOT delete this file!
1264	# It is necessary for linking the library.
1265
1266	# Name of the PIC object.
1267	pic_object=$write_lobj
1268
1269	# Name of the non-PIC object
1270	non_pic_object=$write_oldobj
1271
1272	EOF
1273	$MV "${write_libobj}T" "${write_libobj}"
1274	}
1275	}
1276
1277	# func_mode_compile arg...
1278	func_mode_compile ()
1279	{
1280	$opt_debug
1281	# Get the compilation command and the source file.
1282	base_compile=
1283	srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1284	suppress_opt=yes
1285	suppress_output=
1286	arg_mode=normal
1287	libobj=
1288	later=
1289	pie_flag=
1290
1291	for arg
1292	do
1293	case $arg_mode in
1294	arg )
1295	# do not "continue". Instead, add this to base_compile
1296	lastarg="$arg"
1297	arg_mode=normal
1298	;;
1299
1300	target )
1301	libobj="$arg"
1302	arg_mode=normal
1303	continue
1304	;;
1305
1306	normal )
1307	# Accept any command-line options.
1308	case $arg in
1309	-o)
1310	test -n "$libobj" && \
1311	func_fatal_error "you cannot specify \`-o' more than once"
1312	arg_mode=target
1313	continue
1314	;;
1315
1316	-pie \| -fpie \| -fPIE)
1317	pie_flag="$pie_flag $arg"
1318	continue
1319	;;
1320
1321	-shared \| -static \| -prefer-pic \| -prefer-non-pic)
1322	later="$later $arg"
1323	continue
1324	;;
1325
1326	-no-suppress)
1327	suppress_opt=no
1328	continue
1329	;;
1330
1331	-Xcompiler)
1332	arg_mode=arg # the next one goes into the "base_compile" arg list
1333	continue # The current "srcfile" will either be retained or
1334	;; # replaced later. I would guess that would be a bug.
1335
1336	-Wc,*)
1337	func_stripname '-Wc,' '' "$arg"
1338	args=$func_stripname_result
1339	lastarg=
1340	save_ifs="$IFS"; IFS=','
1341	for arg in $args; do
1342	IFS="$save_ifs"
1343	func_quote_for_eval "$arg"
1344	lastarg="$lastarg $func_quote_for_eval_result"
1345	done
1346	IFS="$save_ifs"
1347	func_stripname ' ' '' "$lastarg"
1348	lastarg=$func_stripname_result
1349
1350	# Add the arguments to base_compile.
1351	base_compile="$base_compile $lastarg"
1352	continue
1353	;;
1354
1355	*)
1356	# Accept the current argument as the source file.
1357	# The previous "srcfile" becomes the current argument.
1358	#
1359	lastarg="$srcfile"
1360	srcfile="$arg"
1361	;;
1362	esac # case $arg
1363	;;
1364	esac # case $arg_mode
1365
1366	# Aesthetically quote the previous argument.
1367	func_quote_for_eval "$lastarg"
1368	base_compile="$base_compile $func_quote_for_eval_result"
1369	done # for arg
1370
1371	case $arg_mode in
1372	arg)
1373	func_fatal_error "you must specify an argument for -Xcompile"
1374	;;
1375	target)
1376	func_fatal_error "you must specify a target with \`-o'"
1377	;;
1378	*)
1379	# Get the name of the library object.
1380	test -z "$libobj" && {
1381	func_basename "$srcfile"
1382	libobj="$func_basename_result"
1383	}
1384	;;
1385	esac
1386
1387	# Recognize several different file suffixes.
1388	# If the user specifies -o file.o, it is replaced with file.lo
1389	case $libobj in
1390	*.[cCFSifmso] \| \
1391	.ada \| .adb \| .ads \| .asm \| \
1392	.c++ \| .cc \| .ii \| .class \| .cpp \| .cxx \| \
1393	.[fF][09]? \| .for \| .java \| .obj \| .sx \| .cu \| *.cup)
1394	func_xform "$libobj"
1395	libobj=$func_xform_result
1396	;;
1397	esac
1398
1399	case $libobj in
1400	*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1401	*)
1402	func_fatal_error "cannot determine name of library object from \`$libobj'"
1403	;;
1404	esac
1405
1406	func_infer_tag $base_compile
1407
1408	for arg in $later; do
1409	case $arg in
1410	-shared)
1411	test "$build_libtool_libs" != yes && \
1412	func_fatal_configuration "can not build a shared library"
1413	build_old_libs=no
1414	continue
1415	;;
1416
1417	-static)
1418	build_libtool_libs=no
1419	build_old_libs=yes
1420	continue
1421	;;
1422
1423	-prefer-pic)
1424	pic_mode=yes
1425	continue
1426	;;
1427
1428	-prefer-non-pic)
1429	pic_mode=no
1430	continue
1431	;;
1432	esac
1433	done
1434
1435	func_quote_for_eval "$libobj"
1436	test "X$libobj" != "X$func_quote_for_eval_result" \
1437	&& $ECHO "X$libobj" \| $GREP '[]~#^*{};<>?"'"'"' &()\|`$[]' \
1438	&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1439	func_dirname_and_basename "$obj" "/" ""
1440	objname="$func_basename_result"
1441	xdir="$func_dirname_result"
1442	lobj=${xdir}$objdir/$objname
1443
1444	test -z "$base_compile" && \
1445	func_fatal_help "you must specify a compilation command"
1446
1447	# Delete any leftover library objects.
1448	if test "$build_old_libs" = yes; then
1449	removelist="$obj $lobj $libobj ${libobj}T"
1450	else
1451	removelist="$lobj $libobj ${libobj}T"
1452	fi
1453
1454	# On Cygwin there's no "real" PIC flag so we must build both object types
1455	case $host_os in
1456	cygwin* \| mingw* \| pw32* \| os2* \| cegcc*)
1457	pic_mode=default
1458	;;
1459	esac
1460	if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1461	# non-PIC code in shared libraries is not supported
1462	pic_mode=default
1463	fi
1464
1465	# Calculate the filename of the output object if compiler does
1466	# not support -o with -c
1467	if test "$compiler_c_o" = no; then
1468	output_obj=`$ECHO "$srcfile" \| $SED 's%^./%%; s%\.[^.]$%%'`.${objext}
1469	lockfile="$output_obj.lock"
1470	else
1471	output_obj=
1472	need_locks=no
1473	lockfile=
1474	fi
1475
1476	# Lock this critical section if it is needed
1477	# We use this script file to make the link, it avoids creating a new file
1478	if test "$need_locks" = yes; then
1479	until $opt_dry_run \|\| ln "$progpath" "$lockfile" 2>/dev/null; do
1480	func_echo "Waiting for $lockfile to be removed"
1481	sleep 2
1482	done
1483	elif test "$need_locks" = warn; then
1484	if test -f "$lockfile"; then
1485	$ECHO "\
1486	*** ERROR, $lockfile exists and contains:
1487	`cat $lockfile 2>/dev/null`
1488
1489	This indicates that another process is trying to use the same
1490	temporary object file, and libtool could not work around it because
1491	your compiler does not support \`-c' and \`-o' together. If you
1492	repeat this compilation, it may succeed, by chance, but you had better
1493	avoid parallel builds (make -j) in this platform, or get a better
1494	compiler."
1495
1496	$opt_dry_run \|\| $RM $removelist
1497	exit $EXIT_FAILURE
1498	fi
1499	removelist="$removelist $output_obj"
1500	$ECHO "$srcfile" > "$lockfile"
1501	fi
1502
1503	$opt_dry_run \|\| $RM $removelist
1504	removelist="$removelist $lockfile"
1505	trap '$opt_dry_run \|\| $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1506
1507	if test -n "$fix_srcfile_path"; then
1508	eval "srcfile=\"$fix_srcfile_path\""
1509	fi
1510	func_quote_for_eval "$srcfile"
1511	qsrcfile=$func_quote_for_eval_result
1512
1513	# Only build a PIC object if we are building libtool libraries.
1514	if test "$build_libtool_libs" = yes; then
1515	# Without this assignment, base_compile gets emptied.
1516	fbsd_hideous_sh_bug=$base_compile
1517
1518	if test "$pic_mode" != no; then
1519	command="$base_compile $qsrcfile $pic_flag"
1520	else
1521	# Don't build PIC code
1522	command="$base_compile $qsrcfile"
1523	fi
1524
1525	func_mkdir_p "$xdir$objdir"
1526
1527	if test -z "$output_obj"; then
1528	# Place PIC objects in $objdir
1529	command="$command -o $lobj"
1530	fi
1531
1532	func_show_eval_locale "$command" \
1533	'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1534
1535	if test "$need_locks" = warn &&
1536	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1537	$ECHO "\
1538	*** ERROR, $lockfile contains:
1539	`cat $lockfile 2>/dev/null`
1540
1541	but it should contain:
1542	$srcfile
1543
1544	This indicates that another process is trying to use the same
1545	temporary object file, and libtool could not work around it because
1546	your compiler does not support \`-c' and \`-o' together. If you
1547	repeat this compilation, it may succeed, by chance, but you had better
1548	avoid parallel builds (make -j) in this platform, or get a better
1549	compiler."
1550
1551	$opt_dry_run \|\| $RM $removelist
1552	exit $EXIT_FAILURE
1553	fi
1554
1555	# Just move the object if needed, then go on to compile the next one
1556	if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1557	func_show_eval '$MV "$output_obj" "$lobj"' \
1558	'error=$?; $opt_dry_run \|\| $RM $removelist; exit $error'
1559	fi
1560
1561	# Allow error messages only from the first compilation.
1562	if test "$suppress_opt" = yes; then
1563	suppress_output=' >/dev/null 2>&1'
1564	fi
1565	fi
1566
1567	# Only build a position-dependent object if we build old libraries.
1568	if test "$build_old_libs" = yes; then
1569	if test "$pic_mode" != yes; then
1570	# Don't build PIC code
1571	command="$base_compile $qsrcfile$pie_flag"
1572	else
1573	command="$base_compile $qsrcfile $pic_flag"
1574	fi
1575	if test "$compiler_c_o" = yes; then
1576	command="$command -o $obj"
1577	fi
1578
1579	# Suppress compiler output if we already did a PIC compilation.
1580	command="$command$suppress_output"
1581	func_show_eval_locale "$command" \
1582	'$opt_dry_run \|\| $RM $removelist; exit $EXIT_FAILURE'
1583
1584	if test "$need_locks" = warn &&
1585	test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1586	$ECHO "\
1587	*** ERROR, $lockfile contains:
1588	`cat $lockfile 2>/dev/null`
1589
1590	but it should contain:
1591	$srcfile
1592
1593	This indicates that another process is trying to use the same
1594	temporary object file, and libtool could not work around it because
1595	your compiler does not support \`-c' and \`-o' together. If you
1596	repeat this compilation, it may succeed, by chance, but you had better
1597	avoid parallel builds (make -j) in this platform, or get a better
1598	compiler."
1599
1600	$opt_dry_run \|\| $RM $removelist
1601	exit $EXIT_FAILURE
1602	fi
1603
1604	# Just move the object if needed
1605	if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1606	func_show_eval '$MV "$output_obj" "$obj"' \
1607	'error=$?; $opt_dry_run \|\| $RM $removelist; exit $error'
1608	fi
1609	fi
1610
1611	$opt_dry_run \|\| {
1612	func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1613
1614	# Unlock the critical section if it was locked
1615	if test "$need_locks" != no; then
1616	removelist=$lockfile
1617	$RM "$lockfile"
1618	fi
1619	}
1620
1621	exit $EXIT_SUCCESS
1622	}
1623
1624	$opt_help \|\| {
1625	test "$mode" = compile && func_mode_compile ${1+"$@"}
1626	}
1627
1628	func_mode_help ()
1629	{
1630	# We need to display help for each of the modes.
1631	case $mode in
1632	"")
1633	# Generic help is extracted from the usage comments
1634	# at the start of this file.
1635	func_help
1636	;;
1637
1638	clean)
1639	$ECHO \
1640	"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1641
1642	Remove files from the build directory.
1643
1644	RM is the name of the program to use to delete files associated with each FILE
1645	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1646	to RM.
1647
1648	If FILE is a libtool library, object or program, all the files associated
1649	with it are deleted. Otherwise, only FILE itself is deleted using RM."
1650	;;
1651
1652	compile)
1653	$ECHO \
1654	"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1655
1656	Compile a source file into a libtool library object.
1657
1658	This mode accepts the following additional options:
1659
1660	-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1661	-no-suppress do not suppress compiler output for multiple passes
1662	-prefer-pic try to building PIC objects only
1663	-prefer-non-pic try to building non-PIC objects only
1664	-shared do not build a \`.o' file suitable for static linking
1665	-static only build a \`.o' file suitable for static linking
1666	-Wc,FLAG pass FLAG directly to the compiler
1667
1668	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1669	from the given SOURCEFILE.
1670
1671	The output file name is determined by removing the directory component from
1672	SOURCEFILE, then substituting the C source code suffix \`.c' with the
1673	library object suffix, \`.lo'."
1674	;;
1675
1676	execute)
1677	$ECHO \
1678	"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1679
1680	Automatically set library path, then run a program.
1681
1682	This mode accepts the following additional options:
1683
1684	-dlopen FILE add the directory containing FILE to the library path
1685
1686	This mode sets the library path environment variable according to \`-dlopen'
1687	flags.
1688
1689	If any of the ARGS are libtool executable wrappers, then they are translated
1690	into their corresponding uninstalled binary, and any of their required library
1691	directories are added to the library path.
1692
1693	Then, COMMAND is executed, with ARGS as arguments."
1694	;;
1695
1696	finish)
1697	$ECHO \
1698	"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1699
1700	Complete the installation of libtool libraries.
1701
1702	Each LIBDIR is a directory that contains libtool libraries.
1703
1704	The commands that this mode executes may require superuser privileges. Use
1705	the \`--dry-run' option if you just want to see what would be executed."
1706	;;
1707
1708	install)
1709	$ECHO \
1710	"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1711
1712	Install executables or libraries.
1713
1714	INSTALL-COMMAND is the installation command. The first component should be
1715	either the \`install' or \`cp' program.
1716
1717	The following components of INSTALL-COMMAND are treated specially:
1718
1719	-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1720
1721	The rest of the components are interpreted as arguments to that command (only
1722	BSD-compatible install options are recognized)."
1723	;;
1724
1725	link)
1726	$ECHO \
1727	"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1728
1729	Link object files or libraries together to form another library, or to
1730	create an executable program.
1731
1732	LINK-COMMAND is a command using the C compiler that you would use to create
1733	a program from several object files.
1734
1735	The following components of LINK-COMMAND are treated specially:
1736
1737	-all-static do not do any dynamic linking at all
1738	-avoid-version do not add a version suffix if possible
1739	-bindir BINDIR specify path to binaries directory (for systems where
1740	libraries must be found in the PATH setting at runtime)
1741	-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1742	-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1743	-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1744	-export-symbols SYMFILE
1745	try to export only the symbols listed in SYMFILE
1746	-export-symbols-regex REGEX
1747	try to export only the symbols matching REGEX
1748	-LLIBDIR search LIBDIR for required installed libraries
1749	-lNAME OUTPUT-FILE requires the installed library libNAME
1750	-module build a library that can dlopened
1751	-no-fast-install disable the fast-install mode
1752	-no-install link a not-installable executable
1753	-no-undefined declare that a library does not refer to external symbols
1754	-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1755	-objectlist FILE Use a list of object files found in FILE to specify objects
1756	-precious-files-regex REGEX
1757	don't remove output files matching REGEX
1758	-release RELEASE specify package release information
1759	-rpath LIBDIR the created library will eventually be installed in LIBDIR
1760	-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1761	-shared only do dynamic linking of libtool libraries
1762	-shrext SUFFIX override the standard shared library file extension
1763	-static do not do any dynamic linking of uninstalled libtool libraries
1764	-static-libtool-libs
1765	do not do any dynamic linking of libtool libraries
1766	-version-info CURRENT[:REVISION[:AGE]]
1767	specify library version info [each variable defaults to 0]
1768	-weak LIBNAME declare that the target provides the LIBNAME interface
1769	-Wc,FLAG
1770	-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
1771	-Wl,FLAG
1772	-Xlinker FLAG pass linker-specific FLAG directly to the linker
1773	-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
1774
1775	All other options (arguments beginning with \`-') are ignored.
1776
1777	Every other argument is treated as a filename. Files ending in \`.la' are
1778	treated as uninstalled libtool libraries, other files are standard or library
1779	object files.
1780
1781	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1782	only library objects (\`.lo' files) may be specified, and \`-rpath' is
1783	required, except when creating a convenience library.
1784
1785	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1786	using \`ar' and \`ranlib', or on Windows using \`lib'.
1787
1788	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1789	is created, otherwise an executable program is created."
1790	;;
1791
1792	uninstall)
1793	$ECHO \
1794	"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1795
1796	Remove libraries from an installation directory.
1797
1798	RM is the name of the program to use to delete files associated with each FILE
1799	(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1800	to RM.
1801
1802	If FILE is a libtool library, all the files associated with it are deleted.
1803	Otherwise, only FILE itself is deleted using RM."
1804	;;
1805
1806	*)
1807	func_fatal_help "invalid operation mode \`$mode'"
1808	;;
1809	esac
1810
1811	echo
1812	$ECHO "Try \`$progname --help' for more information about other modes."
1813	}
1814
1815	# Now that we've collected a possible --mode arg, show help if necessary
1816	if $opt_help; then
1817	if test "$opt_help" = :; then
1818	func_mode_help
1819	else
1820	{
1821	func_help noexit
1822	for mode in compile link execute install finish uninstall clean; do
1823	func_mode_help
1824	done
1825	} \| sed -n '1p; 2,$s/^Usage:/ or: /p'
1826	{
1827	func_help noexit
1828	for mode in compile link execute install finish uninstall clean; do
1829	echo
1830	func_mode_help
1831	done
1832	} \|
1833	sed '1d
1834	/^When reporting/,/^Report/{
1835	H
1836	d
1837	}
1838	$x
1839	/information about other modes/d
1840	/more detailed .*MODE/d
1841	s/^Usage:.--mode=$[^ ]$ .*/Description of \1 mode:/'
1842	fi
1843	exit $?
1844	fi
1845
1846
1847	# func_mode_execute arg...
1848	func_mode_execute ()
1849	{
1850	$opt_debug
1851	# The first argument is the command name.
1852	cmd="$nonopt"
1853	test -z "$cmd" && \
1854	func_fatal_help "you must specify a COMMAND"
1855
1856	# Handle -dlopen flags immediately.
1857	for file in $execute_dlfiles; do
1858	test -f "$file" \
1859	\|\| func_fatal_help "\`$file' is not a file"
1860
1861	dir=
1862	case $file in
1863	*.la)
1864	# Check to see that this really is a libtool archive.
1865	func_lalib_unsafe_p "$file" \
1866	\|\| func_fatal_help "\`$lib' is not a valid libtool archive"
1867
1868	# Read the libtool library.
1869	dlname=
1870	library_names=
1871	func_source "$file"
1872
1873	# Skip this library if it cannot be dlopened.
1874	if test -z "$dlname"; then
1875	# Warn if it was a shared library.
1876	test -n "$library_names" && \
1877	func_warning "\`$file' was not linked with \`-export-dynamic'"
1878	continue
1879	fi
1880
1881	func_dirname "$file" "" "."
1882	dir="$func_dirname_result"
1883
1884	if test -f "$dir/$objdir/$dlname"; then
1885	dir="$dir/$objdir"
1886	else
1887	if test ! -f "$dir/$dlname"; then
1888	func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1889	fi
1890	fi
1891	;;
1892
1893	*.lo)
1894	# Just add the directory containing the .lo file.
1895	func_dirname "$file" "" "."
1896	dir="$func_dirname_result"
1897	;;
1898
1899	*)
1900	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1901	continue
1902	;;
1903	esac
1904
1905	# Get the absolute pathname.
1906	absdir=`cd "$dir" && pwd`
1907	test -n "$absdir" && dir="$absdir"
1908
1909	# Now add the directory to shlibpath_var.
1910	if eval test -z \"\$$shlibpath_var\"; then
1911	eval $shlibpath_var=\$dir
1912	else
1913	eval $shlibpath_var=\$dir:\$$shlibpath_var
1914	fi
1915	done
1916
1917	# This variable tells wrapper scripts just to set shlibpath_var
1918	# rather than running their programs.
1919	libtool_execute_magic="$magic"
1920
1921	# Check if any of the arguments is a wrapper script.
1922	args=
1923	for file
1924	do
1925	case $file in
1926	-* \| .la \| .lo ) ;;
1927	*)
1928	# Do a test to see if this is really a libtool program.
1929	if func_ltwrapper_script_p "$file"; then
1930	func_source "$file"
1931	# Transform arg to wrapped name.
1932	file="$progdir/$program"
1933	elif func_ltwrapper_executable_p "$file"; then
1934	func_ltwrapper_scriptname "$file"
1935	func_source "$func_ltwrapper_scriptname_result"
1936	# Transform arg to wrapped name.
1937	file="$progdir/$program"
1938	fi
1939	;;
1940	esac
1941	# Quote arguments (to preserve shell metacharacters).
1942	func_quote_for_eval "$file"
1943	args="$args $func_quote_for_eval_result"
1944	done
1945
1946	if test "X$opt_dry_run" = Xfalse; then
1947	if test -n "$shlibpath_var"; then
1948	# Export the shlibpath_var.
1949	eval "export $shlibpath_var"
1950	fi
1951
1952	# Restore saved environment variables
1953	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1954	do
1955	eval "if test \"\${save_$lt_var+set}\" = set; then
1956	$lt_var=\$save_$lt_var; export $lt_var
1957	else
1958	$lt_unset $lt_var
1959	fi"
1960	done
1961
1962	# Now prepare to actually exec the command.
1963	exec_cmd="\$cmd$args"
1964	else
1965	# Display what would be done.
1966	if test -n "$shlibpath_var"; then
1967	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1968	echo "export $shlibpath_var"
1969	fi
1970	$ECHO "$cmd$args"
1971	exit $EXIT_SUCCESS
1972	fi
1973	}
1974
1975	test "$mode" = execute && func_mode_execute ${1+"$@"}
1976
1977
1978	# func_mode_finish arg...
1979	func_mode_finish ()
1980	{
1981	$opt_debug
1982	libdirs="$nonopt"
1983	admincmds=
1984
1985	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1986	for dir
1987	do
1988	libdirs="$libdirs $dir"
1989	done
1990
1991	for libdir in $libdirs; do
1992	if test -n "$finish_cmds"; then
1993	# Do each command in the finish commands.
1994	func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1995	'"$cmd"'"'
1996	fi
1997	if test -n "$finish_eval"; then
1998	# Do the single finish_eval.
1999	eval cmds=\"$finish_eval\"
2000	$opt_dry_run \|\| eval "$cmds" \|\| admincmds="$admincmds
2001	$cmds"
2002	fi
2003	done
2004	fi
2005
2006	# Exit here if they wanted silent mode.
2007	$opt_silent && exit $EXIT_SUCCESS
2008
2009	echo "----------------------------------------------------------------------"
2010	echo "Libraries have been installed in:"
2011	for libdir in $libdirs; do
2012	$ECHO " $libdir"
2013	done
2014	echo
2015	echo "If you ever happen to want to link against installed libraries"
2016	echo "in a given directory, LIBDIR, you must either use libtool, and"
2017	echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2018	echo "flag during linking and do at least one of the following:"
2019	if test -n "$shlibpath_var"; then
2020	echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2021	echo " during execution"
2022	fi
2023	if test -n "$runpath_var"; then
2024	echo " - add LIBDIR to the \`$runpath_var' environment variable"
2025	echo " during linking"
2026	fi
2027	if test -n "$hardcode_libdir_flag_spec"; then
2028	libdir=LIBDIR
2029	eval "flag=\"$hardcode_libdir_flag_spec\""
2030
2031	$ECHO " - use the \`$flag' linker flag"
2032	fi
2033	if test -n "$admincmds"; then
2034	$ECHO " - have your system administrator run these commands:$admincmds"
2035	fi
2036	if test -f /etc/ld.so.conf; then
2037	echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2038	fi
2039	echo
2040
2041	echo "See any operating system documentation about shared libraries for"
2042	case $host in
2043	solaris2.[6789]\|solaris2.1[0-9])
2044	echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2045	echo "pages."
2046	;;
2047	*)
2048	echo "more information, such as the ld(1) and ld.so(8) manual pages."
2049	;;
2050	esac
2051	echo "----------------------------------------------------------------------"
2052	exit $EXIT_SUCCESS
2053	}
2054
2055	test "$mode" = finish && func_mode_finish ${1+"$@"}
2056
2057
2058	# func_mode_install arg...
2059	func_mode_install ()
2060	{
2061	$opt_debug
2062	# There may be an optional sh(1) argument at the beginning of
2063	# install_prog (especially on Windows NT).
2064	if test "$nonopt" = "$SHELL" \|\| test "$nonopt" = /bin/sh \|\|
2065	# Allow the use of GNU shtool's install command.
2066	case $nonopt in shtool) :;; *) false;; esac; then
2067	# Aesthetically quote it.
2068	func_quote_for_eval "$nonopt"
2069	install_prog="$func_quote_for_eval_result "
2070	arg=$1
2071	shift
2072	else
2073	install_prog=
2074	arg=$nonopt
2075	fi
2076
2077	# The real first argument should be the name of the installation program.
2078	# Aesthetically quote it.
2079	func_quote_for_eval "$arg"
2080	install_prog="$install_prog$func_quote_for_eval_result"
2081	install_shared_prog=$install_prog
2082	case " $install_prog " in
2083	[\\\ /]cp\ ) install_cp=: ;;
2084	*) install_cp=false ;;
2085	esac
2086
2087	# We need to accept at least all the BSD install flags.
2088	dest=
2089	files=
2090	opts=
2091	prev=
2092	install_type=
2093	isdir=no
2094	stripme=
2095	no_mode=:
2096	for arg
2097	do
2098	arg2=
2099	if test -n "$dest"; then
2100	files="$files $dest"
2101	dest=$arg
2102	continue
2103	fi
2104
2105	case $arg in
2106	-d) isdir=yes ;;
2107	-f)
2108	if $install_cp; then :; else
2109	prev=$arg
2110	fi
2111	;;
2112	-g \| -m \| -o)
2113	prev=$arg
2114	;;
2115	-s)
2116	stripme=" -s"
2117	continue
2118	;;
2119	-*)
2120	;;
2121	*)
2122	# If the previous option needed an argument, then skip it.
2123	if test -n "$prev"; then
2124	if test "x$prev" = x-m && test -n "$install_override_mode"; then
2125	arg2=$install_override_mode
2126	no_mode=false
2127	fi
2128	prev=
2129	else
2130	dest=$arg
2131	continue
2132	fi
2133	;;
2134	esac
2135
2136	# Aesthetically quote the argument.
2137	func_quote_for_eval "$arg"
2138	install_prog="$install_prog $func_quote_for_eval_result"
2139	if test -n "$arg2"; then
2140	func_quote_for_eval "$arg2"
2141	fi
2142	install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2143	done
2144
2145	test -z "$install_prog" && \
2146	func_fatal_help "you must specify an install program"
2147
2148	test -n "$prev" && \
2149	func_fatal_help "the \`$prev' option requires an argument"
2150
2151	if test -n "$install_override_mode" && $no_mode; then
2152	if $install_cp; then :; else
2153	func_quote_for_eval "$install_override_mode"
2154	install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2155	fi
2156	fi
2157
2158	if test -z "$files"; then
2159	if test -z "$dest"; then
2160	func_fatal_help "no file or destination specified"
2161	else
2162	func_fatal_help "you must specify a destination"
2163	fi
2164	fi
2165
2166	# Strip any trailing slash from the destination.
2167	func_stripname '' '/' "$dest"
2168	dest=$func_stripname_result
2169
2170	# Check to see that the destination is a directory.
2171	test -d "$dest" && isdir=yes
2172	if test "$isdir" = yes; then
2173	destdir="$dest"
2174	destname=
2175	else
2176	func_dirname_and_basename "$dest" "" "."
2177	destdir="$func_dirname_result"
2178	destname="$func_basename_result"
2179
2180	# Not a directory, so check to see that there is only one file specified.
2181	set dummy $files; shift
2182	test "$#" -gt 1 && \
2183	func_fatal_help "\`$dest' is not a directory"
2184	fi
2185	case $destdir in
2186	[\\/]* \| [A-Za-z]:[\\/]*) ;;
2187	*)
2188	for file in $files; do
2189	case $file in
2190	*.lo) ;;
2191	*)
2192	func_fatal_help "\`$destdir' must be an absolute directory name"
2193	;;
2194	esac
2195	done
2196	;;
2197	esac
2198
2199	# This variable tells wrapper scripts just to set variables rather
2200	# than running their programs.
2201	libtool_install_magic="$magic"
2202
2203	staticlibs=
2204	future_libdirs=
2205	current_libdirs=
2206	for file in $files; do
2207
2208	# Do each installation.
2209	case $file in
2210	*.$libext)
2211	# Do the static libraries later.
2212	staticlibs="$staticlibs $file"
2213	;;
2214
2215	*.la)
2216	# Check to see that this really is a libtool archive.
2217	func_lalib_unsafe_p "$file" \
2218	\|\| func_fatal_help "\`$file' is not a valid libtool archive"
2219
2220	library_names=
2221	old_library=
2222	relink_command=
2223	func_source "$file"
2224
2225	# Add the libdir to current_libdirs if it is the destination.
2226	if test "X$destdir" = "X$libdir"; then
2227	case "$current_libdirs " in
2228	" $libdir ") ;;
2229	*) current_libdirs="$current_libdirs $libdir" ;;
2230	esac
2231	else
2232	# Note the libdir as a future libdir.
2233	case "$future_libdirs " in
2234	" $libdir ") ;;
2235	*) future_libdirs="$future_libdirs $libdir" ;;
2236	esac
2237	fi
2238
2239	func_dirname "$file" "/" ""
2240	dir="$func_dirname_result"
2241	dir="$dir$objdir"
2242
2243	if test -n "$relink_command"; then
2244	# Determine the prefix the user has applied to our future dir.
2245	inst_prefix_dir=`$ECHO "$destdir" \| $SED -e "s%$libdir\$%%"`
2246
2247	# Don't allow the user to place us outside of our expected
2248	# location b/c this prevents finding dependent libraries that
2249	# are installed to the same prefix.
2250	# At present, this check doesn't affect windows .dll's that
2251	# are installed into $libdir/../bin (currently, that works fine)
2252	# but it's something to keep an eye on.
2253	test "$inst_prefix_dir" = "$destdir" && \
2254	func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2255
2256	if test -n "$inst_prefix_dir"; then
2257	# Stick the inst_prefix_dir data into the link command.
2258	relink_command=`$ECHO "$relink_command" \| $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2259	else
2260	relink_command=`$ECHO "$relink_command" \| $SED "s%@inst_prefix_dir@%%"`
2261	fi
2262
2263	func_warning "relinking \`$file'"
2264	func_show_eval "$relink_command" \
2265	'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2266	fi
2267
2268	# See the names of the shared library.
2269	set dummy $library_names; shift
2270	if test -n "$1"; then
2271	realname="$1"
2272	shift
2273
2274	srcname="$realname"
2275	test -n "$relink_command" && srcname="$realname"T
2276
2277	# Install the shared library and build the symlinks.
2278	func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2279	'exit $?'
2280	tstripme="$stripme"
2281	case $host_os in
2282	cygwin* \| mingw* \| pw32* \| cegcc*)
2283	case $realname in
2284	*.dll.a)
2285	tstripme=""
2286	;;
2287	esac
2288	;;
2289	esac
2290	if test -n "$tstripme" && test -n "$striplib"; then
2291	func_show_eval "$striplib $destdir/$realname" 'exit $?'
2292	fi
2293
2294	if test "$#" -gt 0; then
2295	# Delete the old symlinks, and create new ones.
2296	# Try `ln -sf' first, because the `ln' binary might depend on
2297	# the symlink we replace! Solaris /bin/ln does not understand -f,
2298	# so we also need to try rm && ln -s.
2299	for linkname
2300	do
2301	test "$linkname" != "$realname" \
2302	&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname \|\| { $RM $linkname && $LN_S $realname $linkname; }; })"
2303	done
2304	fi
2305
2306	# Do each command in the postinstall commands.
2307	lib="$destdir/$realname"
2308	func_execute_cmds "$postinstall_cmds" 'exit $?'
2309	fi
2310
2311	# Install the pseudo-library for information purposes.
2312	func_basename "$file"
2313	name="$func_basename_result"
2314	instname="$dir/$name"i
2315	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2316
2317	# Maybe install the static library, too.
2318	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2319	;;
2320
2321	*.lo)
2322	# Install (i.e. copy) a libtool object.
2323
2324	# Figure out destination file name, if it wasn't already specified.
2325	if test -n "$destname"; then
2326	destfile="$destdir/$destname"
2327	else
2328	func_basename "$file"
2329	destfile="$func_basename_result"
2330	destfile="$destdir/$destfile"
2331	fi
2332
2333	# Deduce the name of the destination old-style object file.
2334	case $destfile in
2335	*.lo)
2336	func_lo2o "$destfile"
2337	staticdest=$func_lo2o_result
2338	;;
2339	*.$objext)
2340	staticdest="$destfile"
2341	destfile=
2342	;;
2343	*)
2344	func_fatal_help "cannot copy a libtool object to \`$destfile'"
2345	;;
2346	esac
2347
2348	# Install the libtool object if requested.
2349	test -n "$destfile" && \
2350	func_show_eval "$install_prog $file $destfile" 'exit $?'
2351
2352	# Install the old object if enabled.
2353	if test "$build_old_libs" = yes; then
2354	# Deduce the name of the old-style object file.
2355	func_lo2o "$file"
2356	staticobj=$func_lo2o_result
2357	func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2358	fi
2359	exit $EXIT_SUCCESS
2360	;;
2361
2362	*)
2363	# Figure out destination file name, if it wasn't already specified.
2364	if test -n "$destname"; then
2365	destfile="$destdir/$destname"
2366	else
2367	func_basename "$file"
2368	destfile="$func_basename_result"
2369	destfile="$destdir/$destfile"
2370	fi
2371
2372	# If the file is missing, and there is a .exe on the end, strip it
2373	# because it is most likely a libtool script we actually want to
2374	# install
2375	stripped_ext=""
2376	case $file in
2377	*.exe)
2378	if test ! -f "$file"; then
2379	func_stripname '' '.exe' "$file"
2380	file=$func_stripname_result
2381	stripped_ext=".exe"
2382	fi
2383	;;
2384	esac
2385
2386	# Do a test to see if this is really a libtool program.
2387	case $host in
2388	cygwin \| mingw)
2389	if func_ltwrapper_executable_p "$file"; then
2390	func_ltwrapper_scriptname "$file"
2391	wrapper=$func_ltwrapper_scriptname_result
2392	else
2393	func_stripname '' '.exe' "$file"
2394	wrapper=$func_stripname_result
2395	fi
2396	;;
2397	*)
2398	wrapper=$file
2399	;;
2400	esac
2401	if func_ltwrapper_script_p "$wrapper"; then
2402	notinst_deplibs=
2403	relink_command=
2404
2405	func_source "$wrapper"
2406
2407	# Check the variables that should have been set.
2408	test -z "$generated_by_libtool_version" && \
2409	func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2410
2411	finalize=yes
2412	for lib in $notinst_deplibs; do
2413	# Check to see that each library is installed.
2414	libdir=
2415	if test -f "$lib"; then
2416	func_source "$lib"
2417	fi
2418	libfile="$libdir/"`$ECHO "$lib" \| $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2419	if test -n "$libdir" && test ! -f "$libfile"; then
2420	func_warning "\`$lib' has not been installed in \`$libdir'"
2421	finalize=no
2422	fi
2423	done
2424
2425	relink_command=
2426	func_source "$wrapper"
2427
2428	outputname=
2429	if test "$fast_install" = no && test -n "$relink_command"; then
2430	$opt_dry_run \|\| {
2431	if test "$finalize" = yes; then
2432	tmpdir=`func_mktempdir`
2433	func_basename "$file$stripped_ext"
2434	file="$func_basename_result"
2435	outputname="$tmpdir/$file"
2436	# Replace the output file specification.
2437	relink_command=`$ECHO "$relink_command" \| $SED 's%@OUTPUT@%'"$outputname"'%g'`
2438
2439	$opt_silent \|\| {
2440	func_quote_for_expand "$relink_command"
2441	eval "func_echo $func_quote_for_expand_result"
2442	}
2443	if eval "$relink_command"; then :
2444	else
2445	func_error "error: relink \`$file' with the above command before installing it"
2446	$opt_dry_run \|\| ${RM}r "$tmpdir"
2447	continue
2448	fi
2449	file="$outputname"
2450	else
2451	func_warning "cannot relink \`$file'"
2452	fi
2453	}
2454	else
2455	# Install the binary that we compiled earlier.
2456	file=`$ECHO "$file$stripped_ext" \| $SED "s%$[^/]*$$%$objdir/\1%"`
2457	fi
2458	fi
2459
2460	# remove .exe since cygwin /usr/bin/install will append another
2461	# one anyway
2462	case $install_prog,$host in
2463	/usr/bin/install,cygwin)
2464	case $file:$destfile in
2465	.exe:.exe)
2466	# this is ok
2467	;;
2468	.exe:)
2469	destfile=$destfile.exe
2470	;;
2471	:.exe)
2472	func_stripname '' '.exe' "$destfile"
2473	destfile=$func_stripname_result
2474	;;
2475	esac
2476	;;
2477	esac
2478	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2479	$opt_dry_run \|\| if test -n "$outputname"; then
2480	${RM}r "$tmpdir"
2481	fi
2482	;;
2483	esac
2484	done
2485
2486	for file in $staticlibs; do
2487	func_basename "$file"
2488	name="$func_basename_result"
2489
2490	# Set up the ranlib parameters.
2491	oldlib="$destdir/$name"
2492
2493	func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2494
2495	if test -n "$stripme" && test -n "$old_striplib"; then
2496	func_show_eval "$old_striplib $oldlib" 'exit $?'
2497	fi
2498
2499	# Do each command in the postinstall commands.
2500	func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2501	done
2502
2503	test -n "$future_libdirs" && \
2504	func_warning "remember to run \`$progname --finish$future_libdirs'"
2505
2506	if test -n "$current_libdirs" && $opt_finish; then
2507	# Maybe just do a dry run.
2508	$opt_dry_run && current_libdirs=" -n$current_libdirs"
2509	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2510	else
2511	exit $EXIT_SUCCESS
2512	fi
2513	}
2514
2515	test "$mode" = install && func_mode_install ${1+"$@"}
2516
2517
2518	# func_generate_dlsyms outputname originator pic_p
2519	# Extract symbols from dlprefiles and create ${outputname}S.o with
2520	# a dlpreopen symbol table.
2521	func_generate_dlsyms ()
2522	{
2523	$opt_debug
2524	my_outputname="$1"
2525	my_originator="$2"
2526	my_pic_p="${3-no}"
2527	my_prefix=`$ECHO "$my_originator" \| sed 's%[^a-zA-Z0-9]%_%g'`
2528	my_dlsyms=
2529
2530	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
2531	if test -n "$NM" && test -n "$global_symbol_pipe"; then
2532	my_dlsyms="${my_outputname}S.c"
2533	else
2534	func_error "not configured to extract global symbols from dlpreopened files"
2535	fi
2536	fi
2537
2538	if test -n "$my_dlsyms"; then
2539	case $my_dlsyms in
2540	"") ;;
2541	*.c)
2542	# Discover the nlist of each of the dlfiles.
2543	nlist="$output_objdir/${my_outputname}.nm"
2544
2545	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2546
2547	# Parse the name list into a source file.
2548	func_verbose "creating $output_objdir/$my_dlsyms"
2549
2550	$opt_dry_run \|\| $ECHO > "$output_objdir/$my_dlsyms" "\
2551	/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2552	/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2553
2554	#ifdef __cplusplus
2555	extern \"C\" {
2556	#endif
2557
2558	#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) \|\| (__GNUC__ > 4))
2559	#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2560	#endif
2561
2562	/* External symbol declarations for the compiler. */\
2563	"
2564
2565	if test "$dlself" = yes; then
2566	func_verbose "generating symbol list for \`$output'"
2567
2568	$opt_dry_run \|\| echo ': @PROGRAM@ ' > "$nlist"
2569
2570	# Add our own program objects to the symbol list.
2571	progfiles=`$ECHO "$objs$old_deplibs" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
2572	for progfile in $progfiles; do
2573	func_verbose "extracting global C symbols from \`$progfile'"
2574	$opt_dry_run \|\| eval "$NM $progfile \| $global_symbol_pipe >> '$nlist'"
2575	done
2576
2577	if test -n "$exclude_expsyms"; then
2578	$opt_dry_run \|\| {
2579	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2580	$MV "$nlist"T "$nlist"
2581	}
2582	fi
2583
2584	if test -n "$export_symbols_regex"; then
2585	$opt_dry_run \|\| {
2586	$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T
2587	$MV "$nlist"T "$nlist"
2588	}
2589	fi
2590
2591	# Prepare the list of exported symbols
2592	if test -z "$export_symbols"; then
2593	export_symbols="$output_objdir/$outputname.exp"
2594	$opt_dry_run \|\| {
2595	$RM $export_symbols
2596	${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' < "$nlist" > "$export_symbols"
2597	case $host in
2598	cygwin \| mingw \| cegcc )
2599	echo EXPORTS > "$output_objdir/$outputname.def"
2600	cat "$export_symbols" >> "$output_objdir/$outputname.def"
2601	;;
2602	esac
2603	}
2604	else
2605	$opt_dry_run \|\| {
2606	${SED} -e 's/$[].[*^$]$/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp"
2607	$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T
2608	$MV "$nlist"T "$nlist"
2609	case $host in
2610	cygwin \| mingw \| cegcc )
2611	echo EXPORTS > "$output_objdir/$outputname.def"
2612	cat "$nlist" >> "$output_objdir/$outputname.def"
2613	;;
2614	esac
2615	}
2616	fi
2617	fi
2618
2619	for dlprefile in $dlprefiles; do
2620	func_verbose "extracting global C symbols from \`$dlprefile'"
2621	func_basename "$dlprefile"
2622	name="$func_basename_result"
2623	$opt_dry_run \|\| {
2624	$ECHO ": $name " >> "$nlist"
2625	eval "$NM $dlprefile 2>/dev/null \| $global_symbol_pipe >> '$nlist'"
2626	}
2627	done
2628
2629	$opt_dry_run \|\| {
2630	# Make sure we have at least an empty file.
2631	test -f "$nlist" \|\| : > "$nlist"
2632
2633	if test -n "$exclude_expsyms"; then
2634	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2635	$MV "$nlist"T "$nlist"
2636	fi
2637
2638	# Try sorting and uniquifying the output.
2639	if $GREP -v "^: " < "$nlist" \|
2640	if sort -k 3 </dev/null >/dev/null 2>&1; then
2641	sort -k 3
2642	else
2643	sort +2
2644	fi \|
2645	uniq > "$nlist"S; then
2646	:
2647	else
2648	$GREP -v "^: " < "$nlist" > "$nlist"S
2649	fi
2650
2651	if test -f "$nlist"S; then
2652	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2653	else
2654	echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2655	fi
2656
2657	echo >> "$output_objdir/$my_dlsyms" "\
2658
2659	/* The mapping between symbol names and symbols. */
2660	typedef struct {
2661	const char *name;
2662	void *address;
2663	} lt_dlsymlist;
2664	"
2665	case $host in
2666	cygwin \| mingw \| cegcc )
2667	echo >> "$output_objdir/$my_dlsyms" "\
2668	/* DATA imports from DLLs on WIN32 con't be const, because
2669	runtime relocations are performed -- see ld's documentation
2670	on pseudo-relocs. */"
2671	lt_dlsym_const= ;;
2672	osf5)
2673	echo >> "$output_objdir/$my_dlsyms" "\
2674	/* This system does not cope well with relocations in const data */"
2675	lt_dlsym_const= ;;
2676	*)
2677	lt_dlsym_const=const ;;
2678	esac
2679
2680	echo >> "$output_objdir/$my_dlsyms" "\
2681	extern $lt_dlsym_const lt_dlsymlist
2682	lt_${my_prefix}_LTX_preloaded_symbols[];
2683	$lt_dlsym_const lt_dlsymlist
2684	lt_${my_prefix}_LTX_preloaded_symbols[] =
2685	{\
2686	{ \"$my_originator\", (void *) 0 },"
2687
2688	case $need_lib_prefix in
2689	no)
2690	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2691	;;
2692	*)
2693	eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2694	;;
2695	esac
2696	echo >> "$output_objdir/$my_dlsyms" "\
2697	{0, (void *) 0}
2698	};
2699
2700	/* This works around a problem in FreeBSD linker */
2701	#ifdef FREEBSD_WORKAROUND
2702	static const void *lt_preloaded_setup() {
2703	return lt_${my_prefix}_LTX_preloaded_symbols;
2704	}
2705	#endif
2706
2707	#ifdef __cplusplus
2708	}
2709	#endif\
2710	"
2711	} # !$opt_dry_run
2712
2713	pic_flag_for_symtable=
2714	case "$compile_command " in
2715	" -static ") ;;
2716	*)
2717	case $host in
2718	# compiling the symbol table file with pic_flag works around
2719	# a FreeBSD bug that causes programs to crash when -lm is
2720	# linked before any other PIC object. But we must not use
2721	# pic_flag when linking with -static. The problem exists in
2722	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2723	--freebsd2\|--freebsd3.0\|--freebsdelf3.0*)
2724	pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2725	--hpux*)
2726	pic_flag_for_symtable=" $pic_flag" ;;
2727	*)
2728	if test "X$my_pic_p" != Xno; then
2729	pic_flag_for_symtable=" $pic_flag"
2730	fi
2731	;;
2732	esac
2733	;;
2734	esac
2735	symtab_cflags=
2736	for arg in $LTCFLAGS; do
2737	case $arg in
2738	-pie \| -fpie \| -fPIE) ;;
2739	*) symtab_cflags="$symtab_cflags $arg" ;;
2740	esac
2741	done
2742
2743	# Now compile the dynamic symbol file.
2744	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2745
2746	# Clean up the generated files.
2747	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2748
2749	# Transform the symbol file into the correct name.
2750	symfileobj="$output_objdir/${my_outputname}S.$objext"
2751	case $host in
2752	cygwin \| mingw \| cegcc )
2753	if test -f "$output_objdir/$my_outputname.def"; then
2754	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2755	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2756	else
2757	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
2758	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
2759	fi
2760	;;
2761	*)
2762	compile_command=`$ECHO "$compile_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
2763	finalize_command=`$ECHO "$finalize_command" \| $SED "s%@SYMFILE@%$symfileobj%"`
2764	;;
2765	esac
2766	;;
2767	*)
2768	func_fatal_error "unknown suffix for \`$my_dlsyms'"
2769	;;
2770	esac
2771	else
2772	# We keep going just in case the user didn't refer to
2773	# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2774	# really was required.
2775
2776	# Nullify the symbol file.
2777	compile_command=`$ECHO "$compile_command" \| $SED "s% @SYMFILE@%%"`
2778	finalize_command=`$ECHO "$finalize_command" \| $SED "s% @SYMFILE@%%"`
2779	fi
2780	}
2781
2782	# func_win32_libid arg
2783	# return the library type of file 'arg'
2784	#
2785	# Need a lot of goo to handle both DLLs and import libs
2786	# Has to be a shell function in order to 'eat' the argument
2787	# that is supplied when $file_magic_command is called.
2788	# Despite the name, also deal with 64 bit binaries.
2789	func_win32_libid ()
2790	{
2791	$opt_debug
2792	win32_libid_type="unknown"
2793	win32_fileres=`file -L $1 2>/dev/null`
2794	case $win32_fileres in
2795	ar\ archive\ import\ library) # definitely import
2796	win32_libid_type="x86 archive import"
2797	;;
2798	ar\ archive) # could be an import, or static
2799	if $OBJDUMP -f "$1" \| $SED -e '10q' 2>/dev/null \|
2800	$EGREP 'file format (pe-i386(.*architecture: i386)?\|pe-arm-wince\|pe-x86-64)' >/dev/null; then
2801	win32_nmres=`$NM -f posix -A "$1" \|
2802	$SED -n -e '
2803	1,100{
2804	/ I /{
2805	s,.*,import,
2806	p
2807	q
2808	}
2809	}'`
2810	case $win32_nmres in
2811	import*) win32_libid_type="x86 archive import";;
2812	*) win32_libid_type="x86 archive static";;
2813	esac
2814	fi
2815	;;
2816	DLL)
2817	win32_libid_type="x86 DLL"
2818	;;
2819	executable) # but shell scripts are "executable" too...
2820	case $win32_fileres in
2821	MS\ Windows\ PE\ Intel)
2822	win32_libid_type="x86 DLL"
2823	;;
2824	esac
2825	;;
2826	esac
2827	$ECHO "$win32_libid_type"
2828	}
2829
2830
2831
2832	# func_extract_an_archive dir oldlib
2833	func_extract_an_archive ()
2834	{
2835	$opt_debug
2836	f_ex_an_ar_dir="$1"; shift
2837	f_ex_an_ar_oldlib="$1"
2838	if test "$lock_old_archive_extraction" = yes; then
2839	lockfile=$f_ex_an_ar_oldlib.lock
2840	until $opt_dry_run \|\| ln "$progpath" "$lockfile" 2>/dev/null; do
2841	func_echo "Waiting for $lockfile to be removed"
2842	sleep 2
2843	done
2844	fi
2845	func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2846	'stat=$?; rm -f "$lockfile"; exit $stat'
2847	if test "$lock_old_archive_extraction" = yes; then
2848	$opt_dry_run \|\| rm -f "$lockfile"
2849	fi
2850	if ($AR t "$f_ex_an_ar_oldlib" \| sort \| sort -uc >/dev/null 2>&1); then
2851	:
2852	else
2853	func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2854	fi
2855	}
2856
2857
2858	# func_extract_archives gentop oldlib ...
2859	func_extract_archives ()
2860	{
2861	$opt_debug
2862	my_gentop="$1"; shift
2863	my_oldlibs=${1+"$@"}
2864	my_oldobjs=""
2865	my_xlib=""
2866	my_xabs=""
2867	my_xdir=""
2868
2869	for my_xlib in $my_oldlibs; do
2870	# Extract the objects.
2871	case $my_xlib in
2872	[\\/]* \| [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2873	*) my_xabs=`pwd`"/$my_xlib" ;;
2874	esac
2875	func_basename "$my_xlib"
2876	my_xlib="$func_basename_result"
2877	my_xlib_u=$my_xlib
2878	while :; do
2879	case " $extracted_archives " in
2880	" $my_xlib_u ")
2881	func_arith $extracted_serial + 1
2882	extracted_serial=$func_arith_result
2883	my_xlib_u=lt$extracted_serial-$my_xlib ;;
2884	*) break ;;
2885	esac
2886	done
2887	extracted_archives="$extracted_archives $my_xlib_u"
2888	my_xdir="$my_gentop/$my_xlib_u"
2889
2890	func_mkdir_p "$my_xdir"
2891
2892	case $host in
2893	-darwin)
2894	func_verbose "Extracting $my_xabs"
2895	# Do not bother doing anything if just a dry run
2896	$opt_dry_run \|\| {
2897	darwin_orig_dir=`pwd`
2898	cd $my_xdir \|\| exit $?
2899	darwin_archive=$my_xabs
2900	darwin_curdir=`pwd`
2901	darwin_base_archive=`basename "$darwin_archive"`
2902	darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null \| $GREP Architectures 2>/dev/null \|\| true`
2903	if test -n "$darwin_arches"; then
2904	darwin_arches=`$ECHO "$darwin_arches" \| $SED -e 's/.*are://'`
2905	darwin_arch=
2906	func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2907	for darwin_arch in $darwin_arches ; do
2908	func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2909	$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2910	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2911	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2912	cd "$darwin_curdir"
2913	$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2914	done # $darwin_arches
2915	## Okay now we've a bunch of thin objects, gotta fatten them up :)
2916	darwin_filelist=`find unfat-$$ -type f -name \.o -print -o -name \.lo -print \| $SED -e "$basename" \| sort -u`
2917	darwin_file=
2918	darwin_files=
2919	for darwin_file in $darwin_filelist; do
2920	darwin_files=`find unfat-$$ -name $darwin_file -print \| $NL2SP`
2921	$LIPO -create -output "$darwin_file" $darwin_files
2922	done # $darwin_filelist
2923	$RM -rf unfat-$$
2924	cd "$darwin_orig_dir"
2925	else
2926	cd $darwin_orig_dir
2927	func_extract_an_archive "$my_xdir" "$my_xabs"
2928	fi # $darwin_arches
2929	} # !$opt_dry_run
2930	;;
2931	*)
2932	func_extract_an_archive "$my_xdir" "$my_xabs"
2933	;;
2934	esac
2935	my_oldobjs="$my_oldobjs "`find $my_xdir -name \.$objext -print -o -name \.lo -print \| $NL2SP`
2936	done
2937
2938	func_extract_archives_result="$my_oldobjs"
2939	}
2940
2941
2942	# func_emit_wrapper [arg=no]
2943	#
2944	# Emit a libtool wrapper script on stdout.
2945	# Don't directly open a file because we may want to
2946	# incorporate the script contents within a cygwin/mingw
2947	# wrapper executable. Must ONLY be called from within
2948	# func_mode_link because it depends on a number of variables
2949	# set therein.
2950	#
2951	# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2952	# variable will take. If 'yes', then the emitted script
2953	# will assume that the directory in which it is stored is
2954	# the $objdir directory. This is a cygwin/mingw-specific
2955	# behavior.
2956	func_emit_wrapper ()
2957	{
2958	func_emit_wrapper_arg1=${1-no}
2959
2960	$ECHO "\
2961	#! $SHELL
2962
2963	# $output - temporary wrapper script for $objdir/$outputname
2964	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2965	#
2966	# The $output program cannot be directly executed until all the libtool
2967	# libraries that it depends on are installed.
2968	#
2969	# This wrapper script should never be moved out of the build directory.
2970	# If it is, it will not operate correctly.
2971
2972	# Sed substitution that helps us do robust quoting. It backslashifies
2973	# metacharacters that are still active within double-quoted strings.
2974	sed_quote_subst='$sed_quote_subst'
2975
2976	# Be Bourne compatible
2977	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2978	emulate sh
2979	NULLCMD=:
2980	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2981	# is contrary to our usage. Disable this feature.
2982	alias -g '\${1+\"\$@\"}'='\"\$@\"'
2983	setopt NO_GLOB_SUBST
2984	else
2985	case \`(set -o) 2>/dev/null\` in posix) set -o posix;; esac
2986	fi
2987	BIN_SH=xpg4; export BIN_SH # for Tru64
2988	DUALCASE=1; export DUALCASE # for MKS sh
2989
2990	# The HP-UX ksh and POSIX shell print the target directory to stdout
2991	# if CDPATH is set.
2992	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2993
2994	relink_command=\"$relink_command\"
2995
2996	# This environment variable determines our operation mode.
2997	if test \"\$libtool_install_magic\" = \"$magic\"; then
2998	# install mode needs the following variables:
2999	generated_by_libtool_version='$macro_version'
3000	notinst_deplibs='$notinst_deplibs'
3001	else
3002	# When we are sourced in execute mode, \$file and \$ECHO are already set.
3003	if test \"\$libtool_execute_magic\" != \"$magic\"; then
3004	file=\"\$0\""
3005
3006	qECHO=`$ECHO "$ECHO" \| $SED "$sed_quote_subst"`
3007	$ECHO "\
3008
3009	# A function that is used when there is no print builtin or printf.
3010	func_fallback_echo ()
3011	{
3012	eval 'cat <<_LTECHO_EOF
3013	\$1
3014	_LTECHO_EOF'
3015	}
3016	ECHO=\"$qECHO\"
3017	fi\
3018
3019	# Find the directory that this script lives in.
3020	thisdir=\`\$ECHO \"\$file\" \| $SED 's%/[^/]*$%%'\`
3021	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3022
3023	# Follow symbolic links until we get to the real thisdir.
3024	file=\`ls -ld \"\$file\" \| $SED -n 's/.*-> //p'\`
3025	while test -n \"\$file\"; do
3026	destdir=\`\$ECHO \"\$file\" \| $SED 's%/[^/]*\$%%'\`
3027
3028	# If there was a directory component, then change thisdir.
3029	if test \"x\$destdir\" != \"x\$file\"; then
3030	case \"\$destdir\" in
3031	[\\\\/]* \| [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3032	*) thisdir=\"\$thisdir/\$destdir\" ;;
3033	esac
3034	fi
3035
3036	file=\`\$ECHO \"\$file\" \| $SED 's%^.*/%%'\`
3037	file=\`ls -ld \"\$thisdir/\$file\" \| $SED -n 's/.*-> //p'\`
3038	done
3039
3040	# Usually 'no', except on cygwin/mingw when embedded into
3041	# the cwrapper.
3042	WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3043	if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3044	# special case for '.'
3045	if test \"\$thisdir\" = \".\"; then
3046	thisdir=\`pwd\`
3047	fi
3048	# remove .libs from thisdir
3049	case \"\$thisdir\" in
3050	[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" \| $SED 's%[\\\\/][^\\\\/]$%%'\` ;;
3051	$objdir ) thisdir=. ;;
3052	esac
3053	fi
3054
3055	# Try to get the absolute directory name.
3056	absdir=\`cd \"\$thisdir\" && pwd\`
3057	test -n \"\$absdir\" && thisdir=\"\$absdir\"
3058	"
3059
3060	if test "$fast_install" = yes; then
3061	$ECHO "\
3062	program=lt-'$outputname'$exeext
3063	progdir=\"\$thisdir/$objdir\"
3064
3065	if test ! -f \"\$progdir/\$program\" \|\|
3066	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null \| ${SED} 1q\`; \\
3067	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3068
3069	file=\"\$\$-\$program\"
3070
3071	if test ! -d \"\$progdir\"; then
3072	$MKDIR \"\$progdir\"
3073	else
3074	$RM \"\$progdir/\$file\"
3075	fi"
3076
3077	$ECHO "\
3078
3079	# relink executable if necessary
3080	if test -n \"\$relink_command\"; then
3081	if relink_command_output=\`eval \"\$relink_command\" 2>&1\`; then :
3082	else
3083	$ECHO \"\$relink_command_output\" >&2
3084	$RM \"\$progdir/\$file\"
3085	exit 1
3086	fi
3087	fi
3088
3089	$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null \|\|
3090	{ $RM \"\$progdir/\$program\";
3091	$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3092	$RM \"\$progdir/\$file\"
3093	fi"
3094	else
3095	$ECHO "\
3096	program='$outputname'
3097	progdir=\"\$thisdir/$objdir\"
3098	"
3099	fi
3100
3101	$ECHO "\
3102
3103	if test -f \"\$progdir/\$program\"; then"
3104
3105	# Export our shlibpath_var if we have one.
3106	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3107	$ECHO "\
3108	# Add our own library path to $shlibpath_var
3109	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3110
3111	# Some systems cannot cope with colon-terminated $shlibpath_var
3112	# The second colon is a workaround for a bug in BeOS R4 sed
3113	$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" \| $SED 's/::*\$//'\`
3114
3115	export $shlibpath_var
3116	"
3117	fi
3118
3119	# fixup the dll searchpath if we need to.
3120	if test -n "$dllsearchpath"; then
3121	$ECHO "\
3122	# Add the dll search path components to the executable PATH
3123	PATH=$dllsearchpath:\$PATH
3124	"
3125	fi
3126
3127	$ECHO "\
3128	if test \"\$libtool_execute_magic\" != \"$magic\"; then
3129	# Run the actual program with our arguments.
3130	"
3131	case $host in
3132	# Backslashes separate directories on plain windows
3133	--mingw \| --os2* \| -cegcc)
3134	$ECHO "\
3135	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3136	"
3137	;;
3138
3139	*)
3140	$ECHO "\
3141	exec \"\$progdir/\$program\" \${1+\"\$@\"}
3142	"
3143	;;
3144	esac
3145	$ECHO "\
3146	\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3147	exit 1
3148	fi
3149	else
3150	# The program doesn't exist.
3151	\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3152	\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3153	\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3154	exit 1
3155	fi
3156	fi\
3157	"
3158	}
3159
3160
3161	# func_to_host_path arg
3162	#
3163	# Convert paths to host format when used with build tools.
3164	# Intended for use with "native" mingw (where libtool itself
3165	# is running under the msys shell), or in the following cross-
3166	# build environments:
3167	# $build $host
3168	# mingw (msys) mingw [e.g. native]
3169	# cygwin mingw
3170	# *nix + wine mingw
3171	# where wine is equipped with the `winepath' executable.
3172	# In the native mingw case, the (msys) shell automatically
3173	# converts paths for any non-msys applications it launches,
3174	# but that facility isn't available from inside the cwrapper.
3175	# Similar accommodations are necessary for $host mingw and
3176	# $build cygwin. Calling this function does no harm for other
3177	# $host/$build combinations not listed above.
3178	#
3179	# ARG is the path (on $build) that should be converted to
3180	# the proper representation for $host. The result is stored
3181	# in $func_to_host_path_result.
3182	func_to_host_path ()
3183	{
3184	func_to_host_path_result="$1"
3185	if test -n "$1"; then
3186	case $host in
3187	mingw )
3188	lt_sed_naive_backslashify='s\|\\\\*\|\\\|g;s\|/\|\\\|g;s\|\\\|\\\\\|g'
3189	case $build in
3190	mingw ) # actually, msys
3191	# awkward: cmd appends spaces to result
3192	func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null \|
3193	$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3194	;;
3195	cygwin )
3196	func_to_host_path_result=`cygpath -w "$1" \|
3197	$SED -e "$lt_sed_naive_backslashify"`
3198	;;
3199	* )
3200	# Unfortunately, winepath does not exit with a non-zero
3201	# error code, so we are forced to check the contents of
3202	# stdout. On the other hand, if the command is not
3203	# found, the shell will set an exit code of 127 and print
3204	# an error message to stdout. So we must check for both
3205	# error code of zero AND non-empty stdout, which explains
3206	# the odd construction:
3207	func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3208	if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3209	func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" \|
3210	$SED -e "$lt_sed_naive_backslashify"`
3211	else
3212	# Allow warning below.
3213	func_to_host_path_result=
3214	fi
3215	;;
3216	esac
3217	if test -z "$func_to_host_path_result" ; then
3218	func_error "Could not determine host path corresponding to"
3219	func_error " \`$1'"
3220	func_error "Continuing, but uninstalled executables may not work."
3221	# Fallback:
3222	func_to_host_path_result="$1"
3223	fi
3224	;;
3225	esac
3226	fi
3227	}
3228	# end: func_to_host_path
3229
3230	# func_to_host_pathlist arg
3231	#
3232	# Convert pathlists to host format when used with build tools.
3233	# See func_to_host_path(), above. This function supports the
3234	# following $build/$host combinations (but does no harm for
3235	# combinations not listed here):
3236	# $build $host
3237	# mingw (msys) mingw [e.g. native]
3238	# cygwin mingw
3239	# *nix + wine mingw
3240	#
3241	# Path separators are also converted from $build format to
3242	# $host format. If ARG begins or ends with a path separator
3243	# character, it is preserved (but converted to $host format)
3244	# on output.
3245	#
3246	# ARG is a pathlist (on $build) that should be converted to
3247	# the proper representation on $host. The result is stored
3248	# in $func_to_host_pathlist_result.
3249	func_to_host_pathlist ()
3250	{
3251	func_to_host_pathlist_result="$1"
3252	if test -n "$1"; then
3253	case $host in
3254	mingw )
3255	lt_sed_naive_backslashify='s\|\\\\*\|\\\|g;s\|/\|\\\|g;s\|\\\|\\\\\|g'
3256	# Remove leading and trailing path separator characters from
3257	# ARG. msys behavior is inconsistent here, cygpath turns them
3258	# into '.;' and ';.', and winepath ignores them completely.
3259	func_stripname : : "$1"
3260	func_to_host_pathlist_tmp1=$func_stripname_result
3261	case $build in
3262	mingw ) # Actually, msys.
3263	# Awkward: cmd appends spaces to result.
3264	func_to_host_pathlist_result=`
3265	( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null \|
3266	$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3267	;;
3268	cygwin )
3269	func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" \|
3270	$SED -e "$lt_sed_naive_backslashify"`
3271	;;
3272	* )
3273	# unfortunately, winepath doesn't convert pathlists
3274	func_to_host_pathlist_result=""
3275	func_to_host_pathlist_oldIFS=$IFS
3276	IFS=:
3277	for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3278	IFS=$func_to_host_pathlist_oldIFS
3279	if test -n "$func_to_host_pathlist_f" ; then
3280	func_to_host_path "$func_to_host_pathlist_f"
3281	if test -n "$func_to_host_path_result" ; then
3282	if test -z "$func_to_host_pathlist_result" ; then
3283	func_to_host_pathlist_result="$func_to_host_path_result"
3284	else
3285	func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3286	fi
3287	fi
3288	fi
3289	done
3290	IFS=$func_to_host_pathlist_oldIFS
3291	;;
3292	esac
3293	if test -z "$func_to_host_pathlist_result"; then
3294	func_error "Could not determine the host path(s) corresponding to"
3295	func_error " \`$1'"
3296	func_error "Continuing, but uninstalled executables may not work."
3297	# Fallback. This may break if $1 contains DOS-style drive
3298	# specifications. The fix is not to complicate the expression
3299	# below, but for the user to provide a working wine installation
3300	# with winepath so that path translation in the cross-to-mingw
3301	# case works properly.
3302	lt_replace_pathsep_nix_to_dos="s\|:\|;\|g"
3303	func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" \|\
3304	$SED -e "$lt_replace_pathsep_nix_to_dos"`
3305	fi
3306	# Now, add the leading and trailing path separators back
3307	case "$1" in
3308	:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3309	;;
3310	esac
3311	case "$1" in
3312	*: ) func_append func_to_host_pathlist_result ";"
3313	;;
3314	esac
3315	;;
3316	esac
3317	fi
3318	}
3319	# end: func_to_host_pathlist
3320
3321	# func_emit_cwrapperexe_src
3322	# emit the source code for a wrapper executable on stdout
3323	# Must ONLY be called from within func_mode_link because
3324	# it depends on a number of variable set therein.
3325	func_emit_cwrapperexe_src ()
3326	{
3327	cat <<EOF
3328
3329	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3330	Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3331
3332	The $output program cannot be directly executed until all the libtool
3333	libraries that it depends on are installed.
3334
3335	This wrapper executable should never be moved out of the build directory.
3336	If it is, it will not operate correctly.
3337
3338	Currently, it simply execs the wrapper script "$SHELL $output",
3339	but could eventually absorb all of the scripts functionality and
3340	exec $objdir/$outputname directly.
3341	*/
3342	EOF
3343	cat <<"EOF"
3344	#ifdef _MSC_VER
3345	# define _CRT_SECURE_NO_DEPRECATE 1
3346	#endif
3347	#include <stdio.h>
3348	#include <stdlib.h>
3349	#ifdef _MSC_VER
3350	# include <direct.h>
3351	# include <process.h>
3352	# include <io.h>
3353	#else
3354	# include <unistd.h>
3355	# include <stdint.h>
3356	# ifdef __CYGWIN__
3357	# include <io.h>
3358	# endif
3359	#endif
3360	#include <malloc.h>
3361	#include <stdarg.h>
3362	#include <assert.h>
3363	#include <string.h>
3364	#include <ctype.h>
3365	#include <errno.h>
3366	#include <fcntl.h>
3367	#include <sys/stat.h>
3368
3369	/* declarations of non-ANSI functions */
3370	#if defined(__MINGW32__)
3371	# ifdef __STRICT_ANSI__
3372	int _putenv (const char *);
3373	# endif
3374	#elif defined(__CYGWIN__)
3375	# ifdef __STRICT_ANSI__
3376	char realpath (const char , char *);
3377	int putenv (char *);
3378	int setenv (const char , const char , int);
3379	# endif
3380	/* #elif defined (other platforms) ... */
3381	#endif
3382
3383	/* portability defines, excluding path handling macros */
3384	#if defined(_MSC_VER)
3385	# define setmode _setmode
3386	# define stat _stat
3387	# define chmod _chmod
3388	# define getcwd _getcwd
3389	# define putenv _putenv
3390	# define S_IXUSR _S_IEXEC
3391	# ifndef _INTPTR_T_DEFINED
3392	# define _INTPTR_T_DEFINED
3393	# define intptr_t int
3394	# endif
3395	#elif defined(__MINGW32__)
3396	# define setmode _setmode
3397	# define stat _stat
3398	# define chmod _chmod
3399	# define getcwd _getcwd
3400	# define putenv _putenv
3401	#elif defined(__CYGWIN__)
3402	# define HAVE_SETENV
3403	# define FOPEN_WB "wb"
3404	/* #elif defined (other platforms) ... */
3405	#endif
3406
3407	#if defined(PATH_MAX)
3408	# define LT_PATHMAX PATH_MAX
3409	#elif defined(MAXPATHLEN)
3410	# define LT_PATHMAX MAXPATHLEN
3411	#else
3412	# define LT_PATHMAX 1024
3413	#endif
3414
3415	#ifndef S_IXOTH
3416	# define S_IXOTH 0
3417	#endif
3418	#ifndef S_IXGRP
3419	# define S_IXGRP 0
3420	#endif
3421
3422	/* path handling portability macros */
3423	#ifndef DIR_SEPARATOR
3424	# define DIR_SEPARATOR '/'
3425	# define PATH_SEPARATOR ':'
3426	#endif
3427
3428	#if defined (_WIN32) \|\| defined (__MSDOS__) \|\| defined (__DJGPP__) \|\| \
3429	defined (__OS2__)
3430	# define HAVE_DOS_BASED_FILE_SYSTEM
3431	# define FOPEN_WB "wb"
3432	# ifndef DIR_SEPARATOR_2
3433	# define DIR_SEPARATOR_2 '\\'
3434	# endif
3435	# ifndef PATH_SEPARATOR_2
3436	# define PATH_SEPARATOR_2 ';'
3437	# endif
3438	#endif
3439
3440	#ifndef DIR_SEPARATOR_2
3441	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3442	#else /* DIR_SEPARATOR_2 */
3443	# define IS_DIR_SEPARATOR(ch) \
3444	(((ch) == DIR_SEPARATOR) \|\| ((ch) == DIR_SEPARATOR_2))
3445	#endif /* DIR_SEPARATOR_2 */
3446
3447	#ifndef PATH_SEPARATOR_2
3448	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3449	#else /* PATH_SEPARATOR_2 */
3450	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3451	#endif /* PATH_SEPARATOR_2 */
3452
3453	#ifndef FOPEN_WB
3454	# define FOPEN_WB "w"
3455	#endif
3456	#ifndef _O_BINARY
3457	# define _O_BINARY 0
3458	#endif
3459
3460	#define XMALLOC(type, num) ((type ) xmalloc ((num) sizeof(type)))
3461	#define XFREE(stale) do { \
3462	if (stale) { free ((void *) stale); stale = 0; } \
3463	} while (0)
3464
3465	#undef LTWRAPPER_DEBUGPRINTF
3466	#if defined LT_DEBUGWRAPPER
3467	# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3468	static void
3469	ltwrapper_debugprintf (const char *fmt, ...)
3470	{
3471	va_list args;
3472	va_start (args, fmt);
3473	(void) vfprintf (stderr, fmt, args);
3474	va_end (args);
3475	}
3476	#else
3477	# define LTWRAPPER_DEBUGPRINTF(args)
3478	#endif
3479
3480	const char *program_name = NULL;
3481
3482	void *xmalloc (size_t num);
3483	char xstrdup (const char string);
3484	const char base_name (const char name);
3485	char find_executable (const char wrapper);
3486	char chase_symlinks (const char pathspec);
3487	int make_executable (const char *path);
3488	int check_executable (const char *path);
3489	char strendzap (char str, const char *pat);
3490	void lt_fatal (const char *message, ...);
3491	void lt_setenv (const char name, const char value);
3492	char lt_extend_str (const char orig_value, const char *add, int to_end);
3493	void lt_update_exe_path (const char name, const char value);
3494	void lt_update_lib_path (const char name, const char value);
3495	char prepare_spawn (char argv);
3496	void lt_dump_script (FILE *f);
3497	EOF
3498
3499	cat <<EOF
3500	const char * MAGIC_EXE = "$magic_exe";
3501	const char * LIB_PATH_VARNAME = "$shlibpath_var";
3502	EOF
3503
3504	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3505	func_to_host_pathlist "$temp_rpath"
3506	cat <<EOF
3507	const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3508	EOF
3509	else
3510	cat <<"EOF"
3511	const char * LIB_PATH_VALUE = "";
3512	EOF
3513	fi
3514
3515	if test -n "$dllsearchpath"; then
3516	func_to_host_pathlist "$dllsearchpath:"
3517	cat <<EOF
3518	const char * EXE_PATH_VARNAME = "PATH";
3519	const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3520	EOF
3521	else
3522	cat <<"EOF"
3523	const char * EXE_PATH_VARNAME = "";
3524	const char * EXE_PATH_VALUE = "";
3525	EOF
3526	fi
3527
3528	if test "$fast_install" = yes; then
3529	cat <<EOF
3530	const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3531	EOF
3532	else
3533	cat <<EOF
3534	const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3535	EOF
3536	fi
3537
3538
3539	cat <<"EOF"
3540
3541	#define LTWRAPPER_OPTION_PREFIX "--lt-"
3542	#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3543
3544	static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3545	static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3546
3547	static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3548
3549	int
3550	main (int argc, char *argv[])
3551	{
3552	char **newargz;
3553	int newargc;
3554	char *tmp_pathspec;
3555	char *actual_cwrapper_path;
3556	char *actual_cwrapper_name;
3557	char *target_name;
3558	char *lt_argv_zero;
3559	intptr_t rval = 127;
3560
3561	int i;
3562
3563	program_name = (char *) xstrdup (base_name (argv[0]));
3564	LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3565	LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3566
3567	/* very simple arg parsing; don't want to rely on getopt */
3568	for (i = 1; i < argc; i++)
3569	{
3570	if (strcmp (argv[i], dumpscript_opt) == 0)
3571	{
3572	EOF
3573	case "$host" in
3574	mingw \| cygwin )
3575	# make stdout use "unix" line endings
3576	echo " setmode(1,_O_BINARY);"
3577	;;
3578	esac
3579
3580	cat <<"EOF"
3581	lt_dump_script (stdout);
3582	return 0;
3583	}
3584	}
3585
3586	newargz = XMALLOC (char *, argc + 1);
3587	tmp_pathspec = find_executable (argv[0]);
3588	if (tmp_pathspec == NULL)
3589	lt_fatal ("Couldn't find %s", argv[0]);
3590	LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3591	tmp_pathspec));
3592
3593	actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3594	LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3595	actual_cwrapper_path));
3596	XFREE (tmp_pathspec);
3597
3598	actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3599	strendzap (actual_cwrapper_path, actual_cwrapper_name);
3600
3601	/* wrapper name transforms */
3602	strendzap (actual_cwrapper_name, ".exe");
3603	tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3604	XFREE (actual_cwrapper_name);
3605	actual_cwrapper_name = tmp_pathspec;
3606	tmp_pathspec = 0;
3607
3608	/* target_name transforms -- use actual target program name; might have lt- prefix */
3609	target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3610	strendzap (target_name, ".exe");
3611	tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3612	XFREE (target_name);
3613	target_name = tmp_pathspec;
3614	tmp_pathspec = 0;
3615
3616	LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3617	target_name));
3618	EOF
3619
3620	cat <<EOF
3621	newargz[0] =
3622	XMALLOC (char, (strlen (actual_cwrapper_path) +
3623	strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3624	strcpy (newargz[0], actual_cwrapper_path);
3625	strcat (newargz[0], "$objdir");
3626	strcat (newargz[0], "/");
3627	EOF
3628
3629	cat <<"EOF"
3630	/* stop here, and copy so we don't have to do this twice */
3631	tmp_pathspec = xstrdup (newargz[0]);
3632
3633	/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3634	strcat (newargz[0], actual_cwrapper_name);
3635
3636	/* DO want the lt- prefix here if it exists, so use target_name */
3637	lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3638	XFREE (tmp_pathspec);
3639	tmp_pathspec = NULL;
3640	EOF
3641
3642	case $host_os in
3643	mingw*)
3644	cat <<"EOF"
3645	{
3646	char* p;
3647	while ((p = strchr (newargz[0], '\\')) != NULL)
3648	{
3649	*p = '/';
3650	}
3651	while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3652	{
3653	*p = '/';
3654	}
3655	}
3656	EOF
3657	;;
3658	esac
3659
3660	cat <<"EOF"
3661	XFREE (target_name);
3662	XFREE (actual_cwrapper_path);
3663	XFREE (actual_cwrapper_name);
3664
3665	lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3666	lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3667	lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3668	lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3669
3670	newargc=0;
3671	for (i = 1; i < argc; i++)
3672	{
3673	if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3674	{
3675	/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3676	namespace, but it is not one of the ones we know about and
3677	have already dealt with, above (inluding dump-script), then
3678	report an error. Otherwise, targets might begin to believe
3679	they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3680	namespace. The first time any user complains about this, we'll
3681	need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3682	or a configure.ac-settable value.
3683	*/
3684	lt_fatal ("Unrecognized option in %s namespace: '%s'",
3685	ltwrapper_option_prefix, argv[i]);
3686	}
3687	/* otherwise ... */
3688	newargz[++newargc] = xstrdup (argv[i]);
3689	}
3690	newargz[++newargc] = NULL;
3691
3692	LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3693	for (i = 0; i < newargc; i++)
3694	{
3695	LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3696	}
3697
3698	EOF
3699
3700	case $host_os in
3701	mingw*)
3702	cat <<"EOF"
3703	/* execv doesn't actually work on mingw as expected on unix */
3704	newargz = prepare_spawn (newargz);
3705	rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3706	if (rval == -1)
3707	{
3708	/* failed to start process */
3709	LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3710	return 127;
3711	}
3712	return rval;
3713	EOF
3714	;;
3715	*)
3716	cat <<"EOF"
3717	execv (lt_argv_zero, newargz);
3718	return rval; /* =127, but avoids unused variable warning */
3719	EOF
3720	;;
3721	esac
3722
3723	cat <<"EOF"
3724	}
3725
3726	void *
3727	xmalloc (size_t num)
3728	{
3729	void p = (void ) malloc (num);
3730	if (!p)
3731	lt_fatal ("Memory exhausted");
3732
3733	return p;
3734	}
3735
3736	char *
3737	xstrdup (const char *string)
3738	{
3739	return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3740	string) : NULL;
3741	}
3742
3743	const char *
3744	base_name (const char *name)
3745	{
3746	const char *base;
3747
3748	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3749	/* Skip over the disk name in MSDOS pathnames. */
3750	if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3751	name += 2;
3752	#endif
3753
3754	for (base = name; *name; name++)
3755	if (IS_DIR_SEPARATOR (*name))
3756	base = name + 1;
3757	return base;
3758	}
3759
3760	int
3761	check_executable (const char *path)
3762	{
3763	struct stat st;
3764
3765	LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3766	path ? (*path ? path : "EMPTY!") : "NULL!"));
3767	if ((!path) \|\| (!*path))
3768	return 0;
3769
3770	if ((stat (path, &st) >= 0)
3771	&& (st.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH)))
3772	return 1;
3773	else
3774	return 0;
3775	}
3776
3777	int
3778	make_executable (const char *path)
3779	{
3780	int rval = 0;
3781	struct stat st;
3782
3783	LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3784	path ? (*path ? path : "EMPTY!") : "NULL!"));
3785	if ((!path) \|\| (!*path))
3786	return 0;
3787
3788	if (stat (path, &st) >= 0)
3789	{
3790	rval = chmod (path, st.st_mode \| S_IXOTH \| S_IXGRP \| S_IXUSR);
3791	}
3792	return rval;
3793	}
3794
3795	/* Searches for the full path of the wrapper. Returns
3796	newly allocated full path name if found, NULL otherwise
3797	Does not chase symlinks, even on platforms that support them.
3798	*/
3799	char *
3800	find_executable (const char *wrapper)
3801	{
3802	int has_slash = 0;
3803	const char *p;
3804	const char *p_next;
3805	/* static buffer for getcwd */
3806	char tmp[LT_PATHMAX + 1];
3807	int tmp_len;
3808	char *concat_name;
3809
3810	LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3811	wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3812
3813	if ((wrapper == NULL) \|\| (*wrapper == '\0'))
3814	return NULL;
3815
3816	/* Absolute path? */
3817	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3818	if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3819	{
3820	concat_name = xstrdup (wrapper);
3821	if (check_executable (concat_name))
3822	return concat_name;
3823	XFREE (concat_name);
3824	}
3825	else
3826	{
3827	#endif
3828	if (IS_DIR_SEPARATOR (wrapper[0]))
3829	{
3830	concat_name = xstrdup (wrapper);
3831	if (check_executable (concat_name))
3832	return concat_name;
3833	XFREE (concat_name);
3834	}
3835	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3836	}
3837	#endif
3838
3839	for (p = wrapper; *p; p++)
3840	if (*p == '/')
3841	{
3842	has_slash = 1;
3843	break;
3844	}
3845	if (!has_slash)
3846	{
3847	/* no slashes; search PATH */
3848	const char *path = getenv ("PATH");
3849	if (path != NULL)
3850	{
3851	for (p = path; *p; p = p_next)
3852	{
3853	const char *q;
3854	size_t p_len;
3855	for (q = p; *q; q++)
3856	if (IS_PATH_SEPARATOR (*q))
3857	break;
3858	p_len = q - p;
3859	p_next = (*q == '\0' ? q : q + 1);
3860	if (p_len == 0)
3861	{
3862	/* empty path: current directory */
3863	if (getcwd (tmp, LT_PATHMAX) == NULL)
3864	lt_fatal ("getcwd failed");
3865	tmp_len = strlen (tmp);
3866	concat_name =
3867	XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3868	memcpy (concat_name, tmp, tmp_len);
3869	concat_name[tmp_len] = '/';
3870	strcpy (concat_name + tmp_len + 1, wrapper);
3871	}
3872	else
3873	{
3874	concat_name =
3875	XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3876	memcpy (concat_name, p, p_len);
3877	concat_name[p_len] = '/';
3878	strcpy (concat_name + p_len + 1, wrapper);
3879	}
3880	if (check_executable (concat_name))
3881	return concat_name;
3882	XFREE (concat_name);
3883	}
3884	}
3885	/* not found in PATH; assume curdir */
3886	}
3887	/* Relative path \| not found in path: prepend cwd */
3888	if (getcwd (tmp, LT_PATHMAX) == NULL)
3889	lt_fatal ("getcwd failed");
3890	tmp_len = strlen (tmp);
3891	concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3892	memcpy (concat_name, tmp, tmp_len);
3893	concat_name[tmp_len] = '/';
3894	strcpy (concat_name + tmp_len + 1, wrapper);
3895
3896	if (check_executable (concat_name))
3897	return concat_name;
3898	XFREE (concat_name);
3899	return NULL;
3900	}
3901
3902	char *
3903	chase_symlinks (const char *pathspec)
3904	{
3905	#ifndef S_ISLNK
3906	return xstrdup (pathspec);
3907	#else
3908	char buf[LT_PATHMAX];
3909	struct stat s;
3910	char *tmp_pathspec = xstrdup (pathspec);
3911	char *p;
3912	int has_symlinks = 0;
3913	while (strlen (tmp_pathspec) && !has_symlinks)
3914	{
3915	LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3916	tmp_pathspec));
3917	if (lstat (tmp_pathspec, &s) == 0)
3918	{
3919	if (S_ISLNK (s.st_mode) != 0)
3920	{
3921	has_symlinks = 1;
3922	break;
3923	}
3924
3925	/* search backwards for last DIR_SEPARATOR */
3926	p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3927	while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3928	p--;
3929	if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3930	{
3931	/* no more DIR_SEPARATORS left */
3932	break;
3933	}
3934	*p = '\0';
3935	}
3936	else
3937	{
3938	char *errstr = strerror (errno);
3939	lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3940	}
3941	}
3942	XFREE (tmp_pathspec);
3943
3944	if (!has_symlinks)
3945	{
3946	return xstrdup (pathspec);
3947	}
3948
3949	tmp_pathspec = realpath (pathspec, buf);
3950	if (tmp_pathspec == 0)
3951	{
3952	lt_fatal ("Could not follow symlinks for %s", pathspec);
3953	}
3954	return xstrdup (tmp_pathspec);
3955	#endif
3956	}
3957
3958	char *
3959	strendzap (char str, const char pat)
3960	{
3961	size_t len, patlen;
3962
3963	assert (str != NULL);
3964	assert (pat != NULL);
3965
3966	len = strlen (str);
3967	patlen = strlen (pat);
3968
3969	if (patlen <= len)
3970	{
3971	str += len - patlen;
3972	if (strcmp (str, pat) == 0)
3973	*str = '\0';
3974	}
3975	return str;
3976	}
3977
3978	static void
3979	lt_error_core (int exit_status, const char *mode,
3980	const char *message, va_list ap)
3981	{
3982	fprintf (stderr, "%s: %s: ", program_name, mode);
3983	vfprintf (stderr, message, ap);
3984	fprintf (stderr, ".\n");
3985
3986	if (exit_status >= 0)
3987	exit (exit_status);
3988	}
3989
3990	void
3991	lt_fatal (const char *message, ...)
3992	{
3993	va_list ap;
3994	va_start (ap, message);
3995	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3996	va_end (ap);
3997	}
3998
3999	void
4000	lt_setenv (const char name, const char value)
4001	{
4002	LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4003	(name ? name : "<NULL>"),
4004	(value ? value : "<NULL>")));
4005	{
4006	#ifdef HAVE_SETENV
4007	/* always make a copy, for consistency with !HAVE_SETENV */
4008	char *str = xstrdup (value);
4009	setenv (name, str, 1);
4010	#else
4011	int len = strlen (name) + 1 + strlen (value) + 1;
4012	char *str = XMALLOC (char, len);
4013	sprintf (str, "%s=%s", name, value);
4014	if (putenv (str) != EXIT_SUCCESS)
4015	{
4016	XFREE (str);
4017	}
4018	#endif
4019	}
4020	}
4021
4022	char *
4023	lt_extend_str (const char orig_value, const char add, int to_end)
4024	{
4025	char *new_value;
4026	if (orig_value && *orig_value)
4027	{
4028	int orig_value_len = strlen (orig_value);
4029	int add_len = strlen (add);
4030	new_value = XMALLOC (char, add_len + orig_value_len + 1);
4031	if (to_end)
4032	{
4033	strcpy (new_value, orig_value);
4034	strcpy (new_value + orig_value_len, add);
4035	}
4036	else
4037	{
4038	strcpy (new_value, add);
4039	strcpy (new_value + add_len, orig_value);
4040	}
4041	}
4042	else
4043	{
4044	new_value = xstrdup (add);
4045	}
4046	return new_value;
4047	}
4048
4049	void
4050	lt_update_exe_path (const char name, const char value)
4051	{
4052	LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4053	(name ? name : "<NULL>"),
4054	(value ? value : "<NULL>")));
4055
4056	if (name && name && value && value)
4057	{
4058	char *new_value = lt_extend_str (getenv (name), value, 0);
4059	/* some systems can't cope with a ':'-terminated path #' */
4060	int len = strlen (new_value);
4061	while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4062	{
4063	new_value[len-1] = '\0';
4064	}
4065	lt_setenv (name, new_value);
4066	XFREE (new_value);
4067	}
4068	}
4069
4070	void
4071	lt_update_lib_path (const char name, const char value)
4072	{
4073	LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4074	(name ? name : "<NULL>"),
4075	(value ? value : "<NULL>")));
4076
4077	if (name && name && value && value)
4078	{
4079	char *new_value = lt_extend_str (getenv (name), value, 0);
4080	lt_setenv (name, new_value);
4081	XFREE (new_value);
4082	}
4083	}
4084
4085	EOF
4086	case $host_os in
4087	mingw*)
4088	cat <<"EOF"
4089
4090	/* Prepares an argument vector before calling spawn().
4091	Note that spawn() does not by itself call the command interpreter
4092	(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4093	({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4094	GetVersionEx(&v);
4095	v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4096	}) ? "cmd.exe" : "command.com").
4097	Instead it simply concatenates the arguments, separated by ' ', and calls
4098	CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4099	interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4100	special way:
4101	- Space and tab are interpreted as delimiters. They are not treated as
4102	delimiters if they are surrounded by double quotes: "...".
4103	- Unescaped double quotes are removed from the input. Their only effect is
4104	that within double quotes, space and tab are treated like normal
4105	characters.
4106	- Backslashes not followed by double quotes are not special.
4107	- But 2*n+1 backslashes followed by a double quote become
4108	n backslashes followed by a double quote (n >= 0):
4109	\" -> "
4110	\\\" -> \"
4111	\\\\\" -> \\"
4112	*/
4113	#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4114	#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4115	char **
4116	prepare_spawn (char **argv)
4117	{
4118	size_t argc;
4119	char **new_argv;
4120	size_t i;
4121
4122	/* Count number of arguments. */
4123	for (argc = 0; argv[argc] != NULL; argc++)
4124	;
4125
4126	/* Allocate new argument vector. */
4127	new_argv = XMALLOC (char *, argc + 1);
4128
4129	/* Put quoted arguments into the new argument vector. */
4130	for (i = 0; i < argc; i++)
4131	{
4132	const char *string = argv[i];
4133
4134	if (string[0] == '\0')
4135	new_argv[i] = xstrdup ("\"\"");
4136	else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4137	{
4138	int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4139	size_t length;
4140	unsigned int backslashes;
4141	const char *s;
4142	char *quoted_string;
4143	char *p;
4144
4145	length = 0;
4146	backslashes = 0;
4147	if (quote_around)
4148	length++;
4149	for (s = string; *s != '\0'; s++)
4150	{
4151	char c = *s;
4152	if (c == '"')
4153	length += backslashes + 1;
4154	length++;
4155	if (c == '\\')
4156	backslashes++;
4157	else
4158	backslashes = 0;
4159	}
4160	if (quote_around)
4161	length += backslashes + 1;
4162
4163	quoted_string = XMALLOC (char, length + 1);
4164
4165	p = quoted_string;
4166	backslashes = 0;
4167	if (quote_around)
4168	*p++ = '"';
4169	for (s = string; *s != '\0'; s++)
4170	{
4171	char c = *s;
4172	if (c == '"')
4173	{
4174	unsigned int j;
4175	for (j = backslashes + 1; j > 0; j--)
4176	*p++ = '\\';
4177	}
4178	*p++ = c;
4179	if (c == '\\')
4180	backslashes++;
4181	else
4182	backslashes = 0;
4183	}
4184	if (quote_around)
4185	{
4186	unsigned int j;
4187	for (j = backslashes; j > 0; j--)
4188	*p++ = '\\';
4189	*p++ = '"';
4190	}
4191	*p = '\0';
4192
4193	new_argv[i] = quoted_string;
4194	}
4195	else
4196	new_argv[i] = (char *) string;
4197	}
4198	new_argv[argc] = NULL;
4199
4200	return new_argv;
4201	}
4202	EOF
4203	;;
4204	esac
4205
4206	cat <<"EOF"
4207	void lt_dump_script (FILE* f)
4208	{
4209	EOF
4210	func_emit_wrapper yes \|
4211	$SED -e 's/$[\\"]$/\\\1/g' \
4212	-e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
4213
4214	cat <<"EOF"
4215	}
4216	EOF
4217	}
4218	# end: func_emit_cwrapperexe_src
4219
4220	# func_win32_import_lib_p ARG
4221	# True if ARG is an import lib, as indicated by $file_magic_cmd
4222	func_win32_import_lib_p ()
4223	{
4224	$opt_debug
4225	case `eval "$file_magic_cmd \"\$1\" 2>/dev/null" \| $SED -e 10q` in
4226	import) : ;;
4227	*) false ;;
4228	esac
4229	}
4230
4231	# func_mode_link arg...
4232	func_mode_link ()
4233	{
4234	$opt_debug
4235	case $host in
4236	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
4237	# It is impossible to link a dll without this setting, and
4238	# we shouldn't force the makefile maintainer to figure out
4239	# which system we are compiling for in order to pass an extra
4240	# flag for every libtool invocation.
4241	# allow_undefined=no
4242
4243	# FIXME: Unfortunately, there are problems with the above when trying
4244	# to make a dll which has undefined symbols, in which case not
4245	# even a static library is built. For now, we need to specify
4246	# -no-undefined on the libtool link line when we can be certain
4247	# that all symbols are satisfied, otherwise we get a static library.
4248	allow_undefined=yes
4249	;;
4250	*)
4251	allow_undefined=yes
4252	;;
4253	esac
4254	libtool_args=$nonopt
4255	base_compile="$nonopt $@"
4256	compile_command=$nonopt
4257	finalize_command=$nonopt
4258
4259	compile_rpath=
4260	finalize_rpath=
4261	compile_shlibpath=
4262	finalize_shlibpath=
4263	convenience=
4264	old_convenience=
4265	deplibs=
4266	old_deplibs=
4267	compiler_flags=
4268	linker_flags=
4269	dllsearchpath=
4270	lib_search_path=`pwd`
4271	inst_prefix_dir=
4272	new_inherited_linker_flags=
4273
4274	avoid_version=no
4275	bindir=
4276	dlfiles=
4277	dlprefiles=
4278	dlself=no
4279	export_dynamic=no
4280	export_symbols=
4281	export_symbols_regex=
4282	generated=
4283	libobjs=
4284	ltlibs=
4285	module=no
4286	no_install=no
4287	objs=
4288	non_pic_objects=
4289	precious_files_regex=
4290	prefer_static_libs=no
4291	preload=no
4292	prev=
4293	prevarg=
4294	release=
4295	rpath=
4296	xrpath=
4297	perm_rpath=
4298	temp_rpath=
4299	thread_safe=no
4300	vinfo=
4301	vinfo_number=no
4302	weak_libs=
4303	single_module="${wl}-single_module"
4304	func_infer_tag $base_compile
4305
4306	# We need to know -static, to get the right output filenames.
4307	for arg
4308	do
4309	case $arg in
4310	-shared)
4311	test "$build_libtool_libs" != yes && \
4312	func_fatal_configuration "can not build a shared library"
4313	build_old_libs=no
4314	break
4315	;;
4316	-all-static \| -static \| -static-libtool-libs)
4317	case $arg in
4318	-all-static)
4319	if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4320	func_warning "complete static linking is impossible in this configuration"
4321	fi
4322	if test -n "$link_static_flag"; then
4323	dlopen_self=$dlopen_self_static
4324	fi
4325	prefer_static_libs=yes
4326	;;
4327	-static)
4328	if test -z "$pic_flag" && test -n "$link_static_flag"; then
4329	dlopen_self=$dlopen_self_static
4330	fi
4331	prefer_static_libs=built
4332	;;
4333	-static-libtool-libs)
4334	if test -z "$pic_flag" && test -n "$link_static_flag"; then
4335	dlopen_self=$dlopen_self_static
4336	fi
4337	prefer_static_libs=yes
4338	;;
4339	esac
4340	build_libtool_libs=no
4341	build_old_libs=yes
4342	break
4343	;;
4344	esac
4345	done
4346
4347	# See if our shared archives depend on static archives.
4348	test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4349
4350	# Go through the arguments, transforming them on the way.
4351	while test "$#" -gt 0; do
4352	arg="$1"
4353	shift
4354	func_quote_for_eval "$arg"
4355	qarg=$func_quote_for_eval_unquoted_result
4356	func_append libtool_args " $func_quote_for_eval_result"
4357
4358	# If the previous option needs an argument, assign it.
4359	if test -n "$prev"; then
4360	case $prev in
4361	output)
4362	func_append compile_command " @OUTPUT@"
4363	func_append finalize_command " @OUTPUT@"
4364	;;
4365	esac
4366
4367	case $prev in
4368	bindir)
4369	bindir="$arg"
4370	prev=
4371	continue
4372	;;
4373	dlfiles\|dlprefiles)
4374	if test "$preload" = no; then
4375	# Add the symbol object into the linking commands.
4376	func_append compile_command " @SYMFILE@"
4377	func_append finalize_command " @SYMFILE@"
4378	preload=yes
4379	fi
4380	case $arg in
4381	.la \| .lo) ;; # We handle these cases below.
4382	force)
4383	if test "$dlself" = no; then
4384	dlself=needless
4385	export_dynamic=yes
4386	fi
4387	prev=
4388	continue
4389	;;
4390	self)
4391	if test "$prev" = dlprefiles; then
4392	dlself=yes
4393	elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4394	dlself=yes
4395	else
4396	dlself=needless
4397	export_dynamic=yes
4398	fi
4399	prev=
4400	continue
4401	;;
4402	*)
4403	if test "$prev" = dlfiles; then
4404	dlfiles="$dlfiles $arg"
4405	else
4406	dlprefiles="$dlprefiles $arg"
4407	fi
4408	prev=
4409	continue
4410	;;
4411	esac
4412	;;
4413	expsyms)
4414	export_symbols="$arg"
4415	test -f "$arg" \
4416	\|\| func_fatal_error "symbol file \`$arg' does not exist"
4417	prev=
4418	continue
4419	;;
4420	expsyms_regex)
4421	export_symbols_regex="$arg"
4422	prev=
4423	continue
4424	;;
4425	framework)
4426	case $host in
4427	--darwin*)
4428	case "$deplibs " in
4429	" $qarg.ltframework ") ;;
4430	*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4431	;;
4432	esac
4433	;;
4434	esac
4435	prev=
4436	continue
4437	;;
4438	inst_prefix)
4439	inst_prefix_dir="$arg"
4440	prev=
4441	continue
4442	;;
4443	objectlist)
4444	if test -f "$arg"; then
4445	save_arg=$arg
4446	moreargs=
4447	for fil in `cat "$save_arg"`
4448	do
4449	# moreargs="$moreargs $fil"
4450	arg=$fil
4451	# A libtool-controlled object.
4452
4453	# Check to see that this really is a libtool object.
4454	if func_lalib_unsafe_p "$arg"; then
4455	pic_object=
4456	non_pic_object=
4457
4458	# Read the .lo file
4459	func_source "$arg"
4460
4461	if test -z "$pic_object" \|\|
4462	test -z "$non_pic_object" \|\|
4463	test "$pic_object" = none &&
4464	test "$non_pic_object" = none; then
4465	func_fatal_error "cannot find name of object for \`$arg'"
4466	fi
4467
4468	# Extract subdirectory from the argument.
4469	func_dirname "$arg" "/" ""
4470	xdir="$func_dirname_result"
4471
4472	if test "$pic_object" != none; then
4473	# Prepend the subdirectory the object is found in.
4474	pic_object="$xdir$pic_object"
4475
4476	if test "$prev" = dlfiles; then
4477	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4478	dlfiles="$dlfiles $pic_object"
4479	prev=
4480	continue
4481	else
4482	# If libtool objects are unsupported, then we need to preload.
4483	prev=dlprefiles
4484	fi
4485	fi
4486
4487	# CHECK ME: I think I busted this. -Ossama
4488	if test "$prev" = dlprefiles; then
4489	# Preload the old-style object.
4490	dlprefiles="$dlprefiles $pic_object"
4491	prev=
4492	fi
4493
4494	# A PIC object.
4495	func_append libobjs " $pic_object"
4496	arg="$pic_object"
4497	fi
4498
4499	# Non-PIC object.
4500	if test "$non_pic_object" != none; then
4501	# Prepend the subdirectory the object is found in.
4502	non_pic_object="$xdir$non_pic_object"
4503
4504	# A standard non-PIC object
4505	func_append non_pic_objects " $non_pic_object"
4506	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
4507	arg="$non_pic_object"
4508	fi
4509	else
4510	# If the PIC object exists, use it instead.
4511	# $xdir was prepended to $pic_object above.
4512	non_pic_object="$pic_object"
4513	func_append non_pic_objects " $non_pic_object"
4514	fi
4515	else
4516	# Only an error if not doing a dry-run.
4517	if $opt_dry_run; then
4518	# Extract subdirectory from the argument.
4519	func_dirname "$arg" "/" ""
4520	xdir="$func_dirname_result"
4521
4522	func_lo2o "$arg"
4523	pic_object=$xdir$objdir/$func_lo2o_result
4524	non_pic_object=$xdir$func_lo2o_result
4525	func_append libobjs " $pic_object"
4526	func_append non_pic_objects " $non_pic_object"
4527	else
4528	func_fatal_error "\`$arg' is not a valid libtool object"
4529	fi
4530	fi
4531	done
4532	else
4533	func_fatal_error "link input file \`$arg' does not exist"
4534	fi
4535	arg=$save_arg
4536	prev=
4537	continue
4538	;;
4539	precious_regex)
4540	precious_files_regex="$arg"
4541	prev=
4542	continue
4543	;;
4544	release)
4545	release="-$arg"
4546	prev=
4547	continue
4548	;;
4549	rpath \| xrpath)
4550	# We need an absolute path.
4551	case $arg in
4552	[\\/]* \| [A-Za-z]:[\\/]*) ;;
4553	*)
4554	func_fatal_error "only absolute run-paths are allowed"
4555	;;
4556	esac
4557	if test "$prev" = rpath; then
4558	case "$rpath " in
4559	" $arg ") ;;
4560	*) rpath="$rpath $arg" ;;
4561	esac
4562	else
4563	case "$xrpath " in
4564	" $arg ") ;;
4565	*) xrpath="$xrpath $arg" ;;
4566	esac
4567	fi
4568	prev=
4569	continue
4570	;;
4571	shrext)
4572	shrext_cmds="$arg"
4573	prev=
4574	continue
4575	;;
4576	weak)
4577	weak_libs="$weak_libs $arg"
4578	prev=
4579	continue
4580	;;
4581	xcclinker)
4582	linker_flags="$linker_flags $qarg"
4583	compiler_flags="$compiler_flags $qarg"
4584	prev=
4585	func_append compile_command " $qarg"
4586	func_append finalize_command " $qarg"
4587	continue
4588	;;
4589	xcompiler)
4590	compiler_flags="$compiler_flags $qarg"
4591	prev=
4592	func_append compile_command " $qarg"
4593	func_append finalize_command " $qarg"
4594	continue
4595	;;
4596	xlinker)
4597	linker_flags="$linker_flags $qarg"
4598	compiler_flags="$compiler_flags $wl$qarg"
4599	prev=
4600	func_append compile_command " $wl$qarg"
4601	func_append finalize_command " $wl$qarg"
4602	continue
4603	;;
4604	*)
4605	eval "$prev=\"\$arg\""
4606	prev=
4607	continue
4608	;;
4609	esac
4610	fi # test -n "$prev"
4611
4612	prevarg="$arg"
4613
4614	case $arg in
4615	-all-static)
4616	if test -n "$link_static_flag"; then
4617	# See comment for -static flag below, for more details.
4618	func_append compile_command " $link_static_flag"
4619	func_append finalize_command " $link_static_flag"
4620	fi
4621	continue
4622	;;
4623
4624	-allow-undefined)
4625	# FIXME: remove this flag sometime in the future.
4626	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4627	;;
4628
4629	-avoid-version)
4630	avoid_version=yes
4631	continue
4632	;;
4633
4634	-bindir)
4635	prev=bindir
4636	continue
4637	;;
4638
4639	-dlopen)
4640	prev=dlfiles
4641	continue
4642	;;
4643
4644	-dlpreopen)
4645	prev=dlprefiles
4646	continue
4647	;;
4648
4649	-export-dynamic)
4650	export_dynamic=yes
4651	continue
4652	;;
4653
4654	-export-symbols \| -export-symbols-regex)
4655	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
4656	func_fatal_error "more than one -exported-symbols argument is not allowed"
4657	fi
4658	if test "X$arg" = "X-export-symbols"; then
4659	prev=expsyms
4660	else
4661	prev=expsyms_regex
4662	fi
4663	continue
4664	;;
4665
4666	-framework)
4667	prev=framework
4668	continue
4669	;;
4670
4671	-inst-prefix-dir)
4672	prev=inst_prefix
4673	continue
4674	;;
4675
4676	# The native IRIX linker understands -LANG:, -LIST: and -LNO:*
4677	# so, if we see these flags be careful not to treat them like -L
4678	-L[A-Z][A-Z]:)
4679	case $with_gcc/$host in
4680	no/--irix* \| /--irix*)
4681	func_append compile_command " $arg"
4682	func_append finalize_command " $arg"
4683	;;
4684	esac
4685	continue
4686	;;
4687
4688	-L*)
4689	func_stripname '-L' '' "$arg"
4690	dir=$func_stripname_result
4691	if test -z "$dir"; then
4692	if test "$#" -gt 0; then
4693	func_fatal_error "require no space between \`-L' and \`$1'"
4694	else
4695	func_fatal_error "need path for \`-L' option"
4696	fi
4697	fi
4698	# We need an absolute path.
4699	case $dir in
4700	[\\/]* \| [A-Za-z]:[\\/]*) ;;
4701	*)
4702	absdir=`cd "$dir" && pwd`
4703	test -z "$absdir" && \
4704	func_fatal_error "cannot determine absolute directory name of \`$dir'"
4705	dir="$absdir"
4706	;;
4707	esac
4708	case "$deplibs " in
4709	" -L$dir ") ;;
4710	*)
4711	deplibs="$deplibs -L$dir"
4712	lib_search_path="$lib_search_path $dir"
4713	;;
4714	esac
4715	case $host in
4716	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
4717	testbindir=`$ECHO "$dir" \| $SED 's/lib$/bin*'`
4718	case :$dllsearchpath: in
4719	":$dir:") ;;
4720	::) dllsearchpath=$dir;;
4721	*) dllsearchpath="$dllsearchpath:$dir";;
4722	esac
4723	case :$dllsearchpath: in
4724	":$testbindir:") ;;
4725	::) dllsearchpath=$testbindir;;
4726	*) dllsearchpath="$dllsearchpath:$testbindir";;
4727	esac
4728	;;
4729	esac
4730	continue
4731	;;
4732
4733	-l*)
4734	if test "X$arg" = "X-lc" \|\| test "X$arg" = "X-lm"; then
4735	case $host in
4736	--cygwin* \| --mingw* \| --pw32* \| --beos* \| -cegcc \| --haiku*)
4737	# These systems don't actually have a C or math library (as such)
4738	continue
4739	;;
4740	--os2*)
4741	# These systems don't actually have a C library (as such)
4742	test "X$arg" = "X-lc" && continue
4743	;;
4744	--openbsd* \| --freebsd* \| --dragonfly*)
4745	# Do not include libc due to us having libc/libc_r.
4746	test "X$arg" = "X-lc" && continue
4747	;;
4748	--rhapsody* \| --darwin1.[012])
4749	# Rhapsody C and math libraries are in the System framework
4750	deplibs="$deplibs System.ltframework"
4751	continue
4752	;;
4753	--sco3.2v5* \| --sco5v6*)
4754	# Causes problems with __ctype
4755	test "X$arg" = "X-lc" && continue
4756	;;
4757	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
4758	# Compiler inserts libc in the correct place for threads to work
4759	test "X$arg" = "X-lc" && continue
4760	;;
4761	--linux*)
4762	test "X$arg" = "X-lc" && continue
4763	;;
4764	esac
4765	elif test "X$arg" = "X-lc_r"; then
4766	case $host in
4767	--openbsd* \| --freebsd* \| --dragonfly*)
4768	# Do not include libc_r directly, use -pthread flag.
4769	continue
4770	;;
4771	esac
4772	fi
4773	deplibs="$deplibs $arg"
4774	continue
4775	;;
4776
4777	-module)
4778	module=yes
4779	continue
4780	;;
4781
4782	# Tru64 UNIX uses -model [arg] to determine the layout of C++
4783	# classes, name mangling, and exception handling.
4784	# Darwin uses the -arch flag to determine output architecture.
4785	-model\|-arch\|-isysroot)
4786	compiler_flags="$compiler_flags $arg"
4787	func_append compile_command " $arg"
4788	func_append finalize_command " $arg"
4789	prev=xcompiler
4790	continue
4791	;;
4792
4793	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
4794	compiler_flags="$compiler_flags $arg"
4795	func_append compile_command " $arg"
4796	func_append finalize_command " $arg"
4797	case "$new_inherited_linker_flags " in
4798	" $arg ") ;;
4799	* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4800	esac
4801	continue
4802	;;
4803
4804	-multi_module)
4805	single_module="${wl}-multi_module"
4806	continue
4807	;;
4808
4809	-no-fast-install)
4810	fast_install=no
4811	continue
4812	;;
4813
4814	-no-install)
4815	case $host in
4816	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --darwin* \| -cegcc)
4817	# The PATH hackery in wrapper scripts is required on Windows
4818	# and Darwin in order for the loader to find any dlls it needs.
4819	func_warning "\`-no-install' is ignored for $host"
4820	func_warning "assuming \`-no-fast-install' instead"
4821	fast_install=no
4822	;;
4823	*) no_install=yes ;;
4824	esac
4825	continue
4826	;;
4827
4828	-no-undefined)
4829	allow_undefined=no
4830	continue
4831	;;
4832
4833	-objectlist)
4834	prev=objectlist
4835	continue
4836	;;
4837
4838	-o) prev=output ;;
4839
4840	-precious-files-regex)
4841	prev=precious_regex
4842	continue
4843	;;
4844
4845	-release)
4846	prev=release
4847	continue
4848	;;
4849
4850	-rpath)
4851	prev=rpath
4852	continue
4853	;;
4854
4855	-R)
4856	prev=xrpath
4857	continue
4858	;;
4859
4860	-R*)
4861	func_stripname '-R' '' "$arg"
4862	dir=$func_stripname_result
4863	# We need an absolute path.
4864	case $dir in
4865	[\\/]* \| [A-Za-z]:[\\/]*) ;;
4866	*)
4867	func_fatal_error "only absolute run-paths are allowed"
4868	;;
4869	esac
4870	case "$xrpath " in
4871	" $dir ") ;;
4872	*) xrpath="$xrpath $dir" ;;
4873	esac
4874	continue
4875	;;
4876
4877	-shared)
4878	# The effects of -shared are defined in a previous loop.
4879	continue
4880	;;
4881
4882	-shrext)
4883	prev=shrext
4884	continue
4885	;;
4886
4887	-static \| -static-libtool-libs)
4888	# The effects of -static are defined in a previous loop.
4889	# We used to do the same as -all-static on platforms that
4890	# didn't have a PIC flag, but the assumption that the effects
4891	# would be equivalent was wrong. It would break on at least
4892	# Digital Unix and AIX.
4893	continue
4894	;;
4895
4896	-thread-safe)
4897	thread_safe=yes
4898	continue
4899	;;
4900
4901	-version-info)
4902	prev=vinfo
4903	continue
4904	;;
4905
4906	-version-number)
4907	prev=vinfo
4908	vinfo_number=yes
4909	continue
4910	;;
4911
4912	-weak)
4913	prev=weak
4914	continue
4915	;;
4916
4917	-Wc,*)
4918	func_stripname '-Wc,' '' "$arg"
4919	args=$func_stripname_result
4920	arg=
4921	save_ifs="$IFS"; IFS=','
4922	for flag in $args; do
4923	IFS="$save_ifs"
4924	func_quote_for_eval "$flag"
4925	arg="$arg $func_quote_for_eval_result"
4926	compiler_flags="$compiler_flags $func_quote_for_eval_result"
4927	done
4928	IFS="$save_ifs"
4929	func_stripname ' ' '' "$arg"
4930	arg=$func_stripname_result
4931	;;
4932
4933	-Wl,*)
4934	func_stripname '-Wl,' '' "$arg"
4935	args=$func_stripname_result
4936	arg=
4937	save_ifs="$IFS"; IFS=','
4938	for flag in $args; do
4939	IFS="$save_ifs"
4940	func_quote_for_eval "$flag"
4941	arg="$arg $wl$func_quote_for_eval_result"
4942	compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4943	linker_flags="$linker_flags $func_quote_for_eval_result"
4944	done
4945	IFS="$save_ifs"
4946	func_stripname ' ' '' "$arg"
4947	arg=$func_stripname_result
4948	;;
4949
4950	-Xcompiler)
4951	prev=xcompiler
4952	continue
4953	;;
4954
4955	-Xlinker)
4956	prev=xlinker
4957	continue
4958	;;
4959
4960	-XCClinker)
4961	prev=xcclinker
4962	continue
4963	;;
4964
4965	# -msg_* for osf cc
4966	-msg_*)
4967	func_quote_for_eval "$arg"
4968	arg="$func_quote_for_eval_result"
4969	;;
4970
4971	# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4972	# -r[0-9][0-9]* specifies the processor on the SGI compiler
4973	# -xarch=, -xtarget= enable 64-bit mode on the Sun compiler
4974	# +DA, +DD enable 64-bit mode on the HP compiler
4975	# -q* pass through compiler args for the IBM compiler
4976	# -m, -t[45], -txscale* pass through architecture-specific
4977	# compiler args for GCC
4978	# -F/path gives path to uninstalled frameworks, gcc on darwin
4979	# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4980	# @file GCC response files
4981	# -tp=* Portland pgcc target processor selection
4982	-64\|-mips[0-9]\|-r[0-9][0-9]\|-xarch=\|-xtarget=\|+DA\|+DD\|-q\|-m*\| \
4983	-t[45]\|-txscale\|-p\|-pg\|--coverage\|-fprofile-\|-F\|@\|-tp=)
4984	func_quote_for_eval "$arg"
4985	arg="$func_quote_for_eval_result"
4986	func_append compile_command " $arg"
4987	func_append finalize_command " $arg"
4988	compiler_flags="$compiler_flags $arg"
4989	continue
4990	;;
4991
4992	# Some other compiler flag.
4993	-* \| +*)
4994	func_quote_for_eval "$arg"
4995	arg="$func_quote_for_eval_result"
4996	;;
4997
4998	*.$objext)
4999	# A standard object.
5000	objs="$objs $arg"
5001	;;
5002
5003	*.lo)
5004	# A libtool-controlled object.
5005
5006	# Check to see that this really is a libtool object.
5007	if func_lalib_unsafe_p "$arg"; then
5008	pic_object=
5009	non_pic_object=
5010
5011	# Read the .lo file
5012	func_source "$arg"
5013
5014	if test -z "$pic_object" \|\|
5015	test -z "$non_pic_object" \|\|
5016	test "$pic_object" = none &&
5017	test "$non_pic_object" = none; then
5018	func_fatal_error "cannot find name of object for \`$arg'"
5019	fi
5020
5021	# Extract subdirectory from the argument.
5022	func_dirname "$arg" "/" ""
5023	xdir="$func_dirname_result"
5024
5025	if test "$pic_object" != none; then
5026	# Prepend the subdirectory the object is found in.
5027	pic_object="$xdir$pic_object"
5028
5029	if test "$prev" = dlfiles; then
5030	if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5031	dlfiles="$dlfiles $pic_object"
5032	prev=
5033	continue
5034	else
5035	# If libtool objects are unsupported, then we need to preload.
5036	prev=dlprefiles
5037	fi
5038	fi
5039
5040	# CHECK ME: I think I busted this. -Ossama
5041	if test "$prev" = dlprefiles; then
5042	# Preload the old-style object.
5043	dlprefiles="$dlprefiles $pic_object"
5044	prev=
5045	fi
5046
5047	# A PIC object.
5048	func_append libobjs " $pic_object"
5049	arg="$pic_object"
5050	fi
5051
5052	# Non-PIC object.
5053	if test "$non_pic_object" != none; then
5054	# Prepend the subdirectory the object is found in.
5055	non_pic_object="$xdir$non_pic_object"
5056
5057	# A standard non-PIC object
5058	func_append non_pic_objects " $non_pic_object"
5059	if test -z "$pic_object" \|\| test "$pic_object" = none ; then
5060	arg="$non_pic_object"
5061	fi
5062	else
5063	# If the PIC object exists, use it instead.
5064	# $xdir was prepended to $pic_object above.
5065	non_pic_object="$pic_object"
5066	func_append non_pic_objects " $non_pic_object"
5067	fi
5068	else
5069	# Only an error if not doing a dry-run.
5070	if $opt_dry_run; then
5071	# Extract subdirectory from the argument.
5072	func_dirname "$arg" "/" ""
5073	xdir="$func_dirname_result"
5074
5075	func_lo2o "$arg"
5076	pic_object=$xdir$objdir/$func_lo2o_result
5077	non_pic_object=$xdir$func_lo2o_result
5078	func_append libobjs " $pic_object"
5079	func_append non_pic_objects " $non_pic_object"
5080	else
5081	func_fatal_error "\`$arg' is not a valid libtool object"
5082	fi
5083	fi
5084	;;
5085
5086	*.$libext)
5087	# An archive.
5088	deplibs="$deplibs $arg"
5089	old_deplibs="$old_deplibs $arg"
5090	continue
5091	;;
5092
5093	*.la)
5094	# A libtool-controlled library.
5095
5096	if test "$prev" = dlfiles; then
5097	# This library was specified with -dlopen.
5098	dlfiles="$dlfiles $arg"
5099	prev=
5100	elif test "$prev" = dlprefiles; then
5101	# The library was specified with -dlpreopen.
5102	dlprefiles="$dlprefiles $arg"
5103	prev=
5104	else
5105	deplibs="$deplibs $arg"
5106	fi
5107	continue
5108	;;
5109
5110	# Some other compiler argument.
5111	*)
5112	# Unknown arguments in both finalize_command and compile_command need
5113	# to be aesthetically quoted because they are evaled later.
5114	func_quote_for_eval "$arg"
5115	arg="$func_quote_for_eval_result"
5116	;;
5117	esac # arg
5118
5119	# Now actually substitute the argument into the commands.
5120	if test -n "$arg"; then
5121	func_append compile_command " $arg"
5122	func_append finalize_command " $arg"
5123	fi
5124	done # argument parsing loop
5125
5126	test -n "$prev" && \
5127	func_fatal_help "the \`$prevarg' option requires an argument"
5128
5129	if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5130	eval "arg=\"$export_dynamic_flag_spec\""
5131	func_append compile_command " $arg"
5132	func_append finalize_command " $arg"
5133	fi
5134
5135	oldlibs=
5136	# calculate the name of the file, without its directory
5137	func_basename "$output"
5138	outputname="$func_basename_result"
5139	libobjs_save="$libobjs"
5140
5141	if test -n "$shlibpath_var"; then
5142	# get the directories listed in $shlibpath_var
5143	eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \\| \$SED \'s/:/ /g\'\`
5144	else
5145	shlib_search_path=
5146	fi
5147	eval "sys_lib_search_path=\"$sys_lib_search_path_spec\""
5148	eval "sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\""
5149
5150	func_dirname "$output" "/" ""
5151	output_objdir="$func_dirname_result$objdir"
5152	# Create the object directory.
5153	func_mkdir_p "$output_objdir"
5154
5155	# Determine the type of output
5156	case $output in
5157	"")
5158	func_fatal_help "you must specify an output file"
5159	;;
5160	*.$libext) linkmode=oldlib ;;
5161	.lo \| .$objext) linkmode=obj ;;
5162	*.la) linkmode=lib ;;
5163	*) linkmode=prog ;; # Anything else should be a program.
5164	esac
5165
5166	specialdeplibs=
5167
5168	libs=
5169	# Find all interdependent deplibs by searching for libraries
5170	# that are linked more than once (e.g. -la -lb -la)
5171	for deplib in $deplibs; do
5172	if $opt_duplicate_deps ; then
5173	case "$libs " in
5174	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
5175	esac
5176	fi
5177	libs="$libs $deplib"
5178	done
5179
5180	if test "$linkmode" = lib; then
5181	libs="$predeps $libs $compiler_lib_search_path $postdeps"
5182
5183	# Compute libraries that are listed more than once in $predeps
5184	# $postdeps and mark them as special (i.e., whose duplicates are
5185	# not to be eliminated).
5186	pre_post_deps=
5187	if $opt_duplicate_compiler_generated_deps; then
5188	for pre_post_dep in $predeps $postdeps; do
5189	case "$pre_post_deps " in
5190	" $pre_post_dep ") specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5191	esac
5192	pre_post_deps="$pre_post_deps $pre_post_dep"
5193	done
5194	fi
5195	pre_post_deps=
5196	fi
5197
5198	deplibs=
5199	newdependency_libs=
5200	newlib_search_path=
5201	need_relink=no # whether we're linking any uninstalled libtool libraries
5202	notinst_deplibs= # not-installed libtool libraries
5203	notinst_path= # paths that contain not-installed libtool libraries
5204
5205	case $linkmode in
5206	lib)
5207	passes="conv dlpreopen link"
5208	for file in $dlfiles $dlprefiles; do
5209	case $file in
5210	*.la) ;;
5211	*)
5212	func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5213	;;
5214	esac
5215	done
5216	;;
5217	prog)
5218	compile_deplibs=
5219	finalize_deplibs=
5220	alldeplibs=no
5221	newdlfiles=
5222	newdlprefiles=
5223	passes="conv scan dlopen dlpreopen link"
5224	;;
5225	*) passes="conv"
5226	;;
5227	esac
5228
5229	for pass in $passes; do
5230	# The preopen pass in lib mode reverses $deplibs; put it back here
5231	# so that -L comes before libs that need it for instance...
5232	if test "$linkmode,$pass" = "lib,link"; then
5233	## FIXME: Find the place where the list is rebuilt in the wrong
5234	## order, and fix it there properly
5235	tmp_deplibs=
5236	for deplib in $deplibs; do
5237	tmp_deplibs="$deplib $tmp_deplibs"
5238	done
5239	deplibs="$tmp_deplibs"
5240	fi
5241
5242	if test "$linkmode,$pass" = "lib,link" \|\|
5243	test "$linkmode,$pass" = "prog,scan"; then
5244	libs="$deplibs"
5245	deplibs=
5246	fi
5247	if test "$linkmode" = prog; then
5248	case $pass in
5249	dlopen) libs="$dlfiles" ;;
5250	dlpreopen) libs="$dlprefiles" ;;
5251	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5252	esac
5253	fi
5254	if test "$linkmode,$pass" = "lib,dlpreopen"; then
5255	# Collect and forward deplibs of preopened libtool libs
5256	for lib in $dlprefiles; do
5257	# Ignore non-libtool-libs
5258	dependency_libs=
5259	case $lib in
5260	*.la) func_source "$lib" ;;
5261	esac
5262
5263	# Collect preopened libtool deplibs, except any this library
5264	# has declared as weak libs
5265	for deplib in $dependency_libs; do
5266	func_basename "$deplib"
5267	deplib_base=$func_basename_result
5268	case " $weak_libs " in
5269	" $deplib_base ") ;;
5270	*) deplibs="$deplibs $deplib" ;;
5271	esac
5272	done
5273	done
5274	libs="$dlprefiles"
5275	fi
5276	if test "$pass" = dlopen; then
5277	# Collect dlpreopened libraries
5278	save_deplibs="$deplibs"
5279	deplibs=
5280	fi
5281
5282	for deplib in $libs; do
5283	lib=
5284	found=no
5285	case $deplib in
5286	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe\|-threads)
5287	if test "$linkmode,$pass" = "prog,link"; then
5288	compile_deplibs="$deplib $compile_deplibs"
5289	finalize_deplibs="$deplib $finalize_deplibs"
5290	else
5291	compiler_flags="$compiler_flags $deplib"
5292	if test "$linkmode" = lib ; then
5293	case "$new_inherited_linker_flags " in
5294	" $deplib ") ;;
5295	* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5296	esac
5297	fi
5298	fi
5299	continue
5300	;;
5301	-l*)
5302	if test "$linkmode" != lib && test "$linkmode" != prog; then
5303	func_warning "\`-l' is ignored for archives/objects"
5304	continue
5305	fi
5306	func_stripname '-l' '' "$deplib"
5307	name=$func_stripname_result
5308	if test "$linkmode" = lib; then
5309	searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5310	else
5311	searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5312	fi
5313	for searchdir in $searchdirs; do
5314	for search_ext in .la $std_shrext .so .a; do
5315	# Search the libtool library
5316	lib="$searchdir/lib${name}${search_ext}"
5317	if test -f "$lib"; then
5318	if test "$search_ext" = ".la"; then
5319	found=yes
5320	else
5321	found=no
5322	fi
5323	break 2
5324	fi
5325	done
5326	done
5327	if test "$found" != yes; then
5328	# deplib doesn't seem to be a libtool library
5329	if test "$linkmode,$pass" = "prog,link"; then
5330	compile_deplibs="$deplib $compile_deplibs"
5331	finalize_deplibs="$deplib $finalize_deplibs"
5332	else
5333	deplibs="$deplib $deplibs"
5334	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5335	fi
5336	continue
5337	else # deplib is a libtool library
5338	# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5339	# We need to do some special things here, and not later.
5340	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5341	case " $predeps $postdeps " in
5342	" $deplib ")
5343	if func_lalib_p "$lib"; then
5344	library_names=
5345	old_library=
5346	func_source "$lib"
5347	for l in $old_library $library_names; do
5348	ll="$l"
5349	done
5350	if test "X$ll" = "X$old_library" ; then # only static version available
5351	found=no
5352	func_dirname "$lib" "" "."
5353	ladir="$func_dirname_result"
5354	lib=$ladir/$old_library
5355	if test "$linkmode,$pass" = "prog,link"; then
5356	compile_deplibs="$deplib $compile_deplibs"
5357	finalize_deplibs="$deplib $finalize_deplibs"
5358	else
5359	deplibs="$deplib $deplibs"
5360	test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5361	fi
5362	continue
5363	fi
5364	fi
5365	;;
5366	*) ;;
5367	esac
5368	fi
5369	fi
5370	;; # -l
5371	*.ltframework)
5372	if test "$linkmode,$pass" = "prog,link"; then
5373	compile_deplibs="$deplib $compile_deplibs"
5374	finalize_deplibs="$deplib $finalize_deplibs"
5375	else
5376	deplibs="$deplib $deplibs"
5377	if test "$linkmode" = lib ; then
5378	case "$new_inherited_linker_flags " in
5379	" $deplib ") ;;
5380	* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5381	esac
5382	fi
5383	fi
5384	continue
5385	;;
5386	-L*)
5387	case $linkmode in
5388	lib)
5389	deplibs="$deplib $deplibs"
5390	test "$pass" = conv && continue
5391	newdependency_libs="$deplib $newdependency_libs"
5392	func_stripname '-L' '' "$deplib"
5393	newlib_search_path="$newlib_search_path $func_stripname_result"
5394	;;
5395	prog)
5396	if test "$pass" = conv; then
5397	deplibs="$deplib $deplibs"
5398	continue
5399	fi
5400	if test "$pass" = scan; then
5401	deplibs="$deplib $deplibs"
5402	else
5403	compile_deplibs="$deplib $compile_deplibs"
5404	finalize_deplibs="$deplib $finalize_deplibs"
5405	fi
5406	func_stripname '-L' '' "$deplib"
5407	newlib_search_path="$newlib_search_path $func_stripname_result"
5408	;;
5409	*)
5410	func_warning "\`-L' is ignored for archives/objects"
5411	;;
5412	esac # linkmode
5413	continue
5414	;; # -L
5415	-R*)
5416	if test "$pass" = link; then
5417	func_stripname '-R' '' "$deplib"
5418	dir=$func_stripname_result
5419	# Make sure the xrpath contains only unique directories.
5420	case "$xrpath " in
5421	" $dir ") ;;
5422	*) xrpath="$xrpath $dir" ;;
5423	esac
5424	fi
5425	deplibs="$deplib $deplibs"
5426	continue
5427	;;
5428	*.la) lib="$deplib" ;;
5429	*.$libext)
5430	if test "$pass" = conv; then
5431	deplibs="$deplib $deplibs"
5432	continue
5433	fi
5434	case $linkmode in
5435	lib)
5436	# Linking convenience modules into shared libraries is allowed,
5437	# but linking other static libraries is non-portable.
5438	case " $dlpreconveniencelibs " in
5439	" $deplib ") ;;
5440	*)
5441	valid_a_lib=no
5442	case $deplibs_check_method in
5443	match_pattern*)
5444	set dummy $deplibs_check_method; shift
5445	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
5446	if eval "\$ECHO \"$deplib\"" 2>/dev/null \| $SED 10q \
5447	\| $EGREP "$match_pattern_regex" > /dev/null; then
5448	valid_a_lib=yes
5449	fi
5450	;;
5451	pass_all)
5452	valid_a_lib=yes
5453	;;
5454	esac
5455	if test "$valid_a_lib" != yes; then
5456	echo
5457	$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5458	echo "*** I have the capability to make that library automatically link in when"
5459	echo "*** you link to this library. But I can only do this if you have a"
5460	echo "*** shared version of the library, which you do not appear to have"
5461	echo "*** because the file extensions .$libext of this argument makes me believe"
5462	echo "*** that it is just a static archive that I should not use here."
5463	else
5464	echo
5465	$ECHO "*** Warning: Linking the shared library $output against the"
5466	$ECHO "*** static library $deplib is not portable!"
5467	deplibs="$deplib $deplibs"
5468	fi
5469	;;
5470	esac
5471	continue
5472	;;
5473	prog)
5474	if test "$pass" != link; then
5475	deplibs="$deplib $deplibs"
5476	else
5477	compile_deplibs="$deplib $compile_deplibs"
5478	finalize_deplibs="$deplib $finalize_deplibs"
5479	fi
5480	continue
5481	;;
5482	esac # linkmode
5483	;; # *.$libext
5484	.lo \| .$objext)
5485	if test "$pass" = conv; then
5486	deplibs="$deplib $deplibs"
5487	elif test "$linkmode" = prog; then
5488	if test "$pass" = dlpreopen \|\| test "$dlopen_support" != yes \|\| test "$build_libtool_libs" = no; then
5489	# If there is no dlopen support or we're linking statically,
5490	# we need to preload.
5491	newdlprefiles="$newdlprefiles $deplib"
5492	compile_deplibs="$deplib $compile_deplibs"
5493	finalize_deplibs="$deplib $finalize_deplibs"
5494	else
5495	newdlfiles="$newdlfiles $deplib"
5496	fi
5497	fi
5498	continue
5499	;;
5500	%DEPLIBS%)
5501	alldeplibs=yes
5502	continue
5503	;;
5504	esac # case $deplib
5505
5506	if test "$found" = yes \|\| test -f "$lib"; then :
5507	else
5508	func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5509	fi
5510
5511	# Check to see that this really is a libtool archive.
5512	func_lalib_unsafe_p "$lib" \
5513	\|\| func_fatal_error "\`$lib' is not a valid libtool archive"
5514
5515	func_dirname "$lib" "" "."
5516	ladir="$func_dirname_result"
5517
5518	dlname=
5519	dlopen=
5520	dlpreopen=
5521	libdir=
5522	library_names=
5523	old_library=
5524	inherited_linker_flags=
5525	# If the library was installed with an old release of libtool,
5526	# it will not redefine variables installed, or shouldnotlink
5527	installed=yes
5528	shouldnotlink=no
5529	avoidtemprpath=
5530
5531
5532	# Read the .la file
5533	func_source "$lib"
5534
5535	# Convert "-framework foo" to "foo.ltframework"
5536	if test -n "$inherited_linker_flags"; then
5537	tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" \| $SED 's/-framework $[^ $]*$/\1.ltframework/g'`
5538	for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5539	case " $new_inherited_linker_flags " in
5540	" $tmp_inherited_linker_flag ") ;;
5541	*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5542	esac
5543	done
5544	fi
5545	dependency_libs=`$ECHO " $dependency_libs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
5546	if test "$linkmode,$pass" = "lib,link" \|\|
5547	test "$linkmode,$pass" = "prog,scan" \|\|
5548	{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5549	test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5550	test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5551	fi
5552
5553	if test "$pass" = conv; then
5554	# Only check for convenience libraries
5555	deplibs="$lib $deplibs"
5556	if test -z "$libdir"; then
5557	if test -z "$old_library"; then
5558	func_fatal_error "cannot find name of link library for \`$lib'"
5559	fi
5560	# It is a libtool convenience library, so add in its objects.
5561	convenience="$convenience $ladir/$objdir/$old_library"
5562	old_convenience="$old_convenience $ladir/$objdir/$old_library"
5563	elif test "$linkmode" != prog && test "$linkmode" != lib; then
5564	func_fatal_error "\`$lib' is not a convenience library"
5565	fi
5566	tmp_libs=
5567	for deplib in $dependency_libs; do
5568	deplibs="$deplib $deplibs"
5569	if $opt_duplicate_deps ; then
5570	case "$tmp_libs " in
5571	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
5572	esac
5573	fi
5574	tmp_libs="$tmp_libs $deplib"
5575	done
5576	continue
5577	fi # $pass = conv
5578
5579
5580	# Get the name of the library we link against.
5581	linklib=
5582	for l in $old_library $library_names; do
5583	linklib="$l"
5584	done
5585	if test -z "$linklib"; then
5586	func_fatal_error "cannot find name of link library for \`$lib'"
5587	fi
5588
5589	# This library was specified with -dlopen.
5590	if test "$pass" = dlopen; then
5591	if test -z "$libdir"; then
5592	func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5593	fi
5594	if test -z "$dlname" \|\|
5595	test "$dlopen_support" != yes \|\|
5596	test "$build_libtool_libs" = no; then
5597	# If there is no dlname, no dlopen support or we're linking
5598	# statically, we need to preload. We also need to preload any
5599	# dependent libraries so libltdl's deplib preloader doesn't
5600	# bomb out in the load deplibs phase.
5601	dlprefiles="$dlprefiles $lib $dependency_libs"
5602	else
5603	newdlfiles="$newdlfiles $lib"
5604	fi
5605	continue
5606	fi # $pass = dlopen
5607
5608	# We need an absolute path.
5609	case $ladir in
5610	[\\/]* \| [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5611	*)
5612	abs_ladir=`cd "$ladir" && pwd`
5613	if test -z "$abs_ladir"; then
5614	func_warning "cannot determine absolute directory name of \`$ladir'"
5615	func_warning "passing it literally to the linker, although it might fail"
5616	abs_ladir="$ladir"
5617	fi
5618	;;
5619	esac
5620	func_basename "$lib"
5621	laname="$func_basename_result"
5622
5623	# Find the relevant object directory and library name.
5624	if test "X$installed" = Xyes; then
5625	if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5626	func_warning "library \`$lib' was moved."
5627	dir="$ladir"
5628	absdir="$abs_ladir"
5629	libdir="$abs_ladir"
5630	else
5631	dir="$libdir"
5632	absdir="$libdir"
5633	fi
5634	test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5635	else
5636	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5637	dir="$ladir"
5638	absdir="$abs_ladir"
5639	# Remove this search path later
5640	notinst_path="$notinst_path $abs_ladir"
5641	else
5642	dir="$ladir/$objdir"
5643	absdir="$abs_ladir/$objdir"
5644	# Remove this search path later
5645	notinst_path="$notinst_path $abs_ladir"
5646	fi
5647	fi # $installed = yes
5648	func_stripname 'lib' '.la' "$laname"
5649	name=$func_stripname_result
5650
5651	# This library was specified with -dlpreopen.
5652	if test "$pass" = dlpreopen; then
5653	if test -z "$libdir" && test "$linkmode" = prog; then
5654	func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5655	fi
5656	# Prefer using a static library (so that no silly _DYNAMIC symbols
5657	# are required to link).
5658	if test -n "$old_library"; then
5659	newdlprefiles="$newdlprefiles $dir/$old_library"
5660	# Keep a list of preopened convenience libraries to check
5661	# that they are being used correctly in the link pass.
5662	test -z "$libdir" && \
5663	dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5664	# Otherwise, use the dlname, so that lt_dlopen finds it.
5665	elif test -n "$dlname"; then
5666	newdlprefiles="$newdlprefiles $dir/$dlname"
5667	else
5668	newdlprefiles="$newdlprefiles $dir/$linklib"
5669	fi
5670	fi # $pass = dlpreopen
5671
5672	if test -z "$libdir"; then
5673	# Link the convenience library
5674	if test "$linkmode" = lib; then
5675	deplibs="$dir/$old_library $deplibs"
5676	elif test "$linkmode,$pass" = "prog,link"; then
5677	compile_deplibs="$dir/$old_library $compile_deplibs"
5678	finalize_deplibs="$dir/$old_library $finalize_deplibs"
5679	else
5680	deplibs="$lib $deplibs" # used for prog,scan pass
5681	fi
5682	continue
5683	fi
5684
5685
5686	if test "$linkmode" = prog && test "$pass" != link; then
5687	newlib_search_path="$newlib_search_path $ladir"
5688	deplibs="$lib $deplibs"
5689
5690	linkalldeplibs=no
5691	if test "$link_all_deplibs" != no \|\| test -z "$library_names" \|\|
5692	test "$build_libtool_libs" = no; then
5693	linkalldeplibs=yes
5694	fi
5695
5696	tmp_libs=
5697	for deplib in $dependency_libs; do
5698	case $deplib in
5699	-L*) func_stripname '-L' '' "$deplib"
5700	newlib_search_path="$newlib_search_path $func_stripname_result"
5701	;;
5702	esac
5703	# Need to link against all dependency_libs?
5704	if test "$linkalldeplibs" = yes; then
5705	deplibs="$deplib $deplibs"
5706	else
5707	# Need to hardcode shared library paths
5708	# or/and link against static libraries
5709	newdependency_libs="$deplib $newdependency_libs"
5710	fi
5711	if $opt_duplicate_deps ; then
5712	case "$tmp_libs " in
5713	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
5714	esac
5715	fi
5716	tmp_libs="$tmp_libs $deplib"
5717	done # for deplib
5718	continue
5719	fi # $linkmode = prog...
5720
5721	if test "$linkmode,$pass" = "prog,link"; then
5722	if test -n "$library_names" &&
5723	{ { test "$prefer_static_libs" = no \|\|
5724	test "$prefer_static_libs,$installed" = "built,yes"; } \|\|
5725	test -z "$old_library"; }; then
5726	# We need to hardcode the library path
5727	if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5728	# Make sure the rpath contains only unique directories.
5729	case "$temp_rpath:" in
5730	"$absdir:") ;;
5731	*) temp_rpath="$temp_rpath$absdir:" ;;
5732	esac
5733	fi
5734
5735	# Hardcode the library path.
5736	# Skip directories that are in the system default run-time
5737	# search path.
5738	case " $sys_lib_dlsearch_path " in
5739	" $absdir ") ;;
5740	*)
5741	case "$compile_rpath " in
5742	" $absdir ") ;;
5743	*) compile_rpath="$compile_rpath $absdir"
5744	esac
5745	;;
5746	esac
5747	case " $sys_lib_dlsearch_path " in
5748	" $libdir ") ;;
5749	*)
5750	case "$finalize_rpath " in
5751	" $libdir ") ;;
5752	*) finalize_rpath="$finalize_rpath $libdir"
5753	esac
5754	;;
5755	esac
5756	fi # $linkmode,$pass = prog,link...
5757
5758	if test "$alldeplibs" = yes &&
5759	{ test "$deplibs_check_method" = pass_all \|\|
5760	{ test "$build_libtool_libs" = yes &&
5761	test -n "$library_names"; }; }; then
5762	# We only need to search for static libraries
5763	continue
5764	fi
5765	fi
5766
5767	link_static=no # Whether the deplib will be linked statically
5768	use_static_libs=$prefer_static_libs
5769	if test "$use_static_libs" = built && test "$installed" = yes; then
5770	use_static_libs=no
5771	fi
5772	if test -n "$library_names" &&
5773	{ test "$use_static_libs" = no \|\| test -z "$old_library"; }; then
5774	case $host in
5775	cygwin \| mingw \| cegcc)
5776	# No point in relinking DLLs because paths are not encoded
5777	notinst_deplibs="$notinst_deplibs $lib"
5778	need_relink=no
5779	;;
5780	*)
5781	if test "$installed" = no; then
5782	notinst_deplibs="$notinst_deplibs $lib"
5783	need_relink=yes
5784	fi
5785	;;
5786	esac
5787	# This is a shared library
5788
5789	# Warn about portability, can't link against -module's on some
5790	# systems (darwin). Don't bleat about dlopened modules though!
5791	dlopenmodule=""
5792	for dlpremoduletest in $dlprefiles; do
5793	if test "X$dlpremoduletest" = "X$lib"; then
5794	dlopenmodule="$dlpremoduletest"
5795	break
5796	fi
5797	done
5798	if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5799	echo
5800	if test "$linkmode" = prog; then
5801	$ECHO "*** Warning: Linking the executable $output against the loadable module"
5802	else
5803	$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5804	fi
5805	$ECHO "*** $linklib is not portable!"
5806	fi
5807	if test "$linkmode" = lib &&
5808	test "$hardcode_into_libs" = yes; then
5809	# Hardcode the library path.
5810	# Skip directories that are in the system default run-time
5811	# search path.
5812	case " $sys_lib_dlsearch_path " in
5813	" $absdir ") ;;
5814	*)
5815	case "$compile_rpath " in
5816	" $absdir ") ;;
5817	*) compile_rpath="$compile_rpath $absdir"
5818	esac
5819	;;
5820	esac
5821	case " $sys_lib_dlsearch_path " in
5822	" $libdir ") ;;
5823	*)
5824	case "$finalize_rpath " in
5825	" $libdir ") ;;
5826	*) finalize_rpath="$finalize_rpath $libdir"
5827	esac
5828	;;
5829	esac
5830	fi
5831
5832	if test -n "$old_archive_from_expsyms_cmds"; then
5833	# figure out the soname
5834	set dummy $library_names
5835	shift
5836	realname="$1"
5837	shift
5838	eval "libname=\"$libname_spec\""
5839	# use dlname if we got it. it's perfectly good, no?
5840	if test -n "$dlname"; then
5841	soname="$dlname"
5842	elif test -n "$soname_spec"; then
5843	# bleh windows
5844	case $host in
5845	cygwin \| mingw* \| cegcc)
5846	func_arith $current - $age
5847	major=$func_arith_result
5848	versuffix="-$major"
5849	;;
5850	esac
5851	eval "soname=\"$soname_spec\""
5852	else
5853	soname="$realname"
5854	fi
5855
5856	# Make a new name for the extract_expsyms_cmds to use
5857	soroot="$soname"
5858	func_basename "$soroot"
5859	soname="$func_basename_result"
5860	func_stripname 'lib' '.dll' "$soname"
5861	newlib=libimp-$func_stripname_result.a
5862
5863	# If the library has no export list, then create one now
5864	if test -f "$output_objdir/$soname-def"; then :
5865	else
5866	func_verbose "extracting exported symbol list from \`$soname'"
5867	func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5868	fi
5869
5870	# Create $newlib
5871	if test -f "$output_objdir/$newlib"; then :; else
5872	func_verbose "generating import library for \`$soname'"
5873	func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5874	fi
5875	# make sure the library variables are pointing to the new library
5876	dir=$output_objdir
5877	linklib=$newlib
5878	fi # test -n "$old_archive_from_expsyms_cmds"
5879
5880	if test "$linkmode" = prog \|\| test "$mode" != relink; then
5881	add_shlibpath=
5882	add_dir=
5883	add=
5884	lib_linked=yes
5885	case $hardcode_action in
5886	immediate \| unsupported)
5887	if test "$hardcode_direct" = no; then
5888	add="$dir/$linklib"
5889	case $host in
5890	--sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5891	--sysv4uw2) add_dir="-L$dir" ;;
5892	--sysv5OpenUNIX* \| --sysv5UnixWare7.[01].[10]* \| \
5893	--unixware7*) add_dir="-L$dir" ;;
5894	--darwin* )
5895	# if the lib is a (non-dlopened) module then we can not
5896	# link against it, someone is ignoring the earlier warnings
5897	if /usr/bin/file -L $add 2> /dev/null \|
5898	$GREP ": [^:]* bundle" >/dev/null ; then
5899	if test "X$dlopenmodule" != "X$lib"; then
5900	$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5901	if test -z "$old_library" ; then
5902	echo
5903	echo "*** And there doesn't seem to be a static archive available"
5904	echo "*** The link will probably fail, sorry"
5905	else
5906	add="$dir/$old_library"
5907	fi
5908	elif test -n "$old_library"; then
5909	add="$dir/$old_library"
5910	fi
5911	fi
5912	esac
5913	elif test "$hardcode_minus_L" = no; then
5914	case $host in
5915	--sunos*) add_shlibpath="$dir" ;;
5916	esac
5917	add_dir="-L$dir"
5918	add="-l$name"
5919	elif test "$hardcode_shlibpath_var" = no; then
5920	add_shlibpath="$dir"
5921	add="-l$name"
5922	else
5923	lib_linked=no
5924	fi
5925	;;
5926	relink)
5927	if test "$hardcode_direct" = yes &&
5928	test "$hardcode_direct_absolute" = no; then
5929	add="$dir/$linklib"
5930	elif test "$hardcode_minus_L" = yes; then
5931	add_dir="-L$absdir"
5932	# Try looking first in the location we're being installed to.
5933	if test -n "$inst_prefix_dir"; then
5934	case $libdir in
5935	[\\/]*)
5936	add_dir="$add_dir -L$inst_prefix_dir$libdir"
5937	;;
5938	esac
5939	fi
5940	add="-l$name"
5941	elif test "$hardcode_shlibpath_var" = yes; then
5942	add_shlibpath="$dir"
5943	add="-l$name"
5944	else
5945	lib_linked=no
5946	fi
5947	;;
5948	*) lib_linked=no ;;
5949	esac
5950
5951	if test "$lib_linked" != yes; then
5952	func_fatal_configuration "unsupported hardcode properties"
5953	fi
5954
5955	if test -n "$add_shlibpath"; then
5956	case :$compile_shlibpath: in
5957	":$add_shlibpath:") ;;
5958	*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5959	esac
5960	fi
5961	if test "$linkmode" = prog; then
5962	test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5963	test -n "$add" && compile_deplibs="$add $compile_deplibs"
5964	else
5965	test -n "$add_dir" && deplibs="$add_dir $deplibs"
5966	test -n "$add" && deplibs="$add $deplibs"
5967	if test "$hardcode_direct" != yes &&
5968	test "$hardcode_minus_L" != yes &&
5969	test "$hardcode_shlibpath_var" = yes; then
5970	case :$finalize_shlibpath: in
5971	":$libdir:") ;;
5972	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5973	esac
5974	fi
5975	fi
5976	fi
5977
5978	if test "$linkmode" = prog \|\| test "$mode" = relink; then
5979	add_shlibpath=
5980	add_dir=
5981	add=
5982	# Finalize command for both is simple: just hardcode it.
5983	if test "$hardcode_direct" = yes &&
5984	test "$hardcode_direct_absolute" = no; then
5985	add="$libdir/$linklib"
5986	elif test "$hardcode_minus_L" = yes; then
5987	add_dir="-L$libdir"
5988	add="-l$name"
5989	elif test "$hardcode_shlibpath_var" = yes; then
5990	case :$finalize_shlibpath: in
5991	":$libdir:") ;;
5992	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5993	esac
5994	add="-l$name"
5995	elif test "$hardcode_automatic" = yes; then
5996	if test -n "$inst_prefix_dir" &&
5997	test -f "$inst_prefix_dir$libdir/$linklib" ; then
5998	add="$inst_prefix_dir$libdir/$linklib"
5999	else
6000	add="$libdir/$linklib"
6001	fi
6002	else
6003	# We cannot seem to hardcode it, guess we'll fake it.
6004	add_dir="-L$libdir"
6005	# Try looking first in the location we're being installed to.
6006	if test -n "$inst_prefix_dir"; then
6007	case $libdir in
6008	[\\/]*)
6009	add_dir="$add_dir -L$inst_prefix_dir$libdir"
6010	;;
6011	esac
6012	fi
6013	add="-l$name"
6014	fi
6015
6016	if test "$linkmode" = prog; then
6017	test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6018	test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6019	else
6020	test -n "$add_dir" && deplibs="$add_dir $deplibs"
6021	test -n "$add" && deplibs="$add $deplibs"
6022	fi
6023	fi
6024	elif test "$linkmode" = prog; then
6025	# Here we assume that one of hardcode_direct or hardcode_minus_L
6026	# is not unsupported. This is valid on all known static and
6027	# shared platforms.
6028	if test "$hardcode_direct" != unsupported; then
6029	test -n "$old_library" && linklib="$old_library"
6030	compile_deplibs="$dir/$linklib $compile_deplibs"
6031	finalize_deplibs="$dir/$linklib $finalize_deplibs"
6032	else
6033	compile_deplibs="-l$name -L$dir $compile_deplibs"
6034	finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6035	fi
6036	elif test "$build_libtool_libs" = yes; then
6037	# Not a shared library
6038	if test "$deplibs_check_method" != pass_all; then
6039	# We're trying link a shared library against a static one
6040	# but the system doesn't support it.
6041
6042	# Just print a warning and add the library to dependency_libs so
6043	# that the program can be linked against the static library.
6044	echo
6045	$ECHO "*** Warning: This system can not link to static lib archive $lib."
6046	echo "*** I have the capability to make that library automatically link in when"
6047	echo "*** you link to this library. But I can only do this if you have a"
6048	echo "*** shared version of the library, which you do not appear to have."
6049	if test "$module" = yes; then
6050	echo "*** But as you try to build a module library, libtool will still create "
6051	echo "*** a static module, that should work as long as the dlopening application"
6052	echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6053	if test -z "$global_symbol_pipe"; then
6054	echo
6055	echo "*** However, this would only work if libtool was able to extract symbol"
6056	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6057	echo "*** not find such a program. So, this module is probably useless."
6058	echo "*** \`nm' from GNU binutils and a full rebuild may help."
6059	fi
6060	if test "$build_old_libs" = no; then
6061	build_libtool_libs=module
6062	build_old_libs=yes
6063	else
6064	build_libtool_libs=no
6065	fi
6066	fi
6067	else
6068	deplibs="$dir/$old_library $deplibs"
6069	link_static=yes
6070	fi
6071	fi # link shared/static library?
6072
6073	if test "$linkmode" = lib; then
6074	if test -n "$dependency_libs" &&
6075	{ test "$hardcode_into_libs" != yes \|\|
6076	test "$build_old_libs" = yes \|\|
6077	test "$link_static" = yes; }; then
6078	# Extract -R from dependency_libs
6079	temp_deplibs=
6080	for libdir in $dependency_libs; do
6081	case $libdir in
6082	-R*) func_stripname '-R' '' "$libdir"
6083	temp_xrpath=$func_stripname_result
6084	case " $xrpath " in
6085	" $temp_xrpath ") ;;
6086	*) xrpath="$xrpath $temp_xrpath";;
6087	esac;;
6088	*) temp_deplibs="$temp_deplibs $libdir";;
6089	esac
6090	done
6091	dependency_libs="$temp_deplibs"
6092	fi
6093
6094	newlib_search_path="$newlib_search_path $absdir"
6095	# Link against this library
6096	test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6097	# ... and its dependency_libs
6098	tmp_libs=
6099	for deplib in $dependency_libs; do
6100	newdependency_libs="$deplib $newdependency_libs"
6101	if $opt_duplicate_deps ; then
6102	case "$tmp_libs " in
6103	" $deplib ") specialdeplibs="$specialdeplibs $deplib" ;;
6104	esac
6105	fi
6106	tmp_libs="$tmp_libs $deplib"
6107	done
6108
6109	if test "$link_all_deplibs" != no; then
6110	# Add the search paths of all dependency libraries
6111	for deplib in $dependency_libs; do
6112	path=
6113	case $deplib in
6114	-L*) path="$deplib" ;;
6115	*.la)
6116	func_dirname "$deplib" "" "."
6117	dir="$func_dirname_result"
6118	# We need an absolute path.
6119	case $dir in
6120	[\\/]* \| [A-Za-z]:[\\/]*) absdir="$dir" ;;
6121	*)
6122	absdir=`cd "$dir" && pwd`
6123	if test -z "$absdir"; then
6124	func_warning "cannot determine absolute directory name of \`$dir'"
6125	absdir="$dir"
6126	fi
6127	;;
6128	esac
6129	if $GREP "^installed=no" $deplib > /dev/null; then
6130	case $host in
6131	--darwin*)
6132	depdepl=
6133	deplibrary_names=`${SED} -n -e 's/^library_names=$.*$$/\1/p' $deplib`
6134	if test -n "$deplibrary_names" ; then
6135	for tmp in $deplibrary_names ; do
6136	depdepl=$tmp
6137	done
6138	if test -f "$absdir/$objdir/$depdepl" ; then
6139	depdepl="$absdir/$objdir/$depdepl"
6140	darwin_install_name=`${OTOOL} -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
6141	if test -z "$darwin_install_name"; then
6142	darwin_install_name=`${OTOOL64} -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
6143	fi
6144	compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6145	linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6146	path=
6147	fi
6148	fi
6149	;;
6150	*)
6151	path="-L$absdir/$objdir"
6152	;;
6153	esac
6154	else
6155	libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`
6156	test -z "$libdir" && \
6157	func_fatal_error "\`$deplib' is not a valid libtool archive"
6158	test "$absdir" != "$libdir" && \
6159	func_warning "\`$deplib' seems to be moved"
6160
6161	path="-L$absdir"
6162	fi
6163	;;
6164	esac
6165	case " $deplibs " in
6166	" $path ") ;;
6167	*) deplibs="$path $deplibs" ;;
6168	esac
6169	done
6170	fi # link_all_deplibs != no
6171	fi # linkmode = lib
6172	done # for deplib in $libs
6173	if test "$pass" = link; then
6174	if test "$linkmode" = "prog"; then
6175	compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6176	finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6177	else
6178	compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
6179	fi
6180	fi
6181	dependency_libs="$newdependency_libs"
6182	if test "$pass" = dlpreopen; then
6183	# Link the dlpreopened libraries before other libraries
6184	for deplib in $save_deplibs; do
6185	deplibs="$deplib $deplibs"
6186	done
6187	fi
6188	if test "$pass" != dlopen; then
6189	if test "$pass" != conv; then
6190	# Make sure lib_search_path contains only unique directories.
6191	lib_search_path=
6192	for dir in $newlib_search_path; do
6193	case "$lib_search_path " in
6194	" $dir ") ;;
6195	*) lib_search_path="$lib_search_path $dir" ;;
6196	esac
6197	done
6198	newlib_search_path=
6199	fi
6200
6201	if test "$linkmode,$pass" != "prog,link"; then
6202	vars="deplibs"
6203	else
6204	vars="compile_deplibs finalize_deplibs"
6205	fi
6206	for var in $vars dependency_libs; do
6207	# Add libraries to $var in reverse order
6208	eval tmp_libs=\$$var
6209	new_libs=
6210	for deplib in $tmp_libs; do
6211	# FIXME: Pedantically, this is the right thing to do, so
6212	# that some nasty dependency loop isn't accidentally
6213	# broken:
6214	#new_libs="$deplib $new_libs"
6215	# Pragmatically, this seems to cause very few problems in
6216	# practice:
6217	case $deplib in
6218	-L*) new_libs="$deplib $new_libs" ;;
6219	-R*) ;;
6220	*)
6221	# And here is the reason: when a library appears more
6222	# than once as an explicit dependence of a library, or
6223	# is implicitly linked in more than once by the
6224	# compiler, it is considered special, and multiple
6225	# occurrences thereof are not removed. Compare this
6226	# with having the same library being listed as a
6227	# dependency of multiple other libraries: in this case,
6228	# we know (pedantically, we assume) the library does not
6229	# need to be listed more than once, so we keep only the
6230	# last copy. This is not always right, but it is rare
6231	# enough that we require users that really mean to play
6232	# such unportable linking tricks to link the library
6233	# using -Wl,-lname, so that libtool does not consider it
6234	# for duplicate removal.
6235	case " $specialdeplibs " in
6236	" $deplib ") new_libs="$deplib $new_libs" ;;
6237	*)
6238	case " $new_libs " in
6239	" $deplib ") ;;
6240	*) new_libs="$deplib $new_libs" ;;
6241	esac
6242	;;
6243	esac
6244	;;
6245	esac
6246	done
6247	tmp_libs=
6248	for deplib in $new_libs; do
6249	case $deplib in
6250	-L*)
6251	case " $tmp_libs " in
6252	" $deplib ") ;;
6253	*) tmp_libs="$tmp_libs $deplib" ;;
6254	esac
6255	;;
6256	*) tmp_libs="$tmp_libs $deplib" ;;
6257	esac
6258	done
6259	eval $var=\$tmp_libs
6260	done # for var
6261	fi
6262	# Last step: remove runtime libs from dependency_libs
6263	# (they stay in deplibs)
6264	tmp_libs=
6265	for i in $dependency_libs ; do
6266	case " $predeps $postdeps $compiler_lib_search_path " in
6267	" $i ")
6268	i=""
6269	;;
6270	esac
6271	if test -n "$i" ; then
6272	tmp_libs="$tmp_libs $i"
6273	fi
6274	done
6275	dependency_libs=$tmp_libs
6276	done # for pass
6277	if test "$linkmode" = prog; then
6278	dlfiles="$newdlfiles"
6279	fi
6280	if test "$linkmode" = prog \|\| test "$linkmode" = lib; then
6281	dlprefiles="$newdlprefiles"
6282	fi
6283
6284	case $linkmode in
6285	oldlib)
6286	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
6287	func_warning "\`-dlopen' is ignored for archives"
6288	fi
6289
6290	case " $deplibs" in
6291	\ -l \| \ -L)
6292	func_warning "\`-l' and \`-L' are ignored for archives" ;;
6293	esac
6294
6295	test -n "$rpath" && \
6296	func_warning "\`-rpath' is ignored for archives"
6297
6298	test -n "$xrpath" && \
6299	func_warning "\`-R' is ignored for archives"
6300
6301	test -n "$vinfo" && \
6302	func_warning "\`-version-info/-version-number' is ignored for archives"
6303
6304	test -n "$release" && \
6305	func_warning "\`-release' is ignored for archives"
6306
6307	test -n "$export_symbols$export_symbols_regex" && \
6308	func_warning "\`-export-symbols' is ignored for archives"
6309
6310	# Now set the variables for building old libraries.
6311	build_libtool_libs=no
6312	oldlibs="$output"
6313	objs="$objs$old_deplibs"
6314	;;
6315
6316	lib)
6317	# Make sure we only generate libraries of the form `libNAME.la'.
6318	case $outputname in
6319	lib*)
6320	func_stripname 'lib' '.la' "$outputname"
6321	name=$func_stripname_result
6322	eval "shared_ext=\"$shrext_cmds\""
6323	eval "libname=\"$libname_spec\""
6324	;;
6325	*)
6326	test "$module" = no && \
6327	func_fatal_help "libtool library \`$output' must begin with \`lib'"
6328
6329	if test "$need_lib_prefix" != no; then
6330	# Add the "lib" prefix for modules if required
6331	func_stripname '' '.la' "$outputname"
6332	name=$func_stripname_result
6333	eval "shared_ext=\"$shrext_cmds\""
6334	eval "libname=\"$libname_spec\""
6335	else
6336	func_stripname '' '.la' "$outputname"
6337	libname=$func_stripname_result
6338	fi
6339	;;
6340	esac
6341
6342	if test -n "$objs"; then
6343	if test "$deplibs_check_method" != pass_all; then
6344	func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6345	else
6346	echo
6347	$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6348	$ECHO "*** objects $objs is not portable!"
6349	libobjs="$libobjs $objs"
6350	fi
6351	fi
6352
6353	test "$dlself" != no && \
6354	func_warning "\`-dlopen self' is ignored for libtool libraries"
6355
6356	set dummy $rpath
6357	shift
6358	test "$#" -gt 1 && \
6359	func_warning "ignoring multiple \`-rpath's for a libtool library"
6360
6361	install_libdir="$1"
6362
6363	oldlibs=
6364	if test -z "$rpath"; then
6365	if test "$build_libtool_libs" = yes; then
6366	# Building a libtool convenience library.
6367	# Some compilers have problems with a `.al' extension so
6368	# convenience libraries should have the same extension an
6369	# archive normally would.
6370	oldlibs="$output_objdir/$libname.$libext $oldlibs"
6371	build_libtool_libs=convenience
6372	build_old_libs=yes
6373	fi
6374
6375	test -n "$vinfo" && \
6376	func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6377
6378	test -n "$release" && \
6379	func_warning "\`-release' is ignored for convenience libraries"
6380	else
6381
6382	# Parse the version information argument.
6383	save_ifs="$IFS"; IFS=':'
6384	set dummy $vinfo 0 0 0
6385	shift
6386	IFS="$save_ifs"
6387
6388	test -n "$7" && \
6389	func_fatal_help "too many parameters to \`-version-info'"
6390
6391	# convert absolute version numbers to libtool ages
6392	# this retains compatibility with .la files and attempts
6393	# to make the code below a bit more comprehensible
6394
6395	case $vinfo_number in
6396	yes)
6397	number_major="$1"
6398	number_minor="$2"
6399	number_revision="$3"
6400	#
6401	# There are really only two kinds -- those that
6402	# use the current revision as the major version
6403	# and those that subtract age and use age as
6404	# a minor version. But, then there is irix
6405	# which has an extra 1 added just for fun
6406	#
6407	case $version_type in
6408	darwin\|linux\|osf\|windows\|none)
6409	func_arith $number_major + $number_minor
6410	current=$func_arith_result
6411	age="$number_minor"
6412	revision="$number_revision"
6413	;;
6414	freebsd-aout\|freebsd-elf\|qnx\|sunos)
6415	current="$number_major"
6416	revision="$number_minor"
6417	age="0"
6418	;;
6419	irix\|nonstopux)
6420	func_arith $number_major + $number_minor
6421	current=$func_arith_result
6422	age="$number_minor"
6423	revision="$number_minor"
6424	lt_irix_increment=no
6425	;;
6426	esac
6427	;;
6428	no)
6429	current="$1"
6430	revision="$2"
6431	age="$3"
6432	;;
6433	esac
6434
6435	# Check that each of the things are valid numbers.
6436	case $current in
6437	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]) ;;
6438	*)
6439	func_error "CURRENT \`$current' must be a nonnegative integer"
6440	func_fatal_error "\`$vinfo' is not valid version information"
6441	;;
6442	esac
6443
6444	case $revision in
6445	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]) ;;
6446	*)
6447	func_error "REVISION \`$revision' must be a nonnegative integer"
6448	func_fatal_error "\`$vinfo' is not valid version information"
6449	;;
6450	esac
6451
6452	case $age in
6453	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]) ;;
6454	*)
6455	func_error "AGE \`$age' must be a nonnegative integer"
6456	func_fatal_error "\`$vinfo' is not valid version information"
6457	;;
6458	esac
6459
6460	if test "$age" -gt "$current"; then
6461	func_error "AGE \`$age' is greater than the current interface number \`$current'"
6462	func_fatal_error "\`$vinfo' is not valid version information"
6463	fi
6464
6465	# Calculate the version variables.
6466	major=
6467	versuffix=
6468	verstring=
6469	case $version_type in
6470	none) ;;
6471
6472	darwin)
6473	# Like Linux, but with the current version available in
6474	# verstring for coding it into the library header
6475	func_arith $current - $age
6476	major=.$func_arith_result
6477	versuffix="$major.$age.$revision"
6478	# Darwin ld doesn't like 0 for these options...
6479	func_arith $current + 1
6480	minor_current=$func_arith_result
6481	xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6482	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6483	;;
6484
6485	freebsd-aout)
6486	major=".$current"
6487	versuffix=".$current.$revision";
6488	;;
6489
6490	freebsd-elf)
6491	major=".$current"
6492	versuffix=".$current"
6493	;;
6494
6495	irix \| nonstopux)
6496	if test "X$lt_irix_increment" = "Xno"; then
6497	func_arith $current - $age
6498	else
6499	func_arith $current - $age + 1
6500	fi
6501	major=$func_arith_result
6502
6503	case $version_type in
6504	nonstopux) verstring_prefix=nonstopux ;;
6505	*) verstring_prefix=sgi ;;
6506	esac
6507	verstring="$verstring_prefix$major.$revision"
6508
6509	# Add in all the interfaces that we are compatible with.
6510	loop=$revision
6511	while test "$loop" -ne 0; do
6512	func_arith $revision - $loop
6513	iface=$func_arith_result
6514	func_arith $loop - 1
6515	loop=$func_arith_result
6516	verstring="$verstring_prefix$major.$iface:$verstring"
6517	done
6518
6519	# Before this point, $major must not contain `.'.
6520	major=.$major
6521	versuffix="$major.$revision"
6522	;;
6523
6524	linux)
6525	func_arith $current - $age
6526	major=.$func_arith_result
6527	versuffix="$major.$age.$revision"
6528	;;
6529
6530	osf)
6531	func_arith $current - $age
6532	major=.$func_arith_result
6533	versuffix=".$current.$age.$revision"
6534	verstring="$current.$age.$revision"
6535
6536	# Add in all the interfaces that we are compatible with.
6537	loop=$age
6538	while test "$loop" -ne 0; do
6539	func_arith $current - $loop
6540	iface=$func_arith_result
6541	func_arith $loop - 1
6542	loop=$func_arith_result
6543	verstring="$verstring:${iface}.0"
6544	done
6545
6546	# Make executables depend on our current version.
6547	verstring="$verstring:${current}.0"
6548	;;
6549
6550	qnx)
6551	major=".$current"
6552	versuffix=".$current"
6553	;;
6554
6555	sunos)
6556	major=".$current"
6557	versuffix=".$current.$revision"
6558	;;
6559
6560	windows)
6561	# Use '-' rather than '.', since we only want one
6562	# extension on DOS 8.3 filesystems.
6563	func_arith $current - $age
6564	major=$func_arith_result
6565	versuffix="-$major"
6566	;;
6567
6568	*)
6569	func_fatal_configuration "unknown library version type \`$version_type'"
6570	;;
6571	esac
6572
6573	# Clear the version info if we defaulted, and they specified a release.
6574	if test -z "$vinfo" && test -n "$release"; then
6575	major=
6576	case $version_type in
6577	darwin)
6578	# we can't check for "0.0" in archive_cmds due to quoting
6579	# problems, so we reset it completely
6580	verstring=
6581	;;
6582	*)
6583	verstring="0.0"
6584	;;
6585	esac
6586	if test "$need_version" = no; then
6587	versuffix=
6588	else
6589	versuffix=".0.0"
6590	fi
6591	fi
6592
6593	# Remove version info from name if versioning should be avoided
6594	if test "$avoid_version" = yes && test "$need_version" = no; then
6595	major=
6596	versuffix=
6597	verstring=""
6598	fi
6599
6600	# Check to see if the archive will have undefined symbols.
6601	if test "$allow_undefined" = yes; then
6602	if test "$allow_undefined_flag" = unsupported; then
6603	func_warning "undefined symbols not allowed in $host shared libraries"
6604	build_libtool_libs=no
6605	build_old_libs=yes
6606	fi
6607	else
6608	# Don't allow undefined symbols.
6609	allow_undefined_flag="$no_undefined_flag"
6610	fi
6611
6612	fi
6613
6614	func_generate_dlsyms "$libname" "$libname" "yes"
6615	libobjs="$libobjs $symfileobj"
6616	test "X$libobjs" = "X " && libobjs=
6617
6618	if test "$mode" != relink; then
6619	# Remove our outputs, but don't remove object files since they
6620	# may have been created when compiling PIC objects.
6621	removelist=
6622	tempremovelist=`$ECHO "$output_objdir/*"`
6623	for p in $tempremovelist; do
6624	case $p in
6625	.$objext \| .gcno)
6626	;;
6627	$output_objdir/$outputname \| $output_objdir/$libname.* \| $output_objdir/${libname}${release}.*)
6628	if test "X$precious_files_regex" != "X"; then
6629	if $ECHO "$p" \| $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6630	then
6631	continue
6632	fi
6633	fi
6634	removelist="$removelist $p"
6635	;;
6636	*) ;;
6637	esac
6638	done
6639	test -n "$removelist" && \
6640	func_show_eval "${RM}r \$removelist"
6641	fi
6642
6643	# Now set the variables for building old libraries.
6644	if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6645	oldlibs="$oldlibs $output_objdir/$libname.$libext"
6646
6647	# Transform .lo files to .o files.
6648	oldobjs="$objs "`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.${libext}$/d; $lo2o" \| $NL2SP`
6649	fi
6650
6651	# Eliminate all temporary directories.
6652	#for path in $notinst_path; do
6653	# lib_search_path=`$ECHO "$lib_search_path " \| $SED "s% $path % %g"`
6654	# deplibs=`$ECHO "$deplibs " \| $SED "s% -L$path % %g"`
6655	# dependency_libs=`$ECHO "$dependency_libs " \| $SED "s% -L$path % %g"`
6656	#done
6657
6658	if test -n "$xrpath"; then
6659	# If the user specified any rpath flags, then add them.
6660	temp_xrpath=
6661	for libdir in $xrpath; do
6662	temp_xrpath="$temp_xrpath -R$libdir"
6663	case "$finalize_rpath " in
6664	" $libdir ") ;;
6665	*) finalize_rpath="$finalize_rpath $libdir" ;;
6666	esac
6667	done
6668	if test "$hardcode_into_libs" != yes \|\| test "$build_old_libs" = yes; then
6669	dependency_libs="$temp_xrpath $dependency_libs"
6670	fi
6671	fi
6672
6673	# Make sure dlfiles contains only unique files that won't be dlpreopened
6674	old_dlfiles="$dlfiles"
6675	dlfiles=
6676	for lib in $old_dlfiles; do
6677	case " $dlprefiles $dlfiles " in
6678	" $lib ") ;;
6679	*) dlfiles="$dlfiles $lib" ;;
6680	esac
6681	done
6682
6683	# Make sure dlprefiles contains only unique files
6684	old_dlprefiles="$dlprefiles"
6685	dlprefiles=
6686	for lib in $old_dlprefiles; do
6687	case "$dlprefiles " in
6688	" $lib ") ;;
6689	*) dlprefiles="$dlprefiles $lib" ;;
6690	esac
6691	done
6692
6693	if test "$build_libtool_libs" = yes; then
6694	if test -n "$rpath"; then
6695	case $host in
6696	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --beos* \| -cegcc \| --haiku*)
6697	# these systems don't actually have a c library (as such)!
6698	;;
6699	--rhapsody* \| --darwin1.[012])
6700	# Rhapsody C library is in the System framework
6701	deplibs="$deplibs System.ltframework"
6702	;;
6703	--netbsd*)
6704	# Don't link with libc until the a.out ld.so is fixed.
6705	;;
6706	--openbsd* \| --freebsd* \| --dragonfly*)
6707	# Do not include libc due to us having libc/libc_r.
6708	;;
6709	--sco3.2v5* \| --sco5v6*)
6710	# Causes problems with __ctype
6711	;;
6712	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
6713	# Compiler inserts libc in the correct place for threads to work
6714	;;
6715	*)
6716	# Add libc to deplibs on all other systems if necessary.
6717	if test "$build_libtool_need_lc" = "yes"; then
6718	deplibs="$deplibs -lc"
6719	fi
6720	;;
6721	esac
6722	fi
6723
6724	# Transform deplibs into only deplibs that can be linked in shared.
6725	name_save=$name
6726	libname_save=$libname
6727	release_save=$release
6728	versuffix_save=$versuffix
6729	major_save=$major
6730	# I'm not sure if I'm treating the release correctly. I think
6731	# release should show up in the -l (ie -lgmp5) so we don't want to
6732	# add it in twice. Is that correct?
6733	release=""
6734	versuffix=""
6735	major=""
6736	newdeplibs=
6737	droppeddeps=no
6738	case $deplibs_check_method in
6739	pass_all)
6740	# Don't check for shared/static. Everything works.
6741	# This might be a little naive. We might want to check
6742	# whether the library exists or not. But this is on
6743	# osf3 & osf4 and I'm not really sure... Just
6744	# implementing what was already the behavior.
6745	newdeplibs=$deplibs
6746	;;
6747	test_compile)
6748	# This code stresses the "libraries are programs" paradigm to its
6749	# limits. Maybe even breaks it. We compile a program, linking it
6750	# against the deplibs as a proxy for the library. Then we can check
6751	# whether they linked in statically or dynamically with ldd.
6752	$opt_dry_run \|\| $RM conftest.c
6753	cat > conftest.c <<EOF
6754	int main() { return 0; }
6755	EOF
6756	$opt_dry_run \|\| $RM conftest
6757	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6758	ldd_output=`ldd conftest`
6759	for i in $deplibs; do
6760	case $i in
6761	-l*)
6762	func_stripname -l '' "$i"
6763	name=$func_stripname_result
6764	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6765	case " $predeps $postdeps " in
6766	" $i ")
6767	newdeplibs="$newdeplibs $i"
6768	i=""
6769	;;
6770	esac
6771	fi
6772	if test -n "$i" ; then
6773	eval "libname=\"$libname_spec\""
6774	eval "deplib_matches=\"$library_names_spec\""
6775	set dummy $deplib_matches; shift
6776	deplib_match=$1
6777	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6778	newdeplibs="$newdeplibs $i"
6779	else
6780	droppeddeps=yes
6781	echo
6782	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6783	echo "*** I have the capability to make that library automatically link in when"
6784	echo "*** you link to this library. But I can only do this if you have a"
6785	echo "*** shared version of the library, which I believe you do not have"
6786	echo "*** because a test_compile did reveal that the linker did not use it for"
6787	echo "*** its dynamic dependency list that programs get resolved with at runtime."
6788	fi
6789	fi
6790	;;
6791	*)
6792	newdeplibs="$newdeplibs $i"
6793	;;
6794	esac
6795	done
6796	else
6797	# Error occurred in the first compile. Let's try to salvage
6798	# the situation: Compile a separate program for each library.
6799	for i in $deplibs; do
6800	case $i in
6801	-l*)
6802	func_stripname -l '' "$i"
6803	name=$func_stripname_result
6804	$opt_dry_run \|\| $RM conftest
6805	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6806	ldd_output=`ldd conftest`
6807	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6808	case " $predeps $postdeps " in
6809	" $i ")
6810	newdeplibs="$newdeplibs $i"
6811	i=""
6812	;;
6813	esac
6814	fi
6815	if test -n "$i" ; then
6816	eval "libname=\"$libname_spec\""
6817	eval "deplib_matches=\"$library_names_spec\""
6818	set dummy $deplib_matches; shift
6819	deplib_match=$1
6820	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6821	newdeplibs="$newdeplibs $i"
6822	else
6823	droppeddeps=yes
6824	echo
6825	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6826	echo "*** I have the capability to make that library automatically link in when"
6827	echo "*** you link to this library. But I can only do this if you have a"
6828	echo "*** shared version of the library, which you do not appear to have"
6829	echo "*** because a test_compile did reveal that the linker did not use this one"
6830	echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6831	fi
6832	fi
6833	else
6834	droppeddeps=yes
6835	echo
6836	$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6837	echo "*** make it link in! You will probably need to install it or some"
6838	echo "*** library that it depends on before this library will be fully"
6839	echo "*** functional. Installing it before continuing would be even better."
6840	fi
6841	;;
6842	*)
6843	newdeplibs="$newdeplibs $i"
6844	;;
6845	esac
6846	done
6847	fi
6848	;;
6849	file_magic*)
6850	set dummy $deplibs_check_method; shift
6851	file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
6852	for a_deplib in $deplibs; do
6853	case $a_deplib in
6854	-l*)
6855	func_stripname -l '' "$a_deplib"
6856	name=$func_stripname_result
6857	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6858	case " $predeps $postdeps " in
6859	" $a_deplib ")
6860	newdeplibs="$newdeplibs $a_deplib"
6861	a_deplib=""
6862	;;
6863	esac
6864	fi
6865	if test -n "$a_deplib" ; then
6866	eval "libname=\"$libname_spec\""
6867	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6868	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6869	for potent_lib in $potential_libs; do
6870	# Follow soft links.
6871	if ls -lLd "$potent_lib" 2>/dev/null \|
6872	$GREP " -> " >/dev/null; then
6873	continue
6874	fi
6875	# The statement above tries to avoid entering an
6876	# endless loop below, in case of cyclic links.
6877	# We might still enter an endless loop, since a link
6878	# loop can be closed while we follow links,
6879	# but so what?
6880	potlib="$potent_lib"
6881	while test -h "$potlib" 2>/dev/null; do
6882	potliblink=`ls -ld $potlib \| ${SED} 's/.* -> //'`
6883	case $potliblink in
6884	[\\/]* \| [A-Za-z]:[\\/]*) potlib="$potliblink";;
6885	) potlib=`$ECHO "$potlib" \| $SED 's,[^/]$,,'`"$potliblink";;
6886	esac
6887	done
6888	if eval "$file_magic_cmd \"\$potlib\"" 2>/dev/null \|
6889	$SED -e 10q \|
6890	$EGREP "$file_magic_regex" > /dev/null; then
6891	newdeplibs="$newdeplibs $a_deplib"
6892	a_deplib=""
6893	break 2
6894	fi
6895	done
6896	done
6897	fi
6898	if test -n "$a_deplib" ; then
6899	droppeddeps=yes
6900	echo
6901	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6902	echo "*** I have the capability to make that library automatically link in when"
6903	echo "*** you link to this library. But I can only do this if you have a"
6904	echo "*** shared version of the library, which you do not appear to have"
6905	echo "*** because I did check the linker path looking for a file starting"
6906	if test -z "$potlib" ; then
6907	$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6908	else
6909	$ECHO "*** with $libname and none of the candidates passed a file format test"
6910	$ECHO "*** using a file magic. Last file checked: $potlib"
6911	fi
6912	fi
6913	;;
6914	*)
6915	# Add a -L argument.
6916	newdeplibs="$newdeplibs $a_deplib"
6917	;;
6918	esac
6919	done # Gone through all deplibs.
6920	;;
6921	match_pattern*)
6922	set dummy $deplibs_check_method; shift
6923	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
6924	for a_deplib in $deplibs; do
6925	case $a_deplib in
6926	-l*)
6927	func_stripname -l '' "$a_deplib"
6928	name=$func_stripname_result
6929	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6930	case " $predeps $postdeps " in
6931	" $a_deplib ")
6932	newdeplibs="$newdeplibs $a_deplib"
6933	a_deplib=""
6934	;;
6935	esac
6936	fi
6937	if test -n "$a_deplib" ; then
6938	eval "libname=\"$libname_spec\""
6939	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6940	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6941	for potent_lib in $potential_libs; do
6942	potlib="$potent_lib" # see symlink-check above in file_magic test
6943	if eval "\$ECHO \"$potent_lib\"" 2>/dev/null \| $SED 10q \| \
6944	$EGREP "$match_pattern_regex" > /dev/null; then
6945	newdeplibs="$newdeplibs $a_deplib"
6946	a_deplib=""
6947	break 2
6948	fi
6949	done
6950	done
6951	fi
6952	if test -n "$a_deplib" ; then
6953	droppeddeps=yes
6954	echo
6955	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6956	echo "*** I have the capability to make that library automatically link in when"
6957	echo "*** you link to this library. But I can only do this if you have a"
6958	echo "*** shared version of the library, which you do not appear to have"
6959	echo "*** because I did check the linker path looking for a file starting"
6960	if test -z "$potlib" ; then
6961	$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6962	else
6963	$ECHO "*** with $libname and none of the candidates passed a file format test"
6964	$ECHO "*** using a regex pattern. Last file checked: $potlib"
6965	fi
6966	fi
6967	;;
6968	*)
6969	# Add a -L argument.
6970	newdeplibs="$newdeplibs $a_deplib"
6971	;;
6972	esac
6973	done # Gone through all deplibs.
6974	;;
6975	none \| unknown \| *)
6976	newdeplibs=""
6977	tmp_deplibs=`$ECHO " $deplibs" \| $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6978	if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6979	for i in $predeps $postdeps ; do
6980	# can't use Xsed below, because $i might contain '/'
6981	tmp_deplibs=`$ECHO " $tmp_deplibs" \| $SED "s,$i,,"`
6982	done
6983	fi
6984	case $tmp_deplibs in
6985	[!\ \ ])
6986	echo
6987	if test "X$deplibs_check_method" = "Xnone"; then
6988	echo "*** Warning: inter-library dependencies are not supported in this platform."
6989	else
6990	echo "*** Warning: inter-library dependencies are not known to be supported."
6991	fi
6992	echo "*** All declared inter-library dependencies are being dropped."
6993	droppeddeps=yes
6994	;;
6995	esac
6996	;;
6997	esac
6998	versuffix=$versuffix_save
6999	major=$major_save
7000	release=$release_save
7001	libname=$libname_save
7002	name=$name_save
7003
7004	case $host in
7005	--rhapsody* \| --darwin1.[012])
7006	# On Rhapsody replace the C library with the System framework
7007	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's/ -lc / System.ltframework /'`
7008	;;
7009	esac
7010
7011	if test "$droppeddeps" = yes; then
7012	if test "$module" = yes; then
7013	echo
7014	echo "*** Warning: libtool could not satisfy all declared inter-library"
7015	$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7016	echo "*** a static module, that should work as long as the dlopening"
7017	echo "*** application is linked with the -dlopen flag."
7018	if test -z "$global_symbol_pipe"; then
7019	echo
7020	echo "*** However, this would only work if libtool was able to extract symbol"
7021	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7022	echo "*** not find such a program. So, this module is probably useless."
7023	echo "*** \`nm' from GNU binutils and a full rebuild may help."
7024	fi
7025	if test "$build_old_libs" = no; then
7026	oldlibs="$output_objdir/$libname.$libext"
7027	build_libtool_libs=module
7028	build_old_libs=yes
7029	else
7030	build_libtool_libs=no
7031	fi
7032	else
7033	echo "*** The inter-library dependencies that have been dropped here will be"
7034	echo "*** automatically added whenever a program is linked with this library"
7035	echo "*** or is declared to -dlopen it."
7036
7037	if test "$allow_undefined" = no; then
7038	echo
7039	echo "*** Since this library must not contain undefined symbols,"
7040	echo "*** because either the platform does not support them or"
7041	echo "*** it was explicitly requested with -no-undefined,"
7042	echo "*** libtool will only create a static version of it."
7043	if test "$build_old_libs" = no; then
7044	oldlibs="$output_objdir/$libname.$libext"
7045	build_libtool_libs=module
7046	build_old_libs=yes
7047	else
7048	build_libtool_libs=no
7049	fi
7050	fi
7051	fi
7052	fi
7053	# Done checking deplibs!
7054	deplibs=$newdeplibs
7055	fi
7056	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7057	case $host in
7058	--darwin*)
7059	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7060	new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7061	deplibs=`$ECHO " $deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7062	;;
7063	esac
7064
7065	# move library search paths that coincide with paths to not yet
7066	# installed libraries to the beginning of the library search list
7067	new_libs=
7068	for path in $notinst_path; do
7069	case " $new_libs " in
7070	" -L$path/$objdir ") ;;
7071	*)
7072	case " $deplibs " in
7073	" -L$path/$objdir ")
7074	new_libs="$new_libs -L$path/$objdir" ;;
7075	esac
7076	;;
7077	esac
7078	done
7079	for deplib in $deplibs; do
7080	case $deplib in
7081	-L*)
7082	case " $new_libs " in
7083	" $deplib ") ;;
7084	*) new_libs="$new_libs $deplib" ;;
7085	esac
7086	;;
7087	*) new_libs="$new_libs $deplib" ;;
7088	esac
7089	done
7090	deplibs="$new_libs"
7091
7092	# All the library-specific variables (install_libdir is set above).
7093	library_names=
7094	old_library=
7095	dlname=
7096
7097	# Test again, we may have decided not to build it any more
7098	if test "$build_libtool_libs" = yes; then
7099	if test "$hardcode_into_libs" = yes; then
7100	# Hardcode the library paths
7101	hardcode_libdirs=
7102	dep_rpath=
7103	rpath="$finalize_rpath"
7104	test "$mode" != relink && rpath="$compile_rpath$rpath"
7105	for libdir in $rpath; do
7106	if test -n "$hardcode_libdir_flag_spec"; then
7107	if test -n "$hardcode_libdir_separator"; then
7108	if test -z "$hardcode_libdirs"; then
7109	hardcode_libdirs="$libdir"
7110	else
7111	# Just accumulate the unique libdirs.
7112	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7113	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
7114	;;
7115	*)
7116	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7117	;;
7118	esac
7119	fi
7120	else
7121	eval "flag=\"$hardcode_libdir_flag_spec\""
7122	dep_rpath="$dep_rpath $flag"
7123	fi
7124	elif test -n "$runpath_var"; then
7125	case "$perm_rpath " in
7126	" $libdir ") ;;
7127	*) perm_rpath="$perm_rpath $libdir" ;;
7128	esac
7129	fi
7130	done
7131	# Substitute the hardcoded libdirs into the rpath.
7132	if test -n "$hardcode_libdir_separator" &&
7133	test -n "$hardcode_libdirs"; then
7134	libdir="$hardcode_libdirs"
7135	if test -n "$hardcode_libdir_flag_spec_ld"; then
7136	eval "dep_rpath=\"$hardcode_libdir_flag_spec_ld\""
7137	else
7138	eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
7139	fi
7140	fi
7141	if test -n "$runpath_var" && test -n "$perm_rpath"; then
7142	# We should set the runpath_var.
7143	rpath=
7144	for dir in $perm_rpath; do
7145	rpath="$rpath$dir:"
7146	done
7147	eval $runpath_var=\$rpath\$$runpath_var
7148	export $runpath_var
7149	fi
7150	test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7151	fi
7152
7153	shlibpath="$finalize_shlibpath"
7154	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7155	if test -n "$shlibpath"; then
7156	eval $shlibpath_var=\$shlibpath\$$shlibpath_var
7157	export $shlibpath_var
7158	fi
7159
7160	# Get the real and link names of the library.
7161	eval "shared_ext=\"$shrext_cmds\""
7162	eval "library_names=\"$library_names_spec\""
7163	set dummy $library_names
7164	shift
7165	realname="$1"
7166	shift
7167
7168	if test -n "$soname_spec"; then
7169	eval "soname=\"$soname_spec\""
7170	else
7171	soname="$realname"
7172	fi
7173	if test -z "$dlname"; then
7174	dlname=$soname
7175	fi
7176
7177	lib="$output_objdir/$realname"
7178	linknames=
7179	for link
7180	do
7181	linknames="$linknames $link"
7182	done
7183
7184	# Use standard objects if they are pic
7185	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
7186	test "X$libobjs" = "X " && libobjs=
7187
7188	delfiles=
7189	if test -n "$export_symbols" && test -n "$include_expsyms"; then
7190	$opt_dry_run \|\| cp "$export_symbols" "$output_objdir/$libname.uexp"
7191	export_symbols="$output_objdir/$libname.uexp"
7192	delfiles="$delfiles $export_symbols"
7193	fi
7194
7195	orig_export_symbols=
7196	case $host_os in
7197	cygwin* \| mingw* \| cegcc*)
7198	if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7199	# exporting using user supplied symfile
7200	if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7201	# and it's NOT already a .def file. Must figure out
7202	# which of the given symbols are data symbols and tag
7203	# them as such. So, trigger use of export_symbols_cmds.
7204	# export_symbols gets reassigned inside the "prepare
7205	# the list of exported symbols" if statement, so the
7206	# include_expsyms logic still works.
7207	orig_export_symbols="$export_symbols"
7208	export_symbols=
7209	always_export_symbols=yes
7210	fi
7211	fi
7212	;;
7213	esac
7214
7215	# Prepare the list of exported symbols
7216	if test -z "$export_symbols"; then
7217	if test "$always_export_symbols" = yes \|\| test -n "$export_symbols_regex"; then
7218	func_verbose "generating symbol list for \`$libname.la'"
7219	export_symbols="$output_objdir/$libname.exp"
7220	$opt_dry_run \|\| $RM $export_symbols
7221	cmds=$export_symbols_cmds
7222	save_ifs="$IFS"; IFS='~'
7223	for cmd in $cmds; do
7224	IFS="$save_ifs"
7225	eval "cmd=\"$cmd\""
7226	func_len " $cmd"
7227	len=$func_len_result
7228	if test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
7229	func_show_eval "$cmd" 'exit $?'
7230	skipped_export=false
7231	else
7232	# The command line is too long to execute in one step.
7233	func_verbose "using reloadable object file for export list..."
7234	skipped_export=:
7235	# Break out early, otherwise skipped_export may be
7236	# set to false by a later but shorter cmd.
7237	break
7238	fi
7239	done
7240	IFS="$save_ifs"
7241	if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7242	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7243	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7244	fi
7245	fi
7246	fi
7247
7248	if test -n "$export_symbols" && test -n "$include_expsyms"; then
7249	tmp_export_symbols="$export_symbols"
7250	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7251	$opt_dry_run \|\| $ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"
7252	fi
7253
7254	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7255	# The given exports_symbols file has to be filtered, so filter it.
7256	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7257	# FIXME: $output_objdir/$libname.filter potentially contains lots of
7258	# 's' commands which not all seds can handle. GNU sed should be fine
7259	# though. Also, the filter scales superlinearly with the number of
7260	# global variables. join(1) would be nice here, but unfortunately
7261	# isn't a blessed tool.
7262	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
7263	delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7264	export_symbols=$output_objdir/$libname.def
7265	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7266	fi
7267
7268	tmp_deplibs=
7269	for test_deplib in $deplibs; do
7270	case " $convenience " in
7271	" $test_deplib ") ;;
7272	*)
7273	tmp_deplibs="$tmp_deplibs $test_deplib"
7274	;;
7275	esac
7276	done
7277	deplibs="$tmp_deplibs"
7278
7279	if test -n "$convenience"; then
7280	if test -n "$whole_archive_flag_spec" &&
7281	test "$compiler_needs_object" = yes &&
7282	test -z "$libobjs"; then
7283	# extract the archives, so we have objects to list.
7284	# TODO: could optimize this to just extract one archive.
7285	whole_archive_flag_spec=
7286	fi
7287	if test -n "$whole_archive_flag_spec"; then
7288	save_libobjs=$libobjs
7289	eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7290	test "X$libobjs" = "X " && libobjs=
7291	else
7292	gentop="$output_objdir/${outputname}x"
7293	generated="$generated $gentop"
7294
7295	func_extract_archives $gentop $convenience
7296	libobjs="$libobjs $func_extract_archives_result"
7297	test "X$libobjs" = "X " && libobjs=
7298	fi
7299	fi
7300
7301	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7302	eval "flag=\"$thread_safe_flag_spec\""
7303	linker_flags="$linker_flags $flag"
7304	fi
7305
7306	# Make a backup of the uninstalled library when relinking
7307	if test "$mode" = relink; then
7308	$opt_dry_run \|\| (cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U) \|\| exit $?
7309	fi
7310
7311	# Do each of the archive commands.
7312	if test "$module" = yes && test -n "$module_cmds" ; then
7313	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7314	eval "test_cmds=\"$module_expsym_cmds\""
7315	cmds=$module_expsym_cmds
7316	else
7317	eval "test_cmds=\"$module_cmds\""
7318	cmds=$module_cmds
7319	fi
7320	else
7321	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7322	eval "test_cmds=\"$archive_expsym_cmds\""
7323	cmds=$archive_expsym_cmds
7324	else
7325	eval "test_cmds=\"$archive_cmds\""
7326	cmds=$archive_cmds
7327	fi
7328	fi
7329
7330	if test "X$skipped_export" != "X:" &&
7331	func_len " $test_cmds" &&
7332	len=$func_len_result &&
7333	test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
7334	:
7335	else
7336	# The command line is too long to link in one step, link piecewise
7337	# or, if using GNU ld and skipped_export is not :, use a linker
7338	# script.
7339
7340	# Save the value of $output and $libobjs because we want to
7341	# use them later. If we have whole_archive_flag_spec, we
7342	# want to use save_libobjs as it was before
7343	# whole_archive_flag_spec was expanded, because we can't
7344	# assume the linker understands whole_archive_flag_spec.
7345	# This may have to be revisited, in case too many
7346	# convenience libraries get linked in and end up exceeding
7347	# the spec.
7348	if test -z "$convenience" \|\| test -z "$whole_archive_flag_spec"; then
7349	save_libobjs=$libobjs
7350	fi
7351	save_output=$output
7352	func_basename "$output"
7353	output_la=$func_basename_result
7354
7355	# Clear the reloadable object creation command queue and
7356	# initialize k to one.
7357	test_cmds=
7358	concat_cmds=
7359	objlist=
7360	last_robj=
7361	k=1
7362
7363	if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7364	output=${output_objdir}/${output_la}.lnkscript
7365	func_verbose "creating GNU ld script: $output"
7366	echo 'INPUT (' > $output
7367	for obj in $save_libobjs
7368	do
7369	$ECHO "$obj" >> $output
7370	done
7371	echo ')' >> $output
7372	delfiles="$delfiles $output"
7373	elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7374	output=${output_objdir}/${output_la}.lnk
7375	func_verbose "creating linker input file list: $output"
7376	: > $output
7377	set x $save_libobjs
7378	shift
7379	firstobj=
7380	if test "$compiler_needs_object" = yes; then
7381	firstobj="$1 "
7382	shift
7383	fi
7384	for obj
7385	do
7386	$ECHO "$obj" >> $output
7387	done
7388	delfiles="$delfiles $output"
7389	output=$firstobj\"$file_list_spec$output\"
7390	else
7391	if test -n "$save_libobjs"; then
7392	func_verbose "creating reloadable object files..."
7393	output=$output_objdir/$output_la-${k}.$objext
7394	eval "test_cmds=\"$reload_cmds\""
7395	func_len " $test_cmds"
7396	len0=$func_len_result
7397	len=$len0
7398
7399	# Loop over the list of objects to be linked.
7400	for obj in $save_libobjs
7401	do
7402	func_len " $obj"
7403	func_arith $len + $func_len_result
7404	len=$func_arith_result
7405	if test "X$objlist" = X \|\|
7406	test "$len" -lt "$max_cmd_len"; then
7407	func_append objlist " $obj"
7408	else
7409	# The command $test_cmds is almost too long, add a
7410	# command to the queue.
7411	if test "$k" -eq 1 ; then
7412	# The first file doesn't have a previous command to add.
7413	reload_objs=$objlist
7414	eval "concat_cmds=\"$reload_cmds\""
7415	else
7416	# All subsequent reloadable object files will link in
7417	# the last one created.
7418	reload_objs="$objlist $last_robj"
7419	eval "concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\""
7420	fi
7421	last_robj=$output_objdir/$output_la-${k}.$objext
7422	func_arith $k + 1
7423	k=$func_arith_result
7424	output=$output_objdir/$output_la-${k}.$objext
7425	objlist=" $obj"
7426	func_len " $last_robj"
7427	func_arith $len0 + $func_len_result
7428	len=$func_arith_result
7429	fi
7430	done
7431	# Handle the remaining objects by creating one last
7432	# reloadable object file. All subsequent reloadable object
7433	# files will link in the last one created.
7434	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
7435	reload_objs="$objlist $last_robj"
7436	eval "concat_cmds=\"\${concat_cmds}$reload_cmds\""
7437	if test -n "$last_robj"; then
7438	eval "concat_cmds=\"\${concat_cmds}~\$RM $last_robj\""
7439	fi
7440	delfiles="$delfiles $output"
7441
7442	else
7443	output=
7444	fi
7445
7446	if ${skipped_export-false}; then
7447	func_verbose "generating symbol list for \`$libname.la'"
7448	export_symbols="$output_objdir/$libname.exp"
7449	$opt_dry_run \|\| $RM $export_symbols
7450	libobjs=$output
7451	# Append the command to create the export file.
7452	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
7453	eval "concat_cmds=\"\$concat_cmds$export_symbols_cmds\""
7454	if test -n "$last_robj"; then
7455	eval "concat_cmds=\"\$concat_cmds~\$RM $last_robj\""
7456	fi
7457	fi
7458
7459	test -n "$save_libobjs" &&
7460	func_verbose "creating a temporary reloadable object file: $output"
7461
7462	# Loop through the commands generated above and execute them.
7463	save_ifs="$IFS"; IFS='~'
7464	for cmd in $concat_cmds; do
7465	IFS="$save_ifs"
7466	$opt_silent \|\| {
7467	func_quote_for_expand "$cmd"
7468	eval "func_echo $func_quote_for_expand_result"
7469	}
7470	$opt_dry_run \|\| eval "$cmd" \|\| {
7471	lt_exit=$?
7472
7473	# Restore the uninstalled library and exit
7474	if test "$mode" = relink; then
7475	( cd "$output_objdir" && \
7476	$RM "${realname}T" && \
7477	$MV "${realname}U" "$realname" )
7478	fi
7479
7480	exit $lt_exit
7481	}
7482	done
7483	IFS="$save_ifs"
7484
7485	if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7486	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7487	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7488	fi
7489	fi
7490
7491	if ${skipped_export-false}; then
7492	if test -n "$export_symbols" && test -n "$include_expsyms"; then
7493	tmp_export_symbols="$export_symbols"
7494	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7495	$opt_dry_run \|\| $ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"
7496	fi
7497
7498	if test -n "$orig_export_symbols"; then
7499	# The given exports_symbols file has to be filtered, so filter it.
7500	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7501	# FIXME: $output_objdir/$libname.filter potentially contains lots of
7502	# 's' commands which not all seds can handle. GNU sed should be fine
7503	# though. Also, the filter scales superlinearly with the number of
7504	# global variables. join(1) would be nice here, but unfortunately
7505	# isn't a blessed tool.
7506	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
7507	delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7508	export_symbols=$output_objdir/$libname.def
7509	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7510	fi
7511	fi
7512
7513	libobjs=$output
7514	# Restore the value of output.
7515	output=$save_output
7516
7517	if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7518	eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7519	test "X$libobjs" = "X " && libobjs=
7520	fi
7521	# Expand the library linking commands again to reset the
7522	# value of $libobjs for piecewise linking.
7523
7524	# Do each of the archive commands.
7525	if test "$module" = yes && test -n "$module_cmds" ; then
7526	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7527	cmds=$module_expsym_cmds
7528	else
7529	cmds=$module_cmds
7530	fi
7531	else
7532	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7533	cmds=$archive_expsym_cmds
7534	else
7535	cmds=$archive_cmds
7536	fi
7537	fi
7538	fi
7539
7540	if test -n "$delfiles"; then
7541	# Append the command to remove temporary files to $cmds.
7542	eval "cmds=\"\$cmds~\$RM $delfiles\""
7543	fi
7544
7545	# Add any objects from preloaded convenience libraries
7546	if test -n "$dlprefiles"; then
7547	gentop="$output_objdir/${outputname}x"
7548	generated="$generated $gentop"
7549
7550	func_extract_archives $gentop $dlprefiles
7551	libobjs="$libobjs $func_extract_archives_result"
7552	test "X$libobjs" = "X " && libobjs=
7553	fi
7554
7555	save_ifs="$IFS"; IFS='~'
7556	for cmd in $cmds; do
7557	IFS="$save_ifs"
7558	eval "cmd=\"$cmd\""
7559	$opt_silent \|\| {
7560	func_quote_for_expand "$cmd"
7561	eval "func_echo $func_quote_for_expand_result"
7562	}
7563	$opt_dry_run \|\| eval "$cmd" \|\| {
7564	lt_exit=$?
7565
7566	# Restore the uninstalled library and exit
7567	if test "$mode" = relink; then
7568	( cd "$output_objdir" && \
7569	$RM "${realname}T" && \
7570	$MV "${realname}U" "$realname" )
7571	fi
7572
7573	exit $lt_exit
7574	}
7575	done
7576	IFS="$save_ifs"
7577
7578	# Restore the uninstalled library and exit
7579	if test "$mode" = relink; then
7580	$opt_dry_run \|\| (cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname) \|\| exit $?
7581
7582	if test -n "$convenience"; then
7583	if test -z "$whole_archive_flag_spec"; then
7584	func_show_eval '${RM}r "$gentop"'
7585	fi
7586	fi
7587
7588	exit $EXIT_SUCCESS
7589	fi
7590
7591	# Create links to the real library.
7592	for linkname in $linknames; do
7593	if test "$realname" != "$linkname"; then
7594	func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7595	fi
7596	done
7597
7598	# If -module or -export-dynamic was specified, set the dlname.
7599	if test "$module" = yes \|\| test "$export_dynamic" = yes; then
7600	# On all known operating systems, these are identical.
7601	dlname="$soname"
7602	fi
7603	fi
7604	;;
7605
7606	obj)
7607	if test -n "$dlfiles$dlprefiles" \|\| test "$dlself" != no; then
7608	func_warning "\`-dlopen' is ignored for objects"
7609	fi
7610
7611	case " $deplibs" in
7612	\ -l \| \ -L)
7613	func_warning "\`-l' and \`-L' are ignored for objects" ;;
7614	esac
7615
7616	test -n "$rpath" && \
7617	func_warning "\`-rpath' is ignored for objects"
7618
7619	test -n "$xrpath" && \
7620	func_warning "\`-R' is ignored for objects"
7621
7622	test -n "$vinfo" && \
7623	func_warning "\`-version-info' is ignored for objects"
7624
7625	test -n "$release" && \
7626	func_warning "\`-release' is ignored for objects"
7627
7628	case $output in
7629	*.lo)
7630	test -n "$objs$old_deplibs" && \
7631	func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7632
7633	libobj=$output
7634	func_lo2o "$libobj"
7635	obj=$func_lo2o_result
7636	;;
7637	*)
7638	libobj=
7639	obj="$output"
7640	;;
7641	esac
7642
7643	# Delete the old objects.
7644	$opt_dry_run \|\| $RM $obj $libobj
7645
7646	# Objects from convenience libraries. This assumes
7647	# single-version convenience libraries. Whenever we create
7648	# different ones for PIC/non-PIC, this we'll have to duplicate
7649	# the extraction.
7650	reload_conv_objs=
7651	gentop=
7652	# reload_cmds runs $LD directly, so let us get rid of
7653	# -Wl from whole_archive_flag_spec and hope we can get by with
7654	# turning comma into space..
7655	wl=
7656
7657	if test -n "$convenience"; then
7658	if test -n "$whole_archive_flag_spec"; then
7659	eval "tmp_whole_archive_flags=\"$whole_archive_flag_spec\""
7660	reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" \| $SED 's\|,\| \|g'`
7661	else
7662	gentop="$output_objdir/${obj}x"
7663	generated="$generated $gentop"
7664
7665	func_extract_archives $gentop $convenience
7666	reload_conv_objs="$reload_objs $func_extract_archives_result"
7667	fi
7668	fi
7669
7670	# Create the old-style object.
7671	reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" \| $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7672
7673	output="$obj"
7674	func_execute_cmds "$reload_cmds" 'exit $?'
7675
7676	# Exit if we aren't doing a library object file.
7677	if test -z "$libobj"; then
7678	if test -n "$gentop"; then
7679	func_show_eval '${RM}r "$gentop"'
7680	fi
7681
7682	exit $EXIT_SUCCESS
7683	fi
7684
7685	if test "$build_libtool_libs" != yes; then
7686	if test -n "$gentop"; then
7687	func_show_eval '${RM}r "$gentop"'
7688	fi
7689
7690	# Create an invalid libtool object if no PIC, so that we don't
7691	# accidentally link it into a program.
7692	# $show "echo timestamp > $libobj"
7693	# $opt_dry_run \|\| echo timestamp > $libobj \|\| exit $?
7694	exit $EXIT_SUCCESS
7695	fi
7696
7697	if test -n "$pic_flag" \|\| test "$pic_mode" != default; then
7698	# Only do commands if we really have different PIC objects.
7699	reload_objs="$libobjs $reload_conv_objs"
7700	output="$libobj"
7701	func_execute_cmds "$reload_cmds" 'exit $?'
7702	fi
7703
7704	if test -n "$gentop"; then
7705	func_show_eval '${RM}r "$gentop"'
7706	fi
7707
7708	exit $EXIT_SUCCESS
7709	;;
7710
7711	prog)
7712	case $host in
7713	cygwin) func_stripname '' '.exe' "$output"
7714	output=$func_stripname_result.exe;;
7715	esac
7716	test -n "$vinfo" && \
7717	func_warning "\`-version-info' is ignored for programs"
7718
7719	test -n "$release" && \
7720	func_warning "\`-release' is ignored for programs"
7721
7722	test "$preload" = yes \
7723	&& test "$dlopen_support" = unknown \
7724	&& test "$dlopen_self" = unknown \
7725	&& test "$dlopen_self_static" = unknown && \
7726	func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7727
7728	case $host in
7729	--rhapsody* \| --darwin1.[012])
7730	# On Rhapsody replace the C library is the System framework
7731	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's/ -lc / System.ltframework /'`
7732	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's/ -lc / System.ltframework /'`
7733	;;
7734	esac
7735
7736	case $host in
7737	--darwin*)
7738	# Don't allow lazy linking, it breaks C++ global constructors
7739	# But is supposedly fixed on 10.4 or later (yay!).
7740	if test "$tagname" = CXX ; then
7741	case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7742	10.[0123])
7743	compile_command="$compile_command ${wl}-bind_at_load"
7744	finalize_command="$finalize_command ${wl}-bind_at_load"
7745	;;
7746	esac
7747	fi
7748	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7749	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7750	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7751	;;
7752	esac
7753
7754
7755	# move library search paths that coincide with paths to not yet
7756	# installed libraries to the beginning of the library search list
7757	new_libs=
7758	for path in $notinst_path; do
7759	case " $new_libs " in
7760	" -L$path/$objdir ") ;;
7761	*)
7762	case " $compile_deplibs " in
7763	" -L$path/$objdir ")
7764	new_libs="$new_libs -L$path/$objdir" ;;
7765	esac
7766	;;
7767	esac
7768	done
7769	for deplib in $compile_deplibs; do
7770	case $deplib in
7771	-L*)
7772	case " $new_libs " in
7773	" $deplib ") ;;
7774	*) new_libs="$new_libs $deplib" ;;
7775	esac
7776	;;
7777	*) new_libs="$new_libs $deplib" ;;
7778	esac
7779	done
7780	compile_deplibs="$new_libs"
7781
7782
7783	compile_command="$compile_command $compile_deplibs"
7784	finalize_command="$finalize_command $finalize_deplibs"
7785
7786	if test -n "$rpath$xrpath"; then
7787	# If the user specified any rpath flags, then add them.
7788	for libdir in $rpath $xrpath; do
7789	# This is the magic to use -rpath.
7790	case "$finalize_rpath " in
7791	" $libdir ") ;;
7792	*) finalize_rpath="$finalize_rpath $libdir" ;;
7793	esac
7794	done
7795	fi
7796
7797	# Now hardcode the library paths
7798	rpath=
7799	hardcode_libdirs=
7800	for libdir in $compile_rpath $finalize_rpath; do
7801	if test -n "$hardcode_libdir_flag_spec"; then
7802	if test -n "$hardcode_libdir_separator"; then
7803	if test -z "$hardcode_libdirs"; then
7804	hardcode_libdirs="$libdir"
7805	else
7806	# Just accumulate the unique libdirs.
7807	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7808	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
7809	;;
7810	*)
7811	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7812	;;
7813	esac
7814	fi
7815	else
7816	eval "flag=\"$hardcode_libdir_flag_spec\""
7817	rpath="$rpath $flag"
7818	fi
7819	elif test -n "$runpath_var"; then
7820	case "$perm_rpath " in
7821	" $libdir ") ;;
7822	*) perm_rpath="$perm_rpath $libdir" ;;
7823	esac
7824	fi
7825	case $host in
7826	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
7827	testbindir=`${ECHO} "$libdir" \| ${SED} -e 's/lib$/bin*'`
7828	case :$dllsearchpath: in
7829	":$libdir:") ;;
7830	::) dllsearchpath=$libdir;;
7831	*) dllsearchpath="$dllsearchpath:$libdir";;
7832	esac
7833	case :$dllsearchpath: in
7834	":$testbindir:") ;;
7835	::) dllsearchpath=$testbindir;;
7836	*) dllsearchpath="$dllsearchpath:$testbindir";;
7837	esac
7838	;;
7839	esac
7840	done
7841	# Substitute the hardcoded libdirs into the rpath.
7842	if test -n "$hardcode_libdir_separator" &&
7843	test -n "$hardcode_libdirs"; then
7844	libdir="$hardcode_libdirs"
7845	eval "rpath=\" $hardcode_libdir_flag_spec\""
7846	fi
7847	compile_rpath="$rpath"
7848
7849	rpath=
7850	hardcode_libdirs=
7851	for libdir in $finalize_rpath; do
7852	if test -n "$hardcode_libdir_flag_spec"; then
7853	if test -n "$hardcode_libdir_separator"; then
7854	if test -z "$hardcode_libdirs"; then
7855	hardcode_libdirs="$libdir"
7856	else
7857	# Just accumulate the unique libdirs.
7858	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7859	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
7860	;;
7861	*)
7862	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7863	;;
7864	esac
7865	fi
7866	else
7867	eval "flag=\"$hardcode_libdir_flag_spec\""
7868	rpath="$rpath $flag"
7869	fi
7870	elif test -n "$runpath_var"; then
7871	case "$finalize_perm_rpath " in
7872	" $libdir ") ;;
7873	*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7874	esac
7875	fi
7876	done
7877	# Substitute the hardcoded libdirs into the rpath.
7878	if test -n "$hardcode_libdir_separator" &&
7879	test -n "$hardcode_libdirs"; then
7880	libdir="$hardcode_libdirs"
7881	eval "rpath=\" $hardcode_libdir_flag_spec\""
7882	fi
7883	finalize_rpath="$rpath"
7884
7885	if test -n "$libobjs" && test "$build_old_libs" = yes; then
7886	# Transform all the library objects into standard objects.
7887	compile_command=`$ECHO "$compile_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
7888	finalize_command=`$ECHO "$finalize_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
7889	fi
7890
7891	func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7892
7893	# template prelinking step
7894	if test -n "$prelink_cmds"; then
7895	func_execute_cmds "$prelink_cmds" 'exit $?'
7896	fi
7897
7898	wrappers_required=yes
7899	case $host in
7900	cegcc \| mingw32ce)
7901	# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
7902	wrappers_required=no
7903	;;
7904	cygwin \| mingw )
7905	if test "$build_libtool_libs" != yes; then
7906	wrappers_required=no
7907	fi
7908	;;
7909	*)
7910	if test "$need_relink" = no \|\| test "$build_libtool_libs" != yes; then
7911	wrappers_required=no
7912	fi
7913	;;
7914	esac
7915	if test "$wrappers_required" = no; then
7916	# Replace the output file specification.
7917	compile_command=`$ECHO "$compile_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
7918	link_command="$compile_command$compile_rpath"
7919
7920	# We have no uninstalled library dependencies, so finalize right now.
7921	exit_status=0
7922	func_show_eval "$link_command" 'exit_status=$?'
7923
7924	# Delete the generated files.
7925	if test -f "$output_objdir/${outputname}S.${objext}"; then
7926	func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7927	fi
7928
7929	exit $exit_status
7930	fi
7931
7932	if test -n "$compile_shlibpath$finalize_shlibpath"; then
7933	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7934	fi
7935	if test -n "$finalize_shlibpath"; then
7936	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7937	fi
7938
7939	compile_var=
7940	finalize_var=
7941	if test -n "$runpath_var"; then
7942	if test -n "$perm_rpath"; then
7943	# We should set the runpath_var.
7944	rpath=
7945	for dir in $perm_rpath; do
7946	rpath="$rpath$dir:"
7947	done
7948	compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7949	fi
7950	if test -n "$finalize_perm_rpath"; then
7951	# We should set the runpath_var.
7952	rpath=
7953	for dir in $finalize_perm_rpath; do
7954	rpath="$rpath$dir:"
7955	done
7956	finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7957	fi
7958	fi
7959
7960	if test "$no_install" = yes; then
7961	# We don't need to create a wrapper script.
7962	link_command="$compile_var$compile_command$compile_rpath"
7963	# Replace the output file specification.
7964	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
7965	# Delete the old output file.
7966	$opt_dry_run \|\| $RM $output
7967	# Link the executable and exit
7968	func_show_eval "$link_command" 'exit $?'
7969	exit $EXIT_SUCCESS
7970	fi
7971
7972	if test "$hardcode_action" = relink; then
7973	# Fast installation is not supported
7974	link_command="$compile_var$compile_command$compile_rpath"
7975	relink_command="$finalize_var$finalize_command$finalize_rpath"
7976
7977	func_warning "this platform does not like uninstalled shared libraries"
7978	func_warning "\`$output' will be relinked during installation"
7979	else
7980	if test "$fast_install" != no; then
7981	link_command="$finalize_var$compile_command$finalize_rpath"
7982	if test "$fast_install" = yes; then
7983	relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" \| $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7984	else
7985	# fast_install is set to needless
7986	relink_command=
7987	fi
7988	else
7989	link_command="$compile_var$compile_command$compile_rpath"
7990	relink_command="$finalize_var$finalize_command$finalize_rpath"
7991	fi
7992	fi
7993
7994	# Replace the output file specification.
7995	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7996
7997	# Delete the old output files.
7998	$opt_dry_run \|\| $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7999
8000	func_show_eval "$link_command" 'exit $?'
8001
8002	# Now create the wrapper script.
8003	func_verbose "creating $output"
8004
8005	# Quote the relink command for shipping.
8006	if test -n "$relink_command"; then
8007	# Preserve any variables that may affect compiler behavior
8008	for var in $variables_saved_for_relink; do
8009	if eval test -z \"\${$var+set}\"; then
8010	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
8011	elif eval var_value=\$$var; test -z "$var_value"; then
8012	relink_command="$var=; export $var; $relink_command"
8013	else
8014	func_quote_for_eval "$var_value"
8015	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8016	fi
8017	done
8018	relink_command="(cd `pwd`; $relink_command)"
8019	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
8020	fi
8021
8022	# Only actually do things if not in dry run mode.
8023	$opt_dry_run \|\| {
8024	# win32 will think the script is a binary if it has
8025	# a .exe suffix, so we strip it off here.
8026	case $output in
8027	*.exe) func_stripname '' '.exe' "$output"
8028	output=$func_stripname_result ;;
8029	esac
8030	# test for cygwin because mv fails w/o .exe extensions
8031	case $host in
8032	cygwin)
8033	exeext=.exe
8034	func_stripname '' '.exe' "$outputname"
8035	outputname=$func_stripname_result ;;
8036	*) exeext= ;;
8037	esac
8038	case $host in
8039	cygwin \| mingw )
8040	func_dirname_and_basename "$output" "" "."
8041	output_name=$func_basename_result
8042	output_path=$func_dirname_result
8043	cwrappersource="$output_path/$objdir/lt-$output_name.c"
8044	cwrapper="$output_path/$output_name.exe"
8045	$RM $cwrappersource $cwrapper
8046	trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8047
8048	func_emit_cwrapperexe_src > $cwrappersource
8049
8050	# The wrapper executable is built using the $host compiler,
8051	# because it contains $host paths and files. If cross-
8052	# compiling, it, like the target executable, must be
8053	# executed on the $host or under an emulation environment.
8054	$opt_dry_run \|\| {
8055	$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8056	$STRIP $cwrapper
8057	}
8058
8059	# Now, create the wrapper script for func_source use:
8060	func_ltwrapper_scriptname $cwrapper
8061	$RM $func_ltwrapper_scriptname_result
8062	trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8063	$opt_dry_run \|\| {
8064	# note: this script will not be executed, so do not chmod.
8065	if test "x$build" = "x$host" ; then
8066	$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8067	else
8068	func_emit_wrapper no > $func_ltwrapper_scriptname_result
8069	fi
8070	}
8071	;;
8072	* )
8073	$RM $output
8074	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8075
8076	func_emit_wrapper no > $output
8077	chmod +x $output
8078	;;
8079	esac
8080	}
8081	exit $EXIT_SUCCESS
8082	;;
8083	esac
8084
8085	# See if we need to build an old-fashioned archive.
8086	for oldlib in $oldlibs; do
8087
8088	if test "$build_libtool_libs" = convenience; then
8089	oldobjs="$libobjs_save $symfileobj"
8090	addlibs="$convenience"
8091	build_libtool_libs=no
8092	else
8093	if test "$build_libtool_libs" = module; then
8094	oldobjs="$libobjs_save"
8095	build_libtool_libs=no
8096	else
8097	oldobjs="$old_deplibs $non_pic_objects"
8098	if test "$preload" = yes && test -f "$symfileobj"; then
8099	oldobjs="$oldobjs $symfileobj"
8100	fi
8101	fi
8102	addlibs="$old_convenience"
8103	fi
8104
8105	if test -n "$addlibs"; then
8106	gentop="$output_objdir/${outputname}x"
8107	generated="$generated $gentop"
8108
8109	func_extract_archives $gentop $addlibs
8110	oldobjs="$oldobjs $func_extract_archives_result"
8111	fi
8112
8113	# Do each command in the archive commands.
8114	if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8115	cmds=$old_archive_from_new_cmds
8116	else
8117
8118	# Add any objects from preloaded convenience libraries
8119	if test -n "$dlprefiles"; then
8120	gentop="$output_objdir/${outputname}x"
8121	generated="$generated $gentop"
8122
8123	func_extract_archives $gentop $dlprefiles
8124	oldobjs="$oldobjs $func_extract_archives_result"
8125	fi
8126
8127	# POSIX demands no paths to be encoded in archives. We have
8128	# to avoid creating archives with duplicate basenames if we
8129	# might have to extract them afterwards, e.g., when creating a
8130	# static archive out of a convenience library, or when linking
8131	# the entirety of a libtool archive into another (currently
8132	# not supported by libtool).
8133	if (for obj in $oldobjs
8134	do
8135	func_basename "$obj"
8136	$ECHO "$func_basename_result"
8137	done \| sort \| sort -uc >/dev/null 2>&1); then
8138	:
8139	else
8140	echo "copying selected object files to avoid basename conflicts..."
8141	gentop="$output_objdir/${outputname}x"
8142	generated="$generated $gentop"
8143	func_mkdir_p "$gentop"
8144	save_oldobjs=$oldobjs
8145	oldobjs=
8146	counter=1
8147	for obj in $save_oldobjs
8148	do
8149	func_basename "$obj"
8150	objbase="$func_basename_result"
8151	case " $oldobjs " in
8152	" ") oldobjs=$obj ;;
8153	[\ /]"$objbase ")
8154	while :; do
8155	# Make sure we don't pick an alternate name that also
8156	# overlaps.
8157	newobj=lt$counter-$objbase
8158	func_arith $counter + 1
8159	counter=$func_arith_result
8160	case " $oldobjs " in
8161	[\ /]"$newobj ") ;;
8162	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
8163	esac
8164	done
8165	func_show_eval "ln $obj $gentop/$newobj \|\| cp $obj $gentop/$newobj"
8166	oldobjs="$oldobjs $gentop/$newobj"
8167	;;
8168	*) oldobjs="$oldobjs $obj" ;;
8169	esac
8170	done
8171	fi
8172	eval "cmds=\"$old_archive_cmds\""
8173
8174	func_len " $cmds"
8175	len=$func_len_result
8176	if test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
8177	cmds=$old_archive_cmds
8178	else
8179	# the command line is too long to link in one step, link in parts
8180	func_verbose "using piecewise archive linking..."
8181	save_RANLIB=$RANLIB
8182	RANLIB=:
8183	objlist=
8184	concat_cmds=
8185	save_oldobjs=$oldobjs
8186	oldobjs=
8187	# Is there a better way of finding the last object in the list?
8188	for obj in $save_oldobjs
8189	do
8190	last_oldobj=$obj
8191	done
8192	eval "test_cmds=\"$old_archive_cmds\""
8193	func_len " $test_cmds"
8194	len0=$func_len_result
8195	len=$len0
8196	for obj in $save_oldobjs
8197	do
8198	func_len " $obj"
8199	func_arith $len + $func_len_result
8200	len=$func_arith_result
8201	func_append objlist " $obj"
8202	if test "$len" -lt "$max_cmd_len"; then
8203	:
8204	else
8205	# the above command should be used before it gets too long
8206	oldobjs=$objlist
8207	if test "$obj" = "$last_oldobj" ; then
8208	RANLIB=$save_RANLIB
8209	fi
8210	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
8211	eval "concat_cmds=\"\${concat_cmds}$old_archive_cmds\""
8212	objlist=
8213	len=$len0
8214	fi
8215	done
8216	RANLIB=$save_RANLIB
8217	oldobjs=$objlist
8218	if test "X$oldobjs" = "X" ; then
8219	eval "cmds=\"\$concat_cmds\""
8220	else
8221	eval "cmds=\"\$concat_cmds~\$old_archive_cmds\""
8222	fi
8223	fi
8224	fi
8225	func_execute_cmds "$cmds" 'exit $?'
8226	done
8227
8228	test -n "$generated" && \
8229	func_show_eval "${RM}r$generated"
8230
8231	# Now create the libtool archive.
8232	case $output in
8233	*.la)
8234	old_library=
8235	test "$build_old_libs" = yes && old_library="$libname.$libext"
8236	func_verbose "creating $output"
8237
8238	# Preserve any variables that may affect compiler behavior
8239	for var in $variables_saved_for_relink; do
8240	if eval test -z \"\${$var+set}\"; then
8241	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
8242	elif eval var_value=\$$var; test -z "$var_value"; then
8243	relink_command="$var=; export $var; $relink_command"
8244	else
8245	func_quote_for_eval "$var_value"
8246	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8247	fi
8248	done
8249	# Quote the link command for shipping.
8250	relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8251	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
8252	if test "$hardcode_automatic" = yes ; then
8253	relink_command=
8254	fi
8255
8256	# Only create the output if not a dry run.
8257	$opt_dry_run \|\| {
8258	for installed in no yes; do
8259	if test "$installed" = yes; then
8260	if test -z "$install_libdir"; then
8261	break
8262	fi
8263	output="$output_objdir/$outputname"i
8264	# Replace all uninstalled libtool libraries with the installed ones
8265	newdependency_libs=
8266	for deplib in $dependency_libs; do
8267	case $deplib in
8268	*.la)
8269	func_basename "$deplib"
8270	name="$func_basename_result"
8271	libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $deplib`
8272	test -z "$libdir" && \
8273	func_fatal_error "\`$deplib' is not a valid libtool archive"
8274	newdependency_libs="$newdependency_libs $libdir/$name"
8275	;;
8276	*) newdependency_libs="$newdependency_libs $deplib" ;;
8277	esac
8278	done
8279	dependency_libs="$newdependency_libs"
8280	newdlfiles=
8281
8282	for lib in $dlfiles; do
8283	case $lib in
8284	*.la)
8285	func_basename "$lib"
8286	name="$func_basename_result"
8287	libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
8288	test -z "$libdir" && \
8289	func_fatal_error "\`$lib' is not a valid libtool archive"
8290	newdlfiles="$newdlfiles $libdir/$name"
8291	;;
8292	*) newdlfiles="$newdlfiles $lib" ;;
8293	esac
8294	done
8295	dlfiles="$newdlfiles"
8296	newdlprefiles=
8297	for lib in $dlprefiles; do
8298	case $lib in
8299	*.la)
8300	# Only pass preopened files to the pseudo-archive (for
8301	# eventual linking with the app. that links it) if we
8302	# didn't already link the preopened objects directly into
8303	# the library:
8304	func_basename "$lib"
8305	name="$func_basename_result"
8306	libdir=`${SED} -n -e 's/^libdir=$.*$$/\1/p' $lib`
8307	test -z "$libdir" && \
8308	func_fatal_error "\`$lib' is not a valid libtool archive"
8309	newdlprefiles="$newdlprefiles $libdir/$name"
8310	;;
8311	esac
8312	done
8313	dlprefiles="$newdlprefiles"
8314	else
8315	newdlfiles=
8316	for lib in $dlfiles; do
8317	case $lib in
8318	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
8319	*) abs=`pwd`"/$lib" ;;
8320	esac
8321	newdlfiles="$newdlfiles $abs"
8322	done
8323	dlfiles="$newdlfiles"
8324	newdlprefiles=
8325	for lib in $dlprefiles; do
8326	case $lib in
8327	[\\/]* \| [A-Za-z]:[\\/]*) abs="$lib" ;;
8328	*) abs=`pwd`"/$lib" ;;
8329	esac
8330	newdlprefiles="$newdlprefiles $abs"
8331	done
8332	dlprefiles="$newdlprefiles"
8333	fi
8334	$RM $output
8335	# place dlname in correct position for cygwin
8336	# In fact, it would be nice if we could use this code for all target
8337	# systems that can't hard-code library paths into their executables
8338	# and that have no shared library path variable independent of PATH,
8339	# but it turns out we can't easily determine that from inspecting
8340	# libtool variables, so we have to hard-code the OSs to which it
8341	# applies here; at the moment, that means platforms that use the PE
8342	# object format with DLL files. See the long comment at the top of
8343	# tests/bindir.at for full details.
8344	tdlname=$dlname
8345	case $host,$output,$installed,$module,$dlname in
8346	cygwin,lai,yes,no,.dll \| mingw,lai,yes,no,.dll \| cegcc,lai,yes,no,.dll)
8347	# If a -bindir argument was supplied, place the dll there.
8348	if test "x$bindir" != x ;
8349	then
8350	func_relative_path "$install_libdir" "$bindir"
8351	tdlname=$func_relative_path_result$dlname
8352	else
8353	# Otherwise fall back on heuristic.
8354	tdlname=../bin/$dlname
8355	fi
8356	;;
8357	esac
8358	$ECHO > $output "\
8359	# $outputname - a libtool library file
8360	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8361	#
8362	# Please DO NOT delete this file!
8363	# It is necessary for linking the library.
8364
8365	# The name that we can dlopen(3).
8366	dlname='$tdlname'
8367
8368	# Names of this library.
8369	library_names='$library_names'
8370
8371	# The name of the static archive.
8372	old_library='$old_library'
8373
8374	# Linker flags that can not go in dependency_libs.
8375	inherited_linker_flags='$new_inherited_linker_flags'
8376
8377	# Libraries that this one depends upon.
8378	dependency_libs='$dependency_libs'
8379
8380	# Names of additional weak libraries provided by this library
8381	weak_library_names='$weak_libs'
8382
8383	# Version information for $libname.
8384	current=$current
8385	age=$age
8386	revision=$revision
8387
8388	# Is this an already installed library?
8389	installed=$installed
8390
8391	# Should we warn about portability when linking against -modules?
8392	shouldnotlink=$module
8393
8394	# Files to dlopen/dlpreopen
8395	dlopen='$dlfiles'
8396	dlpreopen='$dlprefiles'
8397
8398	# Directory that this library needs to be installed in:
8399	libdir='$install_libdir'"
8400	if test "$installed" = no && test "$need_relink" = yes; then
8401	$ECHO >> $output "\
8402	relink_command=\"$relink_command\""
8403	fi
8404	done
8405	}
8406
8407	# Do a symbolic link so that the libtool archive can be found in
8408	# LD_LIBRARY_PATH before the program is installed.
8409	func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8410	;;
8411	esac
8412	exit $EXIT_SUCCESS
8413	}
8414
8415	{ test "$mode" = link \|\| test "$mode" = relink; } &&
8416	func_mode_link ${1+"$@"}
8417
8418
8419	# func_mode_uninstall arg...
8420	func_mode_uninstall ()
8421	{
8422	$opt_debug
8423	RM="$nonopt"
8424	files=
8425	rmforce=
8426	exit_status=0
8427
8428	# This variable tells wrapper scripts just to set variables rather
8429	# than running their programs.
8430	libtool_install_magic="$magic"
8431
8432	for arg
8433	do
8434	case $arg in
8435	-f) RM="$RM $arg"; rmforce=yes ;;
8436	-*) RM="$RM $arg" ;;
8437	*) files="$files $arg" ;;
8438	esac
8439	done
8440
8441	test -z "$RM" && \
8442	func_fatal_help "you must specify an RM program"
8443
8444	rmdirs=
8445
8446	origobjdir="$objdir"
8447	for file in $files; do
8448	func_dirname "$file" "" "."
8449	dir="$func_dirname_result"
8450	if test "X$dir" = X.; then
8451	objdir="$origobjdir"
8452	else
8453	objdir="$dir/$origobjdir"
8454	fi
8455	func_basename "$file"
8456	name="$func_basename_result"
8457	test "$mode" = uninstall && objdir="$dir"
8458
8459	# Remember objdir for removal later, being careful to avoid duplicates
8460	if test "$mode" = clean; then
8461	case " $rmdirs " in
8462	" $objdir ") ;;
8463	*) rmdirs="$rmdirs $objdir" ;;
8464	esac
8465	fi
8466
8467	# Don't error if the file doesn't exist and rm -f was used.
8468	if { test -L "$file"; } >/dev/null 2>&1 \|\|
8469	{ test -h "$file"; } >/dev/null 2>&1 \|\|
8470	test -f "$file"; then
8471	:
8472	elif test -d "$file"; then
8473	exit_status=1
8474	continue
8475	elif test "$rmforce" = yes; then
8476	continue
8477	fi
8478
8479	rmfiles="$file"
8480
8481	case $name in
8482	*.la)
8483	# Possibly a libtool archive, so verify it.
8484	if func_lalib_p "$file"; then
8485	func_source $dir/$name
8486
8487	# Delete the libtool libraries and symlinks.
8488	for n in $library_names; do
8489	rmfiles="$rmfiles $objdir/$n"
8490	done
8491	test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8492
8493	case "$mode" in
8494	clean)
8495	case " $library_names " in
8496	# " " in the beginning catches empty $dlname
8497	" $dlname ") ;;
8498	*) rmfiles="$rmfiles $objdir/$dlname" ;;
8499	esac
8500	test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8501	;;
8502	uninstall)
8503	if test -n "$library_names"; then
8504	# Do each command in the postuninstall commands.
8505	func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes \|\| exit_status=1'
8506	fi
8507
8508	if test -n "$old_library"; then
8509	# Do each command in the old_postuninstall commands.
8510	func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes \|\| exit_status=1'
8511	fi
8512	# FIXME: should reinstall the best remaining shared library.
8513	;;
8514	esac
8515	fi
8516	;;
8517
8518	*.lo)
8519	# Possibly a libtool object, so verify it.
8520	if func_lalib_p "$file"; then
8521
8522	# Read the .lo file
8523	func_source $dir/$name
8524
8525	# Add PIC object to the list of files to remove.
8526	if test -n "$pic_object" &&
8527	test "$pic_object" != none; then
8528	rmfiles="$rmfiles $dir/$pic_object"
8529	fi
8530
8531	# Add non-PIC object to the list of files to remove.
8532	if test -n "$non_pic_object" &&
8533	test "$non_pic_object" != none; then
8534	rmfiles="$rmfiles $dir/$non_pic_object"
8535	fi
8536	fi
8537	;;
8538
8539	*)
8540	if test "$mode" = clean ; then
8541	noexename=$name
8542	case $file in
8543	*.exe)
8544	func_stripname '' '.exe' "$file"
8545	file=$func_stripname_result
8546	func_stripname '' '.exe' "$name"
8547	noexename=$func_stripname_result
8548	# $file with .exe has already been added to rmfiles,
8549	# add $file without .exe
8550	rmfiles="$rmfiles $file"
8551	;;
8552	esac
8553	# Do a test to see if this is a libtool program.
8554	if func_ltwrapper_p "$file"; then
8555	if func_ltwrapper_executable_p "$file"; then
8556	func_ltwrapper_scriptname "$file"
8557	relink_command=
8558	func_source $func_ltwrapper_scriptname_result
8559	rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8560	else
8561	relink_command=
8562	func_source $dir/$noexename
8563	fi
8564
8565	# note $name still contains .exe if it was in $file originally
8566	# as does the version of $file that was added into $rmfiles
8567	rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8568	if test "$fast_install" = yes && test -n "$relink_command"; then
8569	rmfiles="$rmfiles $objdir/lt-$name"
8570	fi
8571	if test "X$noexename" != "X$name" ; then
8572	rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8573	fi
8574	fi
8575	fi
8576	;;
8577	esac
8578	func_show_eval "$RM $rmfiles" 'exit_status=1'
8579	done
8580	objdir="$origobjdir"
8581
8582	# Try to remove the ${objdir}s in the directories where we deleted files
8583	for dir in $rmdirs; do
8584	if test -d "$dir"; then
8585	func_show_eval "rmdir $dir >/dev/null 2>&1"
8586	fi
8587	done
8588
8589	exit $exit_status
8590	}
8591
8592	{ test "$mode" = uninstall \|\| test "$mode" = clean; } &&
8593	func_mode_uninstall ${1+"$@"}
8594
8595	test -z "$mode" && {
8596	help="$generic_help"
8597	func_fatal_help "you must specify a MODE"
8598	}
8599
8600	test -z "$exec_cmd" && \
8601	func_fatal_help "invalid operation mode \`$mode'"
8602
8603	if test -n "$exec_cmd"; then
8604	eval exec "$exec_cmd"
8605	exit $EXIT_FAILURE
8606	fi
8607
8608	exit $exit_status
8609
8610
8611	# The TAGs below are defined such that we never get into a situation
8612	# in which we disable both kinds of libraries. Given conflicting
8613	# choices, we go for a static library, that is the most portable,
8614	# since we can't tell whether shared libraries were disabled because
8615	# the user asked for that or because the platform doesn't support
8616	# them. This is particularly important on AIX, because we don't
8617	# support having both static and shared libraries enabled at the same
8618	# time on that platform, so we default to a shared-only configuration.
8619	# If a disable-shared tag is given, we'll fallback to a static-only
8620	# configuration. But we'll never go from static-only to shared-only.
8621
8622	# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8623	build_libtool_libs=no
8624	build_old_libs=yes
8625	# ### END LIBTOOL TAG CONFIG: disable-shared
8626
8627	# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8628	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8629	# ### END LIBTOOL TAG CONFIG: disable-static
8630
8631	# Local Variables:
8632	# mode:shell-script
8633	# sh-indentation:2
8634	# End:
8635	# vi:sw=2
8636

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

Context Navigation

source: trunk/libs/newlib/src/ltmain.sh @ 458

Download in other formats: