Context Navigation

ltmain.sh @ 180e49f

Visit:

debian/masterdebian/stretch-backportsjessie-backportsupstream upstream/0.5.10

Last change on this file since 180e49f was 180e49f, checked in by Daniel Kahn Gillmor <dkg@…>, 10 years ago
Imported Upstream version 0.5.10
Property mode set to `100755`
File size: 247.2 KB

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