ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/ltmain.sh

Comparing:
ircd-hybrid-7.2/ltmain.sh (file contents), Revision 912 by michael, Wed Nov 7 22:47:44 2007 UTC vs.
ircd-hybrid-7.3/ltmain.sh (file contents), Revision 1084 by michael, Sat Mar 13 23:24:10 2010 UTC

#	Line 1 | Line 1
1	<	# ltmain.sh - Provide generalized library-building support services.
2	<	# NOTE: Changing this file will not affect anything until you rerun configure.
3	<	#
4	<	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
5	<	# 2007  Free Software Foundation, Inc.
6	<	# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7	<	#
8	<	# This program is free software; you can redistribute it and/or modify
1	>	# Generated from ltmain.m4sh.
2	>
3	>	# ltmain.sh (GNU libtool) 2.2.6b
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, 2007 2008 Free Software Foundation, Inc.
7	>	# This is free software; see the source for copying conditions.  There is NO
8	>	# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9	>
10	>	# GNU Libtool is free software; you can redistribute it and/or modify
11		# it under the terms of the GNU General Public License as published by
12		# the Free Software Foundation; either version 2 of the License, or
13		# (at your option) any later version.
14		#
15	<	# This program is distributed in the hope that it will be useful, but
15	>	# As a special exception to the GNU General Public License,
16	>	# if you distribute this file as part of a program or library that
17	>	# is built using GNU Libtool, you may include this file under the
18	>	# same distribution terms that you use for the rest of that program.
19	>	#
20	>	# GNU Libtool is distributed in the hope that it will be useful, but
21		# WITHOUT ANY WARRANTY; without even the implied warranty of
22		# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23		# General Public License for more details.
24		#
25		# You should have received a copy of the GNU General Public License
26	<	# along with this program; if not, write to the Free Software
27	<	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
28	<	#
29	<	# As a special exception to the GNU General Public License, if you
23	<	# distribute this file as part of a program that contains a
24	<	# configuration script generated by Autoconf, you may include it under
25	<	# the same distribution terms that you use for the rest of that program.
26	<
27	<	basename="s,^.*/,,g"
28	<
29	<	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
30	<	# is ksh but when the shell is invoked as "sh" and the current value of
31	<	# the _XPG environment variable is not equal to 1 (one), the special
32	<	# positional parameter $0, within a function call, is the name of the
33	<	# function.
34	<	progpath="$0"
26	>	# along with GNU Libtool; see the file COPYING.  If not, a copy
27	>	# can be downloaded from http://www.gnu.org/licenses/gpl.html,
28	>	# or obtained by writing to the Free Software Foundation, Inc.,
29	>	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30
31	<	# The name of this program:
32	<	progname=`echo "$progpath" | $SED $basename`
33	<	modename="$progname"
34	<
35	<	# Global variables:
36	<	EXIT_SUCCESS=0
37	<	EXIT_FAILURE=1
31	>	# Usage: $progname [OPTION]... [MODE-ARG]...
32	>	#
33	>	# Provide generalized library-building support services.
34	>	#
35	>	#     --config             show all configuration variables
36	>	#     --debug              enable verbose shell tracing
37	>	# -n, --dry-run            display commands without modifying any files
38	>	#     --features           display basic configuration information and exit
39	>	#     --mode=MODE          use operation mode MODE
40	>	#     --preserve-dup-deps  don't remove duplicate dependency libraries
41	>	#     --quiet, --silent    don't print informational messages
42	>	#     --tag=TAG            use configuration variables from tag TAG
43	>	# -v, --verbose            print informational messages (default)
44	>	#     --version            print version information
45	>	# -h, --help               print short or long help message
46	>	#
47	>	# MODE must be one of the following:
48	>	#
49	>	#       clean              remove files from the build directory
50	>	#       compile            compile a source file into a libtool object
51	>	#       execute            automatically set library path, then run a program
52	>	#       finish             complete the installation of libtool libraries
53	>	#       install            install libraries or executables
54	>	#       link               create a library or an executable
55	>	#       uninstall          remove libraries from an installed directory
56	>	#
57	>	# MODE-ARGS vary depending on the MODE.
58	>	# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
59	>	#
60	>	# When reporting a bug, please describe a test case to reproduce it and
61	>	# include the following information:
62	>	#
63	>	#       host-triplet:   $host
64	>	#       shell:          $SHELL
65	>	#       compiler:               $LTCC
66	>	#       compiler flags:         $LTCFLAGS
67	>	#       linker:         $LD (gnu? $with_gnu_ld)
68	>	#       $progname:              (GNU libtool) 2.2.6b
69	>	#       automake:               $automake_version
70	>	#       autoconf:               $autoconf_version
71	>	#
72	>	# Report bugs to <bug-libtool@gnu.org>.
73
74		PROGRAM=ltmain.sh
75		PACKAGE=libtool
76	<	VERSION=1.5.24
77	<	TIMESTAMP=" (1.1220.2.455 2007/06/24 02:13:29)"
76	>	VERSION=2.2.6b
77	>	TIMESTAMP=""
78	>	package_revision=1.3017
79
80	<	# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
80	>	# Be Bourne compatible
81		if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
82		emulate sh
83		NULLCMD=:
#	Line 60 | Line 91 | fi
91		BIN_SH=xpg4; export BIN_SH # for Tru64
92		DUALCASE=1; export DUALCASE # for MKS sh
93
94	<	# Check that we have a working $echo.
64	<	if test "X$1" = X--no-reexec; then
65	<	# Discard the --no-reexec flag, and continue.
66	<	shift
67	<	elif test "X$1" = X--fallback-echo; then
68	<	# Avoid inline document here, it may be left over
69	<	:
70	<	elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
71	<	# Yippee, $echo works!
72	<	:
73	<	else
74	<	# Restart under the correct shell, and then maybe $echo will work.
75	<	exec $SHELL "$progpath" --no-reexec ${1+"$@"}
76	<	fi
77	<
78	<	if test "X$1" = X--fallback-echo; then
79	<	# used as fallback echo
80	<	shift
81	<	cat <<EOF
82	<	$*
83	<	EOF
84	<	exit $EXIT_SUCCESS
85	<	fi
86	<
87	<	default_mode=
88	<	help="Try \`$progname --help' for more information."
89	<	magic="%%%MAGIC variable%%%"
90	<	mkdir="mkdir"
91	<	mv="mv -f"
92	<	rm="rm -f"
93	<
94	<	# Sed substitution that helps us do robust quoting.  It backslashifies
95	<	# metacharacters that are still active within double-quoted strings.
96	<	Xsed="${SED}"' -e 1s/^X//'
97	<	sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
98	<	# test EBCDIC or ASCII
99	<	case `echo X|tr X '\101'` in
100	<	A) # ASCII based system
101	<	# \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
102	<	SP2NL='tr \040 \012'
103	<	NL2SP='tr \015\012 \040\040'
104	<	;;
105	<	*) # EBCDIC based system
106	<	SP2NL='tr \100 \n'
107	<	NL2SP='tr \r\n \100\100'
108	<	;;
109	<	esac
110	<
111	<	# NLS nuisances.
94	>	# NLS nuisances: We save the old values to restore during execute mode.
95		# Only set LANG and LC_ALL to C if already set.
96		# These must not be set unconditionally because not all systems understand
97		# e.g. LANG=C (notably SCO).
98	<	# We save the old values to restore during execute mode.
99	<	for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
98	>	lt_user_locale=
99	>	lt_safe_locale=
100	>	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
101		do
102		eval "if test \"\${$lt_var+set}\" = set; then
103	<	save_$lt_var=\$$lt_var
104	<	$lt_var=C
103	>	save_$lt_var=\$$lt_var
104	>	$lt_var=C
105		export $lt_var
106	+	lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
107	+	lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
108		fi"
109		done
110
111	+	$lt_unset CDPATH
112	+
113	+
114	+
115	+
116	+
117	+	: ${CP="cp -f"}
118	+	: ${ECHO="echo"}
119	+	: ${EGREP="/bin/grep -E"}
120	+	: ${FGREP="/bin/grep -F"}
121	+	: ${GREP="/bin/grep"}
122	+	: ${LN_S="ln -s"}
123	+	: ${MAKE="make"}
124	+	: ${MKDIR="mkdir"}
125	+	: ${MV="mv -f"}
126	+	: ${RM="rm -f"}
127	+	: ${SED="/bin/sed"}
128	+	: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
129	+	: ${Xsed="$SED -e 1s/^X//"}
130	+
131	+	# Global variables:
132	+	EXIT_SUCCESS=0
133	+	EXIT_FAILURE=1
134	+	EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
135	+	EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
136	+
137	+	exit_status=$EXIT_SUCCESS
138	+
139		# Make sure IFS has a sensible default
140		lt_nl='
141		'
142		IFS="   $lt_nl"
143
144	<	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
145	<	$echo "$modename: not configured to build any kind of library" 1>&2
132	<	$echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
133	<	exit $EXIT_FAILURE
134	<	fi
144	>	dirname="s,/[^/]*$,,"
145	>	basename="s,^.*/,,"
146
147	<	# Global variables.
148	<	mode=$default_mode
149	<	nonopt=
150	<	prev=
151	<	prevopt=
152	<	run=
153	<	show="$echo"
154	<	show_help=
155	<	execute_dlfiles=
156	<	duplicate_deps=no
157	<	preserve_args=
158	<	lo2o="s/\\.lo\$/.${objext}/"
159	<	o2lo="s/\\.${objext}\$/.lo/"
160	<	extracted_archives=
161	<	extracted_serial=0
147	>	# func_dirname_and_basename file append nondir_replacement
148	>	# perform func_basename and func_dirname in a single function
149	>	# call:
150	>	#   dirname:  Compute the dirname of FILE.  If nonempty,
151	>	#             add APPEND to the result, otherwise set result
152	>	#             to NONDIR_REPLACEMENT.
153	>	#             value returned in "$func_dirname_result"
154	>	#   basename: Compute filename of FILE.
155	>	#             value retuned in "$func_basename_result"
156	>	# Implementation must be kept synchronized with func_dirname
157	>	# and func_basename. For efficiency, we do not delegate to
158	>	# those functions but instead duplicate the functionality here.
159	>	func_dirname_and_basename ()
160	>	{
161	>	# Extract subdirectory from the argument.
162	>	func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
163	>	if test "X$func_dirname_result" = "X${1}"; then
164	>	func_dirname_result="${3}"
165	>	else
166	>	func_dirname_result="$func_dirname_result${2}"
167	>	fi
168	>	func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
169	>	}
170	>
171	>	# Generated shell functions inserted here.
172	>
173	>	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
174	>	# is ksh but when the shell is invoked as "sh" and the current value of
175	>	# the _XPG environment variable is not equal to 1 (one), the special
176	>	# positional parameter $0, within a function call, is the name of the
177	>	# function.
178	>	progpath="$0"
179	>
180	>	# The name of this program:
181	>	# In the unlikely event $progname began with a '-', it would play havoc with
182	>	# func_echo (imagine progname=-n), so we prepend ./ in that case:
183	>	func_dirname_and_basename "$progpath"
184	>	progname=$func_basename_result
185	>	case $progname in
186	>	-*) progname=./$progname ;;
187	>	esac
188	>
189	>	# Make sure we have an absolute path for reexecution:
190	>	case $progpath in
191	>	[\\/]*|[A-Za-z]:\\*) ;;
192	>	*[\\/]*)
193	>	progdir=$func_dirname_result
194	>	progdir=`cd "$progdir" && pwd`
195	>	progpath="$progdir/$progname"
196	>	;;
197	>	*)
198	>	save_IFS="$IFS"
199	>	IFS=:
200	>	for progdir in $PATH; do
201	>	IFS="$save_IFS"
202	>	test -x "$progdir/$progname" && break
203	>	done
204	>	IFS="$save_IFS"
205	>	test -n "$progdir" || progdir=`pwd`
206	>	progpath="$progdir/$progname"
207	>	;;
208	>	esac
209	>
210	>	# Sed substitution that helps us do robust quoting.  It backslashifies
211	>	# metacharacters that are still active within double-quoted strings.
212	>	Xsed="${SED}"' -e 1s/^X//'
213	>	sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
214	>
215	>	# Same as above, but do not quote variable references.
216	>	double_quote_subst='s/\(["`\\]\)/\\\1/g'
217	>
218	>	# Re-`\' parameter expansions in output of double_quote_subst that were
219	>	# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
220	>	# in input to double_quote_subst, that '$' was protected from expansion.
221	>	# Since each input `\' is now two `\'s, look for any number of runs of
222	>	# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
223	>	bs='\\'
224	>	bs2='\\\\'
225	>	bs4='\\\\\\\\'
226	>	dollar='\$'
227	>	sed_double_backslash="\
228	>	s/$bs4/&\\
229	>	/g
230	>	s/^$bs2$dollar/$bs&/
231	>	s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
232	>	s/\n//g"
233	>
234	>	# Standard options:
235	>	opt_dry_run=false
236	>	opt_help=false
237	>	opt_quiet=false
238	>	opt_verbose=false
239	>	opt_warning=:
240	>
241	>	# func_echo arg...
242	>	# Echo program name prefixed message, along with the current mode
243	>	# name if it has been set yet.
244	>	func_echo ()
245	>	{
246	>	$ECHO "$progname${mode+: }$mode: $*"
247	>	}
248	>
249	>	# func_verbose arg...
250	>	# Echo program name prefixed message in verbose mode only.
251	>	func_verbose ()
252	>	{
253	>	$opt_verbose && func_echo ${1+"$@"}
254	>
255	>	# A bug in bash halts the script if the last line of a function
256	>	# fails when set -e is in force, so we need another command to
257	>	# work around that:
258	>	:
259	>	}
260	>
261	>	# func_error arg...
262	>	# Echo program name prefixed message to standard error.
263	>	func_error ()
264	>	{
265	>	$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
266	>	}
267	>
268	>	# func_warning arg...
269	>	# Echo program name prefixed warning message to standard error.
270	>	func_warning ()
271	>	{
272	>	$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
273	>
274	>	# bash bug again:
275	>	:
276	>	}
277	>
278	>	# func_fatal_error arg...
279	>	# Echo program name prefixed message to standard error, and exit.
280	>	func_fatal_error ()
281	>	{
282	>	func_error ${1+"$@"}
283	>	exit $EXIT_FAILURE
284	>	}
285	>
286	>	# func_fatal_help arg...
287	>	# Echo program name prefixed message to standard error, followed by
288	>	# a help hint, and exit.
289	>	func_fatal_help ()
290	>	{
291	>	func_error ${1+"$@"}
292	>	func_fatal_error "$help"
293	>	}
294	>	help="Try \`$progname --help' for more information."  ## default
295	>
296	>
297	>	# func_grep expression filename
298	>	# Check whether EXPRESSION matches any line of FILENAME, without output.
299	>	func_grep ()
300	>	{
301	>	$GREP "$1" "$2" >/dev/null 2>&1
302	>	}
303	>
304	>
305	>	# func_mkdir_p directory-path
306	>	# Make sure the entire path to DIRECTORY-PATH is available.
307	>	func_mkdir_p ()
308	>	{
309	>	my_directory_path="$1"
310	>	my_dir_list=
311	>
312	>	if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
313	>
314	>	# Protect directory names starting with `-'
315	>	case $my_directory_path in
316	>	-*) my_directory_path="./$my_directory_path" ;;
317	>	esac
318	>
319	>	# While some portion of DIR does not yet exist...
320	>	while test ! -d "$my_directory_path"; do
321	>	# ...make a list in topmost first order.  Use a colon delimited
322	>	# list incase some portion of path contains whitespace.
323	>	my_dir_list="$my_directory_path:$my_dir_list"
324	>
325	>	# If the last portion added has no slash in it, the list is done
326	>	case $my_directory_path in */*) ;; *) break ;; esac
327	>
328	>	# ...otherwise throw away the child directory and loop
329	>	my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
330	>	done
331	>	my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
332	>
333	>	save_mkdir_p_IFS="$IFS"; IFS=':'
334	>	for my_dir in $my_dir_list; do
335	>	IFS="$save_mkdir_p_IFS"
336	>	# mkdir can fail with a `File exist' error if two processes
337	>	# try to create one of the directories concurrently.  Don't
338	>	# stop in that case!
339	>	$MKDIR "$my_dir" 2>/dev/null || :
340	>	done
341	>	IFS="$save_mkdir_p_IFS"
342	>
343	>	# Bail out if we (or some other process) failed to create a directory.
344	>	test -d "$my_directory_path" || \
345	>	func_fatal_error "Failed to create \`$1'"
346	>	fi
347	>	}
348
152	–	#####################################
153	–	# Shell function definitions:
154	–	# This seems to be the best place for them
349
350		# func_mktempdir [string]
351		# Make a temporary directory that won't clash with other running
#	Line 161 | Line 355 | func_mktempdir ()
355		{
356		my_template="${TMPDIR-/tmp}/${1-$progname}"
357
358	<	if test "$run" = ":"; then
358	>	if test "$opt_dry_run" = ":"; then
359		# Return a directory name, but don't create it in dry-run mode
360		my_tmpdir="${my_template}-$$"
361		else
#	Line 170 | Line 364 | func_mktempdir ()
364		my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
365
366		if test ! -d "$my_tmpdir"; then
367	<	# Failing that, at least try and use $RANDOM to avoid a race
368	<	my_tmpdir="${my_template}-${RANDOM-0}$$"
367	>	# Failing that, at least try and use $RANDOM to avoid a race
368	>	my_tmpdir="${my_template}-${RANDOM-0}$$"
369
370	<	save_mktempdir_umask=`umask`
371	<	umask 0077
372	<	$mkdir "$my_tmpdir"
373	<	umask $save_mktempdir_umask
370	>	save_mktempdir_umask=`umask`
371	>	umask 0077
372	>	$MKDIR "$my_tmpdir"
373	>	umask $save_mktempdir_umask
374		fi
375
376		# If we're not in dry-run mode, bomb out on failure
377	<	test -d "$my_tmpdir" || {
378	<	$echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
185	<	exit $EXIT_FAILURE
186	<	}
377	>	test -d "$my_tmpdir" || \
378	>	func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
379		fi
380
381	<	$echo "X$my_tmpdir" | $Xsed
381	>	$ECHO "X$my_tmpdir" | $Xsed
382		}
383
384
385	<	# func_win32_libid arg
386	<	# return the library type of file 'arg'
387	<	#
388	<	# Need a lot of goo to handle *both* DLLs and import libs
389	<	# Has to be a shell function in order to 'eat' the argument
390	<	# that is supplied when $file_magic_command is called.
391	<	func_win32_libid ()
385	>	# func_quote_for_eval arg
386	>	# Aesthetically quote ARG to be evaled later.
387	>	# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
388	>	# is double-quoted, suitable for a subsequent eval, whereas
389	>	# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
390	>	# which are still active within double quotes backslashified.
391	>	func_quote_for_eval ()
392		{
393	<	win32_libid_type="unknown"
394	<	win32_fileres=`file -L $1 2>/dev/null`
395	<	case $win32_fileres in
396	<	*ar\ archive\ import\ library*) # definitely import
397	<	win32_libid_type="x86 archive import"
398	<	;;
399	<	*ar\ archive*) # could be an import, or static
400	<	if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
401	<	$EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
402	<	win32_nmres=`eval $NM -f posix -A $1 | \
403	<	$SED -n -e '1,100{
404	<	/ I /{
405	<	s,.*,import,
406	<	p
407	<	q
408	<	}
409	<	}'`
410	<	case $win32_nmres in
219	<	import*)  win32_libid_type="x86 archive import";;
220	<	*)        win32_libid_type="x86 archive static";;
221	<	esac
222	<	fi
223	<	;;
224	<	*DLL*)
225	<	win32_libid_type="x86 DLL"
226	<	;;
227	<	*executable*) # but shell scripts are "executable" too...
228	<	case $win32_fileres in
229	<	*MS\ Windows\ PE\ Intel*)
230	<	win32_libid_type="x86 DLL"
231	<	;;
393	>	case $1 in
394	>	*[\\\`\"\$]*)
395	>	func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
396	>	*)
397	>	func_quote_for_eval_unquoted_result="$1" ;;
398	>	esac
399	>
400	>	case $func_quote_for_eval_unquoted_result in
401	>	# Double-quote args containing shell metacharacters to delay
402	>	# word splitting, command substitution and and variable
403	>	# expansion for a subsequent eval.
404	>	# Many Bourne shells cannot handle close brackets correctly
405	>	# in scan sets, so we specify it separately.
406	>	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
407	>	func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
408	>	;;
409	>	*)
410	>	func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
411		esac
233	–	;;
234	–	esac
235	–	$echo $win32_libid_type
412		}
413
414
415	<	# func_infer_tag arg
416	<	# Infer tagged configuration to use if any are available and
417	<	# if one wasn't chosen via the "--tag" command line option.
418	<	# Only attempt this if the compiler in the base compile
243	<	# command doesn't match the default compiler.
244	<	# arg is usually of the form 'gcc ...'
245	<	func_infer_tag ()
415	>	# func_quote_for_expand arg
416	>	# Aesthetically quote ARG to be evaled later; same as above,
417	>	# but do not quote variable references.
418	>	func_quote_for_expand ()
419		{
420	<	if test -n "$available_tags" && test -z "$tagname"; then
421	<	CC_quoted=
422	<	for arg in $CC; do
423	<	case $arg in
251	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
252	<	arg="\"$arg\""
253	<	;;
254	<	esac
255	<	CC_quoted="$CC_quoted $arg"
256	<	done
257	<	case $@ in
258	<	# Blanks in the command may have been stripped by the calling shell,
259	<	# but not from the CC environment variable when configure was run.
260	<	" $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
261	<	# Blanks at the start of $base_compile will cause this to fail
262	<	# if we don't check for them as well.
420	>	case $1 in
421	>	*[\\\`\"]*)
422	>	my_arg=`$ECHO "X$1" | $Xsed \
423	>	-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
424		*)
425	<	for z in $available_tags; do
426	<	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
427	<	# Evaluate the configuration.
428	<	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
429	<	CC_quoted=
430	<	for arg in $CC; do
431	<	# Double-quote args containing other shell metacharacters.
432	<	case $arg in
433	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
434	<	arg="\"$arg\""
435	<	;;
436	<	esac
437	<	CC_quoted="$CC_quoted $arg"
438	<	done
278	<	case "$@ " in
279	<	" $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
280	<	# The compiler in the base compile command matches
281	<	# the one in the tagged configuration.
282	<	# Assume this is the tagged configuration we want.
283	<	tagname=$z
284	<	break
285	<	;;
286	<	esac
287	<	fi
288	<	done
289	<	# If $tagname still isn't set, then no tagged configuration
290	<	# was found and let the user know that the "--tag" command
291	<	# line option must be used.
292	<	if test -z "$tagname"; then
293	<	$echo "$modename: unable to infer tagged configuration"
294	<	$echo "$modename: specify a tag with \`--tag'" 1>&2
295	<	exit $EXIT_FAILURE
296	<	#        else
297	<	#          $echo "$modename: using $tagname tagged configuration"
298	<	fi
299	<	;;
300	<	esac
301	<	fi
425	>	my_arg="$1" ;;
426	>	esac
427	>
428	>	case $my_arg in
429	>	# Double-quote args containing shell metacharacters to delay
430	>	# word splitting and command substitution for a subsequent eval.
431	>	# Many Bourne shells cannot handle close brackets correctly
432	>	# in scan sets, so we specify it separately.
433	>	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
434	>	my_arg="\"$my_arg\""
435	>	;;
436	>	esac
437	>
438	>	func_quote_for_expand_result="$my_arg"
439		}
440
441
442	<	# func_extract_an_archive dir oldlib
443	<	func_extract_an_archive ()
442	>	# func_show_eval cmd [fail_exp]
443	>	# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
444	>	# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
445	>	# is given, then evaluate it.
446	>	func_show_eval ()
447		{
448	<	f_ex_an_ar_dir="$1"; shift
449	<	f_ex_an_ar_oldlib="$1"
448	>	my_cmd="$1"
449	>	my_fail_exp="${2-:}"
450
451	<	$show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
452	<	$run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
453	<	if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
454	<	:
455	<	else
456	<	$echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
457	<	exit $EXIT_FAILURE
451	>	${opt_silent-false} || {
452	>	func_quote_for_expand "$my_cmd"
453	>	eval "func_echo $func_quote_for_expand_result"
454	>	}
455	>
456	>	if ${opt_dry_run-false}; then :; else
457	>	eval "$my_cmd"
458	>	my_status=$?
459	>	if test "$my_status" -eq 0; then :; else
460	>	eval "(exit $my_status); $my_fail_exp"
461	>	fi
462		fi
463		}
464
465	<	# func_extract_archives gentop oldlib ...
466	<	func_extract_archives ()
465	>
466	>	# func_show_eval_locale cmd [fail_exp]
467	>	# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
468	>	# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
469	>	# is given, then evaluate it.  Use the saved locale for evaluation.
470	>	func_show_eval_locale ()
471		{
472	<	my_gentop="$1"; shift
473	<	my_oldlibs=${1+"$@"}
474	<	my_oldobjs=""
475	<	my_xlib=""
476	<	my_xabs=""
477	<	my_xdir=""
478	<	my_status=""
472	>	my_cmd="$1"
473	>	my_fail_exp="${2-:}"
474	>
475	>	${opt_silent-false} || {
476	>	func_quote_for_expand "$my_cmd"
477	>	eval "func_echo $func_quote_for_expand_result"
478	>	}
479
480	<	$show "${rm}r $my_gentop"
481	<	$run ${rm}r "$my_gentop"
482	<	$show "$mkdir $my_gentop"
483	<	$run $mkdir "$my_gentop"
484	<	my_status=$?
485	<	if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
486	<	exit $my_status
480	>	if ${opt_dry_run-false}; then :; else
481	>	eval "$lt_user_locale
482	>	$my_cmd"
483	>	my_status=$?
484	>	eval "$lt_safe_locale"
485	>	if test "$my_status" -eq 0; then :; else
486	>	eval "(exit $my_status); $my_fail_exp"
487	>	fi
488		fi
489	+	}
490
341	–	for my_xlib in $my_oldlibs; do
342	–	# Extract the objects.
343	–	case $my_xlib in
344	–	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
345	–	*) my_xabs=`pwd`"/$my_xlib" ;;
346	–	esac
347	–	my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
348	–	my_xlib_u=$my_xlib
349	–	while :; do
350	–	case " $extracted_archives " in
351	–	*" $my_xlib_u "*)
352	–	extracted_serial=`expr $extracted_serial + 1`
353	–	my_xlib_u=lt$extracted_serial-$my_xlib ;;
354	–	*) break ;;
355	–	esac
356	–	done
357	–	extracted_archives="$extracted_archives $my_xlib_u"
358	–	my_xdir="$my_gentop/$my_xlib_u"
491
492	<	$show "${rm}r $my_xdir"
493	<	$run ${rm}r "$my_xdir"
494	<	$show "$mkdir $my_xdir"
495	<	$run $mkdir "$my_xdir"
496	<	exit_status=$?
497	<	if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
498	<	exit $exit_status
499	<	fi
500	<	case $host in
501	<	*-darwin*)
502	<	$show "Extracting $my_xabs"
503	<	# Do not bother doing anything if just a dry run
504	<	if test -z "$run"; then
505	<	darwin_orig_dir=`pwd`
374	<	cd $my_xdir || exit $?
375	<	darwin_archive=$my_xabs
376	<	darwin_curdir=`pwd`
377	<	darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
378	<	darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
379	<	if test -n "$darwin_arches"; then
380	<	darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
381	<	darwin_arch=
382	<	$show "$darwin_base_archive has multiple architectures $darwin_arches"
383	<	for darwin_arch in  $darwin_arches ; do
384	<	mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
385	<	lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
386	<	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
387	<	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
388	<	cd "$darwin_curdir"
389	<	$rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
390	<	done # $darwin_arches
391	<	## Okay now we have a bunch of thin objects, gotta fatten them up :)
392	<	darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
393	<	darwin_file=
394	<	darwin_files=
395	<	for darwin_file in $darwin_filelist; do
396	<	darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
397	<	lipo -create -output "$darwin_file" $darwin_files
398	<	done # $darwin_filelist
399	<	${rm}r unfat-$$
400	<	cd "$darwin_orig_dir"
401	<	else
402	<	cd "$darwin_orig_dir"
403	<	func_extract_an_archive "$my_xdir" "$my_xabs"
404	<	fi # $darwin_arches
405	<	fi # $run
406	<	;;
407	<	*)
408	<	func_extract_an_archive "$my_xdir" "$my_xabs"
409	<	;;
410	<	esac
411	<	my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
412	<	done
413	<	func_extract_archives_result="$my_oldobjs"
492	>
493	>
494	>
495	>	# func_version
496	>	# Echo version message to standard output and exit.
497	>	func_version ()
498	>	{
499	>	$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
500	>	s/^# //
501	>	s/^# *$//
502	>	s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
503	>	p
504	>	}' < "$progpath"
505	>	exit $?
506		}
415	–	# End of Shell function definitions
416	–	#####################################
507
508	<	# Darwin sucks
509	<	eval std_shrext=\"$shrext_cmds\"
508	>	# func_usage
509	>	# Echo short help message to standard output and exit.
510	>	func_usage ()
511	>	{
512	>	$SED -n '/^# Usage:/,/# -h/ {
513	>	s/^# //
514	>	s/^# *$//
515	>	s/\$progname/'$progname'/
516	>	p
517	>	}' < "$progpath"
518	>	$ECHO
519	>	$ECHO "run \`$progname --help | more' for full usage"
520	>	exit $?
521	>	}
522
523	<	disable_libs=no
523	>	# func_help
524	>	# Echo long help message to standard output and exit.
525	>	func_help ()
526	>	{
527	>	$SED -n '/^# Usage:/,/# Report bugs to/ {
528	>	s/^# //
529	>	s/^# *$//
530	>	s*\$progname*'$progname'*
531	>	s*\$host*'"$host"'*
532	>	s*\$SHELL*'"$SHELL"'*
533	>	s*\$LTCC*'"$LTCC"'*
534	>	s*\$LTCFLAGS*'"$LTCFLAGS"'*
535	>	s*\$LD*'"$LD"'*
536	>	s/\$with_gnu_ld/'"$with_gnu_ld"'/
537	>	s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538	>	s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
539	>	p
540	>	}' < "$progpath"
541	>	exit $?
542	>	}
543
544	<	# Parse our command line options once, thoroughly.
545	<	while test "$#" -gt 0
546	<	do
547	<	arg="$1"
544	>	# func_missing_arg argname
545	>	# Echo program name prefixed message to standard error and set global
546	>	# exit_cmd.
547	>	func_missing_arg ()
548	>	{
549	>	func_error "missing argument for $1"
550	>	exit_cmd=exit
551	>	}
552	>
553	>	exit_cmd=:
554	>
555	>
556	>
557	>
558	>
559	>	# Check that we have a working $ECHO.
560	>	if test "X$1" = X--no-reexec; then
561	>	# Discard the --no-reexec flag, and continue.
562		shift
563	+	elif test "X$1" = X--fallback-echo; then
564	+	# Avoid inline document here, it may be left over
565	+	:
566	+	elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567	+	# Yippee, $ECHO works!
568	+	:
569	+	else
570	+	# Restart under the correct shell, and then maybe $ECHO will work.
571	+	exec $SHELL "$progpath" --no-reexec ${1+"$@"}
572	+	fi
573
574	<	case $arg in
575	<	-*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
576	<	*) optarg= ;;
577	<	esac
574	>	if test "X$1" = X--fallback-echo; then
575	>	# used as fallback echo
576	>	shift
577	>	cat <<EOF
578	>	$*
579	>	EOF
580	>	exit $EXIT_SUCCESS
581	>	fi
582
583	<	# If the previous option needs an argument, assign it.
584	<	if test -n "$prev"; then
436	<	case $prev in
437	<	execute_dlfiles)
438	<	execute_dlfiles="$execute_dlfiles $arg"
439	<	;;
440	<	tag)
441	<	tagname="$arg"
442	<	preserve_args="${preserve_args}=$arg"
443	<
444	<	# Check whether tagname contains only valid characters
445	<	case $tagname in
446	<	*[!-_A-Za-z0-9,/]*)
447	<	$echo "$progname: invalid tag name: $tagname" 1>&2
448	<	exit $EXIT_FAILURE
449	<	;;
450	<	esac
583	>	magic="%%%MAGIC variable%%%"
584	>	magic_exe="%%%MAGIC EXE variable%%%"
585
586	<	case $tagname in
587	<	CC)
588	<	# Don't test for the "default" C tag, as we know, it's there, but
589	<	# not specially marked.
590	<	;;
591	<	*)
592	<	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
593	<	taglist="$taglist $tagname"
594	<	# Evaluate the configuration.
461	<	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
462	<	else
463	<	$echo "$progname: ignoring unknown tag $tagname" 1>&2
464	<	fi
465	<	;;
466	<	esac
467	<	;;
468	<	*)
469	<	eval "$prev=\$arg"
470	<	;;
471	<	esac
586	>	# Global variables.
587	>	# $mode is unset
588	>	nonopt=
589	>	execute_dlfiles=
590	>	preserve_args=
591	>	lo2o="s/\\.lo\$/.${objext}/"
592	>	o2lo="s/\\.${objext}\$/.lo/"
593	>	extracted_archives=
594	>	extracted_serial=0
595
596	<	prev=
597	<	prevopt=
598	<	continue
599	<	fi
596	>	opt_dry_run=false
597	>	opt_duplicate_deps=false
598	>	opt_silent=false
599	>	opt_debug=:
600
601	<	# Have we seen a non-optional argument yet?
602	<	case $arg in
603	<	--help)
604	<	show_help=yes
482	<	;;
601	>	# If this variable is set in any of the actions, the command in it
602	>	# will be execed at the end.  This prevents here-documents from being
603	>	# left over by shells.
604	>	exec_cmd=
605
606	<	--version)
607	<	echo "\
608	<	$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
609	<
610	<	Copyright (C) 2007  Free Software Foundation, Inc.
611	<	This is free software; see the source for copying conditions.  There is NO
612	<	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
613	<	exit $?
614	<	;;
606	>	# func_fatal_configuration arg...
607	>	# Echo program name prefixed message to standard error, followed by
608	>	# a configuration failure hint, and exit.
609	>	func_fatal_configuration ()
610	>	{
611	>	func_error ${1+"$@"}
612	>	func_error "See the $PACKAGE documentation for more information."
613	>	func_fatal_error "Fatal configuration error."
614	>	}
615	>
616	>
617	>	# func_config
618	>	# Display the configuration for all the tags in this script.
619	>	func_config ()
620	>	{
621	>	re_begincf='^# ### BEGIN LIBTOOL'
622	>	re_endcf='^# ### END LIBTOOL'
623	>
624	>	# Default configuration.
625	>	$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
626
494	–	--config)
495	–	${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
627		# Now print the configurations for the tags.
628		for tagname in $taglist; do
629	<	${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
629	>	$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
630		done
500	–	exit $?
501	–	;;
631
632	<	--debug)
633	<	$echo "$progname: enabling shell trace mode"
505	<	set -x
506	<	preserve_args="$preserve_args $arg"
507	<	;;
508	<
509	<	--dry-run | -n)
510	<	run=:
511	<	;;
632	>	exit $?
633	>	}
634
635	<	--features)
636	<	$echo "host: $host"
635	>	# func_features
636	>	# Display the features supported by this script.
637	>	func_features ()
638	>	{
639	>	$ECHO "host: $host"
640		if test "$build_libtool_libs" = yes; then
641	<	$echo "enable shared libraries"
641	>	$ECHO "enable shared libraries"
642		else
643	<	$echo "disable shared libraries"
643	>	$ECHO "disable shared libraries"
644		fi
645		if test "$build_old_libs" = yes; then
646	<	$echo "enable static libraries"
646	>	$ECHO "enable static libraries"
647		else
648	<	$echo "disable static libraries"
648	>	$ECHO "disable static libraries"
649		fi
650	+
651		exit $?
652	<	;;
652	>	}
653
654	<	--finish) mode="finish" ;;
654	>	# func_enable_tag tagname
655	>	# Verify that TAGNAME is valid, and either flag an error and exit, or
656	>	# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
657	>	# variable here.
658	>	func_enable_tag ()
659	>	{
660	>	# Global variable:
661	>	tagname="$1"
662
663	<	--mode) prevopt="--mode" prev=mode ;;
664	<	--mode=*) mode="$optarg" ;;
663	>	re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
664	>	re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
665	>	sed_extractcf="/$re_begincf/,/$re_endcf/p"
666	>
667	>	# Validate tagname.
668	>	case $tagname in
669	>	*[!-_A-Za-z0-9,/]*)
670	>	func_fatal_error "invalid tag name: $tagname"
671	>	;;
672	>	esac
673
674	<	--preserve-dup-deps) duplicate_deps="yes" ;;
674	>	# Don't test for the "default" C tag, as we know it's
675	>	# there but not specially marked.
676	>	case $tagname in
677	>	CC) ;;
678	>	*)
679	>	if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
680	>	taglist="$taglist $tagname"
681
682	<	--quiet | --silent)
683	<	show=:
684	<	preserve_args="$preserve_args $arg"
685	<	;;
682	>	# Evaluate the configuration.  Be careful to quote the path
683	>	# and the sed script, to avoid splitting on whitespace, but
684	>	# also don't use non-portable quotes within backquotes within
685	>	# quotes we have to do it in 2 steps:
686	>	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
687	>	eval "$extractedcf"
688	>	else
689	>	func_error "ignoring unknown tag $tagname"
690	>	fi
691	>	;;
692	>	esac
693	>	}
694	>
695	>	# Parse options once, thoroughly.  This comes as soon as possible in
696	>	# the script to make things like `libtool --version' happen quickly.
697	>	{
698
699	<	--tag)
700	<	prevopt="--tag"
701	<	prev=tag
702	<	preserve_args="$preserve_args --tag"
699	>	# Shorthand for --mode=foo, only valid as the first argument
700	>	case $1 in
701	>	clean|clea|cle|cl)
702	>	shift; set dummy --mode clean ${1+"$@"}; shift
703		;;
704	<	--tag=*)
705	<	set tag "$optarg" ${1+"$@"}
547	<	shift
548	<	prev=tag
549	<	preserve_args="$preserve_args --tag"
704	>	compile|compil|compi|comp|com|co|c)
705	>	shift; set dummy --mode compile ${1+"$@"}; shift
706		;;
707	<
708	<	-dlopen)
553	<	prevopt="-dlopen"
554	<	prev=execute_dlfiles
707	>	execute|execut|execu|exec|exe|ex|e)
708	>	shift; set dummy --mode execute ${1+"$@"}; shift
709		;;
710	<
711	<	-*)
558	<	$echo "$modename: unrecognized option \`$arg'" 1>&2
559	<	$echo "$help" 1>&2
560	<	exit $EXIT_FAILURE
710	>	finish|finis|fini|fin|fi|f)
711	>	shift; set dummy --mode finish ${1+"$@"}; shift
712		;;
713	<
714	<	*)
715	<	nonopt="$arg"
716	<	break
713	>	install|instal|insta|inst|ins|in|i)
714	>	shift; set dummy --mode install ${1+"$@"}; shift
715	>	;;
716	>	link|lin|li|l)
717	>	shift; set dummy --mode link ${1+"$@"}; shift
718	>	;;
719	>	uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720	>	shift; set dummy --mode uninstall ${1+"$@"}; shift
721		;;
722		esac
568	–	done
723
724	<	if test -n "$prevopt"; then
725	<	$echo "$modename: option \`$prevopt' requires an argument" 1>&2
726	<	$echo "$help" 1>&2
727	<	exit $EXIT_FAILURE
574	<	fi
724	>	# Parse non-mode specific arguments:
725	>	while test "$#" -gt 0; do
726	>	opt="$1"
727	>	shift
728
729	<	case $disable_libs in
730	<	no)
578	<	;;
579	<	shared)
580	<	build_libtool_libs=no
581	<	build_old_libs=yes
582	<	;;
583	<	static)
584	<	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
585	<	;;
586	<	esac
729	>	case $opt in
730	>	--config)         func_config                                     ;;
731
732	<	# If this variable is set in any of the actions, the command in it
733	<	# will be execed at the end.  This prevents here-documents from being
734	<	# left over by shells.
735	<	exec_cmd=
732	>	--debug)          preserve_args="$preserve_args $opt"
733	>	func_echo "enabling shell trace mode"
734	>	opt_debug='set -x'
735	>	$opt_debug
736	>	;;
737
738	<	if test -z "$show_help"; then
738	>	-dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
739	>	execute_dlfiles="$execute_dlfiles $1"
740	>	shift
741	>	;;
742
743	<	# Infer the operation mode.
744	<	if test -z "$mode"; then
745	<	$echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
746	<	$echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
747	<	case $nonopt in
748	<	*cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
749	<	mode=link
750	<	for arg
751	<	do
752	<	case $arg in
753	<	-c)
754	<	mode=compile
755	<	break
756	<	;;
757	<	esac
758	<	done
759	<	;;
760	<	*db | *dbx | *strace | *truss)
761	<	mode=execute
762	<	;;
763	<	*install*|cp|mv)
764	<	mode=install
765	<	;;
766	<	*rm)
767	<	mode=uninstall
743	>	--dry-run | -n)   opt_dry_run=:                                   ;;
744	>	--features)       func_features                                   ;;
745	>	--finish)         mode="finish"                                   ;;
746	>
747	>	--mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
748	>	case $1 in
749	>	# Valid mode arguments:
750	>	clean)        ;;
751	>	compile)      ;;
752	>	execute)      ;;
753	>	finish)       ;;
754	>	install)      ;;
755	>	link)         ;;
756	>	relink)       ;;
757	>	uninstall)    ;;
758	>
759	>	# Catch anything else as an error
760	>	*) func_error "invalid argument for $opt"
761	>	exit_cmd=exit
762	>	break
763	>	;;
764	>	esac
765	>
766	>	mode="$1"
767	>	shift
768	>	;;
769	>
770	>	--preserve-dup-deps)
771	>	opt_duplicate_deps=:                            ;;
772	>
773	>	--quiet|--silent) preserve_args="$preserve_args $opt"
774	>	opt_silent=:
775	>	;;
776	>
777	>	--verbose| -v)    preserve_args="$preserve_args $opt"
778	>	opt_silent=false
779	>	;;
780	>
781	>	--tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
782	>	preserve_args="$preserve_args $opt $1"
783	>	func_enable_tag "$1"    # tagname is set here
784	>	shift
785	>	;;
786	>
787	>	# Separate optargs to long options:
788	>	-dlopen=*|--mode=*|--tag=*)
789	>	func_opt_split "$opt"
790	>	set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
791	>	shift
792	>	;;
793	>
794	>	-\?|-h)           func_usage                                      ;;
795	>	--help)           opt_help=:                                      ;;
796	>	--version)        func_version                                    ;;
797	>
798	>	-*)               func_fatal_help "unrecognized option \`$opt'"   ;;
799	>
800	>	*)                nonopt="$opt"
801	>	break
802	>	;;
803	>	esac
804	>	done
805	>
806	>
807	>	case $host in
808	>	*cygwin* | *mingw* | *pw32* | *cegcc*)
809	>	# don't eliminate duplications in $postdeps and $predeps
810	>	opt_duplicate_compiler_generated_deps=:
811		;;
812		*)
813	<	# If we have no mode, but dlfiles were specified, then do execute mode.
814	<	test -n "$execute_dlfiles" && mode=execute
813	>	opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
814	>	;;
815	>	esac
816
817	<	# Just use the default operation mode.
818	<	if test -z "$mode"; then
819	<	if test -n "$nonopt"; then
820	<	$echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
821	<	else
822	<	$echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
823	<	fi
817	>	# Having warned about all mis-specified options, bail out if
818	>	# anything was wrong.
819	>	$exit_cmd $EXIT_FAILURE
820	>	}
821	>
822	>	# func_check_version_match
823	>	# Ensure that we are using m4 macros, and libtool script from the same
824	>	# release of libtool.
825	>	func_check_version_match ()
826	>	{
827	>	if test "$package_revision" != "$macro_revision"; then
828	>	if test "$VERSION" != "$macro_version"; then
829	>	if test -z "$macro_version"; then
830	>	cat >&2 <<_LT_EOF
831	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
832	>	$progname: definition of this LT_INIT comes from an older release.
833	>	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
834	>	$progname: and run autoconf again.
835	>	_LT_EOF
836	>	else
837	>	cat >&2 <<_LT_EOF
838	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
839	>	$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
840	>	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
841	>	$progname: and run autoconf again.
842	>	_LT_EOF
843		fi
844	<	;;
845	<	esac
844	>	else
845	>	cat >&2 <<_LT_EOF
846	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
847	>	$progname: but the definition of this LT_INIT comes from revision $macro_revision.
848	>	$progname: You should recreate aclocal.m4 with macros from revision $package_revision
849	>	$progname: of $PACKAGE $VERSION and run autoconf again.
850	>	_LT_EOF
851	>	fi
852	>
853	>	exit $EXIT_MISMATCH
854	>	fi
855	>	}
856	>
857	>
858	>	## ----------- ##
859	>	##    Main.    ##
860	>	## ----------- ##
861	>
862	>	$opt_help || {
863	>	# Sanity checks first:
864	>	func_check_version_match
865	>
866	>	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
867	>	func_fatal_configuration "not configured to build any kind of library"
868		fi
869
870	+	test -z "$mode" && func_fatal_error "error: you must specify a MODE."
871	+
872	+
873	+	# Darwin sucks
874	+	eval std_shrext=\"$shrext_cmds\"
875	+
876	+
877		# Only execute mode is allowed to have -dlopen flags.
878		if test -n "$execute_dlfiles" && test "$mode" != execute; then
879	<	$echo "$modename: unrecognized option \`-dlopen'" 1>&2
880	<	$echo "$help" 1>&2
879	>	func_error "unrecognized option \`-dlopen'"
880	>	$ECHO "$help" 1>&2
881		exit $EXIT_FAILURE
882		fi
883
884		# Change the help message to a mode-specific one.
885		generic_help="$help"
886	<	help="Try \`$modename --help --mode=$mode' for more information."
886	>	help="Try \`$progname --help --mode=$mode' for more information."
887	>	}
888	>
889	>
890	>	# func_lalib_p file
891	>	# True iff FILE is a libtool `.la' library or `.lo' object file.
892	>	# This function is only a basic sanity check; it will hardly flush out
893	>	# determined imposters.
894	>	func_lalib_p ()
895	>	{
896	>	test -f "$1" &&
897	>	$SED -e 4q "$1" 2>/dev/null \
898	>	| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
899	>	}
900	>
901	>	# func_lalib_unsafe_p file
902	>	# True iff FILE is a libtool `.la' library or `.lo' object file.
903	>	# This function implements the same check as func_lalib_p without
904	>	# resorting to external programs.  To this end, it redirects stdin and
905	>	# closes it afterwards, without saving the original file descriptor.
906	>	# As a safety measure, use it only where a negative result would be
907	>	# fatal anyway.  Works if `file' does not exist.
908	>	func_lalib_unsafe_p ()
909	>	{
910	>	lalib_p=no
911	>	if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
912	>	for lalib_p_l in 1 2 3 4
913	>	do
914	>	read lalib_p_line
915	>	case "$lalib_p_line" in
916	>	\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
917	>	esac
918	>	done
919	>	exec 0<&5 5<&-
920	>	fi
921	>	test "$lalib_p" = yes
922	>	}
923	>
924	>	# func_ltwrapper_script_p file
925	>	# True iff FILE is a libtool wrapper script
926	>	# This function is only a basic sanity check; it will hardly flush out
927	>	# determined imposters.
928	>	func_ltwrapper_script_p ()
929	>	{
930	>	func_lalib_p "$1"
931	>	}
932	>
933	>	# func_ltwrapper_executable_p file
934	>	# True iff FILE is a libtool wrapper executable
935	>	# This function is only a basic sanity check; it will hardly flush out
936	>	# determined imposters.
937	>	func_ltwrapper_executable_p ()
938	>	{
939	>	func_ltwrapper_exec_suffix=
940	>	case $1 in
941	>	*.exe) ;;
942	>	*) func_ltwrapper_exec_suffix=.exe ;;
943	>	esac
944	>	$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
945	>	}
946	>
947	>	# func_ltwrapper_scriptname file
948	>	# Assumes file is an ltwrapper_executable
949	>	# uses $file to determine the appropriate filename for a
950	>	# temporary ltwrapper_script.
951	>	func_ltwrapper_scriptname ()
952	>	{
953	>	func_ltwrapper_scriptname_result=""
954	>	if func_ltwrapper_executable_p "$1"; then
955	>	func_dirname_and_basename "$1" "" "."
956	>	func_stripname '' '.exe' "$func_basename_result"
957	>	func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
958	>	fi
959	>	}
960	>
961	>	# func_ltwrapper_p file
962	>	# True iff FILE is a libtool wrapper script or wrapper executable
963	>	# This function is only a basic sanity check; it will hardly flush out
964	>	# determined imposters.
965	>	func_ltwrapper_p ()
966	>	{
967	>	func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
968	>	}
969	>
970	>
971	>	# func_execute_cmds commands fail_cmd
972	>	# Execute tilde-delimited COMMANDS.
973	>	# If FAIL_CMD is given, eval that upon failure.
974	>	# FAIL_CMD may read-access the current command in variable CMD!
975	>	func_execute_cmds ()
976	>	{
977	>	$opt_debug
978	>	save_ifs=$IFS; IFS='~'
979	>	for cmd in $1; do
980	>	IFS=$save_ifs
981	>	eval cmd=\"$cmd\"
982	>	func_show_eval "$cmd" "${2-:}"
983	>	done
984	>	IFS=$save_ifs
985	>	}
986	>
987	>
988	>	# func_source file
989	>	# Source FILE, adding directory component if necessary.
990	>	# Note that it is not necessary on cygwin/mingw to append a dot to
991	>	# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
992	>	# behavior happens only for exec(3), not for open(2)!  Also, sourcing
993	>	# `FILE.' does not work on cygwin managed mounts.
994	>	func_source ()
995	>	{
996	>	$opt_debug
997	>	case $1 in
998	>	*/* | *\\*) . "$1" ;;
999	>	*)          . "./$1" ;;
1000	>	esac
1001	>	}
1002	>
1003	>
1004	>	# func_infer_tag arg
1005	>	# Infer tagged configuration to use if any are available and
1006	>	# if one wasn't chosen via the "--tag" command line option.
1007	>	# Only attempt this if the compiler in the base compile
1008	>	# command doesn't match the default compiler.
1009	>	# arg is usually of the form 'gcc ...'
1010	>	func_infer_tag ()
1011	>	{
1012	>	$opt_debug
1013	>	if test -n "$available_tags" && test -z "$tagname"; then
1014	>	CC_quoted=
1015	>	for arg in $CC; do
1016	>	func_quote_for_eval "$arg"
1017	>	CC_quoted="$CC_quoted $func_quote_for_eval_result"
1018	>	done
1019	>	case $@ in
1020	>	# Blanks in the command may have been stripped by the calling shell,
1021	>	# but not from the CC environment variable when configure was run.
1022	>	" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1023	>	# Blanks at the start of $base_compile will cause this to fail
1024	>	# if we don't check for them as well.
1025	>	*)
1026	>	for z in $available_tags; do
1027	>	if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1028	>	# Evaluate the configuration.
1029	>	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1030	>	CC_quoted=
1031	>	for arg in $CC; do
1032	>	# Double-quote args containing other shell metacharacters.
1033	>	func_quote_for_eval "$arg"
1034	>	CC_quoted="$CC_quoted $func_quote_for_eval_result"
1035	>	done
1036	>	case "$@ " in
1037	>	" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1038	>	# The compiler in the base compile command matches
1039	>	# the one in the tagged configuration.
1040	>	# Assume this is the tagged configuration we want.
1041	>	tagname=$z
1042	>	break
1043	>	;;
1044	>	esac
1045	>	fi
1046	>	done
1047	>	# If $tagname still isn't set, then no tagged configuration
1048	>	# was found and let the user know that the "--tag" command
1049	>	# line option must be used.
1050	>	if test -z "$tagname"; then
1051	>	func_echo "unable to infer tagged configuration"
1052	>	func_fatal_error "specify a tag with \`--tag'"
1053	>	#       else
1054	>	#         func_verbose "using $tagname tagged configuration"
1055	>	fi
1056	>	;;
1057	>	esac
1058	>	fi
1059	>	}
1060	>
1061	>
1062	>
1063	>	# func_write_libtool_object output_name pic_name nonpic_name
1064	>	# Create a libtool object file (analogous to a ".la" file),
1065	>	# but don't create it if we're doing a dry run.
1066	>	func_write_libtool_object ()
1067	>	{
1068	>	write_libobj=${1}
1069	>	if test "$build_libtool_libs" = yes; then
1070	>	write_lobj=\'${2}\'
1071	>	else
1072	>	write_lobj=none
1073	>	fi
1074	>
1075	>	if test "$build_old_libs" = yes; then
1076	>	write_oldobj=\'${3}\'
1077	>	else
1078	>	write_oldobj=none
1079	>	fi
1080	>
1081	>	$opt_dry_run || {
1082	>	cat >${write_libobj}T <<EOF
1083	>	# $write_libobj - a libtool object file
1084	>	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1085	>	#
1086	>	# Please DO NOT delete this file!
1087	>	# It is necessary for linking the library.
1088	>
1089	>	# Name of the PIC object.
1090	>	pic_object=$write_lobj
1091	>
1092	>	# Name of the non-PIC object
1093	>	non_pic_object=$write_oldobj
1094	>
1095	>	EOF
1096	>	$MV "${write_libobj}T" "${write_libobj}"
1097	>	}
1098	>	}
1099
1100	<	# These modes are in order of execution frequency so that they run quickly.
1101	<	case $mode in
1102	<	# libtool compile mode
1103	<	compile)
652	<	modename="$modename: compile"
1100	>	# func_mode_compile arg...
1101	>	func_mode_compile ()
1102	>	{
1103	>	$opt_debug
1104		# Get the compilation command and the source file.
1105		base_compile=
1106		srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
#	Line 658 | Line 1109 | if test -z "$show_help"; then
1109		arg_mode=normal
1110		libobj=
1111		later=
1112	+	pie_flag=
1113
1114		for arg
1115		do
#	Line 678 | Line 1130 | if test -z "$show_help"; then
1130		# Accept any command-line options.
1131		case $arg in
1132		-o)
1133	<	if test -n "$libobj" ; then
1134	<	$echo "$modename: you cannot specify \`-o' more than once" 1>&2
683	<	exit $EXIT_FAILURE
684	<	fi
1133	>	test -n "$libobj" && \
1134	>	func_fatal_error "you cannot specify \`-o' more than once"
1135		arg_mode=target
1136		continue
1137		;;
1138
1139	<	-static | -prefer-pic | -prefer-non-pic)
1139	>	-pie | -fpie | -fPIE)
1140	>	pie_flag="$pie_flag $arg"
1141	>	continue
1142	>	;;
1143	>
1144	>	-shared | -static | -prefer-pic | -prefer-non-pic)
1145		later="$later $arg"
1146		continue
1147		;;
#	Line 702 | Line 1157 | if test -z "$show_help"; then
1157		;;            #  replaced later.  I would guess that would be a bug.
1158
1159		-Wc,*)
1160	<	args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
1160	>	func_stripname '-Wc,' '' "$arg"
1161	>	args=$func_stripname_result
1162		lastarg=
1163		save_ifs="$IFS"; IFS=','
1164	<	for arg in $args; do
1164	>	for arg in $args; do
1165		IFS="$save_ifs"
1166	<
1167	<	# Double-quote args containing other shell metacharacters.
712	<	# Many Bourne shells cannot handle close brackets correctly
713	<	# in scan sets, so we specify it separately.
714	<	case $arg in
715	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
716	<	arg="\"$arg\""
717	<	;;
718	<	esac
719	<	lastarg="$lastarg $arg"
1166	>	func_quote_for_eval "$arg"
1167	>	lastarg="$lastarg $func_quote_for_eval_result"
1168		done
1169		IFS="$save_ifs"
1170	<	lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
1170	>	func_stripname ' ' '' "$lastarg"
1171	>	lastarg=$func_stripname_result
1172
1173		# Add the arguments to base_compile.
1174		base_compile="$base_compile $lastarg"
1175		continue
1176		;;
1177
1178	<	* )
1178	>	*)
1179		# Accept the current argument as the source file.
1180		# The previous "srcfile" becomes the current argument.
1181		#
#	Line 738 | Line 1187 | if test -z "$show_help"; then
1187		esac    #  case $arg_mode
1188
1189		# Aesthetically quote the previous argument.
1190	<	lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
1191	<
743	<	case $lastarg in
744	<	# Double-quote args containing other shell metacharacters.
745	<	# Many Bourne shells cannot handle close brackets correctly
746	<	# in scan sets, and some SunOS ksh mistreat backslash-escaping
747	<	# in scan sets (worked around with variable expansion),
748	<	# and furthermore cannot handle '|' '&' '(' ')' in scan sets
749	<	# at all, so we specify them separately.
750	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
751	<	lastarg="\"$lastarg\""
752	<	;;
753	<	esac
754	<
755	<	base_compile="$base_compile $lastarg"
1190	>	func_quote_for_eval "$lastarg"
1191	>	base_compile="$base_compile $func_quote_for_eval_result"
1192		done # for arg
1193
1194		case $arg_mode in
1195		arg)
1196	<	$echo "$modename: you must specify an argument for -Xcompile"
761	<	exit $EXIT_FAILURE
1196	>	func_fatal_error "you must specify an argument for -Xcompile"
1197		;;
1198		target)
1199	<	$echo "$modename: you must specify a target with \`-o'" 1>&2
765	<	exit $EXIT_FAILURE
1199	>	func_fatal_error "you must specify a target with \`-o'"
1200		;;
1201		*)
1202		# Get the name of the library object.
1203	<	[ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
1203	>	test -z "$libobj" && {
1204	>	func_basename "$srcfile"
1205	>	libobj="$func_basename_result"
1206	>	}
1207		;;
1208		esac
1209
1210		# Recognize several different file suffixes.
1211		# If the user specifies -o file.o, it is replaced with file.lo
775	–	xform='[cCFSifmso]'
1212		case $libobj in
1213	<	*.ada) xform=ada ;;
1214	<	*.adb) xform=adb ;;
1215	<	*.ads) xform=ads ;;
1216	<	*.asm) xform=asm ;;
1217	<	*.c++) xform=c++ ;;
1218	<	*.cc) xform=cc ;;
1219	<	*.ii) xform=ii ;;
784	<	*.class) xform=class ;;
785	<	*.cpp) xform=cpp ;;
786	<	*.cxx) xform=cxx ;;
787	<	*.[fF][09]?) xform=[fF][09]. ;;
788	<	*.for) xform=for ;;
789	<	*.java) xform=java ;;
790	<	*.obj) xform=obj ;;
1213	>	*.[cCFSifmso] | \
1214	>	*.ada | *.adb | *.ads | *.asm | \
1215	>	*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1216	>	*.[fF][09]? | *.for | *.java | *.obj | *.sx)
1217	>	func_xform "$libobj"
1218	>	libobj=$func_xform_result
1219	>	;;
1220		esac
1221
793	–	libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
794	–
1222		case $libobj in
1223	<	*.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
1223	>	*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1224		*)
1225	<	$echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
799	<	exit $EXIT_FAILURE
1225	>	func_fatal_error "cannot determine name of library object from \`$libobj'"
1226		;;
1227		esac
1228
#	Line 804 | Line 1230 | if test -z "$show_help"; then
1230
1231		for arg in $later; do
1232		case $arg in
1233	+	-shared)
1234	+	test "$build_libtool_libs" != yes && \
1235	+	func_fatal_configuration "can not build a shared library"
1236	+	build_old_libs=no
1237	+	continue
1238	+	;;
1239	+
1240		-static)
1241	+	build_libtool_libs=no
1242		build_old_libs=yes
1243		continue
1244		;;
#	Line 821 | Line 1255 | if test -z "$show_help"; then
1255		esac
1256		done
1257
1258	<	qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
1259	<	case $qlibobj in
1260	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1261	<	qlibobj="\"$qlibobj\"" ;;
1262	<	esac
1263	<	test "X$libobj" != "X$qlibobj" \
1264	<	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
831	<	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
832	<	objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
833	<	xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
834	<	if test "X$xdir" = "X$obj"; then
835	<	xdir=
836	<	else
837	<	xdir=$xdir/
838	<	fi
1258	>	func_quote_for_eval "$libobj"
1259	>	test "X$libobj" != "X$func_quote_for_eval_result" \
1260	>	&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1261	>	&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1262	>	func_dirname_and_basename "$obj" "/" ""
1263	>	objname="$func_basename_result"
1264	>	xdir="$func_dirname_result"
1265		lobj=${xdir}$objdir/$objname
1266
1267	<	if test -z "$base_compile"; then
1268	<	$echo "$modename: you must specify a compilation command" 1>&2
843	<	$echo "$help" 1>&2
844	<	exit $EXIT_FAILURE
845	<	fi
1267	>	test -z "$base_compile" && \
1268	>	func_fatal_help "you must specify a compilation command"
1269
1270		# Delete any leftover library objects.
1271		if test "$build_old_libs" = yes; then
#	Line 851 | Line 1274 | if test -z "$show_help"; then
1274		removelist="$lobj $libobj ${libobj}T"
1275		fi
1276
854	–	$run $rm $removelist
855	–	trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
856	–
1277		# On Cygwin there's no "real" PIC flag so we must build both object types
1278		case $host_os in
1279	<	cygwin* | mingw* | pw32* | os2*)
1279	>	cygwin* | mingw* | pw32* | os2* | cegcc*)
1280		pic_mode=default
1281		;;
1282		esac
#	Line 868 | Line 1288 | if test -z "$show_help"; then
1288		# Calculate the filename of the output object if compiler does
1289		# not support -o with -c
1290		if test "$compiler_c_o" = no; then
1291	<	output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1291	>	output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1292		lockfile="$output_obj.lock"
873	–	removelist="$removelist $output_obj $lockfile"
874	–	trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
1293		else
1294		output_obj=
1295		need_locks=no
#	Line 881 | Line 1299 | if test -z "$show_help"; then
1299		# Lock this critical section if it is needed
1300		# We use this script file to make the link, it avoids creating a new file
1301		if test "$need_locks" = yes; then
1302	<	until $run ln "$progpath" "$lockfile" 2>/dev/null; do
1303	<	$show "Waiting for $lockfile to be removed"
1302	>	until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1303	>	func_echo "Waiting for $lockfile to be removed"
1304		sleep 2
1305		done
1306		elif test "$need_locks" = warn; then
1307		if test -f "$lockfile"; then
1308	<	$echo "\
1308	>	$ECHO "\
1309		*** ERROR, $lockfile exists and contains:
1310		`cat $lockfile 2>/dev/null`
1311
#	Line 898 | Line 1316 | repeat this compilation, it may succeed,
1316		avoid parallel builds (make -j) in this platform, or get a better
1317		compiler."
1318
1319	<	$run $rm $removelist
1319	>	$opt_dry_run || $RM $removelist
1320		exit $EXIT_FAILURE
1321		fi
1322	<	$echo "$srcfile" > "$lockfile"
1322	>	removelist="$removelist $output_obj"
1323	>	$ECHO "$srcfile" > "$lockfile"
1324		fi
1325
1326	+	$opt_dry_run || $RM $removelist
1327	+	removelist="$removelist $lockfile"
1328	+	trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1329	+
1330		if test -n "$fix_srcfile_path"; then
1331		eval srcfile=\"$fix_srcfile_path\"
1332		fi
1333	<	qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
1334	<	case $qsrcfile in
912	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
913	<	qsrcfile="\"$qsrcfile\"" ;;
914	<	esac
915	<
916	<	$run $rm "$libobj" "${libobj}T"
917	<
918	<	# Create a libtool object file (analogous to a ".la" file),
919	<	# but don't create it if we're doing a dry run.
920	<	test -z "$run" && cat > ${libobj}T <<EOF
921	<	# $libobj - a libtool object file
922	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
923	<	#
924	<	# Please DO NOT delete this file!
925	<	# It is necessary for linking the library.
926	<
927	<	# Name of the PIC object.
928	<	EOF
1333	>	func_quote_for_eval "$srcfile"
1334	>	qsrcfile=$func_quote_for_eval_result
1335
1336		# Only build a PIC object if we are building libtool libraries.
1337		if test "$build_libtool_libs" = yes; then
#	Line 939 | Line 1345 | EOF
1345		command="$base_compile $qsrcfile"
1346		fi
1347
1348	<	if test ! -d "${xdir}$objdir"; then
943	<	$show "$mkdir ${xdir}$objdir"
944	<	$run $mkdir ${xdir}$objdir
945	<	exit_status=$?
946	<	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
947	<	exit $exit_status
948	<	fi
949	<	fi
1348	>	func_mkdir_p "$xdir$objdir"
1349
1350		if test -z "$output_obj"; then
1351		# Place PIC objects in $objdir
1352		command="$command -o $lobj"
1353		fi
1354
1355	<	$run $rm "$lobj" "$output_obj"
1356	<
958	<	$show "$command"
959	<	if $run eval "$command"; then :
960	<	else
961	<	test -n "$output_obj" && $run $rm $removelist
962	<	exit $EXIT_FAILURE
963	<	fi
1355	>	func_show_eval_locale "$command"  \
1356	>	'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1357
1358		if test "$need_locks" = warn &&
1359		test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1360	<	$echo "\
1360	>	$ECHO "\
1361		*** ERROR, $lockfile contains:
1362		`cat $lockfile 2>/dev/null`
1363
#	Line 978 | Line 1371 | repeat this compilation, it may succeed,
1371		avoid parallel builds (make -j) in this platform, or get a better
1372		compiler."
1373
1374	<	$run $rm $removelist
1374	>	$opt_dry_run || $RM $removelist
1375		exit $EXIT_FAILURE
1376		fi
1377
1378		# Just move the object if needed, then go on to compile the next one
1379		if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1380	<	$show "$mv $output_obj $lobj"
1381	<	if $run $mv $output_obj $lobj; then :
989	<	else
990	<	error=$?
991	<	$run $rm $removelist
992	<	exit $error
993	<	fi
1380	>	func_show_eval '$MV "$output_obj" "$lobj"' \
1381	>	'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1382		fi
1383
996	–	# Append the name of the PIC object to the libtool object file.
997	–	test -z "$run" && cat >> ${libobj}T <<EOF
998	–	pic_object='$objdir/$objname'
999	–
1000	–	EOF
1001	–
1384		# Allow error messages only from the first compilation.
1385		if test "$suppress_opt" = yes; then
1386	<	suppress_output=' >/dev/null 2>&1'
1386	>	suppress_output=' >/dev/null 2>&1'
1387		fi
1006	–	else
1007	–	# No PIC object so indicate it doesn't exist in the libtool
1008	–	# object file.
1009	–	test -z "$run" && cat >> ${libobj}T <<EOF
1010	–	pic_object=none
1011	–
1012	–	EOF
1388		fi
1389
1390		# Only build a position-dependent object if we build old libraries.
1391		if test "$build_old_libs" = yes; then
1392		if test "$pic_mode" != yes; then
1393		# Don't build PIC code
1394	<	command="$base_compile $qsrcfile"
1394	>	command="$base_compile $qsrcfile$pie_flag"
1395		else
1396		command="$base_compile $qsrcfile $pic_flag"
1397		fi
#	Line 1026 | Line 1401 | EOF
1401
1402		# Suppress compiler output if we already did a PIC compilation.
1403		command="$command$suppress_output"
1404	<	$run $rm "$obj" "$output_obj"
1405	<	$show "$command"
1031	<	if $run eval "$command"; then :
1032	<	else
1033	<	$run $rm $removelist
1034	<	exit $EXIT_FAILURE
1035	<	fi
1404	>	func_show_eval_locale "$command" \
1405	>	'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1406
1407		if test "$need_locks" = warn &&
1408		test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1409	<	$echo "\
1409	>	$ECHO "\
1410		*** ERROR, $lockfile contains:
1411		`cat $lockfile 2>/dev/null`
1412
#	Line 1050 | Line 1420 | repeat this compilation, it may succeed,
1420		avoid parallel builds (make -j) in this platform, or get a better
1421		compiler."
1422
1423	<	$run $rm $removelist
1423	>	$opt_dry_run || $RM $removelist
1424		exit $EXIT_FAILURE
1425		fi
1426
1427		# Just move the object if needed
1428		if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1429	<	$show "$mv $output_obj $obj"
1430	<	if $run $mv $output_obj $obj; then :
1429	>	func_show_eval '$MV "$output_obj" "$obj"' \
1430	>	'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1431	>	fi
1432	>	fi
1433	>
1434	>	$opt_dry_run || {
1435	>	func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1436	>
1437	>	# Unlock the critical section if it was locked
1438	>	if test "$need_locks" != no; then
1439	>	removelist=$lockfile
1440	>	$RM "$lockfile"
1441	>	fi
1442	>	}
1443	>
1444	>	exit $EXIT_SUCCESS
1445	>	}
1446	>
1447	>	$opt_help || {
1448	>	test "$mode" = compile && func_mode_compile ${1+"$@"}
1449	>	}
1450	>
1451	>	func_mode_help ()
1452	>	{
1453	>	# We need to display help for each of the modes.
1454	>	case $mode in
1455	>	"")
1456	>	# Generic help is extracted from the usage comments
1457	>	# at the start of this file.
1458	>	func_help
1459	>	;;
1460	>
1461	>	clean)
1462	>	$ECHO \
1463	>	"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1464	>
1465	>	Remove files from the build directory.
1466	>
1467	>	RM is the name of the program to use to delete files associated with each FILE
1468	>	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1469	>	to RM.
1470	>
1471	>	If FILE is a libtool library, object or program, all the files associated
1472	>	with it are deleted. Otherwise, only FILE itself is deleted using RM."
1473	>	;;
1474	>
1475	>	compile)
1476	>	$ECHO \
1477	>	"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1478	>
1479	>	Compile a source file into a libtool library object.
1480	>
1481	>	This mode accepts the following additional options:
1482	>
1483	>	-o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1484	>	-no-suppress      do not suppress compiler output for multiple passes
1485	>	-prefer-pic       try to building PIC objects only
1486	>	-prefer-non-pic   try to building non-PIC objects only
1487	>	-shared           do not build a \`.o' file suitable for static linking
1488	>	-static           only build a \`.o' file suitable for static linking
1489	>
1490	>	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1491	>	from the given SOURCEFILE.
1492	>
1493	>	The output file name is determined by removing the directory component from
1494	>	SOURCEFILE, then substituting the C source code suffix \`.c' with the
1495	>	library object suffix, \`.lo'."
1496	>	;;
1497	>
1498	>	execute)
1499	>	$ECHO \
1500	>	"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1501	>
1502	>	Automatically set library path, then run a program.
1503	>
1504	>	This mode accepts the following additional options:
1505	>
1506	>	-dlopen FILE      add the directory containing FILE to the library path
1507	>
1508	>	This mode sets the library path environment variable according to \`-dlopen'
1509	>	flags.
1510	>
1511	>	If any of the ARGS are libtool executable wrappers, then they are translated
1512	>	into their corresponding uninstalled binary, and any of their required library
1513	>	directories are added to the library path.
1514	>
1515	>	Then, COMMAND is executed, with ARGS as arguments."
1516	>	;;
1517	>
1518	>	finish)
1519	>	$ECHO \
1520	>	"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1521	>
1522	>	Complete the installation of libtool libraries.
1523	>
1524	>	Each LIBDIR is a directory that contains libtool libraries.
1525	>
1526	>	The commands that this mode executes may require superuser privileges.  Use
1527	>	the \`--dry-run' option if you just want to see what would be executed."
1528	>	;;
1529	>
1530	>	install)
1531	>	$ECHO \
1532	>	"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1533	>
1534	>	Install executables or libraries.
1535	>
1536	>	INSTALL-COMMAND is the installation command.  The first component should be
1537	>	either the \`install' or \`cp' program.
1538	>
1539	>	The following components of INSTALL-COMMAND are treated specially:
1540	>
1541	>	-inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
1542	>
1543	>	The rest of the components are interpreted as arguments to that command (only
1544	>	BSD-compatible install options are recognized)."
1545	>	;;
1546	>
1547	>	link)
1548	>	$ECHO \
1549	>	"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1550	>
1551	>	Link object files or libraries together to form another library, or to
1552	>	create an executable program.
1553	>
1554	>	LINK-COMMAND is a command using the C compiler that you would use to create
1555	>	a program from several object files.
1556	>
1557	>	The following components of LINK-COMMAND are treated specially:
1558	>
1559	>	-all-static       do not do any dynamic linking at all
1560	>	-avoid-version    do not add a version suffix if possible
1561	>	-dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
1562	>	-dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
1563	>	-export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1564	>	-export-symbols SYMFILE
1565	>	try to export only the symbols listed in SYMFILE
1566	>	-export-symbols-regex REGEX
1567	>	try to export only the symbols matching REGEX
1568	>	-LLIBDIR          search LIBDIR for required installed libraries
1569	>	-lNAME            OUTPUT-FILE requires the installed library libNAME
1570	>	-module           build a library that can dlopened
1571	>	-no-fast-install  disable the fast-install mode
1572	>	-no-install       link a not-installable executable
1573	>	-no-undefined     declare that a library does not refer to external symbols
1574	>	-o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
1575	>	-objectlist FILE  Use a list of object files found in FILE to specify objects
1576	>	-precious-files-regex REGEX
1577	>	don't remove output files matching REGEX
1578	>	-release RELEASE  specify package release information
1579	>	-rpath LIBDIR     the created library will eventually be installed in LIBDIR
1580	>	-R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
1581	>	-shared           only do dynamic linking of libtool libraries
1582	>	-shrext SUFFIX    override the standard shared library file extension
1583	>	-static           do not do any dynamic linking of uninstalled libtool libraries
1584	>	-static-libtool-libs
1585	>	do not do any dynamic linking of libtool libraries
1586	>	-version-info CURRENT[:REVISION[:AGE]]
1587	>	specify library version info [each variable defaults to 0]
1588	>	-weak LIBNAME     declare that the target provides the LIBNAME interface
1589	>
1590	>	All other options (arguments beginning with \`-') are ignored.
1591	>
1592	>	Every other argument is treated as a filename.  Files ending in \`.la' are
1593	>	treated as uninstalled libtool libraries, other files are standard or library
1594	>	object files.
1595	>
1596	>	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1597	>	only library objects (\`.lo' files) may be specified, and \`-rpath' is
1598	>	required, except when creating a convenience library.
1599	>
1600	>	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1601	>	using \`ar' and \`ranlib', or on Windows using \`lib'.
1602	>
1603	>	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1604	>	is created, otherwise an executable program is created."
1605	>	;;
1606	>
1607	>	uninstall)
1608	>	$ECHO \
1609	>	"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1610	>
1611	>	Remove libraries from an installation directory.
1612	>
1613	>	RM is the name of the program to use to delete files associated with each FILE
1614	>	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1615	>	to RM.
1616	>
1617	>	If FILE is a libtool library, all the files associated with it are deleted.
1618	>	Otherwise, only FILE itself is deleted using RM."
1619	>	;;
1620	>
1621	>	*)
1622	>	func_fatal_help "invalid operation mode \`$mode'"
1623	>	;;
1624	>	esac
1625	>
1626	>	$ECHO
1627	>	$ECHO "Try \`$progname --help' for more information about other modes."
1628	>
1629	>	exit $?
1630	>	}
1631	>
1632	>	# Now that we've collected a possible --mode arg, show help if necessary
1633	>	$opt_help && func_mode_help
1634	>
1635	>
1636	>	# func_mode_execute arg...
1637	>	func_mode_execute ()
1638	>	{
1639	>	$opt_debug
1640	>	# The first argument is the command name.
1641	>	cmd="$nonopt"
1642	>	test -z "$cmd" && \
1643	>	func_fatal_help "you must specify a COMMAND"
1644	>
1645	>	# Handle -dlopen flags immediately.
1646	>	for file in $execute_dlfiles; do
1647	>	test -f "$file" \
1648	>	|| func_fatal_help "\`$file' is not a file"
1649	>
1650	>	dir=
1651	>	case $file in
1652	>	*.la)
1653	>	# Check to see that this really is a libtool archive.
1654	>	func_lalib_unsafe_p "$file" \
1655	>	|| func_fatal_help "\`$lib' is not a valid libtool archive"
1656	>
1657	>	# Read the libtool library.
1658	>	dlname=
1659	>	library_names=
1660	>	func_source "$file"
1661	>
1662	>	# Skip this library if it cannot be dlopened.
1663	>	if test -z "$dlname"; then
1664	>	# Warn if it was a shared library.
1665	>	test -n "$library_names" && \
1666	>	func_warning "\`$file' was not linked with \`-export-dynamic'"
1667	>	continue
1668	>	fi
1669	>
1670	>	func_dirname "$file" "" "."
1671	>	dir="$func_dirname_result"
1672	>
1673	>	if test -f "$dir/$objdir/$dlname"; then
1674	>	dir="$dir/$objdir"
1675		else
1676	<	error=$?
1677	<	$run $rm $removelist
1678	<	exit $error
1676	>	if test ! -f "$dir/$dlname"; then
1677	>	func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1678	>	fi
1679		fi
1680	+	;;
1681	+
1682	+	*.lo)
1683	+	# Just add the directory containing the .lo file.
1684	+	func_dirname "$file" "" "."
1685	+	dir="$func_dirname_result"
1686	+	;;
1687	+
1688	+	*)
1689	+	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1690	+	continue
1691	+	;;
1692	+	esac
1693	+
1694	+	# Get the absolute pathname.
1695	+	absdir=`cd "$dir" && pwd`
1696	+	test -n "$absdir" && dir="$absdir"
1697	+
1698	+	# Now add the directory to shlibpath_var.
1699	+	if eval "test -z \"\$$shlibpath_var\""; then
1700	+	eval "$shlibpath_var=\"\$dir\""
1701	+	else
1702	+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1703		fi
1704	+	done
1705
1706	<	# Append the name of the non-PIC object the libtool object file.
1707	<	# Only append if the libtool object file exists.
1708	<	test -z "$run" && cat >> ${libobj}T <<EOF
1071	<	# Name of the non-PIC object.
1072	<	non_pic_object='$objname'
1706	>	# This variable tells wrapper scripts just to set shlibpath_var
1707	>	# rather than running their programs.
1708	>	libtool_execute_magic="$magic"
1709
1710	<	EOF
1710	>	# Check if any of the arguments is a wrapper script.
1711	>	args=
1712	>	for file
1713	>	do
1714	>	case $file in
1715	>	-*) ;;
1716	>	*)
1717	>	# Do a test to see if this is really a libtool program.
1718	>	if func_ltwrapper_script_p "$file"; then
1719	>	func_source "$file"
1720	>	# Transform arg to wrapped name.
1721	>	file="$progdir/$program"
1722	>	elif func_ltwrapper_executable_p "$file"; then
1723	>	func_ltwrapper_scriptname "$file"
1724	>	func_source "$func_ltwrapper_scriptname_result"
1725	>	# Transform arg to wrapped name.
1726	>	file="$progdir/$program"
1727	>	fi
1728	>	;;
1729	>	esac
1730	>	# Quote arguments (to preserve shell metacharacters).
1731	>	func_quote_for_eval "$file"
1732	>	args="$args $func_quote_for_eval_result"
1733	>	done
1734	>
1735	>	if test "X$opt_dry_run" = Xfalse; then
1736	>	if test -n "$shlibpath_var"; then
1737	>	# Export the shlibpath_var.
1738	>	eval "export $shlibpath_var"
1739	>	fi
1740	>
1741	>	# Restore saved environment variables
1742	>	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1743	>	do
1744	>	eval "if test \"\${save_$lt_var+set}\" = set; then
1745	>	$lt_var=\$save_$lt_var; export $lt_var
1746	>	else
1747	>	$lt_unset $lt_var
1748	>	fi"
1749	>	done
1750	>
1751	>	# Now prepare to actually exec the command.
1752	>	exec_cmd="\$cmd$args"
1753		else
1754	<	# Append the name of the non-PIC object the libtool object file.
1755	<	# Only append if the libtool object file exists.
1756	<	test -z "$run" && cat >> ${libobj}T <<EOF
1757	<	# Name of the non-PIC object.
1758	<	non_pic_object=none
1754	>	# Display what would be done.
1755	>	if test -n "$shlibpath_var"; then
1756	>	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1757	>	$ECHO "export $shlibpath_var"
1758	>	fi
1759	>	$ECHO "$cmd$args"
1760	>	exit $EXIT_SUCCESS
1761	>	fi
1762	>	}
1763
1764	<	EOF
1764	>	test "$mode" = execute && func_mode_execute ${1+"$@"}
1765	>
1766	>
1767	>	# func_mode_finish arg...
1768	>	func_mode_finish ()
1769	>	{
1770	>	$opt_debug
1771	>	libdirs="$nonopt"
1772	>	admincmds=
1773	>
1774	>	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1775	>	for dir
1776	>	do
1777	>	libdirs="$libdirs $dir"
1778	>	done
1779	>
1780	>	for libdir in $libdirs; do
1781	>	if test -n "$finish_cmds"; then
1782	>	# Do each command in the finish commands.
1783	>	func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1784	>	'"$cmd"'"'
1785	>	fi
1786	>	if test -n "$finish_eval"; then
1787	>	# Do the single finish_eval.
1788	>	eval cmds=\"$finish_eval\"
1789	>	$opt_dry_run || eval "$cmds" || admincmds="$admincmds
1790	>	$cmds"
1791	>	fi
1792	>	done
1793		fi
1794
1795	<	$run $mv "${libobj}T" "${libobj}"
1795	>	# Exit here if they wanted silent mode.
1796	>	$opt_silent && exit $EXIT_SUCCESS
1797	>
1798	>	$ECHO "X----------------------------------------------------------------------" | $Xsed
1799	>	$ECHO "Libraries have been installed in:"
1800	>	for libdir in $libdirs; do
1801	>	$ECHO "   $libdir"
1802	>	done
1803	>	$ECHO
1804	>	$ECHO "If you ever happen to want to link against installed libraries"
1805	>	$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1806	>	$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1807	>	$ECHO "flag during linking and do at least one of the following:"
1808	>	if test -n "$shlibpath_var"; then
1809	>	$ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
1810	>	$ECHO "     during execution"
1811	>	fi
1812	>	if test -n "$runpath_var"; then
1813	>	$ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
1814	>	$ECHO "     during linking"
1815	>	fi
1816	>	if test -n "$hardcode_libdir_flag_spec"; then
1817	>	libdir=LIBDIR
1818	>	eval flag=\"$hardcode_libdir_flag_spec\"
1819
1820	<	# Unlock the critical section if it was locked
1821	<	if test "$need_locks" != no; then
1822	<	$run $rm "$lockfile"
1820	>	$ECHO "   - use the \`$flag' linker flag"
1821	>	fi
1822	>	if test -n "$admincmds"; then
1823	>	$ECHO "   - have your system administrator run these commands:$admincmds"
1824		fi
1825	+	if test -f /etc/ld.so.conf; then
1826	+	$ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1827	+	fi
1828	+	$ECHO
1829
1830	+	$ECHO "See any operating system documentation about shared libraries for"
1831	+	case $host in
1832	+	solaris2.[6789]|solaris2.1[0-9])
1833	+	$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1834	+	$ECHO "pages."
1835	+	;;
1836	+	*)
1837	+	$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1838	+	;;
1839	+	esac
1840	+	$ECHO "X----------------------------------------------------------------------" | $Xsed
1841		exit $EXIT_SUCCESS
1842	+	}
1843	+
1844	+	test "$mode" = finish && func_mode_finish ${1+"$@"}
1845	+
1846	+
1847	+	# func_mode_install arg...
1848	+	func_mode_install ()
1849	+	{
1850	+	$opt_debug
1851	+	# There may be an optional sh(1) argument at the beginning of
1852	+	# install_prog (especially on Windows NT).
1853	+	if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1854	+	# Allow the use of GNU shtool's install command.
1855	+	$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1856	+	# Aesthetically quote it.
1857	+	func_quote_for_eval "$nonopt"
1858	+	install_prog="$func_quote_for_eval_result "
1859	+	arg=$1
1860	+	shift
1861	+	else
1862	+	install_prog=
1863	+	arg=$nonopt
1864	+	fi
1865	+
1866	+	# The real first argument should be the name of the installation program.
1867	+	# Aesthetically quote it.
1868	+	func_quote_for_eval "$arg"
1869	+	install_prog="$install_prog$func_quote_for_eval_result"
1870	+
1871	+	# We need to accept at least all the BSD install flags.
1872	+	dest=
1873	+	files=
1874	+	opts=
1875	+	prev=
1876	+	install_type=
1877	+	isdir=no
1878	+	stripme=
1879	+	for arg
1880	+	do
1881	+	if test -n "$dest"; then
1882	+	files="$files $dest"
1883	+	dest=$arg
1884	+	continue
1885	+	fi
1886	+
1887	+	case $arg in
1888	+	-d) isdir=yes ;;
1889	+	-f)
1890	+	case " $install_prog " in
1891	+	*[\\\ /]cp\ *) ;;
1892	+	*) prev=$arg ;;
1893	+	esac
1894	+	;;
1895	+	-g | -m | -o)
1896	+	prev=$arg
1897	+	;;
1898	+	-s)
1899	+	stripme=" -s"
1900	+	continue
1901	+	;;
1902	+	-*)
1903	+	;;
1904	+	*)
1905	+	# If the previous option needed an argument, then skip it.
1906	+	if test -n "$prev"; then
1907	+	prev=
1908	+	else
1909	+	dest=$arg
1910	+	continue
1911	+	fi
1912	+	;;
1913	+	esac
1914	+
1915	+	# Aesthetically quote the argument.
1916	+	func_quote_for_eval "$arg"
1917	+	install_prog="$install_prog $func_quote_for_eval_result"
1918	+	done
1919	+
1920	+	test -z "$install_prog" && \
1921	+	func_fatal_help "you must specify an install program"
1922	+
1923	+	test -n "$prev" && \
1924	+	func_fatal_help "the \`$prev' option requires an argument"
1925	+
1926	+	if test -z "$files"; then
1927	+	if test -z "$dest"; then
1928	+	func_fatal_help "no file or destination specified"
1929	+	else
1930	+	func_fatal_help "you must specify a destination"
1931	+	fi
1932	+	fi
1933	+
1934	+	# Strip any trailing slash from the destination.
1935	+	func_stripname '' '/' "$dest"
1936	+	dest=$func_stripname_result
1937	+
1938	+	# Check to see that the destination is a directory.
1939	+	test -d "$dest" && isdir=yes
1940	+	if test "$isdir" = yes; then
1941	+	destdir="$dest"
1942	+	destname=
1943	+	else
1944	+	func_dirname_and_basename "$dest" "" "."
1945	+	destdir="$func_dirname_result"
1946	+	destname="$func_basename_result"
1947	+
1948	+	# Not a directory, so check to see that there is only one file specified.
1949	+	set dummy $files; shift
1950	+	test "$#" -gt 1 && \
1951	+	func_fatal_help "\`$dest' is not a directory"
1952	+	fi
1953	+	case $destdir in
1954	+	[\\/]* | [A-Za-z]:[\\/]*) ;;
1955	+	*)
1956	+	for file in $files; do
1957	+	case $file in
1958	+	*.lo) ;;
1959	+	*)
1960	+	func_fatal_help "\`$destdir' must be an absolute directory name"
1961	+	;;
1962	+	esac
1963	+	done
1964	+	;;
1965	+	esac
1966	+
1967	+	# This variable tells wrapper scripts just to set variables rather
1968	+	# than running their programs.
1969	+	libtool_install_magic="$magic"
1970	+
1971	+	staticlibs=
1972	+	future_libdirs=
1973	+	current_libdirs=
1974	+	for file in $files; do
1975	+
1976	+	# Do each installation.
1977	+	case $file in
1978	+	*.$libext)
1979	+	# Do the static libraries later.
1980	+	staticlibs="$staticlibs $file"
1981	+	;;
1982	+
1983	+	*.la)
1984	+	# Check to see that this really is a libtool archive.
1985	+	func_lalib_unsafe_p "$file" \
1986	+	|| func_fatal_help "\`$file' is not a valid libtool archive"
1987	+
1988	+	library_names=
1989	+	old_library=
1990	+	relink_command=
1991	+	func_source "$file"
1992	+
1993	+	# Add the libdir to current_libdirs if it is the destination.
1994	+	if test "X$destdir" = "X$libdir"; then
1995	+	case "$current_libdirs " in
1996	+	*" $libdir "*) ;;
1997	+	*) current_libdirs="$current_libdirs $libdir" ;;
1998	+	esac
1999	+	else
2000	+	# Note the libdir as a future libdir.
2001	+	case "$future_libdirs " in
2002	+	*" $libdir "*) ;;
2003	+	*) future_libdirs="$future_libdirs $libdir" ;;
2004	+	esac
2005	+	fi
2006	+
2007	+	func_dirname "$file" "/" ""
2008	+	dir="$func_dirname_result"
2009	+	dir="$dir$objdir"
2010	+
2011	+	if test -n "$relink_command"; then
2012	+	# Determine the prefix the user has applied to our future dir.
2013	+	inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2014	+
2015	+	# Don't allow the user to place us outside of our expected
2016	+	# location b/c this prevents finding dependent libraries that
2017	+	# are installed to the same prefix.
2018	+	# At present, this check doesn't affect windows .dll's that
2019	+	# are installed into $libdir/../bin (currently, that works fine)
2020	+	# but it's something to keep an eye on.
2021	+	test "$inst_prefix_dir" = "$destdir" && \
2022	+	func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2023	+
2024	+	if test -n "$inst_prefix_dir"; then
2025	+	# Stick the inst_prefix_dir data into the link command.
2026	+	relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2027	+	else
2028	+	relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2029	+	fi
2030	+
2031	+	func_warning "relinking \`$file'"
2032	+	func_show_eval "$relink_command" \
2033	+	'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2034	+	fi
2035	+
2036	+	# See the names of the shared library.
2037	+	set dummy $library_names; shift
2038	+	if test -n "$1"; then
2039	+	realname="$1"
2040	+	shift
2041	+
2042	+	srcname="$realname"
2043	+	test -n "$relink_command" && srcname="$realname"T
2044	+
2045	+	# Install the shared library and build the symlinks.
2046	+	func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2047	+	'exit $?'
2048	+	tstripme="$stripme"
2049	+	case $host_os in
2050	+	cygwin* | mingw* | pw32* | cegcc*)
2051	+	case $realname in
2052	+	*.dll.a)
2053	+	tstripme=""
2054	+	;;
2055	+	esac
2056	+	;;
2057	+	esac
2058	+	if test -n "$tstripme" && test -n "$striplib"; then
2059	+	func_show_eval "$striplib $destdir/$realname" 'exit $?'
2060	+	fi
2061	+
2062	+	if test "$#" -gt 0; then
2063	+	# Delete the old symlinks, and create new ones.
2064	+	# Try `ln -sf' first, because the `ln' binary might depend on
2065	+	# the symlink we replace!  Solaris /bin/ln does not understand -f,
2066	+	# so we also need to try rm && ln -s.
2067	+	for linkname
2068	+	do
2069	+	test "$linkname" != "$realname" \
2070	+	&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2071	+	done
2072	+	fi
2073	+
2074	+	# Do each command in the postinstall commands.
2075	+	lib="$destdir/$realname"
2076	+	func_execute_cmds "$postinstall_cmds" 'exit $?'
2077	+	fi
2078	+
2079	+	# Install the pseudo-library for information purposes.
2080	+	func_basename "$file"
2081	+	name="$func_basename_result"
2082	+	instname="$dir/$name"i
2083	+	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2084	+
2085	+	# Maybe install the static library, too.
2086	+	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2087	+	;;
2088	+
2089	+	*.lo)
2090	+	# Install (i.e. copy) a libtool object.
2091	+
2092	+	# Figure out destination file name, if it wasn't already specified.
2093	+	if test -n "$destname"; then
2094	+	destfile="$destdir/$destname"
2095	+	else
2096	+	func_basename "$file"
2097	+	destfile="$func_basename_result"
2098	+	destfile="$destdir/$destfile"
2099	+	fi
2100	+
2101	+	# Deduce the name of the destination old-style object file.
2102	+	case $destfile in
2103	+	*.lo)
2104	+	func_lo2o "$destfile"
2105	+	staticdest=$func_lo2o_result
2106	+	;;
2107	+	*.$objext)
2108	+	staticdest="$destfile"
2109	+	destfile=
2110	+	;;
2111	+	*)
2112	+	func_fatal_help "cannot copy a libtool object to \`$destfile'"
2113	+	;;
2114	+	esac
2115	+
2116	+	# Install the libtool object if requested.
2117	+	test -n "$destfile" && \
2118	+	func_show_eval "$install_prog $file $destfile" 'exit $?'
2119	+
2120	+	# Install the old object if enabled.
2121	+	if test "$build_old_libs" = yes; then
2122	+	# Deduce the name of the old-style object file.
2123	+	func_lo2o "$file"
2124	+	staticobj=$func_lo2o_result
2125	+	func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2126	+	fi
2127	+	exit $EXIT_SUCCESS
2128	+	;;
2129	+
2130	+	*)
2131	+	# Figure out destination file name, if it wasn't already specified.
2132	+	if test -n "$destname"; then
2133	+	destfile="$destdir/$destname"
2134	+	else
2135	+	func_basename "$file"
2136	+	destfile="$func_basename_result"
2137	+	destfile="$destdir/$destfile"
2138	+	fi
2139	+
2140	+	# If the file is missing, and there is a .exe on the end, strip it
2141	+	# because it is most likely a libtool script we actually want to
2142	+	# install
2143	+	stripped_ext=""
2144	+	case $file in
2145	+	*.exe)
2146	+	if test ! -f "$file"; then
2147	+	func_stripname '' '.exe' "$file"
2148	+	file=$func_stripname_result
2149	+	stripped_ext=".exe"
2150	+	fi
2151	+	;;
2152	+	esac
2153	+
2154	+	# Do a test to see if this is really a libtool program.
2155	+	case $host in
2156	+	*cygwin* | *mingw*)
2157	+	if func_ltwrapper_executable_p "$file"; then
2158	+	func_ltwrapper_scriptname "$file"
2159	+	wrapper=$func_ltwrapper_scriptname_result
2160	+	else
2161	+	func_stripname '' '.exe' "$file"
2162	+	wrapper=$func_stripname_result
2163	+	fi
2164	+	;;
2165	+	*)
2166	+	wrapper=$file
2167	+	;;
2168	+	esac
2169	+	if func_ltwrapper_script_p "$wrapper"; then
2170	+	notinst_deplibs=
2171	+	relink_command=
2172	+
2173	+	func_source "$wrapper"
2174	+
2175	+	# Check the variables that should have been set.
2176	+	test -z "$generated_by_libtool_version" && \
2177	+	func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2178	+
2179	+	finalize=yes
2180	+	for lib in $notinst_deplibs; do
2181	+	# Check to see that each library is installed.
2182	+	libdir=
2183	+	if test -f "$lib"; then
2184	+	func_source "$lib"
2185	+	fi
2186	+	libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187	+	if test -n "$libdir" && test ! -f "$libfile"; then
2188	+	func_warning "\`$lib' has not been installed in \`$libdir'"
2189	+	finalize=no
2190	+	fi
2191	+	done
2192	+
2193	+	relink_command=
2194	+	func_source "$wrapper"
2195	+
2196	+	outputname=
2197	+	if test "$fast_install" = no && test -n "$relink_command"; then
2198	+	$opt_dry_run || {
2199	+	if test "$finalize" = yes; then
2200	+	tmpdir=`func_mktempdir`
2201	+	func_basename "$file$stripped_ext"
2202	+	file="$func_basename_result"
2203	+	outputname="$tmpdir/$file"
2204	+	# Replace the output file specification.
2205	+	relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2206	+
2207	+	$opt_silent || {
2208	+	func_quote_for_expand "$relink_command"
2209	+	eval "func_echo $func_quote_for_expand_result"
2210	+	}
2211	+	if eval "$relink_command"; then :
2212	+	else
2213	+	func_error "error: relink \`$file' with the above command before installing it"
2214	+	$opt_dry_run || ${RM}r "$tmpdir"
2215	+	continue
2216	+	fi
2217	+	file="$outputname"
2218	+	else
2219	+	func_warning "cannot relink \`$file'"
2220	+	fi
2221	+	}
2222	+	else
2223	+	# Install the binary that we compiled earlier.
2224	+	file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2225	+	fi
2226	+	fi
2227	+
2228	+	# remove .exe since cygwin /usr/bin/install will append another
2229	+	# one anyway
2230	+	case $install_prog,$host in
2231	+	*/usr/bin/install*,*cygwin*)
2232	+	case $file:$destfile in
2233	+	*.exe:*.exe)
2234	+	# this is ok
2235	+	;;
2236	+	*.exe:*)
2237	+	destfile=$destfile.exe
2238	+	;;
2239	+	*:*.exe)
2240	+	func_stripname '' '.exe' "$destfile"
2241	+	destfile=$func_stripname_result
2242	+	;;
2243	+	esac
2244	+	;;
2245	+	esac
2246	+	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2247	+	$opt_dry_run || if test -n "$outputname"; then
2248	+	${RM}r "$tmpdir"
2249	+	fi
2250	+	;;
2251	+	esac
2252	+	done
2253	+
2254	+	for file in $staticlibs; do
2255	+	func_basename "$file"
2256	+	name="$func_basename_result"
2257	+
2258	+	# Set up the ranlib parameters.
2259	+	oldlib="$destdir/$name"
2260	+
2261	+	func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2262	+
2263	+	if test -n "$stripme" && test -n "$old_striplib"; then
2264	+	func_show_eval "$old_striplib $oldlib" 'exit $?'
2265	+	fi
2266	+
2267	+	# Do each command in the postinstall commands.
2268	+	func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2269	+	done
2270	+
2271	+	test -n "$future_libdirs" && \
2272	+	func_warning "remember to run \`$progname --finish$future_libdirs'"
2273	+
2274	+	if test -n "$current_libdirs"; then
2275	+	# Maybe just do a dry run.
2276	+	$opt_dry_run && current_libdirs=" -n$current_libdirs"
2277	+	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2278	+	else
2279	+	exit $EXIT_SUCCESS
2280	+	fi
2281	+	}
2282	+
2283	+	test "$mode" = install && func_mode_install ${1+"$@"}
2284	+
2285	+
2286	+	# func_generate_dlsyms outputname originator pic_p
2287	+	# Extract symbols from dlprefiles and create ${outputname}S.o with
2288	+	# a dlpreopen symbol table.
2289	+	func_generate_dlsyms ()
2290	+	{
2291	+	$opt_debug
2292	+	my_outputname="$1"
2293	+	my_originator="$2"
2294	+	my_pic_p="${3-no}"
2295	+	my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2296	+	my_dlsyms=
2297	+
2298	+	if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2299	+	if test -n "$NM" && test -n "$global_symbol_pipe"; then
2300	+	my_dlsyms="${my_outputname}S.c"
2301	+	else
2302	+	func_error "not configured to extract global symbols from dlpreopened files"
2303	+	fi
2304	+	fi
2305	+
2306	+	if test -n "$my_dlsyms"; then
2307	+	case $my_dlsyms in
2308	+	"") ;;
2309	+	*.c)
2310	+	# Discover the nlist of each of the dlfiles.
2311	+	nlist="$output_objdir/${my_outputname}.nm"
2312	+
2313	+	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2314	+
2315	+	# Parse the name list into a source file.
2316	+	func_verbose "creating $output_objdir/$my_dlsyms"
2317	+
2318	+	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2319	+	/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2320	+	/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2321	+
2322	+	#ifdef __cplusplus
2323	+	extern \"C\" {
2324	+	#endif
2325	+
2326	+	/* External symbol declarations for the compiler. */\
2327	+	"
2328	+
2329	+	if test "$dlself" = yes; then
2330	+	func_verbose "generating symbol list for \`$output'"
2331	+
2332	+	$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2333	+
2334	+	# Add our own program objects to the symbol list.
2335	+	progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2336	+	for progfile in $progfiles; do
2337	+	func_verbose "extracting global C symbols from \`$progfile'"
2338	+	$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2339	+	done
2340	+
2341	+	if test -n "$exclude_expsyms"; then
2342	+	$opt_dry_run || {
2343	+	eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2344	+	eval '$MV "$nlist"T "$nlist"'
2345	+	}
2346	+	fi
2347	+
2348	+	if test -n "$export_symbols_regex"; then
2349	+	$opt_dry_run || {
2350	+	eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2351	+	eval '$MV "$nlist"T "$nlist"'
2352	+	}
2353	+	fi
2354	+
2355	+	# Prepare the list of exported symbols
2356	+	if test -z "$export_symbols"; then
2357	+	export_symbols="$output_objdir/$outputname.exp"
2358	+	$opt_dry_run || {
2359	+	$RM $export_symbols
2360	+	eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2361	+	case $host in
2362	+	*cygwin* | *mingw* | *cegcc* )
2363	+	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2364	+	eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2365	+	;;
2366	+	esac
2367	+	}
2368	+	else
2369	+	$opt_dry_run || {
2370	+	eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2371	+	eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372	+	eval '$MV "$nlist"T "$nlist"'
2373	+	case $host in
2374	+	*cygwin | *mingw* | *cegcc* )
2375	+	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376	+	eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2377	+	;;
2378	+	esac
2379	+	}
2380	+	fi
2381	+	fi
2382	+
2383	+	for dlprefile in $dlprefiles; do
2384	+	func_verbose "extracting global C symbols from \`$dlprefile'"
2385	+	func_basename "$dlprefile"
2386	+	name="$func_basename_result"
2387	+	$opt_dry_run || {
2388	+	eval '$ECHO ": $name " >> "$nlist"'
2389	+	eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2390	+	}
2391	+	done
2392	+
2393	+	$opt_dry_run || {
2394	+	# Make sure we have at least an empty file.
2395	+	test -f "$nlist" || : > "$nlist"
2396	+
2397	+	if test -n "$exclude_expsyms"; then
2398	+	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2399	+	$MV "$nlist"T "$nlist"
2400	+	fi
2401	+
2402	+	# Try sorting and uniquifying the output.
2403	+	if $GREP -v "^: " < "$nlist" |
2404	+	if sort -k 3 </dev/null >/dev/null 2>&1; then
2405	+	sort -k 3
2406	+	else
2407	+	sort +2
2408	+	fi |
2409	+	uniq > "$nlist"S; then
2410	+	:
2411	+	else
2412	+	$GREP -v "^: " < "$nlist" > "$nlist"S
2413	+	fi
2414	+
2415	+	if test -f "$nlist"S; then
2416	+	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2417	+	else
2418	+	$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2419	+	fi
2420	+
2421	+	$ECHO >> "$output_objdir/$my_dlsyms" "\
2422	+
2423	+	/* The mapping between symbol names and symbols.  */
2424	+	typedef struct {
2425	+	const char *name;
2426	+	void *address;
2427	+	} lt_dlsymlist;
2428	+	"
2429	+	case $host in
2430	+	*cygwin* | *mingw* | *cegcc* )
2431	+	$ECHO >> "$output_objdir/$my_dlsyms" "\
2432	+	/* DATA imports from DLLs on WIN32 con't be const, because
2433	+	runtime relocations are performed -- see ld's documentation
2434	+	on pseudo-relocs.  */"
2435	+	lt_dlsym_const= ;;
2436	+	*osf5*)
2437	+	echo >> "$output_objdir/$my_dlsyms" "\
2438	+	/* This system does not cope well with relocations in const data */"
2439	+	lt_dlsym_const= ;;
2440	+	*)
2441	+	lt_dlsym_const=const ;;
2442	+	esac
2443	+
2444	+	$ECHO >> "$output_objdir/$my_dlsyms" "\
2445	+	extern $lt_dlsym_const lt_dlsymlist
2446	+	lt_${my_prefix}_LTX_preloaded_symbols[];
2447	+	$lt_dlsym_const lt_dlsymlist
2448	+	lt_${my_prefix}_LTX_preloaded_symbols[] =
2449	+	{\
2450	+	{ \"$my_originator\", (void *) 0 },"
2451	+
2452	+	case $need_lib_prefix in
2453	+	no)
2454	+	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2455	+	;;
2456	+	*)
2457	+	eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2458	+	;;
2459	+	esac
2460	+	$ECHO >> "$output_objdir/$my_dlsyms" "\
2461	+	{0, (void *) 0}
2462	+	};
2463	+
2464	+	/* This works around a problem in FreeBSD linker */
2465	+	#ifdef FREEBSD_WORKAROUND
2466	+	static const void *lt_preloaded_setup() {
2467	+	return lt_${my_prefix}_LTX_preloaded_symbols;
2468	+	}
2469	+	#endif
2470	+
2471	+	#ifdef __cplusplus
2472	+	}
2473	+	#endif\
2474	+	"
2475	+	} # !$opt_dry_run
2476	+
2477	+	pic_flag_for_symtable=
2478	+	case "$compile_command " in
2479	+	*" -static "*) ;;
2480	+	*)
2481	+	case $host in
2482	+	# compiling the symbol table file with pic_flag works around
2483	+	# a FreeBSD bug that causes programs to crash when -lm is
2484	+	# linked before any other PIC object.  But we must not use
2485	+	# pic_flag when linking with -static.  The problem exists in
2486	+	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2487	+	*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2488	+	pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2489	+	*-*-hpux*)
2490	+	pic_flag_for_symtable=" $pic_flag"  ;;
2491	+	*)
2492	+	if test "X$my_pic_p" != Xno; then
2493	+	pic_flag_for_symtable=" $pic_flag"
2494	+	fi
2495	+	;;
2496	+	esac
2497	+	;;
2498	+	esac
2499	+	symtab_cflags=
2500	+	for arg in $LTCFLAGS; do
2501	+	case $arg in
2502	+	-pie | -fpie | -fPIE) ;;
2503	+	*) symtab_cflags="$symtab_cflags $arg" ;;
2504	+	esac
2505	+	done
2506	+
2507	+	# Now compile the dynamic symbol file.
2508	+	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2509	+
2510	+	# Clean up the generated files.
2511	+	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2512	+
2513	+	# Transform the symbol file into the correct name.
2514	+	symfileobj="$output_objdir/${my_outputname}S.$objext"
2515	+	case $host in
2516	+	*cygwin* | *mingw* | *cegcc* )
2517	+	if test -f "$output_objdir/$my_outputname.def"; then
2518	+	compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519	+	finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2520	+	else
2521	+	compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522	+	finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2523	+	fi
2524	+	;;
2525	+	*)
2526	+	compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527	+	finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2528	+	;;
2529	+	esac
2530	+	;;
2531	+	*)
2532	+	func_fatal_error "unknown suffix for \`$my_dlsyms'"
2533	+	;;
2534	+	esac
2535	+	else
2536	+	# We keep going just in case the user didn't refer to
2537	+	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
2538	+	# really was required.
2539	+
2540	+	# Nullify the symbol file.
2541	+	compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542	+	finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2543	+	fi
2544	+	}
2545	+
2546	+	# func_win32_libid arg
2547	+	# return the library type of file 'arg'
2548	+	#
2549	+	# Need a lot of goo to handle *both* DLLs and import libs
2550	+	# Has to be a shell function in order to 'eat' the argument
2551	+	# that is supplied when $file_magic_command is called.
2552	+	func_win32_libid ()
2553	+	{
2554	+	$opt_debug
2555	+	win32_libid_type="unknown"
2556	+	win32_fileres=`file -L $1 2>/dev/null`
2557	+	case $win32_fileres in
2558	+	*ar\ archive\ import\ library*) # definitely import
2559	+	win32_libid_type="x86 archive import"
2560	+	;;
2561	+	*ar\ archive*) # could be an import, or static
2562	+	if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2563	+	$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564	+	win32_nmres=`eval $NM -f posix -A $1 |
2565	+	$SED -n -e '
2566	+	1,100{
2567	+	/ I /{
2568	+	s,.*,import,
2569	+	p
2570	+	q
2571	+	}
2572	+	}'`
2573	+	case $win32_nmres in
2574	+	import*)  win32_libid_type="x86 archive import";;
2575	+	*)        win32_libid_type="x86 archive static";;
2576	+	esac
2577	+	fi
2578	+	;;
2579	+	*DLL*)
2580	+	win32_libid_type="x86 DLL"
2581		;;
2582	+	*executable*) # but shell scripts are "executable" too...
2583	+	case $win32_fileres in
2584	+	*MS\ Windows\ PE\ Intel*)
2585	+	win32_libid_type="x86 DLL"
2586	+	;;
2587	+	esac
2588	+	;;
2589	+	esac
2590	+	$ECHO "$win32_libid_type"
2591	+	}
2592	+
2593	+
2594	+
2595	+	# func_extract_an_archive dir oldlib
2596	+	func_extract_an_archive ()
2597	+	{
2598	+	$opt_debug
2599	+	f_ex_an_ar_dir="$1"; shift
2600	+	f_ex_an_ar_oldlib="$1"
2601	+	func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2602	+	if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2603	+	:
2604	+	else
2605	+	func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2606	+	fi
2607	+	}
2608	+
2609	+
2610	+	# func_extract_archives gentop oldlib ...
2611	+	func_extract_archives ()
2612	+	{
2613	+	$opt_debug
2614	+	my_gentop="$1"; shift
2615	+	my_oldlibs=${1+"$@"}
2616	+	my_oldobjs=""
2617	+	my_xlib=""
2618	+	my_xabs=""
2619	+	my_xdir=""
2620	+
2621	+	for my_xlib in $my_oldlibs; do
2622	+	# Extract the objects.
2623	+	case $my_xlib in
2624	+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2625	+	*) my_xabs=`pwd`"/$my_xlib" ;;
2626	+	esac
2627	+	func_basename "$my_xlib"
2628	+	my_xlib="$func_basename_result"
2629	+	my_xlib_u=$my_xlib
2630	+	while :; do
2631	+	case " $extracted_archives " in
2632	+	*" $my_xlib_u "*)
2633	+	func_arith $extracted_serial + 1
2634	+	extracted_serial=$func_arith_result
2635	+	my_xlib_u=lt$extracted_serial-$my_xlib ;;
2636	+	*) break ;;
2637	+	esac
2638	+	done
2639	+	extracted_archives="$extracted_archives $my_xlib_u"
2640	+	my_xdir="$my_gentop/$my_xlib_u"
2641	+
2642	+	func_mkdir_p "$my_xdir"
2643	+
2644	+	case $host in
2645	+	*-darwin*)
2646	+	func_verbose "Extracting $my_xabs"
2647	+	# Do not bother doing anything if just a dry run
2648	+	$opt_dry_run || {
2649	+	darwin_orig_dir=`pwd`
2650	+	cd $my_xdir || exit $?
2651	+	darwin_archive=$my_xabs
2652	+	darwin_curdir=`pwd`
2653	+	darwin_base_archive=`basename "$darwin_archive"`
2654	+	darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2655	+	if test -n "$darwin_arches"; then
2656	+	darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2657	+	darwin_arch=
2658	+	func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2659	+	for darwin_arch in  $darwin_arches ; do
2660	+	func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2661	+	$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2662	+	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2663	+	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2664	+	cd "$darwin_curdir"
2665	+	$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2666	+	done # $darwin_arches
2667	+	## Okay now we've a bunch of thin objects, gotta fatten them up :)
2668	+	darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2669	+	darwin_file=
2670	+	darwin_files=
2671	+	for darwin_file in $darwin_filelist; do
2672	+	darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2673	+	$LIPO -create -output "$darwin_file" $darwin_files
2674	+	done # $darwin_filelist
2675	+	$RM -rf unfat-$$
2676	+	cd "$darwin_orig_dir"
2677	+	else
2678	+	cd $darwin_orig_dir
2679	+	func_extract_an_archive "$my_xdir" "$my_xabs"
2680	+	fi # $darwin_arches
2681	+	} # !$opt_dry_run
2682	+	;;
2683	+	*)
2684	+	func_extract_an_archive "$my_xdir" "$my_xabs"
2685	+	;;
2686	+	esac
2687	+	my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2688	+	done
2689	+
2690	+	func_extract_archives_result="$my_oldobjs"
2691	+	}
2692	+
2693	+
2694	+
2695	+	# func_emit_wrapper_part1 [arg=no]
2696	+	#
2697	+	# Emit the first part of a libtool wrapper script on stdout.
2698	+	# For more information, see the description associated with
2699	+	# func_emit_wrapper(), below.
2700	+	func_emit_wrapper_part1 ()
2701	+	{
2702	+	func_emit_wrapper_part1_arg1=no
2703	+	if test -n "$1" ; then
2704	+	func_emit_wrapper_part1_arg1=$1
2705	+	fi
2706	+
2707	+	$ECHO "\
2708	+	#! $SHELL
2709	+
2710	+	# $output - temporary wrapper script for $objdir/$outputname
2711	+	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2712	+	#
2713	+	# The $output program cannot be directly executed until all the libtool
2714	+	# libraries that it depends on are installed.
2715	+	#
2716	+	# This wrapper script should never be moved out of the build directory.
2717	+	# If it is, it will not operate correctly.
2718	+
2719	+	# Sed substitution that helps us do robust quoting.  It backslashifies
2720	+	# metacharacters that are still active within double-quoted strings.
2721	+	Xsed='${SED} -e 1s/^X//'
2722	+	sed_quote_subst='$sed_quote_subst'
2723	+
2724	+	# Be Bourne compatible
2725	+	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2726	+	emulate sh
2727	+	NULLCMD=:
2728	+	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2729	+	# is contrary to our usage.  Disable this feature.
2730	+	alias -g '\${1+\"\$@\"}'='\"\$@\"'
2731	+	setopt NO_GLOB_SUBST
2732	+	else
2733	+	case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2734	+	fi
2735	+	BIN_SH=xpg4; export BIN_SH # for Tru64
2736	+	DUALCASE=1; export DUALCASE # for MKS sh
2737	+
2738	+	# The HP-UX ksh and POSIX shell print the target directory to stdout
2739	+	# if CDPATH is set.
2740	+	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2741	+
2742	+	relink_command=\"$relink_command\"
2743	+
2744	+	# This environment variable determines our operation mode.
2745	+	if test \"\$libtool_install_magic\" = \"$magic\"; then
2746	+	# install mode needs the following variables:
2747	+	generated_by_libtool_version='$macro_version'
2748	+	notinst_deplibs='$notinst_deplibs'
2749	+	else
2750	+	# When we are sourced in execute mode, \$file and \$ECHO are already set.
2751	+	if test \"\$libtool_execute_magic\" != \"$magic\"; then
2752	+	ECHO=\"$qecho\"
2753	+	file=\"\$0\"
2754	+	# Make sure echo works.
2755	+	if test \"X\$1\" = X--no-reexec; then
2756	+	# Discard the --no-reexec flag, and continue.
2757	+	shift
2758	+	elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2759	+	# Yippee, \$ECHO works!
2760	+	:
2761	+	else
2762	+	# Restart under the correct shell, and then maybe \$ECHO will work.
2763	+	exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2764	+	fi
2765	+	fi\
2766	+	"
2767	+	$ECHO "\
2768	+
2769	+	# Find the directory that this script lives in.
2770	+	thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2771	+	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2772	+
2773	+	# Follow symbolic links until we get to the real thisdir.
2774	+	file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2775	+	while test -n \"\$file\"; do
2776	+	destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2777	+
2778	+	# If there was a directory component, then change thisdir.
2779	+	if test \"x\$destdir\" != \"x\$file\"; then
2780	+	case \"\$destdir\" in
2781	+	[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2782	+	*) thisdir=\"\$thisdir/\$destdir\" ;;
2783	+	esac
2784	+	fi
2785	+
2786	+	file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787	+	file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2788	+	done
2789	+	"
2790	+	}
2791	+	# end: func_emit_wrapper_part1
2792	+
2793	+	# func_emit_wrapper_part2 [arg=no]
2794	+	#
2795	+	# Emit the second part of a libtool wrapper script on stdout.
2796	+	# For more information, see the description associated with
2797	+	# func_emit_wrapper(), below.
2798	+	func_emit_wrapper_part2 ()
2799	+	{
2800	+	func_emit_wrapper_part2_arg1=no
2801	+	if test -n "$1" ; then
2802	+	func_emit_wrapper_part2_arg1=$1
2803	+	fi
2804	+
2805	+	$ECHO "\
2806	+
2807	+	# Usually 'no', except on cygwin/mingw when embedded into
2808	+	# the cwrapper.
2809	+	WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2810	+	if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811	+	# special case for '.'
2812	+	if test \"\$thisdir\" = \".\"; then
2813	+	thisdir=\`pwd\`
2814	+	fi
2815	+	# remove .libs from thisdir
2816	+	case \"\$thisdir\" in
2817	+	*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818	+	$objdir )   thisdir=. ;;
2819	+	esac
2820	+	fi
2821	+
2822	+	# Try to get the absolute directory name.
2823	+	absdir=\`cd \"\$thisdir\" && pwd\`
2824	+	test -n \"\$absdir\" && thisdir=\"\$absdir\"
2825	+	"
2826	+
2827	+	if test "$fast_install" = yes; then
2828	+	$ECHO "\
2829	+	program=lt-'$outputname'$exeext
2830	+	progdir=\"\$thisdir/$objdir\"
2831	+
2832	+	if test ! -f \"\$progdir/\$program\" ||
2833	+	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2834	+	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2835	+
2836	+	file=\"\$\$-\$program\"
2837	+
2838	+	if test ! -d \"\$progdir\"; then
2839	+	$MKDIR \"\$progdir\"
2840	+	else
2841	+	$RM \"\$progdir/\$file\"
2842	+	fi"
2843	+
2844	+	$ECHO "\
2845	+
2846	+	# relink executable if necessary
2847	+	if test -n \"\$relink_command\"; then
2848	+	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2849	+	else
2850	+	$ECHO \"\$relink_command_output\" >&2
2851	+	$RM \"\$progdir/\$file\"
2852	+	exit 1
2853	+	fi
2854	+	fi
2855	+
2856	+	$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2857	+	{ $RM \"\$progdir/\$program\";
2858	+	$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2859	+	$RM \"\$progdir/\$file\"
2860	+	fi"
2861	+	else
2862	+	$ECHO "\
2863	+	program='$outputname'
2864	+	progdir=\"\$thisdir/$objdir\"
2865	+	"
2866	+	fi
2867	+
2868	+	$ECHO "\
2869	+
2870	+	if test -f \"\$progdir/\$program\"; then"
2871	+
2872	+	# Export our shlibpath_var if we have one.
2873	+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2874	+	$ECHO "\
2875	+	# Add our own library path to $shlibpath_var
2876	+	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2877	+
2878	+	# Some systems cannot cope with colon-terminated $shlibpath_var
2879	+	# The second colon is a workaround for a bug in BeOS R4 sed
2880	+	$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2881	+
2882	+	export $shlibpath_var
2883	+	"
2884	+	fi
2885	+
2886	+	# fixup the dll searchpath if we need to.
2887	+	if test -n "$dllsearchpath"; then
2888	+	$ECHO "\
2889	+	# Add the dll search path components to the executable PATH
2890	+	PATH=$dllsearchpath:\$PATH
2891	+	"
2892	+	fi
2893	+
2894	+	$ECHO "\
2895	+	if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896	+	# Run the actual program with our arguments.
2897	+	"
2898	+	case $host in
2899	+	# Backslashes separate directories on plain windows
2900	+	*-*-mingw | *-*-os2* | *-cegcc*)
2901	+	$ECHO "\
2902	+	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2903	+	"
2904	+	;;
2905
2906	<	# libtool link mode
2907	<	link | relink)
2908	<	modename="$modename: link"
2906	>	*)
2907	>	$ECHO "\
2908	>	exec \"\$progdir/\$program\" \${1+\"\$@\"}
2909	>	"
2910	>	;;
2911	>	esac
2912	>	$ECHO "\
2913	>	\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2914	>	exit 1
2915	>	fi
2916	>	else
2917	>	# The program doesn't exist.
2918	>	\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919	>	\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920	>	$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2921	>	exit 1
2922	>	fi
2923	>	fi\
2924	>	"
2925	>	}
2926	>	# end: func_emit_wrapper_part2
2927	>
2928	>
2929	>	# func_emit_wrapper [arg=no]
2930	>	#
2931	>	# Emit a libtool wrapper script on stdout.
2932	>	# Don't directly open a file because we may want to
2933	>	# incorporate the script contents within a cygwin/mingw
2934	>	# wrapper executable.  Must ONLY be called from within
2935	>	# func_mode_link because it depends on a number of variables
2936	>	# set therein.
2937	>	#
2938	>	# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2939	>	# variable will take.  If 'yes', then the emitted script
2940	>	# will assume that the directory in which it is stored is
2941	>	# the $objdir directory.  This is a cygwin/mingw-specific
2942	>	# behavior.
2943	>	func_emit_wrapper ()
2944	>	{
2945	>	func_emit_wrapper_arg1=no
2946	>	if test -n "$1" ; then
2947	>	func_emit_wrapper_arg1=$1
2948	>	fi
2949	>
2950	>	# split this up so that func_emit_cwrapperexe_src
2951	>	# can call each part independently.
2952	>	func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2953	>	func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2954	>	}
2955	>
2956	>
2957	>	# func_to_host_path arg
2958	>	#
2959	>	# Convert paths to host format when used with build tools.
2960	>	# Intended for use with "native" mingw (where libtool itself
2961	>	# is running under the msys shell), or in the following cross-
2962	>	# build environments:
2963	>	#    $build          $host
2964	>	#    mingw (msys)    mingw  [e.g. native]
2965	>	#    cygwin          mingw
2966	>	#    *nix + wine     mingw
2967	>	# where wine is equipped with the `winepath' executable.
2968	>	# In the native mingw case, the (msys) shell automatically
2969	>	# converts paths for any non-msys applications it launches,
2970	>	# but that facility isn't available from inside the cwrapper.
2971	>	# Similar accommodations are necessary for $host mingw and
2972	>	# $build cygwin.  Calling this function does no harm for other
2973	>	# $host/$build combinations not listed above.
2974	>	#
2975	>	# ARG is the path (on $build) that should be converted to
2976	>	# the proper representation for $host. The result is stored
2977	>	# in $func_to_host_path_result.
2978	>	func_to_host_path ()
2979	>	{
2980	>	func_to_host_path_result="$1"
2981	>	if test -n "$1" ; then
2982		case $host in
2983	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
2983	>	*mingw* )
2984	>	lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2985	>	case $build in
2986	>	*mingw* ) # actually, msys
2987	>	# awkward: cmd appends spaces to result
2988	>	lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2989	>	func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2990	>	$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2991	>	func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2992	>	$SED -e "$lt_sed_naive_backslashify"`
2993	>	;;
2994	>	*cygwin* )
2995	>	func_to_host_path_tmp1=`cygpath -w "$1"`
2996	>	func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2997	>	$SED -e "$lt_sed_naive_backslashify"`
2998	>	;;
2999	>	* )
3000	>	# Unfortunately, winepath does not exit with a non-zero
3001	>	# error code, so we are forced to check the contents of
3002	>	# stdout. On the other hand, if the command is not
3003	>	# found, the shell will set an exit code of 127 and print
3004	>	# *an error message* to stdout. So we must check for both
3005	>	# error code of zero AND non-empty stdout, which explains
3006	>	# the odd construction:
3007	>	func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3008	>	if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3009	>	func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3010	>	$SED -e "$lt_sed_naive_backslashify"`
3011	>	else
3012	>	# Allow warning below.
3013	>	func_to_host_path_result=""
3014	>	fi
3015	>	;;
3016	>	esac
3017	>	if test -z "$func_to_host_path_result" ; then
3018	>	func_error "Could not determine host path corresponding to"
3019	>	func_error "  '$1'"
3020	>	func_error "Continuing, but uninstalled executables may not work."
3021	>	# Fallback:
3022	>	func_to_host_path_result="$1"
3023	>	fi
3024	>	;;
3025	>	esac
3026	>	fi
3027	>	}
3028	>	# end: func_to_host_path
3029	>
3030	>	# func_to_host_pathlist arg
3031	>	#
3032	>	# Convert pathlists to host format when used with build tools.
3033	>	# See func_to_host_path(), above. This function supports the
3034	>	# following $build/$host combinations (but does no harm for
3035	>	# combinations not listed here):
3036	>	#    $build          $host
3037	>	#    mingw (msys)    mingw  [e.g. native]
3038	>	#    cygwin          mingw
3039	>	#    *nix + wine     mingw
3040	>	#
3041	>	# Path separators are also converted from $build format to
3042	>	# $host format. If ARG begins or ends with a path separator
3043	>	# character, it is preserved (but converted to $host format)
3044	>	# on output.
3045	>	#
3046	>	# ARG is a pathlist (on $build) that should be converted to
3047	>	# the proper representation on $host. The result is stored
3048	>	# in $func_to_host_pathlist_result.
3049	>	func_to_host_pathlist ()
3050	>	{
3051	>	func_to_host_pathlist_result="$1"
3052	>	if test -n "$1" ; then
3053	>	case $host in
3054	>	*mingw* )
3055	>	lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3056	>	# Remove leading and trailing path separator characters from
3057	>	# ARG. msys behavior is inconsistent here, cygpath turns them
3058	>	# into '.;' and ';.', and winepath ignores them completely.
3059	>	func_to_host_pathlist_tmp2="$1"
3060	>	# Once set for this call, this variable should not be
3061	>	# reassigned. It is used in tha fallback case.
3062	>	func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3063	>	$SED -e 's|^:*||' -e 's|:*$||'`
3064	>	case $build in
3065	>	*mingw* ) # Actually, msys.
3066	>	# Awkward: cmd appends spaces to result.
3067	>	lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3068	>	func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3069	>	$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3070	>	func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3071	>	$SED -e "$lt_sed_naive_backslashify"`
3072	>	;;
3073	>	*cygwin* )
3074	>	func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3075	>	func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3076	>	$SED -e "$lt_sed_naive_backslashify"`
3077	>	;;
3078	>	* )
3079	>	# unfortunately, winepath doesn't convert pathlists
3080	>	func_to_host_pathlist_result=""
3081	>	func_to_host_pathlist_oldIFS=$IFS
3082	>	IFS=:
3083	>	for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3084	>	IFS=$func_to_host_pathlist_oldIFS
3085	>	if test -n "$func_to_host_pathlist_f" ; then
3086	>	func_to_host_path "$func_to_host_pathlist_f"
3087	>	if test -n "$func_to_host_path_result" ; then
3088	>	if test -z "$func_to_host_pathlist_result" ; then
3089	>	func_to_host_pathlist_result="$func_to_host_path_result"
3090	>	else
3091	>	func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3092	>	fi
3093	>	fi
3094	>	fi
3095	>	IFS=:
3096	>	done
3097	>	IFS=$func_to_host_pathlist_oldIFS
3098	>	;;
3099	>	esac
3100	>	if test -z "$func_to_host_pathlist_result" ; then
3101	>	func_error "Could not determine the host path(s) corresponding to"
3102	>	func_error "  '$1'"
3103	>	func_error "Continuing, but uninstalled executables may not work."
3104	>	# Fallback. This may break if $1 contains DOS-style drive
3105	>	# specifications. The fix is not to complicate the expression
3106	>	# below, but for the user to provide a working wine installation
3107	>	# with winepath so that path translation in the cross-to-mingw
3108	>	# case works properly.
3109	>	lt_replace_pathsep_nix_to_dos="s|:|;|g"
3110	>	func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3111	>	$SED -e "$lt_replace_pathsep_nix_to_dos"`
3112	>	fi
3113	>	# Now, add the leading and trailing path separators back
3114	>	case "$1" in
3115	>	:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3116	>	;;
3117	>	esac
3118	>	case "$1" in
3119	>	*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3120	>	;;
3121	>	esac
3122	>	;;
3123	>	esac
3124	>	fi
3125	>	}
3126	>	# end: func_to_host_pathlist
3127	>
3128	>	# func_emit_cwrapperexe_src
3129	>	# emit the source code for a wrapper executable on stdout
3130	>	# Must ONLY be called from within func_mode_link because
3131	>	# it depends on a number of variable set therein.
3132	>	func_emit_cwrapperexe_src ()
3133	>	{
3134	>	cat <<EOF
3135	>
3136	>	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3137	>	Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3138	>
3139	>	The $output program cannot be directly executed until all the libtool
3140	>	libraries that it depends on are installed.
3141	>
3142	>	This wrapper executable should never be moved out of the build directory.
3143	>	If it is, it will not operate correctly.
3144	>
3145	>	Currently, it simply execs the wrapper *script* "$SHELL $output",
3146	>	but could eventually absorb all of the scripts functionality and
3147	>	exec $objdir/$outputname directly.
3148	>	*/
3149	>	EOF
3150	>	cat <<"EOF"
3151	>	#include <stdio.h>
3152	>	#include <stdlib.h>
3153	>	#ifdef _MSC_VER
3154	>	# include <direct.h>
3155	>	# include <process.h>
3156	>	# include <io.h>
3157	>	# define setmode _setmode
3158	>	#else
3159	>	# include <unistd.h>
3160	>	# include <stdint.h>
3161	>	# ifdef __CYGWIN__
3162	>	#  include <io.h>
3163	>	#  define HAVE_SETENV
3164	>	#  ifdef __STRICT_ANSI__
3165	>	char *realpath (const char *, char *);
3166	>	int putenv (char *);
3167	>	int setenv (const char *, const char *, int);
3168	>	#  endif
3169	>	# endif
3170	>	#endif
3171	>	#include <malloc.h>
3172	>	#include <stdarg.h>
3173	>	#include <assert.h>
3174	>	#include <string.h>
3175	>	#include <ctype.h>
3176	>	#include <errno.h>
3177	>	#include <fcntl.h>
3178	>	#include <sys/stat.h>
3179	>
3180	>	#if defined(PATH_MAX)
3181	>	# define LT_PATHMAX PATH_MAX
3182	>	#elif defined(MAXPATHLEN)
3183	>	# define LT_PATHMAX MAXPATHLEN
3184	>	#else
3185	>	# define LT_PATHMAX 1024
3186	>	#endif
3187	>
3188	>	#ifndef S_IXOTH
3189	>	# define S_IXOTH 0
3190	>	#endif
3191	>	#ifndef S_IXGRP
3192	>	# define S_IXGRP 0
3193	>	#endif
3194	>
3195	>	#ifdef _MSC_VER
3196	>	# define S_IXUSR _S_IEXEC
3197	>	# define stat _stat
3198	>	# ifndef _INTPTR_T_DEFINED
3199	>	#  define intptr_t int
3200	>	# endif
3201	>	#endif
3202	>
3203	>	#ifndef DIR_SEPARATOR
3204	>	# define DIR_SEPARATOR '/'
3205	>	# define PATH_SEPARATOR ':'
3206	>	#endif
3207	>
3208	>	#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3209	>	defined (__OS2__)
3210	>	# define HAVE_DOS_BASED_FILE_SYSTEM
3211	>	# define FOPEN_WB "wb"
3212	>	# ifndef DIR_SEPARATOR_2
3213	>	#  define DIR_SEPARATOR_2 '\\'
3214	>	# endif
3215	>	# ifndef PATH_SEPARATOR_2
3216	>	#  define PATH_SEPARATOR_2 ';'
3217	>	# endif
3218	>	#endif
3219	>
3220	>	#ifndef DIR_SEPARATOR_2
3221	>	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3222	>	#else /* DIR_SEPARATOR_2 */
3223	>	# define IS_DIR_SEPARATOR(ch) \
3224	>	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3225	>	#endif /* DIR_SEPARATOR_2 */
3226	>
3227	>	#ifndef PATH_SEPARATOR_2
3228	>	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3229	>	#else /* PATH_SEPARATOR_2 */
3230	>	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231	>	#endif /* PATH_SEPARATOR_2 */
3232	>
3233	>	#ifdef __CYGWIN__
3234	>	# define FOPEN_WB "wb"
3235	>	#endif
3236	>
3237	>	#ifndef FOPEN_WB
3238	>	# define FOPEN_WB "w"
3239	>	#endif
3240	>	#ifndef _O_BINARY
3241	>	# define _O_BINARY 0
3242	>	#endif
3243	>
3244	>	#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3245	>	#define XFREE(stale) do { \
3246	>	if (stale) { free ((void *) stale); stale = 0; } \
3247	>	} while (0)
3248	>
3249	>	#undef LTWRAPPER_DEBUGPRINTF
3250	>	#if defined DEBUGWRAPPER
3251	>	# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3252	>	static void
3253	>	ltwrapper_debugprintf (const char *fmt, ...)
3254	>	{
3255	>	va_list args;
3256	>	va_start (args, fmt);
3257	>	(void) vfprintf (stderr, fmt, args);
3258	>	va_end (args);
3259	>	}
3260	>	#else
3261	>	# define LTWRAPPER_DEBUGPRINTF(args)
3262	>	#endif
3263	>
3264	>	const char *program_name = NULL;
3265	>
3266	>	void *xmalloc (size_t num);
3267	>	char *xstrdup (const char *string);
3268	>	const char *base_name (const char *name);
3269	>	char *find_executable (const char *wrapper);
3270	>	char *chase_symlinks (const char *pathspec);
3271	>	int make_executable (const char *path);
3272	>	int check_executable (const char *path);
3273	>	char *strendzap (char *str, const char *pat);
3274	>	void lt_fatal (const char *message, ...);
3275	>	void lt_setenv (const char *name, const char *value);
3276	>	char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3277	>	void lt_opt_process_env_set (const char *arg);
3278	>	void lt_opt_process_env_prepend (const char *arg);
3279	>	void lt_opt_process_env_append (const char *arg);
3280	>	int lt_split_name_value (const char *arg, char** name, char** value);
3281	>	void lt_update_exe_path (const char *name, const char *value);
3282	>	void lt_update_lib_path (const char *name, const char *value);
3283	>
3284	>	static const char *script_text_part1 =
3285	>	EOF
3286	>
3287	>	func_emit_wrapper_part1 yes |
3288	>	$SED -e 's/\([\\"]\)/\\\1/g' \
3289	>	-e 's/^/  "/' -e 's/$/\\n"/'
3290	>	echo ";"
3291	>	cat <<EOF
3292	>
3293	>	static const char *script_text_part2 =
3294	>	EOF
3295	>	func_emit_wrapper_part2 yes |
3296	>	$SED -e 's/\([\\"]\)/\\\1/g' \
3297	>	-e 's/^/  "/' -e 's/$/\\n"/'
3298	>	echo ";"
3299	>
3300	>	cat <<EOF
3301	>	const char * MAGIC_EXE = "$magic_exe";
3302	>	const char * LIB_PATH_VARNAME = "$shlibpath_var";
3303	>	EOF
3304	>
3305	>	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306	>	func_to_host_pathlist "$temp_rpath"
3307	>	cat <<EOF
3308	>	const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3309	>	EOF
3310	>	else
3311	>	cat <<"EOF"
3312	>	const char * LIB_PATH_VALUE   = "";
3313	>	EOF
3314	>	fi
3315	>
3316	>	if test -n "$dllsearchpath"; then
3317	>	func_to_host_pathlist "$dllsearchpath:"
3318	>	cat <<EOF
3319	>	const char * EXE_PATH_VARNAME = "PATH";
3320	>	const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3321	>	EOF
3322	>	else
3323	>	cat <<"EOF"
3324	>	const char * EXE_PATH_VARNAME = "";
3325	>	const char * EXE_PATH_VALUE   = "";
3326	>	EOF
3327	>	fi
3328	>
3329	>	if test "$fast_install" = yes; then
3330	>	cat <<EOF
3331	>	const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3332	>	EOF
3333	>	else
3334	>	cat <<EOF
3335	>	const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3336	>	EOF
3337	>	fi
3338	>
3339	>
3340	>	cat <<"EOF"
3341	>
3342	>	#define LTWRAPPER_OPTION_PREFIX         "--lt-"
3343	>	#define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3344	>
3345	>	static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346	>	static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3347	>
3348	>	static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3349	>
3350	>	static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3351	>	static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
3352	>	/* argument is putenv-style "foo=bar", value of foo is set to bar */
3353	>
3354	>	static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3355	>	static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
3356	>	/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3357	>
3358	>	static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3359	>	static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
3360	>	/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3361	>
3362	>	int
3363	>	main (int argc, char *argv[])
3364	>	{
3365	>	char **newargz;
3366	>	int  newargc;
3367	>	char *tmp_pathspec;
3368	>	char *actual_cwrapper_path;
3369	>	char *actual_cwrapper_name;
3370	>	char *target_name;
3371	>	char *lt_argv_zero;
3372	>	intptr_t rval = 127;
3373	>
3374	>	int i;
3375	>
3376	>	program_name = (char *) xstrdup (base_name (argv[0]));
3377	>	LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3378	>	LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3379	>
3380	>	/* very simple arg parsing; don't want to rely on getopt */
3381	>	for (i = 1; i < argc; i++)
3382	>	{
3383	>	if (strcmp (argv[i], dumpscript_opt) == 0)
3384	>	{
3385	>	EOF
3386	>	case "$host" in
3387	>	*mingw* | *cygwin* )
3388	>	# make stdout use "unix" line endings
3389	>	echo "          setmode(1,_O_BINARY);"
3390	>	;;
3391	>	esac
3392	>
3393	>	cat <<"EOF"
3394	>	printf ("%s", script_text_part1);
3395	>	printf ("%s", script_text_part2);
3396	>	return 0;
3397	>	}
3398	>	}
3399	>
3400	>	newargz = XMALLOC (char *, argc + 1);
3401	>	tmp_pathspec = find_executable (argv[0]);
3402	>	if (tmp_pathspec == NULL)
3403	>	lt_fatal ("Couldn't find %s", argv[0]);
3404	>	LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3405	>	tmp_pathspec));
3406	>
3407	>	actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3408	>	LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409	>	actual_cwrapper_path));
3410	>	XFREE (tmp_pathspec);
3411	>
3412	>	actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3413	>	strendzap (actual_cwrapper_path, actual_cwrapper_name);
3414	>
3415	>	/* wrapper name transforms */
3416	>	strendzap (actual_cwrapper_name, ".exe");
3417	>	tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3418	>	XFREE (actual_cwrapper_name);
3419	>	actual_cwrapper_name = tmp_pathspec;
3420	>	tmp_pathspec = 0;
3421	>
3422	>	/* target_name transforms -- use actual target program name; might have lt- prefix */
3423	>	target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3424	>	strendzap (target_name, ".exe");
3425	>	tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3426	>	XFREE (target_name);
3427	>	target_name = tmp_pathspec;
3428	>	tmp_pathspec = 0;
3429	>
3430	>	LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3431	>	target_name));
3432	>	EOF
3433	>
3434	>	cat <<EOF
3435	>	newargz[0] =
3436	>	XMALLOC (char, (strlen (actual_cwrapper_path) +
3437	>	strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3438	>	strcpy (newargz[0], actual_cwrapper_path);
3439	>	strcat (newargz[0], "$objdir");
3440	>	strcat (newargz[0], "/");
3441	>	EOF
3442	>
3443	>	cat <<"EOF"
3444	>	/* stop here, and copy so we don't have to do this twice */
3445	>	tmp_pathspec = xstrdup (newargz[0]);
3446	>
3447	>	/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3448	>	strcat (newargz[0], actual_cwrapper_name);
3449	>
3450	>	/* DO want the lt- prefix here if it exists, so use target_name */
3451	>	lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3452	>	XFREE (tmp_pathspec);
3453	>	tmp_pathspec = NULL;
3454	>	EOF
3455	>
3456	>	case $host_os in
3457	>	mingw*)
3458	>	cat <<"EOF"
3459	>	{
3460	>	char* p;
3461	>	while ((p = strchr (newargz[0], '\\')) != NULL)
3462	>	{
3463	>	*p = '/';
3464	>	}
3465	>	while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3466	>	{
3467	>	*p = '/';
3468	>	}
3469	>	}
3470	>	EOF
3471	>	;;
3472	>	esac
3473	>
3474	>	cat <<"EOF"
3475	>	XFREE (target_name);
3476	>	XFREE (actual_cwrapper_path);
3477	>	XFREE (actual_cwrapper_name);
3478	>
3479	>	lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3480	>	lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3481	>	lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3482	>	lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3483	>
3484	>	newargc=0;
3485	>	for (i = 1; i < argc; i++)
3486	>	{
3487	>	if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3488	>	{
3489	>	if (argv[i][env_set_opt_len] == '=')
3490	>	{
3491	>	const char *p = argv[i] + env_set_opt_len + 1;
3492	>	lt_opt_process_env_set (p);
3493	>	}
3494	>	else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3495	>	{
3496	>	lt_opt_process_env_set (argv[++i]); /* don't copy */
3497	>	}
3498	>	else
3499	>	lt_fatal ("%s missing required argument", env_set_opt);
3500	>	continue;
3501	>	}
3502	>	if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3503	>	{
3504	>	if (argv[i][env_prepend_opt_len] == '=')
3505	>	{
3506	>	const char *p = argv[i] + env_prepend_opt_len + 1;
3507	>	lt_opt_process_env_prepend (p);
3508	>	}
3509	>	else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3510	>	{
3511	>	lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3512	>	}
3513	>	else
3514	>	lt_fatal ("%s missing required argument", env_prepend_opt);
3515	>	continue;
3516	>	}
3517	>	if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3518	>	{
3519	>	if (argv[i][env_append_opt_len] == '=')
3520	>	{
3521	>	const char *p = argv[i] + env_append_opt_len + 1;
3522	>	lt_opt_process_env_append (p);
3523	>	}
3524	>	else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3525	>	{
3526	>	lt_opt_process_env_append (argv[++i]); /* don't copy */
3527	>	}
3528	>	else
3529	>	lt_fatal ("%s missing required argument", env_append_opt);
3530	>	continue;
3531	>	}
3532	>	if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3533	>	{
3534	>	/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3535	>	namespace, but it is not one of the ones we know about and
3536	>	have already dealt with, above (inluding dump-script), then
3537	>	report an error. Otherwise, targets might begin to believe
3538	>	they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3539	>	namespace. The first time any user complains about this, we'll
3540	>	need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3541	>	or a configure.ac-settable value.
3542	>	*/
3543	>	lt_fatal ("Unrecognized option in %s namespace: '%s'",
3544	>	ltwrapper_option_prefix, argv[i]);
3545	>	}
3546	>	/* otherwise ... */
3547	>	newargz[++newargc] = xstrdup (argv[i]);
3548	>	}
3549	>	newargz[++newargc] = NULL;
3550	>
3551	>	LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3552	>	for (i = 0; i < newargc; i++)
3553	>	{
3554	>	LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3555	>	}
3556	>
3557	>	EOF
3558	>
3559	>	case $host_os in
3560	>	mingw*)
3561	>	cat <<"EOF"
3562	>	/* execv doesn't actually work on mingw as expected on unix */
3563	>	rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3564	>	if (rval == -1)
3565	>	{
3566	>	/* failed to start process */
3567	>	LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3568	>	return 127;
3569	>	}
3570	>	return rval;
3571	>	EOF
3572	>	;;
3573	>	*)
3574	>	cat <<"EOF"
3575	>	execv (lt_argv_zero, newargz);
3576	>	return rval; /* =127, but avoids unused variable warning */
3577	>	EOF
3578	>	;;
3579	>	esac
3580	>
3581	>	cat <<"EOF"
3582	>	}
3583	>
3584	>	void *
3585	>	xmalloc (size_t num)
3586	>	{
3587	>	void *p = (void *) malloc (num);
3588	>	if (!p)
3589	>	lt_fatal ("Memory exhausted");
3590	>
3591	>	return p;
3592	>	}
3593	>
3594	>	char *
3595	>	xstrdup (const char *string)
3596	>	{
3597	>	return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3598	>	string) : NULL;
3599	>	}
3600	>
3601	>	const char *
3602	>	base_name (const char *name)
3603	>	{
3604	>	const char *base;
3605	>
3606	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3607	>	/* Skip over the disk name in MSDOS pathnames. */
3608	>	if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3609	>	name += 2;
3610	>	#endif
3611	>
3612	>	for (base = name; *name; name++)
3613	>	if (IS_DIR_SEPARATOR (*name))
3614	>	base = name + 1;
3615	>	return base;
3616	>	}
3617	>
3618	>	int
3619	>	check_executable (const char *path)
3620	>	{
3621	>	struct stat st;
3622	>
3623	>	LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
3624	>	path ? (*path ? path : "EMPTY!") : "NULL!"));
3625	>	if ((!path) || (!*path))
3626	>	return 0;
3627	>
3628	>	if ((stat (path, &st) >= 0)
3629	>	&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3630	>	return 1;
3631	>	else
3632	>	return 0;
3633	>	}
3634	>
3635	>	int
3636	>	make_executable (const char *path)
3637	>	{
3638	>	int rval = 0;
3639	>	struct stat st;
3640	>
3641	>	LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
3642	>	path ? (*path ? path : "EMPTY!") : "NULL!"));
3643	>	if ((!path) || (!*path))
3644	>	return 0;
3645	>
3646	>	if (stat (path, &st) >= 0)
3647	>	{
3648	>	rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3649	>	}
3650	>	return rval;
3651	>	}
3652	>
3653	>	/* Searches for the full path of the wrapper.  Returns
3654	>	newly allocated full path name if found, NULL otherwise
3655	>	Does not chase symlinks, even on platforms that support them.
3656	>	*/
3657	>	char *
3658	>	find_executable (const char *wrapper)
3659	>	{
3660	>	int has_slash = 0;
3661	>	const char *p;
3662	>	const char *p_next;
3663	>	/* static buffer for getcwd */
3664	>	char tmp[LT_PATHMAX + 1];
3665	>	int tmp_len;
3666	>	char *concat_name;
3667	>
3668	>	LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
3669	>	wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3670	>
3671	>	if ((wrapper == NULL) || (*wrapper == '\0'))
3672	>	return NULL;
3673	>
3674	>	/* Absolute path? */
3675	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3676	>	if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3677	>	{
3678	>	concat_name = xstrdup (wrapper);
3679	>	if (check_executable (concat_name))
3680	>	return concat_name;
3681	>	XFREE (concat_name);
3682	>	}
3683	>	else
3684	>	{
3685	>	#endif
3686	>	if (IS_DIR_SEPARATOR (wrapper[0]))
3687	>	{
3688	>	concat_name = xstrdup (wrapper);
3689	>	if (check_executable (concat_name))
3690	>	return concat_name;
3691	>	XFREE (concat_name);
3692	>	}
3693	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3694	>	}
3695	>	#endif
3696	>
3697	>	for (p = wrapper; *p; p++)
3698	>	if (*p == '/')
3699	>	{
3700	>	has_slash = 1;
3701	>	break;
3702	>	}
3703	>	if (!has_slash)
3704	>	{
3705	>	/* no slashes; search PATH */
3706	>	const char *path = getenv ("PATH");
3707	>	if (path != NULL)
3708	>	{
3709	>	for (p = path; *p; p = p_next)
3710	>	{
3711	>	const char *q;
3712	>	size_t p_len;
3713	>	for (q = p; *q; q++)
3714	>	if (IS_PATH_SEPARATOR (*q))
3715	>	break;
3716	>	p_len = q - p;
3717	>	p_next = (*q == '\0' ? q : q + 1);
3718	>	if (p_len == 0)
3719	>	{
3720	>	/* empty path: current directory */
3721	>	if (getcwd (tmp, LT_PATHMAX) == NULL)
3722	>	lt_fatal ("getcwd failed");
3723	>	tmp_len = strlen (tmp);
3724	>	concat_name =
3725	>	XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3726	>	memcpy (concat_name, tmp, tmp_len);
3727	>	concat_name[tmp_len] = '/';
3728	>	strcpy (concat_name + tmp_len + 1, wrapper);
3729	>	}
3730	>	else
3731	>	{
3732	>	concat_name =
3733	>	XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3734	>	memcpy (concat_name, p, p_len);
3735	>	concat_name[p_len] = '/';
3736	>	strcpy (concat_name + p_len + 1, wrapper);
3737	>	}
3738	>	if (check_executable (concat_name))
3739	>	return concat_name;
3740	>	XFREE (concat_name);
3741	>	}
3742	>	}
3743	>	/* not found in PATH; assume curdir */
3744	>	}
3745	>	/* Relative path | not found in path: prepend cwd */
3746	>	if (getcwd (tmp, LT_PATHMAX) == NULL)
3747	>	lt_fatal ("getcwd failed");
3748	>	tmp_len = strlen (tmp);
3749	>	concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3750	>	memcpy (concat_name, tmp, tmp_len);
3751	>	concat_name[tmp_len] = '/';
3752	>	strcpy (concat_name + tmp_len + 1, wrapper);
3753	>
3754	>	if (check_executable (concat_name))
3755	>	return concat_name;
3756	>	XFREE (concat_name);
3757	>	return NULL;
3758	>	}
3759	>
3760	>	char *
3761	>	chase_symlinks (const char *pathspec)
3762	>	{
3763	>	#ifndef S_ISLNK
3764	>	return xstrdup (pathspec);
3765	>	#else
3766	>	char buf[LT_PATHMAX];
3767	>	struct stat s;
3768	>	char *tmp_pathspec = xstrdup (pathspec);
3769	>	char *p;
3770	>	int has_symlinks = 0;
3771	>	while (strlen (tmp_pathspec) && !has_symlinks)
3772	>	{
3773	>	LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3774	>	tmp_pathspec));
3775	>	if (lstat (tmp_pathspec, &s) == 0)
3776	>	{
3777	>	if (S_ISLNK (s.st_mode) != 0)
3778	>	{
3779	>	has_symlinks = 1;
3780	>	break;
3781	>	}
3782	>
3783	>	/* search backwards for last DIR_SEPARATOR */
3784	>	p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3785	>	while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3786	>	p--;
3787	>	if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3788	>	{
3789	>	/* no more DIR_SEPARATORS left */
3790	>	break;
3791	>	}
3792	>	*p = '\0';
3793	>	}
3794	>	else
3795	>	{
3796	>	char *errstr = strerror (errno);
3797	>	lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3798	>	}
3799	>	}
3800	>	XFREE (tmp_pathspec);
3801	>
3802	>	if (!has_symlinks)
3803	>	{
3804	>	return xstrdup (pathspec);
3805	>	}
3806	>
3807	>	tmp_pathspec = realpath (pathspec, buf);
3808	>	if (tmp_pathspec == 0)
3809	>	{
3810	>	lt_fatal ("Could not follow symlinks for %s", pathspec);
3811	>	}
3812	>	return xstrdup (tmp_pathspec);
3813	>	#endif
3814	>	}
3815	>
3816	>	char *
3817	>	strendzap (char *str, const char *pat)
3818	>	{
3819	>	size_t len, patlen;
3820	>
3821	>	assert (str != NULL);
3822	>	assert (pat != NULL);
3823	>
3824	>	len = strlen (str);
3825	>	patlen = strlen (pat);
3826	>
3827	>	if (patlen <= len)
3828	>	{
3829	>	str += len - patlen;
3830	>	if (strcmp (str, pat) == 0)
3831	>	*str = '\0';
3832	>	}
3833	>	return str;
3834	>	}
3835	>
3836	>	static void
3837	>	lt_error_core (int exit_status, const char *mode,
3838	>	const char *message, va_list ap)
3839	>	{
3840	>	fprintf (stderr, "%s: %s: ", program_name, mode);
3841	>	vfprintf (stderr, message, ap);
3842	>	fprintf (stderr, ".\n");
3843	>
3844	>	if (exit_status >= 0)
3845	>	exit (exit_status);
3846	>	}
3847	>
3848	>	void
3849	>	lt_fatal (const char *message, ...)
3850	>	{
3851	>	va_list ap;
3852	>	va_start (ap, message);
3853	>	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3854	>	va_end (ap);
3855	>	}
3856	>
3857	>	void
3858	>	lt_setenv (const char *name, const char *value)
3859	>	{
3860	>	LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861	>	(name ? name : "<NULL>"),
3862	>	(value ? value : "<NULL>")));
3863	>	{
3864	>	#ifdef HAVE_SETENV
3865	>	/* always make a copy, for consistency with !HAVE_SETENV */
3866	>	char *str = xstrdup (value);
3867	>	setenv (name, str, 1);
3868	>	#else
3869	>	int len = strlen (name) + 1 + strlen (value) + 1;
3870	>	char *str = XMALLOC (char, len);
3871	>	sprintf (str, "%s=%s", name, value);
3872	>	if (putenv (str) != EXIT_SUCCESS)
3873	>	{
3874	>	XFREE (str);
3875	>	}
3876	>	#endif
3877	>	}
3878	>	}
3879	>
3880	>	char *
3881	>	lt_extend_str (const char *orig_value, const char *add, int to_end)
3882	>	{
3883	>	char *new_value;
3884	>	if (orig_value && *orig_value)
3885	>	{
3886	>	int orig_value_len = strlen (orig_value);
3887	>	int add_len = strlen (add);
3888	>	new_value = XMALLOC (char, add_len + orig_value_len + 1);
3889	>	if (to_end)
3890	>	{
3891	>	strcpy (new_value, orig_value);
3892	>	strcpy (new_value + orig_value_len, add);
3893	>	}
3894	>	else
3895	>	{
3896	>	strcpy (new_value, add);
3897	>	strcpy (new_value + add_len, orig_value);
3898	>	}
3899	>	}
3900	>	else
3901	>	{
3902	>	new_value = xstrdup (add);
3903	>	}
3904	>	return new_value;
3905	>	}
3906	>
3907	>	int
3908	>	lt_split_name_value (const char *arg, char** name, char** value)
3909	>	{
3910	>	const char *p;
3911	>	int len;
3912	>	if (!arg || !*arg)
3913	>	return 1;
3914	>
3915	>	p = strchr (arg, (int)'=');
3916	>
3917	>	if (!p)
3918	>	return 1;
3919	>
3920	>	*value = xstrdup (++p);
3921	>
3922	>	len = strlen (arg) - strlen (*value);
3923	>	*name = XMALLOC (char, len);
3924	>	strncpy (*name, arg, len-1);
3925	>	(*name)[len - 1] = '\0';
3926	>
3927	>	return 0;
3928	>	}
3929	>
3930	>	void
3931	>	lt_opt_process_env_set (const char *arg)
3932	>	{
3933	>	char *name = NULL;
3934	>	char *value = NULL;
3935	>
3936	>	if (lt_split_name_value (arg, &name, &value) != 0)
3937	>	{
3938	>	XFREE (name);
3939	>	XFREE (value);
3940	>	lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3941	>	}
3942	>
3943	>	lt_setenv (name, value);
3944	>	XFREE (name);
3945	>	XFREE (value);
3946	>	}
3947	>
3948	>	void
3949	>	lt_opt_process_env_prepend (const char *arg)
3950	>	{
3951	>	char *name = NULL;
3952	>	char *value = NULL;
3953	>	char *new_value = NULL;
3954	>
3955	>	if (lt_split_name_value (arg, &name, &value) != 0)
3956	>	{
3957	>	XFREE (name);
3958	>	XFREE (value);
3959	>	lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3960	>	}
3961	>
3962	>	new_value = lt_extend_str (getenv (name), value, 0);
3963	>	lt_setenv (name, new_value);
3964	>	XFREE (new_value);
3965	>	XFREE (name);
3966	>	XFREE (value);
3967	>	}
3968	>
3969	>	void
3970	>	lt_opt_process_env_append (const char *arg)
3971	>	{
3972	>	char *name = NULL;
3973	>	char *value = NULL;
3974	>	char *new_value = NULL;
3975	>
3976	>	if (lt_split_name_value (arg, &name, &value) != 0)
3977	>	{
3978	>	XFREE (name);
3979	>	XFREE (value);
3980	>	lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3981	>	}
3982	>
3983	>	new_value = lt_extend_str (getenv (name), value, 1);
3984	>	lt_setenv (name, new_value);
3985	>	XFREE (new_value);
3986	>	XFREE (name);
3987	>	XFREE (value);
3988	>	}
3989	>
3990	>	void
3991	>	lt_update_exe_path (const char *name, const char *value)
3992	>	{
3993	>	LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994	>	(name ? name : "<NULL>"),
3995	>	(value ? value : "<NULL>")));
3996	>
3997	>	if (name && *name && value && *value)
3998	>	{
3999	>	char *new_value = lt_extend_str (getenv (name), value, 0);
4000	>	/* some systems can't cope with a ':'-terminated path #' */
4001	>	int len = strlen (new_value);
4002	>	while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4003	>	{
4004	>	new_value[len-1] = '\0';
4005	>	}
4006	>	lt_setenv (name, new_value);
4007	>	XFREE (new_value);
4008	>	}
4009	>	}
4010	>
4011	>	void
4012	>	lt_update_lib_path (const char *name, const char *value)
4013	>	{
4014	>	LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015	>	(name ? name : "<NULL>"),
4016	>	(value ? value : "<NULL>")));
4017	>
4018	>	if (name && *name && value && *value)
4019	>	{
4020	>	char *new_value = lt_extend_str (getenv (name), value, 0);
4021	>	lt_setenv (name, new_value);
4022	>	XFREE (new_value);
4023	>	}
4024	>	}
4025	>
4026	>
4027	>	EOF
4028	>	}
4029	>	# end: func_emit_cwrapperexe_src
4030	>
4031	>	# func_mode_link arg...
4032	>	func_mode_link ()
4033	>	{
4034	>	$opt_debug
4035	>	case $host in
4036	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4037		# It is impossible to link a dll without this setting, and
4038		# we shouldn't force the makefile maintainer to figure out
4039		# which system we are compiling for in order to pass an extra
#	Line 1114 | Line 4051 | EOF
4051		allow_undefined=yes
4052		;;
4053		esac
4054	<	libtool_args="$nonopt"
4054	>	libtool_args=$nonopt
4055		base_compile="$nonopt $@"
4056	<	compile_command="$nonopt"
4057	<	finalize_command="$nonopt"
4056	>	compile_command=$nonopt
4057	>	finalize_command=$nonopt
4058
4059		compile_rpath=
4060		finalize_rpath=
#	Line 1132 | Line 4069 | EOF
4069		dllsearchpath=
4070		lib_search_path=`pwd`
4071		inst_prefix_dir=
4072	+	new_inherited_linker_flags=
4073
4074		avoid_version=no
4075		dlfiles=
#	Line 1147 | Line 4085 | EOF
4085		no_install=no
4086		objs=
4087		non_pic_objects=
1150	–	notinst_path= # paths that contain not-installed libtool libraries
4088		precious_files_regex=
4089		prefer_static_libs=no
4090		preload=no
#	Line 1161 | Line 4098 | EOF
4098		thread_safe=no
4099		vinfo=
4100		vinfo_number=no
4101	<
4101	>	weak_libs=
4102	>	single_module="${wl}-single_module"
4103		func_infer_tag $base_compile
4104
4105		# We need to know -static, to get the right output filenames.
4106		for arg
4107		do
4108		case $arg in
4109	+	-shared)
4110	+	test "$build_libtool_libs" != yes && \
4111	+	func_fatal_configuration "can not build a shared library"
4112	+	build_old_libs=no
4113	+	break
4114	+	;;
4115		-all-static | -static | -static-libtool-libs)
4116		case $arg in
4117		-all-static)
4118		if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4119	<	$echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
4119	>	func_warning "complete static linking is impossible in this configuration"
4120		fi
4121		if test -n "$link_static_flag"; then
4122		dlopen_self=$dlopen_self_static
#	Line 1206 | Line 4150 | EOF
4150		while test "$#" -gt 0; do
4151		arg="$1"
4152		shift
4153	<	case $arg in
4154	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
4155	<	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1212	<	;;
1213	<	*) qarg=$arg ;;
1214	<	esac
1215	<	libtool_args="$libtool_args $qarg"
4153	>	func_quote_for_eval "$arg"
4154	>	qarg=$func_quote_for_eval_unquoted_result
4155	>	func_append libtool_args " $func_quote_for_eval_result"
4156
4157		# If the previous option needs an argument, assign it.
4158		if test -n "$prev"; then
4159		case $prev in
4160		output)
4161	<	compile_command="$compile_command @OUTPUT@"
4162	<	finalize_command="$finalize_command @OUTPUT@"
4161	>	func_append compile_command " @OUTPUT@"
4162	>	func_append finalize_command " @OUTPUT@"
4163		;;
4164		esac
4165
#	Line 1227 | Line 4167 | EOF
4167		dlfiles|dlprefiles)
4168		if test "$preload" = no; then
4169		# Add the symbol object into the linking commands.
4170	<	compile_command="$compile_command @SYMFILE@"
4171	<	finalize_command="$finalize_command @SYMFILE@"
4170	>	func_append compile_command " @SYMFILE@"
4171	>	func_append finalize_command " @SYMFILE@"
4172		preload=yes
4173		fi
4174		case $arg in
#	Line 1266 | Line 4206 | EOF
4206		;;
4207		expsyms)
4208		export_symbols="$arg"
4209	<	if test ! -f "$arg"; then
4210	<	$echo "$modename: symbol file \`$arg' does not exist"
1271	<	exit $EXIT_FAILURE
1272	<	fi
4209	>	test -f "$arg" \
4210	>	|| func_fatal_error "symbol file \`$arg' does not exist"
4211		prev=
4212		continue
4213		;;
#	Line 1278 | Line 4216 | EOF
4216		prev=
4217		continue
4218		;;
4219	<	inst_prefix)
4220	<	inst_prefix_dir="$arg"
4221	<	prev=
4222	<	continue
4223	<	;;
4224	<	precious_regex)
4225	<	precious_files_regex="$arg"
4219	>	framework)
4220	>	case $host in
4221	>	*-*-darwin*)
4222	>	case "$deplibs " in
4223	>	*" $qarg.ltframework "*) ;;
4224	>	*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4225	>	;;
4226	>	esac
4227	>	;;
4228	>	esac
4229		prev=
4230		continue
4231		;;
4232	<	release)
4233	<	release="-$arg"
4232	>	inst_prefix)
4233	>	inst_prefix_dir="$arg"
4234		prev=
4235		continue
4236		;;
#	Line 1297 | Line 4238 | EOF
4238		if test -f "$arg"; then
4239		save_arg=$arg
4240		moreargs=
4241	<	for fil in `cat $save_arg`
4241	>	for fil in `cat "$save_arg"`
4242		do
4243		#             moreargs="$moreargs $fil"
4244		arg=$fil
4245		# A libtool-controlled object.
4246
4247		# Check to see that this really is a libtool object.
4248	<	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4248	>	if func_lalib_unsafe_p "$arg"; then
4249		pic_object=
4250		non_pic_object=
4251
4252		# Read the .lo file
4253	<	# If there is no directory component, then add one.
1313	<	case $arg in
1314	<	*/* | *\\*) . $arg ;;
1315	<	*) . ./$arg ;;
1316	<	esac
4253	>	func_source "$arg"
4254
4255	<	if test -z "$pic_object" || \
4255	>	if test -z "$pic_object" ||
4256		test -z "$non_pic_object" ||
4257	<	test "$pic_object" = none && \
4257	>	test "$pic_object" = none &&
4258		test "$non_pic_object" = none; then
4259	<	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
1323	<	exit $EXIT_FAILURE
4259	>	func_fatal_error "cannot find name of object for \`$arg'"
4260		fi
4261
4262		# Extract subdirectory from the argument.
4263	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
4264	<	if test "X$xdir" = "X$arg"; then
1329	<	xdir=
1330	<	else
1331	<	xdir="$xdir/"
1332	<	fi
4263	>	func_dirname "$arg" "/" ""
4264	>	xdir="$func_dirname_result"
4265
4266		if test "$pic_object" != none; then
4267		# Prepend the subdirectory the object is found in.
#	Line 1354 | Line 4286 | EOF
4286		fi
4287
4288		# A PIC object.
4289	<	libobjs="$libobjs $pic_object"
4289	>	func_append libobjs " $pic_object"
4290		arg="$pic_object"
4291		fi
4292
#	Line 1364 | Line 4296 | EOF
4296		non_pic_object="$xdir$non_pic_object"
4297
4298		# A standard non-PIC object
4299	<	non_pic_objects="$non_pic_objects $non_pic_object"
4299	>	func_append non_pic_objects " $non_pic_object"
4300		if test -z "$pic_object" || test "$pic_object" = none ; then
4301		arg="$non_pic_object"
4302		fi
#	Line 1372 | Line 4304 | EOF
4304		# If the PIC object exists, use it instead.
4305		# $xdir was prepended to $pic_object above.
4306		non_pic_object="$pic_object"
4307	<	non_pic_objects="$non_pic_objects $non_pic_object"
4307	>	func_append non_pic_objects " $non_pic_object"
4308		fi
4309		else
4310		# Only an error if not doing a dry-run.
4311	<	if test -z "$run"; then
1380	<	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1381	<	exit $EXIT_FAILURE
1382	<	else
1383	<	# Dry-run case.
1384	<
4311	>	if $opt_dry_run; then
4312		# Extract subdirectory from the argument.
4313	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
4314	<	if test "X$xdir" = "X$arg"; then
1388	<	xdir=
1389	<	else
1390	<	xdir="$xdir/"
1391	<	fi
4313	>	func_dirname "$arg" "/" ""
4314	>	xdir="$func_dirname_result"
4315
4316	<	pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
4317	<	non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
4318	<	libobjs="$libobjs $pic_object"
4319	<	non_pic_objects="$non_pic_objects $non_pic_object"
4316	>	func_lo2o "$arg"
4317	>	pic_object=$xdir$objdir/$func_lo2o_result
4318	>	non_pic_object=$xdir$func_lo2o_result
4319	>	func_append libobjs " $pic_object"
4320	>	func_append non_pic_objects " $non_pic_object"
4321	>	else
4322	>	func_fatal_error "\`$arg' is not a valid libtool object"
4323		fi
4324		fi
4325		done
4326		else
4327	<	$echo "$modename: link input file \`$save_arg' does not exist"
1402	<	exit $EXIT_FAILURE
4327	>	func_fatal_error "link input file \`$arg' does not exist"
4328		fi
4329		arg=$save_arg
4330		prev=
4331		continue
4332		;;
4333	+	precious_regex)
4334	+	precious_files_regex="$arg"
4335	+	prev=
4336	+	continue
4337	+	;;
4338	+	release)
4339	+	release="-$arg"
4340	+	prev=
4341	+	continue
4342	+	;;
4343		rpath | xrpath)
4344		# We need an absolute path.
4345		case $arg in
4346		[\\/]* | [A-Za-z]:[\\/]*) ;;
4347		*)
4348	<	$echo "$modename: only absolute run-paths are allowed" 1>&2
1414	<	exit $EXIT_FAILURE
4348	>	func_fatal_error "only absolute run-paths are allowed"
4349		;;
4350		esac
4351		if test "$prev" = rpath; then
#	Line 1428 | Line 4362 | EOF
4362		prev=
4363		continue
4364		;;
4365	<	xcompiler)
4366	<	compiler_flags="$compiler_flags $qarg"
4365	>	shrext)
4366	>	shrext_cmds="$arg"
4367		prev=
1434	–	compile_command="$compile_command $qarg"
1435	–	finalize_command="$finalize_command $qarg"
4368		continue
4369		;;
4370	<	xlinker)
4371	<	linker_flags="$linker_flags $qarg"
1440	<	compiler_flags="$compiler_flags $wl$qarg"
4370	>	weak)
4371	>	weak_libs="$weak_libs $arg"
4372		prev=
1442	–	compile_command="$compile_command $wl$qarg"
1443	–	finalize_command="$finalize_command $wl$qarg"
4373		continue
4374		;;
4375		xcclinker)
4376		linker_flags="$linker_flags $qarg"
4377		compiler_flags="$compiler_flags $qarg"
4378		prev=
4379	<	compile_command="$compile_command $qarg"
4380	<	finalize_command="$finalize_command $qarg"
4379	>	func_append compile_command " $qarg"
4380	>	func_append finalize_command " $qarg"
4381		continue
4382		;;
4383	<	shrext)
4384	<	shrext_cmds="$arg"
4383	>	xcompiler)
4384	>	compiler_flags="$compiler_flags $qarg"
4385		prev=
4386	+	func_append compile_command " $qarg"
4387	+	func_append finalize_command " $qarg"
4388		continue
4389		;;
4390	<	darwin_framework|darwin_framework_skip)
4391	<	test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
4392	<	compile_command="$compile_command $arg"
1462	<	finalize_command="$finalize_command $arg"
4390	>	xlinker)
4391	>	linker_flags="$linker_flags $qarg"
4392	>	compiler_flags="$compiler_flags $wl$qarg"
4393		prev=
4394	+	func_append compile_command " $wl$qarg"
4395	+	func_append finalize_command " $wl$qarg"
4396		continue
4397		;;
4398		*)
#	Line 1476 | Line 4408 | EOF
4408		case $arg in
4409		-all-static)
4410		if test -n "$link_static_flag"; then
4411	<	compile_command="$compile_command $link_static_flag"
4412	<	finalize_command="$finalize_command $link_static_flag"
4411	>	# See comment for -static flag below, for more details.
4412	>	func_append compile_command " $link_static_flag"
4413	>	func_append finalize_command " $link_static_flag"
4414		fi
4415		continue
4416		;;
4417
4418		-allow-undefined)
4419		# FIXME: remove this flag sometime in the future.
4420	<	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1488	<	continue
4420	>	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4421		;;
4422
4423		-avoid-version)
#	Line 1510 | Line 4442 | EOF
4442
4443		-export-symbols | -export-symbols-regex)
4444		if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4445	<	$echo "$modename: more than one -exported-symbols argument is not allowed"
1514	<	exit $EXIT_FAILURE
4445	>	func_fatal_error "more than one -exported-symbols argument is not allowed"
4446		fi
4447		if test "X$arg" = "X-export-symbols"; then
4448		prev=expsyms
#	Line 1521 | Line 4452 | EOF
4452		continue
4453		;;
4454
4455	<	-framework|-arch|-isysroot)
4456	<	case " $CC " in
1526	<	*" ${arg} ${1} "* | *" ${arg} ${1} "*)
1527	<	prev=darwin_framework_skip ;;
1528	<	*) compiler_flags="$compiler_flags $arg"
1529	<	prev=darwin_framework ;;
1530	<	esac
1531	<	compile_command="$compile_command $arg"
1532	<	finalize_command="$finalize_command $arg"
4455	>	-framework)
4456	>	prev=framework
4457		continue
4458		;;
4459
#	Line 1543 | Line 4467 | EOF
4467		-L[A-Z][A-Z]*:*)
4468		case $with_gcc/$host in
4469		no/*-*-irix* | /*-*-irix*)
4470	<	compile_command="$compile_command $arg"
4471	<	finalize_command="$finalize_command $arg"
4470	>	func_append compile_command " $arg"
4471	>	func_append finalize_command " $arg"
4472		;;
4473		esac
4474		continue
4475		;;
4476
4477		-L*)
4478	<	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
4478	>	func_stripname '-L' '' "$arg"
4479	>	dir=$func_stripname_result
4480	>	if test -z "$dir"; then
4481	>	if test "$#" -gt 0; then
4482	>	func_fatal_error "require no space between \`-L' and \`$1'"
4483	>	else
4484	>	func_fatal_error "need path for \`-L' option"
4485	>	fi
4486	>	fi
4487		# We need an absolute path.
4488		case $dir in
4489		[\\/]* | [A-Za-z]:[\\/]*) ;;
4490		*)
4491		absdir=`cd "$dir" && pwd`
4492	<	if test -z "$absdir"; then
4493	<	$echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1562	<	absdir="$dir"
1563	<	notinst_path="$notinst_path $dir"
1564	<	fi
4492	>	test -z "$absdir" && \
4493	>	func_fatal_error "cannot determine absolute directory name of \`$dir'"
4494		dir="$absdir"
4495		;;
4496		esac
#	Line 1573 | Line 4502 | EOF
4502		;;
4503		esac
4504		case $host in
4505	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4506	<	testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4505	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4506	>	testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4507		case :$dllsearchpath: in
4508		*":$dir:"*) ;;
4509	+	::) dllsearchpath=$dir;;
4510		*) dllsearchpath="$dllsearchpath:$dir";;
4511		esac
4512		case :$dllsearchpath: in
4513		*":$testbindir:"*) ;;
4514	+	::) dllsearchpath=$testbindir;;
4515		*) dllsearchpath="$dllsearchpath:$testbindir";;
4516		esac
4517		;;
#	Line 1591 | Line 4522 | EOF
4522		-l*)
4523		if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4524		case $host in
4525	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
4525	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4526		# These systems don't actually have a C or math library (as such)
4527		continue
4528		;;
#	Line 1605 | Line 4536 | EOF
4536		;;
4537		*-*-rhapsody* | *-*-darwin1.[012])
4538		# Rhapsody C and math libraries are in the System framework
4539	<	deplibs="$deplibs -framework System"
4539	>	deplibs="$deplibs System.ltframework"
4540		continue
4541		;;
4542		*-*-sco3.2v5* | *-*-sco5v6*)
#	Line 1629 | Line 4560 | EOF
4560		continue
4561		;;
4562
4563	+	-module)
4564	+	module=yes
4565	+	continue
4566	+	;;
4567	+
4568		# Tru64 UNIX uses -model [arg] to determine the layout of C++
4569		# classes, name mangling, and exception handling.
4570	<	-model)
4571	<	compile_command="$compile_command $arg"
4570	>	# Darwin uses the -arch flag to determine output architecture.
4571	>	-model|-arch|-isysroot)
4572		compiler_flags="$compiler_flags $arg"
4573	<	finalize_command="$finalize_command $arg"
4573	>	func_append compile_command " $arg"
4574	>	func_append finalize_command " $arg"
4575		prev=xcompiler
4576		continue
4577		;;
4578
4579	<	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4579	>	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4580		compiler_flags="$compiler_flags $arg"
4581	<	compile_command="$compile_command $arg"
4582	<	finalize_command="$finalize_command $arg"
4581	>	func_append compile_command " $arg"
4582	>	func_append finalize_command " $arg"
4583	>	case "$new_inherited_linker_flags " in
4584	>	*" $arg "*) ;;
4585	>	* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4586	>	esac
4587		continue
4588		;;
4589
4590	<	-module)
4591	<	module=yes
1651	<	continue
1652	<	;;
1653	<
1654	<	# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1655	<	# -r[0-9][0-9]* specifies the processor on the SGI compiler
1656	<	# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1657	<	# +DA*, +DD* enable 64-bit mode on the HP compiler
1658	<	# -q* pass through compiler args for the IBM compiler
1659	<	# -m* pass through architecture-specific compiler args for GCC
1660	<	# -m*, -t[45]*, -txscale* pass through architecture-specific
1661	<	# compiler args for GCC
1662	<	# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
1663	<	# -F/path gives path to uninstalled frameworks, gcc on darwin
1664	<	# @file GCC response files
1665	<	-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
1666	<	-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
1667	<
1668	<	# Unknown arguments in both finalize_command and compile_command need
1669	<	# to be aesthetically quoted because they are evaled later.
1670	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1671	<	case $arg in
1672	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1673	<	arg="\"$arg\""
1674	<	;;
1675	<	esac
1676	<	compile_command="$compile_command $arg"
1677	<	finalize_command="$finalize_command $arg"
1678	<	compiler_flags="$compiler_flags $arg"
1679	<	continue
1680	<	;;
1681	<
1682	<	-shrext)
1683	<	prev=shrext
4590	>	-multi_module)
4591	>	single_module="${wl}-multi_module"
4592		continue
4593		;;
4594
#	Line 1691 | Line 4599 | EOF
4599
4600		-no-install)
4601		case $host in
4602	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
4602	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4603		# The PATH hackery in wrapper scripts is required on Windows
4604		# and Darwin in order for the loader to find any dlls it needs.
4605	<	$echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
4606	<	$echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
4605	>	func_warning "\`-no-install' is ignored for $host"
4606	>	func_warning "assuming \`-no-fast-install' instead"
4607		fast_install=no
4608		;;
4609		*) no_install=yes ;;
#	Line 1736 | Line 4644 | EOF
4644		;;
4645
4646		-R*)
4647	<	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
4647	>	func_stripname '-R' '' "$arg"
4648	>	dir=$func_stripname_result
4649		# We need an absolute path.
4650		case $dir in
4651		[\\/]* | [A-Za-z]:[\\/]*) ;;
4652		*)
4653	<	$echo "$modename: only absolute run-paths are allowed" 1>&2
1745	<	exit $EXIT_FAILURE
4653	>	func_fatal_error "only absolute run-paths are allowed"
4654		;;
4655		esac
4656		case "$xrpath " in
#	Line 1752 | Line 4660 | EOF
4660		continue
4661		;;
4662
4663	+	-shared)
4664	+	# The effects of -shared are defined in a previous loop.
4665	+	continue
4666	+	;;
4667	+
4668	+	-shrext)
4669	+	prev=shrext
4670	+	continue
4671	+	;;
4672	+
4673		-static | -static-libtool-libs)
4674		# The effects of -static are defined in a previous loop.
4675		# We used to do the same as -all-static on platforms that
#	Line 1770 | Line 4688 | EOF
4688		prev=vinfo
4689		continue
4690		;;
4691	+
4692		-version-number)
4693		prev=vinfo
4694		vinfo_number=yes
4695		continue
4696		;;
4697
4698	+	-weak)
4699	+	prev=weak
4700	+	continue
4701	+	;;
4702	+
4703		-Wc,*)
4704	<	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
4704	>	func_stripname '-Wc,' '' "$arg"
4705	>	args=$func_stripname_result
4706		arg=
4707		save_ifs="$IFS"; IFS=','
4708		for flag in $args; do
4709		IFS="$save_ifs"
4710	<	case $flag in
4711	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
4712	<	flag="\"$flag\""
1788	<	;;
1789	<	esac
1790	<	arg="$arg $wl$flag"
1791	<	compiler_flags="$compiler_flags $flag"
4710	>	func_quote_for_eval "$flag"
4711	>	arg="$arg $wl$func_quote_for_eval_result"
4712	>	compiler_flags="$compiler_flags $func_quote_for_eval_result"
4713		done
4714		IFS="$save_ifs"
4715	<	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
4715	>	func_stripname ' ' '' "$arg"
4716	>	arg=$func_stripname_result
4717		;;
4718
4719		-Wl,*)
4720	<	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
4720	>	func_stripname '-Wl,' '' "$arg"
4721	>	args=$func_stripname_result
4722		arg=
4723		save_ifs="$IFS"; IFS=','
4724		for flag in $args; do
4725		IFS="$save_ifs"
4726	<	case $flag in
4727	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
4728	<	flag="\"$flag\""
4729	<	;;
1807	<	esac
1808	<	arg="$arg $wl$flag"
1809	<	compiler_flags="$compiler_flags $wl$flag"
1810	<	linker_flags="$linker_flags $flag"
4726	>	func_quote_for_eval "$flag"
4727	>	arg="$arg $wl$func_quote_for_eval_result"
4728	>	compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4729	>	linker_flags="$linker_flags $func_quote_for_eval_result"
4730		done
4731		IFS="$save_ifs"
4732	<	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
4732	>	func_stripname ' ' '' "$arg"
4733	>	arg=$func_stripname_result
4734		;;
4735
4736		-Xcompiler)
#	Line 1828 | Line 4748 | EOF
4748		continue
4749		;;
4750
4751	+	# -msg_* for osf cc
4752	+	-msg_*)
4753	+	func_quote_for_eval "$arg"
4754	+	arg="$func_quote_for_eval_result"
4755	+	;;
4756	+
4757	+	# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4758	+	# -r[0-9][0-9]* specifies the processor on the SGI compiler
4759	+	# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4760	+	# +DA*, +DD* enable 64-bit mode on the HP compiler
4761	+	# -q* pass through compiler args for the IBM compiler
4762	+	# -m*, -t[45]*, -txscale* pass through architecture-specific
4763	+	# compiler args for GCC
4764	+	# -F/path gives path to uninstalled frameworks, gcc on darwin
4765	+	# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4766	+	# @file GCC response files
4767	+	-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4768	+	-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4769	+	func_quote_for_eval "$arg"
4770	+	arg="$func_quote_for_eval_result"
4771	+	func_append compile_command " $arg"
4772	+	func_append finalize_command " $arg"
4773	+	compiler_flags="$compiler_flags $arg"
4774	+	continue
4775	+	;;
4776	+
4777		# Some other compiler flag.
4778		-* | +*)
4779	<	# Unknown arguments in both finalize_command and compile_command need
4780	<	# to be aesthetically quoted because they are evaled later.
1835	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1836	<	case $arg in
1837	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1838	<	arg="\"$arg\""
1839	<	;;
1840	<	esac
4779	>	func_quote_for_eval "$arg"
4780	>	arg="$func_quote_for_eval_result"
4781		;;
4782
4783		*.$objext)
#	Line 1849 | Line 4789 | EOF
4789		# A libtool-controlled object.
4790
4791		# Check to see that this really is a libtool object.
4792	<	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4792	>	if func_lalib_unsafe_p "$arg"; then
4793		pic_object=
4794		non_pic_object=
4795
4796		# Read the .lo file
4797	<	# If there is no directory component, then add one.
1858	<	case $arg in
1859	<	*/* | *\\*) . $arg ;;
1860	<	*) . ./$arg ;;
1861	<	esac
4797	>	func_source "$arg"
4798
4799	<	if test -z "$pic_object" || \
4799	>	if test -z "$pic_object" ||
4800		test -z "$non_pic_object" ||
4801	<	test "$pic_object" = none && \
4801	>	test "$pic_object" = none &&
4802		test "$non_pic_object" = none; then
4803	<	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
1868	<	exit $EXIT_FAILURE
4803	>	func_fatal_error "cannot find name of object for \`$arg'"
4804		fi
4805
4806		# Extract subdirectory from the argument.
4807	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
4808	<	if test "X$xdir" = "X$arg"; then
1874	<	xdir=
1875	<	else
1876	<	xdir="$xdir/"
1877	<	fi
4807	>	func_dirname "$arg" "/" ""
4808	>	xdir="$func_dirname_result"
4809
4810		if test "$pic_object" != none; then
4811		# Prepend the subdirectory the object is found in.
#	Line 1899 | Line 4830 | EOF
4830		fi
4831
4832		# A PIC object.
4833	<	libobjs="$libobjs $pic_object"
4833	>	func_append libobjs " $pic_object"
4834		arg="$pic_object"
4835		fi
4836
#	Line 1909 | Line 4840 | EOF
4840		non_pic_object="$xdir$non_pic_object"
4841
4842		# A standard non-PIC object
4843	<	non_pic_objects="$non_pic_objects $non_pic_object"
4843	>	func_append non_pic_objects " $non_pic_object"
4844		if test -z "$pic_object" || test "$pic_object" = none ; then
4845		arg="$non_pic_object"
4846		fi
#	Line 1917 | Line 4848 | EOF
4848		# If the PIC object exists, use it instead.
4849		# $xdir was prepended to $pic_object above.
4850		non_pic_object="$pic_object"
4851	<	non_pic_objects="$non_pic_objects $non_pic_object"
4851	>	func_append non_pic_objects " $non_pic_object"
4852		fi
4853		else
4854		# Only an error if not doing a dry-run.
4855	<	if test -z "$run"; then
1925	<	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1926	<	exit $EXIT_FAILURE
1927	<	else
1928	<	# Dry-run case.
1929	<
4855	>	if $opt_dry_run; then
4856		# Extract subdirectory from the argument.
4857	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
4858	<	if test "X$xdir" = "X$arg"; then
1933	<	xdir=
1934	<	else
1935	<	xdir="$xdir/"
1936	<	fi
4857	>	func_dirname "$arg" "/" ""
4858	>	xdir="$func_dirname_result"
4859
4860	<	pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
4861	<	non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
4862	<	libobjs="$libobjs $pic_object"
4863	<	non_pic_objects="$non_pic_objects $non_pic_object"
4860	>	func_lo2o "$arg"
4861	>	pic_object=$xdir$objdir/$func_lo2o_result
4862	>	non_pic_object=$xdir$func_lo2o_result
4863	>	func_append libobjs " $pic_object"
4864	>	func_append non_pic_objects " $non_pic_object"
4865	>	else
4866	>	func_fatal_error "\`$arg' is not a valid libtool object"
4867		fi
4868		fi
4869		;;
#	Line 1971 | Line 4896 | EOF
4896		*)
4897		# Unknown arguments in both finalize_command and compile_command need
4898		# to be aesthetically quoted because they are evaled later.
4899	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4900	<	case $arg in
1976	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1977	<	arg="\"$arg\""
1978	<	;;
1979	<	esac
4899	>	func_quote_for_eval "$arg"
4900	>	arg="$func_quote_for_eval_result"
4901		;;
4902		esac # arg
4903
4904		# Now actually substitute the argument into the commands.
4905		if test -n "$arg"; then
4906	<	compile_command="$compile_command $arg"
4907	<	finalize_command="$finalize_command $arg"
4906	>	func_append compile_command " $arg"
4907	>	func_append finalize_command " $arg"
4908		fi
4909		done # argument parsing loop
4910
4911	<	if test -n "$prev"; then
4912	<	$echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1992	<	$echo "$help" 1>&2
1993	<	exit $EXIT_FAILURE
1994	<	fi
4911	>	test -n "$prev" && \
4912	>	func_fatal_help "the \`$prevarg' option requires an argument"
4913
4914		if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4915		eval arg=\"$export_dynamic_flag_spec\"
4916	<	compile_command="$compile_command $arg"
4917	<	finalize_command="$finalize_command $arg"
4916	>	func_append compile_command " $arg"
4917	>	func_append finalize_command " $arg"
4918		fi
4919
4920		oldlibs=
4921		# calculate the name of the file, without its directory
4922	<	outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
4922	>	func_basename "$output"
4923	>	outputname="$func_basename_result"
4924		libobjs_save="$libobjs"
4925
4926		if test -n "$shlibpath_var"; then
4927		# get the directories listed in $shlibpath_var
4928	<	eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4928	>	eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4929		else
4930		shlib_search_path=
4931		fi
4932		eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4933		eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4934
4935	<	output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
4936	<	if test "X$output_objdir" = "X$output"; then
2018	<	output_objdir="$objdir"
2019	<	else
2020	<	output_objdir="$output_objdir/$objdir"
2021	<	fi
4935	>	func_dirname "$output" "/" ""
4936	>	output_objdir="$func_dirname_result$objdir"
4937		# Create the object directory.
4938	<	if test ! -d "$output_objdir"; then
2024	<	$show "$mkdir $output_objdir"
2025	<	$run $mkdir $output_objdir
2026	<	exit_status=$?
2027	<	if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
2028	<	exit $exit_status
2029	<	fi
2030	<	fi
4938	>	func_mkdir_p "$output_objdir"
4939
4940		# Determine the type of output
4941		case $output in
4942		"")
4943	<	$echo "$modename: you must specify an output file" 1>&2
2036	<	$echo "$help" 1>&2
2037	<	exit $EXIT_FAILURE
4943	>	func_fatal_help "you must specify an output file"
4944		;;
4945		*.$libext) linkmode=oldlib ;;
4946		*.lo | *.$objext) linkmode=obj ;;
#	Line 2042 | Line 4948 | EOF
4948		*) linkmode=prog ;; # Anything else should be a program.
4949		esac
4950
2045	–	case $host in
2046	–	*cygwin* | *mingw* | *pw32*)
2047	–	# don't eliminate duplications in $postdeps and $predeps
2048	–	duplicate_compiler_generated_deps=yes
2049	–	;;
2050	–	*)
2051	–	duplicate_compiler_generated_deps=$duplicate_deps
2052	–	;;
2053	–	esac
4951		specialdeplibs=
4952
4953		libs=
4954		# Find all interdependent deplibs by searching for libraries
4955		# that are linked more than once (e.g. -la -lb -la)
4956		for deplib in $deplibs; do
4957	<	if test "X$duplicate_deps" = "Xyes" ; then
4957	>	if $opt_duplicate_deps ; then
4958		case "$libs " in
4959		*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4960		esac
#	Line 2072 | Line 4969 | EOF
4969		# $postdeps and mark them as special (i.e., whose duplicates are
4970		# not to be eliminated).
4971		pre_post_deps=
4972	<	if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
4972	>	if $opt_duplicate_compiler_generated_deps; then
4973		for pre_post_dep in $predeps $postdeps; do
4974		case "$pre_post_deps " in
4975		*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
#	Line 2088 | Line 4985 | EOF
4985		newlib_search_path=
4986		need_relink=no # whether we're linking any uninstalled libtool libraries
4987		notinst_deplibs= # not-installed libtool libraries
4988	+	notinst_path= # paths that contain not-installed libtool libraries
4989	+
4990		case $linkmode in
4991		lib)
4992	<	passes="conv link"
4992	>	passes="conv dlpreopen link"
4993		for file in $dlfiles $dlprefiles; do
4994		case $file in
4995		*.la) ;;
4996		*)
4997	<	$echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2099	<	exit $EXIT_FAILURE
4997	>	func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
4998		;;
4999		esac
5000		done
#	Line 2112 | Line 5010 | EOF
5010		*)  passes="conv"
5011		;;
5012		esac
5013	+
5014		for pass in $passes; do
5015	+	# The preopen pass in lib mode reverses $deplibs; put it back here
5016	+	# so that -L comes before libs that need it for instance...
5017	+	if test "$linkmode,$pass" = "lib,link"; then
5018	+	## FIXME: Find the place where the list is rebuilt in the wrong
5019	+	##        order, and fix it there properly
5020	+	tmp_deplibs=
5021	+	for deplib in $deplibs; do
5022	+	tmp_deplibs="$deplib $tmp_deplibs"
5023	+	done
5024	+	deplibs="$tmp_deplibs"
5025	+	fi
5026	+
5027		if test "$linkmode,$pass" = "lib,link" ||
5028		test "$linkmode,$pass" = "prog,scan"; then
5029		libs="$deplibs"
#	Line 2125 | Line 5036 | EOF
5036		link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5037		esac
5038		fi
5039	+	if test "$linkmode,$pass" = "lib,dlpreopen"; then
5040	+	# Collect and forward deplibs of preopened libtool libs
5041	+	for lib in $dlprefiles; do
5042	+	# Ignore non-libtool-libs
5043	+	dependency_libs=
5044	+	case $lib in
5045	+	*.la) func_source "$lib" ;;
5046	+	esac
5047	+
5048	+	# Collect preopened libtool deplibs, except any this library
5049	+	# has declared as weak libs
5050	+	for deplib in $dependency_libs; do
5051	+	deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5052	+	case " $weak_libs " in
5053	+	*" $deplib_base "*) ;;
5054	+	*) deplibs="$deplibs $deplib" ;;
5055	+	esac
5056	+	done
5057	+	done
5058	+	libs="$dlprefiles"
5059	+	fi
5060		if test "$pass" = dlopen; then
5061		# Collect dlpreopened libraries
5062		save_deplibs="$deplibs"
5063		deplibs=
5064		fi
5065	+
5066		for deplib in $libs; do
5067		lib=
5068		found=no
#	Line 2140 | Line 5073 | EOF
5073		finalize_deplibs="$deplib $finalize_deplibs"
5074		else
5075		compiler_flags="$compiler_flags $deplib"
5076	+	if test "$linkmode" = lib ; then
5077	+	case "$new_inherited_linker_flags " in
5078	+	*" $deplib "*) ;;
5079	+	* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5080	+	esac
5081	+	fi
5082		fi
5083		continue
5084		;;
5085		-l*)
5086		if test "$linkmode" != lib && test "$linkmode" != prog; then
5087	<	$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
5087	>	func_warning "\`-l' is ignored for archives/objects"
5088		continue
5089		fi
5090	<	name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
5091	<	for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
5090	>	func_stripname '-l' '' "$deplib"
5091	>	name=$func_stripname_result
5092	>	if test "$linkmode" = lib; then
5093	>	searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5094	>	else
5095	>	searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5096	>	fi
5097	>	for searchdir in $searchdirs; do
5098		for search_ext in .la $std_shrext .so .a; do
5099		# Search the libtool library
5100		lib="$searchdir/lib${name}${search_ext}"
#	Line 2179 | Line 5124 | EOF
5124		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5125		case " $predeps $postdeps " in
5126		*" $deplib "*)
5127	<	if (${SED} -e '2q' $lib |
2183	<	grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5127	>	if func_lalib_p "$lib"; then
5128		library_names=
5129		old_library=
5130	<	case $lib in
2187	<	*/* | *\\*) . $lib ;;
2188	<	*) . ./$lib ;;
2189	<	esac
5130	>	func_source "$lib"
5131		for l in $old_library $library_names; do
5132		ll="$l"
5133		done
5134		if test "X$ll" = "X$old_library" ; then # only static version available
5135		found=no
5136	<	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
5137	<	test "X$ladir" = "X$lib" && ladir="."
5136	>	func_dirname "$lib" "" "."
5137	>	ladir="$func_dirname_result"
5138		lib=$ladir/$old_library
5139		if test "$linkmode,$pass" = "prog,link"; then
5140		compile_deplibs="$deplib $compile_deplibs"
#	Line 2205 | Line 5146 | EOF
5146		continue
5147		fi
5148		fi
5149	<	;;
5149	>	;;
5150		*) ;;
5151		esac
5152		fi
5153		fi
5154		;; # -l
5155	+	*.ltframework)
5156	+	if test "$linkmode,$pass" = "prog,link"; then
5157	+	compile_deplibs="$deplib $compile_deplibs"
5158	+	finalize_deplibs="$deplib $finalize_deplibs"
5159	+	else
5160	+	deplibs="$deplib $deplibs"
5161	+	if test "$linkmode" = lib ; then
5162	+	case "$new_inherited_linker_flags " in
5163	+	*" $deplib "*) ;;
5164	+	* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5165	+	esac
5166	+	fi
5167	+	fi
5168	+	continue
5169	+	;;
5170		-L*)
5171		case $linkmode in
5172		lib)
5173		deplibs="$deplib $deplibs"
5174		test "$pass" = conv && continue
5175		newdependency_libs="$deplib $newdependency_libs"
5176	<	newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
5176	>	func_stripname '-L' '' "$deplib"
5177	>	newlib_search_path="$newlib_search_path $func_stripname_result"
5178		;;
5179		prog)
5180		if test "$pass" = conv; then
#	Line 2230 | Line 5187 | EOF
5187		compile_deplibs="$deplib $compile_deplibs"
5188		finalize_deplibs="$deplib $finalize_deplibs"
5189		fi
5190	<	newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
5190	>	func_stripname '-L' '' "$deplib"
5191	>	newlib_search_path="$newlib_search_path $func_stripname_result"
5192		;;
5193		*)
5194	<	$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
5194	>	func_warning "\`-L' is ignored for archives/objects"
5195		;;
5196		esac # linkmode
5197		continue
5198		;; # -L
5199		-R*)
5200		if test "$pass" = link; then
5201	<	dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
5201	>	func_stripname '-R' '' "$deplib"
5202	>	dir=$func_stripname_result
5203		# Make sure the xrpath contains only unique directories.
5204		case "$xrpath " in
5205		*" $dir "*) ;;
#	Line 2258 | Line 5217 | EOF
5217		fi
5218		case $linkmode in
5219		lib)
5220	<	valid_a_lib=no
5221	<	case $deplibs_check_method in
5222	<	match_pattern*)
5223	<	set dummy $deplibs_check_method
5224	<	match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
5225	<	if eval $echo \"$deplib\" 2>/dev/null \
5226	<	| $SED 10q \
5220	>	# Linking convenience modules into shared libraries is allowed,
5221	>	# but linking other static libraries is non-portable.
5222	>	case " $dlpreconveniencelibs " in
5223	>	*" $deplib "*) ;;
5224	>	*)
5225	>	valid_a_lib=no
5226	>	case $deplibs_check_method in
5227	>	match_pattern*)
5228	>	set dummy $deplibs_check_method; shift
5229	>	match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5230	>	if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5231		| $EGREP "$match_pattern_regex" > /dev/null; then
5232	<	valid_a_lib=yes
5233	<	fi
5232	>	valid_a_lib=yes
5233	>	fi
5234		;;
5235	<	pass_all)
5236	<	valid_a_lib=yes
5235	>	pass_all)
5236	>	valid_a_lib=yes
5237		;;
5238	<	esac
5239	<	if test "$valid_a_lib" != yes; then
5240	<	$echo
5241	<	$echo "*** Warning: Trying to link with static lib archive $deplib."
5242	<	$echo "*** I have the capability to make that library automatically link in when"
5243	<	$echo "*** you link to this library.  But I can only do this if you have a"
5244	<	$echo "*** shared version of the library, which you do not appear to have"
5245	<	$echo "*** because the file extensions .$libext of this argument makes me believe"
5246	<	$echo "*** that it is just a static archive that I should not used here."
5247	<	else
5248	<	$echo
5249	<	$echo "*** Warning: Linking the shared library $output against the"
5250	<	$echo "*** static library $deplib is not portable!"
5251	<	deplibs="$deplib $deplibs"
5252	<	fi
5238	>	esac
5239	>	if test "$valid_a_lib" != yes; then
5240	>	$ECHO
5241	>	$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5242	>	$ECHO "*** I have the capability to make that library automatically link in when"
5243	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
5244	>	$ECHO "*** shared version of the library, which you do not appear to have"
5245	>	$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5246	>	$ECHO "*** that it is just a static archive that I should not use here."
5247	>	else
5248	>	$ECHO
5249	>	$ECHO "*** Warning: Linking the shared library $output against the"
5250	>	$ECHO "*** static library $deplib is not portable!"
5251	>	deplibs="$deplib $deplibs"
5252	>	fi
5253	>	;;
5254	>	esac
5255		continue
5256		;;
5257		prog)
#	Line 2321 | Line 5286 | EOF
5286		continue
5287		;;
5288		esac # case $deplib
5289	+
5290		if test "$found" = yes || test -f "$lib"; then :
5291		else
5292	<	$echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2327	<	exit $EXIT_FAILURE
5292	>	func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5293		fi
5294
5295		# Check to see that this really is a libtool archive.
5296	<	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5297	<	else
2333	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2334	<	exit $EXIT_FAILURE
2335	<	fi
5296	>	func_lalib_unsafe_p "$lib" \
5297	>	|| func_fatal_error "\`$lib' is not a valid libtool archive"
5298
5299	<	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
5300	<	test "X$ladir" = "X$lib" && ladir="."
5299	>	func_dirname "$lib" "" "."
5300	>	ladir="$func_dirname_result"
5301
5302		dlname=
5303		dlopen=
#	Line 2343 | Line 5305 | EOF
5305		libdir=
5306		library_names=
5307		old_library=
5308	+	inherited_linker_flags=
5309		# If the library was installed with an old release of libtool,
5310		# it will not redefine variables installed, or shouldnotlink
5311		installed=yes
#	Line 2351 | Line 5314 | EOF
5314
5315
5316		# Read the .la file
5317	<	case $lib in
2355	<	*/* | *\\*) . $lib ;;
2356	<	*) . ./$lib ;;
2357	<	esac
5317	>	func_source "$lib"
5318
5319	+	# Convert "-framework foo" to "foo.ltframework"
5320	+	if test -n "$inherited_linker_flags"; then
5321	+	tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5322	+	for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5323	+	case " $new_inherited_linker_flags " in
5324	+	*" $tmp_inherited_linker_flag "*) ;;
5325	+	*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5326	+	esac
5327	+	done
5328	+	fi
5329	+	dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5330		if test "$linkmode,$pass" = "lib,link" ||
5331		test "$linkmode,$pass" = "prog,scan" ||
5332		{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
#	Line 2368 | Line 5339 | EOF
5339		deplibs="$lib $deplibs"
5340		if test -z "$libdir"; then
5341		if test -z "$old_library"; then
5342	<	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2372	<	exit $EXIT_FAILURE
5342	>	func_fatal_error "cannot find name of link library for \`$lib'"
5343		fi
5344		# It is a libtool convenience library, so add in its objects.
5345		convenience="$convenience $ladir/$objdir/$old_library"
5346		old_convenience="$old_convenience $ladir/$objdir/$old_library"
2377	–	tmp_libs=
2378	–	for deplib in $dependency_libs; do
2379	–	deplibs="$deplib $deplibs"
2380	–	if test "X$duplicate_deps" = "Xyes" ; then
2381	–	case "$tmp_libs " in
2382	–	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2383	–	esac
2384	–	fi
2385	–	tmp_libs="$tmp_libs $deplib"
2386	–	done
5347		elif test "$linkmode" != prog && test "$linkmode" != lib; then
5348	<	$echo "$modename: \`$lib' is not a convenience library" 1>&2
2389	<	exit $EXIT_FAILURE
5348	>	func_fatal_error "\`$lib' is not a convenience library"
5349		fi
5350	+	tmp_libs=
5351	+	for deplib in $dependency_libs; do
5352	+	deplibs="$deplib $deplibs"
5353	+	if $opt_duplicate_deps ; then
5354	+	case "$tmp_libs " in
5355	+	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5356	+	esac
5357	+	fi
5358	+	tmp_libs="$tmp_libs $deplib"
5359	+	done
5360		continue
5361		fi # $pass = conv
5362
#	Line 2398 | Line 5367 | EOF
5367		linklib="$l"
5368		done
5369		if test -z "$linklib"; then
5370	<	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2402	<	exit $EXIT_FAILURE
5370	>	func_fatal_error "cannot find name of link library for \`$lib'"
5371		fi
5372
5373		# This library was specified with -dlopen.
5374		if test "$pass" = dlopen; then
5375		if test -z "$libdir"; then
5376	<	$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2409	<	exit $EXIT_FAILURE
5376	>	func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5377		fi
5378		if test -z "$dlname" ||
5379		test "$dlopen_support" != yes ||
#	Line 2428 | Line 5395 | EOF
5395		*)
5396		abs_ladir=`cd "$ladir" && pwd`
5397		if test -z "$abs_ladir"; then
5398	<	$echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
5399	<	$echo "$modename: passing it literally to the linker, although it might fail" 1>&2
5398	>	func_warning "cannot determine absolute directory name of \`$ladir'"
5399	>	func_warning "passing it literally to the linker, although it might fail"
5400		abs_ladir="$ladir"
5401		fi
5402		;;
5403		esac
5404	<	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5404	>	func_basename "$lib"
5405	>	laname="$func_basename_result"
5406
5407		# Find the relevant object directory and library name.
5408		if test "X$installed" = Xyes; then
5409		if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5410	<	$echo "$modename: warning: library \`$lib' was moved." 1>&2
5410	>	func_warning "library \`$lib' was moved."
5411		dir="$ladir"
5412		absdir="$abs_ladir"
5413		libdir="$abs_ladir"
#	Line 2461 | Line 5429 | EOF
5429		notinst_path="$notinst_path $abs_ladir"
5430		fi
5431		fi # $installed = yes
5432	<	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
5432	>	func_stripname 'lib' '.la' "$laname"
5433	>	name=$func_stripname_result
5434
5435		# This library was specified with -dlpreopen.
5436		if test "$pass" = dlpreopen; then
5437	<	if test -z "$libdir"; then
5438	<	$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2470	<	exit $EXIT_FAILURE
5437	>	if test -z "$libdir" && test "$linkmode" = prog; then
5438	>	func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5439		fi
5440		# Prefer using a static library (so that no silly _DYNAMIC symbols
5441		# are required to link).
5442		if test -n "$old_library"; then
5443		newdlprefiles="$newdlprefiles $dir/$old_library"
5444	+	# Keep a list of preopened convenience libraries to check
5445	+	# that they are being used correctly in the link pass.
5446	+	test -z "$libdir" && \
5447	+	dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5448		# Otherwise, use the dlname, so that lt_dlopen finds it.
5449		elif test -n "$dlname"; then
5450		newdlprefiles="$newdlprefiles $dir/$dlname"
#	Line 2508 | Line 5480 | EOF
5480		tmp_libs=
5481		for deplib in $dependency_libs; do
5482		case $deplib in
5483	<	-L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
5483	>	-L*) func_stripname '-L' '' "$deplib"
5484	>	newlib_search_path="$newlib_search_path $func_stripname_result"
5485	>	;;
5486		esac
5487		# Need to link against all dependency_libs?
5488		if test "$linkalldeplibs" = yes; then
#	Line 2518 | Line 5492 | EOF
5492		# or/and link against static libraries
5493		newdependency_libs="$deplib $newdependency_libs"
5494		fi
5495	<	if test "X$duplicate_deps" = "Xyes" ; then
5495	>	if $opt_duplicate_deps ; then
5496		case "$tmp_libs " in
5497		*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5498		esac
#	Line 2531 | Line 5505 | EOF
5505		if test "$linkmode,$pass" = "prog,link"; then
5506		if test -n "$library_names" &&
5507		{ { test "$prefer_static_libs" = no ||
5508	<	test "$prefer_static_libs,$installed" = "built,yes"; } ||
5508	>	test "$prefer_static_libs,$installed" = "built,yes"; } ||
5509		test -z "$old_library"; }; then
5510		# We need to hardcode the library path
5511		if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5512		# Make sure the rpath contains only unique directories.
5513	<	case "$temp_rpath " in
5514	<	*" $dir "*) ;;
5515	<	*" $absdir "*) ;;
2542	<	*) temp_rpath="$temp_rpath $absdir" ;;
5513	>	case "$temp_rpath:" in
5514	>	*"$absdir:"*) ;;
5515	>	*) temp_rpath="$temp_rpath$absdir:" ;;
5516		esac
5517		fi
5518
#	Line 2577 | Line 5550 | EOF
5550
5551		link_static=no # Whether the deplib will be linked statically
5552		use_static_libs=$prefer_static_libs
5553	<	if test "$use_static_libs" = built && test "$installed" = yes ; then
5553	>	if test "$use_static_libs" = built && test "$installed" = yes; then
5554		use_static_libs=no
5555		fi
5556		if test -n "$library_names" &&
5557		{ test "$use_static_libs" = no || test -z "$old_library"; }; then
5558	<	if test "$installed" = no; then
5559	<	notinst_deplibs="$notinst_deplibs $lib"
5560	<	need_relink=yes
5561	<	fi
5558	>	case $host in
5559	>	*cygwin* | *mingw* | *cegcc*)
5560	>	# No point in relinking DLLs because paths are not encoded
5561	>	notinst_deplibs="$notinst_deplibs $lib"
5562	>	need_relink=no
5563	>	;;
5564	>	*)
5565	>	if test "$installed" = no; then
5566	>	notinst_deplibs="$notinst_deplibs $lib"
5567	>	need_relink=yes
5568	>	fi
5569	>	;;
5570	>	esac
5571		# This is a shared library
5572
5573	<	# Warn about portability, can't link against -module's on
5574	<	# some systems (darwin)
5575	<	if test "$shouldnotlink" = yes && test "$pass" = link ; then
5576	<	$echo
5573	>	# Warn about portability, can't link against -module's on some
5574	>	# systems (darwin).  Don't bleat about dlopened modules though!
5575	>	dlopenmodule=""
5576	>	for dlpremoduletest in $dlprefiles; do
5577	>	if test "X$dlpremoduletest" = "X$lib"; then
5578	>	dlopenmodule="$dlpremoduletest"
5579	>	break
5580	>	fi
5581	>	done
5582	>	if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5583	>	$ECHO
5584		if test "$linkmode" = prog; then
5585	<	$echo "*** Warning: Linking the executable $output against the loadable module"
5585	>	$ECHO "*** Warning: Linking the executable $output against the loadable module"
5586		else
5587	<	$echo "*** Warning: Linking the shared library $output against the loadable module"
5587	>	$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5588		fi
5589	<	$echo "*** $linklib is not portable!"
5589	>	$ECHO "*** $linklib is not portable!"
5590		fi
5591		if test "$linkmode" = lib &&
5592		test "$hardcode_into_libs" = yes; then
#	Line 2627 | Line 5616 | EOF
5616		if test -n "$old_archive_from_expsyms_cmds"; then
5617		# figure out the soname
5618		set dummy $library_names
5619	<	realname="$2"
5620	<	shift; shift
5621	<	libname=`eval \\$echo \"$libname_spec\"`
5619	>	shift
5620	>	realname="$1"
5621	>	shift
5622	>	libname=`eval "\\$ECHO \"$libname_spec\""`
5623		# use dlname if we got it. it's perfectly good, no?
5624		if test -n "$dlname"; then
5625		soname="$dlname"
5626		elif test -n "$soname_spec"; then
5627		# bleh windows
5628		case $host in
5629	<	*cygwin* | mingw*)
5630	<	major=`expr $current - $age`
5629	>	*cygwin* | mingw* | *cegcc*)
5630	>	func_arith $current - $age
5631	>	major=$func_arith_result
5632		versuffix="-$major"
5633		;;
5634		esac
#	Line 2648 | Line 5639 | EOF
5639
5640		# Make a new name for the extract_expsyms_cmds to use
5641		soroot="$soname"
5642	<	soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
5643	<	newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
5642	>	func_basename "$soroot"
5643	>	soname="$func_basename_result"
5644	>	func_stripname 'lib' '.dll' "$soname"
5645	>	newlib=libimp-$func_stripname_result.a
5646
5647		# If the library has no export list, then create one now
5648		if test -f "$output_objdir/$soname-def"; then :
5649		else
5650	<	$show "extracting exported symbol list from \`$soname'"
5651	<	save_ifs="$IFS"; IFS='~'
2659	<	cmds=$extract_expsyms_cmds
2660	<	for cmd in $cmds; do
2661	<	IFS="$save_ifs"
2662	<	eval cmd=\"$cmd\"
2663	<	$show "$cmd"
2664	<	$run eval "$cmd" || exit $?
2665	<	done
2666	<	IFS="$save_ifs"
5650	>	func_verbose "extracting exported symbol list from \`$soname'"
5651	>	func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5652		fi
5653
5654		# Create $newlib
5655		if test -f "$output_objdir/$newlib"; then :; else
5656	<	$show "generating import library for \`$soname'"
5657	<	save_ifs="$IFS"; IFS='~'
2673	<	cmds=$old_archive_from_expsyms_cmds
2674	<	for cmd in $cmds; do
2675	<	IFS="$save_ifs"
2676	<	eval cmd=\"$cmd\"
2677	<	$show "$cmd"
2678	<	$run eval "$cmd" || exit $?
2679	<	done
2680	<	IFS="$save_ifs"
5656	>	func_verbose "generating import library for \`$soname'"
5657	>	func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5658		fi
5659		# make sure the library variables are pointing to the new library
5660		dir=$output_objdir
#	Line 2699 | Line 5676 | EOF
5676		*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5677		*-*-unixware7*) add_dir="-L$dir" ;;
5678		*-*-darwin* )
5679	<	# if the lib is a module then we can not link against
5680	<	# it, someone is ignoring the new warnings I added
5679	>	# if the lib is a (non-dlopened) module then we can not
5680	>	# link against it, someone is ignoring the earlier warnings
5681		if /usr/bin/file -L $add 2> /dev/null |
5682	<	$EGREP ": [^:]* bundle" >/dev/null ; then
5683	<	$echo "** Warning, lib $linklib is a module, not a shared library"
5684	<	if test -z "$old_library" ; then
5685	<	$echo
5686	<	$echo "** And there doesn't seem to be a static archive available"
5687	<	$echo "** The link will probably fail, sorry"
5688	<	else
5689	<	add="$dir/$old_library"
5682	>	$GREP ": [^:]* bundle" >/dev/null ; then
5683	>	if test "X$dlopenmodule" != "X$lib"; then
5684	>	$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5685	>	if test -z "$old_library" ; then
5686	>	$ECHO
5687	>	$ECHO "*** And there doesn't seem to be a static archive available"
5688	>	$ECHO "*** The link will probably fail, sorry"
5689	>	else
5690	>	add="$dir/$old_library"
5691	>	fi
5692	>	elif test -n "$old_library"; then
5693	>	add="$dir/$old_library"
5694		fi
5695		fi
5696		esac
#	Line 2727 | Line 5708 | EOF
5708		fi
5709		;;
5710		relink)
5711	<	if test "$hardcode_direct" = yes; then
5711	>	if test "$hardcode_direct" = yes &&
5712	>	test "$hardcode_direct_absolute" = no; then
5713		add="$dir/$linklib"
5714		elif test "$hardcode_minus_L" = yes; then
5715		add_dir="-L$dir"
#	Line 2751 | Line 5733 | EOF
5733		esac
5734
5735		if test "$lib_linked" != yes; then
5736	<	$echo "$modename: configuration error: unsupported hardcode properties"
2755	<	exit $EXIT_FAILURE
5736	>	func_fatal_configuration "unsupported hardcode properties"
5737		fi
5738
5739		if test -n "$add_shlibpath"; then
#	Line 2767 | Line 5748 | EOF
5748		else
5749		test -n "$add_dir" && deplibs="$add_dir $deplibs"
5750		test -n "$add" && deplibs="$add $deplibs"
5751	<	if test "$hardcode_direct" != yes && \
5752	<	test "$hardcode_minus_L" != yes && \
5751	>	if test "$hardcode_direct" != yes &&
5752	>	test "$hardcode_minus_L" != yes &&
5753		test "$hardcode_shlibpath_var" = yes; then
5754		case :$finalize_shlibpath: in
5755		*":$libdir:"*) ;;
#	Line 2783 | Line 5764 | EOF
5764		add_dir=
5765		add=
5766		# Finalize command for both is simple: just hardcode it.
5767	<	if test "$hardcode_direct" = yes; then
5767	>	if test "$hardcode_direct" = yes &&
5768	>	test "$hardcode_direct_absolute" = no; then
5769		add="$libdir/$linklib"
5770		elif test "$hardcode_minus_L" = yes; then
5771		add_dir="-L$libdir"
#	Line 2797 | Line 5779 | EOF
5779		elif test "$hardcode_automatic" = yes; then
5780		if test -n "$inst_prefix_dir" &&
5781		test -f "$inst_prefix_dir$libdir/$linklib" ; then
5782	<	add="$inst_prefix_dir$libdir/$linklib"
5782	>	add="$inst_prefix_dir$libdir/$linklib"
5783		else
5784	<	add="$libdir/$linklib"
5784	>	add="$libdir/$linklib"
5785		fi
5786		else
5787		# We cannot seem to hardcode it, guess we'll fake it.
#	Line 2843 | Line 5825 | EOF
5825
5826		# Just print a warning and add the library to dependency_libs so
5827		# that the program can be linked against the static library.
5828	<	$echo
5829	<	$echo "*** Warning: This system can not link to static lib archive $lib."
5830	<	$echo "*** I have the capability to make that library automatically link in when"
5831	<	$echo "*** you link to this library.  But I can only do this if you have a"
5832	<	$echo "*** shared version of the library, which you do not appear to have."
5828	>	$ECHO
5829	>	$ECHO "*** Warning: This system can not link to static lib archive $lib."
5830	>	$ECHO "*** I have the capability to make that library automatically link in when"
5831	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
5832	>	$ECHO "*** shared version of the library, which you do not appear to have."
5833		if test "$module" = yes; then
5834	<	$echo "*** But as you try to build a module library, libtool will still create "
5835	<	$echo "*** a static module, that should work as long as the dlopening application"
5836	<	$echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
5834	>	$ECHO "*** But as you try to build a module library, libtool will still create "
5835	>	$ECHO "*** a static module, that should work as long as the dlopening application"
5836	>	$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5837		if test -z "$global_symbol_pipe"; then
5838	<	$echo
5839	<	$echo "*** However, this would only work if libtool was able to extract symbol"
5840	<	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
5841	<	$echo "*** not find such a program.  So, this module is probably useless."
5842	<	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
5838	>	$ECHO
5839	>	$ECHO "*** However, this would only work if libtool was able to extract symbol"
5840	>	$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5841	>	$ECHO "*** not find such a program.  So, this module is probably useless."
5842	>	$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5843		fi
5844		if test "$build_old_libs" = no; then
5845		build_libtool_libs=module
#	Line 2881 | Line 5863 | EOF
5863		temp_deplibs=
5864		for libdir in $dependency_libs; do
5865		case $libdir in
5866	<	-R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
5866	>	-R*) func_stripname '-R' '' "$libdir"
5867	>	temp_xrpath=$func_stripname_result
5868		case " $xrpath " in
5869		*" $temp_xrpath "*) ;;
5870		*) xrpath="$xrpath $temp_xrpath";;
#	Line 2899 | Line 5882 | EOF
5882		tmp_libs=
5883		for deplib in $dependency_libs; do
5884		newdependency_libs="$deplib $newdependency_libs"
5885	<	if test "X$duplicate_deps" = "Xyes" ; then
5885	>	if $opt_duplicate_deps ; then
5886		case "$tmp_libs " in
5887		*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5888		esac
#	Line 2913 | Line 5896 | EOF
5896		case $deplib in
5897		-L*) path="$deplib" ;;
5898		*.la)
5899	<	dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
5900	<	test "X$dir" = "X$deplib" && dir="."
5899	>	func_dirname "$deplib" "" "."
5900	>	dir="$func_dirname_result"
5901		# We need an absolute path.
5902		case $dir in
5903		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5904		*)
5905		absdir=`cd "$dir" && pwd`
5906		if test -z "$absdir"; then
5907	<	$echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
5907	>	func_warning "cannot determine absolute directory name of \`$dir'"
5908		absdir="$dir"
5909		fi
5910		;;
5911		esac
5912	<	if grep "^installed=no" $deplib > /dev/null; then
2930	<	path="$absdir/$objdir"
2931	<	else
2932	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2933	<	if test -z "$libdir"; then
2934	<	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2935	<	exit $EXIT_FAILURE
2936	<	fi
2937	<	if test "$absdir" != "$libdir"; then
2938	<	$echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2939	<	fi
2940	<	path="$absdir"
2941	<	fi
2942	<	depdepl=
5912	>	if $GREP "^installed=no" $deplib > /dev/null; then
5913		case $host in
5914		*-*-darwin*)
5915	<	# we do not want to link against static libs,
2946	<	# but need to link against shared
5915	>	depdepl=
5916		eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5917		if test -n "$deplibrary_names" ; then
5918		for tmp in $deplibrary_names ; do
5919		depdepl=$tmp
5920		done
5921	<	if test -f "$path/$depdepl" ; then
5922	<	depdepl="$path/$depdepl"
5921	>	if test -f "$absdir/$objdir/$depdepl" ; then
5922	>	depdepl="$absdir/$objdir/$depdepl"
5923	>	darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5924	>	if test -z "$darwin_install_name"; then
5925	>	darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
5926	>	fi
5927	>	compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5928	>	linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5929	>	path=
5930		fi
2955	–	# do not add paths which are already there
2956	–	case " $newlib_search_path " in
2957	–	*" $path "*) ;;
2958	–	*) newlib_search_path="$newlib_search_path $path";;
2959	–	esac
5931		fi
2961	–	path=""
5932		;;
5933		*)
5934	<	path="-L$path"
5934	>	path="-L$absdir/$objdir"
5935		;;
5936		esac
5937	+	else
5938	+	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5939	+	test -z "$libdir" && \
5940	+	func_fatal_error "\`$deplib' is not a valid libtool archive"
5941	+	test "$absdir" != "$libdir" && \
5942	+	func_warning "\`$deplib' seems to be moved"
5943	+
5944	+	path="-L$absdir"
5945	+	fi
5946		;;
2968	–	-l*)
2969	–	case $host in
2970	–	*-*-darwin*)
2971	–	# Again, we only want to link against shared libraries
2972	–	eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2973	–	for tmp in $newlib_search_path ; do
2974	–	if test -f "$tmp/lib$tmp_libs.dylib" ; then
2975	–	eval depdepl="$tmp/lib$tmp_libs.dylib"
2976	–	break
2977	–	fi
2978	–	done
2979	–	path=""
2980	–	;;
2981	–	*) continue ;;
2982	–	esac
2983	–	;;
2984	–	*) continue ;;
5947		esac
5948		case " $deplibs " in
5949		*" $path "*) ;;
5950		*) deplibs="$path $deplibs" ;;
5951		esac
2990	–	case " $deplibs " in
2991	–	*" $depdepl "*) ;;
2992	–	*) deplibs="$depdepl $deplibs" ;;
2993	–	esac
5952		done
5953		fi # link_all_deplibs != no
5954		fi # linkmode = lib
5955		done # for deplib in $libs
5956	+	if test "$pass" = link; then
5957	+	if test "$linkmode" = "prog"; then
5958	+	compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5959	+	finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5960	+	else
5961	+	compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5962	+	fi
5963	+	fi
5964		dependency_libs="$newdependency_libs"
5965		if test "$pass" = dlpreopen; then
5966		# Link the dlpreopened libraries before other libraries
#	Line 3093 | Line 6059 | EOF
6059		done # for pass
6060		if test "$linkmode" = prog; then
6061		dlfiles="$newdlfiles"
6062	+	fi
6063	+	if test "$linkmode" = prog || test "$linkmode" = lib; then
6064		dlprefiles="$newdlprefiles"
6065		fi
6066
6067		case $linkmode in
6068		oldlib)
3101	–	if test -n "$deplibs"; then
3102	–	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
3103	–	fi
3104	–
6069		if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6070	<	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
6070	>	func_warning "\`-dlopen' is ignored for archives"
6071		fi
6072
6073	<	if test -n "$rpath"; then
6074	<	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
6075	<	fi
6073	>	case " $deplibs" in
6074	>	*\ -l* | *\ -L*)
6075	>	func_warning "\`-l' and \`-L' are ignored for archives" ;;
6076	>	esac
6077
6078	<	if test -n "$xrpath"; then
6079	<	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3115	<	fi
6078	>	test -n "$rpath" && \
6079	>	func_warning "\`-rpath' is ignored for archives"
6080
6081	<	if test -n "$vinfo"; then
6082	<	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3119	<	fi
6081	>	test -n "$xrpath" && \
6082	>	func_warning "\`-R' is ignored for archives"
6083
6084	<	if test -n "$release"; then
6085	<	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3123	<	fi
6084	>	test -n "$vinfo" && \
6085	>	func_warning "\`-version-info/-version-number' is ignored for archives"
6086
6087	<	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
6088	<	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
6089	<	fi
6087	>	test -n "$release" && \
6088	>	func_warning "\`-release' is ignored for archives"
6089	>
6090	>	test -n "$export_symbols$export_symbols_regex" && \
6091	>	func_warning "\`-export-symbols' is ignored for archives"
6092
6093		# Now set the variables for building old libraries.
6094		build_libtool_libs=no
#	Line 3136 | Line 6100 | EOF
6100		# Make sure we only generate libraries of the form `libNAME.la'.
6101		case $outputname in
6102		lib*)
6103	<	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
6103	>	func_stripname 'lib' '.la' "$outputname"
6104	>	name=$func_stripname_result
6105		eval shared_ext=\"$shrext_cmds\"
6106		eval libname=\"$libname_spec\"
6107		;;
6108		*)
6109	<	if test "$module" = no; then
6110	<	$echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
6111	<	$echo "$help" 1>&2
3147	<	exit $EXIT_FAILURE
3148	<	fi
6109	>	test "$module" = no && \
6110	>	func_fatal_help "libtool library \`$output' must begin with \`lib'"
6111	>
6112		if test "$need_lib_prefix" != no; then
6113		# Add the "lib" prefix for modules if required
6114	<	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
6114	>	func_stripname '' '.la' "$outputname"
6115	>	name=$func_stripname_result
6116		eval shared_ext=\"$shrext_cmds\"
6117		eval libname=\"$libname_spec\"
6118		else
6119	<	libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
6119	>	func_stripname '' '.la' "$outputname"
6120	>	libname=$func_stripname_result
6121		fi
6122		;;
6123		esac
6124
6125		if test -n "$objs"; then
6126		if test "$deplibs_check_method" != pass_all; then
6127	<	$echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3163	<	exit $EXIT_FAILURE
6127	>	func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6128		else
6129	<	$echo
6130	<	$echo "*** Warning: Linking the shared library $output against the non-libtool"
6131	<	$echo "*** objects $objs is not portable!"
6129	>	$ECHO
6130	>	$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6131	>	$ECHO "*** objects $objs is not portable!"
6132		libobjs="$libobjs $objs"
6133		fi
6134		fi
6135
6136	<	if test "$dlself" != no; then
6137	<	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3174	<	fi
6136	>	test "$dlself" != no && \
6137	>	func_warning "\`-dlopen self' is ignored for libtool libraries"
6138
6139		set dummy $rpath
6140	<	if test "$#" -gt 2; then
6141	<	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
6142	<	fi
6143	<	install_libdir="$2"
6140	>	shift
6141	>	test "$#" -gt 1 && \
6142	>	func_warning "ignoring multiple \`-rpath's for a libtool library"
6143	>
6144	>	install_libdir="$1"
6145
6146		oldlibs=
6147		if test -z "$rpath"; then
#	Line 3191 | Line 6155 | EOF
6155		build_old_libs=yes
6156		fi
6157
6158	<	if test -n "$vinfo"; then
6159	<	$echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3196	<	fi
6158	>	test -n "$vinfo" && \
6159	>	func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6160
6161	<	if test -n "$release"; then
6162	<	$echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3200	<	fi
6161	>	test -n "$release" && \
6162	>	func_warning "\`-release' is ignored for convenience libraries"
6163		else
6164
6165		# Parse the version information argument.
6166		save_ifs="$IFS"; IFS=':'
6167		set dummy $vinfo 0 0 0
6168	+	shift
6169		IFS="$save_ifs"
6170
6171	<	if test -n "$8"; then
6172	<	$echo "$modename: too many parameters to \`-version-info'" 1>&2
3210	<	$echo "$help" 1>&2
3211	<	exit $EXIT_FAILURE
3212	<	fi
6171	>	test -n "$7" && \
6172	>	func_fatal_help "too many parameters to \`-version-info'"
6173
6174		# convert absolute version numbers to libtool ages
6175		# this retains compatibility with .la files and attempts
#	Line 3217 | Line 6177 | EOF
6177
6178		case $vinfo_number in
6179		yes)
6180	<	number_major="$2"
6181	<	number_minor="$3"
6182	<	number_revision="$4"
6180	>	number_major="$1"
6181	>	number_minor="$2"
6182	>	number_revision="$3"
6183		#
6184		# There are really only two kinds -- those that
6185		# use the current revision as the major version
#	Line 3229 | Line 6189 | EOF
6189		#
6190		case $version_type in
6191		darwin|linux|osf|windows|none)
6192	<	current=`expr $number_major + $number_minor`
6192	>	func_arith $number_major + $number_minor
6193	>	current=$func_arith_result
6194		age="$number_minor"
6195		revision="$number_revision"
6196		;;
#	Line 3239 | Line 6200 | EOF
6200		age="0"
6201		;;
6202		irix|nonstopux)
6203	<	current=`expr $number_major + $number_minor`
6203	>	func_arith $number_major + $number_minor
6204	>	current=$func_arith_result
6205		age="$number_minor"
6206		revision="$number_minor"
6207		lt_irix_increment=no
#	Line 3247 | Line 6209 | EOF
6209		esac
6210		;;
6211		no)
6212	<	current="$2"
6213	<	revision="$3"
6214	<	age="$4"
6212	>	current="$1"
6213	>	revision="$2"
6214	>	age="$3"
6215		;;
6216		esac
6217
#	Line 3257 | Line 6219 | EOF
6219		case $current in
6220		0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6221		*)
6222	<	$echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
6223	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
3262	<	exit $EXIT_FAILURE
6222	>	func_error "CURRENT \`$current' must be a nonnegative integer"
6223	>	func_fatal_error "\`$vinfo' is not valid version information"
6224		;;
6225		esac
6226
6227		case $revision in
6228		0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6229		*)
6230	<	$echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
6231	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
3271	<	exit $EXIT_FAILURE
6230	>	func_error "REVISION \`$revision' must be a nonnegative integer"
6231	>	func_fatal_error "\`$vinfo' is not valid version information"
6232		;;
6233		esac
6234
6235		case $age in
6236		0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
6237		*)
6238	<	$echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
6239	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
3280	<	exit $EXIT_FAILURE
6238	>	func_error "AGE \`$age' must be a nonnegative integer"
6239	>	func_fatal_error "\`$vinfo' is not valid version information"
6240		;;
6241		esac
6242
6243		if test "$age" -gt "$current"; then
6244	<	$echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
6245	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
3287	<	exit $EXIT_FAILURE
6244	>	func_error "AGE \`$age' is greater than the current interface number \`$current'"
6245	>	func_fatal_error "\`$vinfo' is not valid version information"
6246		fi
6247
6248		# Calculate the version variables.
#	Line 3297 | Line 6255 | EOF
6255		darwin)
6256		# Like Linux, but with the current version available in
6257		# verstring for coding it into the library header
6258	<	major=.`expr $current - $age`
6258	>	func_arith $current - $age
6259	>	major=.$func_arith_result
6260		versuffix="$major.$age.$revision"
6261		# Darwin ld doesn't like 0 for these options...
6262	<	minor_current=`expr $current + 1`
6262	>	func_arith $current + 1
6263	>	minor_current=$func_arith_result
6264		xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6265		verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6266		;;
#	Line 3312 | Line 6272 | EOF
6272
6273		freebsd-elf)
6274		major=".$current"
6275	<	versuffix=".$current";
6275	>	versuffix=".$current"
6276		;;
6277
6278		irix | nonstopux)
6279		if test "X$lt_irix_increment" = "Xno"; then
6280	<	major=`expr $current - $age`
6280	>	func_arith $current - $age
6281		else
6282	<	major=`expr $current - $age + 1`
6282	>	func_arith $current - $age + 1
6283		fi
6284	+	major=$func_arith_result
6285	+
6286		case $version_type in
6287		nonstopux) verstring_prefix=nonstopux ;;
6288		*)         verstring_prefix=sgi ;;
#	Line 3330 | Line 6292 | EOF
6292		# Add in all the interfaces that we are compatible with.
6293		loop=$revision
6294		while test "$loop" -ne 0; do
6295	<	iface=`expr $revision - $loop`
6296	<	loop=`expr $loop - 1`
6295	>	func_arith $revision - $loop
6296	>	iface=$func_arith_result
6297	>	func_arith $loop - 1
6298	>	loop=$func_arith_result
6299		verstring="$verstring_prefix$major.$iface:$verstring"
6300		done
6301
#	Line 3341 | Line 6305 | EOF
6305		;;
6306
6307		linux)
6308	<	major=.`expr $current - $age`
6308	>	func_arith $current - $age
6309	>	major=.$func_arith_result
6310		versuffix="$major.$age.$revision"
6311		;;
6312
6313		osf)
6314	<	major=.`expr $current - $age`
6314	>	func_arith $current - $age
6315	>	major=.$func_arith_result
6316		versuffix=".$current.$age.$revision"
6317		verstring="$current.$age.$revision"
6318
6319		# Add in all the interfaces that we are compatible with.
6320		loop=$age
6321		while test "$loop" -ne 0; do
6322	<	iface=`expr $current - $loop`
6323	<	loop=`expr $loop - 1`
6322	>	func_arith $current - $loop
6323	>	iface=$func_arith_result
6324	>	func_arith $loop - 1
6325	>	loop=$func_arith_result
6326		verstring="$verstring:${iface}.0"
6327		done
6328
#	Line 3362 | Line 6330 | EOF
6330		verstring="$verstring:${current}.0"
6331		;;
6332
6333	+	qnx)
6334	+	major=".$current"
6335	+	versuffix=".$current"
6336	+	;;
6337	+
6338		sunos)
6339		major=".$current"
6340		versuffix=".$current.$revision"
#	Line 3370 | Line 6343 | EOF
6343		windows)
6344		# Use '-' rather than '.', since we only want one
6345		# extension on DOS 8.3 filesystems.
6346	<	major=`expr $current - $age`
6346	>	func_arith $current - $age
6347	>	major=$func_arith_result
6348		versuffix="-$major"
6349		;;
6350
6351		*)
6352	<	$echo "$modename: unknown library version type \`$version_type'" 1>&2
3379	<	$echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3380	<	exit $EXIT_FAILURE
6352	>	func_fatal_configuration "unknown library version type \`$version_type'"
6353		;;
6354		esac
6355
#	Line 3411 | Line 6383 | EOF
6383		# Check to see if the archive will have undefined symbols.
6384		if test "$allow_undefined" = yes; then
6385		if test "$allow_undefined_flag" = unsupported; then
6386	<	$echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
6386	>	func_warning "undefined symbols not allowed in $host shared libraries"
6387		build_libtool_libs=no
6388		build_old_libs=yes
6389		fi
#	Line 3419 | Line 6391 | EOF
6391		# Don't allow undefined symbols.
6392		allow_undefined_flag="$no_undefined_flag"
6393		fi
6394	+
6395		fi
6396
6397	+	func_generate_dlsyms "$libname" "$libname" "yes"
6398	+	libobjs="$libobjs $symfileobj"
6399	+	test "X$libobjs" = "X " && libobjs=
6400	+
6401		if test "$mode" != relink; then
6402		# Remove our outputs, but don't remove object files since they
6403		# may have been created when compiling PIC objects.
6404		removelist=
6405	<	tempremovelist=`$echo "$output_objdir/*"`
6405	>	tempremovelist=`$ECHO "$output_objdir/*"`
6406		for p in $tempremovelist; do
6407		case $p in
6408	<	*.$objext)
6408	>	*.$objext | *.gcno)
6409		;;
6410		$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6411		if test "X$precious_files_regex" != "X"; then
6412	<	if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6413	<	then
6412	>	if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6413	>	then
6414		continue
6415		fi
6416		fi
#	Line 3442 | Line 6419 | EOF
6419		*) ;;
6420		esac
6421		done
6422	<	if test -n "$removelist"; then
6423	<	$show "${rm}r $removelist"
3447	<	$run ${rm}r $removelist
3448	<	fi
6422	>	test -n "$removelist" && \
6423	>	func_show_eval "${RM}r \$removelist"
6424		fi
6425
6426		# Now set the variables for building old libraries.
#	Line 3453 | Line 6428 | EOF
6428		oldlibs="$oldlibs $output_objdir/$libname.$libext"
6429
6430		# Transform .lo files to .o files.
6431	<	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6431	>	oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6432		fi
6433
6434		# Eliminate all temporary directories.
6435		#for path in $notinst_path; do
6436	<	# lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
6437	<	# deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
6438	<	# dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
6436	>	# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6437	>	# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6438	>	# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6439		#done
6440
6441		if test -n "$xrpath"; then
#	Line 3501 | Line 6476 | EOF
6476		if test "$build_libtool_libs" = yes; then
6477		if test -n "$rpath"; then
6478		case $host in
6479	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
6479	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6480		# these systems don't actually have a c library (as such)!
6481		;;
6482		*-*-rhapsody* | *-*-darwin1.[012])
6483		# Rhapsody C library is in the System framework
6484	<	deplibs="$deplibs -framework System"
6484	>	deplibs="$deplibs System.ltframework"
6485		;;
6486		*-*-netbsd*)
6487		# Don't link with libc until the a.out ld.so is fixed.
#	Line 3520 | Line 6495 | EOF
6495		*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6496		# Compiler inserts libc in the correct place for threads to work
6497		;;
6498	<	*)
6498	>	*)
6499		# Add libc to deplibs on all other systems if necessary.
6500		if test "$build_libtool_need_lc" = "yes"; then
6501		deplibs="$deplibs -lc"
#	Line 3557 | Line 6532 | EOF
6532		# limits. Maybe even breaks it.  We compile a program, linking it
6533		# against the deplibs as a proxy for the library.  Then we can check
6534		# whether they linked in statically or dynamically with ldd.
6535	<	$rm conftest.c
6535	>	$opt_dry_run || $RM conftest.c
6536		cat > conftest.c <<EOF
6537		int main() { return 0; }
6538		EOF
6539	<	$rm conftest
6539	>	$opt_dry_run || $RM conftest
6540		if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6541		ldd_output=`ldd conftest`
6542		for i in $deplibs; do
6543	<	name=`expr $i : '-l\(.*\)'`
6544	<	# If $name is empty we are operating on a -L argument.
6545	<	if test "$name" != "" && test "$name" != "0"; then
6543	>	case $i in
6544	>	-l*)
6545	>	func_stripname -l '' "$i"
6546	>	name=$func_stripname_result
6547		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6548		case " $predeps $postdeps " in
6549		*" $i "*)
#	Line 3575 | Line 6551 | EOF
6551		i=""
6552		;;
6553		esac
6554	<	fi
6554	>	fi
6555		if test -n "$i" ; then
6556	<	libname=`eval \\$echo \"$libname_spec\"`
6557	<	deplib_matches=`eval \\$echo \"$library_names_spec\"`
6558	<	set dummy $deplib_matches
6559	<	deplib_match=$2
6556	>	libname=`eval "\\$ECHO \"$libname_spec\""`
6557	>	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6558	>	set dummy $deplib_matches; shift
6559	>	deplib_match=$1
6560		if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6561		newdeplibs="$newdeplibs $i"
6562		else
6563		droppeddeps=yes
6564	<	$echo
6565	<	$echo "*** Warning: dynamic linker does not accept needed library $i."
6566	<	$echo "*** I have the capability to make that library automatically link in when"
6567	<	$echo "*** you link to this library.  But I can only do this if you have a"
6568	<	$echo "*** shared version of the library, which I believe you do not have"
6569	<	$echo "*** because a test_compile did reveal that the linker did not use it for"
6570	<	$echo "*** its dynamic dependency list that programs get resolved with at runtime."
6564	>	$ECHO
6565	>	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6566	>	$ECHO "*** I have the capability to make that library automatically link in when"
6567	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
6568	>	$ECHO "*** shared version of the library, which I believe you do not have"
6569	>	$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6570	>	$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6571		fi
6572		fi
6573	<	else
6573	>	;;
6574	>	*)
6575		newdeplibs="$newdeplibs $i"
6576	<	fi
6576	>	;;
6577	>	esac
6578		done
6579		else
6580		# Error occurred in the first compile.  Let's try to salvage
6581		# the situation: Compile a separate program for each library.
6582		for i in $deplibs; do
6583	<	name=`expr $i : '-l\(.*\)'`
6584	<	# If $name is empty we are operating on a -L argument.
6585	<	if test "$name" != "" && test "$name" != "0"; then
6586	<	$rm conftest
6583	>	case $i in
6584	>	-l*)
6585	>	func_stripname -l '' "$i"
6586	>	name=$func_stripname_result
6587	>	$opt_dry_run || $RM conftest
6588		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6589		ldd_output=`ldd conftest`
6590		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
#	Line 3617 | Line 6596 | EOF
6596		esac
6597		fi
6598		if test -n "$i" ; then
6599	<	libname=`eval \\$echo \"$libname_spec\"`
6600	<	deplib_matches=`eval \\$echo \"$library_names_spec\"`
6601	<	set dummy $deplib_matches
6602	<	deplib_match=$2
6599	>	libname=`eval "\\$ECHO \"$libname_spec\""`
6600	>	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6601	>	set dummy $deplib_matches; shift
6602	>	deplib_match=$1
6603		if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6604		newdeplibs="$newdeplibs $i"
6605		else
6606		droppeddeps=yes
6607	<	$echo
6608	<	$echo "*** Warning: dynamic linker does not accept needed library $i."
6609	<	$echo "*** I have the capability to make that library automatically link in when"
6610	<	$echo "*** you link to this library.  But I can only do this if you have a"
6611	<	$echo "*** shared version of the library, which you do not appear to have"
6612	<	$echo "*** because a test_compile did reveal that the linker did not use this one"
6613	<	$echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6607	>	$ECHO
6608	>	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6609	>	$ECHO "*** I have the capability to make that library automatically link in when"
6610	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
6611	>	$ECHO "*** shared version of the library, which you do not appear to have"
6612	>	$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6613	>	$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6614		fi
6615		fi
6616		else
6617		droppeddeps=yes
6618	<	$echo
6619	<	$echo "*** Warning!  Library $i is needed by this library but I was not able to"
6620	<	$echo "*** make it link in!  You will probably need to install it or some"
6621	<	$echo "*** library that it depends on before this library will be fully"
6622	<	$echo "*** functional.  Installing it before continuing would be even better."
6618	>	$ECHO
6619	>	$ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
6620	>	$ECHO "*** make it link in!  You will probably need to install it or some"
6621	>	$ECHO "*** library that it depends on before this library will be fully"
6622	>	$ECHO "*** functional.  Installing it before continuing would be even better."
6623		fi
6624	<	else
6624	>	;;
6625	>	*)
6626		newdeplibs="$newdeplibs $i"
6627	<	fi
6627	>	;;
6628	>	esac
6629		done
6630		fi
6631		;;
6632		file_magic*)
6633	<	set dummy $deplibs_check_method
6634	<	file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
6633	>	set dummy $deplibs_check_method; shift
6634	>	file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6635		for a_deplib in $deplibs; do
6636	<	name=`expr $a_deplib : '-l\(.*\)'`
6637	<	# If $name is empty we are operating on a -L argument.
6638	<	if test "$name" != "" && test  "$name" != "0"; then
6636	>	case $a_deplib in
6637	>	-l*)
6638	>	func_stripname -l '' "$a_deplib"
6639	>	name=$func_stripname_result
6640		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6641		case " $predeps $postdeps " in
6642		*" $a_deplib "*)
#	Line 3664 | Line 6646 | EOF
6646		esac
6647		fi
6648		if test -n "$a_deplib" ; then
6649	<	libname=`eval \\$echo \"$libname_spec\"`
6649	>	libname=`eval "\\$ECHO \"$libname_spec\""`
6650		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6651		potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6652		for potent_lib in $potential_libs; do
6653		# Follow soft links.
6654	<	if ls -lLd "$potent_lib" 2>/dev/null \
6655	<	| grep " -> " >/dev/null; then
6654	>	if ls -lLd "$potent_lib" 2>/dev/null |
6655	>	$GREP " -> " >/dev/null; then
6656		continue
6657		fi
6658		# The statement above tries to avoid entering an
#	Line 3683 | Line 6665 | EOF
6665		potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6666		case $potliblink in
6667		[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6668	<	*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6668	>	*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6669		esac
6670		done
6671	<	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
6672	<	| ${SED} 10q \
6673	<	| $EGREP "$file_magic_regex" > /dev/null; then
6671	>	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6672	>	$SED -e 10q |
6673	>	$EGREP "$file_magic_regex" > /dev/null; then
6674		newdeplibs="$newdeplibs $a_deplib"
6675		a_deplib=""
6676		break 2
#	Line 3698 | Line 6680 | EOF
6680		fi
6681		if test -n "$a_deplib" ; then
6682		droppeddeps=yes
6683	<	$echo
6684	<	$echo "*** Warning: linker path does not have real file for library $a_deplib."
6685	<	$echo "*** I have the capability to make that library automatically link in when"
6686	<	$echo "*** you link to this library.  But I can only do this if you have a"
6687	<	$echo "*** shared version of the library, which you do not appear to have"
6688	<	$echo "*** because I did check the linker path looking for a file starting"
6683	>	$ECHO
6684	>	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6685	>	$ECHO "*** I have the capability to make that library automatically link in when"
6686	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
6687	>	$ECHO "*** shared version of the library, which you do not appear to have"
6688	>	$ECHO "*** because I did check the linker path looking for a file starting"
6689		if test -z "$potlib" ; then
6690	<	$echo "*** with $libname but no candidates were found. (...for file magic test)"
6690	>	$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6691		else
6692	<	$echo "*** with $libname and none of the candidates passed a file format test"
6693	<	$echo "*** using a file magic. Last file checked: $potlib"
6692	>	$ECHO "*** with $libname and none of the candidates passed a file format test"
6693	>	$ECHO "*** using a file magic. Last file checked: $potlib"
6694		fi
6695		fi
6696	<	else
6696	>	;;
6697	>	*)
6698		# Add a -L argument.
6699		newdeplibs="$newdeplibs $a_deplib"
6700	<	fi
6700	>	;;
6701	>	esac
6702		done # Gone through all deplibs.
6703		;;
6704		match_pattern*)
6705	<	set dummy $deplibs_check_method
6706	<	match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
6705	>	set dummy $deplibs_check_method; shift
6706	>	match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6707		for a_deplib in $deplibs; do
6708	<	name=`expr $a_deplib : '-l\(.*\)'`
6709	<	# If $name is empty we are operating on a -L argument.
6710	<	if test -n "$name" && test "$name" != "0"; then
6708	>	case $a_deplib in
6709	>	-l*)
6710	>	func_stripname -l '' "$a_deplib"
6711	>	name=$func_stripname_result
6712		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6713		case " $predeps $postdeps " in
6714		*" $a_deplib "*)
#	Line 3733 | Line 6718 | EOF
6718		esac
6719		fi
6720		if test -n "$a_deplib" ; then
6721	<	libname=`eval \\$echo \"$libname_spec\"`
6721	>	libname=`eval "\\$ECHO \"$libname_spec\""`
6722		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6723		potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6724		for potent_lib in $potential_libs; do
6725		potlib="$potent_lib" # see symlink-check above in file_magic test
6726	<	if eval $echo \"$potent_lib\" 2>/dev/null \
6727	<	| ${SED} 10q \
3743	<	| $EGREP "$match_pattern_regex" > /dev/null; then
6726	>	if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6727	>	$EGREP "$match_pattern_regex" > /dev/null; then
6728		newdeplibs="$newdeplibs $a_deplib"
6729		a_deplib=""
6730		break 2
#	Line 3750 | Line 6734 | EOF
6734		fi
6735		if test -n "$a_deplib" ; then
6736		droppeddeps=yes
6737	<	$echo
6738	<	$echo "*** Warning: linker path does not have real file for library $a_deplib."
6739	<	$echo "*** I have the capability to make that library automatically link in when"
6740	<	$echo "*** you link to this library.  But I can only do this if you have a"
6741	<	$echo "*** shared version of the library, which you do not appear to have"
6742	<	$echo "*** because I did check the linker path looking for a file starting"
6737	>	$ECHO
6738	>	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6739	>	$ECHO "*** I have the capability to make that library automatically link in when"
6740	>	$ECHO "*** you link to this library.  But I can only do this if you have a"
6741	>	$ECHO "*** shared version of the library, which you do not appear to have"
6742	>	$ECHO "*** because I did check the linker path looking for a file starting"
6743		if test -z "$potlib" ; then
6744	<	$echo "*** with $libname but no candidates were found. (...for regex pattern test)"
6744	>	$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6745		else
6746	<	$echo "*** with $libname and none of the candidates passed a file format test"
6747	<	$echo "*** using a regex pattern. Last file checked: $potlib"
6746	>	$ECHO "*** with $libname and none of the candidates passed a file format test"
6747	>	$ECHO "*** using a regex pattern. Last file checked: $potlib"
6748		fi
6749		fi
6750	<	else
6750	>	;;
6751	>	*)
6752		# Add a -L argument.
6753		newdeplibs="$newdeplibs $a_deplib"
6754	<	fi
6754	>	;;
6755	>	esac
6756		done # Gone through all deplibs.
6757		;;
6758		none | unknown | *)
6759		newdeplibs=""
6760	<	tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
6761	<	-e 's/ -[LR][^ ]*//g'`
6760	>	tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6761	>	-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6762		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6763		for i in $predeps $postdeps ; do
6764		# can't use Xsed below, because $i might contain '/'
6765	<	tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
6765	>	tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6766		done
6767		fi
6768	<	if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
6769	<	| grep . >/dev/null; then
6770	<	$echo
6768	>	if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
6769	>	$GREP . >/dev/null; then
6770	>	$ECHO
6771		if test "X$deplibs_check_method" = "Xnone"; then
6772	<	$echo "*** Warning: inter-library dependencies are not supported in this platform."
6772	>	$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6773		else
6774	<	$echo "*** Warning: inter-library dependencies are not known to be supported."
6774	>	$ECHO "*** Warning: inter-library dependencies are not known to be supported."
6775		fi
6776	<	$echo "*** All declared inter-library dependencies are being dropped."
6776	>	$ECHO "*** All declared inter-library dependencies are being dropped."
6777		droppeddeps=yes
6778		fi
6779		;;
#	Line 3800 | Line 6786 | EOF
6786
6787		case $host in
6788		*-*-rhapsody* | *-*-darwin1.[012])
6789	<	# On Rhapsody replace the C library is the System framework
6790	<	newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
6789	>	# On Rhapsody replace the C library with the System framework
6790	>	newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6791		;;
6792		esac
6793
6794		if test "$droppeddeps" = yes; then
6795		if test "$module" = yes; then
6796	<	$echo
6797	<	$echo "*** Warning: libtool could not satisfy all declared inter-library"
6798	<	$echo "*** dependencies of module $libname.  Therefore, libtool will create"
6799	<	$echo "*** a static module, that should work as long as the dlopening"
6800	<	$echo "*** application is linked with the -dlopen flag."
6796	>	$ECHO
6797	>	$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6798	>	$ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
6799	>	$ECHO "*** a static module, that should work as long as the dlopening"
6800	>	$ECHO "*** application is linked with the -dlopen flag."
6801		if test -z "$global_symbol_pipe"; then
6802	<	$echo
6803	<	$echo "*** However, this would only work if libtool was able to extract symbol"
6804	<	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6805	<	$echo "*** not find such a program.  So, this module is probably useless."
6806	<	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
6802	>	$ECHO
6803	>	$ECHO "*** However, this would only work if libtool was able to extract symbol"
6804	>	$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6805	>	$ECHO "*** not find such a program.  So, this module is probably useless."
6806	>	$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6807		fi
6808		if test "$build_old_libs" = no; then
6809		oldlibs="$output_objdir/$libname.$libext"
#	Line 3827 | Line 6813 | EOF
6813		build_libtool_libs=no
6814		fi
6815		else
6816	<	$echo "*** The inter-library dependencies that have been dropped here will be"
6817	<	$echo "*** automatically added whenever a program is linked with this library"
6818	<	$echo "*** or is declared to -dlopen it."
6816	>	$ECHO "*** The inter-library dependencies that have been dropped here will be"
6817	>	$ECHO "*** automatically added whenever a program is linked with this library"
6818	>	$ECHO "*** or is declared to -dlopen it."
6819
6820		if test "$allow_undefined" = no; then
6821	<	$echo
6822	<	$echo "*** Since this library must not contain undefined symbols,"
6823	<	$echo "*** because either the platform does not support them or"
6824	<	$echo "*** it was explicitly requested with -no-undefined,"
6825	<	$echo "*** libtool will only create a static version of it."
6821	>	$ECHO
6822	>	$ECHO "*** Since this library must not contain undefined symbols,"
6823	>	$ECHO "*** because either the platform does not support them or"
6824	>	$ECHO "*** it was explicitly requested with -no-undefined,"
6825	>	$ECHO "*** libtool will only create a static version of it."
6826		if test "$build_old_libs" = no; then
6827		oldlibs="$output_objdir/$libname.$libext"
6828		build_libtool_libs=module
#	Line 3850 | Line 6836 | EOF
6836		# Done checking deplibs!
6837		deplibs=$newdeplibs
6838		fi
6839	<
6839	>	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6840	>	case $host in
6841	>	*-*-darwin*)
6842	>	newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6843	>	new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6844	>	deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6845	>	;;
6846	>	esac
6847
6848		# move library search paths that coincide with paths to not yet
6849		# installed libraries to the beginning of the library search list
#	Line 3879 | Line 6872 | EOF
6872		done
6873		deplibs="$new_libs"
6874
3882	–
6875		# All the library-specific variables (install_libdir is set above).
6876		library_names=
6877		old_library=
#	Line 3924 | Line 6916 | EOF
6916		test -n "$hardcode_libdirs"; then
6917		libdir="$hardcode_libdirs"
6918		if test -n "$hardcode_libdir_flag_spec_ld"; then
6919	<	case $archive_cmds in
3928	<	*\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
3929	<	*)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
3930	<	esac
6919	>	eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6920		else
6921		eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6922		fi
#	Line 3953 | Line 6942 | EOF
6942		eval shared_ext=\"$shrext_cmds\"
6943		eval library_names=\"$library_names_spec\"
6944		set dummy $library_names
6945	<	realname="$2"
6946	<	shift; shift
6945	>	shift
6946	>	realname="$1"
6947	>	shift
6948
6949		if test -n "$soname_spec"; then
6950		eval soname=\"$soname_spec\"
#	Line 3973 | Line 6963 | EOF
6963		done
6964
6965		# Use standard objects if they are pic
6966	<	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6966	>	test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6967	>	test "X$libobjs" = "X " && libobjs=
6968	>
6969	>	delfiles=
6970	>	if test -n "$export_symbols" && test -n "$include_expsyms"; then
6971	>	$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6972	>	export_symbols="$output_objdir/$libname.uexp"
6973	>	delfiles="$delfiles $export_symbols"
6974	>	fi
6975	>
6976	>	orig_export_symbols=
6977	>	case $host_os in
6978	>	cygwin* | mingw* | cegcc*)
6979	>	if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6980	>	# exporting using user supplied symfile
6981	>	if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6982	>	# and it's NOT already a .def file. Must figure out
6983	>	# which of the given symbols are data symbols and tag
6984	>	# them as such. So, trigger use of export_symbols_cmds.
6985	>	# export_symbols gets reassigned inside the "prepare
6986	>	# the list of exported symbols" if statement, so the
6987	>	# include_expsyms logic still works.
6988	>	orig_export_symbols="$export_symbols"
6989	>	export_symbols=
6990	>	always_export_symbols=yes
6991	>	fi
6992	>	fi
6993	>	;;
6994	>	esac
6995
6996		# Prepare the list of exported symbols
6997		if test -z "$export_symbols"; then
6998		if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6999	<	$show "generating symbol list for \`$libname.la'"
6999	>	func_verbose "generating symbol list for \`$libname.la'"
7000		export_symbols="$output_objdir/$libname.exp"
7001	<	$run $rm $export_symbols
7001	>	$opt_dry_run || $RM $export_symbols
7002		cmds=$export_symbols_cmds
7003		save_ifs="$IFS"; IFS='~'
7004		for cmd in $cmds; do
7005		IFS="$save_ifs"
7006		eval cmd=\"$cmd\"
7007	<	if len=`expr "X$cmd" : ".*"` &&
7008	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7009	<	$show "$cmd"
7010	<	$run eval "$cmd" || exit $?
7011	<	skipped_export=false
7007	>	func_len " $cmd"
7008	>	len=$func_len_result
7009	>	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7010	>	func_show_eval "$cmd" 'exit $?'
7011	>	skipped_export=false
7012		else
7013	<	# The command line is too long to execute in one step.
7014	<	$show "using reloadable object file for export list..."
7015	<	skipped_export=:
7013	>	# The command line is too long to execute in one step.
7014	>	func_verbose "using reloadable object file for export list..."
7015	>	skipped_export=:
7016		# Break out early, otherwise skipped_export may be
7017		# set to false by a later but shorter cmd.
7018		break
7019		fi
7020		done
7021		IFS="$save_ifs"
7022	<	if test -n "$export_symbols_regex"; then
7023	<	$show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
7024	<	$run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
4007	<	$show "$mv \"${export_symbols}T\" \"$export_symbols\""
4008	<	$run eval '$mv "${export_symbols}T" "$export_symbols"'
7022	>	if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7023	>	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7024	>	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7025		fi
7026		fi
7027		fi
7028
7029		if test -n "$export_symbols" && test -n "$include_expsyms"; then
7030	<	$run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
7030	>	tmp_export_symbols="$export_symbols"
7031	>	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7032	>	$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7033	>	fi
7034	>
7035	>	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7036	>	# The given exports_symbols file has to be filtered, so filter it.
7037	>	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7038	>	# FIXME: $output_objdir/$libname.filter potentially contains lots of
7039	>	# 's' commands which not all seds can handle. GNU sed should be fine
7040	>	# though. Also, the filter scales superlinearly with the number of
7041	>	# global variables. join(1) would be nice here, but unfortunately
7042	>	# isn't a blessed tool.
7043	>	$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7044	>	delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7045	>	export_symbols=$output_objdir/$libname.def
7046	>	$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7047		fi
7048
7049		tmp_deplibs=
7050		for test_deplib in $deplibs; do
7051	<	case " $convenience " in
7052	<	*" $test_deplib "*) ;;
7053	<	*)
7054	<	tmp_deplibs="$tmp_deplibs $test_deplib"
7055	<	;;
7056	<	esac
7051	>	case " $convenience " in
7052	>	*" $test_deplib "*) ;;
7053	>	*)
7054	>	tmp_deplibs="$tmp_deplibs $test_deplib"
7055	>	;;
7056	>	esac
7057		done
7058		deplibs="$tmp_deplibs"
7059
7060		if test -n "$convenience"; then
7061	+	if test -n "$whole_archive_flag_spec" &&
7062	+	test "$compiler_needs_object" = yes &&
7063	+	test -z "$libobjs"; then
7064	+	# extract the archives, so we have objects to list.
7065	+	# TODO: could optimize this to just extract one archive.
7066	+	whole_archive_flag_spec=
7067	+	fi
7068		if test -n "$whole_archive_flag_spec"; then
7069		save_libobjs=$libobjs
7070		eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7071	+	test "X$libobjs" = "X " && libobjs=
7072		else
7073		gentop="$output_objdir/${outputname}x"
7074		generated="$generated $gentop"
7075
7076		func_extract_archives $gentop $convenience
7077		libobjs="$libobjs $func_extract_archives_result"
7078	+	test "X$libobjs" = "X " && libobjs=
7079		fi
7080		fi
7081	<
7081	>
7082		if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7083		eval flag=\"$thread_safe_flag_spec\"
7084		linker_flags="$linker_flags $flag"
#	Line 4045 | Line 7086 | EOF
7086
7087		# Make a backup of the uninstalled library when relinking
7088		if test "$mode" = relink; then
7089	<	$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
7089	>	$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7090		fi
7091
7092		# Do each of the archive commands.
#	Line 4058 | Line 7099 | EOF
7099		cmds=$module_cmds
7100		fi
7101		else
7102	<	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7103	<	eval test_cmds=\"$archive_expsym_cmds\"
7104	<	cmds=$archive_expsym_cmds
7105	<	else
7106	<	eval test_cmds=\"$archive_cmds\"
7107	<	cmds=$archive_cmds
7102	>	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7103	>	eval test_cmds=\"$archive_expsym_cmds\"
7104	>	cmds=$archive_expsym_cmds
7105	>	else
7106	>	eval test_cmds=\"$archive_cmds\"
7107	>	cmds=$archive_cmds
7108		fi
7109		fi
7110
7111		if test "X$skipped_export" != "X:" &&
7112	<	len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
7113	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7112	>	func_len " $test_cmds" &&
7113	>	len=$func_len_result &&
7114	>	test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7115		:
7116		else
7117	<	# The command line is too long to link in one step, link piecewise.
7118	<	$echo "creating reloadable object files..."
7117	>	# The command line is too long to link in one step, link piecewise
7118	>	# or, if using GNU ld and skipped_export is not :, use a linker
7119	>	# script.
7120
7121		# Save the value of $output and $libobjs because we want to
7122		# use them later.  If we have whole_archive_flag_spec, we
#	Line 4087 | Line 7130 | EOF
7130		save_libobjs=$libobjs
7131		fi
7132		save_output=$output
7133	<	output_la=`$echo "X$output" | $Xsed -e "$basename"`
7133	>	output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7134
7135		# Clear the reloadable object creation command queue and
7136		# initialize k to one.
7137		test_cmds=
7138		concat_cmds=
7139		objlist=
4097	–	delfiles=
7140		last_robj=
7141		k=1
7142	<	output=$output_objdir/$output_la-${k}.$objext
7143	<	# Loop over the list of objects to be linked.
7144	<	for obj in $save_libobjs
7145	<	do
7146	<	eval test_cmds=\"$reload_cmds $objlist $last_robj\"
7147	<	if test "X$objlist" = X ||
7148	<	{ len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
7149	<	test "$len" -le "$max_cmd_len"; }; then
7150	<	objlist="$objlist $obj"
7142	>
7143	>	if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7144	>	output=${output_objdir}/${output_la}.lnkscript
7145	>	func_verbose "creating GNU ld script: $output"
7146	>	$ECHO 'INPUT (' > $output
7147	>	for obj in $save_libobjs
7148	>	do
7149	>	$ECHO "$obj" >> $output
7150	>	done
7151	>	$ECHO ')' >> $output
7152	>	delfiles="$delfiles $output"
7153	>	elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7154	>	output=${output_objdir}/${output_la}.lnk
7155	>	func_verbose "creating linker input file list: $output"
7156	>	: > $output
7157	>	set x $save_libobjs
7158	>	shift
7159	>	firstobj=
7160	>	if test "$compiler_needs_object" = yes; then
7161	>	firstobj="$1 "
7162	>	shift
7163	>	fi
7164	>	for obj
7165	>	do
7166	>	$ECHO "$obj" >> $output
7167	>	done
7168	>	delfiles="$delfiles $output"
7169	>	output=$firstobj\"$file_list_spec$output\"
7170	>	else
7171	>	if test -n "$save_libobjs"; then
7172	>	func_verbose "creating reloadable object files..."
7173	>	output=$output_objdir/$output_la-${k}.$objext
7174	>	eval test_cmds=\"$reload_cmds\"
7175	>	func_len " $test_cmds"
7176	>	len0=$func_len_result
7177	>	len=$len0
7178	>
7179	>	# Loop over the list of objects to be linked.
7180	>	for obj in $save_libobjs
7181	>	do
7182	>	func_len " $obj"
7183	>	func_arith $len + $func_len_result
7184	>	len=$func_arith_result
7185	>	if test "X$objlist" = X ||
7186	>	test "$len" -lt "$max_cmd_len"; then
7187	>	func_append objlist " $obj"
7188	>	else
7189	>	# The command $test_cmds is almost too long, add a
7190	>	# command to the queue.
7191	>	if test "$k" -eq 1 ; then
7192	>	# The first file doesn't have a previous command to add.
7193	>	eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7194	>	else
7195	>	# All subsequent reloadable object files will link in
7196	>	# the last one created.
7197	>	eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7198	>	fi
7199	>	last_robj=$output_objdir/$output_la-${k}.$objext
7200	>	func_arith $k + 1
7201	>	k=$func_arith_result
7202	>	output=$output_objdir/$output_la-${k}.$objext
7203	>	objlist=$obj
7204	>	func_len " $last_robj"
7205	>	func_arith $len0 + $func_len_result
7206	>	len=$func_arith_result
7207	>	fi
7208	>	done
7209	>	# Handle the remaining objects by creating one last
7210	>	# reloadable object file.  All subsequent reloadable object
7211	>	# files will link in the last one created.
7212	>	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7213	>	eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7214	>	if test -n "$last_robj"; then
7215	>	eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7216	>	fi
7217	>	delfiles="$delfiles $output"
7218	>
7219		else
7220	<	# The command $test_cmds is almost too long, add a
7221	<	# command to the queue.
7222	<	if test "$k" -eq 1 ; then
7223	<	# The first file doesn't have a previous command to add.
7224	<	eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7225	<	else
7226	<	# All subsequent reloadable object files will link in
7227	<	# the last one created.
7228	<	eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
7220	>	output=
7221	>	fi
7222	>
7223	>	if ${skipped_export-false}; then
7224	>	func_verbose "generating symbol list for \`$libname.la'"
7225	>	export_symbols="$output_objdir/$libname.exp"
7226	>	$opt_dry_run || $RM $export_symbols
7227	>	libobjs=$output
7228	>	# Append the command to create the export file.
7229	>	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7230	>	eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7231	>	if test -n "$last_robj"; then
7232	>	eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7233		fi
4120	–	last_robj=$output_objdir/$output_la-${k}.$objext
4121	–	k=`expr $k + 1`
4122	–	output=$output_objdir/$output_la-${k}.$objext
4123	–	objlist=$obj
4124	–	len=1
7234		fi
4126	–	done
4127	–	# Handle the remaining objects by creating one last
4128	–	# reloadable object file.  All subsequent reloadable object
4129	–	# files will link in the last one created.
4130	–	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4131	–	eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7235
7236	<	if ${skipped_export-false}; then
7237	<	$show "generating symbol list for \`$libname.la'"
4135	<	export_symbols="$output_objdir/$libname.exp"
4136	<	$run $rm $export_symbols
4137	<	libobjs=$output
4138	<	# Append the command to create the export file.
4139	<	eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4140	<	fi
4141	<
4142	<	# Set up a command to remove the reloadable object files
4143	<	# after they are used.
4144	<	i=0
4145	<	while test "$i" -lt "$k"
4146	<	do
4147	<	i=`expr $i + 1`
4148	<	delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4149	<	done
7236	>	test -n "$save_libobjs" &&
7237	>	func_verbose "creating a temporary reloadable object file: $output"
7238
7239	<	$echo "creating a temporary reloadable object file: $output"
7239	>	# Loop through the commands generated above and execute them.
7240	>	save_ifs="$IFS"; IFS='~'
7241	>	for cmd in $concat_cmds; do
7242	>	IFS="$save_ifs"
7243	>	$opt_silent || {
7244	>	func_quote_for_expand "$cmd"
7245	>	eval "func_echo $func_quote_for_expand_result"
7246	>	}
7247	>	$opt_dry_run || eval "$cmd" || {
7248	>	lt_exit=$?
7249	>
7250	>	# Restore the uninstalled library and exit
7251	>	if test "$mode" = relink; then
7252	>	( cd "$output_objdir" && \
7253	>	$RM "${realname}T" && \
7254	>	$MV "${realname}U" "$realname" )
7255	>	fi
7256
7257	<	# Loop through the commands generated above and execute them.
7258	<	save_ifs="$IFS"; IFS='~'
7259	<	for cmd in $concat_cmds; do
7257	>	exit $lt_exit
7258	>	}
7259	>	done
7260		IFS="$save_ifs"
7261	<	$show "$cmd"
7262	<	$run eval "$cmd" || exit $?
7263	<	done
7264	<	IFS="$save_ifs"
7261	>
7262	>	if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7263	>	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7264	>	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7265	>	fi
7266	>	fi
7267	>
7268	>	if ${skipped_export-false}; then
7269	>	if test -n "$export_symbols" && test -n "$include_expsyms"; then
7270	>	tmp_export_symbols="$export_symbols"
7271	>	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7272	>	$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7273	>	fi
7274	>
7275	>	if test -n "$orig_export_symbols"; then
7276	>	# The given exports_symbols file has to be filtered, so filter it.
7277	>	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7278	>	# FIXME: $output_objdir/$libname.filter potentially contains lots of
7279	>	# 's' commands which not all seds can handle. GNU sed should be fine
7280	>	# though. Also, the filter scales superlinearly with the number of
7281	>	# global variables. join(1) would be nice here, but unfortunately
7282	>	# isn't a blessed tool.
7283	>	$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7284	>	delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7285	>	export_symbols=$output_objdir/$libname.def
7286	>	$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7287	>	fi
7288	>	fi
7289
7290		libobjs=$output
7291		# Restore the value of output.
#	Line 4165 | Line 7293 | EOF
7293
7294		if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7295		eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7296	+	test "X$libobjs" = "X " && libobjs=
7297		fi
7298		# Expand the library linking commands again to reset the
7299		# value of $libobjs for piecewise linking.
#	Line 4177 | Line 7306 | EOF
7306		cmds=$module_cmds
7307		fi
7308		else
7309	<	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7310	<	cmds=$archive_expsym_cmds
7311	<	else
7312	<	cmds=$archive_cmds
7309	>	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7310	>	cmds=$archive_expsym_cmds
7311	>	else
7312	>	cmds=$archive_cmds
7313		fi
7314		fi
7315	+	fi
7316
7317	<	# Append the command to remove the reloadable object files
7318	<	# to the just-reset $cmds.
7319	<	eval cmds=\"\$cmds~\$rm $delfiles\"
7317	>	if test -n "$delfiles"; then
7318	>	# Append the command to remove temporary files to $cmds.
7319	>	eval cmds=\"\$cmds~\$RM $delfiles\"
7320		fi
7321	+
7322	+	# Add any objects from preloaded convenience libraries
7323	+	if test -n "$dlprefiles"; then
7324	+	gentop="$output_objdir/${outputname}x"
7325	+	generated="$generated $gentop"
7326	+
7327	+	func_extract_archives $gentop $dlprefiles
7328	+	libobjs="$libobjs $func_extract_archives_result"
7329	+	test "X$libobjs" = "X " && libobjs=
7330	+	fi
7331	+
7332		save_ifs="$IFS"; IFS='~'
7333		for cmd in $cmds; do
7334		IFS="$save_ifs"
7335		eval cmd=\"$cmd\"
7336	<	$show "$cmd"
7337	<	$run eval "$cmd" || {
7336	>	$opt_silent || {
7337	>	func_quote_for_expand "$cmd"
7338	>	eval "func_echo $func_quote_for_expand_result"
7339	>	}
7340	>	$opt_dry_run || eval "$cmd" || {
7341		lt_exit=$?
7342
7343		# Restore the uninstalled library and exit
7344		if test "$mode" = relink; then
7345	<	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
7345	>	( cd "$output_objdir" && \
7346	>	$RM "${realname}T" && \
7347	>	$MV "${realname}U" "$realname" )
7348		fi
7349
7350		exit $lt_exit
#	Line 4208 | Line 7354 | EOF
7354
7355		# Restore the uninstalled library and exit
7356		if test "$mode" = relink; then
7357	<	$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
7357	>	$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7358
7359		if test -n "$convenience"; then
7360		if test -z "$whole_archive_flag_spec"; then
7361	<	$show "${rm}r $gentop"
4216	<	$run ${rm}r "$gentop"
7361	>	func_show_eval '${RM}r "$gentop"'
7362		fi
7363		fi
7364
#	Line 4223 | Line 7368 | EOF
7368		# Create links to the real library.
7369		for linkname in $linknames; do
7370		if test "$realname" != "$linkname"; then
7371	<	$show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4227	<	$run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
7371	>	func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7372		fi
7373		done
7374
#	Line 4237 | Line 7381 | EOF
7381		;;
7382
7383		obj)
4240	–	if test -n "$deplibs"; then
4241	–	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4242	–	fi
4243	–
7384		if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7385	<	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
7385	>	func_warning "\`-dlopen' is ignored for objects"
7386		fi
7387
7388	<	if test -n "$rpath"; then
7389	<	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
7390	<	fi
7388	>	case " $deplibs" in
7389	>	*\ -l* | *\ -L*)
7390	>	func_warning "\`-l' and \`-L' are ignored for objects" ;;
7391	>	esac
7392
7393	<	if test -n "$xrpath"; then
7394	<	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4254	<	fi
7393	>	test -n "$rpath" && \
7394	>	func_warning "\`-rpath' is ignored for objects"
7395
7396	<	if test -n "$vinfo"; then
7397	<	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4258	<	fi
7396	>	test -n "$xrpath" && \
7397	>	func_warning "\`-R' is ignored for objects"
7398
7399	<	if test -n "$release"; then
7400	<	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
7401	<	fi
7399	>	test -n "$vinfo" && \
7400	>	func_warning "\`-version-info' is ignored for objects"
7401	>
7402	>	test -n "$release" && \
7403	>	func_warning "\`-release' is ignored for objects"
7404
7405		case $output in
7406		*.lo)
7407	<	if test -n "$objs$old_deplibs"; then
7408	<	$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
7409	<	exit $EXIT_FAILURE
7410	<	fi
7411	<	libobj="$output"
7412	<	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
7407	>	test -n "$objs$old_deplibs" && \
7408	>	func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7409	>
7410	>	libobj=$output
7411	>	func_lo2o "$libobj"
7412	>	obj=$func_lo2o_result
7413		;;
7414		*)
7415		libobj=
#	Line 4277 | Line 7418 | EOF
7418		esac
7419
7420		# Delete the old objects.
7421	<	$run $rm $obj $libobj
7421	>	$opt_dry_run || $RM $obj $libobj
7422
7423		# Objects from convenience libraries.  This assumes
7424		# single-version convenience libraries.  Whenever we create
#	Line 4293 | Line 7434 | EOF
7434		if test -n "$convenience"; then
7435		if test -n "$whole_archive_flag_spec"; then
7436		eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7437	<	reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7437	>	reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7438		else
7439		gentop="$output_objdir/${obj}x"
7440		generated="$generated $gentop"
#	Line 4304 | Line 7445 | EOF
7445		fi
7446
7447		# Create the old-style object.
7448	<	reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7448	>	reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7449
7450		output="$obj"
7451	<	cmds=$reload_cmds
4311	<	save_ifs="$IFS"; IFS='~'
4312	<	for cmd in $cmds; do
4313	<	IFS="$save_ifs"
4314	<	eval cmd=\"$cmd\"
4315	<	$show "$cmd"
4316	<	$run eval "$cmd" || exit $?
4317	<	done
4318	<	IFS="$save_ifs"
7451	>	func_execute_cmds "$reload_cmds" 'exit $?'
7452
7453		# Exit if we aren't doing a library object file.
7454		if test -z "$libobj"; then
7455		if test -n "$gentop"; then
7456	<	$show "${rm}r $gentop"
4324	<	$run ${rm}r $gentop
7456	>	func_show_eval '${RM}r "$gentop"'
7457		fi
7458
7459		exit $EXIT_SUCCESS
#	Line 4329 | Line 7461 | EOF
7461
7462		if test "$build_libtool_libs" != yes; then
7463		if test -n "$gentop"; then
7464	<	$show "${rm}r $gentop"
4333	<	$run ${rm}r $gentop
7464	>	func_show_eval '${RM}r "$gentop"'
7465		fi
7466
7467		# Create an invalid libtool object if no PIC, so that we don't
7468		# accidentally link it into a program.
7469		# $show "echo timestamp > $libobj"
7470	<	# $run eval "echo timestamp > $libobj" || exit $?
7470	>	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7471		exit $EXIT_SUCCESS
7472		fi
7473
#	Line 4344 | Line 7475 | EOF
7475		# Only do commands if we really have different PIC objects.
7476		reload_objs="$libobjs $reload_conv_objs"
7477		output="$libobj"
7478	<	cmds=$reload_cmds
4348	<	save_ifs="$IFS"; IFS='~'
4349	<	for cmd in $cmds; do
4350	<	IFS="$save_ifs"
4351	<	eval cmd=\"$cmd\"
4352	<	$show "$cmd"
4353	<	$run eval "$cmd" || exit $?
4354	<	done
4355	<	IFS="$save_ifs"
7478	>	func_execute_cmds "$reload_cmds" 'exit $?'
7479		fi
7480
7481		if test -n "$gentop"; then
7482	<	$show "${rm}r $gentop"
4360	<	$run ${rm}r $gentop
7482	>	func_show_eval '${RM}r "$gentop"'
7483		fi
7484
7485		exit $EXIT_SUCCESS
#	Line 4365 | Line 7487 | EOF
7487
7488		prog)
7489		case $host in
7490	<	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
7490	>	*cygwin*) func_stripname '' '.exe' "$output"
7491	>	output=$func_stripname_result.exe;;
7492		esac
7493	<	if test -n "$vinfo"; then
7494	<	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4372	<	fi
7493	>	test -n "$vinfo" && \
7494	>	func_warning "\`-version-info' is ignored for programs"
7495
7496	<	if test -n "$release"; then
7497	<	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4376	<	fi
7496	>	test -n "$release" && \
7497	>	func_warning "\`-release' is ignored for programs"
7498
7499	<	if test "$preload" = yes; then
7500	<	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
7501	<	test "$dlopen_self_static" = unknown; then
7502	<	$echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
7503	<	fi
4383	<	fi
7499	>	test "$preload" = yes \
7500	>	&& test "$dlopen_support" = unknown \
7501	>	&& test "$dlopen_self" = unknown \
7502	>	&& test "$dlopen_self_static" = unknown && \
7503	>	func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7504
7505		case $host in
7506		*-*-rhapsody* | *-*-darwin1.[012])
7507		# On Rhapsody replace the C library is the System framework
7508	<	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
7509	<	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
7508	>	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7509	>	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7510		;;
7511		esac
7512
7513		case $host in
7514	<	*darwin*)
7515	<	# Don't allow lazy linking, it breaks C++ global constructors
7516	<	if test "$tagname" = CXX ; then
7517	<	compile_command="$compile_command ${wl}-bind_at_load"
7518	<	finalize_command="$finalize_command ${wl}-bind_at_load"
7519	<	fi
7520	<	;;
7514	>	*-*-darwin*)
7515	>	# Don't allow lazy linking, it breaks C++ global constructors
7516	>	# But is supposedly fixed on 10.4 or later (yay!).
7517	>	if test "$tagname" = CXX ; then
7518	>	case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7519	>	10.[0123])
7520	>	compile_command="$compile_command ${wl}-bind_at_load"
7521	>	finalize_command="$finalize_command ${wl}-bind_at_load"
7522	>	;;
7523	>	esac
7524	>	fi
7525	>	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7526	>	compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7527	>	finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7528	>	;;
7529		esac
7530
7531
#	Line 4472 | Line 7600 | EOF
7600		esac
7601		fi
7602		case $host in
7603	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
7604	<	testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
7603	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7604	>	testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7605		case :$dllsearchpath: in
7606		*":$libdir:"*) ;;
7607	+	::) dllsearchpath=$libdir;;
7608		*) dllsearchpath="$dllsearchpath:$libdir";;
7609		esac
7610		case :$dllsearchpath: in
7611		*":$testbindir:"*) ;;
7612	+	::) dllsearchpath=$testbindir;;
7613		*) dllsearchpath="$dllsearchpath:$testbindir";;
7614		esac
7615		;;
#	Line 4531 | Line 7661 | EOF
7661
7662		if test -n "$libobjs" && test "$build_old_libs" = yes; then
7663		# Transform all the library objects into standard objects.
7664	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7665	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4536	<	fi
4537	<
4538	<	dlsyms=
4539	<	if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4540	<	if test -n "$NM" && test -n "$global_symbol_pipe"; then
4541	<	dlsyms="${outputname}S.c"
4542	<	else
4543	<	$echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4544	<	fi
7664	>	compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7665	>	finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7666		fi
7667
7668	<	if test -n "$dlsyms"; then
4548	<	case $dlsyms in
4549	<	"") ;;
4550	<	*.c)
4551	<	# Discover the nlist of each of the dlfiles.
4552	<	nlist="$output_objdir/${outputname}.nm"
4553	<
4554	<	$show "$rm $nlist ${nlist}S ${nlist}T"
4555	<	$run $rm "$nlist" "${nlist}S" "${nlist}T"
4556	<
4557	<	# Parse the name list into a source file.
4558	<	$show "creating $output_objdir/$dlsyms"
4559	<
4560	<	test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4561	<	/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4562	<	/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
7668	>	func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7669
7670	<	#ifdef __cplusplus
7671	<	extern \"C\" {
7672	<	#endif
4567	<
4568	<	/* Prevent the only kind of declaration conflicts we can make. */
4569	<	#define lt_preloaded_symbols some_other_symbol
4570	<
4571	<	/* External symbol declarations for the compiler. */\
4572	<	"
4573	<
4574	<	if test "$dlself" = yes; then
4575	<	$show "generating symbol list for \`$output'"
4576	<
4577	<	test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4578	<
4579	<	# Add our own program objects to the symbol list.
4580	<	progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4581	<	for arg in $progfiles; do
4582	<	$show "extracting global C symbols from \`$arg'"
4583	<	$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4584	<	done
4585	<
4586	<	if test -n "$exclude_expsyms"; then
4587	<	$run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4588	<	$run eval '$mv "$nlist"T "$nlist"'
4589	<	fi
4590	<
4591	<	if test -n "$export_symbols_regex"; then
4592	<	$run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4593	<	$run eval '$mv "$nlist"T "$nlist"'
4594	<	fi
4595	<
4596	<	# Prepare the list of exported symbols
4597	<	if test -z "$export_symbols"; then
4598	<	export_symbols="$output_objdir/$outputname.exp"
4599	<	$run $rm $export_symbols
4600	<	$run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4601	<	case $host in
4602	<	*cygwin* | *mingw* )
4603	<	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4604	<	$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4605	<	;;
4606	<	esac
4607	<	else
4608	<	$run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4609	<	$run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4610	<	$run eval 'mv "$nlist"T "$nlist"'
4611	<	case $host in
4612	<	*cygwin* | *mingw* )
4613	<	$run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4614	<	$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4615	<	;;
4616	<	esac
4617	<	fi
4618	<	fi
4619	<
4620	<	for arg in $dlprefiles; do
4621	<	$show "extracting global C symbols from \`$arg'"
4622	<	name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4623	<	$run eval '$echo ": $name " >> "$nlist"'
4624	<	$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4625	<	done
4626	<
4627	<	if test -z "$run"; then
4628	<	# Make sure we have at least an empty file.
4629	<	test -f "$nlist" || : > "$nlist"
4630	<
4631	<	if test -n "$exclude_expsyms"; then
4632	<	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4633	<	$mv "$nlist"T "$nlist"
4634	<	fi
4635	<
4636	<	# Try sorting and uniquifying the output.
4637	<	if grep -v "^: " < "$nlist" |
4638	<	if sort -k 3 </dev/null >/dev/null 2>&1; then
4639	<	sort -k 3
4640	<	else
4641	<	sort +2
4642	<	fi |
4643	<	uniq > "$nlist"S; then
4644	<	:
4645	<	else
4646	<	grep -v "^: " < "$nlist" > "$nlist"S
4647	<	fi
4648	<
4649	<	if test -f "$nlist"S; then
4650	<	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4651	<	else
4652	<	$echo '/* NONE */' >> "$output_objdir/$dlsyms"
4653	<	fi
4654	<
4655	<	$echo >> "$output_objdir/$dlsyms" "\
4656	<
4657	<	#undef lt_preloaded_symbols
4658	<
4659	<	#if defined (__STDC__) && __STDC__
4660	<	# define lt_ptr void *
4661	<	#else
4662	<	# define lt_ptr char *
4663	<	# define const
4664	<	#endif
4665	<
4666	<	/* The mapping between symbol names and symbols. */
4667	<	"
4668	<
4669	<	case $host in
4670	<	*cygwin* | *mingw* )
4671	<	$echo >> "$output_objdir/$dlsyms" "\
4672	<	/* DATA imports from DLLs on WIN32 can't be const, because
4673	<	runtime relocations are performed -- see ld's documentation
4674	<	on pseudo-relocs */
4675	<	struct {
4676	<	"
4677	<	;;
4678	<	* )
4679	<	$echo >> "$output_objdir/$dlsyms" "\
4680	<	const struct {
4681	<	"
4682	<	;;
4683	<	esac
4684	<
4685	<
4686	<	$echo >> "$output_objdir/$dlsyms" "\
4687	<	const char *name;
4688	<	lt_ptr address;
4689	<	}
4690	<	lt_preloaded_symbols[] =
4691	<	{\
4692	<	"
4693	<
4694	<	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4695	<
4696	<	$echo >> "$output_objdir/$dlsyms" "\
4697	<	{0, (lt_ptr) 0}
4698	<	};
4699	<
4700	<	/* This works around a problem in FreeBSD linker */
4701	<	#ifdef FREEBSD_WORKAROUND
4702	<	static const void *lt_preloaded_setup() {
4703	<	return lt_preloaded_symbols;
4704	<	}
4705	<	#endif
4706	<
4707	<	#ifdef __cplusplus
4708	<	}
4709	<	#endif\
4710	<	"
4711	<	fi
4712	<
4713	<	pic_flag_for_symtable=
4714	<	case $host in
4715	<	# compiling the symbol table file with pic_flag works around
4716	<	# a FreeBSD bug that causes programs to crash when -lm is
4717	<	# linked before any other PIC object.  But we must not use
4718	<	# pic_flag when linking with -static.  The problem exists in
4719	<	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4720	<	*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4721	<	case "$compile_command " in
4722	<	*" -static "*) ;;
4723	<	*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4724	<	esac;;
4725	<	*-*-hpux*)
4726	<	case "$compile_command " in
4727	<	*" -static "*) ;;
4728	<	*) pic_flag_for_symtable=" $pic_flag";;
4729	<	esac
4730	<	esac
4731	<
4732	<	# Now compile the dynamic symbol file.
4733	<	$show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4734	<	$run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4735	<
4736	<	# Clean up the generated files.
4737	<	$show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4738	<	$run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4739	<
4740	<	# Transform the symbol file into the correct name.
4741	<	case $host in
4742	<	*cygwin* | *mingw* )
4743	<	if test -f "$output_objdir/${outputname}.def" ; then
4744	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4745	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4746	<	else
4747	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4748	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4749	<	fi
4750	<	;;
4751	<	* )
4752	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4753	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4754	<	;;
4755	<	esac
4756	<	;;
4757	<	*)
4758	<	$echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4759	<	exit $EXIT_FAILURE
4760	<	;;
4761	<	esac
4762	<	else
4763	<	# We keep going just in case the user didn't refer to
4764	<	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4765	<	# really was required.
4766	<
4767	<	# Nullify the symbol file.
4768	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4769	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
7670	>	# template prelinking step
7671	>	if test -n "$prelink_cmds"; then
7672	>	func_execute_cmds "$prelink_cmds" 'exit $?'
7673		fi
7674
7675	<	if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7675	>	wrappers_required=yes
7676	>	case $host in
7677	>	*cygwin* | *mingw* )
7678	>	if test "$build_libtool_libs" != yes; then
7679	>	wrappers_required=no
7680	>	fi
7681	>	;;
7682	>	*cegcc)
7683	>	# Disable wrappers for cegcc, we are cross compiling anyway.
7684	>	wrappers_required=no
7685	>	;;
7686	>	*)
7687	>	if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7688	>	wrappers_required=no
7689	>	fi
7690	>	;;
7691	>	esac
7692	>	if test "$wrappers_required" = no; then
7693		# Replace the output file specification.
7694	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
7694	>	compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7695		link_command="$compile_command$compile_rpath"
7696
7697		# We have no uninstalled library dependencies, so finalize right now.
7698	<	$show "$link_command"
7699	<	$run eval "$link_command"
4780	<	exit_status=$?
7698	>	exit_status=0
7699	>	func_show_eval "$link_command" 'exit_status=$?'
7700
7701		# Delete the generated files.
7702	<	if test -n "$dlsyms"; then
7703	<	$show "$rm $output_objdir/${outputname}S.${objext}"
4785	<	$run $rm "$output_objdir/${outputname}S.${objext}"
7702	>	if test -f "$output_objdir/${outputname}S.${objext}"; then
7703	>	func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7704		fi
7705
7706		exit $exit_status
7707		fi
7708
4791	–	if test -n "$shlibpath_var"; then
4792	–	# We should set the shlibpath_var
4793	–	rpath=
4794	–	for dir in $temp_rpath; do
4795	–	case $dir in
4796	–	[\\/]* | [A-Za-z]:[\\/]*)
4797	–	# Absolute path.
4798	–	rpath="$rpath$dir:"
4799	–	;;
4800	–	*)
4801	–	# Relative path: add a thisdir entry.
4802	–	rpath="$rpath\$thisdir/$dir:"
4803	–	;;
4804	–	esac
4805	–	done
4806	–	temp_rpath="$rpath"
4807	–	fi
4808	–
7709		if test -n "$compile_shlibpath$finalize_shlibpath"; then
7710		compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7711		fi
#	Line 4838 | Line 7738 | static const void *lt_preloaded_setup()
7738		# We don't need to create a wrapper script.
7739		link_command="$compile_var$compile_command$compile_rpath"
7740		# Replace the output file specification.
7741	<	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7741	>	link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7742		# Delete the old output file.
7743	<	$run $rm $output
7743	>	$opt_dry_run || $RM $output
7744		# Link the executable and exit
7745	<	$show "$link_command"
4846	<	$run eval "$link_command" || exit $?
7745	>	func_show_eval "$link_command" 'exit $?'
7746		exit $EXIT_SUCCESS
7747		fi
7748
#	Line 4852 | Line 7751 | static const void *lt_preloaded_setup()
7751		link_command="$compile_var$compile_command$compile_rpath"
7752		relink_command="$finalize_var$finalize_command$finalize_rpath"
7753
7754	<	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
7755	<	$echo "$modename: \`$output' will be relinked during installation" 1>&2
7754	>	func_warning "this platform does not like uninstalled shared libraries"
7755	>	func_warning "\`$output' will be relinked during installation"
7756		else
7757		if test "$fast_install" != no; then
7758		link_command="$finalize_var$compile_command$finalize_rpath"
7759		if test "$fast_install" = yes; then
7760	<	relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
7760	>	relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7761		else
7762		# fast_install is set to needless
7763		relink_command=
#	Line 4870 | Line 7769 | static const void *lt_preloaded_setup()
7769		fi
7770
7771		# Replace the output file specification.
7772	<	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7772	>	link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7773
7774		# Delete the old output files.
7775	<	$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
7775	>	$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7776
7777	<	$show "$link_command"
4879	<	$run eval "$link_command" || exit $?
7777	>	func_show_eval "$link_command" 'exit $?'
7778
7779		# Now create the wrapper script.
7780	<	$show "creating $output"
7780	>	func_verbose "creating $output"
7781
7782		# Quote the relink command for shipping.
7783		if test -n "$relink_command"; then
7784		# Preserve any variables that may affect compiler behavior
7785		for var in $variables_saved_for_relink; do
7786		if eval test -z \"\${$var+set}\"; then
7787	<	relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
7787	>	relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7788		elif eval var_value=\$$var; test -z "$var_value"; then
7789		relink_command="$var=; export $var; $relink_command"
7790		else
7791	<	var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
7792	<	relink_command="$var=\"$var_value\"; export $var; $relink_command"
7791	>	func_quote_for_eval "$var_value"
7792	>	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7793		fi
7794		done
7795		relink_command="(cd `pwd`; $relink_command)"
7796	<	relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
7796	>	relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7797		fi
7798
7799	<	# Quote $echo for shipping.
7800	<	if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
7799	>	# Quote $ECHO for shipping.
7800	>	if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7801		case $progpath in
7802		[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7803		*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7804		esac
7805	<	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
7805	>	qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7806		else
7807	<	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
7807	>	qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7808		fi
7809
7810	<	# Only actually do things if our run command is non-null.
7811	<	if test -z "$run"; then
7810	>	# Only actually do things if not in dry run mode.
7811	>	$opt_dry_run || {
7812		# win32 will think the script is a binary if it has
7813		# a .exe suffix, so we strip it off here.
7814		case $output in
7815	<	*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
7815	>	*.exe) func_stripname '' '.exe' "$output"
7816	>	output=$func_stripname_result ;;
7817		esac
7818		# test for cygwin because mv fails w/o .exe extensions
7819		case $host in
7820		*cygwin*)
7821		exeext=.exe
7822	<	outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
7822	>	func_stripname '' '.exe' "$outputname"
7823	>	outputname=$func_stripname_result ;;
7824		*) exeext= ;;
7825		esac
7826		case $host in
7827		*cygwin* | *mingw* )
7828	<	output_name=`basename $output`
7829	<	output_path=`dirname $output`
7830	<	cwrappersource="$output_path/$objdir/lt-$output_name.c"
7831	<	cwrapper="$output_path/$output_name.exe"
7832	<	$rm $cwrappersource $cwrapper
7833	<	trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7834	<
7835	<	cat > $cwrappersource <<EOF
7836	<
7837	<	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
7838	<	Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
7839	<
7840	<	The $output program cannot be directly executed until all the libtool
7841	<	libraries that it depends on are installed.
7842	<
7843	<	This wrapper executable should never be moved out of the build directory.
7844	<	If it is, it will not operate correctly.
7845	<
4946	<	Currently, it simply execs the wrapper *script* "/bin/sh $output",
4947	<	but could eventually absorb all of the scripts functionality and
4948	<	exec $objdir/$outputname directly.
4949	<	*/
4950	<	EOF
4951	<	cat >> $cwrappersource<<"EOF"
4952	<	#include <stdio.h>
4953	<	#include <stdlib.h>
4954	<	#include <unistd.h>
4955	<	#include <malloc.h>
4956	<	#include <stdarg.h>
4957	<	#include <assert.h>
4958	<	#include <string.h>
4959	<	#include <ctype.h>
4960	<	#include <sys/stat.h>
4961	<
4962	<	#if defined(PATH_MAX)
4963	<	# define LT_PATHMAX PATH_MAX
4964	<	#elif defined(MAXPATHLEN)
4965	<	# define LT_PATHMAX MAXPATHLEN
4966	<	#else
4967	<	# define LT_PATHMAX 1024
4968	<	#endif
4969	<
4970	<	#ifndef DIR_SEPARATOR
4971	<	# define DIR_SEPARATOR '/'
4972	<	# define PATH_SEPARATOR ':'
4973	<	#endif
4974	<
4975	<	#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4976	<	defined (__OS2__)
4977	<	# define HAVE_DOS_BASED_FILE_SYSTEM
4978	<	# ifndef DIR_SEPARATOR_2
4979	<	#  define DIR_SEPARATOR_2 '\\'
4980	<	# endif
4981	<	# ifndef PATH_SEPARATOR_2
4982	<	#  define PATH_SEPARATOR_2 ';'
4983	<	# endif
4984	<	#endif
4985	<
4986	<	#ifndef DIR_SEPARATOR_2
4987	<	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4988	<	#else /* DIR_SEPARATOR_2 */
4989	<	# define IS_DIR_SEPARATOR(ch) \
4990	<	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4991	<	#endif /* DIR_SEPARATOR_2 */
4992	<
4993	<	#ifndef PATH_SEPARATOR_2
4994	<	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4995	<	#else /* PATH_SEPARATOR_2 */
4996	<	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4997	<	#endif /* PATH_SEPARATOR_2 */
4998	<
4999	<	#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
5000	<	#define XFREE(stale) do { \
5001	<	if (stale) { free ((void *) stale); stale = 0; } \
5002	<	} while (0)
5003	<
5004	<	/* -DDEBUG is fairly common in CFLAGS.  */
5005	<	#undef DEBUG
5006	<	#if defined DEBUGWRAPPER
5007	<	# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5008	<	#else
5009	<	# define DEBUG(format, ...)
5010	<	#endif
5011	<
5012	<	const char *program_name = NULL;
5013	<
5014	<	void * xmalloc (size_t num);
5015	<	char * xstrdup (const char *string);
5016	<	const char * base_name (const char *name);
5017	<	char * find_executable(const char *wrapper);
5018	<	int    check_executable(const char *path);
5019	<	char * strendzap(char *str, const char *pat);
5020	<	void lt_fatal (const char *message, ...);
5021	<
5022	<	int
5023	<	main (int argc, char *argv[])
5024	<	{
5025	<	char **newargz;
5026	<	int i;
5027	<
5028	<	program_name = (char *) xstrdup (base_name (argv[0]));
5029	<	DEBUG("(main) argv[0]      : %s\n",argv[0]);
5030	<	DEBUG("(main) program_name : %s\n",program_name);
5031	<	newargz = XMALLOC(char *, argc+2);
5032	<	EOF
5033	<
5034	<	cat >> $cwrappersource <<EOF
5035	<	newargz[0] = (char *) xstrdup("$SHELL");
5036	<	EOF
5037	<
5038	<	cat >> $cwrappersource <<"EOF"
5039	<	newargz[1] = find_executable(argv[0]);
5040	<	if (newargz[1] == NULL)
5041	<	lt_fatal("Couldn't find %s", argv[0]);
5042	<	DEBUG("(main) found exe at : %s\n",newargz[1]);
5043	<	/* we know the script has the same name, without the .exe */
5044	<	/* so make sure newargz[1] doesn't end in .exe */
5045	<	strendzap(newargz[1],".exe");
5046	<	for (i = 1; i < argc; i++)
5047	<	newargz[i+1] = xstrdup(argv[i]);
5048	<	newargz[argc+1] = NULL;
5049	<
5050	<	for (i=0; i<argc+1; i++)
5051	<	{
5052	<	DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
5053	<	;
5054	<	}
5055	<
5056	<	EOF
5057	<
5058	<	case $host_os in
5059	<	mingw*)
5060	<	cat >> $cwrappersource <<EOF
5061	<	execv("$SHELL",(char const **)newargz);
5062	<	EOF
5063	<	;;
5064	<	*)
5065	<	cat >> $cwrappersource <<EOF
5066	<	execv("$SHELL",newargz);
5067	<	EOF
5068	<	;;
5069	<	esac
5070	<
5071	<	cat >> $cwrappersource <<"EOF"
5072	<	return 127;
5073	<	}
5074	<
5075	<	void *
5076	<	xmalloc (size_t num)
5077	<	{
5078	<	void * p = (void *) malloc (num);
5079	<	if (!p)
5080	<	lt_fatal ("Memory exhausted");
5081	<
5082	<	return p;
5083	<	}
5084	<
5085	<	char *
5086	<	xstrdup (const char *string)
5087	<	{
5088	<	return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5089	<	;
5090	<	}
5091	<
5092	<	const char *
5093	<	base_name (const char *name)
5094	<	{
5095	<	const char *base;
5096	<
5097	<	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5098	<	/* Skip over the disk name in MSDOS pathnames. */
5099	<	if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5100	<	name += 2;
5101	<	#endif
5102	<
5103	<	for (base = name; *name; name++)
5104	<	if (IS_DIR_SEPARATOR (*name))
5105	<	base = name + 1;
5106	<	return base;
5107	<	}
5108	<
5109	<	int
5110	<	check_executable(const char * path)
5111	<	{
5112	<	struct stat st;
5113	<
5114	<	DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5115	<	if ((!path) || (!*path))
5116	<	return 0;
5117	<
5118	<	if ((stat (path, &st) >= 0) &&
5119	<	(
5120	<	/* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5121	<	#if defined (S_IXOTH)
5122	<	((st.st_mode & S_IXOTH) == S_IXOTH) ||
5123	<	#endif
5124	<	#if defined (S_IXGRP)
5125	<	((st.st_mode & S_IXGRP) == S_IXGRP) ||
5126	<	#endif
5127	<	((st.st_mode & S_IXUSR) == S_IXUSR))
5128	<	)
5129	<	return 1;
5130	<	else
5131	<	return 0;
5132	<	}
5133	<
5134	<	/* Searches for the full path of the wrapper.  Returns
5135	<	newly allocated full path name if found, NULL otherwise */
5136	<	char *
5137	<	find_executable (const char* wrapper)
5138	<	{
5139	<	int has_slash = 0;
5140	<	const char* p;
5141	<	const char* p_next;
5142	<	/* static buffer for getcwd */
5143	<	char tmp[LT_PATHMAX + 1];
5144	<	int tmp_len;
5145	<	char* concat_name;
5146	<
5147	<	DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5148	<
5149	<	if ((wrapper == NULL) || (*wrapper == '\0'))
5150	<	return NULL;
5151	<
5152	<	/* Absolute path? */
5153	<	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5154	<	if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5155	<	{
5156	<	concat_name = xstrdup (wrapper);
5157	<	if (check_executable(concat_name))
5158	<	return concat_name;
5159	<	XFREE(concat_name);
5160	<	}
5161	<	else
5162	<	{
5163	<	#endif
5164	<	if (IS_DIR_SEPARATOR (wrapper[0]))
5165	<	{
5166	<	concat_name = xstrdup (wrapper);
5167	<	if (check_executable(concat_name))
5168	<	return concat_name;
5169	<	XFREE(concat_name);
5170	<	}
5171	<	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5172	<	}
5173	<	#endif
5174	<
5175	<	for (p = wrapper; *p; p++)
5176	<	if (*p == '/')
5177	<	{
5178	<	has_slash = 1;
5179	<	break;
5180	<	}
5181	<	if (!has_slash)
5182	<	{
5183	<	/* no slashes; search PATH */
5184	<	const char* path = getenv ("PATH");
5185	<	if (path != NULL)
5186	<	{
5187	<	for (p = path; *p; p = p_next)
5188	<	{
5189	<	const char* q;
5190	<	size_t p_len;
5191	<	for (q = p; *q; q++)
5192	<	if (IS_PATH_SEPARATOR(*q))
5193	<	break;
5194	<	p_len = q - p;
5195	<	p_next = (*q == '\0' ? q : q + 1);
5196	<	if (p_len == 0)
5197	<	{
5198	<	/* empty path: current directory */
5199	<	if (getcwd (tmp, LT_PATHMAX) == NULL)
5200	<	lt_fatal ("getcwd failed");
5201	<	tmp_len = strlen(tmp);
5202	<	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5203	<	memcpy (concat_name, tmp, tmp_len);
5204	<	concat_name[tmp_len] = '/';
5205	<	strcpy (concat_name + tmp_len + 1, wrapper);
5206	<	}
5207	<	else
5208	<	{
5209	<	concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5210	<	memcpy (concat_name, p, p_len);
5211	<	concat_name[p_len] = '/';
5212	<	strcpy (concat_name + p_len + 1, wrapper);
5213	<	}
5214	<	if (check_executable(concat_name))
5215	<	return concat_name;
5216	<	XFREE(concat_name);
5217	<	}
5218	<	}
5219	<	/* not found in PATH; assume curdir */
5220	<	}
5221	<	/* Relative path | not found in path: prepend cwd */
5222	<	if (getcwd (tmp, LT_PATHMAX) == NULL)
5223	<	lt_fatal ("getcwd failed");
5224	<	tmp_len = strlen(tmp);
5225	<	concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5226	<	memcpy (concat_name, tmp, tmp_len);
5227	<	concat_name[tmp_len] = '/';
5228	<	strcpy (concat_name + tmp_len + 1, wrapper);
5229	<
5230	<	if (check_executable(concat_name))
5231	<	return concat_name;
5232	<	XFREE(concat_name);
5233	<	return NULL;
5234	<	}
5235	<
5236	<	char *
5237	<	strendzap(char *str, const char *pat)
5238	<	{
5239	<	size_t len, patlen;
5240	<
5241	<	assert(str != NULL);
5242	<	assert(pat != NULL);
5243	<
5244	<	len = strlen(str);
5245	<	patlen = strlen(pat);
5246	<
5247	<	if (patlen <= len)
5248	<	{
5249	<	str += len - patlen;
5250	<	if (strcmp(str, pat) == 0)
5251	<	*str = '\0';
5252	<	}
5253	<	return str;
5254	<	}
5255	<
5256	<	static void
5257	<	lt_error_core (int exit_status, const char * mode,
5258	<	const char * message, va_list ap)
5259	<	{
5260	<	fprintf (stderr, "%s: %s: ", program_name, mode);
5261	<	vfprintf (stderr, message, ap);
5262	<	fprintf (stderr, ".\n");
5263	<
5264	<	if (exit_status >= 0)
5265	<	exit (exit_status);
5266	<	}
5267	<
5268	<	void
5269	<	lt_fatal (const char *message, ...)
5270	<	{
5271	<	va_list ap;
5272	<	va_start (ap, message);
5273	<	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5274	<	va_end (ap);
5275	<	}
5276	<	EOF
5277	<	# we should really use a build-platform specific compiler
5278	<	# here, but OTOH, the wrappers (shell script and this C one)
5279	<	# are only useful if you want to execute the "real" binary.
5280	<	# Since the "real" binary is built for $host, then this
5281	<	# wrapper might as well be built for $host, too.
5282	<	$run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5283	<	;;
5284	<	esac
5285	<	$rm $output
5286	<	trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5287	<
5288	<	$echo > $output "\
5289	<	#! $SHELL
5290	<
5291	<	# $output - temporary wrapper script for $objdir/$outputname
5292	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5293	<	#
5294	<	# The $output program cannot be directly executed until all the libtool
5295	<	# libraries that it depends on are installed.
5296	<	#
5297	<	# This wrapper script should never be moved out of the build directory.
5298	<	# If it is, it will not operate correctly.
5299	<
5300	<	# Sed substitution that helps us do robust quoting.  It backslashifies
5301	<	# metacharacters that are still active within double-quoted strings.
5302	<	Xsed='${SED} -e 1s/^X//'
5303	<	sed_quote_subst='$sed_quote_subst'
5304	<
5305	<	# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5306	<	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5307	<	emulate sh
5308	<	NULLCMD=:
5309	<	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5310	<	# is contrary to our usage.  Disable this feature.
5311	<	alias -g '\${1+\"\$@\"}'='\"\$@\"'
5312	<	setopt NO_GLOB_SUBST
5313	<	else
5314	<	case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5315	<	fi
5316	<	BIN_SH=xpg4; export BIN_SH # for Tru64
5317	<	DUALCASE=1; export DUALCASE # for MKS sh
5318	<
5319	<	# The HP-UX ksh and POSIX shell print the target directory to stdout
5320	<	# if CDPATH is set.
5321	<	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5322	<
5323	<	relink_command=\"$relink_command\"
5324	<
5325	<	# This environment variable determines our operation mode.
5326	<	if test \"\$libtool_install_magic\" = \"$magic\"; then
5327	<	# install mode needs the following variable:
5328	<	notinst_deplibs='$notinst_deplibs'
5329	<	else
5330	<	# When we are sourced in execute mode, \$file and \$echo are already set.
5331	<	if test \"\$libtool_execute_magic\" != \"$magic\"; then
5332	<	echo=\"$qecho\"
5333	<	file=\"\$0\"
5334	<	# Make sure echo works.
5335	<	if test \"X\$1\" = X--no-reexec; then
5336	<	# Discard the --no-reexec flag, and continue.
5337	<	shift
5338	<	elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5339	<	# Yippee, \$echo works!
5340	<	:
5341	<	else
5342	<	# Restart under the correct shell, and then maybe \$echo will work.
5343	<	exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5344	<	fi
5345	<	fi\
5346	<	"
5347	<	$echo >> $output "\
5348	<
5349	<	# Find the directory that this script lives in.
5350	<	thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5351	<	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5352	<
5353	<	# Follow symbolic links until we get to the real thisdir.
5354	<	file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5355	<	while test -n \"\$file\"; do
5356	<	destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5357	<
5358	<	# If there was a directory component, then change thisdir.
5359	<	if test \"x\$destdir\" != \"x\$file\"; then
5360	<	case \"\$destdir\" in
5361	<	[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5362	<	*) thisdir=\"\$thisdir/\$destdir\" ;;
5363	<	esac
5364	<	fi
5365	<
5366	<	file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5367	<	file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5368	<	done
5369	<
5370	<	# Try to get the absolute directory name.
5371	<	absdir=\`cd \"\$thisdir\" && pwd\`
5372	<	test -n \"\$absdir\" && thisdir=\"\$absdir\"
5373	<	"
5374	<
5375	<	if test "$fast_install" = yes; then
5376	<	$echo >> $output "\
5377	<	program=lt-'$outputname'$exeext
5378	<	progdir=\"\$thisdir/$objdir\"
5379	<
5380	<	if test ! -f \"\$progdir/\$program\" || \\
5381	<	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5382	<	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5383	<
5384	<	file=\"\$\$-\$program\"
5385	<
5386	<	if test ! -d \"\$progdir\"; then
5387	<	$mkdir \"\$progdir\"
5388	<	else
5389	<	$rm \"\$progdir/\$file\"
5390	<	fi"
5391	<
5392	<	$echo >> $output "\
5393	<
5394	<	# relink executable if necessary
5395	<	if test -n \"\$relink_command\"; then
5396	<	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5397	<	else
5398	<	$echo \"\$relink_command_output\" >&2
5399	<	$rm \"\$progdir/\$file\"
5400	<	exit $EXIT_FAILURE
5401	<	fi
5402	<	fi
5403	<
5404	<	$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5405	<	{ $rm \"\$progdir/\$program\";
5406	<	$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5407	<	$rm \"\$progdir/\$file\"
5408	<	fi"
5409	<	else
5410	<	$echo >> $output "\
5411	<	program='$outputname'
5412	<	progdir=\"\$thisdir/$objdir\"
5413	<	"
5414	<	fi
5415	<
5416	<	$echo >> $output "\
5417	<
5418	<	if test -f \"\$progdir/\$program\"; then"
5419	<
5420	<	# Export our shlibpath_var if we have one.
5421	<	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5422	<	$echo >> $output "\
5423	<	# Add our own library path to $shlibpath_var
5424	<	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5425	<
5426	<	# Some systems cannot cope with colon-terminated $shlibpath_var
5427	<	# The second colon is a workaround for a bug in BeOS R4 sed
5428	<	$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5429	<
5430	<	export $shlibpath_var
5431	<	"
5432	<	fi
5433	<
5434	<	# fixup the dll searchpath if we need to.
5435	<	if test -n "$dllsearchpath"; then
5436	<	$echo >> $output "\
5437	<	# Add the dll search path components to the executable PATH
5438	<	PATH=$dllsearchpath:\$PATH
5439	<	"
5440	<	fi
7828	>	func_dirname_and_basename "$output" "" "."
7829	>	output_name=$func_basename_result
7830	>	output_path=$func_dirname_result
7831	>	cwrappersource="$output_path/$objdir/lt-$output_name.c"
7832	>	cwrapper="$output_path/$output_name.exe"
7833	>	$RM $cwrappersource $cwrapper
7834	>	trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7835	>
7836	>	func_emit_cwrapperexe_src > $cwrappersource
7837	>
7838	>	# The wrapper executable is built using the $host compiler,
7839	>	# because it contains $host paths and files. If cross-
7840	>	# compiling, it, like the target executable, must be
7841	>	# executed on the $host or under an emulation environment.
7842	>	$opt_dry_run || {
7843	>	$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7844	>	$STRIP $cwrapper
7845	>	}
7846
7847	<	$echo >> $output "\
7848	<	if test \"\$libtool_execute_magic\" != \"$magic\"; then
7849	<	# Run the actual program with our arguments.
7850	<	"
7851	<	case $host in
7852	<	# Backslashes separate directories on plain windows
7853	<	*-*-mingw | *-*-os2*)
7854	<	$echo >> $output "\
7855	<	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
7856	<	"
7847	>	# Now, create the wrapper script for func_source use:
7848	>	func_ltwrapper_scriptname $cwrapper
7849	>	$RM $func_ltwrapper_scriptname_result
7850	>	trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7851	>	$opt_dry_run || {
7852	>	# note: this script will not be executed, so do not chmod.
7853	>	if test "x$build" = "x$host" ; then
7854	>	$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7855	>	else
7856	>	func_emit_wrapper no > $func_ltwrapper_scriptname_result
7857	>	fi
7858	>	}
7859		;;
7860	+	* )
7861	+	$RM $output
7862	+	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7863
7864	<	*)
7865	<	$echo >> $output "\
5456	<	exec \"\$progdir/\$program\" \${1+\"\$@\"}
5457	<	"
7864	>	func_emit_wrapper no > $output
7865	>	chmod +x $output
7866		;;
7867		esac
7868	<	$echo >> $output "\
5461	<	\$echo \"\$0: cannot exec \$program \$*\"
5462	<	exit $EXIT_FAILURE
5463	<	fi
5464	<	else
5465	<	# The program doesn't exist.
5466	<	\$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5467	<	\$echo \"This script is just a wrapper for \$program.\" 1>&2
5468	<	$echo \"See the $PACKAGE documentation for more information.\" 1>&2
5469	<	exit $EXIT_FAILURE
5470	<	fi
5471	<	fi\
5472	<	"
5473	<	chmod +x $output
5474	<	fi
7868	>	}
7869		exit $EXIT_SUCCESS
7870		;;
7871		esac
#	Line 5480 | Line 7874 | fi\
7874		for oldlib in $oldlibs; do
7875
7876		if test "$build_libtool_libs" = convenience; then
7877	<	oldobjs="$libobjs_save"
7877	>	oldobjs="$libobjs_save $symfileobj"
7878		addlibs="$convenience"
7879		build_libtool_libs=no
7880		else
#	Line 5489 | Line 7883 | fi\
7883		build_libtool_libs=no
7884		else
7885		oldobjs="$old_deplibs $non_pic_objects"
7886	+	if test "$preload" = yes && test -f "$symfileobj"; then
7887	+	oldobjs="$oldobjs $symfileobj"
7888	+	fi
7889		fi
7890		addlibs="$old_convenience"
7891		fi
#	Line 5503 | Line 7900 | fi\
7900
7901		# Do each command in the archive commands.
7902		if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7903	<	cmds=$old_archive_from_new_cmds
7903	>	cmds=$old_archive_from_new_cmds
7904		else
7905	+
7906	+	# Add any objects from preloaded convenience libraries
7907	+	if test -n "$dlprefiles"; then
7908	+	gentop="$output_objdir/${outputname}x"
7909	+	generated="$generated $gentop"
7910	+
7911	+	func_extract_archives $gentop $dlprefiles
7912	+	oldobjs="$oldobjs $func_extract_archives_result"
7913	+	fi
7914	+
7915		# POSIX demands no paths to be encoded in archives.  We have
7916		# to avoid creating archives with duplicate basenames if we
7917		# might have to extract them afterwards, e.g., when creating a
#	Line 5513 | Line 7920 | fi\
7920		# not supported by libtool).
7921		if (for obj in $oldobjs
7922		do
7923	<	$echo "X$obj" | $Xsed -e 's%^.*/%%'
7923	>	func_basename "$obj"
7924	>	$ECHO "$func_basename_result"
7925		done | sort | sort -uc >/dev/null 2>&1); then
7926		:
7927		else
7928	<	$echo "copying selected object files to avoid basename conflicts..."
7929	<
7930	<	if test -z "$gentop"; then
7931	<	gentop="$output_objdir/${outputname}x"
5524	<	generated="$generated $gentop"
5525	<
5526	<	$show "${rm}r $gentop"
5527	<	$run ${rm}r "$gentop"
5528	<	$show "$mkdir $gentop"
5529	<	$run $mkdir "$gentop"
5530	<	exit_status=$?
5531	<	if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5532	<	exit $exit_status
5533	<	fi
5534	<	fi
5535	<
7928	>	$ECHO "copying selected object files to avoid basename conflicts..."
7929	>	gentop="$output_objdir/${outputname}x"
7930	>	generated="$generated $gentop"
7931	>	func_mkdir_p "$gentop"
7932		save_oldobjs=$oldobjs
7933		oldobjs=
7934		counter=1
7935		for obj in $save_oldobjs
7936		do
7937	<	objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
7937	>	func_basename "$obj"
7938	>	objbase="$func_basename_result"
7939		case " $oldobjs " in
7940		" ") oldobjs=$obj ;;
7941		*[\ /]"$objbase "*)
#	Line 5546 | Line 7943 | fi\
7943		# Make sure we don't pick an alternate name that also
7944		# overlaps.
7945		newobj=lt$counter-$objbase
7946	<	counter=`expr $counter + 1`
7946	>	func_arith $counter + 1
7947	>	counter=$func_arith_result
7948		case " $oldobjs " in
7949		*[\ /]"$newobj "*) ;;
7950		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
7951		esac
7952		done
7953	<	$show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5556	<	$run ln "$obj" "$gentop/$newobj" ||
5557	<	$run cp "$obj" "$gentop/$newobj"
7953	>	func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7954		oldobjs="$oldobjs $gentop/$newobj"
7955		;;
7956		*) oldobjs="$oldobjs $obj" ;;
7957		esac
7958		done
7959		fi
5564	–
7960		eval cmds=\"$old_archive_cmds\"
7961
7962	<	if len=`expr "X$cmds" : ".*"` &&
7963	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7962	>	func_len " $cmds"
7963	>	len=$func_len_result
7964	>	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7965		cmds=$old_archive_cmds
7966		else
7967		# the command line is too long to link in one step, link in parts
7968	<	$echo "using piecewise archive linking..."
7968	>	func_verbose "using piecewise archive linking..."
7969		save_RANLIB=$RANLIB
7970		RANLIB=:
7971		objlist=
7972		concat_cmds=
7973		save_oldobjs=$oldobjs
7974	<
7974	>	oldobjs=
7975		# Is there a better way of finding the last object in the list?
7976		for obj in $save_oldobjs
7977		do
7978		last_oldobj=$obj
7979		done
7980	+	eval test_cmds=\"$old_archive_cmds\"
7981	+	func_len " $test_cmds"
7982	+	len0=$func_len_result
7983	+	len=$len0
7984		for obj in $save_oldobjs
7985		do
7986	<	oldobjs="$objlist $obj"
7987	<	objlist="$objlist $obj"
7988	<	eval test_cmds=\"$old_archive_cmds\"
7989	<	if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
7990	<	test "$len" -le "$max_cmd_len"; then
7986	>	func_len " $obj"
7987	>	func_arith $len + $func_len_result
7988	>	len=$func_arith_result
7989	>	func_append objlist " $obj"
7990	>	if test "$len" -lt "$max_cmd_len"; then
7991		:
7992		else
7993		# the above command should be used before it gets too long
7994		oldobjs=$objlist
7995		if test "$obj" = "$last_oldobj" ; then
7996	<	RANLIB=$save_RANLIB
7996	>	RANLIB=$save_RANLIB
7997		fi
7998		test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7999		eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8000		objlist=
8001	+	len=$len0
8002		fi
8003		done
8004		RANLIB=$save_RANLIB
#	Line 5609 | Line 8010 | fi\
8010		fi
8011		fi
8012		fi
8013	<	save_ifs="$IFS"; IFS='~'
5613	<	for cmd in $cmds; do
5614	<	eval cmd=\"$cmd\"
5615	<	IFS="$save_ifs"
5616	<	$show "$cmd"
5617	<	$run eval "$cmd" || exit $?
5618	<	done
5619	<	IFS="$save_ifs"
8013	>	func_execute_cmds "$cmds" 'exit $?'
8014		done
8015
8016	<	if test -n "$generated"; then
8017	<	$show "${rm}r$generated"
5624	<	$run ${rm}r$generated
5625	<	fi
8016	>	test -n "$generated" && \
8017	>	func_show_eval "${RM}r$generated"
8018
8019		# Now create the libtool archive.
8020		case $output in
8021		*.la)
8022		old_library=
8023		test "$build_old_libs" = yes && old_library="$libname.$libext"
8024	<	$show "creating $output"
8024	>	func_verbose "creating $output"
8025
8026		# Preserve any variables that may affect compiler behavior
8027		for var in $variables_saved_for_relink; do
8028		if eval test -z \"\${$var+set}\"; then
8029	<	relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
8029	>	relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8030		elif eval var_value=\$$var; test -z "$var_value"; then
8031		relink_command="$var=; export $var; $relink_command"
8032		else
8033	<	var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
8034	<	relink_command="$var=\"$var_value\"; export $var; $relink_command"
8033	>	func_quote_for_eval "$var_value"
8034	>	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8035		fi
8036		done
8037		# Quote the link command for shipping.
8038		relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8039	<	relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
8039	>	relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8040		if test "$hardcode_automatic" = yes ; then
8041		relink_command=
8042		fi
8043
5652	–
8044		# Only create the output if not a dry run.
8045	<	if test -z "$run"; then
8045	>	$opt_dry_run || {
8046		for installed in no yes; do
8047		if test "$installed" = yes; then
8048		if test -z "$install_libdir"; then
#	Line 5663 | Line 8054 | fi\
8054		for deplib in $dependency_libs; do
8055		case $deplib in
8056		*.la)
8057	<	name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
8057	>	func_basename "$deplib"
8058	>	name="$func_basename_result"
8059		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8060	<	if test -z "$libdir"; then
8061	<	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5670	<	exit $EXIT_FAILURE
5671	<	fi
8060	>	test -z "$libdir" && \
8061	>	func_fatal_error "\`$deplib' is not a valid libtool archive"
8062		newdependency_libs="$newdependency_libs $libdir/$name"
8063		;;
8064		*) newdependency_libs="$newdependency_libs $deplib" ;;
#	Line 5676 | Line 8066 | fi\
8066		done
8067		dependency_libs="$newdependency_libs"
8068		newdlfiles=
8069	+
8070		for lib in $dlfiles; do
8071	<	name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
8072	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8073	<	if test -z "$libdir"; then
8074	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
8075	<	exit $EXIT_FAILURE
8076	<	fi
8077	<	newdlfiles="$newdlfiles $libdir/$name"
8071	>	case $lib in
8072	>	*.la)
8073	>	func_basename "$lib"
8074	>	name="$func_basename_result"
8075	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8076	>	test -z "$libdir" && \
8077	>	func_fatal_error "\`$lib' is not a valid libtool archive"
8078	>	newdlfiles="$newdlfiles $libdir/$name"
8079	>	;;
8080	>	*) newdlfiles="$newdlfiles $lib" ;;
8081	>	esac
8082		done
8083		dlfiles="$newdlfiles"
8084		newdlprefiles=
8085		for lib in $dlprefiles; do
8086	<	name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
8087	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8088	<	if test -z "$libdir"; then
8089	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
8090	<	exit $EXIT_FAILURE
8091	<	fi
8092	<	newdlprefiles="$newdlprefiles $libdir/$name"
8086	>	case $lib in
8087	>	*.la)
8088	>	# Only pass preopened files to the pseudo-archive (for
8089	>	# eventual linking with the app. that links it) if we
8090	>	# didn't already link the preopened objects directly into
8091	>	# the library:
8092	>	func_basename "$lib"
8093	>	name="$func_basename_result"
8094	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8095	>	test -z "$libdir" && \
8096	>	func_fatal_error "\`$lib' is not a valid libtool archive"
8097	>	newdlprefiles="$newdlprefiles $libdir/$name"
8098	>	;;
8099	>	esac
8100		done
8101		dlprefiles="$newdlprefiles"
8102		else
#	Line 5717 | Line 8119 | fi\
8119		done
8120		dlprefiles="$newdlprefiles"
8121		fi
8122	<	$rm $output
8122	>	$RM $output
8123		# place dlname in correct position for cygwin
8124		tdlname=$dlname
8125		case $host,$output,$installed,$module,$dlname in
8126	<	*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8126	>	*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8127		esac
8128	<	$echo > $output "\
8128	>	$ECHO > $output "\
8129		# $outputname - a libtool library file
8130	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
8130	>	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8131		#
8132		# Please DO NOT delete this file!
8133		# It is necessary for linking the library.
#	Line 5739 | Line 8141 | library_names='$library_names'
8141		# The name of the static archive.
8142		old_library='$old_library'
8143
8144	+	# Linker flags that can not go in dependency_libs.
8145	+	inherited_linker_flags='$new_inherited_linker_flags'
8146	+
8147		# Libraries that this one depends upon.
8148		dependency_libs='$dependency_libs'
8149
8150	+	# Names of additional weak libraries provided by this library
8151	+	weak_library_names='$weak_libs'
8152	+
8153		# Version information for $libname.
8154		current=$current
8155		age=$age
#	Line 5760 | Line 8168 | dlpreopen='$dlprefiles'
8168		# Directory that this library needs to be installed in:
8169		libdir='$install_libdir'"
8170		if test "$installed" = no && test "$need_relink" = yes; then
8171	<	$echo >> $output "\
8171	>	$ECHO >> $output "\
8172		relink_command=\"$relink_command\""
8173		fi
8174		done
8175	<	fi
8175	>	}
8176
8177		# Do a symbolic link so that the libtool archive can be found in
8178		# LD_LIBRARY_PATH before the program is installed.
8179	<	$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5772	<	$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
8179	>	func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8180		;;
8181		esac
8182		exit $EXIT_SUCCESS
8183	<	;;
5777	<
5778	<	# libtool install mode
5779	<	install)
5780	<	modename="$modename: install"
5781	<
5782	<	# There may be an optional sh(1) argument at the beginning of
5783	<	# install_prog (especially on Windows NT).
5784	<	if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5785	<	# Allow the use of GNU shtool's install command.
5786	<	$echo "X$nonopt" | grep shtool > /dev/null; then
5787	<	# Aesthetically quote it.
5788	<	arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5789	<	case $arg in
5790	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5791	<	arg="\"$arg\""
5792	<	;;
5793	<	esac
5794	<	install_prog="$arg "
5795	<	arg="$1"
5796	<	shift
5797	<	else
5798	<	install_prog=
5799	<	arg=$nonopt
5800	<	fi
5801	<
5802	<	# The real first argument should be the name of the installation program.
5803	<	# Aesthetically quote it.
5804	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5805	<	case $arg in
5806	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5807	<	arg="\"$arg\""
5808	<	;;
5809	<	esac
5810	<	install_prog="$install_prog$arg"
5811	<
5812	<	# We need to accept at least all the BSD install flags.
5813	<	dest=
5814	<	files=
5815	<	opts=
5816	<	prev=
5817	<	install_type=
5818	<	isdir=no
5819	<	stripme=
5820	<	for arg
5821	<	do
5822	<	if test -n "$dest"; then
5823	<	files="$files $dest"
5824	<	dest=$arg
5825	<	continue
5826	<	fi
5827	<
5828	<	case $arg in
5829	<	-d) isdir=yes ;;
5830	<	-f)
5831	<	case " $install_prog " in
5832	<	*[\\\ /]cp\ *) ;;
5833	<	*) prev=$arg ;;
5834	<	esac
5835	<	;;
5836	<	-g | -m | -o) prev=$arg ;;
5837	<	-s)
5838	<	stripme=" -s"
5839	<	continue
5840	<	;;
5841	<	-*)
5842	<	;;
5843	<	*)
5844	<	# If the previous option needed an argument, then skip it.
5845	<	if test -n "$prev"; then
5846	<	prev=
5847	<	else
5848	<	dest=$arg
5849	<	continue
5850	<	fi
5851	<	;;
5852	<	esac
5853	<
5854	<	# Aesthetically quote the argument.
5855	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5856	<	case $arg in
5857	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5858	<	arg="\"$arg\""
5859	<	;;
5860	<	esac
5861	<	install_prog="$install_prog $arg"
5862	<	done
5863	<
5864	<	if test -z "$install_prog"; then
5865	<	$echo "$modename: you must specify an install program" 1>&2
5866	<	$echo "$help" 1>&2
5867	<	exit $EXIT_FAILURE
5868	<	fi
5869	<
5870	<	if test -n "$prev"; then
5871	<	$echo "$modename: the \`$prev' option requires an argument" 1>&2
5872	<	$echo "$help" 1>&2
5873	<	exit $EXIT_FAILURE
5874	<	fi
5875	<
5876	<	if test -z "$files"; then
5877	<	if test -z "$dest"; then
5878	<	$echo "$modename: no file or destination specified" 1>&2
5879	<	else
5880	<	$echo "$modename: you must specify a destination" 1>&2
5881	<	fi
5882	<	$echo "$help" 1>&2
5883	<	exit $EXIT_FAILURE
5884	<	fi
5885	<
5886	<	# Strip any trailing slash from the destination.
5887	<	dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5888	<
5889	<	# Check to see that the destination is a directory.
5890	<	test -d "$dest" && isdir=yes
5891	<	if test "$isdir" = yes; then
5892	<	destdir="$dest"
5893	<	destname=
5894	<	else
5895	<	destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5896	<	test "X$destdir" = "X$dest" && destdir=.
5897	<	destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5898	<
5899	<	# Not a directory, so check to see that there is only one file specified.
5900	<	set dummy $files
5901	<	if test "$#" -gt 2; then
5902	<	$echo "$modename: \`$dest' is not a directory" 1>&2
5903	<	$echo "$help" 1>&2
5904	<	exit $EXIT_FAILURE
5905	<	fi
5906	<	fi
5907	<	case $destdir in
5908	<	[\\/]* | [A-Za-z]:[\\/]*) ;;
5909	<	*)
5910	<	for file in $files; do
5911	<	case $file in
5912	<	*.lo) ;;
5913	<	*)
5914	<	$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5915	<	$echo "$help" 1>&2
5916	<	exit $EXIT_FAILURE
5917	<	;;
5918	<	esac
5919	<	done
5920	<	;;
5921	<	esac
5922	<
5923	<	# This variable tells wrapper scripts just to set variables rather
5924	<	# than running their programs.
5925	<	libtool_install_magic="$magic"
5926	<
5927	<	staticlibs=
5928	<	future_libdirs=
5929	<	current_libdirs=
5930	<	for file in $files; do
5931	<
5932	<	# Do each installation.
5933	<	case $file in
5934	<	*.$libext)
5935	<	# Do the static libraries later.
5936	<	staticlibs="$staticlibs $file"
5937	<	;;
5938	<
5939	<	*.la)
5940	<	# Check to see that this really is a libtool archive.
5941	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5942	<	else
5943	<	$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5944	<	$echo "$help" 1>&2
5945	<	exit $EXIT_FAILURE
5946	<	fi
5947	<
5948	<	library_names=
5949	<	old_library=
5950	<	relink_command=
5951	<	# If there is no directory component, then add one.
5952	<	case $file in
5953	<	*/* | *\\*) . $file ;;
5954	<	*) . ./$file ;;
5955	<	esac
5956	<
5957	<	# Add the libdir to current_libdirs if it is the destination.
5958	<	if test "X$destdir" = "X$libdir"; then
5959	<	case "$current_libdirs " in
5960	<	*" $libdir "*) ;;
5961	<	*) current_libdirs="$current_libdirs $libdir" ;;
5962	<	esac
5963	<	else
5964	<	# Note the libdir as a future libdir.
5965	<	case "$future_libdirs " in
5966	<	*" $libdir "*) ;;
5967	<	*) future_libdirs="$future_libdirs $libdir" ;;
5968	<	esac
5969	<	fi
5970	<
5971	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5972	<	test "X$dir" = "X$file/" && dir=
5973	<	dir="$dir$objdir"
5974	<
5975	<	if test -n "$relink_command"; then
5976	<	# Determine the prefix the user has applied to our future dir.
5977	<	inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5978	<
5979	<	# Don't allow the user to place us outside of our expected
5980	<	# location b/c this prevents finding dependent libraries that
5981	<	# are installed to the same prefix.
5982	<	# At present, this check doesn't affect windows .dll's that
5983	<	# are installed into $libdir/../bin (currently, that works fine)
5984	<	# but it's something to keep an eye on.
5985	<	if test "$inst_prefix_dir" = "$destdir"; then
5986	<	$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5987	<	exit $EXIT_FAILURE
5988	<	fi
5989	<
5990	<	if test -n "$inst_prefix_dir"; then
5991	<	# Stick the inst_prefix_dir data into the link command.
5992	<	relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`
5993	<	else
5994	<	relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`
5995	<	fi
5996	<
5997	<	$echo "$modename: warning: relinking \`$file'" 1>&2
5998	<	$show "$relink_command"
5999	<	if $run eval "$relink_command"; then :
6000	<	else
6001	<	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6002	<	exit $EXIT_FAILURE
6003	<	fi
6004	<	fi
6005	<
6006	<	# See the names of the shared library.
6007	<	set dummy $library_names
6008	<	if test -n "$2"; then
6009	<	realname="$2"
6010	<	shift
6011	<	shift
6012	<
6013	<	srcname="$realname"
6014	<	test -n "$relink_command" && srcname="$realname"T
6015	<
6016	<	# Install the shared library and build the symlinks.
6017	<	$show "$install_prog $dir/$srcname $destdir/$realname"
6018	<	$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
6019	<	if test -n "$stripme" && test -n "$striplib"; then
6020	<	$show "$striplib $destdir/$realname"
6021	<	$run eval "$striplib $destdir/$realname" || exit $?
6022	<	fi
6023	<
6024	<	if test "$#" -gt 0; then
6025	<	# Delete the old symlinks, and create new ones.
6026	<	# Try `ln -sf' first, because the `ln' binary might depend on
6027	<	# the symlink we replace!  Solaris /bin/ln does not understand -f,
6028	<	# so we also need to try rm && ln -s.
6029	<	for linkname
6030	<	do
6031	<	if test "$linkname" != "$realname"; then
6032	<	$show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6033	<	$run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6034	<	fi
6035	<	done
6036	<	fi
6037	<
6038	<	# Do each command in the postinstall commands.
6039	<	lib="$destdir/$realname"
6040	<	cmds=$postinstall_cmds
6041	<	save_ifs="$IFS"; IFS='~'
6042	<	for cmd in $cmds; do
6043	<	IFS="$save_ifs"
6044	<	eval cmd=\"$cmd\"
6045	<	$show "$cmd"
6046	<	$run eval "$cmd" || {
6047	<	lt_exit=$?
6048	<
6049	<	# Restore the uninstalled library and exit
6050	<	if test "$mode" = relink; then
6051	<	$run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
6052	<	fi
6053	<
6054	<	exit $lt_exit
6055	<	}
6056	<	done
6057	<	IFS="$save_ifs"
6058	<	fi
6059	<
6060	<	# Install the pseudo-library for information purposes.
6061	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6062	<	instname="$dir/$name"i
6063	<	$show "$install_prog $instname $destdir/$name"
6064	<	$run eval "$install_prog $instname $destdir/$name" || exit $?
6065	<
6066	<	# Maybe install the static library, too.
6067	<	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6068	<	;;
6069	<
6070	<	*.lo)
6071	<	# Install (i.e. copy) a libtool object.
6072	<
6073	<	# Figure out destination file name, if it wasn't already specified.
6074	<	if test -n "$destname"; then
6075	<	destfile="$destdir/$destname"
6076	<	else
6077	<	destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6078	<	destfile="$destdir/$destfile"
6079	<	fi
6080	<
6081	<	# Deduce the name of the destination old-style object file.
6082	<	case $destfile in
6083	<	*.lo)
6084	<	staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6085	<	;;
6086	<	*.$objext)
6087	<	staticdest="$destfile"
6088	<	destfile=
6089	<	;;
6090	<	*)
6091	<	$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6092	<	$echo "$help" 1>&2
6093	<	exit $EXIT_FAILURE
6094	<	;;
6095	<	esac
6096	<
6097	<	# Install the libtool object if requested.
6098	<	if test -n "$destfile"; then
6099	<	$show "$install_prog $file $destfile"
6100	<	$run eval "$install_prog $file $destfile" || exit $?
6101	<	fi
6102	<
6103	<	# Install the old object if enabled.
6104	<	if test "$build_old_libs" = yes; then
6105	<	# Deduce the name of the old-style object file.
6106	<	staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6107	<
6108	<	$show "$install_prog $staticobj $staticdest"
6109	<	$run eval "$install_prog \$staticobj \$staticdest" || exit $?
6110	<	fi
6111	<	exit $EXIT_SUCCESS
6112	<	;;
6113	<
6114	<	*)
6115	<	# Figure out destination file name, if it wasn't already specified.
6116	<	if test -n "$destname"; then
6117	<	destfile="$destdir/$destname"
6118	<	else
6119	<	destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6120	<	destfile="$destdir/$destfile"
6121	<	fi
6122	<
6123	<	# If the file is missing, and there is a .exe on the end, strip it
6124	<	# because it is most likely a libtool script we actually want to
6125	<	# install
6126	<	stripped_ext=""
6127	<	case $file in
6128	<	*.exe)
6129	<	if test ! -f "$file"; then
6130	<	file=`$echo $file|${SED} 's,.exe$,,'`
6131	<	stripped_ext=".exe"
6132	<	fi
6133	<	;;
6134	<	esac
6135	<
6136	<	# Do a test to see if this is really a libtool program.
6137	<	case $host in
6138	<	*cygwin*|*mingw*)
6139	<	wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6140	<	;;
6141	<	*)
6142	<	wrapper=$file
6143	<	;;
6144	<	esac
6145	<	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6146	<	notinst_deplibs=
6147	<	relink_command=
6148	<
6149	<	# Note that it is not necessary on cygwin/mingw to append a dot to
6150	<	# foo even if both foo and FILE.exe exist: automatic-append-.exe
6151	<	# behavior happens only for exec(3), not for open(2)!  Also, sourcing
6152	<	# `FILE.' does not work on cygwin managed mounts.
6153	<	#
6154	<	# If there is no directory component, then add one.
6155	<	case $wrapper in
6156	<	*/* | *\\*) . ${wrapper} ;;
6157	<	*) . ./${wrapper} ;;
6158	<	esac
6159	<
6160	<	# Check the variables that should have been set.
6161	<	if test -z "$notinst_deplibs"; then
6162	<	$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6163	<	exit $EXIT_FAILURE
6164	<	fi
6165	<
6166	<	finalize=yes
6167	<	for lib in $notinst_deplibs; do
6168	<	# Check to see that each library is installed.
6169	<	libdir=
6170	<	if test -f "$lib"; then
6171	<	# If there is no directory component, then add one.
6172	<	case $lib in
6173	<	*/* | *\\*) . $lib ;;
6174	<	*) . ./$lib ;;
6175	<	esac
6176	<	fi
6177	<	libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6178	<	if test -n "$libdir" && test ! -f "$libfile"; then
6179	<	$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6180	<	finalize=no
6181	<	fi
6182	<	done
6183	<
6184	<	relink_command=
6185	<	# Note that it is not necessary on cygwin/mingw to append a dot to
6186	<	# foo even if both foo and FILE.exe exist: automatic-append-.exe
6187	<	# behavior happens only for exec(3), not for open(2)!  Also, sourcing
6188	<	# `FILE.' does not work on cygwin managed mounts.
6189	<	#
6190	<	# If there is no directory component, then add one.
6191	<	case $wrapper in
6192	<	*/* | *\\*) . ${wrapper} ;;
6193	<	*) . ./${wrapper} ;;
6194	<	esac
6195	<
6196	<	outputname=
6197	<	if test "$fast_install" = no && test -n "$relink_command"; then
6198	<	if test "$finalize" = yes && test -z "$run"; then
6199	<	tmpdir=`func_mktempdir`
6200	<	file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6201	<	outputname="$tmpdir/$file"
6202	<	# Replace the output file specification.
6203	<	relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`
6204	<
6205	<	$show "$relink_command"
6206	<	if $run eval "$relink_command"; then :
6207	<	else
6208	<	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6209	<	${rm}r "$tmpdir"
6210	<	continue
6211	<	fi
6212	<	file="$outputname"
6213	<	else
6214	<	$echo "$modename: warning: cannot relink \`$file'" 1>&2
6215	<	fi
6216	<	else
6217	<	# Install the binary that we compiled earlier.
6218	<	file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6219	<	fi
6220	<	fi
6221	<
6222	<	# remove .exe since cygwin /usr/bin/install will append another
6223	<	# one anyway
6224	<	case $install_prog,$host in
6225	<	*/usr/bin/install*,*cygwin*)
6226	<	case $file:$destfile in
6227	<	*.exe:*.exe)
6228	<	# this is ok
6229	<	;;
6230	<	*.exe:*)
6231	<	destfile=$destfile.exe
6232	<	;;
6233	<	*:*.exe)
6234	<	destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6235	<	;;
6236	<	esac
6237	<	;;
6238	<	esac
6239	<	$show "$install_prog$stripme $file $destfile"
6240	<	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6241	<	test -n "$outputname" && ${rm}r "$tmpdir"
6242	<	;;
6243	<	esac
6244	<	done
6245	<
6246	<	for file in $staticlibs; do
6247	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6248	<
6249	<	# Set up the ranlib parameters.
6250	<	oldlib="$destdir/$name"
6251	<
6252	<	$show "$install_prog $file $oldlib"
6253	<	$run eval "$install_prog \$file \$oldlib" || exit $?
6254	<
6255	<	if test -n "$stripme" && test -n "$old_striplib"; then
6256	<	$show "$old_striplib $oldlib"
6257	<	$run eval "$old_striplib $oldlib" || exit $?
6258	<	fi
6259	<
6260	<	# Do each command in the postinstall commands.
6261	<	cmds=$old_postinstall_cmds
6262	<	save_ifs="$IFS"; IFS='~'
6263	<	for cmd in $cmds; do
6264	<	IFS="$save_ifs"
6265	<	eval cmd=\"$cmd\"
6266	<	$show "$cmd"
6267	<	$run eval "$cmd" || exit $?
6268	<	done
6269	<	IFS="$save_ifs"
6270	<	done
6271	<
6272	<	if test -n "$future_libdirs"; then
6273	<	$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6274	<	fi
6275	<
6276	<	if test -n "$current_libdirs"; then
6277	<	# Maybe just do a dry run.
6278	<	test -n "$run" && current_libdirs=" -n$current_libdirs"
6279	<	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6280	<	else
6281	<	exit $EXIT_SUCCESS
6282	<	fi
6283	<	;;
6284	<
6285	<	# libtool finish mode
6286	<	finish)
6287	<	modename="$modename: finish"
6288	<	libdirs="$nonopt"
6289	<	admincmds=
6290	<
6291	<	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6292	<	for dir
6293	<	do
6294	<	libdirs="$libdirs $dir"
6295	<	done
6296	<
6297	<	for libdir in $libdirs; do
6298	<	if test -n "$finish_cmds"; then
6299	<	# Do each command in the finish commands.
6300	<	cmds=$finish_cmds
6301	<	save_ifs="$IFS"; IFS='~'
6302	<	for cmd in $cmds; do
6303	<	IFS="$save_ifs"
6304	<	eval cmd=\"$cmd\"
6305	<	$show "$cmd"
6306	<	$run eval "$cmd" || admincmds="$admincmds
6307	<	$cmd"
6308	<	done
6309	<	IFS="$save_ifs"
6310	<	fi
6311	<	if test -n "$finish_eval"; then
6312	<	# Do the single finish_eval.
6313	<	eval cmds=\"$finish_eval\"
6314	<	$run eval "$cmds" || admincmds="$admincmds
6315	<	$cmds"
6316	<	fi
6317	<	done
6318	<	fi
6319	<
6320	<	# Exit here if they wanted silent mode.
6321	<	test "$show" = : && exit $EXIT_SUCCESS
6322	<
6323	<	$echo "X----------------------------------------------------------------------" | $Xsed
6324	<	$echo "Libraries have been installed in:"
6325	<	for libdir in $libdirs; do
6326	<	$echo "   $libdir"
6327	<	done
6328	<	$echo
6329	<	$echo "If you ever happen to want to link against installed libraries"
6330	<	$echo "in a given directory, LIBDIR, you must either use libtool, and"
6331	<	$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6332	<	$echo "flag during linking and do at least one of the following:"
6333	<	if test -n "$shlibpath_var"; then
6334	<	$echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
6335	<	$echo "     during execution"
6336	<	fi
6337	<	if test -n "$runpath_var"; then
6338	<	$echo "   - add LIBDIR to the \`$runpath_var' environment variable"
6339	<	$echo "     during linking"
6340	<	fi
6341	<	if test -n "$hardcode_libdir_flag_spec"; then
6342	<	libdir=LIBDIR
6343	<	eval flag=\"$hardcode_libdir_flag_spec\"
6344	<
6345	<	$echo "   - use the \`$flag' linker flag"
6346	<	fi
6347	<	if test -n "$admincmds"; then
6348	<	$echo "   - have your system administrator run these commands:$admincmds"
6349	<	fi
6350	<	if test -f /etc/ld.so.conf; then
6351	<	$echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6352	<	fi
6353	<	$echo
6354	<	$echo "See any operating system documentation about shared libraries for"
6355	<	$echo "more information, such as the ld(1) and ld.so(8) manual pages."
6356	<	$echo "X----------------------------------------------------------------------" | $Xsed
6357	<	exit $EXIT_SUCCESS
6358	<	;;
6359	<
6360	<	# libtool execute mode
6361	<	execute)
6362	<	modename="$modename: execute"
6363	<
6364	<	# The first argument is the command name.
6365	<	cmd="$nonopt"
6366	<	if test -z "$cmd"; then
6367	<	$echo "$modename: you must specify a COMMAND" 1>&2
6368	<	$echo "$help"
6369	<	exit $EXIT_FAILURE
6370	<	fi
6371	<
6372	<	# Handle -dlopen flags immediately.
6373	<	for file in $execute_dlfiles; do
6374	<	if test ! -f "$file"; then
6375	<	$echo "$modename: \`$file' is not a file" 1>&2
6376	<	$echo "$help" 1>&2
6377	<	exit $EXIT_FAILURE
6378	<	fi
6379	<
6380	<	dir=
6381	<	case $file in
6382	<	*.la)
6383	<	# Check to see that this really is a libtool archive.
6384	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6385	<	else
6386	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6387	<	$echo "$help" 1>&2
6388	<	exit $EXIT_FAILURE
6389	<	fi
6390	<
6391	<	# Read the libtool library.
6392	<	dlname=
6393	<	library_names=
6394	<
6395	<	# If there is no directory component, then add one.
6396	<	case $file in
6397	<	*/* | *\\*) . $file ;;
6398	<	*) . ./$file ;;
6399	<	esac
6400	<
6401	<	# Skip this library if it cannot be dlopened.
6402	<	if test -z "$dlname"; then
6403	<	# Warn if it was a shared library.
6404	<	test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6405	<	continue
6406	<	fi
6407	<
6408	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6409	<	test "X$dir" = "X$file" && dir=.
6410	<
6411	<	if test -f "$dir/$objdir/$dlname"; then
6412	<	dir="$dir/$objdir"
6413	<	else
6414	<	if test ! -f "$dir/$dlname"; then
6415	<	$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6416	<	exit $EXIT_FAILURE
6417	<	fi
6418	<	fi
6419	<	;;
6420	<
6421	<	*.lo)
6422	<	# Just add the directory containing the .lo file.
6423	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6424	<	test "X$dir" = "X$file" && dir=.
6425	<	;;
6426	<
6427	<	*)
6428	<	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6429	<	continue
6430	<	;;
6431	<	esac
6432	<
6433	<	# Get the absolute pathname.
6434	<	absdir=`cd "$dir" && pwd`
6435	<	test -n "$absdir" && dir="$absdir"
6436	<
6437	<	# Now add the directory to shlibpath_var.
6438	<	if eval "test -z \"\$$shlibpath_var\""; then
6439	<	eval "$shlibpath_var=\"\$dir\""
6440	<	else
6441	<	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6442	<	fi
6443	<	done
6444	<
6445	<	# This variable tells wrapper scripts just to set shlibpath_var
6446	<	# rather than running their programs.
6447	<	libtool_execute_magic="$magic"
6448	<
6449	<	# Check if any of the arguments is a wrapper script.
6450	<	args=
6451	<	for file
6452	<	do
6453	<	case $file in
6454	<	-*) ;;
6455	<	*)
6456	<	# Do a test to see if this is really a libtool program.
6457	<	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6458	<	# If there is no directory component, then add one.
6459	<	case $file in
6460	<	*/* | *\\*) . $file ;;
6461	<	*) . ./$file ;;
6462	<	esac
6463	<
6464	<	# Transform arg to wrapped name.
6465	<	file="$progdir/$program"
6466	<	fi
6467	<	;;
6468	<	esac
6469	<	# Quote arguments (to preserve shell metacharacters).
6470	<	file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6471	<	args="$args \"$file\""
6472	<	done
8183	>	}
8184
8185	<	if test -z "$run"; then
8186	<	if test -n "$shlibpath_var"; then
6476	<	# Export the shlibpath_var.
6477	<	eval "export $shlibpath_var"
6478	<	fi
8185	>	{ test "$mode" = link || test "$mode" = relink; } &&
8186	>	func_mode_link ${1+"$@"}
8187
6480	–	# Restore saved environment variables
6481	–	for lt_var in LANG LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
6482	–	do
6483	–	eval "if test \"\${save_$lt_var+set}\" = set; then
6484	–	$lt_var=\$save_$lt_var; export $lt_var
6485	–	fi"
6486	–	done
8188
8189	<	# Now prepare to actually exec the command.
8190	<	exec_cmd="\$cmd$args"
8191	<	else
8192	<	# Display what would be done.
8193	<	if test -n "$shlibpath_var"; then
6493	<	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6494	<	$echo "export $shlibpath_var"
6495	<	fi
6496	<	$echo "$cmd$args"
6497	<	exit $EXIT_SUCCESS
6498	<	fi
6499	<	;;
6500	<
6501	<	# libtool clean and uninstall mode
6502	<	clean | uninstall)
6503	<	modename="$modename: $mode"
6504	<	rm="$nonopt"
8189	>	# func_mode_uninstall arg...
8190	>	func_mode_uninstall ()
8191	>	{
8192	>	$opt_debug
8193	>	RM="$nonopt"
8194		files=
8195		rmforce=
8196		exit_status=0
#	Line 6513 | Line 8202 | relink_command=\"$relink_command\""
8202		for arg
8203		do
8204		case $arg in
8205	<	-f) rm="$rm $arg"; rmforce=yes ;;
8206	<	-*) rm="$rm $arg" ;;
8205	>	-f) RM="$RM $arg"; rmforce=yes ;;
8206	>	-*) RM="$RM $arg" ;;
8207		*) files="$files $arg" ;;
8208		esac
8209		done
8210
8211	<	if test -z "$rm"; then
8212	<	$echo "$modename: you must specify an RM program" 1>&2
6524	<	$echo "$help" 1>&2
6525	<	exit $EXIT_FAILURE
6526	<	fi
8211	>	test -z "$RM" && \
8212	>	func_fatal_help "you must specify an RM program"
8213
8214		rmdirs=
8215
8216		origobjdir="$objdir"
8217		for file in $files; do
8218	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
8219	<	if test "X$dir" = "X$file"; then
8220	<	dir=.
8218	>	func_dirname "$file" "" "."
8219	>	dir="$func_dirname_result"
8220	>	if test "X$dir" = X.; then
8221		objdir="$origobjdir"
8222		else
8223		objdir="$dir/$origobjdir"
8224		fi
8225	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
8225	>	func_basename "$file"
8226	>	name="$func_basename_result"
8227		test "$mode" = uninstall && objdir="$dir"
8228
8229		# Remember objdir for removal later, being careful to avoid duplicates
#	Line 6548 | Line 8235 | relink_command=\"$relink_command\""
8235		fi
8236
8237		# Don't error if the file doesn't exist and rm -f was used.
8238	<	if (test -L "$file") >/dev/null 2>&1 \
8239	<	|| (test -h "$file") >/dev/null 2>&1 \
8240	<	|| test -f "$file"; then
8238	>	if { test -L "$file"; } >/dev/null 2>&1 ||
8239	>	{ test -h "$file"; } >/dev/null 2>&1 ||
8240	>	test -f "$file"; then
8241		:
8242		elif test -d "$file"; then
8243		exit_status=1
#	Line 6564 | Line 8251 | relink_command=\"$relink_command\""
8251		case $name in
8252		*.la)
8253		# Possibly a libtool archive, so verify it.
8254	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
8255	<	. $dir/$name
8254	>	if func_lalib_p "$file"; then
8255	>	func_source $dir/$name
8256
8257		# Delete the libtool libraries and symlinks.
8258		for n in $library_names; do
#	Line 6580 | Line 8267 | relink_command=\"$relink_command\""
8267		*" $dlname "*) ;;
8268		*) rmfiles="$rmfiles $objdir/$dlname" ;;
8269		esac
8270	<	test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8270	>	test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8271		;;
8272		uninstall)
8273		if test -n "$library_names"; then
8274		# Do each command in the postuninstall commands.
8275	<	cmds=$postuninstall_cmds
6589	<	save_ifs="$IFS"; IFS='~'
6590	<	for cmd in $cmds; do
6591	<	IFS="$save_ifs"
6592	<	eval cmd=\"$cmd\"
6593	<	$show "$cmd"
6594	<	$run eval "$cmd"
6595	<	if test "$?" -ne 0 && test "$rmforce" != yes; then
6596	<	exit_status=1
6597	<	fi
6598	<	done
6599	<	IFS="$save_ifs"
8275	>	func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8276		fi
8277
8278		if test -n "$old_library"; then
8279		# Do each command in the old_postuninstall commands.
8280	<	cmds=$old_postuninstall_cmds
6605	<	save_ifs="$IFS"; IFS='~'
6606	<	for cmd in $cmds; do
6607	<	IFS="$save_ifs"
6608	<	eval cmd=\"$cmd\"
6609	<	$show "$cmd"
6610	<	$run eval "$cmd"
6611	<	if test "$?" -ne 0 && test "$rmforce" != yes; then
6612	<	exit_status=1
6613	<	fi
6614	<	done
6615	<	IFS="$save_ifs"
8280	>	func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8281		fi
8282		# FIXME: should reinstall the best remaining shared library.
8283		;;
#	Line 6622 | Line 8287 | relink_command=\"$relink_command\""
8287
8288		*.lo)
8289		# Possibly a libtool object, so verify it.
8290	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
8290	>	if func_lalib_p "$file"; then
8291
8292		# Read the .lo file
8293	<	. $dir/$name
8293	>	func_source $dir/$name
8294
8295		# Add PIC object to the list of files to remove.
8296	<	if test -n "$pic_object" \
8297	<	&& test "$pic_object" != none; then
8296	>	if test -n "$pic_object" &&
8297	>	test "$pic_object" != none; then
8298		rmfiles="$rmfiles $dir/$pic_object"
8299		fi
8300
8301		# Add non-PIC object to the list of files to remove.
8302	<	if test -n "$non_pic_object" \
8303	<	&& test "$non_pic_object" != none; then
8302	>	if test -n "$non_pic_object" &&
8303	>	test "$non_pic_object" != none; then
8304		rmfiles="$rmfiles $dir/$non_pic_object"
8305		fi
8306		fi
#	Line 6646 | Line 8311 | relink_command=\"$relink_command\""
8311		noexename=$name
8312		case $file in
8313		*.exe)
8314	<	file=`$echo $file|${SED} 's,.exe$,,'`
8315	<	noexename=`$echo $name|${SED} 's,.exe$,,'`
8314	>	func_stripname '' '.exe' "$file"
8315	>	file=$func_stripname_result
8316	>	func_stripname '' '.exe' "$name"
8317	>	noexename=$func_stripname_result
8318		# $file with .exe has already been added to rmfiles,
8319		# add $file without .exe
8320		rmfiles="$rmfiles $file"
8321		;;
8322		esac
8323		# Do a test to see if this is a libtool program.
8324	<	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
8325	<	relink_command=
8326	<	. $dir/$noexename
8324	>	if func_ltwrapper_p "$file"; then
8325	>	if func_ltwrapper_executable_p "$file"; then
8326	>	func_ltwrapper_scriptname "$file"
8327	>	relink_command=
8328	>	func_source $func_ltwrapper_scriptname_result
8329	>	rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8330	>	else
8331	>	relink_command=
8332	>	func_source $dir/$noexename
8333	>	fi
8334
8335		# note $name still contains .exe if it was in $file originally
8336		# as does the version of $file that was added into $rmfiles
#	Line 6671 | Line 8345 | relink_command=\"$relink_command\""
8345		fi
8346		;;
8347		esac
8348	<	$show "$rm $rmfiles"
6675	<	$run $rm $rmfiles || exit_status=1
8348	>	func_show_eval "$RM $rmfiles" 'exit_status=1'
8349		done
8350		objdir="$origobjdir"
8351
8352		# Try to remove the ${objdir}s in the directories where we deleted files
8353		for dir in $rmdirs; do
8354		if test -d "$dir"; then
8355	<	$show "rmdir $dir"
6683	<	$run rmdir $dir >/dev/null 2>&1
8355	>	func_show_eval "rmdir $dir >/dev/null 2>&1"
8356		fi
8357		done
8358
8359		exit $exit_status
8360	<	;;
8360	>	}
8361
8362	<	"")
8363	<	$echo "$modename: you must specify a MODE" 1>&2
6692	<	$echo "$generic_help" 1>&2
6693	<	exit $EXIT_FAILURE
6694	<	;;
6695	<	esac
8362	>	{ test "$mode" = uninstall || test "$mode" = clean; } &&
8363	>	func_mode_uninstall ${1+"$@"}
8364
8365	<	if test -z "$exec_cmd"; then
8366	<	$echo "$modename: invalid operation mode \`$mode'" 1>&2
8367	<	$echo "$generic_help" 1>&2
8368	<	exit $EXIT_FAILURE
8369	<	fi
8370	<	fi # test -z "$show_help"
8365	>	test -z "$mode" && {
8366	>	help="$generic_help"
8367	>	func_fatal_help "you must specify a MODE"
8368	>	}
8369	>
8370	>	test -z "$exec_cmd" && \
8371	>	func_fatal_help "invalid operation mode \`$mode'"
8372
8373		if test -n "$exec_cmd"; then
8374	<	eval exec $exec_cmd
8374	>	eval exec "$exec_cmd"
8375		exit $EXIT_FAILURE
8376		fi
8377
8378	<	# We need to display help for each of the modes.
6710	<	case $mode in
6711	<	"") $echo \
6712	<	"Usage: $modename [OPTION]... [MODE-ARG]...
6713	<
6714	<	Provide generalized library-building support services.
6715	<
6716	<	--config          show all configuration variables
6717	<	--debug           enable verbose shell tracing
6718	<	-n, --dry-run         display commands without modifying any files
6719	<	--features        display basic configuration information and exit
6720	<	--finish          same as \`--mode=finish'
6721	<	--help            display this help message and exit
6722	<	--mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6723	<	--quiet           same as \`--silent'
6724	<	--silent          don't print informational messages
6725	<	--tag=TAG         use configuration variables from tag TAG
6726	<	--version         print version information
6727	<
6728	<	MODE must be one of the following:
6729	<
6730	<	clean           remove files from the build directory
6731	<	compile         compile a source file into a libtool object
6732	<	execute         automatically set library path, then run a program
6733	<	finish          complete the installation of libtool libraries
6734	<	install         install libraries or executables
6735	<	link            create a library or an executable
6736	<	uninstall       remove libraries from an installed directory
6737	<
6738	<	MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6739	<	a more detailed description of MODE.
6740	<
6741	<	Report bugs to <bug-libtool@gnu.org>."
6742	<	exit $EXIT_SUCCESS
6743	<	;;
6744	<
6745	<	clean)
6746	<	$echo \
6747	<	"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6748	<
6749	<	Remove files from the build directory.
6750	<
6751	<	RM is the name of the program to use to delete files associated with each FILE
6752	<	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6753	<	to RM.
6754	<
6755	<	If FILE is a libtool library, object or program, all the files associated
6756	<	with it are deleted. Otherwise, only FILE itself is deleted using RM."
6757	<	;;
6758	<
6759	<	compile)
6760	<	$echo \
6761	<	"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6762	<
6763	<	Compile a source file into a libtool library object.
6764	<
6765	<	This mode accepts the following additional options:
6766	<
6767	<	-o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6768	<	-prefer-pic       try to building PIC objects only
6769	<	-prefer-non-pic   try to building non-PIC objects only
6770	<	-static           always build a \`.o' file suitable for static linking
6771	<
6772	<	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6773	<	from the given SOURCEFILE.
6774	<
6775	<	The output file name is determined by removing the directory component from
6776	<	SOURCEFILE, then substituting the C source code suffix \`.c' with the
6777	<	library object suffix, \`.lo'."
6778	<	;;
6779	<
6780	<	execute)
6781	<	$echo \
6782	<	"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6783	<
6784	<	Automatically set library path, then run a program.
6785	<
6786	<	This mode accepts the following additional options:
6787	<
6788	<	-dlopen FILE      add the directory containing FILE to the library path
6789	<
6790	<	This mode sets the library path environment variable according to \`-dlopen'
6791	<	flags.
6792	<
6793	<	If any of the ARGS are libtool executable wrappers, then they are translated
6794	<	into their corresponding uninstalled binary, and any of their required library
6795	<	directories are added to the library path.
6796	<
6797	<	Then, COMMAND is executed, with ARGS as arguments."
6798	<	;;
6799	<
6800	<	finish)
6801	<	$echo \
6802	<	"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6803	<
6804	<	Complete the installation of libtool libraries.
6805	<
6806	<	Each LIBDIR is a directory that contains libtool libraries.
6807	<
6808	<	The commands that this mode executes may require superuser privileges.  Use
6809	<	the \`--dry-run' option if you just want to see what would be executed."
6810	<	;;
6811	<
6812	<	install)
6813	<	$echo \
6814	<	"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6815	<
6816	<	Install executables or libraries.
6817	<
6818	<	INSTALL-COMMAND is the installation command.  The first component should be
6819	<	either the \`install' or \`cp' program.
6820	<
6821	<	The rest of the components are interpreted as arguments to that command (only
6822	<	BSD-compatible install options are recognized)."
6823	<	;;
6824	<
6825	<	link)
6826	<	$echo \
6827	<	"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6828	<
6829	<	Link object files or libraries together to form another library, or to
6830	<	create an executable program.
6831	<
6832	<	LINK-COMMAND is a command using the C compiler that you would use to create
6833	<	a program from several object files.
6834	<
6835	<	The following components of LINK-COMMAND are treated specially:
6836	<
6837	<	-all-static       do not do any dynamic linking at all
6838	<	-avoid-version    do not add a version suffix if possible
6839	<	-dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6840	<	-dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6841	<	-export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6842	<	-export-symbols SYMFILE
6843	<	try to export only the symbols listed in SYMFILE
6844	<	-export-symbols-regex REGEX
6845	<	try to export only the symbols matching REGEX
6846	<	-LLIBDIR          search LIBDIR for required installed libraries
6847	<	-lNAME            OUTPUT-FILE requires the installed library libNAME
6848	<	-module           build a library that can dlopened
6849	<	-no-fast-install  disable the fast-install mode
6850	<	-no-install       link a not-installable executable
6851	<	-no-undefined     declare that a library does not refer to external symbols
6852	<	-o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6853	<	-objectlist FILE  Use a list of object files found in FILE to specify objects
6854	<	-precious-files-regex REGEX
6855	<	don't remove output files matching REGEX
6856	<	-release RELEASE  specify package release information
6857	<	-rpath LIBDIR     the created library will eventually be installed in LIBDIR
6858	<	-R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6859	<	-static           do not do any dynamic linking of uninstalled libtool libraries
6860	<	-static-libtool-libs
6861	<	do not do any dynamic linking of libtool libraries
6862	<	-version-info CURRENT[:REVISION[:AGE]]
6863	<	specify library version info [each variable defaults to 0]
6864	<
6865	<	All other options (arguments beginning with \`-') are ignored.
8378	>	exit $exit_status
8379
6867	–	Every other argument is treated as a filename.  Files ending in \`.la' are
6868	–	treated as uninstalled libtool libraries, other files are standard or library
6869	–	object files.
6870	–
6871	–	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6872	–	only library objects (\`.lo' files) may be specified, and \`-rpath' is
6873	–	required, except when creating a convenience library.
6874	–
6875	–	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6876	–	using \`ar' and \`ranlib', or on Windows using \`lib'.
6877	–
6878	–	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6879	–	is created, otherwise an executable program is created."
6880	–	;;
6881	–
6882	–	uninstall)
6883	–	$echo \
6884	–	"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6885	–
6886	–	Remove libraries from an installation directory.
6887	–
6888	–	RM is the name of the program to use to delete files associated with each FILE
6889	–	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6890	–	to RM.
6891	–
6892	–	If FILE is a libtool library, all the files associated with it are deleted.
6893	–	Otherwise, only FILE itself is deleted using RM."
6894	–	;;
6895	–
6896	–	*)
6897	–	$echo "$modename: invalid operation mode \`$mode'" 1>&2
6898	–	$echo "$help" 1>&2
6899	–	exit $EXIT_FAILURE
6900	–	;;
6901	–	esac
6902	–
6903	–	$echo
6904	–	$echo "Try \`$modename --help' for more information about other modes."
6905	–
6906	–	exit $?
8380
8381		# The TAGs below are defined such that we never get into a situation
8382		# in which we disable both kinds of libraries.  Given conflicting
#	Line 6917 | Line 8390 | exit $?
8390		# configuration.  But we'll never go from static-only to shared-only.
8391
8392		# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8393	<	disable_libs=shared
8393	>	build_libtool_libs=no
8394	>	build_old_libs=yes
8395		# ### END LIBTOOL TAG CONFIG: disable-shared
8396
8397		# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8398	<	disable_libs=static
8398	>	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8399		# ### END LIBTOOL TAG CONFIG: disable-static
8400
8401		# Local Variables:
8402		# mode:shell-script
8403		# sh-indentation:2
8404		# End:
8405	+	# vi:sw=2
8406	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)