ViewVC Help

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

root/svn/pxys-hybrid/trunk/pxyservd/libbcl/ltmain.sh

Comparing pxys-hybrid/trunk/pxyservd/libbcl/ltmain.sh (file contents):
Revision 3392 by michael, Fri Apr 25 16:43:41 2014 UTC vs.
Revision 3393 by michael, Fri Apr 25 17:07:35 2014 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
5	<	# Free Software Foundation, Inc.
6	<	# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7	<	#
8	<	# This program is free software; you can redistribute it and/or modify
1	>
2	>	# libtool (GNU libtool) 2.4.2
3	>	# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
4	>
5	>	# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6	>	# 2007, 2008, 2009, 2010, 2011 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
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	>	# Usage: $progname [OPTION]... [MODE-ARG]...
32		#
33	<	# As a special exception to the GNU General Public License, if you
34	<	# distribute this file as part of a program that contains a
35	<	# configuration script generated by Autoconf, you may include it under
36	<	# the same distribution terms that you use for the rest of that program.
37	<
38	<	# Check that we have a working $echo.
39	<	if test "X$1" = X--no-reexec; then
40	<	# Discard the --no-reexec flag, and continue.
41	<	shift
42	<	elif test "X$1" = X--fallback-echo; then
43	<	# Avoid inline document here, it may be left over
44	<	:
45	<	elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
46	<	# Yippee, $echo works!
47	<	:
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	>	#       --no-quiet, --no-silent
43	>	#                            print informational messages (default)
44	>	#       --no-warn            don't display warning messages
45	>	#       --tag=TAG            use configuration variables from tag TAG
46	>	#   -v, --verbose            print more informational messages than default
47	>	#       --no-verbose         don't print the extra informational messages
48	>	#       --version            print version information
49	>	#   -h, --help, --help-all   print short, long, or detailed help message
50	>	#
51	>	# MODE must be one of the following:
52	>	#
53	>	#         clean              remove files from the build directory
54	>	#         compile            compile a source file into a libtool object
55	>	#         execute            automatically set library path, then run a program
56	>	#         finish             complete the installation of libtool libraries
57	>	#         install            install libraries or executables
58	>	#         link               create a library or an executable
59	>	#         uninstall          remove libraries from an installed directory
60	>	#
61	>	# MODE-ARGS vary depending on the MODE.  When passed as first option,
62	>	# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
63	>	# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64	>	#
65	>	# When reporting a bug, please describe a test case to reproduce it and
66	>	# include the following information:
67	>	#
68	>	#         host-triplet: $host
69	>	#         shell:                $SHELL
70	>	#         compiler:             $LTCC
71	>	#         compiler flags:               $LTCFLAGS
72	>	#         linker:               $LD (gnu? $with_gnu_ld)
73	>	#         $progname:    (GNU libtool) 2.4.2
74	>	#         automake:     $automake_version
75	>	#         autoconf:     $autoconf_version
76	>	#
77	>	# Report bugs to <bug-libtool@gnu.org>.
78	>	# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79	>	# General help using GNU software: <http://www.gnu.org/gethelp/>.
80	>
81	>	PROGRAM=libtool
82	>	PACKAGE=libtool
83	>	VERSION=2.4.2
84	>	TIMESTAMP=""
85	>	package_revision=1.3337
86	>
87	>	# Be Bourne compatible
88	>	if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
89	>	emulate sh
90	>	NULLCMD=:
91	>	# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92	>	# is contrary to our usage.  Disable this feature.
93	>	alias -g '${1+"$@"}'='"$@"'
94	>	setopt NO_GLOB_SUBST
95		else
96	<	# Restart under the correct shell, and then maybe $echo will work.
39	<	exec $SHELL "$0" --no-reexec ${1+"$@"}
96	>	case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97		fi
98	+	BIN_SH=xpg4; export BIN_SH # for Tru64
99	+	DUALCASE=1; export DUALCASE # for MKS sh
100
101	<	if test "X$1" = X--fallback-echo; then
102	<	# used as fallback echo
103	<	shift
104	<	cat <<EOF
105	<	$*
106	<	EOF
107	<	exit 0
49	<	fi
101	>	# A function that is used when there is no print builtin or printf.
102	>	func_fallback_echo ()
103	>	{
104	>	eval 'cat <<_LTECHO_EOF
105	>	$1
106	>	_LTECHO_EOF'
107	>	}
108
109	<	# The name of this program.
110	<	progname=`$echo "$0" | ${SED} 's%^.*/%%'`
111	<	modename="$progname"
109	>	# NLS nuisances: We save the old values to restore during execute mode.
110	>	lt_user_locale=
111	>	lt_safe_locale=
112	>	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113	>	do
114	>	eval "if test \"\${$lt_var+set}\" = set; then
115	>	save_$lt_var=\$$lt_var
116	>	$lt_var=C
117	>	export $lt_var
118	>	lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119	>	lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
120	>	fi"
121	>	done
122	>	LC_ALL=C
123	>	LANGUAGE=C
124	>	export LANGUAGE LC_ALL
125	>
126	>	$lt_unset CDPATH
127	>
128	>
129	>	# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130	>	# is ksh but when the shell is invoked as "sh" and the current value of
131	>	# the _XPG environment variable is not equal to 1 (one), the special
132	>	# positional parameter $0, within a function call, is the name of the
133	>	# function.
134	>	progpath="$0"
135
55	–	# Constants.
56	–	PROGRAM=ltmain.sh
57	–	PACKAGE=libtool
58	–	VERSION=1.5
59	–	TIMESTAMP=" (1.1220 2003/04/05 19:32:58)"
136
61	–	default_mode=
62	–	help="Try \`$progname --help' for more information."
63	–	magic="%%%MAGIC variable%%%"
64	–	mkdir="mkdir"
65	–	mv="mv -f"
66	–	rm="rm -f"
137
138	<	# Sed substitution that helps us do robust quoting.  It backslashifies
139	<	# metacharacters that are still active within double-quoted strings.
140	<	Xsed="${SED}"' -e 1s/^X//'
141	<	sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
142	<	# test EBCDIC or ASCII
143	<	case `echo A|od -x` in
144	<	*[Cc]1*) # EBCDIC based system
145	<	SP2NL="tr '\100' '\n'"
146	<	NL2SP="tr '\r\n' '\100\100'"
147	<	;;
148	<	*) # Assume ASCII based system
149	<	SP2NL="tr '\040' '\012'"
150	<	NL2SP="tr '\015\012' '\040\040'"
151	<	;;
82	<	esac
138	>	: ${CP="cp -f"}
139	>	test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
140	>	: ${MAKE="make"}
141	>	: ${MKDIR="mkdir"}
142	>	: ${MV="mv -f"}
143	>	: ${RM="rm -f"}
144	>	: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145	>	: ${Xsed="$SED -e 1s/^X//"}
146	>
147	>	# Global variables:
148	>	EXIT_SUCCESS=0
149	>	EXIT_FAILURE=1
150	>	EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
151	>	EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
152
153	<	# NLS nuisances.
85	<	# Only set LANG and LC_ALL to C if already set.
86	<	# These must not be set unconditionally because not all systems understand
87	<	# e.g. LANG=C (notably SCO).
88	<	# We save the old values to restore during execute mode.
89	<	if test "${LC_ALL+set}" = set; then
90	<	save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
91	<	fi
92	<	if test "${LANG+set}" = set; then
93	<	save_LANG="$LANG"; LANG=C; export LANG
94	<	fi
153	>	exit_status=$EXIT_SUCCESS
154
155		# Make sure IFS has a sensible default
156	<	: ${IFS="       "}
156	>	lt_nl='
157	>	'
158	>	IFS="   $lt_nl"
159	>
160	>	dirname="s,/[^/]*$,,"
161	>	basename="s,^.*/,,"
162	>
163	>	# func_dirname file append nondir_replacement
164	>	# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
165	>	# otherwise set result to NONDIR_REPLACEMENT.
166	>	func_dirname ()
167	>	{
168	>	func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
169	>	if test "X$func_dirname_result" = "X${1}"; then
170	>	func_dirname_result="${3}"
171	>	else
172	>	func_dirname_result="$func_dirname_result${2}"
173	>	fi
174	>	} # func_dirname may be replaced by extended shell implementation
175
99	–	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
100	–	$echo "$modename: not configured to build any kind of library" 1>&2
101	–	$echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
102	–	exit 1
103	–	fi
176
177	<	# Global variables.
178	<	mode=$default_mode
179	<	nonopt=
180	<	prev=
181	<	prevopt=
110	<	run=
111	<	show="$echo"
112	<	show_help=
113	<	execute_dlfiles=
114	<	lo2o="s/\\.lo\$/.${objext}/"
115	<	o2lo="s/\\.${objext}\$/.lo/"
177	>	# func_basename file
178	>	func_basename ()
179	>	{
180	>	func_basename_result=`$ECHO "${1}" | $SED "$basename"`
181	>	} # func_basename may be replaced by extended shell implementation
182
117	–	#####################################
118	–	# Shell function definitions:
119	–	# This seems to be the best place for them
183
184	<	# Need a lot of goo to handle *both* DLLs and import libs
185	<	# Has to be a shell function in order to 'eat' the argument
186	<	# that is supplied when $file_magic_command is called.
187	<	win32_libid () {
188	<	win32_libid_type="unknown"
189	<	win32_fileres=`file -L $1 2>/dev/null`
190	<	case $win32_fileres in
191	<	*ar\ archive\ import\ library*) # definitely import
192	<	win32_libid_type="x86 archive import"
193	<	;;
194	<	*ar\ archive*) # could be an import, or static
195	<	if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
196	<	grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
197	<	win32_nmres=`eval $NM -f posix -A $1 | \
198	<	sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
199	<	if test "X$win32_nmres" = "Ximport" ; then
200	<	win32_libid_type="x86 archive import"
201	<	else
202	<	win32_libid_type="x86 archive static"
203	<	fi
184	>	# func_dirname_and_basename file append nondir_replacement
185	>	# perform func_basename and func_dirname in a single function
186	>	# call:
187	>	#   dirname:  Compute the dirname of FILE.  If nonempty,
188	>	#             add APPEND to the result, otherwise set result
189	>	#             to NONDIR_REPLACEMENT.
190	>	#             value returned in "$func_dirname_result"
191	>	#   basename: Compute filename of FILE.
192	>	#             value retuned in "$func_basename_result"
193	>	# Implementation must be kept synchronized with func_dirname
194	>	# and func_basename. For efficiency, we do not delegate to
195	>	# those functions but instead duplicate the functionality here.
196	>	func_dirname_and_basename ()
197	>	{
198	>	# Extract subdirectory from the argument.
199	>	func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
200	>	if test "X$func_dirname_result" = "X${1}"; then
201	>	func_dirname_result="${3}"
202	>	else
203	>	func_dirname_result="$func_dirname_result${2}"
204		fi
205	+	func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
206	+	} # func_dirname_and_basename may be replaced by extended shell implementation
207	+
208	+
209	+	# func_stripname prefix suffix name
210	+	# strip PREFIX and SUFFIX off of NAME.
211	+	# PREFIX and SUFFIX must not contain globbing or regex special
212	+	# characters, hashes, percent signs, but SUFFIX may contain a leading
213	+	# dot (in which case that matches only a dot).
214	+	# func_strip_suffix prefix name
215	+	func_stripname ()
216	+	{
217	+	case ${2} in
218	+	.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219	+	*)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
220	+	esac
221	+	} # func_stripname may be replaced by extended shell implementation
222	+
223	+
224	+	# These SED scripts presuppose an absolute path with a trailing slash.
225	+	pathcar='s,^/\([^/]*\).*$,\1,'
226	+	pathcdr='s,^/[^/]*,,'
227	+	removedotparts=':dotsl
228	+	s@/\./@/@g
229	+	t dotsl
230	+	s,/\.$,/,'
231	+	collapseslashes='s@/\{1,\}@/@g'
232	+	finalslash='s,/*$,/,'
233	+
234	+	# func_normal_abspath PATH
235	+	# Remove doubled-up and trailing slashes, "." path components,
236	+	# and cancel out any ".." path components in PATH after making
237	+	# it an absolute path.
238	+	#             value returned in "$func_normal_abspath_result"
239	+	func_normal_abspath ()
240	+	{
241	+	# Start from root dir and reassemble the path.
242	+	func_normal_abspath_result=
243	+	func_normal_abspath_tpath=$1
244	+	func_normal_abspath_altnamespace=
245	+	case $func_normal_abspath_tpath in
246	+	"")
247	+	# Empty path, that just means $cwd.
248	+	func_stripname '' '/' "`pwd`"
249	+	func_normal_abspath_result=$func_stripname_result
250	+	return
251		;;
252	<	*DLL*)
253	<	win32_libid_type="x86 DLL"
252	>	# The next three entries are used to spot a run of precisely
253	>	# two leading slashes without using negated character classes;
254	>	# we take advantage of case's first-match behaviour.
255	>	///*)
256	>	# Unusual form of absolute path, do nothing.
257		;;
258	<	*executable*) # but shell scripts are "executable" too...
259	<	case $win32_fileres in
260	<	*MS\ Windows\ PE\ Intel*)
261	<	win32_libid_type="x86 DLL"
262	<	;;
263	<	esac
258	>	//*)
259	>	# Not necessarily an ordinary path; POSIX reserves leading '//'
260	>	# and for example Cygwin uses it to access remote file shares
261	>	# over CIFS/SMB, so we conserve a leading double slash if found.
262	>	func_normal_abspath_altnamespace=/
263	>	;;
264	>	/*)
265	>	# Absolute path, do nothing.
266	>	;;
267	>	*)
268	>	# Relative path, prepend $cwd.
269	>	func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
270		;;
271		esac
272	<	$echo $win32_libid_type
272	>	# Cancel out all the simple stuff to save iterations.  We also want
273	>	# the path to end with a slash for ease of parsing, so make sure
274	>	# there is one (and only one) here.
275	>	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
276	>	-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
277	>	while :; do
278	>	# Processed it all yet?
279	>	if test "$func_normal_abspath_tpath" = / ; then
280	>	# If we ascended to the root using ".." the result may be empty now.
281	>	if test -z "$func_normal_abspath_result" ; then
282	>	func_normal_abspath_result=/
283	>	fi
284	>	break
285	>	fi
286	>	func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
287	>	-e "$pathcar"`
288	>	func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
289	>	-e "$pathcdr"`
290	>	# Figure out what to do with it
291	>	case $func_normal_abspath_tcomponent in
292	>	"")
293	>	# Trailing empty path component, ignore it.
294	>	;;
295	>	..)
296	>	# Parent dir; strip last assembled component from result.
297	>	func_dirname "$func_normal_abspath_result"
298	>	func_normal_abspath_result=$func_dirname_result
299	>	;;
300	>	*)
301	>	# Actual path component, append it.
302	>	func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
303	>	;;
304	>	esac
305	>	done
306	>	# Restore leading double-slash if one was found on entry.
307	>	func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
308		}
309
310	<	# End of Shell function definitions
311	<	#####################################
310	>	# func_relative_path SRCDIR DSTDIR
311	>	# generates a relative path from SRCDIR to DSTDIR, with a trailing
312	>	# slash if non-empty, suitable for immediately appending a filename
313	>	# without needing to append a separator.
314	>	#             value returned in "$func_relative_path_result"
315	>	func_relative_path ()
316	>	{
317	>	func_relative_path_result=
318	>	func_normal_abspath "$1"
319	>	func_relative_path_tlibdir=$func_normal_abspath_result
320	>	func_normal_abspath "$2"
321	>	func_relative_path_tbindir=$func_normal_abspath_result
322	>
323	>	# Ascend the tree starting from libdir
324	>	while :; do
325	>	# check if we have found a prefix of bindir
326	>	case $func_relative_path_tbindir in
327	>	$func_relative_path_tlibdir)
328	>	# found an exact match
329	>	func_relative_path_tcancelled=
330	>	break
331	>	;;
332	>	$func_relative_path_tlibdir*)
333	>	# found a matching prefix
334	>	func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335	>	func_relative_path_tcancelled=$func_stripname_result
336	>	if test -z "$func_relative_path_result"; then
337	>	func_relative_path_result=.
338	>	fi
339	>	break
340	>	;;
341	>	*)
342	>	func_dirname $func_relative_path_tlibdir
343	>	func_relative_path_tlibdir=${func_dirname_result}
344	>	if test "x$func_relative_path_tlibdir" = x ; then
345	>	# Have to descend all the way to the root!
346	>	func_relative_path_result=../$func_relative_path_result
347	>	func_relative_path_tcancelled=$func_relative_path_tbindir
348	>	break
349	>	fi
350	>	func_relative_path_result=../$func_relative_path_result
351	>	;;
352	>	esac
353	>	done
354
355	<	# Parse our command line options once, thoroughly.
356	<	while test "$#" -gt 0
357	<	do
358	<	arg="$1"
359	<	shift
355	>	# Now calculate path; take care to avoid doubling-up slashes.
356	>	func_stripname '' '/' "$func_relative_path_result"
357	>	func_relative_path_result=$func_stripname_result
358	>	func_stripname '/' '/' "$func_relative_path_tcancelled"
359	>	if test "x$func_stripname_result" != x ; then
360	>	func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
361	>	fi
362
363	<	case $arg in
364	<	-*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
365	<	*) optarg= ;;
366	<	esac
363	>	# Normalisation. If bindir is libdir, return empty string,
364	>	# else relative path ending with a slash; either way, target
365	>	# file name can be directly appended.
366	>	if test ! -z "$func_relative_path_result"; then
367	>	func_stripname './' '' "$func_relative_path_result/"
368	>	func_relative_path_result=$func_stripname_result
369	>	fi
370	>	}
371
372	<	# If the previous option needs an argument, assign it.
373	<	if test -n "$prev"; then
374	<	case $prev in
375	<	execute_dlfiles)
376	<	execute_dlfiles="$execute_dlfiles $arg"
377	<	;;
378	<	tag)
379	<	tagname="$arg"
372	>	# The name of this program:
373	>	func_dirname_and_basename "$progpath"
374	>	progname=$func_basename_result
375	>
376	>	# Make sure we have an absolute path for reexecution:
377	>	case $progpath in
378	>	[\\/]*|[A-Za-z]:\\*) ;;
379	>	*[\\/]*)
380	>	progdir=$func_dirname_result
381	>	progdir=`cd "$progdir" && pwd`
382	>	progpath="$progdir/$progname"
383	>	;;
384	>	*)
385	>	save_IFS="$IFS"
386	>	IFS=${PATH_SEPARATOR-:}
387	>	for progdir in $PATH; do
388	>	IFS="$save_IFS"
389	>	test -x "$progdir/$progname" && break
390	>	done
391	>	IFS="$save_IFS"
392	>	test -n "$progdir" || progdir=`pwd`
393	>	progpath="$progdir/$progname"
394	>	;;
395	>	esac
396
397	<	# Check whether tagname contains only valid characters
398	<	case $tagname in
399	<	*[!-_A-Za-z0-9,/]*)
400	<	$echo "$progname: invalid tag name: $tagname" 1>&2
401	<	exit 1
402	<	;;
397	>	# Sed substitution that helps us do robust quoting.  It backslashifies
398	>	# metacharacters that are still active within double-quoted strings.
399	>	Xsed="${SED}"' -e 1s/^X//'
400	>	sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
401	>
402	>	# Same as above, but do not quote variable references.
403	>	double_quote_subst='s/\(["`\\]\)/\\\1/g'
404	>
405	>	# Sed substitution that turns a string into a regex matching for the
406	>	# string literally.
407	>	sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
408	>
409	>	# Sed substitution that converts a w32 file name or path
410	>	# which contains forward slashes, into one that contains
411	>	# (escaped) backslashes.  A very naive implementation.
412	>	lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
413	>
414	>	# Re-`\' parameter expansions in output of double_quote_subst that were
415	>	# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
416	>	# in input to double_quote_subst, that '$' was protected from expansion.
417	>	# Since each input `\' is now two `\'s, look for any number of runs of
418	>	# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
419	>	bs='\\'
420	>	bs2='\\\\'
421	>	bs4='\\\\\\\\'
422	>	dollar='\$'
423	>	sed_double_backslash="\
424	>	s/$bs4/&\\
425	>	/g
426	>	s/^$bs2$dollar/$bs&/
427	>	s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
428	>	s/\n//g"
429	>
430	>	# Standard options:
431	>	opt_dry_run=false
432	>	opt_help=false
433	>	opt_quiet=false
434	>	opt_verbose=false
435	>	opt_warning=:
436	>
437	>	# func_echo arg...
438	>	# Echo program name prefixed message, along with the current mode
439	>	# name if it has been set yet.
440	>	func_echo ()
441	>	{
442	>	$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
443	>	}
444	>
445	>	# func_verbose arg...
446	>	# Echo program name prefixed message in verbose mode only.
447	>	func_verbose ()
448	>	{
449	>	$opt_verbose && func_echo ${1+"$@"}
450	>
451	>	# A bug in bash halts the script if the last line of a function
452	>	# fails when set -e is in force, so we need another command to
453	>	# work around that:
454	>	:
455	>	}
456	>
457	>	# func_echo_all arg...
458	>	# Invoke $ECHO with all args, space-separated.
459	>	func_echo_all ()
460	>	{
461	>	$ECHO "$*"
462	>	}
463	>
464	>	# func_error arg...
465	>	# Echo program name prefixed message to standard error.
466	>	func_error ()
467	>	{
468	>	$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
469	>	}
470	>
471	>	# func_warning arg...
472	>	# Echo program name prefixed warning message to standard error.
473	>	func_warning ()
474	>	{
475	>	$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
476	>
477	>	# bash bug again:
478	>	:
479	>	}
480	>
481	>	# func_fatal_error arg...
482	>	# Echo program name prefixed message to standard error, and exit.
483	>	func_fatal_error ()
484	>	{
485	>	func_error ${1+"$@"}
486	>	exit $EXIT_FAILURE
487	>	}
488	>
489	>	# func_fatal_help arg...
490	>	# Echo program name prefixed message to standard error, followed by
491	>	# a help hint, and exit.
492	>	func_fatal_help ()
493	>	{
494	>	func_error ${1+"$@"}
495	>	func_fatal_error "$help"
496	>	}
497	>	help="Try \`$progname --help' for more information."  ## default
498	>
499	>
500	>	# func_grep expression filename
501	>	# Check whether EXPRESSION matches any line of FILENAME, without output.
502	>	func_grep ()
503	>	{
504	>	$GREP "$1" "$2" >/dev/null 2>&1
505	>	}
506	>
507	>
508	>	# func_mkdir_p directory-path
509	>	# Make sure the entire path to DIRECTORY-PATH is available.
510	>	func_mkdir_p ()
511	>	{
512	>	my_directory_path="$1"
513	>	my_dir_list=
514	>
515	>	if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
516	>
517	>	# Protect directory names starting with `-'
518	>	case $my_directory_path in
519	>	-*) my_directory_path="./$my_directory_path" ;;
520		esac
521
522	<	case $tagname in
523	<	CC)
524	<	# Don't test for the "default" C tag, as we know, it's there, but
525	<	# not specially marked.
526	<	;;
522	>	# While some portion of DIR does not yet exist...
523	>	while test ! -d "$my_directory_path"; do
524	>	# ...make a list in topmost first order.  Use a colon delimited
525	>	# list incase some portion of path contains whitespace.
526	>	my_dir_list="$my_directory_path:$my_dir_list"
527	>
528	>	# If the last portion added has no slash in it, the list is done
529	>	case $my_directory_path in */*) ;; *) break ;; esac
530	>
531	>	# ...otherwise throw away the child directory and loop
532	>	my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
533	>	done
534	>	my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
535	>
536	>	save_mkdir_p_IFS="$IFS"; IFS=':'
537	>	for my_dir in $my_dir_list; do
538	>	IFS="$save_mkdir_p_IFS"
539	>	# mkdir can fail with a `File exist' error if two processes
540	>	# try to create one of the directories concurrently.  Don't
541	>	# stop in that case!
542	>	$MKDIR "$my_dir" 2>/dev/null || :
543	>	done
544	>	IFS="$save_mkdir_p_IFS"
545	>
546	>	# Bail out if we (or some other process) failed to create a directory.
547	>	test -d "$my_directory_path" || \
548	>	func_fatal_error "Failed to create \`$1'"
549	>	fi
550	>	}
551	>
552	>
553	>	# func_mktempdir [string]
554	>	# Make a temporary directory that won't clash with other running
555	>	# libtool processes, and avoids race conditions if possible.  If
556	>	# given, STRING is the basename for that directory.
557	>	func_mktempdir ()
558	>	{
559	>	my_template="${TMPDIR-/tmp}/${1-$progname}"
560	>
561	>	if test "$opt_dry_run" = ":"; then
562	>	# Return a directory name, but don't create it in dry-run mode
563	>	my_tmpdir="${my_template}-$$"
564	>	else
565	>
566	>	# If mktemp works, use that first and foremost
567	>	my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
568	>
569	>	if test ! -d "$my_tmpdir"; then
570	>	# Failing that, at least try and use $RANDOM to avoid a race
571	>	my_tmpdir="${my_template}-${RANDOM-0}$$"
572	>
573	>	save_mktempdir_umask=`umask`
574	>	umask 0077
575	>	$MKDIR "$my_tmpdir"
576	>	umask $save_mktempdir_umask
577	>	fi
578	>
579	>	# If we're not in dry-run mode, bomb out on failure
580	>	test -d "$my_tmpdir" || \
581	>	func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
582	>	fi
583	>
584	>	$ECHO "$my_tmpdir"
585	>	}
586	>
587	>
588	>	# func_quote_for_eval arg
589	>	# Aesthetically quote ARG to be evaled later.
590	>	# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591	>	# is double-quoted, suitable for a subsequent eval, whereas
592	>	# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593	>	# which are still active within double quotes backslashified.
594	>	func_quote_for_eval ()
595	>	{
596	>	case $1 in
597	>	*[\\\`\"\$]*)
598	>	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
599		*)
600	<	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
195	<	taglist="$taglist $tagname"
196	<	# Evaluate the configuration.
197	<	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
198	<	else
199	<	$echo "$progname: ignoring unknown tag $tagname" 1>&2
200	<	fi
201	<	;;
202	<	esac
203	<	;;
204	<	*)
205	<	eval "$prev=\$arg"
206	<	;;
600	>	func_quote_for_eval_unquoted_result="$1" ;;
601		esac
602
603	<	prev=
604	<	prevopt=
605	<	continue
606	<	fi
603	>	case $func_quote_for_eval_unquoted_result in
604	>	# Double-quote args containing shell metacharacters to delay
605	>	# word splitting, command substitution and and variable
606	>	# expansion for a subsequent eval.
607	>	# Many Bourne shells cannot handle close brackets correctly
608	>	# in scan sets, so we specify it separately.
609	>	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
610	>	func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
611	>	;;
612	>	*)
613	>	func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
614	>	esac
615	>	}
616
214	–	# Have we seen a non-optional argument yet?
215	–	case $arg in
216	–	--help)
217	–	show_help=yes
218	–	;;
617
618	<	--version)
619	<	$echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
620	<	$echo
621	<	$echo "Copyright (C) 2003  Free Software Foundation, Inc."
622	<	$echo "This is free software; see the source for copying conditions.  There is NO"
623	<	$echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
624	<	exit 0
618	>	# func_quote_for_expand arg
619	>	# Aesthetically quote ARG to be evaled later; same as above,
620	>	# but do not quote variable references.
621	>	func_quote_for_expand ()
622	>	{
623	>	case $1 in
624	>	*[\\\`\"]*)
625	>	my_arg=`$ECHO "$1" | $SED \
626	>	-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
627	>	*)
628	>	my_arg="$1" ;;
629	>	esac
630	>
631	>	case $my_arg in
632	>	# Double-quote args containing shell metacharacters to delay
633	>	# word splitting and command substitution for a subsequent eval.
634	>	# Many Bourne shells cannot handle close brackets correctly
635	>	# in scan sets, so we specify it separately.
636	>	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
637	>	my_arg="\"$my_arg\""
638	>	;;
639	>	esac
640	>
641	>	func_quote_for_expand_result="$my_arg"
642	>	}
643	>
644	>
645	>	# func_show_eval cmd [fail_exp]
646	>	# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
647	>	# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
648	>	# is given, then evaluate it.
649	>	func_show_eval ()
650	>	{
651	>	my_cmd="$1"
652	>	my_fail_exp="${2-:}"
653	>
654	>	${opt_silent-false} || {
655	>	func_quote_for_expand "$my_cmd"
656	>	eval "func_echo $func_quote_for_expand_result"
657	>	}
658	>
659	>	if ${opt_dry_run-false}; then :; else
660	>	eval "$my_cmd"
661	>	my_status=$?
662	>	if test "$my_status" -eq 0; then :; else
663	>	eval "(exit $my_status); $my_fail_exp"
664	>	fi
665	>	fi
666	>	}
667	>
668	>
669	>	# func_show_eval_locale cmd [fail_exp]
670	>	# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
671	>	# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
672	>	# is given, then evaluate it.  Use the saved locale for evaluation.
673	>	func_show_eval_locale ()
674	>	{
675	>	my_cmd="$1"
676	>	my_fail_exp="${2-:}"
677	>
678	>	${opt_silent-false} || {
679	>	func_quote_for_expand "$my_cmd"
680	>	eval "func_echo $func_quote_for_expand_result"
681	>	}
682	>
683	>	if ${opt_dry_run-false}; then :; else
684	>	eval "$lt_user_locale
685	>	$my_cmd"
686	>	my_status=$?
687	>	eval "$lt_safe_locale"
688	>	if test "$my_status" -eq 0; then :; else
689	>	eval "(exit $my_status); $my_fail_exp"
690	>	fi
691	>	fi
692	>	}
693	>
694	>	# func_tr_sh
695	>	# Turn $1 into a string suitable for a shell variable name.
696	>	# Result is stored in $func_tr_sh_result.  All characters
697	>	# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698	>	# if $1 begins with a digit, a '_' is prepended as well.
699	>	func_tr_sh ()
700	>	{
701	>	case $1 in
702	>	[0-9]* | *[!a-zA-Z0-9_]*)
703	>	func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
704	>	;;
705	>	* )
706	>	func_tr_sh_result=$1
707		;;
708	+	esac
709	+	}
710	+
711	+
712	+	# func_version
713	+	# Echo version message to standard output and exit.
714	+	func_version ()
715	+	{
716	+	$opt_debug
717	+
718	+	$SED -n '/(C)/!b go
719	+	:more
720	+	/\./!{
721	+	N
722	+	s/\n# / /
723	+	b more
724	+	}
725	+	:go
726	+	/^# '$PROGRAM' (GNU /,/# warranty; / {
727	+	s/^# //
728	+	s/^# *$//
729	+	s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
730	+	p
731	+	}' < "$progpath"
732	+	exit $?
733	+	}
734	+
735	+	# func_usage
736	+	# Echo short help message to standard output and exit.
737	+	func_usage ()
738	+	{
739	+	$opt_debug
740	+
741	+	$SED -n '/^# Usage:/,/^#  *.*--help/ {
742	+	s/^# //
743	+	s/^# *$//
744	+	s/\$progname/'$progname'/
745	+	p
746	+	}' < "$progpath"
747	+	echo
748	+	$ECHO "run \`$progname --help | more' for full usage"
749	+	exit $?
750	+	}
751	+
752	+	# func_help [NOEXIT]
753	+	# Echo long help message to standard output and exit,
754	+	# unless 'noexit' is passed as argument.
755	+	func_help ()
756	+	{
757	+	$opt_debug
758	+
759	+	$SED -n '/^# Usage:/,/# Report bugs to/ {
760	+	:print
761	+	s/^# //
762	+	s/^# *$//
763	+	s*\$progname*'$progname'*
764	+	s*\$host*'"$host"'*
765	+	s*\$SHELL*'"$SHELL"'*
766	+	s*\$LTCC*'"$LTCC"'*
767	+	s*\$LTCFLAGS*'"$LTCFLAGS"'*
768	+	s*\$LD*'"$LD"'*
769	+	s/\$with_gnu_ld/'"$with_gnu_ld"'/
770	+	s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771	+	s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
772	+	p
773	+	d
774	+	}
775	+	/^# .* home page:/b print
776	+	/^# General help using/b print
777	+	' < "$progpath"
778	+	ret=$?
779	+	if test -z "$1"; then
780	+	exit $ret
781	+	fi
782	+	}
783	+
784	+	# func_missing_arg argname
785	+	# Echo program name prefixed message to standard error and set global
786	+	# exit_cmd.
787	+	func_missing_arg ()
788	+	{
789	+	$opt_debug
790	+
791	+	func_error "missing argument for $1."
792	+	exit_cmd=exit
793	+	}
794	+
795	+
796	+	# func_split_short_opt shortopt
797	+	# Set func_split_short_opt_name and func_split_short_opt_arg shell
798	+	# variables after splitting SHORTOPT after the 2nd character.
799	+	func_split_short_opt ()
800	+	{
801	+	my_sed_short_opt='1s/^\(..\).*$/\1/;q'
802	+	my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
803	+
804	+	func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805	+	func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806	+	} # func_split_short_opt may be replaced by extended shell implementation
807	+
808	+
809	+	# func_split_long_opt longopt
810	+	# Set func_split_long_opt_name and func_split_long_opt_arg shell
811	+	# variables after splitting LONGOPT at the `=' sign.
812	+	func_split_long_opt ()
813	+	{
814	+	my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
815	+	my_sed_long_arg='1s/^--[^=]*=//'
816	+
817	+	func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818	+	func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819	+	} # func_split_long_opt may be replaced by extended shell implementation
820	+
821	+	exit_cmd=:
822	+
823	+
824	+
825	+
826	+
827	+	magic="%%%MAGIC variable%%%"
828	+	magic_exe="%%%MAGIC EXE variable%%%"
829	+
830	+	# Global variables.
831	+	nonopt=
832	+	preserve_args=
833	+	lo2o="s/\\.lo\$/.${objext}/"
834	+	o2lo="s/\\.${objext}\$/.lo/"
835	+	extracted_archives=
836	+	extracted_serial=0
837	+
838	+	# If this variable is set in any of the actions, the command in it
839	+	# will be execed at the end.  This prevents here-documents from being
840	+	# left over by shells.
841	+	exec_cmd=
842	+
843	+	# func_append var value
844	+	# Append VALUE to the end of shell variable VAR.
845	+	func_append ()
846	+	{
847	+	eval "${1}=\$${1}\${2}"
848	+	} # func_append may be replaced by extended shell implementation
849	+
850	+	# func_append_quoted var value
851	+	# Quote VALUE and append to the end of shell variable VAR, separated
852	+	# by a space.
853	+	func_append_quoted ()
854	+	{
855	+	func_quote_for_eval "${2}"
856	+	eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857	+	} # func_append_quoted may be replaced by extended shell implementation
858	+
859	+
860	+	# func_arith arithmetic-term...
861	+	func_arith ()
862	+	{
863	+	func_arith_result=`expr "${@}"`
864	+	} # func_arith may be replaced by extended shell implementation
865	+
866	+
867	+	# func_len string
868	+	# STRING may not start with a hyphen.
869	+	func_len ()
870	+	{
871	+	func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872	+	} # func_len may be replaced by extended shell implementation
873	+
874	+
875	+	# func_lo2o object
876	+	func_lo2o ()
877	+	{
878	+	func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
879	+	} # func_lo2o may be replaced by extended shell implementation
880	+
881	+
882	+	# func_xform libobj-or-source
883	+	func_xform ()
884	+	{
885	+	func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886	+	} # func_xform may be replaced by extended shell implementation
887	+
888	+
889	+	# func_fatal_configuration arg...
890	+	# Echo program name prefixed message to standard error, followed by
891	+	# a configuration failure hint, and exit.
892	+	func_fatal_configuration ()
893	+	{
894	+	func_error ${1+"$@"}
895	+	func_error "See the $PACKAGE documentation for more information."
896	+	func_fatal_error "Fatal configuration error."
897	+	}
898	+
899	+
900	+	# func_config
901	+	# Display the configuration for all the tags in this script.
902	+	func_config ()
903	+	{
904	+	re_begincf='^# ### BEGIN LIBTOOL'
905	+	re_endcf='^# ### END LIBTOOL'
906	+
907	+	# Default configuration.
908	+	$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
909
229	–	--config)
230	–	${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
910		# Now print the configurations for the tags.
911		for tagname in $taglist; do
912	<	${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
912	>	$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
913		done
235	–	exit 0
236	–	;;
237	–
238	–	--debug)
239	–	$echo "$progname: enabling shell trace mode"
240	–	set -x
241	–	;;
914
915	<	--dry-run | -n)
916	<	run=:
245	<	;;
915	>	exit $?
916	>	}
917
918	<	--features)
919	<	$echo "host: $host"
918	>	# func_features
919	>	# Display the features supported by this script.
920	>	func_features ()
921	>	{
922	>	echo "host: $host"
923		if test "$build_libtool_libs" = yes; then
924	<	$echo "enable shared libraries"
924	>	echo "enable shared libraries"
925		else
926	<	$echo "disable shared libraries"
926	>	echo "disable shared libraries"
927		fi
928		if test "$build_old_libs" = yes; then
929	<	$echo "enable static libraries"
929	>	echo "enable static libraries"
930		else
931	<	$echo "disable static libraries"
931	>	echo "disable static libraries"
932		fi
259	–	exit 0
260	–	;;
933
934	<	--finish) mode="finish" ;;
934	>	exit $?
935	>	}
936
937	<	--mode) prevopt="--mode" prev=mode ;;
938	<	--mode=*) mode="$optarg" ;;
937	>	# func_enable_tag tagname
938	>	# Verify that TAGNAME is valid, and either flag an error and exit, or
939	>	# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
940	>	# variable here.
941	>	func_enable_tag ()
942	>	{
943	>	# Global variable:
944	>	tagname="$1"
945
946	<	--preserve-dup-deps) duplicate_deps="yes" ;;
946	>	re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947	>	re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948	>	sed_extractcf="/$re_begincf/,/$re_endcf/p"
949	>
950	>	# Validate tagname.
951	>	case $tagname in
952	>	*[!-_A-Za-z0-9,/]*)
953	>	func_fatal_error "invalid tag name: $tagname"
954	>	;;
955	>	esac
956
957	<	--quiet | --silent)
958	<	show=:
959	<	;;
957	>	# Don't test for the "default" C tag, as we know it's
958	>	# there but not specially marked.
959	>	case $tagname in
960	>	CC) ;;
961	>	*)
962	>	if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
963	>	taglist="$taglist $tagname"
964
965	<	--tag) prevopt="--tag" prev=tag ;;
966	<	--tag=*)
967	<	set tag "$optarg" ${1+"$@"}
965	>	# Evaluate the configuration.  Be careful to quote the path
966	>	# and the sed script, to avoid splitting on whitespace, but
967	>	# also don't use non-portable quotes within backquotes within
968	>	# quotes we have to do it in 2 steps:
969	>	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
970	>	eval "$extractedcf"
971	>	else
972	>	func_error "ignoring unknown tag $tagname"
973	>	fi
974	>	;;
975	>	esac
976	>	}
977	>
978	>	# func_check_version_match
979	>	# Ensure that we are using m4 macros, and libtool script from the same
980	>	# release of libtool.
981	>	func_check_version_match ()
982	>	{
983	>	if test "$package_revision" != "$macro_revision"; then
984	>	if test "$VERSION" != "$macro_version"; then
985	>	if test -z "$macro_version"; then
986	>	cat >&2 <<_LT_EOF
987	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
988	>	$progname: definition of this LT_INIT comes from an older release.
989	>	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990	>	$progname: and run autoconf again.
991	>	_LT_EOF
992	>	else
993	>	cat >&2 <<_LT_EOF
994	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
995	>	$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996	>	$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997	>	$progname: and run autoconf again.
998	>	_LT_EOF
999	>	fi
1000	>	else
1001	>	cat >&2 <<_LT_EOF
1002	>	$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1003	>	$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004	>	$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005	>	$progname: of $PACKAGE $VERSION and run autoconf again.
1006	>	_LT_EOF
1007	>	fi
1008	>
1009	>	exit $EXIT_MISMATCH
1010	>	fi
1011	>	}
1012	>
1013	>
1014	>	# Shorthand for --mode=foo, only valid as the first argument
1015	>	case $1 in
1016	>	clean|clea|cle|cl)
1017	>	shift; set dummy --mode clean ${1+"$@"}; shift
1018	>	;;
1019	>	compile|compil|compi|comp|com|co|c)
1020	>	shift; set dummy --mode compile ${1+"$@"}; shift
1021	>	;;
1022	>	execute|execut|execu|exec|exe|ex|e)
1023	>	shift; set dummy --mode execute ${1+"$@"}; shift
1024	>	;;
1025	>	finish|finis|fini|fin|fi|f)
1026	>	shift; set dummy --mode finish ${1+"$@"}; shift
1027	>	;;
1028	>	install|instal|insta|inst|ins|in|i)
1029	>	shift; set dummy --mode install ${1+"$@"}; shift
1030	>	;;
1031	>	link|lin|li|l)
1032	>	shift; set dummy --mode link ${1+"$@"}; shift
1033	>	;;
1034	>	uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1035	>	shift; set dummy --mode uninstall ${1+"$@"}; shift
1036	>	;;
1037	>	esac
1038	>
1039	>
1040	>
1041	>	# Option defaults:
1042	>	opt_debug=:
1043	>	opt_dry_run=false
1044	>	opt_config=false
1045	>	opt_preserve_dup_deps=false
1046	>	opt_features=false
1047	>	opt_finish=false
1048	>	opt_help=false
1049	>	opt_help_all=false
1050	>	opt_silent=:
1051	>	opt_warning=:
1052	>	opt_verbose=:
1053	>	opt_silent=false
1054	>	opt_verbose=false
1055	>
1056	>
1057	>	# Parse options once, thoroughly.  This comes as soon as possible in the
1058	>	# script to make things like `--version' happen as quickly as we can.
1059	>	{
1060	>	# this just eases exit handling
1061	>	while test $# -gt 0; do
1062	>	opt="$1"
1063		shift
1064	<	prev=tag
1065	<	;;
1064	>	case $opt in
1065	>	--debug|-x)       opt_debug='set -x'
1066	>	func_echo "enabling shell trace mode"
1067	>	$opt_debug
1068	>	;;
1069	>	--dry-run|--dryrun|-n)
1070	>	opt_dry_run=:
1071	>	;;
1072	>	--config)
1073	>	opt_config=:
1074	>	func_config
1075	>	;;
1076	>	--dlopen|-dlopen)
1077	>	optarg="$1"
1078	>	opt_dlopen="${opt_dlopen+$opt_dlopen
1079	>	}$optarg"
1080	>	shift
1081	>	;;
1082	>	--preserve-dup-deps)
1083	>	opt_preserve_dup_deps=:
1084	>	;;
1085	>	--features)
1086	>	opt_features=:
1087	>	func_features
1088	>	;;
1089	>	--finish)
1090	>	opt_finish=:
1091	>	set dummy --mode finish ${1+"$@"}; shift
1092	>	;;
1093	>	--help)
1094	>	opt_help=:
1095	>	;;
1096	>	--help-all)
1097	>	opt_help_all=:
1098	>	opt_help=': help-all'
1099	>	;;
1100	>	--mode)
1101	>	test $# = 0 && func_missing_arg $opt && break
1102	>	optarg="$1"
1103	>	opt_mode="$optarg"
1104	>	case $optarg in
1105	>	# Valid mode arguments:
1106	>	clean|compile|execute|finish|install|link|relink|uninstall) ;;
1107	>
1108	>	# Catch anything else as an error
1109	>	*) func_error "invalid argument for $opt"
1110	>	exit_cmd=exit
1111	>	break
1112	>	;;
1113	>	esac
1114	>	shift
1115	>	;;
1116	>	--no-silent|--no-quiet)
1117	>	opt_silent=false
1118	>	func_append preserve_args " $opt"
1119	>	;;
1120	>	--no-warning|--no-warn)
1121	>	opt_warning=false
1122	>	func_append preserve_args " $opt"
1123	>	;;
1124	>	--no-verbose)
1125	>	opt_verbose=false
1126	>	func_append preserve_args " $opt"
1127	>	;;
1128	>	--silent|--quiet)
1129	>	opt_silent=:
1130	>	func_append preserve_args " $opt"
1131	>	opt_verbose=false
1132	>	;;
1133	>	--verbose|-v)
1134	>	opt_verbose=:
1135	>	func_append preserve_args " $opt"
1136	>	opt_silent=false
1137	>	;;
1138	>	--tag)
1139	>	test $# = 0 && func_missing_arg $opt && break
1140	>	optarg="$1"
1141	>	opt_tag="$optarg"
1142	>	func_append preserve_args " $opt $optarg"
1143	>	func_enable_tag "$optarg"
1144	>	shift
1145	>	;;
1146
1147	<	-dlopen)
1148	<	prevopt="-dlopen"
1149	<	prev=execute_dlfiles
1150	<	;;
1147	>	-\?|-h)           func_usage                              ;;
1148	>	--help)           func_help                               ;;
1149	>	--version)        func_version                            ;;
1150	>
1151	>	# Separate optargs to long options:
1152	>	--*=*)
1153	>	func_split_long_opt "$opt"
1154	>	set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1155	>	shift
1156	>	;;
1157
1158	<	-*)
1159	<	$echo "$modename: unrecognized option \`$arg'" 1>&2
1160	<	$echo "$help" 1>&2
1161	<	exit 1
1158	>	# Separate non-argument short options:
1159	>	-\?*|-h*|-n*|-v*)
1160	>	func_split_short_opt "$opt"
1161	>	set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1162	>	shift
1163	>	;;
1164	>
1165	>	--)               break                                   ;;
1166	>	-*)               func_fatal_help "unrecognized option \`$opt'" ;;
1167	>	*)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
1168	>	esac
1169	>	done
1170	>
1171	>	# Validate options:
1172	>
1173	>	# save first non-option argument
1174	>	if test "$#" -gt 0; then
1175	>	nonopt="$opt"
1176	>	shift
1177	>	fi
1178	>
1179	>	# preserve --debug
1180	>	test "$opt_debug" = : || func_append preserve_args " --debug"
1181	>
1182	>	case $host in
1183	>	*cygwin* | *mingw* | *pw32* | *cegcc*)
1184	>	# don't eliminate duplications in $postdeps and $predeps
1185	>	opt_duplicate_compiler_generated_deps=:
1186	>	;;
1187	>	*)
1188	>	opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1189	>	;;
1190	>	esac
1191	>
1192	>	$opt_help || {
1193	>	# Sanity checks first:
1194	>	func_check_version_match
1195	>
1196	>	if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197	>	func_fatal_configuration "not configured to build any kind of library"
1198	>	fi
1199	>
1200	>	# Darwin sucks
1201	>	eval std_shrext=\"$shrext_cmds\"
1202	>
1203	>	# Only execute mode is allowed to have -dlopen flags.
1204	>	if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1205	>	func_error "unrecognized option \`-dlopen'"
1206	>	$ECHO "$help" 1>&2
1207	>	exit $EXIT_FAILURE
1208	>	fi
1209	>
1210	>	# Change the help message to a mode-specific one.
1211	>	generic_help="$help"
1212	>	help="Try \`$progname --help --mode=$opt_mode' for more information."
1213	>	}
1214	>
1215	>
1216	>	# Bail if the options were screwed
1217	>	$exit_cmd $EXIT_FAILURE
1218	>	}
1219	>
1220	>
1221	>
1222	>
1223	>	## ----------- ##
1224	>	##    Main.    ##
1225	>	## ----------- ##
1226	>
1227	>	# func_lalib_p file
1228	>	# True iff FILE is a libtool `.la' library or `.lo' object file.
1229	>	# This function is only a basic sanity check; it will hardly flush out
1230	>	# determined imposters.
1231	>	func_lalib_p ()
1232	>	{
1233	>	test -f "$1" &&
1234	>	$SED -e 4q "$1" 2>/dev/null \
1235	>	| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1236	>	}
1237	>
1238	>	# func_lalib_unsafe_p file
1239	>	# True iff FILE is a libtool `.la' library or `.lo' object file.
1240	>	# This function implements the same check as func_lalib_p without
1241	>	# resorting to external programs.  To this end, it redirects stdin and
1242	>	# closes it afterwards, without saving the original file descriptor.
1243	>	# As a safety measure, use it only where a negative result would be
1244	>	# fatal anyway.  Works if `file' does not exist.
1245	>	func_lalib_unsafe_p ()
1246	>	{
1247	>	lalib_p=no
1248	>	if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249	>	for lalib_p_l in 1 2 3 4
1250	>	do
1251	>	read lalib_p_line
1252	>	case "$lalib_p_line" in
1253	>	\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1254	>	esac
1255	>	done
1256	>	exec 0<&5 5<&-
1257	>	fi
1258	>	test "$lalib_p" = yes
1259	>	}
1260	>
1261	>	# func_ltwrapper_script_p file
1262	>	# True iff FILE is a libtool wrapper script
1263	>	# This function is only a basic sanity check; it will hardly flush out
1264	>	# determined imposters.
1265	>	func_ltwrapper_script_p ()
1266	>	{
1267	>	func_lalib_p "$1"
1268	>	}
1269	>
1270	>	# func_ltwrapper_executable_p file
1271	>	# True iff FILE is a libtool wrapper executable
1272	>	# This function is only a basic sanity check; it will hardly flush out
1273	>	# determined imposters.
1274	>	func_ltwrapper_executable_p ()
1275	>	{
1276	>	func_ltwrapper_exec_suffix=
1277	>	case $1 in
1278	>	*.exe) ;;
1279	>	*) func_ltwrapper_exec_suffix=.exe ;;
1280	>	esac
1281	>	$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1282	>	}
1283	>
1284	>	# func_ltwrapper_scriptname file
1285	>	# Assumes file is an ltwrapper_executable
1286	>	# uses $file to determine the appropriate filename for a
1287	>	# temporary ltwrapper_script.
1288	>	func_ltwrapper_scriptname ()
1289	>	{
1290	>	func_dirname_and_basename "$1" "" "."
1291	>	func_stripname '' '.exe' "$func_basename_result"
1292	>	func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1293	>	}
1294	>
1295	>	# func_ltwrapper_p file
1296	>	# True iff FILE is a libtool wrapper script or wrapper executable
1297	>	# This function is only a basic sanity check; it will hardly flush out
1298	>	# determined imposters.
1299	>	func_ltwrapper_p ()
1300	>	{
1301	>	func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1302	>	}
1303	>
1304	>
1305	>	# func_execute_cmds commands fail_cmd
1306	>	# Execute tilde-delimited COMMANDS.
1307	>	# If FAIL_CMD is given, eval that upon failure.
1308	>	# FAIL_CMD may read-access the current command in variable CMD!
1309	>	func_execute_cmds ()
1310	>	{
1311	>	$opt_debug
1312	>	save_ifs=$IFS; IFS='~'
1313	>	for cmd in $1; do
1314	>	IFS=$save_ifs
1315	>	eval cmd=\"$cmd\"
1316	>	func_show_eval "$cmd" "${2-:}"
1317	>	done
1318	>	IFS=$save_ifs
1319	>	}
1320	>
1321	>
1322	>	# func_source file
1323	>	# Source FILE, adding directory component if necessary.
1324	>	# Note that it is not necessary on cygwin/mingw to append a dot to
1325	>	# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326	>	# behavior happens only for exec(3), not for open(2)!  Also, sourcing
1327	>	# `FILE.' does not work on cygwin managed mounts.
1328	>	func_source ()
1329	>	{
1330	>	$opt_debug
1331	>	case $1 in
1332	>	*/* | *\\*) . "$1" ;;
1333	>	*)          . "./$1" ;;
1334	>	esac
1335	>	}
1336	>
1337	>
1338	>	# func_resolve_sysroot PATH
1339	>	# Replace a leading = in PATH with a sysroot.  Store the result into
1340	>	# func_resolve_sysroot_result
1341	>	func_resolve_sysroot ()
1342	>	{
1343	>	func_resolve_sysroot_result=$1
1344	>	case $func_resolve_sysroot_result in
1345	>	=*)
1346	>	func_stripname '=' '' "$func_resolve_sysroot_result"
1347	>	func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1348		;;
1349	+	esac
1350	+	}
1351
1352	+	# func_replace_sysroot PATH
1353	+	# If PATH begins with the sysroot, replace it with = and
1354	+	# store the result into func_replace_sysroot_result.
1355	+	func_replace_sysroot ()
1356	+	{
1357	+	case "$lt_sysroot:$1" in
1358	+	?*:"$lt_sysroot"*)
1359	+	func_stripname "$lt_sysroot" '' "$1"
1360	+	func_replace_sysroot_result="=$func_stripname_result"
1361	+	;;
1362		*)
1363	<	nonopt="$arg"
1364	<	break
1363	>	# Including no sysroot.
1364	>	func_replace_sysroot_result=$1
1365		;;
1366		esac
1367	<	done
1367	>	}
1368
1369	<	if test -n "$prevopt"; then
1370	<	$echo "$modename: option \`$prevopt' requires an argument" 1>&2
1371	<	$echo "$help" 1>&2
1372	<	exit 1
1373	<	fi
1369	>	# func_infer_tag arg
1370	>	# Infer tagged configuration to use if any are available and
1371	>	# if one wasn't chosen via the "--tag" command line option.
1372	>	# Only attempt this if the compiler in the base compile
1373	>	# command doesn't match the default compiler.
1374	>	# arg is usually of the form 'gcc ...'
1375	>	func_infer_tag ()
1376	>	{
1377	>	$opt_debug
1378	>	if test -n "$available_tags" && test -z "$tagname"; then
1379	>	CC_quoted=
1380	>	for arg in $CC; do
1381	>	func_append_quoted CC_quoted "$arg"
1382	>	done
1383	>	CC_expanded=`func_echo_all $CC`
1384	>	CC_quoted_expanded=`func_echo_all $CC_quoted`
1385	>	case $@ in
1386	>	# Blanks in the command may have been stripped by the calling shell,
1387	>	# but not from the CC environment variable when configure was run.
1388	>	" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389	>	" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1390	>	# Blanks at the start of $base_compile will cause this to fail
1391	>	# if we don't check for them as well.
1392	>	*)
1393	>	for z in $available_tags; do
1394	>	if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1395	>	# Evaluate the configuration.
1396	>	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1397	>	CC_quoted=
1398	>	for arg in $CC; do
1399	>	# Double-quote args containing other shell metacharacters.
1400	>	func_append_quoted CC_quoted "$arg"
1401	>	done
1402	>	CC_expanded=`func_echo_all $CC`
1403	>	CC_quoted_expanded=`func_echo_all $CC_quoted`
1404	>	case "$@ " in
1405	>	" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406	>	" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1407	>	# The compiler in the base compile command matches
1408	>	# the one in the tagged configuration.
1409	>	# Assume this is the tagged configuration we want.
1410	>	tagname=$z
1411	>	break
1412	>	;;
1413	>	esac
1414	>	fi
1415	>	done
1416	>	# If $tagname still isn't set, then no tagged configuration
1417	>	# was found and let the user know that the "--tag" command
1418	>	# line option must be used.
1419	>	if test -z "$tagname"; then
1420	>	func_echo "unable to infer tagged configuration"
1421	>	func_fatal_error "specify a tag with \`--tag'"
1422	>	#       else
1423	>	#         func_verbose "using $tagname tagged configuration"
1424	>	fi
1425	>	;;
1426	>	esac
1427	>	fi
1428	>	}
1429
304	–	# If this variable is set in any of the actions, the command in it
305	–	# will be execed at the end.  This prevents here-documents from being
306	–	# left over by shells.
307	–	exec_cmd=
1430
1431	<	if test -z "$show_help"; then
1432	<	archargs=
1433	<	case $host in
1434	<	*-*-darwin*)
1435	<	# For darwin, separate arch arguments and apply them to all compile/link
1436	<	# commands
1437	<	doarch=
1438	<	for arg; do
1439	<	if test -n "$doarch"; then
1440	<	archargs="$archargs -arch $arg"
1441	<	doarch=
1442	<	continue
1431	>
1432	>	# func_write_libtool_object output_name pic_name nonpic_name
1433	>	# Create a libtool object file (analogous to a ".la" file),
1434	>	# but don't create it if we're doing a dry run.
1435	>	func_write_libtool_object ()
1436	>	{
1437	>	write_libobj=${1}
1438	>	if test "$build_libtool_libs" = yes; then
1439	>	write_lobj=\'${2}\'
1440	>	else
1441	>	write_lobj=none
1442	>	fi
1443	>
1444	>	if test "$build_old_libs" = yes; then
1445	>	write_oldobj=\'${3}\'
1446	>	else
1447	>	write_oldobj=none
1448	>	fi
1449	>
1450	>	$opt_dry_run || {
1451	>	cat >${write_libobj}T <<EOF
1452	>	# $write_libobj - a libtool object file
1453	>	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454	>	#
1455	>	# Please DO NOT delete this file!
1456	>	# It is necessary for linking the library.
1457	>
1458	>	# Name of the PIC object.
1459	>	pic_object=$write_lobj
1460	>
1461	>	# Name of the non-PIC object
1462	>	non_pic_object=$write_oldobj
1463	>
1464	>	EOF
1465	>	$MV "${write_libobj}T" "${write_libobj}"
1466	>	}
1467	>	}
1468	>
1469	>
1470	>	##################################################
1471	>	# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472	>	##################################################
1473	>
1474	>	# func_convert_core_file_wine_to_w32 ARG
1475	>	# Helper function used by file name conversion functions when $build is *nix,
1476	>	# and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477	>	# correctly configured wine environment available, with the winepath program
1478	>	# in $build's $PATH.
1479	>	#
1480	>	# ARG is the $build file name to be converted to w32 format.
1481	>	# Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482	>	# be empty on error (or when ARG is empty)
1483	>	func_convert_core_file_wine_to_w32 ()
1484	>	{
1485	>	$opt_debug
1486	>	func_convert_core_file_wine_to_w32_result="$1"
1487	>	if test -n "$1"; then
1488	>	# Unfortunately, winepath does not exit with a non-zero error code, so we
1489	>	# are forced to check the contents of stdout. On the other hand, if the
1490	>	# command is not found, the shell will set an exit code of 127 and print
1491	>	# *an error message* to stdout. So we must check for both error code of
1492	>	# zero AND non-empty stdout, which explains the odd construction:
1493	>	func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1494	>	if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495	>	func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496	>	$SED -e "$lt_sed_naive_backslashify"`
1497	>	else
1498	>	func_convert_core_file_wine_to_w32_result=
1499	>	fi
1500	>	fi
1501	>	}
1502	>	# end: func_convert_core_file_wine_to_w32
1503	>
1504	>
1505	>	# func_convert_core_path_wine_to_w32 ARG
1506	>	# Helper function used by path conversion functions when $build is *nix, and
1507	>	# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508	>	# configured wine environment available, with the winepath program in $build's
1509	>	# $PATH. Assumes ARG has no leading or trailing path separator characters.
1510	>	#
1511	>	# ARG is path to be converted from $build format to win32.
1512	>	# Result is available in $func_convert_core_path_wine_to_w32_result.
1513	>	# Unconvertible file (directory) names in ARG are skipped; if no directory names
1514	>	# are convertible, then the result may be empty.
1515	>	func_convert_core_path_wine_to_w32 ()
1516	>	{
1517	>	$opt_debug
1518	>	# unfortunately, winepath doesn't convert paths, only file names
1519	>	func_convert_core_path_wine_to_w32_result=""
1520	>	if test -n "$1"; then
1521	>	oldIFS=$IFS
1522	>	IFS=:
1523	>	for func_convert_core_path_wine_to_w32_f in $1; do
1524	>	IFS=$oldIFS
1525	>	func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1526	>	if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527	>	if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528	>	func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529	>	else
1530	>	func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1531	>	fi
1532		fi
322	–	case $arg in
323	–	-arch) doarch=y;;
324	–	esac
1533		done
1534	+	IFS=$oldIFS
1535	+	fi
1536	+	}
1537	+	# end: func_convert_core_path_wine_to_w32
1538	+
1539	+
1540	+	# func_cygpath ARGS...
1541	+	# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542	+	# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543	+	# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544	+	# (2), returns the Cygwin file name or path in func_cygpath_result (input
1545	+	# file name or path is assumed to be in w32 format, as previously converted
1546	+	# from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547	+	# or path in func_cygpath_result (input file name or path is assumed to be in
1548	+	# Cygwin format). Returns an empty string on error.
1549	+	#
1550	+	# ARGS are passed to cygpath, with the last one being the file name or path to
1551	+	# be converted.
1552	+	#
1553	+	# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554	+	# environment variable; do not put it in $PATH.
1555	+	func_cygpath ()
1556	+	{
1557	+	$opt_debug
1558	+	if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559	+	func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1560	+	if test "$?" -ne 0; then
1561	+	# on failure, ensure result is empty
1562	+	func_cygpath_result=
1563	+	fi
1564	+	else
1565	+	func_cygpath_result=
1566	+	func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1567	+	fi
1568	+	}
1569	+	#end: func_cygpath
1570	+
1571	+
1572	+	# func_convert_core_msys_to_w32 ARG
1573	+	# Convert file name or path ARG from MSYS format to w32 format.  Return
1574	+	# result in func_convert_core_msys_to_w32_result.
1575	+	func_convert_core_msys_to_w32 ()
1576	+	{
1577	+	$opt_debug
1578	+	# awkward: cmd appends spaces to result
1579	+	func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1580	+	$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581	+	}
1582	+	#end: func_convert_core_msys_to_w32
1583	+
1584	+
1585	+	# func_convert_file_check ARG1 ARG2
1586	+	# Verify that ARG1 (a file name in $build format) was converted to $host
1587	+	# format in ARG2. Otherwise, emit an error message, but continue (resetting
1588	+	# func_to_host_file_result to ARG1).
1589	+	func_convert_file_check ()
1590	+	{
1591	+	$opt_debug
1592	+	if test -z "$2" && test -n "$1" ; then
1593	+	func_error "Could not determine host file name corresponding to"
1594	+	func_error "  \`$1'"
1595	+	func_error "Continuing, but uninstalled executables may not work."
1596	+	# Fallback:
1597	+	func_to_host_file_result="$1"
1598	+	fi
1599	+	}
1600	+	# end func_convert_file_check
1601	+
1602	+
1603	+	# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604	+	# Verify that FROM_PATH (a path in $build format) was converted to $host
1605	+	# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606	+	# func_to_host_file_result to a simplistic fallback value (see below).
1607	+	func_convert_path_check ()
1608	+	{
1609	+	$opt_debug
1610	+	if test -z "$4" && test -n "$3"; then
1611	+	func_error "Could not determine the host path corresponding to"
1612	+	func_error "  \`$3'"
1613	+	func_error "Continuing, but uninstalled executables may not work."
1614	+	# Fallback.  This is a deliberately simplistic "conversion" and
1615	+	# should not be "improved".  See libtool.info.
1616	+	if test "x$1" != "x$2"; then
1617	+	lt_replace_pathsep_chars="s|$1|$2|g"
1618	+	func_to_host_path_result=`echo "$3" |
1619	+	$SED -e "$lt_replace_pathsep_chars"`
1620	+	else
1621	+	func_to_host_path_result="$3"
1622	+	fi
1623	+	fi
1624	+	}
1625	+	# end func_convert_path_check
1626	+
1627	+
1628	+	# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629	+	# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630	+	# and appending REPL if ORIG matches BACKPAT.
1631	+	func_convert_path_front_back_pathsep ()
1632	+	{
1633	+	$opt_debug
1634	+	case $4 in
1635	+	$1 ) func_to_host_path_result="$3$func_to_host_path_result"
1636	+	;;
1637		esac
1638	+	case $4 in
1639	+	$2 ) func_append func_to_host_path_result "$3"
1640	+	;;
1641	+	esac
1642	+	}
1643	+	# end func_convert_path_front_back_pathsep
1644
1645	<	# Infer the operation mode.
1646	<	if test -z "$mode"; then
1647	<	$echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
1648	<	$echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
1649	<	case $nonopt in
1650	<	*cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
1651	<	mode=link
1652	<	for arg
1653	<	do
1654	<	case $arg in
1655	<	-c)
1656	<	mode=compile
1657	<	break
1658	<	;;
1659	<	esac
1660	<	done
1661	<	;;
1662	<	*db | *dbx | *strace | *truss)
1663	<	mode=execute
1664	<	;;
1665	<	*install*|cp|mv)
1666	<	mode=install
1667	<	;;
1668	<	*rm)
1669	<	mode=uninstall
1645	>
1646	>	##################################################
1647	>	# $build to $host FILE NAME CONVERSION FUNCTIONS #
1648	>	##################################################
1649	>	# invoked via `$to_host_file_cmd ARG'
1650	>	#
1651	>	# In each case, ARG is the path to be converted from $build to $host format.
1652	>	# Result will be available in $func_to_host_file_result.
1653	>
1654	>
1655	>	# func_to_host_file ARG
1656	>	# Converts the file name ARG from $build format to $host format. Return result
1657	>	# in func_to_host_file_result.
1658	>	func_to_host_file ()
1659	>	{
1660	>	$opt_debug
1661	>	$to_host_file_cmd "$1"
1662	>	}
1663	>	# end func_to_host_file
1664	>
1665	>
1666	>	# func_to_tool_file ARG LAZY
1667	>	# converts the file name ARG from $build format to toolchain format. Return
1668	>	# result in func_to_tool_file_result.  If the conversion in use is listed
1669	>	# in (the comma separated) LAZY, no conversion takes place.
1670	>	func_to_tool_file ()
1671	>	{
1672	>	$opt_debug
1673	>	case ,$2, in
1674	>	*,"$to_tool_file_cmd",*)
1675	>	func_to_tool_file_result=$1
1676		;;
1677		*)
1678	<	# If we have no mode, but dlfiles were specified, then do execute mode.
1679	<	test -n "$execute_dlfiles" && mode=execute
357	<
358	<	# Just use the default operation mode.
359	<	if test -z "$mode"; then
360	<	if test -n "$nonopt"; then
361	<	$echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
362	<	else
363	<	$echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
364	<	fi
365	<	fi
1678	>	$to_tool_file_cmd "$1"
1679	>	func_to_tool_file_result=$func_to_host_file_result
1680		;;
1681	<	esac
1681	>	esac
1682	>	}
1683	>	# end func_to_tool_file
1684	>
1685	>
1686	>	# func_convert_file_noop ARG
1687	>	# Copy ARG to func_to_host_file_result.
1688	>	func_convert_file_noop ()
1689	>	{
1690	>	func_to_host_file_result="$1"
1691	>	}
1692	>	# end func_convert_file_noop
1693	>
1694	>
1695	>	# func_convert_file_msys_to_w32 ARG
1696	>	# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697	>	# conversion to w32 is not available inside the cwrapper.  Returns result in
1698	>	# func_to_host_file_result.
1699	>	func_convert_file_msys_to_w32 ()
1700	>	{
1701	>	$opt_debug
1702	>	func_to_host_file_result="$1"
1703	>	if test -n "$1"; then
1704	>	func_convert_core_msys_to_w32 "$1"
1705	>	func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706		fi
1707	+	func_convert_file_check "$1" "$func_to_host_file_result"
1708	+	}
1709	+	# end func_convert_file_msys_to_w32
1710
1711	<	# Only execute mode is allowed to have -dlopen flags.
1712	<	if test -n "$execute_dlfiles" && test "$mode" != execute; then
1713	<	$echo "$modename: unrecognized option \`-dlopen'" 1>&2
1714	<	$echo "$help" 1>&2
1715	<	exit 1
1711	>
1712	>	# func_convert_file_cygwin_to_w32 ARG
1713	>	# Convert file name ARG from Cygwin to w32 format.  Returns result in
1714	>	# func_to_host_file_result.
1715	>	func_convert_file_cygwin_to_w32 ()
1716	>	{
1717	>	$opt_debug
1718	>	func_to_host_file_result="$1"
1719	>	if test -n "$1"; then
1720	>	# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721	>	# LT_CYGPATH in this case.
1722	>	func_to_host_file_result=`cygpath -m "$1"`
1723	>	fi
1724	>	func_convert_file_check "$1" "$func_to_host_file_result"
1725	>	}
1726	>	# end func_convert_file_cygwin_to_w32
1727	>
1728	>
1729	>	# func_convert_file_nix_to_w32 ARG
1730	>	# Convert file name ARG from *nix to w32 format.  Requires a wine environment
1731	>	# and a working winepath. Returns result in func_to_host_file_result.
1732	>	func_convert_file_nix_to_w32 ()
1733	>	{
1734	>	$opt_debug
1735	>	func_to_host_file_result="$1"
1736	>	if test -n "$1"; then
1737	>	func_convert_core_file_wine_to_w32 "$1"
1738	>	func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739	>	fi
1740	>	func_convert_file_check "$1" "$func_to_host_file_result"
1741	>	}
1742	>	# end func_convert_file_nix_to_w32
1743	>
1744	>
1745	>	# func_convert_file_msys_to_cygwin ARG
1746	>	# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
1747	>	# Returns result in func_to_host_file_result.
1748	>	func_convert_file_msys_to_cygwin ()
1749	>	{
1750	>	$opt_debug
1751	>	func_to_host_file_result="$1"
1752	>	if test -n "$1"; then
1753	>	func_convert_core_msys_to_w32 "$1"
1754	>	func_cygpath -u "$func_convert_core_msys_to_w32_result"
1755	>	func_to_host_file_result="$func_cygpath_result"
1756	>	fi
1757	>	func_convert_file_check "$1" "$func_to_host_file_result"
1758	>	}
1759	>	# end func_convert_file_msys_to_cygwin
1760	>
1761	>
1762	>	# func_convert_file_nix_to_cygwin ARG
1763	>	# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
1764	>	# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
1765	>	# in func_to_host_file_result.
1766	>	func_convert_file_nix_to_cygwin ()
1767	>	{
1768	>	$opt_debug
1769	>	func_to_host_file_result="$1"
1770	>	if test -n "$1"; then
1771	>	# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772	>	func_convert_core_file_wine_to_w32 "$1"
1773	>	func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1774	>	func_to_host_file_result="$func_cygpath_result"
1775	>	fi
1776	>	func_convert_file_check "$1" "$func_to_host_file_result"
1777	>	}
1778	>	# end func_convert_file_nix_to_cygwin
1779	>
1780	>
1781	>	#############################################
1782	>	# $build to $host PATH CONVERSION FUNCTIONS #
1783	>	#############################################
1784	>	# invoked via `$to_host_path_cmd ARG'
1785	>	#
1786	>	# In each case, ARG is the path to be converted from $build to $host format.
1787	>	# The result will be available in $func_to_host_path_result.
1788	>	#
1789	>	# Path separators are also converted from $build format to $host format.  If
1790	>	# ARG begins or ends with a path separator character, it is preserved (but
1791	>	# converted to $host format) on output.
1792	>	#
1793	>	# All path conversion functions are named using the following convention:
1794	>	#   file name conversion function    : func_convert_file_X_to_Y ()
1795	>	#   path conversion function         : func_convert_path_X_to_Y ()
1796	>	# where, for any given $build/$host combination the 'X_to_Y' value is the
1797	>	# same.  If conversion functions are added for new $build/$host combinations,
1798	>	# the two new functions must follow this pattern, or func_init_to_host_path_cmd
1799	>	# will break.
1800	>
1801	>
1802	>	# func_init_to_host_path_cmd
1803	>	# Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804	>	# appropriate value, based on the value of $to_host_file_cmd.
1805	>	to_host_path_cmd=
1806	>	func_init_to_host_path_cmd ()
1807	>	{
1808	>	$opt_debug
1809	>	if test -z "$to_host_path_cmd"; then
1810	>	func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1811	>	to_host_path_cmd="func_convert_path_${func_stripname_result}"
1812	>	fi
1813	>	}
1814	>
1815	>
1816	>	# func_to_host_path ARG
1817	>	# Converts the path ARG from $build format to $host format. Return result
1818	>	# in func_to_host_path_result.
1819	>	func_to_host_path ()
1820	>	{
1821	>	$opt_debug
1822	>	func_init_to_host_path_cmd
1823	>	$to_host_path_cmd "$1"
1824	>	}
1825	>	# end func_to_host_path
1826	>
1827	>
1828	>	# func_convert_path_noop ARG
1829	>	# Copy ARG to func_to_host_path_result.
1830	>	func_convert_path_noop ()
1831	>	{
1832	>	func_to_host_path_result="$1"
1833	>	}
1834	>	# end func_convert_path_noop
1835	>
1836	>
1837	>	# func_convert_path_msys_to_w32 ARG
1838	>	# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839	>	# conversion to w32 is not available inside the cwrapper.  Returns result in
1840	>	# func_to_host_path_result.
1841	>	func_convert_path_msys_to_w32 ()
1842	>	{
1843	>	$opt_debug
1844	>	func_to_host_path_result="$1"
1845	>	if test -n "$1"; then
1846	>	# Remove leading and trailing path separator characters from ARG.  MSYS
1847	>	# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848	>	# and winepath ignores them completely.
1849	>	func_stripname : : "$1"
1850	>	func_to_host_path_tmp1=$func_stripname_result
1851	>	func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1852	>	func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1853	>	func_convert_path_check : ";" \
1854	>	"$func_to_host_path_tmp1" "$func_to_host_path_result"
1855	>	func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1856	>	fi
1857	>	}
1858	>	# end func_convert_path_msys_to_w32
1859	>
1860	>
1861	>	# func_convert_path_cygwin_to_w32 ARG
1862	>	# Convert path ARG from Cygwin to w32 format.  Returns result in
1863	>	# func_to_host_file_result.
1864	>	func_convert_path_cygwin_to_w32 ()
1865	>	{
1866	>	$opt_debug
1867	>	func_to_host_path_result="$1"
1868	>	if test -n "$1"; then
1869	>	# See func_convert_path_msys_to_w32:
1870	>	func_stripname : : "$1"
1871	>	func_to_host_path_tmp1=$func_stripname_result
1872	>	func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1873	>	func_convert_path_check : ";" \
1874	>	"$func_to_host_path_tmp1" "$func_to_host_path_result"
1875	>	func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1876	>	fi
1877	>	}
1878	>	# end func_convert_path_cygwin_to_w32
1879	>
1880	>
1881	>	# func_convert_path_nix_to_w32 ARG
1882	>	# Convert path ARG from *nix to w32 format.  Requires a wine environment and
1883	>	# a working winepath.  Returns result in func_to_host_file_result.
1884	>	func_convert_path_nix_to_w32 ()
1885	>	{
1886	>	$opt_debug
1887	>	func_to_host_path_result="$1"
1888	>	if test -n "$1"; then
1889	>	# See func_convert_path_msys_to_w32:
1890	>	func_stripname : : "$1"
1891	>	func_to_host_path_tmp1=$func_stripname_result
1892	>	func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1893	>	func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1894	>	func_convert_path_check : ";" \
1895	>	"$func_to_host_path_tmp1" "$func_to_host_path_result"
1896	>	func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1897	>	fi
1898	>	}
1899	>	# end func_convert_path_nix_to_w32
1900	>
1901	>
1902	>	# func_convert_path_msys_to_cygwin ARG
1903	>	# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
1904	>	# Returns result in func_to_host_file_result.
1905	>	func_convert_path_msys_to_cygwin ()
1906	>	{
1907	>	$opt_debug
1908	>	func_to_host_path_result="$1"
1909	>	if test -n "$1"; then
1910	>	# See func_convert_path_msys_to_w32:
1911	>	func_stripname : : "$1"
1912	>	func_to_host_path_tmp1=$func_stripname_result
1913	>	func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1914	>	func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1915	>	func_to_host_path_result="$func_cygpath_result"
1916	>	func_convert_path_check : : \
1917	>	"$func_to_host_path_tmp1" "$func_to_host_path_result"
1918	>	func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1919	>	fi
1920	>	}
1921	>	# end func_convert_path_msys_to_cygwin
1922	>
1923	>
1924	>	# func_convert_path_nix_to_cygwin ARG
1925	>	# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
1926	>	# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
1927	>	# func_to_host_file_result.
1928	>	func_convert_path_nix_to_cygwin ()
1929	>	{
1930	>	$opt_debug
1931	>	func_to_host_path_result="$1"
1932	>	if test -n "$1"; then
1933	>	# Remove leading and trailing path separator characters from
1934	>	# ARG. msys behavior is inconsistent here, cygpath turns them
1935	>	# into '.;' and ';.', and winepath ignores them completely.
1936	>	func_stripname : : "$1"
1937	>	func_to_host_path_tmp1=$func_stripname_result
1938	>	func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1939	>	func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1940	>	func_to_host_path_result="$func_cygpath_result"
1941	>	func_convert_path_check : : \
1942	>	"$func_to_host_path_tmp1" "$func_to_host_path_result"
1943	>	func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1944		fi
1945	+	}
1946	+	# end func_convert_path_nix_to_cygwin
1947	+
1948
1949	<	# Change the help message to a mode-specific one.
1950	<	generic_help="$help"
1951	<	help="Try \`$modename --help --mode=$mode' for more information."
1952	<
381	<	# These modes are in order of execution frequency so that they run quickly.
382	<	case $mode in
383	<	# libtool compile mode
384	<	compile)
385	<	modename="$modename: compile"
1949	>	# func_mode_compile arg...
1950	>	func_mode_compile ()
1951	>	{
1952	>	$opt_debug
1953		# Get the compilation command and the source file.
1954		base_compile=
1955		srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1956	+	suppress_opt=yes
1957		suppress_output=
1958		arg_mode=normal
1959		libobj=
1960	+	later=
1961	+	pie_flag=
1962
1963		for arg
1964		do
1965	<	case "$arg_mode" in
1965	>	case $arg_mode in
1966		arg  )
1967		# do not "continue".  Instead, add this to base_compile
1968		lastarg="$arg"
#	Line 409 | Line 1979 | if test -z "$show_help"; then
1979		# Accept any command-line options.
1980		case $arg in
1981		-o)
1982	<	if test -n "$libobj" ; then
1983	<	$echo "$modename: you cannot specify \`-o' more than once" 1>&2
414	<	exit 1
415	<	fi
1982	>	test -n "$libobj" && \
1983	>	func_fatal_error "you cannot specify \`-o' more than once"
1984		arg_mode=target
1985		continue
1986		;;
1987
1988	<	-static)
1989	<	build_old_libs=yes
1988	>	-pie | -fpie | -fPIE)
1989	>	func_append pie_flag " $arg"
1990		continue
1991		;;
1992
1993	<	-prefer-pic)
1994	<	pic_mode=yes
1993	>	-shared | -static | -prefer-pic | -prefer-non-pic)
1994	>	func_append later " $arg"
1995		continue
1996		;;
1997
1998	<	-prefer-non-pic)
1999	<	pic_mode=no
1998	>	-no-suppress)
1999	>	suppress_opt=no
2000		continue
2001		;;
2002
#	Line 438 | Line 2006 | if test -z "$show_help"; then
2006		;;            #  replaced later.  I would guess that would be a bug.
2007
2008		-Wc,*)
2009	<	args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
2009	>	func_stripname '-Wc,' '' "$arg"
2010	>	args=$func_stripname_result
2011		lastarg=
2012		save_ifs="$IFS"; IFS=','
2013		for arg in $args; do
2014		IFS="$save_ifs"
2015	<
447	<	# Double-quote args containing other shell metacharacters.
448	<	# Many Bourne shells cannot handle close brackets correctly
449	<	# in scan sets, so we specify it separately.
450	<	case $arg in
451	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
452	<	arg="\"$arg\""
453	<	;;
454	<	esac
455	<	lastarg="$lastarg $arg"
2015	>	func_append_quoted lastarg "$arg"
2016		done
2017		IFS="$save_ifs"
2018	<	lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
2018	>	func_stripname ' ' '' "$lastarg"
2019	>	lastarg=$func_stripname_result
2020
2021		# Add the arguments to base_compile.
2022	<	base_compile="$base_compile $lastarg"
2022	>	func_append base_compile " $lastarg"
2023		continue
2024		;;
2025
2026	<	* )
2026	>	*)
2027		# Accept the current argument as the source file.
2028		# The previous "srcfile" becomes the current argument.
2029		#
#	Line 474 | Line 2035 | if test -z "$show_help"; then
2035		esac    #  case $arg_mode
2036
2037		# Aesthetically quote the previous argument.
2038	<	lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
478	<
479	<	case $lastarg in
480	<	# Double-quote args containing other shell metacharacters.
481	<	# Many Bourne shells cannot handle close brackets correctly
482	<	# in scan sets, so we specify it separately.
483	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
484	<	lastarg="\"$lastarg\""
485	<	;;
486	<	esac
487	<
488	<	base_compile="$base_compile $lastarg"
2038	>	func_append_quoted base_compile "$lastarg"
2039		done # for arg
2040
2041		case $arg_mode in
2042		arg)
2043	<	$echo "$modename: you must specify an argument for -Xcompile"
494	<	exit 1
2043	>	func_fatal_error "you must specify an argument for -Xcompile"
2044		;;
2045		target)
2046	<	$echo "$modename: you must specify a target with \`-o'" 1>&2
498	<	exit 1
2046	>	func_fatal_error "you must specify a target with \`-o'"
2047		;;
2048		*)
2049		# Get the name of the library object.
2050	<	[ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
2050	>	test -z "$libobj" && {
2051	>	func_basename "$srcfile"
2052	>	libobj="$func_basename_result"
2053	>	}
2054		;;
2055		esac
2056
2057		# Recognize several different file suffixes.
2058		# If the user specifies -o file.o, it is replaced with file.lo
508	–	xform='[cCFSifmso]'
2059		case $libobj in
2060	<	*.ada) xform=ada ;;
2061	<	*.adb) xform=adb ;;
2062	<	*.ads) xform=ads ;;
2063	<	*.asm) xform=asm ;;
2064	<	*.c++) xform=c++ ;;
2065	<	*.cc) xform=cc ;;
2066	<	*.ii) xform=ii ;;
517	<	*.class) xform=class ;;
518	<	*.cpp) xform=cpp ;;
519	<	*.cxx) xform=cxx ;;
520	<	*.f90) xform=f90 ;;
521	<	*.for) xform=for ;;
522	<	*.java) xform=java ;;
2060	>	*.[cCFSifmso] | \
2061	>	*.ada | *.adb | *.ads | *.asm | \
2062	>	*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2063	>	*.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
2064	>	func_xform "$libobj"
2065	>	libobj=$func_xform_result
2066	>	;;
2067		esac
2068
525	–	libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
526	–
2069		case $libobj in
2070	<	*.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
2070	>	*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071		*)
2072	<	$echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
531	<	exit 1
2072	>	func_fatal_error "cannot determine name of library object from \`$libobj'"
2073		;;
2074		esac
2075
2076	<	# Infer tagged configuration to use if any are available and
2077	<	# if one wasn't chosen via the "--tag" command line option.
2078	<	# Only attempt this if the compiler in the base compile
2079	<	# command doesn't match the default compiler.
2080	<	if test -n "$available_tags" && test -z "$tagname"; then
2081	<	case $base_compile in
2082	<	# Blanks in the command may have been stripped by the calling shell,
2083	<	# but not from the CC environment variable when configure was run.
2084	<	" $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "*) ;;
2085	<	# Blanks at the start of $base_compile will cause this to fail
2086	<	# if we don't check for them as well.
2087	<	*)
2088	<	for z in $available_tags; do
2089	<	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
2090	<	# Evaluate the configuration.
2091	<	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
2092	<	case "$base_compile " in
2093	<	"$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
2094	<	# The compiler in the base compile command matches
2095	<	# the one in the tagged configuration.
2096	<	# Assume this is the tagged configuration we want.
2097	<	tagname=$z
2098	<	break
2099	<	;;
2100	<	esac
560	<	fi
561	<	done
562	<	# If $tagname still isn't set, then no tagged configuration
563	<	# was found and let the user know that the "--tag" command
564	<	# line option must be used.
565	<	if test -z "$tagname"; then
566	<	$echo "$modename: unable to infer tagged configuration"
567	<	$echo "$modename: specify a tag with \`--tag'" 1>&2
568	<	exit 1
569	<	#        else
570	<	#          $echo "$modename: using $tagname tagged configuration"
571	<	fi
2076	>	func_infer_tag $base_compile
2077	>
2078	>	for arg in $later; do
2079	>	case $arg in
2080	>	-shared)
2081	>	test "$build_libtool_libs" != yes && \
2082	>	func_fatal_configuration "can not build a shared library"
2083	>	build_old_libs=no
2084	>	continue
2085	>	;;
2086	>
2087	>	-static)
2088	>	build_libtool_libs=no
2089	>	build_old_libs=yes
2090	>	continue
2091	>	;;
2092	>
2093	>	-prefer-pic)
2094	>	pic_mode=yes
2095	>	continue
2096	>	;;
2097	>
2098	>	-prefer-non-pic)
2099	>	pic_mode=no
2100	>	continue
2101		;;
2102		esac
2103	<	fi
2103	>	done
2104
2105	<	objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
2106	<	xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
2107	<	if test "X$xdir" = "X$obj"; then
2108	<	xdir=
2109	<	else
2110	<	xdir=$xdir/
2111	<	fi
2105	>	func_quote_for_eval "$libobj"
2106	>	test "X$libobj" != "X$func_quote_for_eval_result" \
2107	>	&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
2108	>	&& func_warning "libobj name \`$libobj' may not contain shell special characters."
2109	>	func_dirname_and_basename "$obj" "/" ""
2110	>	objname="$func_basename_result"
2111	>	xdir="$func_dirname_result"
2112		lobj=${xdir}$objdir/$objname
2113
2114	<	if test -z "$base_compile"; then
2115	<	$echo "$modename: you must specify a compilation command" 1>&2
587	<	$echo "$help" 1>&2
588	<	exit 1
589	<	fi
2114	>	test -z "$base_compile" && \
2115	>	func_fatal_help "you must specify a compilation command"
2116
2117		# Delete any leftover library objects.
2118		if test "$build_old_libs" = yes; then
#	Line 595 | Line 2121 | if test -z "$show_help"; then
2121		removelist="$lobj $libobj ${libobj}T"
2122		fi
2123
598	–	$run $rm $removelist
599	–	trap "$run $rm $removelist; exit 1" 1 2 15
600	–
2124		# On Cygwin there's no "real" PIC flag so we must build both object types
2125		case $host_os in
2126	<	cygwin* | mingw* | pw32* | os2*)
2126	>	cygwin* | mingw* | pw32* | os2* | cegcc*)
2127		pic_mode=default
2128		;;
2129		esac
#	Line 612 | Line 2135 | if test -z "$show_help"; then
2135		# Calculate the filename of the output object if compiler does
2136		# not support -o with -c
2137		if test "$compiler_c_o" = no; then
2138	<	output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
2138	>	output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2139		lockfile="$output_obj.lock"
617	–	removelist="$removelist $output_obj $lockfile"
618	–	trap "$run $rm $removelist; exit 1" 1 2 15
2140		else
2141		output_obj=
2142		need_locks=no
#	Line 625 | Line 2146 | if test -z "$show_help"; then
2146		# Lock this critical section if it is needed
2147		# We use this script file to make the link, it avoids creating a new file
2148		if test "$need_locks" = yes; then
2149	<	until $run ln "$0" "$lockfile" 2>/dev/null; do
2150	<	$show "Waiting for $lockfile to be removed"
2149	>	until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2150	>	func_echo "Waiting for $lockfile to be removed"
2151		sleep 2
2152		done
2153		elif test "$need_locks" = warn; then
2154		if test -f "$lockfile"; then
2155	<	$echo "\
2155	>	$ECHO "\
2156		*** ERROR, $lockfile exists and contains:
2157		`cat $lockfile 2>/dev/null`
2158
#	Line 642 | Line 2163 | repeat this compilation, it may succeed,
2163		avoid parallel builds (make -j) in this platform, or get a better
2164		compiler."
2165
2166	<	$run $rm $removelist
2167	<	exit 1
2166	>	$opt_dry_run || $RM $removelist
2167	>	exit $EXIT_FAILURE
2168		fi
2169	<	$echo $srcfile > "$lockfile"
2170	<	fi
650	<
651	<	if test -n "$fix_srcfile_path"; then
652	<	eval srcfile=\"$fix_srcfile_path\"
2169	>	func_append removelist " $output_obj"
2170	>	$ECHO "$srcfile" > "$lockfile"
2171		fi
2172
2173	<	$run $rm "$libobj" "${libobj}T"
2174	<
2175	<	# Create a libtool object file (analogous to a ".la" file),
658	<	# but don't create it if we're doing a dry run.
659	<	test -z "$run" && cat > ${libobj}T <<EOF
660	<	# $libobj - a libtool object file
661	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
662	<	#
663	<	# Please DO NOT delete this file!
664	<	# It is necessary for linking the library.
2173	>	$opt_dry_run || $RM $removelist
2174	>	func_append removelist " $lockfile"
2175	>	trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176
2177	<	# Name of the PIC object.
2178	<	EOF
2177	>	func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178	>	srcfile=$func_to_tool_file_result
2179	>	func_quote_for_eval "$srcfile"
2180	>	qsrcfile=$func_quote_for_eval_result
2181
2182		# Only build a PIC object if we are building libtool libraries.
2183		if test "$build_libtool_libs" = yes; then
#	Line 672 | Line 2185 | EOF
2185		fbsd_hideous_sh_bug=$base_compile
2186
2187		if test "$pic_mode" != no; then
2188	<	command="$base_compile $srcfile $pic_flag"
2188	>	command="$base_compile $qsrcfile $pic_flag"
2189		else
2190		# Don't build PIC code
2191	<	command="$base_compile $srcfile"
2191	>	command="$base_compile $qsrcfile"
2192		fi
2193
2194	<	if test ! -d "${xdir}$objdir"; then
682	<	$show "$mkdir ${xdir}$objdir"
683	<	$run $mkdir ${xdir}$objdir
684	<	status=$?
685	<	if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
686	<	exit $status
687	<	fi
688	<	fi
2194	>	func_mkdir_p "$xdir$objdir"
2195
2196		if test -z "$output_obj"; then
2197		# Place PIC objects in $objdir
2198	<	command="$command -o $lobj"
2198	>	func_append command " -o $lobj"
2199		fi
2200
2201	<	$run $rm "$lobj" "$output_obj"
2202	<
697	<	$show "$command"
698	<	if $run eval "$command"; then :
699	<	else
700	<	test -n "$output_obj" && $run $rm $removelist
701	<	exit 1
702	<	fi
2201	>	func_show_eval_locale "$command"  \
2202	>	'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203
2204		if test "$need_locks" = warn &&
2205		test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206	<	$echo "\
2206	>	$ECHO "\
2207		*** ERROR, $lockfile contains:
2208		`cat $lockfile 2>/dev/null`
2209
#	Line 717 | Line 2217 | repeat this compilation, it may succeed,
2217		avoid parallel builds (make -j) in this platform, or get a better
2218		compiler."
2219
2220	<	$run $rm $removelist
2221	<	exit 1
2220	>	$opt_dry_run || $RM $removelist
2221	>	exit $EXIT_FAILURE
2222		fi
2223
2224		# Just move the object if needed, then go on to compile the next one
2225		if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226	<	$show "$mv $output_obj $lobj"
2227	<	if $run $mv $output_obj $lobj; then :
728	<	else
729	<	error=$?
730	<	$run $rm $removelist
731	<	exit $error
732	<	fi
2226	>	func_show_eval '$MV "$output_obj" "$lobj"' \
2227	>	'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2228		fi
2229
735	–	# Append the name of the PIC object to the libtool object file.
736	–	test -z "$run" && cat >> ${libobj}T <<EOF
737	–	pic_object='$objdir/$objname'
738	–
739	–	EOF
740	–
2230		# Allow error messages only from the first compilation.
2231	<	suppress_output=' >/dev/null 2>&1'
2232	<	else
2233	<	# No PIC object so indicate it doesn't exist in the libtool
745	<	# object file.
746	<	test -z "$run" && cat >> ${libobj}T <<EOF
747	<	pic_object=none
748	<
749	<	EOF
2231	>	if test "$suppress_opt" = yes; then
2232	>	suppress_output=' >/dev/null 2>&1'
2233	>	fi
2234		fi
2235
2236		# Only build a position-dependent object if we build old libraries.
2237		if test "$build_old_libs" = yes; then
2238		if test "$pic_mode" != yes; then
2239		# Don't build PIC code
2240	<	command="$base_compile $srcfile"
2240	>	command="$base_compile $qsrcfile$pie_flag"
2241		else
2242	<	command="$base_compile $srcfile $pic_flag"
2242	>	command="$base_compile $qsrcfile $pic_flag"
2243		fi
2244		if test "$compiler_c_o" = yes; then
2245	<	command="$command -o $obj"
2245	>	func_append command " -o $obj"
2246		fi
2247
2248		# Suppress compiler output if we already did a PIC compilation.
2249	<	command="$command$suppress_output"
2250	<	$run $rm "$obj" "$output_obj"
2251	<	$show "$command"
768	<	if $run eval "$command"; then :
769	<	else
770	<	$run $rm $removelist
771	<	exit 1
772	<	fi
2249	>	func_append command "$suppress_output"
2250	>	func_show_eval_locale "$command" \
2251	>	'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252
2253		if test "$need_locks" = warn &&
2254		test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255	<	$echo "\
2255	>	$ECHO "\
2256		*** ERROR, $lockfile contains:
2257		`cat $lockfile 2>/dev/null`
2258
#	Line 787 | Line 2266 | repeat this compilation, it may succeed,
2266		avoid parallel builds (make -j) in this platform, or get a better
2267		compiler."
2268
2269	<	$run $rm $removelist
2270	<	exit 1
2269	>	$opt_dry_run || $RM $removelist
2270	>	exit $EXIT_FAILURE
2271		fi
2272
2273		# Just move the object if needed
2274		if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275	<	$show "$mv $output_obj $obj"
2276	<	if $run $mv $output_obj $obj; then :
2275	>	func_show_eval '$MV "$output_obj" "$obj"' \
2276	>	'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2277	>	fi
2278	>	fi
2279	>
2280	>	$opt_dry_run || {
2281	>	func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282	>
2283	>	# Unlock the critical section if it was locked
2284	>	if test "$need_locks" != no; then
2285	>	removelist=$lockfile
2286	>	$RM "$lockfile"
2287	>	fi
2288	>	}
2289	>
2290	>	exit $EXIT_SUCCESS
2291	>	}
2292	>
2293	>	$opt_help || {
2294	>	test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2295	>	}
2296	>
2297	>	func_mode_help ()
2298	>	{
2299	>	# We need to display help for each of the modes.
2300	>	case $opt_mode in
2301	>	"")
2302	>	# Generic help is extracted from the usage comments
2303	>	# at the start of this file.
2304	>	func_help
2305	>	;;
2306	>
2307	>	clean)
2308	>	$ECHO \
2309	>	"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310	>
2311	>	Remove files from the build directory.
2312	>
2313	>	RM is the name of the program to use to delete files associated with each FILE
2314	>	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2315	>	to RM.
2316	>
2317	>	If FILE is a libtool library, object or program, all the files associated
2318	>	with it are deleted. Otherwise, only FILE itself is deleted using RM."
2319	>	;;
2320	>
2321	>	compile)
2322	>	$ECHO \
2323	>	"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324	>
2325	>	Compile a source file into a libtool library object.
2326	>
2327	>	This mode accepts the following additional options:
2328	>
2329	>	-o OUTPUT-FILE    set the output file name to OUTPUT-FILE
2330	>	-no-suppress      do not suppress compiler output for multiple passes
2331	>	-prefer-pic       try to build PIC objects only
2332	>	-prefer-non-pic   try to build non-PIC objects only
2333	>	-shared           do not build a \`.o' file suitable for static linking
2334	>	-static           only build a \`.o' file suitable for static linking
2335	>	-Wc,FLAG          pass FLAG directly to the compiler
2336	>
2337	>	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338	>	from the given SOURCEFILE.
2339	>
2340	>	The output file name is determined by removing the directory component from
2341	>	SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342	>	library object suffix, \`.lo'."
2343	>	;;
2344	>
2345	>	execute)
2346	>	$ECHO \
2347	>	"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348	>
2349	>	Automatically set library path, then run a program.
2350	>
2351	>	This mode accepts the following additional options:
2352	>
2353	>	-dlopen FILE      add the directory containing FILE to the library path
2354	>
2355	>	This mode sets the library path environment variable according to \`-dlopen'
2356	>	flags.
2357	>
2358	>	If any of the ARGS are libtool executable wrappers, then they are translated
2359	>	into their corresponding uninstalled binary, and any of their required library
2360	>	directories are added to the library path.
2361	>
2362	>	Then, COMMAND is executed, with ARGS as arguments."
2363	>	;;
2364	>
2365	>	finish)
2366	>	$ECHO \
2367	>	"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368	>
2369	>	Complete the installation of libtool libraries.
2370	>
2371	>	Each LIBDIR is a directory that contains libtool libraries.
2372	>
2373	>	The commands that this mode executes may require superuser privileges.  Use
2374	>	the \`--dry-run' option if you just want to see what would be executed."
2375	>	;;
2376	>
2377	>	install)
2378	>	$ECHO \
2379	>	"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380	>
2381	>	Install executables or libraries.
2382	>
2383	>	INSTALL-COMMAND is the installation command.  The first component should be
2384	>	either the \`install' or \`cp' program.
2385	>
2386	>	The following components of INSTALL-COMMAND are treated specially:
2387	>
2388	>	-inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2389	>
2390	>	The rest of the components are interpreted as arguments to that command (only
2391	>	BSD-compatible install options are recognized)."
2392	>	;;
2393	>
2394	>	link)
2395	>	$ECHO \
2396	>	"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397	>
2398	>	Link object files or libraries together to form another library, or to
2399	>	create an executable program.
2400	>
2401	>	LINK-COMMAND is a command using the C compiler that you would use to create
2402	>	a program from several object files.
2403	>
2404	>	The following components of LINK-COMMAND are treated specially:
2405	>
2406	>	-all-static       do not do any dynamic linking at all
2407	>	-avoid-version    do not add a version suffix if possible
2408	>	-bindir BINDIR    specify path to binaries directory (for systems where
2409	>	libraries must be found in the PATH setting at runtime)
2410	>	-dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411	>	-dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2412	>	-export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413	>	-export-symbols SYMFILE
2414	>	try to export only the symbols listed in SYMFILE
2415	>	-export-symbols-regex REGEX
2416	>	try to export only the symbols matching REGEX
2417	>	-LLIBDIR          search LIBDIR for required installed libraries
2418	>	-lNAME            OUTPUT-FILE requires the installed library libNAME
2419	>	-module           build a library that can dlopened
2420	>	-no-fast-install  disable the fast-install mode
2421	>	-no-install       link a not-installable executable
2422	>	-no-undefined     declare that a library does not refer to external symbols
2423	>	-o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2424	>	-objectlist FILE  Use a list of object files found in FILE to specify objects
2425	>	-precious-files-regex REGEX
2426	>	don't remove output files matching REGEX
2427	>	-release RELEASE  specify package release information
2428	>	-rpath LIBDIR     the created library will eventually be installed in LIBDIR
2429	>	-R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2430	>	-shared           only do dynamic linking of libtool libraries
2431	>	-shrext SUFFIX    override the standard shared library file extension
2432	>	-static           do not do any dynamic linking of uninstalled libtool libraries
2433	>	-static-libtool-libs
2434	>	do not do any dynamic linking of libtool libraries
2435	>	-version-info CURRENT[:REVISION[:AGE]]
2436	>	specify library version info [each variable defaults to 0]
2437	>	-weak LIBNAME     declare that the target provides the LIBNAME interface
2438	>	-Wc,FLAG
2439	>	-Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
2440	>	-Wl,FLAG
2441	>	-Xlinker FLAG     pass linker-specific FLAG directly to the linker
2442	>	-XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
2443	>
2444	>	All other options (arguments beginning with \`-') are ignored.
2445	>
2446	>	Every other argument is treated as a filename.  Files ending in \`.la' are
2447	>	treated as uninstalled libtool libraries, other files are standard or library
2448	>	object files.
2449	>
2450	>	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451	>	only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452	>	required, except when creating a convenience library.
2453	>
2454	>	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455	>	using \`ar' and \`ranlib', or on Windows using \`lib'.
2456	>
2457	>	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458	>	is created, otherwise an executable program is created."
2459	>	;;
2460	>
2461	>	uninstall)
2462	>	$ECHO \
2463	>	"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464	>
2465	>	Remove libraries from an installation directory.
2466	>
2467	>	RM is the name of the program to use to delete files associated with each FILE
2468	>	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2469	>	to RM.
2470	>
2471	>	If FILE is a libtool library, all the files associated with it are deleted.
2472	>	Otherwise, only FILE itself is deleted using RM."
2473	>	;;
2474	>
2475	>	*)
2476	>	func_fatal_help "invalid operation mode \`$opt_mode'"
2477	>	;;
2478	>	esac
2479	>
2480	>	echo
2481	>	$ECHO "Try \`$progname --help' for more information about other modes."
2482	>	}
2483	>
2484	>	# Now that we've collected a possible --mode arg, show help if necessary
2485	>	if $opt_help; then
2486	>	if test "$opt_help" = :; then
2487	>	func_mode_help
2488	>	else
2489	>	{
2490	>	func_help noexit
2491	>	for opt_mode in compile link execute install finish uninstall clean; do
2492	>	func_mode_help
2493	>	done
2494	>	} | sed -n '1p; 2,$s/^Usage:/  or: /p'
2495	>	{
2496	>	func_help noexit
2497	>	for opt_mode in compile link execute install finish uninstall clean; do
2498	>	echo
2499	>	func_mode_help
2500	>	done
2501	>	} |
2502	>	sed '1d
2503	>	/^When reporting/,/^Report/{
2504	>	H
2505	>	d
2506	>	}
2507	>	$x
2508	>	/information about other modes/d
2509	>	/more detailed .*MODE/d
2510	>	s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2511	>	fi
2512	>	exit $?
2513	>	fi
2514	>
2515	>
2516	>	# func_mode_execute arg...
2517	>	func_mode_execute ()
2518	>	{
2519	>	$opt_debug
2520	>	# The first argument is the command name.
2521	>	cmd="$nonopt"
2522	>	test -z "$cmd" && \
2523	>	func_fatal_help "you must specify a COMMAND"
2524	>
2525	>	# Handle -dlopen flags immediately.
2526	>	for file in $opt_dlopen; do
2527	>	test -f "$file" \
2528	>	|| func_fatal_help "\`$file' is not a file"
2529	>
2530	>	dir=
2531	>	case $file in
2532	>	*.la)
2533	>	func_resolve_sysroot "$file"
2534	>	file=$func_resolve_sysroot_result
2535	>
2536	>	# Check to see that this really is a libtool archive.
2537	>	func_lalib_unsafe_p "$file" \
2538	>	|| func_fatal_help "\`$lib' is not a valid libtool archive"
2539	>
2540	>	# Read the libtool library.
2541	>	dlname=
2542	>	library_names=
2543	>	func_source "$file"
2544	>
2545	>	# Skip this library if it cannot be dlopened.
2546	>	if test -z "$dlname"; then
2547	>	# Warn if it was a shared library.
2548	>	test -n "$library_names" && \
2549	>	func_warning "\`$file' was not linked with \`-export-dynamic'"
2550	>	continue
2551	>	fi
2552	>
2553	>	func_dirname "$file" "" "."
2554	>	dir="$func_dirname_result"
2555	>
2556	>	if test -f "$dir/$objdir/$dlname"; then
2557	>	func_append dir "/$objdir"
2558	>	else
2559	>	if test ! -f "$dir/$dlname"; then
2560	>	func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2561	>	fi
2562	>	fi
2563	>	;;
2564	>
2565	>	*.lo)
2566	>	# Just add the directory containing the .lo file.
2567	>	func_dirname "$file" "" "."
2568	>	dir="$func_dirname_result"
2569	>	;;
2570	>
2571	>	*)
2572	>	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2573	>	continue
2574	>	;;
2575	>	esac
2576	>
2577	>	# Get the absolute pathname.
2578	>	absdir=`cd "$dir" && pwd`
2579	>	test -n "$absdir" && dir="$absdir"
2580	>
2581	>	# Now add the directory to shlibpath_var.
2582	>	if eval "test -z \"\$$shlibpath_var\""; then
2583	>	eval "$shlibpath_var=\"\$dir\""
2584	>	else
2585	>	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2586	>	fi
2587	>	done
2588	>
2589	>	# This variable tells wrapper scripts just to set shlibpath_var
2590	>	# rather than running their programs.
2591	>	libtool_execute_magic="$magic"
2592	>
2593	>	# Check if any of the arguments is a wrapper script.
2594	>	args=
2595	>	for file
2596	>	do
2597	>	case $file in
2598	>	-* | *.la | *.lo ) ;;
2599	>	*)
2600	>	# Do a test to see if this is really a libtool program.
2601	>	if func_ltwrapper_script_p "$file"; then
2602	>	func_source "$file"
2603	>	# Transform arg to wrapped name.
2604	>	file="$progdir/$program"
2605	>	elif func_ltwrapper_executable_p "$file"; then
2606	>	func_ltwrapper_scriptname "$file"
2607	>	func_source "$func_ltwrapper_scriptname_result"
2608	>	# Transform arg to wrapped name.
2609	>	file="$progdir/$program"
2610	>	fi
2611	>	;;
2612	>	esac
2613	>	# Quote arguments (to preserve shell metacharacters).
2614	>	func_append_quoted args "$file"
2615	>	done
2616	>
2617	>	if test "X$opt_dry_run" = Xfalse; then
2618	>	if test -n "$shlibpath_var"; then
2619	>	# Export the shlibpath_var.
2620	>	eval "export $shlibpath_var"
2621	>	fi
2622	>
2623	>	# Restore saved environment variables
2624	>	for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625	>	do
2626	>	eval "if test \"\${save_$lt_var+set}\" = set; then
2627	>	$lt_var=\$save_$lt_var; export $lt_var
2628	>	else
2629	>	$lt_unset $lt_var
2630	>	fi"
2631	>	done
2632	>
2633	>	# Now prepare to actually exec the command.
2634	>	exec_cmd="\$cmd$args"
2635	>	else
2636	>	# Display what would be done.
2637	>	if test -n "$shlibpath_var"; then
2638	>	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639	>	echo "export $shlibpath_var"
2640	>	fi
2641	>	$ECHO "$cmd$args"
2642	>	exit $EXIT_SUCCESS
2643	>	fi
2644	>	}
2645	>
2646	>	test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2647	>
2648	>
2649	>	# func_mode_finish arg...
2650	>	func_mode_finish ()
2651	>	{
2652	>	$opt_debug
2653	>	libs=
2654	>	libdirs=
2655	>	admincmds=
2656	>
2657	>	for opt in "$nonopt" ${1+"$@"}
2658	>	do
2659	>	if test -d "$opt"; then
2660	>	func_append libdirs " $opt"
2661	>
2662	>	elif test -f "$opt"; then
2663	>	if func_lalib_unsafe_p "$opt"; then
2664	>	func_append libs " $opt"
2665		else
2666	<	error=$?
800	<	$run $rm $removelist
801	<	exit $error
2666	>	func_warning "\`$opt' is not a valid libtool archive"
2667		fi
2668	+
2669	+	else
2670	+	func_fatal_error "invalid argument \`$opt'"
2671		fi
2672	+	done
2673
2674	<	# Append the name of the non-PIC object the libtool object file.
2675	<	# Only append if the libtool object file exists.
2676	<	test -z "$run" && cat >> ${libobj}T <<EOF
2677	<	# Name of the non-PIC object.
2678	<	non_pic_object='$objname'
2674	>	if test -n "$libs"; then
2675	>	if test -n "$lt_sysroot"; then
2676	>	sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677	>	sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2678	>	else
2679	>	sysroot_cmd=
2680	>	fi
2681
2682	<	EOF
2682	>	# Remove sysroot references
2683	>	if $opt_dry_run; then
2684	>	for lib in $libs; do
2685	>	echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2686	>	done
2687	>	else
2688	>	tmpdir=`func_mktempdir`
2689	>	for lib in $libs; do
2690	>	sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691	>	> $tmpdir/tmp-la
2692	>	mv -f $tmpdir/tmp-la $lib
2693	>	done
2694	>	${RM}r "$tmpdir"
2695	>	fi
2696	>	fi
2697	>
2698	>	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699	>	for libdir in $libdirs; do
2700	>	if test -n "$finish_cmds"; then
2701	>	# Do each command in the finish commands.
2702	>	func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2703	>	'"$cmd"'"'
2704	>	fi
2705	>	if test -n "$finish_eval"; then
2706	>	# Do the single finish_eval.
2707	>	eval cmds=\"$finish_eval\"
2708	>	$opt_dry_run || eval "$cmds" || func_append admincmds "
2709	>	$cmds"
2710	>	fi
2711	>	done
2712	>	fi
2713	>
2714	>	# Exit here if they wanted silent mode.
2715	>	$opt_silent && exit $EXIT_SUCCESS
2716	>
2717	>	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718	>	echo "----------------------------------------------------------------------"
2719	>	echo "Libraries have been installed in:"
2720	>	for libdir in $libdirs; do
2721	>	$ECHO "   $libdir"
2722	>	done
2723	>	echo
2724	>	echo "If you ever happen to want to link against installed libraries"
2725	>	echo "in a given directory, LIBDIR, you must either use libtool, and"
2726	>	echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727	>	echo "flag during linking and do at least one of the following:"
2728	>	if test -n "$shlibpath_var"; then
2729	>	echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2730	>	echo "     during execution"
2731	>	fi
2732	>	if test -n "$runpath_var"; then
2733	>	echo "   - add LIBDIR to the \`$runpath_var' environment variable"
2734	>	echo "     during linking"
2735	>	fi
2736	>	if test -n "$hardcode_libdir_flag_spec"; then
2737	>	libdir=LIBDIR
2738	>	eval flag=\"$hardcode_libdir_flag_spec\"
2739	>
2740	>	$ECHO "   - use the \`$flag' linker flag"
2741	>	fi
2742	>	if test -n "$admincmds"; then
2743	>	$ECHO "   - have your system administrator run these commands:$admincmds"
2744	>	fi
2745	>	if test -f /etc/ld.so.conf; then
2746	>	echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2747	>	fi
2748	>	echo
2749	>
2750	>	echo "See any operating system documentation about shared libraries for"
2751	>	case $host in
2752	>	solaris2.[6789]|solaris2.1[0-9])
2753	>	echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2754	>	echo "pages."
2755	>	;;
2756	>	*)
2757	>	echo "more information, such as the ld(1) and ld.so(8) manual pages."
2758	>	;;
2759	>	esac
2760	>	echo "----------------------------------------------------------------------"
2761	>	fi
2762	>	exit $EXIT_SUCCESS
2763	>	}
2764	>
2765	>	test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2766	>
2767	>
2768	>	# func_mode_install arg...
2769	>	func_mode_install ()
2770	>	{
2771	>	$opt_debug
2772	>	# There may be an optional sh(1) argument at the beginning of
2773	>	# install_prog (especially on Windows NT).
2774	>	if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775	>	# Allow the use of GNU shtool's install command.
2776	>	case $nonopt in *shtool*) :;; *) false;; esac; then
2777	>	# Aesthetically quote it.
2778	>	func_quote_for_eval "$nonopt"
2779	>	install_prog="$func_quote_for_eval_result "
2780	>	arg=$1
2781	>	shift
2782		else
2783	<	# Append the name of the non-PIC object the libtool object file.
2784	<	# Only append if the libtool object file exists.
2785	<	test -z "$run" && cat >> ${libobj}T <<EOF
816	<	# Name of the non-PIC object.
817	<	non_pic_object=none
2783	>	install_prog=
2784	>	arg=$nonopt
2785	>	fi
2786
2787	<	EOF
2787	>	# The real first argument should be the name of the installation program.
2788	>	# Aesthetically quote it.
2789	>	func_quote_for_eval "$arg"
2790	>	func_append install_prog "$func_quote_for_eval_result"
2791	>	install_shared_prog=$install_prog
2792	>	case " $install_prog " in
2793	>	*[\\\ /]cp\ *) install_cp=: ;;
2794	>	*) install_cp=false ;;
2795	>	esac
2796	>
2797	>	# We need to accept at least all the BSD install flags.
2798	>	dest=
2799	>	files=
2800	>	opts=
2801	>	prev=
2802	>	install_type=
2803	>	isdir=no
2804	>	stripme=
2805	>	no_mode=:
2806	>	for arg
2807	>	do
2808	>	arg2=
2809	>	if test -n "$dest"; then
2810	>	func_append files " $dest"
2811	>	dest=$arg
2812	>	continue
2813	>	fi
2814	>
2815	>	case $arg in
2816	>	-d) isdir=yes ;;
2817	>	-f)
2818	>	if $install_cp; then :; else
2819	>	prev=$arg
2820	>	fi
2821	>	;;
2822	>	-g | -m | -o)
2823	>	prev=$arg
2824	>	;;
2825	>	-s)
2826	>	stripme=" -s"
2827	>	continue
2828	>	;;
2829	>	-*)
2830	>	;;
2831	>	*)
2832	>	# If the previous option needed an argument, then skip it.
2833	>	if test -n "$prev"; then
2834	>	if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835	>	arg2=$install_override_mode
2836	>	no_mode=false
2837	>	fi
2838	>	prev=
2839	>	else
2840	>	dest=$arg
2841	>	continue
2842	>	fi
2843	>	;;
2844	>	esac
2845	>
2846	>	# Aesthetically quote the argument.
2847	>	func_quote_for_eval "$arg"
2848	>	func_append install_prog " $func_quote_for_eval_result"
2849	>	if test -n "$arg2"; then
2850	>	func_quote_for_eval "$arg2"
2851	>	fi
2852	>	func_append install_shared_prog " $func_quote_for_eval_result"
2853	>	done
2854	>
2855	>	test -z "$install_prog" && \
2856	>	func_fatal_help "you must specify an install program"
2857	>
2858	>	test -n "$prev" && \
2859	>	func_fatal_help "the \`$prev' option requires an argument"
2860	>
2861	>	if test -n "$install_override_mode" && $no_mode; then
2862	>	if $install_cp; then :; else
2863	>	func_quote_for_eval "$install_override_mode"
2864	>	func_append install_shared_prog " -m $func_quote_for_eval_result"
2865	>	fi
2866	>	fi
2867	>
2868	>	if test -z "$files"; then
2869	>	if test -z "$dest"; then
2870	>	func_fatal_help "no file or destination specified"
2871	>	else
2872	>	func_fatal_help "you must specify a destination"
2873	>	fi
2874	>	fi
2875	>
2876	>	# Strip any trailing slash from the destination.
2877	>	func_stripname '' '/' "$dest"
2878	>	dest=$func_stripname_result
2879	>
2880	>	# Check to see that the destination is a directory.
2881	>	test -d "$dest" && isdir=yes
2882	>	if test "$isdir" = yes; then
2883	>	destdir="$dest"
2884	>	destname=
2885	>	else
2886	>	func_dirname_and_basename "$dest" "" "."
2887	>	destdir="$func_dirname_result"
2888	>	destname="$func_basename_result"
2889	>
2890	>	# Not a directory, so check to see that there is only one file specified.
2891	>	set dummy $files; shift
2892	>	test "$#" -gt 1 && \
2893	>	func_fatal_help "\`$dest' is not a directory"
2894	>	fi
2895	>	case $destdir in
2896	>	[\\/]* | [A-Za-z]:[\\/]*) ;;
2897	>	*)
2898	>	for file in $files; do
2899	>	case $file in
2900	>	*.lo) ;;
2901	>	*)
2902	>	func_fatal_help "\`$destdir' must be an absolute directory name"
2903	>	;;
2904	>	esac
2905	>	done
2906	>	;;
2907	>	esac
2908	>
2909	>	# This variable tells wrapper scripts just to set variables rather
2910	>	# than running their programs.
2911	>	libtool_install_magic="$magic"
2912	>
2913	>	staticlibs=
2914	>	future_libdirs=
2915	>	current_libdirs=
2916	>	for file in $files; do
2917	>
2918	>	# Do each installation.
2919	>	case $file in
2920	>	*.$libext)
2921	>	# Do the static libraries later.
2922	>	func_append staticlibs " $file"
2923	>	;;
2924	>
2925	>	*.la)
2926	>	func_resolve_sysroot "$file"
2927	>	file=$func_resolve_sysroot_result
2928	>
2929	>	# Check to see that this really is a libtool archive.
2930	>	func_lalib_unsafe_p "$file" \
2931	>	|| func_fatal_help "\`$file' is not a valid libtool archive"
2932	>
2933	>	library_names=
2934	>	old_library=
2935	>	relink_command=
2936	>	func_source "$file"
2937	>
2938	>	# Add the libdir to current_libdirs if it is the destination.
2939	>	if test "X$destdir" = "X$libdir"; then
2940	>	case "$current_libdirs " in
2941	>	*" $libdir "*) ;;
2942	>	*) func_append current_libdirs " $libdir" ;;
2943	>	esac
2944	>	else
2945	>	# Note the libdir as a future libdir.
2946	>	case "$future_libdirs " in
2947	>	*" $libdir "*) ;;
2948	>	*) func_append future_libdirs " $libdir" ;;
2949	>	esac
2950	>	fi
2951	>
2952	>	func_dirname "$file" "/" ""
2953	>	dir="$func_dirname_result"
2954	>	func_append dir "$objdir"
2955	>
2956	>	if test -n "$relink_command"; then
2957	>	# Determine the prefix the user has applied to our future dir.
2958	>	inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959	>
2960	>	# Don't allow the user to place us outside of our expected
2961	>	# location b/c this prevents finding dependent libraries that
2962	>	# are installed to the same prefix.
2963	>	# At present, this check doesn't affect windows .dll's that
2964	>	# are installed into $libdir/../bin (currently, that works fine)
2965	>	# but it's something to keep an eye on.
2966	>	test "$inst_prefix_dir" = "$destdir" && \
2967	>	func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968	>
2969	>	if test -n "$inst_prefix_dir"; then
2970	>	# Stick the inst_prefix_dir data into the link command.
2971	>	relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972	>	else
2973	>	relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2974	>	fi
2975	>
2976	>	func_warning "relinking \`$file'"
2977	>	func_show_eval "$relink_command" \
2978	>	'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2979	>	fi
2980	>
2981	>	# See the names of the shared library.
2982	>	set dummy $library_names; shift
2983	>	if test -n "$1"; then
2984	>	realname="$1"
2985	>	shift
2986	>
2987	>	srcname="$realname"
2988	>	test -n "$relink_command" && srcname="$realname"T
2989	>
2990	>	# Install the shared library and build the symlinks.
2991	>	func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2992	>	'exit $?'
2993	>	tstripme="$stripme"
2994	>	case $host_os in
2995	>	cygwin* | mingw* | pw32* | cegcc*)
2996	>	case $realname in
2997	>	*.dll.a)
2998	>	tstripme=""
2999	>	;;
3000	>	esac
3001	>	;;
3002	>	esac
3003	>	if test -n "$tstripme" && test -n "$striplib"; then
3004	>	func_show_eval "$striplib $destdir/$realname" 'exit $?'
3005	>	fi
3006	>
3007	>	if test "$#" -gt 0; then
3008	>	# Delete the old symlinks, and create new ones.
3009	>	# Try `ln -sf' first, because the `ln' binary might depend on
3010	>	# the symlink we replace!  Solaris /bin/ln does not understand -f,
3011	>	# so we also need to try rm && ln -s.
3012	>	for linkname
3013	>	do
3014	>	test "$linkname" != "$realname" \
3015	>	&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3016	>	done
3017	>	fi
3018	>
3019	>	# Do each command in the postinstall commands.
3020	>	lib="$destdir/$realname"
3021	>	func_execute_cmds "$postinstall_cmds" 'exit $?'
3022	>	fi
3023	>
3024	>	# Install the pseudo-library for information purposes.
3025	>	func_basename "$file"
3026	>	name="$func_basename_result"
3027	>	instname="$dir/$name"i
3028	>	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029	>
3030	>	# Maybe install the static library, too.
3031	>	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3032	>	;;
3033	>
3034	>	*.lo)
3035	>	# Install (i.e. copy) a libtool object.
3036	>
3037	>	# Figure out destination file name, if it wasn't already specified.
3038	>	if test -n "$destname"; then
3039	>	destfile="$destdir/$destname"
3040	>	else
3041	>	func_basename "$file"
3042	>	destfile="$func_basename_result"
3043	>	destfile="$destdir/$destfile"
3044	>	fi
3045	>
3046	>	# Deduce the name of the destination old-style object file.
3047	>	case $destfile in
3048	>	*.lo)
3049	>	func_lo2o "$destfile"
3050	>	staticdest=$func_lo2o_result
3051	>	;;
3052	>	*.$objext)
3053	>	staticdest="$destfile"
3054	>	destfile=
3055	>	;;
3056	>	*)
3057	>	func_fatal_help "cannot copy a libtool object to \`$destfile'"
3058	>	;;
3059	>	esac
3060	>
3061	>	# Install the libtool object if requested.
3062	>	test -n "$destfile" && \
3063	>	func_show_eval "$install_prog $file $destfile" 'exit $?'
3064	>
3065	>	# Install the old object if enabled.
3066	>	if test "$build_old_libs" = yes; then
3067	>	# Deduce the name of the old-style object file.
3068	>	func_lo2o "$file"
3069	>	staticobj=$func_lo2o_result
3070	>	func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3071	>	fi
3072	>	exit $EXIT_SUCCESS
3073	>	;;
3074	>
3075	>	*)
3076	>	# Figure out destination file name, if it wasn't already specified.
3077	>	if test -n "$destname"; then
3078	>	destfile="$destdir/$destname"
3079	>	else
3080	>	func_basename "$file"
3081	>	destfile="$func_basename_result"
3082	>	destfile="$destdir/$destfile"
3083	>	fi
3084	>
3085	>	# If the file is missing, and there is a .exe on the end, strip it
3086	>	# because it is most likely a libtool script we actually want to
3087	>	# install
3088	>	stripped_ext=""
3089	>	case $file in
3090	>	*.exe)
3091	>	if test ! -f "$file"; then
3092	>	func_stripname '' '.exe' "$file"
3093	>	file=$func_stripname_result
3094	>	stripped_ext=".exe"
3095	>	fi
3096	>	;;
3097	>	esac
3098	>
3099	>	# Do a test to see if this is really a libtool program.
3100	>	case $host in
3101	>	*cygwin* | *mingw*)
3102	>	if func_ltwrapper_executable_p "$file"; then
3103	>	func_ltwrapper_scriptname "$file"
3104	>	wrapper=$func_ltwrapper_scriptname_result
3105	>	else
3106	>	func_stripname '' '.exe' "$file"
3107	>	wrapper=$func_stripname_result
3108	>	fi
3109	>	;;
3110	>	*)
3111	>	wrapper=$file
3112	>	;;
3113	>	esac
3114	>	if func_ltwrapper_script_p "$wrapper"; then
3115	>	notinst_deplibs=
3116	>	relink_command=
3117	>
3118	>	func_source "$wrapper"
3119	>
3120	>	# Check the variables that should have been set.
3121	>	test -z "$generated_by_libtool_version" && \
3122	>	func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3123	>
3124	>	finalize=yes
3125	>	for lib in $notinst_deplibs; do
3126	>	# Check to see that each library is installed.
3127	>	libdir=
3128	>	if test -f "$lib"; then
3129	>	func_source "$lib"
3130	>	fi
3131	>	libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132	>	if test -n "$libdir" && test ! -f "$libfile"; then
3133	>	func_warning "\`$lib' has not been installed in \`$libdir'"
3134	>	finalize=no
3135	>	fi
3136	>	done
3137	>
3138	>	relink_command=
3139	>	func_source "$wrapper"
3140	>
3141	>	outputname=
3142	>	if test "$fast_install" = no && test -n "$relink_command"; then
3143	>	$opt_dry_run || {
3144	>	if test "$finalize" = yes; then
3145	>	tmpdir=`func_mktempdir`
3146	>	func_basename "$file$stripped_ext"
3147	>	file="$func_basename_result"
3148	>	outputname="$tmpdir/$file"
3149	>	# Replace the output file specification.
3150	>	relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3151	>
3152	>	$opt_silent || {
3153	>	func_quote_for_expand "$relink_command"
3154	>	eval "func_echo $func_quote_for_expand_result"
3155	>	}
3156	>	if eval "$relink_command"; then :
3157	>	else
3158	>	func_error "error: relink \`$file' with the above command before installing it"
3159	>	$opt_dry_run || ${RM}r "$tmpdir"
3160	>	continue
3161	>	fi
3162	>	file="$outputname"
3163	>	else
3164	>	func_warning "cannot relink \`$file'"
3165	>	fi
3166	>	}
3167	>	else
3168	>	# Install the binary that we compiled earlier.
3169	>	file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3170	>	fi
3171	>	fi
3172	>
3173	>	# remove .exe since cygwin /usr/bin/install will append another
3174	>	# one anyway
3175	>	case $install_prog,$host in
3176	>	*/usr/bin/install*,*cygwin*)
3177	>	case $file:$destfile in
3178	>	*.exe:*.exe)
3179	>	# this is ok
3180	>	;;
3181	>	*.exe:*)
3182	>	destfile=$destfile.exe
3183	>	;;
3184	>	*:*.exe)
3185	>	func_stripname '' '.exe' "$destfile"
3186	>	destfile=$func_stripname_result
3187	>	;;
3188	>	esac
3189	>	;;
3190	>	esac
3191	>	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192	>	$opt_dry_run || if test -n "$outputname"; then
3193	>	${RM}r "$tmpdir"
3194	>	fi
3195	>	;;
3196	>	esac
3197	>	done
3198	>
3199	>	for file in $staticlibs; do
3200	>	func_basename "$file"
3201	>	name="$func_basename_result"
3202	>
3203	>	# Set up the ranlib parameters.
3204	>	oldlib="$destdir/$name"
3205	>	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206	>	tool_oldlib=$func_to_tool_file_result
3207	>
3208	>	func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3209	>
3210	>	if test -n "$stripme" && test -n "$old_striplib"; then
3211	>	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3212	>	fi
3213	>
3214	>	# Do each command in the postinstall commands.
3215	>	func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3216	>	done
3217	>
3218	>	test -n "$future_libdirs" && \
3219	>	func_warning "remember to run \`$progname --finish$future_libdirs'"
3220	>
3221	>	if test -n "$current_libdirs"; then
3222	>	# Maybe just do a dry run.
3223	>	$opt_dry_run && current_libdirs=" -n$current_libdirs"
3224	>	exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3225	>	else
3226	>	exit $EXIT_SUCCESS
3227	>	fi
3228	>	}
3229	>
3230	>	test "$opt_mode" = install && func_mode_install ${1+"$@"}
3231	>
3232	>
3233	>	# func_generate_dlsyms outputname originator pic_p
3234	>	# Extract symbols from dlprefiles and create ${outputname}S.o with
3235	>	# a dlpreopen symbol table.
3236	>	func_generate_dlsyms ()
3237	>	{
3238	>	$opt_debug
3239	>	my_outputname="$1"
3240	>	my_originator="$2"
3241	>	my_pic_p="${3-no}"
3242	>	my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3243	>	my_dlsyms=
3244	>
3245	>	if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3246	>	if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247	>	my_dlsyms="${my_outputname}S.c"
3248	>	else
3249	>	func_error "not configured to extract global symbols from dlpreopened files"
3250	>	fi
3251	>	fi
3252	>
3253	>	if test -n "$my_dlsyms"; then
3254	>	case $my_dlsyms in
3255	>	"") ;;
3256	>	*.c)
3257	>	# Discover the nlist of each of the dlfiles.
3258	>	nlist="$output_objdir/${my_outputname}.nm"
3259	>
3260	>	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3261	>
3262	>	# Parse the name list into a source file.
3263	>	func_verbose "creating $output_objdir/$my_dlsyms"
3264	>
3265	>	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3266	>	/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267	>	/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3268	>
3269	>	#ifdef __cplusplus
3270	>	extern \"C\" {
3271	>	#endif
3272	>
3273	>	#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274	>	#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3275	>	#endif
3276	>
3277	>	/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
3278	>	#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279	>	/* DATA imports from DLLs on WIN32 con't be const, because runtime
3280	>	relocations are performed -- see ld's documentation on pseudo-relocs.  */
3281	>	# define LT_DLSYM_CONST
3282	>	#elif defined(__osf__)
3283	>	/* This system does not cope well with relocations in const data.  */
3284	>	# define LT_DLSYM_CONST
3285	>	#else
3286	>	# define LT_DLSYM_CONST const
3287	>	#endif
3288	>
3289	>	/* External symbol declarations for the compiler. */\
3290	>	"
3291	>
3292	>	if test "$dlself" = yes; then
3293	>	func_verbose "generating symbol list for \`$output'"
3294	>
3295	>	$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3296	>
3297	>	# Add our own program objects to the symbol list.
3298	>	progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299	>	for progfile in $progfiles; do
3300	>	func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3301	>	func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3302	>	$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3303	>	done
3304	>
3305	>	if test -n "$exclude_expsyms"; then
3306	>	$opt_dry_run || {
3307	>	eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308	>	eval '$MV "$nlist"T "$nlist"'
3309	>	}
3310	>	fi
3311	>
3312	>	if test -n "$export_symbols_regex"; then
3313	>	$opt_dry_run || {
3314	>	eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315	>	eval '$MV "$nlist"T "$nlist"'
3316	>	}
3317	>	fi
3318	>
3319	>	# Prepare the list of exported symbols
3320	>	if test -z "$export_symbols"; then
3321	>	export_symbols="$output_objdir/$outputname.exp"
3322	>	$opt_dry_run || {
3323	>	$RM $export_symbols
3324	>	eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3325	>	case $host in
3326	>	*cygwin* | *mingw* | *cegcc* )
3327	>	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328	>	eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3329	>	;;
3330	>	esac
3331	>	}
3332	>	else
3333	>	$opt_dry_run || {
3334	>	eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335	>	eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336	>	eval '$MV "$nlist"T "$nlist"'
3337	>	case $host in
3338	>	*cygwin* | *mingw* | *cegcc* )
3339	>	eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340	>	eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3341	>	;;
3342	>	esac
3343	>	}
3344	>	fi
3345	>	fi
3346	>
3347	>	for dlprefile in $dlprefiles; do
3348	>	func_verbose "extracting global C symbols from \`$dlprefile'"
3349	>	func_basename "$dlprefile"
3350	>	name="$func_basename_result"
3351	>	case $host in
3352	>	*cygwin* | *mingw* | *cegcc* )
3353	>	# if an import library, we need to obtain dlname
3354	>	if func_win32_import_lib_p "$dlprefile"; then
3355	>	func_tr_sh "$dlprefile"
3356	>	eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357	>	dlprefile_dlbasename=""
3358	>	if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3359	>	# Use subshell, to avoid clobbering current variable values
3360	>	dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3361	>	if test -n "$dlprefile_dlname" ; then
3362	>	func_basename "$dlprefile_dlname"
3363	>	dlprefile_dlbasename="$func_basename_result"
3364	>	else
3365	>	# no lafile. user explicitly requested -dlpreopen <import library>.
3366	>	$sharedlib_from_linklib_cmd "$dlprefile"
3367	>	dlprefile_dlbasename=$sharedlib_from_linklib_result
3368	>	fi
3369	>	fi
3370	>	$opt_dry_run || {
3371	>	if test -n "$dlprefile_dlbasename" ; then
3372	>	eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3373	>	else
3374	>	func_warning "Could not compute DLL name from $name"
3375	>	eval '$ECHO ": $name " >> "$nlist"'
3376	>	fi
3377	>	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3378	>	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379	>	$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3380	>	}
3381	>	else # not an import lib
3382	>	$opt_dry_run || {
3383	>	eval '$ECHO ": $name " >> "$nlist"'
3384	>	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385	>	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3386	>	}
3387	>	fi
3388	>	;;
3389	>	*)
3390	>	$opt_dry_run || {
3391	>	eval '$ECHO ": $name " >> "$nlist"'
3392	>	func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3393	>	eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3394	>	}
3395	>	;;
3396	>	esac
3397	>	done
3398	>
3399	>	$opt_dry_run || {
3400	>	# Make sure we have at least an empty file.
3401	>	test -f "$nlist" || : > "$nlist"
3402	>
3403	>	if test -n "$exclude_expsyms"; then
3404	>	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405	>	$MV "$nlist"T "$nlist"
3406	>	fi
3407	>
3408	>	# Try sorting and uniquifying the output.
3409	>	if $GREP -v "^: " < "$nlist" |
3410	>	if sort -k 3 </dev/null >/dev/null 2>&1; then
3411	>	sort -k 3
3412	>	else
3413	>	sort +2
3414	>	fi |
3415	>	uniq > "$nlist"S; then
3416	>	:
3417	>	else
3418	>	$GREP -v "^: " < "$nlist" > "$nlist"S
3419	>	fi
3420	>
3421	>	if test -f "$nlist"S; then
3422	>	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3423	>	else
3424	>	echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3425	>	fi
3426	>
3427	>	echo >> "$output_objdir/$my_dlsyms" "\
3428	>
3429	>	/* The mapping between symbol names and symbols.  */
3430	>	typedef struct {
3431	>	const char *name;
3432	>	void *address;
3433	>	} lt_dlsymlist;
3434	>	extern LT_DLSYM_CONST lt_dlsymlist
3435	>	lt_${my_prefix}_LTX_preloaded_symbols[];
3436	>	LT_DLSYM_CONST lt_dlsymlist
3437	>	lt_${my_prefix}_LTX_preloaded_symbols[] =
3438	>	{\
3439	>	{ \"$my_originator\", (void *) 0 },"
3440	>
3441	>	case $need_lib_prefix in
3442	>	no)
3443	>	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444	>	;;
3445	>	*)
3446	>	eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3447	>	;;
3448	>	esac
3449	>	echo >> "$output_objdir/$my_dlsyms" "\
3450	>	{0, (void *) 0}
3451	>	};
3452	>
3453	>	/* This works around a problem in FreeBSD linker */
3454	>	#ifdef FREEBSD_WORKAROUND
3455	>	static const void *lt_preloaded_setup() {
3456	>	return lt_${my_prefix}_LTX_preloaded_symbols;
3457	>	}
3458	>	#endif
3459	>
3460	>	#ifdef __cplusplus
3461	>	}
3462	>	#endif\
3463	>	"
3464	>	} # !$opt_dry_run
3465	>
3466	>	pic_flag_for_symtable=
3467	>	case "$compile_command " in
3468	>	*" -static "*) ;;
3469	>	*)
3470	>	case $host in
3471	>	# compiling the symbol table file with pic_flag works around
3472	>	# a FreeBSD bug that causes programs to crash when -lm is
3473	>	# linked before any other PIC object.  But we must not use
3474	>	# pic_flag when linking with -static.  The problem exists in
3475	>	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476	>	*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3477	>	pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3478	>	*-*-hpux*)
3479	>	pic_flag_for_symtable=" $pic_flag"  ;;
3480	>	*)
3481	>	if test "X$my_pic_p" != Xno; then
3482	>	pic_flag_for_symtable=" $pic_flag"
3483	>	fi
3484	>	;;
3485	>	esac
3486	>	;;
3487	>	esac
3488	>	symtab_cflags=
3489	>	for arg in $LTCFLAGS; do
3490	>	case $arg in
3491	>	-pie | -fpie | -fPIE) ;;
3492	>	*) func_append symtab_cflags " $arg" ;;
3493	>	esac
3494	>	done
3495	>
3496	>	# Now compile the dynamic symbol file.
3497	>	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3498	>
3499	>	# Clean up the generated files.
3500	>	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3501	>
3502	>	# Transform the symbol file into the correct name.
3503	>	symfileobj="$output_objdir/${my_outputname}S.$objext"
3504	>	case $host in
3505	>	*cygwin* | *mingw* | *cegcc* )
3506	>	if test -f "$output_objdir/$my_outputname.def"; then
3507	>	compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508	>	finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3509	>	else
3510	>	compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511	>	finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512	>	fi
3513	>	;;
3514	>	*)
3515	>	compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516	>	finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3517	>	;;
3518	>	esac
3519	>	;;
3520	>	*)
3521	>	func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522	>	;;
3523	>	esac
3524	>	else
3525	>	# We keep going just in case the user didn't refer to
3526	>	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3527	>	# really was required.
3528	>
3529	>	# Nullify the symbol file.
3530	>	compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531	>	finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532		fi
3533	+	}
3534	+
3535	+	# func_win32_libid arg
3536	+	# return the library type of file 'arg'
3537	+	#
3538	+	# Need a lot of goo to handle *both* DLLs and import libs
3539	+	# Has to be a shell function in order to 'eat' the argument
3540	+	# that is supplied when $file_magic_command is called.
3541	+	# Despite the name, also deal with 64 bit binaries.
3542	+	func_win32_libid ()
3543	+	{
3544	+	$opt_debug
3545	+	win32_libid_type="unknown"
3546	+	win32_fileres=`file -L $1 2>/dev/null`
3547	+	case $win32_fileres in
3548	+	*ar\ archive\ import\ library*) # definitely import
3549	+	win32_libid_type="x86 archive import"
3550	+	;;
3551	+	*ar\ archive*) # could be an import, or static
3552	+	# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553	+	if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3554	+	$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3555	+	func_to_tool_file "$1" func_convert_file_msys_to_w32
3556	+	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3557	+	$SED -n -e '
3558	+	1,100{
3559	+	/ I /{
3560	+	s,.*,import,
3561	+	p
3562	+	q
3563	+	}
3564	+	}'`
3565	+	case $win32_nmres in
3566	+	import*)  win32_libid_type="x86 archive import";;
3567	+	*)        win32_libid_type="x86 archive static";;
3568	+	esac
3569	+	fi
3570	+	;;
3571	+	*DLL*)
3572	+	win32_libid_type="x86 DLL"
3573	+	;;
3574	+	*executable*) # but shell scripts are "executable" too...
3575	+	case $win32_fileres in
3576	+	*MS\ Windows\ PE\ Intel*)
3577	+	win32_libid_type="x86 DLL"
3578	+	;;
3579	+	esac
3580	+	;;
3581	+	esac
3582	+	$ECHO "$win32_libid_type"
3583	+	}
3584
3585	<	$run $mv "${libobj}T" "${libobj}"
3585	>	# func_cygming_dll_for_implib ARG
3586	>	#
3587	>	# Platform-specific function to extract the
3588	>	# name of the DLL associated with the specified
3589	>	# import library ARG.
3590	>	# Invoked by eval'ing the libtool variable
3591	>	#    $sharedlib_from_linklib_cmd
3592	>	# Result is available in the variable
3593	>	#    $sharedlib_from_linklib_result
3594	>	func_cygming_dll_for_implib ()
3595	>	{
3596	>	$opt_debug
3597	>	sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3598	>	}
3599	>
3600	>	# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3601	>	#
3602	>	# The is the core of a fallback implementation of a
3603	>	# platform-specific function to extract the name of the
3604	>	# DLL associated with the specified import library LIBNAME.
3605	>	#
3606	>	# SECTION_NAME is either .idata$6 or .idata$7, depending
3607	>	# on the platform and compiler that created the implib.
3608	>	#
3609	>	# Echos the name of the DLL associated with the
3610	>	# specified import library.
3611	>	func_cygming_dll_for_implib_fallback_core ()
3612	>	{
3613	>	$opt_debug
3614	>	match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615	>	$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3616	>	$SED '/^Contents of section '"$match_literal"':/{
3617	>	# Place marker at beginning of archive member dllname section
3618	>	s/.*/====MARK====/
3619	>	p
3620	>	d
3621	>	}
3622	>	# These lines can sometimes be longer than 43 characters, but
3623	>	# are always uninteresting
3624	>	/:[  ]*file format pe[i]\{,1\}-/d
3625	>	/^In archive [^:]*:/d
3626	>	# Ensure marker is printed
3627	>	/^====MARK====/p
3628	>	# Remove all lines with less than 43 characters
3629	>	/^.\{43\}/!d
3630	>	# From remaining lines, remove first 43 characters
3631	>	s/^.\{43\}//' |
3632	>	$SED -n '
3633	>	# Join marker and all lines until next marker into a single line
3634	>	/^====MARK====/ b para
3635	>	H
3636	>	$ b para
3637	>	b
3638	>	:para
3639	>	x
3640	>	s/\n//g
3641	>	# Remove the marker
3642	>	s/^====MARK====//
3643	>	# Remove trailing dots and whitespace
3644	>	s/[\. \t]*$//
3645	>	# Print
3646	>	/./p' |
3647	>	# we now have a list, one entry per line, of the stringified
3648	>	# contents of the appropriate section of all members of the
3649	>	# archive which possess that section. Heuristic: eliminate
3650	>	# all those which have a first or second character that is
3651	>	# a '.' (that is, objdump's representation of an unprintable
3652	>	# character.) This should work for all archives with less than
3653	>	# 0x302f exports -- but will fail for DLLs whose name actually
3654	>	# begins with a literal '.' or a single character followed by
3655	>	# a '.'.
3656	>	#
3657	>	# Of those that remain, print the first one.
3658	>	$SED -e '/^\./d;/^.\./d;q'
3659	>	}
3660	>
3661	>	# func_cygming_gnu_implib_p ARG
3662	>	# This predicate returns with zero status (TRUE) if
3663	>	# ARG is a GNU/binutils-style import library. Returns
3664	>	# with nonzero status (FALSE) otherwise.
3665	>	func_cygming_gnu_implib_p ()
3666	>	{
3667	>	$opt_debug
3668	>	func_to_tool_file "$1" func_convert_file_msys_to_w32
3669	>	func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3670	>	test -n "$func_cygming_gnu_implib_tmp"
3671	>	}
3672	>
3673	>	# func_cygming_ms_implib_p ARG
3674	>	# This predicate returns with zero status (TRUE) if
3675	>	# ARG is an MS-style import library. Returns
3676	>	# with nonzero status (FALSE) otherwise.
3677	>	func_cygming_ms_implib_p ()
3678	>	{
3679	>	$opt_debug
3680	>	func_to_tool_file "$1" func_convert_file_msys_to_w32
3681	>	func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682	>	test -n "$func_cygming_ms_implib_tmp"
3683	>	}
3684	>
3685	>	# func_cygming_dll_for_implib_fallback ARG
3686	>	# Platform-specific function to extract the
3687	>	# name of the DLL associated with the specified
3688	>	# import library ARG.
3689	>	#
3690	>	# This fallback implementation is for use when $DLLTOOL
3691	>	# does not support the --identify-strict option.
3692	>	# Invoked by eval'ing the libtool variable
3693	>	#    $sharedlib_from_linklib_cmd
3694	>	# Result is available in the variable
3695	>	#    $sharedlib_from_linklib_result
3696	>	func_cygming_dll_for_implib_fallback ()
3697	>	{
3698	>	$opt_debug
3699	>	if func_cygming_gnu_implib_p "$1" ; then
3700	>	# binutils import library
3701	>	sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702	>	elif func_cygming_ms_implib_p "$1" ; then
3703	>	# ms-generated import library
3704	>	sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3705	>	else
3706	>	# unknown
3707	>	sharedlib_from_linklib_result=""
3708	>	fi
3709	>	}
3710
3711	<	# Unlock the critical section if it was locked
3712	<	if test "$need_locks" != no; then
3713	<	$run $rm "$lockfile"
3711	>
3712	>	# func_extract_an_archive dir oldlib
3713	>	func_extract_an_archive ()
3714	>	{
3715	>	$opt_debug
3716	>	f_ex_an_ar_dir="$1"; shift
3717	>	f_ex_an_ar_oldlib="$1"
3718	>	if test "$lock_old_archive_extraction" = yes; then
3719	>	lockfile=$f_ex_an_ar_oldlib.lock
3720	>	until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3721	>	func_echo "Waiting for $lockfile to be removed"
3722	>	sleep 2
3723	>	done
3724	>	fi
3725	>	func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726	>	'stat=$?; rm -f "$lockfile"; exit $stat'
3727	>	if test "$lock_old_archive_extraction" = yes; then
3728	>	$opt_dry_run || rm -f "$lockfile"
3729	>	fi
3730	>	if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3731	>	:
3732	>	else
3733	>	func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3734		fi
3735	+	}
3736	+
3737	+
3738	+	# func_extract_archives gentop oldlib ...
3739	+	func_extract_archives ()
3740	+	{
3741	+	$opt_debug
3742	+	my_gentop="$1"; shift
3743	+	my_oldlibs=${1+"$@"}
3744	+	my_oldobjs=""
3745	+	my_xlib=""
3746	+	my_xabs=""
3747	+	my_xdir=""
3748	+
3749	+	for my_xlib in $my_oldlibs; do
3750	+	# Extract the objects.
3751	+	case $my_xlib in
3752	+	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3753	+	*) my_xabs=`pwd`"/$my_xlib" ;;
3754	+	esac
3755	+	func_basename "$my_xlib"
3756	+	my_xlib="$func_basename_result"
3757	+	my_xlib_u=$my_xlib
3758	+	while :; do
3759	+	case " $extracted_archives " in
3760	+	*" $my_xlib_u "*)
3761	+	func_arith $extracted_serial + 1
3762	+	extracted_serial=$func_arith_result
3763	+	my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764	+	*) break ;;
3765	+	esac
3766	+	done
3767	+	extracted_archives="$extracted_archives $my_xlib_u"
3768	+	my_xdir="$my_gentop/$my_xlib_u"
3769	+
3770	+	func_mkdir_p "$my_xdir"
3771	+
3772	+	case $host in
3773	+	*-darwin*)
3774	+	func_verbose "Extracting $my_xabs"
3775	+	# Do not bother doing anything if just a dry run
3776	+	$opt_dry_run || {
3777	+	darwin_orig_dir=`pwd`
3778	+	cd $my_xdir || exit $?
3779	+	darwin_archive=$my_xabs
3780	+	darwin_curdir=`pwd`
3781	+	darwin_base_archive=`basename "$darwin_archive"`
3782	+	darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783	+	if test -n "$darwin_arches"; then
3784	+	darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3785	+	darwin_arch=
3786	+	func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3787	+	for darwin_arch in  $darwin_arches ; do
3788	+	func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789	+	$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790	+	cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791	+	func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3792	+	cd "$darwin_curdir"
3793	+	$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794	+	done # $darwin_arches
3795	+	## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796	+	darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3797	+	darwin_file=
3798	+	darwin_files=
3799	+	for darwin_file in $darwin_filelist; do
3800	+	darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801	+	$LIPO -create -output "$darwin_file" $darwin_files
3802	+	done # $darwin_filelist
3803	+	$RM -rf unfat-$$
3804	+	cd "$darwin_orig_dir"
3805	+	else
3806	+	cd $darwin_orig_dir
3807	+	func_extract_an_archive "$my_xdir" "$my_xabs"
3808	+	fi # $darwin_arches
3809	+	} # !$opt_dry_run
3810	+	;;
3811	+	*)
3812	+	func_extract_an_archive "$my_xdir" "$my_xabs"
3813	+	;;
3814	+	esac
3815	+	my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3816	+	done
3817	+
3818	+	func_extract_archives_result="$my_oldobjs"
3819	+	}
3820	+
3821	+
3822	+	# func_emit_wrapper [arg=no]
3823	+	#
3824	+	# Emit a libtool wrapper script on stdout.
3825	+	# Don't directly open a file because we may want to
3826	+	# incorporate the script contents within a cygwin/mingw
3827	+	# wrapper executable.  Must ONLY be called from within
3828	+	# func_mode_link because it depends on a number of variables
3829	+	# set therein.
3830	+	#
3831	+	# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832	+	# variable will take.  If 'yes', then the emitted script
3833	+	# will assume that the directory in which it is stored is
3834	+	# the $objdir directory.  This is a cygwin/mingw-specific
3835	+	# behavior.
3836	+	func_emit_wrapper ()
3837	+	{
3838	+	func_emit_wrapper_arg1=${1-no}
3839	+
3840	+	$ECHO "\
3841	+	#! $SHELL
3842	+
3843	+	# $output - temporary wrapper script for $objdir/$outputname
3844	+	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3845	+	#
3846	+	# The $output program cannot be directly executed until all the libtool
3847	+	# libraries that it depends on are installed.
3848	+	#
3849	+	# This wrapper script should never be moved out of the build directory.
3850	+	# If it is, it will not operate correctly.
3851	+
3852	+	# Sed substitution that helps us do robust quoting.  It backslashifies
3853	+	# metacharacters that are still active within double-quoted strings.
3854	+	sed_quote_subst='$sed_quote_subst'
3855	+
3856	+	# Be Bourne compatible
3857	+	if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3858	+	emulate sh
3859	+	NULLCMD=:
3860	+	# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861	+	# is contrary to our usage.  Disable this feature.
3862	+	alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863	+	setopt NO_GLOB_SUBST
3864	+	else
3865	+	case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3866	+	fi
3867	+	BIN_SH=xpg4; export BIN_SH # for Tru64
3868	+	DUALCASE=1; export DUALCASE # for MKS sh
3869	+
3870	+	# The HP-UX ksh and POSIX shell print the target directory to stdout
3871	+	# if CDPATH is set.
3872	+	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3873	+
3874	+	relink_command=\"$relink_command\"
3875	+
3876	+	# This environment variable determines our operation mode.
3877	+	if test \"\$libtool_install_magic\" = \"$magic\"; then
3878	+	# install mode needs the following variables:
3879	+	generated_by_libtool_version='$macro_version'
3880	+	notinst_deplibs='$notinst_deplibs'
3881	+	else
3882	+	# When we are sourced in execute mode, \$file and \$ECHO are already set.
3883	+	if test \"\$libtool_execute_magic\" != \"$magic\"; then
3884	+	file=\"\$0\""
3885	+
3886	+	qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3887	+	$ECHO "\
3888
3889	<	exit 0
3889	>	# A function that is used when there is no print builtin or printf.
3890	>	func_fallback_echo ()
3891	>	{
3892	>	eval 'cat <<_LTECHO_EOF
3893	>	\$1
3894	>	_LTECHO_EOF'
3895	>	}
3896	>	ECHO=\"$qECHO\"
3897	>	fi
3898	>
3899	>	# Very basic option parsing. These options are (a) specific to
3900	>	# the libtool wrapper, (b) are identical between the wrapper
3901	>	# /script/ and the wrapper /executable/ which is used only on
3902	>	# windows platforms, and (c) all begin with the string "--lt-"
3903	>	# (application programs are unlikely to have options which match
3904	>	# this pattern).
3905	>	#
3906	>	# There are only two supported options: --lt-debug and
3907	>	# --lt-dump-script. There is, deliberately, no --lt-help.
3908	>	#
3909	>	# The first argument to this parsing function should be the
3910	>	# script's $0 value, followed by "$@".
3911	>	lt_option_debug=
3912	>	func_parse_lt_options ()
3913	>	{
3914	>	lt_script_arg0=\$0
3915	>	shift
3916	>	for lt_opt
3917	>	do
3918	>	case \"\$lt_opt\" in
3919	>	--lt-debug) lt_option_debug=1 ;;
3920	>	--lt-dump-script)
3921	>	lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922	>	test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923	>	lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924	>	cat \"\$lt_dump_D/\$lt_dump_F\"
3925	>	exit 0
3926	>	;;
3927	>	--lt-*)
3928	>	\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3929	>	exit 1
3930	>	;;
3931	>	esac
3932	>	done
3933	>
3934	>	# Print the debug banner immediately:
3935	>	if test -n \"\$lt_option_debug\"; then
3936	>	echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937	>	fi
3938	>	}
3939	>
3940	>	# Used when --lt-debug. Prints its arguments to stdout
3941	>	# (redirection is the responsibility of the caller)
3942	>	func_lt_dump_args ()
3943	>	{
3944	>	lt_dump_args_N=1;
3945	>	for lt_arg
3946	>	do
3947	>	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948	>	lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949	>	done
3950	>	}
3951	>
3952	>	# Core function for launching the target application
3953	>	func_exec_program_core ()
3954	>	{
3955	>	"
3956	>	case $host in
3957	>	# Backslashes separate directories on plain windows
3958	>	*-*-mingw | *-*-os2* | *-cegcc*)
3959	>	$ECHO "\
3960	>	if test -n \"\$lt_option_debug\"; then
3961	>	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962	>	func_lt_dump_args \${1+\"\$@\"} 1>&2
3963	>	fi
3964	>	exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3965	>	"
3966	>	;;
3967	>
3968	>	*)
3969	>	$ECHO "\
3970	>	if test -n \"\$lt_option_debug\"; then
3971	>	\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3972	>	func_lt_dump_args \${1+\"\$@\"} 1>&2
3973	>	fi
3974	>	exec \"\$progdir/\$program\" \${1+\"\$@\"}
3975	>	"
3976		;;
3977	+	esac
3978	+	$ECHO "\
3979	+	\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3980	+	exit 1
3981	+	}
3982	+
3983	+	# A function to encapsulate launching the target application
3984	+	# Strips options in the --lt-* namespace from \$@ and
3985	+	# launches target application with the remaining arguments.
3986	+	func_exec_program ()
3987	+	{
3988	+	case \" \$* \" in
3989	+	*\\ --lt-*)
3990	+	for lt_wr_arg
3991	+	do
3992	+	case \$lt_wr_arg in
3993	+	--lt-*) ;;
3994	+	*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3995	+	esac
3996	+	shift
3997	+	done ;;
3998	+	esac
3999	+	func_exec_program_core \${1+\"\$@\"}
4000	+	}
4001	+
4002	+	# Parse options
4003	+	func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4004	+
4005	+	# Find the directory that this script lives in.
4006	+	thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4007	+	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4008	+
4009	+	# Follow symbolic links until we get to the real thisdir.
4010	+	file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4011	+	while test -n \"\$file\"; do
4012	+	destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4013	+
4014	+	# If there was a directory component, then change thisdir.
4015	+	if test \"x\$destdir\" != \"x\$file\"; then
4016	+	case \"\$destdir\" in
4017	+	[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4018	+	*) thisdir=\"\$thisdir/\$destdir\" ;;
4019	+	esac
4020	+	fi
4021	+
4022	+	file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023	+	file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4024	+	done
4025	+
4026	+	# Usually 'no', except on cygwin/mingw when embedded into
4027	+	# the cwrapper.
4028	+	WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4029	+	if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4030	+	# special case for '.'
4031	+	if test \"\$thisdir\" = \".\"; then
4032	+	thisdir=\`pwd\`
4033	+	fi
4034	+	# remove .libs from thisdir
4035	+	case \"\$thisdir\" in
4036	+	*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4037	+	$objdir )   thisdir=. ;;
4038	+	esac
4039	+	fi
4040	+
4041	+	# Try to get the absolute directory name.
4042	+	absdir=\`cd \"\$thisdir\" && pwd\`
4043	+	test -n \"\$absdir\" && thisdir=\"\$absdir\"
4044	+	"
4045	+
4046	+	if test "$fast_install" = yes; then
4047	+	$ECHO "\
4048	+	program=lt-'$outputname'$exeext
4049	+	progdir=\"\$thisdir/$objdir\"
4050	+
4051	+	if test ! -f \"\$progdir/\$program\" ||
4052	+	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4053	+	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4054	+
4055	+	file=\"\$\$-\$program\"
4056	+
4057	+	if test ! -d \"\$progdir\"; then
4058	+	$MKDIR \"\$progdir\"
4059	+	else
4060	+	$RM \"\$progdir/\$file\"
4061	+	fi"
4062	+
4063	+	$ECHO "\
4064	+
4065	+	# relink executable if necessary
4066	+	if test -n \"\$relink_command\"; then
4067	+	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4068	+	else
4069	+	$ECHO \"\$relink_command_output\" >&2
4070	+	$RM \"\$progdir/\$file\"
4071	+	exit 1
4072	+	fi
4073	+	fi
4074	+
4075	+	$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4076	+	{ $RM \"\$progdir/\$program\";
4077	+	$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4078	+	$RM \"\$progdir/\$file\"
4079	+	fi"
4080	+	else
4081	+	$ECHO "\
4082	+	program='$outputname'
4083	+	progdir=\"\$thisdir/$objdir\"
4084	+	"
4085	+	fi
4086	+
4087	+	$ECHO "\
4088	+
4089	+	if test -f \"\$progdir/\$program\"; then"
4090	+
4091	+	# fixup the dll searchpath if we need to.
4092	+	#
4093	+	# Fix the DLL searchpath if we need to.  Do this before prepending
4094	+	# to shlibpath, because on Windows, both are PATH and uninstalled
4095	+	# libraries must come first.
4096	+	if test -n "$dllsearchpath"; then
4097	+	$ECHO "\
4098	+	# Add the dll search path components to the executable PATH
4099	+	PATH=$dllsearchpath:\$PATH
4100	+	"
4101	+	fi
4102	+
4103	+	# Export our shlibpath_var if we have one.
4104	+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4105	+	$ECHO "\
4106	+	# Add our own library path to $shlibpath_var
4107	+	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4108	+
4109	+	# Some systems cannot cope with colon-terminated $shlibpath_var
4110	+	# The second colon is a workaround for a bug in BeOS R4 sed
4111	+	$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4112	+
4113	+	export $shlibpath_var
4114	+	"
4115	+	fi
4116	+
4117	+	$ECHO "\
4118	+	if test \"\$libtool_execute_magic\" != \"$magic\"; then
4119	+	# Run the actual program with our arguments.
4120	+	func_exec_program \${1+\"\$@\"}
4121	+	fi
4122	+	else
4123	+	# The program doesn't exist.
4124	+	\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4125	+	\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4126	+	\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4127	+	exit 1
4128	+	fi
4129	+	fi\
4130	+	"
4131	+	}
4132	+
4133	+
4134	+	# func_emit_cwrapperexe_src
4135	+	# emit the source code for a wrapper executable on stdout
4136	+	# Must ONLY be called from within func_mode_link because
4137	+	# it depends on a number of variable set therein.
4138	+	func_emit_cwrapperexe_src ()
4139	+	{
4140	+	cat <<EOF
4141	+
4142	+	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4143	+	Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4144	+
4145	+	The $output program cannot be directly executed until all the libtool
4146	+	libraries that it depends on are installed.
4147	+
4148	+	This wrapper executable should never be moved out of the build directory.
4149	+	If it is, it will not operate correctly.
4150	+	*/
4151	+	EOF
4152	+	cat <<"EOF"
4153	+	#ifdef _MSC_VER
4154	+	# define _CRT_SECURE_NO_DEPRECATE 1
4155	+	#endif
4156	+	#include <stdio.h>
4157	+	#include <stdlib.h>
4158	+	#ifdef _MSC_VER
4159	+	# include <direct.h>
4160	+	# include <process.h>
4161	+	# include <io.h>
4162	+	#else
4163	+	# include <unistd.h>
4164	+	# include <stdint.h>
4165	+	# ifdef __CYGWIN__
4166	+	#  include <io.h>
4167	+	# endif
4168	+	#endif
4169	+	#include <malloc.h>
4170	+	#include <stdarg.h>
4171	+	#include <assert.h>
4172	+	#include <string.h>
4173	+	#include <ctype.h>
4174	+	#include <errno.h>
4175	+	#include <fcntl.h>
4176	+	#include <sys/stat.h>
4177	+
4178	+	/* declarations of non-ANSI functions */
4179	+	#if defined(__MINGW32__)
4180	+	# ifdef __STRICT_ANSI__
4181	+	int _putenv (const char *);
4182	+	# endif
4183	+	#elif defined(__CYGWIN__)
4184	+	# ifdef __STRICT_ANSI__
4185	+	char *realpath (const char *, char *);
4186	+	int putenv (char *);
4187	+	int setenv (const char *, const char *, int);
4188	+	# endif
4189	+	/* #elif defined (other platforms) ... */
4190	+	#endif
4191	+
4192	+	/* portability defines, excluding path handling macros */
4193	+	#if defined(_MSC_VER)
4194	+	# define setmode _setmode
4195	+	# define stat    _stat
4196	+	# define chmod   _chmod
4197	+	# define getcwd  _getcwd
4198	+	# define putenv  _putenv
4199	+	# define S_IXUSR _S_IEXEC
4200	+	# ifndef _INTPTR_T_DEFINED
4201	+	#  define _INTPTR_T_DEFINED
4202	+	#  define intptr_t int
4203	+	# endif
4204	+	#elif defined(__MINGW32__)
4205	+	# define setmode _setmode
4206	+	# define stat    _stat
4207	+	# define chmod   _chmod
4208	+	# define getcwd  _getcwd
4209	+	# define putenv  _putenv
4210	+	#elif defined(__CYGWIN__)
4211	+	# define HAVE_SETENV
4212	+	# define FOPEN_WB "wb"
4213	+	/* #elif defined (other platforms) ... */
4214	+	#endif
4215	+
4216	+	#if defined(PATH_MAX)
4217	+	# define LT_PATHMAX PATH_MAX
4218	+	#elif defined(MAXPATHLEN)
4219	+	# define LT_PATHMAX MAXPATHLEN
4220	+	#else
4221	+	# define LT_PATHMAX 1024
4222	+	#endif
4223	+
4224	+	#ifndef S_IXOTH
4225	+	# define S_IXOTH 0
4226	+	#endif
4227	+	#ifndef S_IXGRP
4228	+	# define S_IXGRP 0
4229	+	#endif
4230	+
4231	+	/* path handling portability macros */
4232	+	#ifndef DIR_SEPARATOR
4233	+	# define DIR_SEPARATOR '/'
4234	+	# define PATH_SEPARATOR ':'
4235	+	#endif
4236	+
4237	+	#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4238	+	defined (__OS2__)
4239	+	# define HAVE_DOS_BASED_FILE_SYSTEM
4240	+	# define FOPEN_WB "wb"
4241	+	# ifndef DIR_SEPARATOR_2
4242	+	#  define DIR_SEPARATOR_2 '\\'
4243	+	# endif
4244	+	# ifndef PATH_SEPARATOR_2
4245	+	#  define PATH_SEPARATOR_2 ';'
4246	+	# endif
4247	+	#endif
4248	+
4249	+	#ifndef DIR_SEPARATOR_2
4250	+	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4251	+	#else /* DIR_SEPARATOR_2 */
4252	+	# define IS_DIR_SEPARATOR(ch) \
4253	+	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4254	+	#endif /* DIR_SEPARATOR_2 */
4255	+
4256	+	#ifndef PATH_SEPARATOR_2
4257	+	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4258	+	#else /* PATH_SEPARATOR_2 */
4259	+	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4260	+	#endif /* PATH_SEPARATOR_2 */
4261	+
4262	+	#ifndef FOPEN_WB
4263	+	# define FOPEN_WB "w"
4264	+	#endif
4265	+	#ifndef _O_BINARY
4266	+	# define _O_BINARY 0
4267	+	#endif
4268	+
4269	+	#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4270	+	#define XFREE(stale) do { \
4271	+	if (stale) { free ((void *) stale); stale = 0; } \
4272	+	} while (0)
4273	+
4274	+	#if defined(LT_DEBUGWRAPPER)
4275	+	static int lt_debug = 1;
4276	+	#else
4277	+	static int lt_debug = 0;
4278	+	#endif
4279	+
4280	+	const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4281	+
4282	+	void *xmalloc (size_t num);
4283	+	char *xstrdup (const char *string);
4284	+	const char *base_name (const char *name);
4285	+	char *find_executable (const char *wrapper);
4286	+	char *chase_symlinks (const char *pathspec);
4287	+	int make_executable (const char *path);
4288	+	int check_executable (const char *path);
4289	+	char *strendzap (char *str, const char *pat);
4290	+	void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4291	+	void lt_fatal (const char *file, int line, const char *message, ...);
4292	+	static const char *nonnull (const char *s);
4293	+	static const char *nonempty (const char *s);
4294	+	void lt_setenv (const char *name, const char *value);
4295	+	char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4296	+	void lt_update_exe_path (const char *name, const char *value);
4297	+	void lt_update_lib_path (const char *name, const char *value);
4298	+	char **prepare_spawn (char **argv);
4299	+	void lt_dump_script (FILE *f);
4300	+	EOF
4301	+
4302	+	cat <<EOF
4303	+	volatile const char * MAGIC_EXE = "$magic_exe";
4304	+	const char * LIB_PATH_VARNAME = "$shlibpath_var";
4305	+	EOF
4306	+
4307	+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4308	+	func_to_host_path "$temp_rpath"
4309	+	cat <<EOF
4310	+	const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
4311	+	EOF
4312	+	else
4313	+	cat <<"EOF"
4314	+	const char * LIB_PATH_VALUE   = "";
4315	+	EOF
4316	+	fi
4317	+
4318	+	if test -n "$dllsearchpath"; then
4319	+	func_to_host_path "$dllsearchpath:"
4320	+	cat <<EOF
4321	+	const char * EXE_PATH_VARNAME = "PATH";
4322	+	const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
4323	+	EOF
4324	+	else
4325	+	cat <<"EOF"
4326	+	const char * EXE_PATH_VARNAME = "";
4327	+	const char * EXE_PATH_VALUE   = "";
4328	+	EOF
4329	+	fi
4330	+
4331	+	if test "$fast_install" = yes; then
4332	+	cat <<EOF
4333	+	const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4334	+	EOF
4335	+	else
4336	+	cat <<EOF
4337	+	const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4338	+	EOF
4339	+	fi
4340	+
4341	+
4342	+	cat <<"EOF"
4343	+
4344	+	#define LTWRAPPER_OPTION_PREFIX         "--lt-"
4345	+
4346	+	static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4347	+	static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
4348	+	static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
4349	+
4350	+	int
4351	+	main (int argc, char *argv[])
4352	+	{
4353	+	char **newargz;
4354	+	int  newargc;
4355	+	char *tmp_pathspec;
4356	+	char *actual_cwrapper_path;
4357	+	char *actual_cwrapper_name;
4358	+	char *target_name;
4359	+	char *lt_argv_zero;
4360	+	intptr_t rval = 127;
4361	+
4362	+	int i;
4363	+
4364	+	program_name = (char *) xstrdup (base_name (argv[0]));
4365	+	newargz = XMALLOC (char *, argc + 1);
4366	+
4367	+	/* very simple arg parsing; don't want to rely on getopt
4368	+	* also, copy all non cwrapper options to newargz, except
4369	+	* argz[0], which is handled differently
4370	+	*/
4371	+	newargc=0;
4372	+	for (i = 1; i < argc; i++)
4373	+	{
4374	+	if (strcmp (argv[i], dumpscript_opt) == 0)
4375	+	{
4376	+	EOF
4377	+	case "$host" in
4378	+	*mingw* | *cygwin* )
4379	+	# make stdout use "unix" line endings
4380	+	echo "          setmode(1,_O_BINARY);"
4381	+	;;
4382	+	esac
4383	+
4384	+	cat <<"EOF"
4385	+	lt_dump_script (stdout);
4386	+	return 0;
4387	+	}
4388	+	if (strcmp (argv[i], debug_opt) == 0)
4389	+	{
4390	+	lt_debug = 1;
4391	+	continue;
4392	+	}
4393	+	if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4394	+	{
4395	+	/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4396	+	namespace, but it is not one of the ones we know about and
4397	+	have already dealt with, above (inluding dump-script), then
4398	+	report an error. Otherwise, targets might begin to believe
4399	+	they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4400	+	namespace. The first time any user complains about this, we'll
4401	+	need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4402	+	or a configure.ac-settable value.
4403	+	*/
4404	+	lt_fatal (__FILE__, __LINE__,
4405	+	"unrecognized %s option: '%s'",
4406	+	ltwrapper_option_prefix, argv[i]);
4407	+	}
4408	+	/* otherwise ... */
4409	+	newargz[++newargc] = xstrdup (argv[i]);
4410	+	}
4411	+	newargz[++newargc] = NULL;
4412	+
4413	+	EOF
4414	+	cat <<EOF
4415	+	/* The GNU banner must be the first non-error debug message */
4416	+	lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4417	+	EOF
4418	+	cat <<"EOF"
4419	+	lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4420	+	lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4421	+
4422	+	tmp_pathspec = find_executable (argv[0]);
4423	+	if (tmp_pathspec == NULL)
4424	+	lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4425	+	lt_debugprintf (__FILE__, __LINE__,
4426	+	"(main) found exe (before symlink chase) at: %s\n",
4427	+	tmp_pathspec);
4428	+
4429	+	actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4430	+	lt_debugprintf (__FILE__, __LINE__,
4431	+	"(main) found exe (after symlink chase) at: %s\n",
4432	+	actual_cwrapper_path);
4433	+	XFREE (tmp_pathspec);
4434	+
4435	+	actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4436	+	strendzap (actual_cwrapper_path, actual_cwrapper_name);
4437	+
4438	+	/* wrapper name transforms */
4439	+	strendzap (actual_cwrapper_name, ".exe");
4440	+	tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4441	+	XFREE (actual_cwrapper_name);
4442	+	actual_cwrapper_name = tmp_pathspec;
4443	+	tmp_pathspec = 0;
4444	+
4445	+	/* target_name transforms -- use actual target program name; might have lt- prefix */
4446	+	target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4447	+	strendzap (target_name, ".exe");
4448	+	tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4449	+	XFREE (target_name);
4450	+	target_name = tmp_pathspec;
4451	+	tmp_pathspec = 0;
4452	+
4453	+	lt_debugprintf (__FILE__, __LINE__,
4454	+	"(main) libtool target name: %s\n",
4455	+	target_name);
4456	+	EOF
4457	+
4458	+	cat <<EOF
4459	+	newargz[0] =
4460	+	XMALLOC (char, (strlen (actual_cwrapper_path) +
4461	+	strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4462	+	strcpy (newargz[0], actual_cwrapper_path);
4463	+	strcat (newargz[0], "$objdir");
4464	+	strcat (newargz[0], "/");
4465	+	EOF
4466	+
4467	+	cat <<"EOF"
4468	+	/* stop here, and copy so we don't have to do this twice */
4469	+	tmp_pathspec = xstrdup (newargz[0]);
4470	+
4471	+	/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4472	+	strcat (newargz[0], actual_cwrapper_name);
4473	+
4474	+	/* DO want the lt- prefix here if it exists, so use target_name */
4475	+	lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4476	+	XFREE (tmp_pathspec);
4477	+	tmp_pathspec = NULL;
4478	+	EOF
4479	+
4480	+	case $host_os in
4481	+	mingw*)
4482	+	cat <<"EOF"
4483	+	{
4484	+	char* p;
4485	+	while ((p = strchr (newargz[0], '\\')) != NULL)
4486	+	{
4487	+	*p = '/';
4488	+	}
4489	+	while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4490	+	{
4491	+	*p = '/';
4492	+	}
4493	+	}
4494	+	EOF
4495	+	;;
4496	+	esac
4497	+
4498	+	cat <<"EOF"
4499	+	XFREE (target_name);
4500	+	XFREE (actual_cwrapper_path);
4501	+	XFREE (actual_cwrapper_name);
4502	+
4503	+	lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4504	+	lt_setenv ("DUALCASE", "1");  /* for MSK sh */
4505	+	/* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
4506	+	be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4507	+	because on Windows, both *_VARNAMEs are PATH but uninstalled
4508	+	libraries must come first. */
4509	+	lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4510	+	lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4511	+
4512	+	lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513	+	nonnull (lt_argv_zero));
4514	+	for (i = 0; i < newargc; i++)
4515	+	{
4516	+	lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517	+	i, nonnull (newargz[i]));
4518	+	}
4519	+
4520	+	EOF
4521	+
4522	+	case $host_os in
4523	+	mingw*)
4524	+	cat <<"EOF"
4525	+	/* execv doesn't actually work on mingw as expected on unix */
4526	+	newargz = prepare_spawn (newargz);
4527	+	rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4528	+	if (rval == -1)
4529	+	{
4530	+	/* failed to start process */
4531	+	lt_debugprintf (__FILE__, __LINE__,
4532	+	"(main) failed to launch target \"%s\": %s\n",
4533	+	lt_argv_zero, nonnull (strerror (errno)));
4534	+	return 127;
4535	+	}
4536	+	return rval;
4537	+	EOF
4538	+	;;
4539	+	*)
4540	+	cat <<"EOF"
4541	+	execv (lt_argv_zero, newargz);
4542	+	return rval; /* =127, but avoids unused variable warning */
4543	+	EOF
4544	+	;;
4545	+	esac
4546
4547	<	# libtool link mode
4548	<	link | relink)
4549	<	modename="$modename: link"
4547	>	cat <<"EOF"
4548	>	}
4549	>
4550	>	void *
4551	>	xmalloc (size_t num)
4552	>	{
4553	>	void *p = (void *) malloc (num);
4554	>	if (!p)
4555	>	lt_fatal (__FILE__, __LINE__, "memory exhausted");
4556	>
4557	>	return p;
4558	>	}
4559	>
4560	>	char *
4561	>	xstrdup (const char *string)
4562	>	{
4563	>	return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4564	>	string) : NULL;
4565	>	}
4566	>
4567	>	const char *
4568	>	base_name (const char *name)
4569	>	{
4570	>	const char *base;
4571	>
4572	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4573	>	/* Skip over the disk name in MSDOS pathnames. */
4574	>	if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4575	>	name += 2;
4576	>	#endif
4577	>
4578	>	for (base = name; *name; name++)
4579	>	if (IS_DIR_SEPARATOR (*name))
4580	>	base = name + 1;
4581	>	return base;
4582	>	}
4583	>
4584	>	int
4585	>	check_executable (const char *path)
4586	>	{
4587	>	struct stat st;
4588	>
4589	>	lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4590	>	nonempty (path));
4591	>	if ((!path) || (!*path))
4592	>	return 0;
4593	>
4594	>	if ((stat (path, &st) >= 0)
4595	>	&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4596	>	return 1;
4597	>	else
4598	>	return 0;
4599	>	}
4600	>
4601	>	int
4602	>	make_executable (const char *path)
4603	>	{
4604	>	int rval = 0;
4605	>	struct stat st;
4606	>
4607	>	lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4608	>	nonempty (path));
4609	>	if ((!path) || (!*path))
4610	>	return 0;
4611	>
4612	>	if (stat (path, &st) >= 0)
4613	>	{
4614	>	rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4615	>	}
4616	>	return rval;
4617	>	}
4618	>
4619	>	/* Searches for the full path of the wrapper.  Returns
4620	>	newly allocated full path name if found, NULL otherwise
4621	>	Does not chase symlinks, even on platforms that support them.
4622	>	*/
4623	>	char *
4624	>	find_executable (const char *wrapper)
4625	>	{
4626	>	int has_slash = 0;
4627	>	const char *p;
4628	>	const char *p_next;
4629	>	/* static buffer for getcwd */
4630	>	char tmp[LT_PATHMAX + 1];
4631	>	int tmp_len;
4632	>	char *concat_name;
4633	>
4634	>	lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4635	>	nonempty (wrapper));
4636	>
4637	>	if ((wrapper == NULL) || (*wrapper == '\0'))
4638	>	return NULL;
4639	>
4640	>	/* Absolute path? */
4641	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4642	>	if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4643	>	{
4644	>	concat_name = xstrdup (wrapper);
4645	>	if (check_executable (concat_name))
4646	>	return concat_name;
4647	>	XFREE (concat_name);
4648	>	}
4649	>	else
4650	>	{
4651	>	#endif
4652	>	if (IS_DIR_SEPARATOR (wrapper[0]))
4653	>	{
4654	>	concat_name = xstrdup (wrapper);
4655	>	if (check_executable (concat_name))
4656	>	return concat_name;
4657	>	XFREE (concat_name);
4658	>	}
4659	>	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4660	>	}
4661	>	#endif
4662	>
4663	>	for (p = wrapper; *p; p++)
4664	>	if (*p == '/')
4665	>	{
4666	>	has_slash = 1;
4667	>	break;
4668	>	}
4669	>	if (!has_slash)
4670	>	{
4671	>	/* no slashes; search PATH */
4672	>	const char *path = getenv ("PATH");
4673	>	if (path != NULL)
4674	>	{
4675	>	for (p = path; *p; p = p_next)
4676	>	{
4677	>	const char *q;
4678	>	size_t p_len;
4679	>	for (q = p; *q; q++)
4680	>	if (IS_PATH_SEPARATOR (*q))
4681	>	break;
4682	>	p_len = q - p;
4683	>	p_next = (*q == '\0' ? q : q + 1);
4684	>	if (p_len == 0)
4685	>	{
4686	>	/* empty path: current directory */
4687	>	if (getcwd (tmp, LT_PATHMAX) == NULL)
4688	>	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4689	>	nonnull (strerror (errno)));
4690	>	tmp_len = strlen (tmp);
4691	>	concat_name =
4692	>	XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4693	>	memcpy (concat_name, tmp, tmp_len);
4694	>	concat_name[tmp_len] = '/';
4695	>	strcpy (concat_name + tmp_len + 1, wrapper);
4696	>	}
4697	>	else
4698	>	{
4699	>	concat_name =
4700	>	XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4701	>	memcpy (concat_name, p, p_len);
4702	>	concat_name[p_len] = '/';
4703	>	strcpy (concat_name + p_len + 1, wrapper);
4704	>	}
4705	>	if (check_executable (concat_name))
4706	>	return concat_name;
4707	>	XFREE (concat_name);
4708	>	}
4709	>	}
4710	>	/* not found in PATH; assume curdir */
4711	>	}
4712	>	/* Relative path | not found in path: prepend cwd */
4713	>	if (getcwd (tmp, LT_PATHMAX) == NULL)
4714	>	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4715	>	nonnull (strerror (errno)));
4716	>	tmp_len = strlen (tmp);
4717	>	concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4718	>	memcpy (concat_name, tmp, tmp_len);
4719	>	concat_name[tmp_len] = '/';
4720	>	strcpy (concat_name + tmp_len + 1, wrapper);
4721	>
4722	>	if (check_executable (concat_name))
4723	>	return concat_name;
4724	>	XFREE (concat_name);
4725	>	return NULL;
4726	>	}
4727	>
4728	>	char *
4729	>	chase_symlinks (const char *pathspec)
4730	>	{
4731	>	#ifndef S_ISLNK
4732	>	return xstrdup (pathspec);
4733	>	#else
4734	>	char buf[LT_PATHMAX];
4735	>	struct stat s;
4736	>	char *tmp_pathspec = xstrdup (pathspec);
4737	>	char *p;
4738	>	int has_symlinks = 0;
4739	>	while (strlen (tmp_pathspec) && !has_symlinks)
4740	>	{
4741	>	lt_debugprintf (__FILE__, __LINE__,
4742	>	"checking path component for symlinks: %s\n",
4743	>	tmp_pathspec);
4744	>	if (lstat (tmp_pathspec, &s) == 0)
4745	>	{
4746	>	if (S_ISLNK (s.st_mode) != 0)
4747	>	{
4748	>	has_symlinks = 1;
4749	>	break;
4750	>	}
4751	>
4752	>	/* search backwards for last DIR_SEPARATOR */
4753	>	p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4754	>	while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4755	>	p--;
4756	>	if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4757	>	{
4758	>	/* no more DIR_SEPARATORS left */
4759	>	break;
4760	>	}
4761	>	*p = '\0';
4762	>	}
4763	>	else
4764	>	{
4765	>	lt_fatal (__FILE__, __LINE__,
4766	>	"error accessing file \"%s\": %s",
4767	>	tmp_pathspec, nonnull (strerror (errno)));
4768	>	}
4769	>	}
4770	>	XFREE (tmp_pathspec);
4771	>
4772	>	if (!has_symlinks)
4773	>	{
4774	>	return xstrdup (pathspec);
4775	>	}
4776	>
4777	>	tmp_pathspec = realpath (pathspec, buf);
4778	>	if (tmp_pathspec == 0)
4779	>	{
4780	>	lt_fatal (__FILE__, __LINE__,
4781	>	"could not follow symlinks for %s", pathspec);
4782	>	}
4783	>	return xstrdup (tmp_pathspec);
4784	>	#endif
4785	>	}
4786	>
4787	>	char *
4788	>	strendzap (char *str, const char *pat)
4789	>	{
4790	>	size_t len, patlen;
4791	>
4792	>	assert (str != NULL);
4793	>	assert (pat != NULL);
4794	>
4795	>	len = strlen (str);
4796	>	patlen = strlen (pat);
4797	>
4798	>	if (patlen <= len)
4799	>	{
4800	>	str += len - patlen;
4801	>	if (strcmp (str, pat) == 0)
4802	>	*str = '\0';
4803	>	}
4804	>	return str;
4805	>	}
4806	>
4807	>	void
4808	>	lt_debugprintf (const char *file, int line, const char *fmt, ...)
4809	>	{
4810	>	va_list args;
4811	>	if (lt_debug)
4812	>	{
4813	>	(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4814	>	va_start (args, fmt);
4815	>	(void) vfprintf (stderr, fmt, args);
4816	>	va_end (args);
4817	>	}
4818	>	}
4819	>
4820	>	static void
4821	>	lt_error_core (int exit_status, const char *file,
4822	>	int line, const char *mode,
4823	>	const char *message, va_list ap)
4824	>	{
4825	>	fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4826	>	vfprintf (stderr, message, ap);
4827	>	fprintf (stderr, ".\n");
4828	>
4829	>	if (exit_status >= 0)
4830	>	exit (exit_status);
4831	>	}
4832	>
4833	>	void
4834	>	lt_fatal (const char *file, int line, const char *message, ...)
4835	>	{
4836	>	va_list ap;
4837	>	va_start (ap, message);
4838	>	lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4839	>	va_end (ap);
4840	>	}
4841	>
4842	>	static const char *
4843	>	nonnull (const char *s)
4844	>	{
4845	>	return s ? s : "(null)";
4846	>	}
4847	>
4848	>	static const char *
4849	>	nonempty (const char *s)
4850	>	{
4851	>	return (s && !*s) ? "(empty)" : nonnull (s);
4852	>	}
4853	>
4854	>	void
4855	>	lt_setenv (const char *name, const char *value)
4856	>	{
4857	>	lt_debugprintf (__FILE__, __LINE__,
4858	>	"(lt_setenv) setting '%s' to '%s'\n",
4859	>	nonnull (name), nonnull (value));
4860	>	{
4861	>	#ifdef HAVE_SETENV
4862	>	/* always make a copy, for consistency with !HAVE_SETENV */
4863	>	char *str = xstrdup (value);
4864	>	setenv (name, str, 1);
4865	>	#else
4866	>	int len = strlen (name) + 1 + strlen (value) + 1;
4867	>	char *str = XMALLOC (char, len);
4868	>	sprintf (str, "%s=%s", name, value);
4869	>	if (putenv (str) != EXIT_SUCCESS)
4870	>	{
4871	>	XFREE (str);
4872	>	}
4873	>	#endif
4874	>	}
4875	>	}
4876	>
4877	>	char *
4878	>	lt_extend_str (const char *orig_value, const char *add, int to_end)
4879	>	{
4880	>	char *new_value;
4881	>	if (orig_value && *orig_value)
4882	>	{
4883	>	int orig_value_len = strlen (orig_value);
4884	>	int add_len = strlen (add);
4885	>	new_value = XMALLOC (char, add_len + orig_value_len + 1);
4886	>	if (to_end)
4887	>	{
4888	>	strcpy (new_value, orig_value);
4889	>	strcpy (new_value + orig_value_len, add);
4890	>	}
4891	>	else
4892	>	{
4893	>	strcpy (new_value, add);
4894	>	strcpy (new_value + add_len, orig_value);
4895	>	}
4896	>	}
4897	>	else
4898	>	{
4899	>	new_value = xstrdup (add);
4900	>	}
4901	>	return new_value;
4902	>	}
4903	>
4904	>	void
4905	>	lt_update_exe_path (const char *name, const char *value)
4906	>	{
4907	>	lt_debugprintf (__FILE__, __LINE__,
4908	>	"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909	>	nonnull (name), nonnull (value));
4910	>
4911	>	if (name && *name && value && *value)
4912	>	{
4913	>	char *new_value = lt_extend_str (getenv (name), value, 0);
4914	>	/* some systems can't cope with a ':'-terminated path #' */
4915	>	int len = strlen (new_value);
4916	>	while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4917	>	{
4918	>	new_value[len-1] = '\0';
4919	>	}
4920	>	lt_setenv (name, new_value);
4921	>	XFREE (new_value);
4922	>	}
4923	>	}
4924	>
4925	>	void
4926	>	lt_update_lib_path (const char *name, const char *value)
4927	>	{
4928	>	lt_debugprintf (__FILE__, __LINE__,
4929	>	"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930	>	nonnull (name), nonnull (value));
4931	>
4932	>	if (name && *name && value && *value)
4933	>	{
4934	>	char *new_value = lt_extend_str (getenv (name), value, 0);
4935	>	lt_setenv (name, new_value);
4936	>	XFREE (new_value);
4937	>	}
4938	>	}
4939	>
4940	>	EOF
4941	>	case $host_os in
4942	>	mingw*)
4943	>	cat <<"EOF"
4944	>
4945	>	/* Prepares an argument vector before calling spawn().
4946	>	Note that spawn() does not by itself call the command interpreter
4947	>	(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4948	>	({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4949	>	GetVersionEx(&v);
4950	>	v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4951	>	}) ? "cmd.exe" : "command.com").
4952	>	Instead it simply concatenates the arguments, separated by ' ', and calls
4953	>	CreateProcess().  We must quote the arguments since Win32 CreateProcess()
4954	>	interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4955	>	special way:
4956	>	- Space and tab are interpreted as delimiters. They are not treated as
4957	>	delimiters if they are surrounded by double quotes: "...".
4958	>	- Unescaped double quotes are removed from the input. Their only effect is
4959	>	that within double quotes, space and tab are treated like normal
4960	>	characters.
4961	>	- Backslashes not followed by double quotes are not special.
4962	>	- But 2*n+1 backslashes followed by a double quote become
4963	>	n backslashes followed by a double quote (n >= 0):
4964	>	\" -> "
4965	>	\\\" -> \"
4966	>	\\\\\" -> \\"
4967	>	*/
4968	>	#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4969	>	#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4970	>	char **
4971	>	prepare_spawn (char **argv)
4972	>	{
4973	>	size_t argc;
4974	>	char **new_argv;
4975	>	size_t i;
4976	>
4977	>	/* Count number of arguments.  */
4978	>	for (argc = 0; argv[argc] != NULL; argc++)
4979	>	;
4980	>
4981	>	/* Allocate new argument vector.  */
4982	>	new_argv = XMALLOC (char *, argc + 1);
4983	>
4984	>	/* Put quoted arguments into the new argument vector.  */
4985	>	for (i = 0; i < argc; i++)
4986	>	{
4987	>	const char *string = argv[i];
4988	>
4989	>	if (string[0] == '\0')
4990	>	new_argv[i] = xstrdup ("\"\"");
4991	>	else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4992	>	{
4993	>	int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4994	>	size_t length;
4995	>	unsigned int backslashes;
4996	>	const char *s;
4997	>	char *quoted_string;
4998	>	char *p;
4999	>
5000	>	length = 0;
5001	>	backslashes = 0;
5002	>	if (quote_around)
5003	>	length++;
5004	>	for (s = string; *s != '\0'; s++)
5005	>	{
5006	>	char c = *s;
5007	>	if (c == '"')
5008	>	length += backslashes + 1;
5009	>	length++;
5010	>	if (c == '\\')
5011	>	backslashes++;
5012	>	else
5013	>	backslashes = 0;
5014	>	}
5015	>	if (quote_around)
5016	>	length += backslashes + 1;
5017	>
5018	>	quoted_string = XMALLOC (char, length + 1);
5019	>
5020	>	p = quoted_string;
5021	>	backslashes = 0;
5022	>	if (quote_around)
5023	>	*p++ = '"';
5024	>	for (s = string; *s != '\0'; s++)
5025	>	{
5026	>	char c = *s;
5027	>	if (c == '"')
5028	>	{
5029	>	unsigned int j;
5030	>	for (j = backslashes + 1; j > 0; j--)
5031	>	*p++ = '\\';
5032	>	}
5033	>	*p++ = c;
5034	>	if (c == '\\')
5035	>	backslashes++;
5036	>	else
5037	>	backslashes = 0;
5038	>	}
5039	>	if (quote_around)
5040	>	{
5041	>	unsigned int j;
5042	>	for (j = backslashes; j > 0; j--)
5043	>	*p++ = '\\';
5044	>	*p++ = '"';
5045	>	}
5046	>	*p = '\0';
5047	>
5048	>	new_argv[i] = quoted_string;
5049	>	}
5050	>	else
5051	>	new_argv[i] = (char *) string;
5052	>	}
5053	>	new_argv[argc] = NULL;
5054	>
5055	>	return new_argv;
5056	>	}
5057	>	EOF
5058	>	;;
5059	>	esac
5060	>
5061	>	cat <<"EOF"
5062	>	void lt_dump_script (FILE* f)
5063	>	{
5064	>	EOF
5065	>	func_emit_wrapper yes |
5066	>	$SED -n -e '
5067	>	s/^\(.\{79\}\)\(..*\)/\1\
5068	>	\2/
5069	>	h
5070	>	s/\([\\"]\)/\\\1/g
5071	>	s/$/\\n/
5072	>	s/\([^\n]*\).*/  fputs ("\1", f);/p
5073	>	g
5074	>	D'
5075	>	cat <<"EOF"
5076	>	}
5077	>	EOF
5078	>	}
5079	>	# end: func_emit_cwrapperexe_src
5080	>
5081	>	# func_win32_import_lib_p ARG
5082	>	# True if ARG is an import lib, as indicated by $file_magic_cmd
5083	>	func_win32_import_lib_p ()
5084	>	{
5085	>	$opt_debug
5086	>	case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5087	>	*import*) : ;;
5088	>	*) false ;;
5089	>	esac
5090	>	}
5091	>
5092	>	# func_mode_link arg...
5093	>	func_mode_link ()
5094	>	{
5095	>	$opt_debug
5096		case $host in
5097	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
5097	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5098		# It is impossible to link a dll without this setting, and
5099		# we shouldn't force the makefile maintainer to figure out
5100		# which system we are compiling for in order to pass an extra
#	Line 851 | Line 5112 | EOF
5112		allow_undefined=yes
5113		;;
5114		esac
5115	<	libtool_args="$nonopt"
5116	<	base_compile="$nonopt"
5117	<	compile_command="$nonopt"
5118	<	finalize_command="$nonopt"
5115	>	libtool_args=$nonopt
5116	>	base_compile="$nonopt $@"
5117	>	compile_command=$nonopt
5118	>	finalize_command=$nonopt
5119
5120		compile_rpath=
5121		finalize_rpath=
#	Line 869 | Line 5130 | EOF
5130		dllsearchpath=
5131		lib_search_path=`pwd`
5132		inst_prefix_dir=
5133	+	new_inherited_linker_flags=
5134
5135		avoid_version=no
5136	+	bindir=
5137		dlfiles=
5138		dlprefiles=
5139		dlself=no
#	Line 884 | Line 5147 | EOF
5147		no_install=no
5148		objs=
5149		non_pic_objects=
5150	+	precious_files_regex=
5151		prefer_static_libs=no
5152		preload=no
5153		prev=
#	Line 896 | Line 5160 | EOF
5160		thread_safe=no
5161		vinfo=
5162		vinfo_number=no
5163	+	weak_libs=
5164	+	single_module="${wl}-single_module"
5165	+	func_infer_tag $base_compile
5166
5167		# We need to know -static, to get the right output filenames.
5168		for arg
5169		do
5170		case $arg in
5171	<	-all-static | -static)
5172	<	if test "X$arg" = "X-all-static"; then
5171	>	-shared)
5172	>	test "$build_libtool_libs" != yes && \
5173	>	func_fatal_configuration "can not build a shared library"
5174	>	build_old_libs=no
5175	>	break
5176	>	;;
5177	>	-all-static | -static | -static-libtool-libs)
5178	>	case $arg in
5179	>	-all-static)
5180		if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5181	<	$echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
5181	>	func_warning "complete static linking is impossible in this configuration"
5182		fi
5183		if test -n "$link_static_flag"; then
5184		dlopen_self=$dlopen_self_static
5185		fi
5186	<	else
5186	>	prefer_static_libs=yes
5187	>	;;
5188	>	-static)
5189		if test -z "$pic_flag" && test -n "$link_static_flag"; then
5190		dlopen_self=$dlopen_self_static
5191		fi
5192	<	fi
5192	>	prefer_static_libs=built
5193	>	;;
5194	>	-static-libtool-libs)
5195	>	if test -z "$pic_flag" && test -n "$link_static_flag"; then
5196	>	dlopen_self=$dlopen_self_static
5197	>	fi
5198	>	prefer_static_libs=yes
5199	>	;;
5200	>	esac
5201		build_libtool_libs=no
5202		build_old_libs=yes
919	–	prefer_static_libs=yes
5203		break
5204		;;
5205		esac
#	Line 928 | Line 5211 | EOF
5211		# Go through the arguments, transforming them on the way.
5212		while test "$#" -gt 0; do
5213		arg="$1"
931	–	base_compile="$base_compile $arg"
5214		shift
5215	<	case $arg in
5216	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5217	<	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
936	<	;;
937	<	*) qarg=$arg ;;
938	<	esac
939	<	libtool_args="$libtool_args $qarg"
5215	>	func_quote_for_eval "$arg"
5216	>	qarg=$func_quote_for_eval_unquoted_result
5217	>	func_append libtool_args " $func_quote_for_eval_result"
5218
5219		# If the previous option needs an argument, assign it.
5220		if test -n "$prev"; then
5221		case $prev in
5222		output)
5223	<	compile_command="$compile_command @OUTPUT@"
5224	<	finalize_command="$finalize_command @OUTPUT@"
5223	>	func_append compile_command " @OUTPUT@"
5224	>	func_append finalize_command " @OUTPUT@"
5225		;;
5226		esac
5227
5228		case $prev in
5229	+	bindir)
5230	+	bindir="$arg"
5231	+	prev=
5232	+	continue
5233	+	;;
5234		dlfiles|dlprefiles)
5235		if test "$preload" = no; then
5236		# Add the symbol object into the linking commands.
5237	<	compile_command="$compile_command @SYMFILE@"
5238	<	finalize_command="$finalize_command @SYMFILE@"
5237	>	func_append compile_command " @SYMFILE@"
5238	>	func_append finalize_command " @SYMFILE@"
5239		preload=yes
5240		fi
5241		case $arg in
#	Line 979 | Line 5262 | EOF
5262		;;
5263		*)
5264		if test "$prev" = dlfiles; then
5265	<	dlfiles="$dlfiles $arg"
5265	>	func_append dlfiles " $arg"
5266		else
5267	<	dlprefiles="$dlprefiles $arg"
5267	>	func_append dlprefiles " $arg"
5268		fi
5269		prev=
5270		continue
#	Line 990 | Line 5273 | EOF
5273		;;
5274		expsyms)
5275		export_symbols="$arg"
5276	<	if test ! -f "$arg"; then
5277	<	$echo "$modename: symbol file \`$arg' does not exist"
995	<	exit 1
996	<	fi
5276	>	test -f "$arg" \
5277	>	|| func_fatal_error "symbol file \`$arg' does not exist"
5278		prev=
5279		continue
5280		;;
#	Line 1002 | Line 5283 | EOF
5283		prev=
5284		continue
5285		;;
5286	<	inst_prefix)
5287	<	inst_prefix_dir="$arg"
5286	>	framework)
5287	>	case $host in
5288	>	*-*-darwin*)
5289	>	case "$deplibs " in
5290	>	*" $qarg.ltframework "*) ;;
5291	>	*) func_append deplibs " $qarg.ltframework" # this is fixed later
5292	>	;;
5293	>	esac
5294	>	;;
5295	>	esac
5296		prev=
5297		continue
5298		;;
5299	<	release)
5300	<	release="-$arg"
5299	>	inst_prefix)
5300	>	inst_prefix_dir="$arg"
5301		prev=
5302		continue
5303		;;
#	Line 1016 | Line 5305 | EOF
5305		if test -f "$arg"; then
5306		save_arg=$arg
5307		moreargs=
5308	<	for fil in `cat $save_arg`
5308	>	for fil in `cat "$save_arg"`
5309		do
5310	<	#             moreargs="$moreargs $fil"
5310	>	#             func_append moreargs " $fil"
5311		arg=$fil
5312		# A libtool-controlled object.
5313
5314		# Check to see that this really is a libtool object.
5315	<	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5315	>	if func_lalib_unsafe_p "$arg"; then
5316		pic_object=
5317		non_pic_object=
5318
5319		# Read the .lo file
5320	<	# If there is no directory component, then add one.
1032	<	case $arg in
1033	<	*/* | *\\*) . $arg ;;
1034	<	*) . ./$arg ;;
1035	<	esac
5320	>	func_source "$arg"
5321
5322	<	if test -z "$pic_object" || \
5322	>	if test -z "$pic_object" ||
5323		test -z "$non_pic_object" ||
5324	<	test "$pic_object" = none && \
5324	>	test "$pic_object" = none &&
5325		test "$non_pic_object" = none; then
5326	<	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
1042	<	exit 1
5326	>	func_fatal_error "cannot find name of object for \`$arg'"
5327		fi
5328
5329		# Extract subdirectory from the argument.
5330	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
5331	<	if test "X$xdir" = "X$arg"; then
1048	<	xdir=
1049	<	else
1050	<	xdir="$xdir/"
1051	<	fi
5330	>	func_dirname "$arg" "/" ""
5331	>	xdir="$func_dirname_result"
5332
5333		if test "$pic_object" != none; then
5334		# Prepend the subdirectory the object is found in.
#	Line 1056 | Line 5336 | EOF
5336
5337		if test "$prev" = dlfiles; then
5338		if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5339	<	dlfiles="$dlfiles $pic_object"
5339	>	func_append dlfiles " $pic_object"
5340		prev=
5341		continue
5342		else
#	Line 1068 | Line 5348 | EOF
5348		# CHECK ME:  I think I busted this.  -Ossama
5349		if test "$prev" = dlprefiles; then
5350		# Preload the old-style object.
5351	<	dlprefiles="$dlprefiles $pic_object"
5351	>	func_append dlprefiles " $pic_object"
5352		prev=
5353		fi
5354
5355		# A PIC object.
5356	<	libobjs="$libobjs $pic_object"
5356	>	func_append libobjs " $pic_object"
5357		arg="$pic_object"
5358		fi
5359
#	Line 1083 | Line 5363 | EOF
5363		non_pic_object="$xdir$non_pic_object"
5364
5365		# A standard non-PIC object
5366	<	non_pic_objects="$non_pic_objects $non_pic_object"
5366	>	func_append non_pic_objects " $non_pic_object"
5367		if test -z "$pic_object" || test "$pic_object" = none ; then
5368		arg="$non_pic_object"
5369		fi
5370	+	else
5371	+	# If the PIC object exists, use it instead.
5372	+	# $xdir was prepended to $pic_object above.
5373	+	non_pic_object="$pic_object"
5374	+	func_append non_pic_objects " $non_pic_object"
5375		fi
5376		else
5377		# Only an error if not doing a dry-run.
5378	<	if test -z "$run"; then
1094	<	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1095	<	exit 1
1096	<	else
1097	<	# Dry-run case.
1098	<
5378	>	if $opt_dry_run; then
5379		# Extract subdirectory from the argument.
5380	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
5381	<	if test "X$xdir" = "X$arg"; then
1102	<	xdir=
1103	<	else
1104	<	xdir="$xdir/"
1105	<	fi
5380	>	func_dirname "$arg" "/" ""
5381	>	xdir="$func_dirname_result"
5382
5383	<	pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
5384	<	non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
5385	<	libobjs="$libobjs $pic_object"
5386	<	non_pic_objects="$non_pic_objects $non_pic_object"
5383	>	func_lo2o "$arg"
5384	>	pic_object=$xdir$objdir/$func_lo2o_result
5385	>	non_pic_object=$xdir$func_lo2o_result
5386	>	func_append libobjs " $pic_object"
5387	>	func_append non_pic_objects " $non_pic_object"
5388	>	else
5389	>	func_fatal_error "\`$arg' is not a valid libtool object"
5390		fi
5391		fi
5392		done
5393		else
5394	<	$echo "$modename: link input file \`$save_arg' does not exist"
1116	<	exit 1
5394	>	func_fatal_error "link input file \`$arg' does not exist"
5395		fi
5396		arg=$save_arg
5397		prev=
5398		continue
5399		;;
5400	+	precious_regex)
5401	+	precious_files_regex="$arg"
5402	+	prev=
5403	+	continue
5404	+	;;
5405	+	release)
5406	+	release="-$arg"
5407	+	prev=
5408	+	continue
5409	+	;;
5410		rpath | xrpath)
5411		# We need an absolute path.
5412		case $arg in
5413		[\\/]* | [A-Za-z]:[\\/]*) ;;
5414		*)
5415	<	$echo "$modename: only absolute run-paths are allowed" 1>&2
1128	<	exit 1
5415	>	func_fatal_error "only absolute run-paths are allowed"
5416		;;
5417		esac
5418		if test "$prev" = rpath; then
5419		case "$rpath " in
5420		*" $arg "*) ;;
5421	<	*) rpath="$rpath $arg" ;;
5421	>	*) func_append rpath " $arg" ;;
5422		esac
5423		else
5424		case "$xrpath " in
5425		*" $arg "*) ;;
5426	<	*) xrpath="$xrpath $arg" ;;
5426	>	*) func_append xrpath " $arg" ;;
5427		esac
5428		fi
5429		prev=
5430		continue
5431		;;
5432	<	xcompiler)
5433	<	compiler_flags="$compiler_flags $qarg"
5432	>	shrext)
5433	>	shrext_cmds="$arg"
5434		prev=
1148	–	compile_command="$compile_command $qarg"
1149	–	finalize_command="$finalize_command $qarg"
5435		continue
5436		;;
5437	<	xlinker)
5438	<	linker_flags="$linker_flags $qarg"
1154	<	compiler_flags="$compiler_flags $wl$qarg"
5437	>	weak)
5438	>	func_append weak_libs " $arg"
5439		prev=
1156	–	compile_command="$compile_command $wl$qarg"
1157	–	finalize_command="$finalize_command $wl$qarg"
5440		continue
5441		;;
5442		xcclinker)
5443	<	linker_flags="$linker_flags $qarg"
5444	<	compiler_flags="$compiler_flags $qarg"
5443	>	func_append linker_flags " $qarg"
5444	>	func_append compiler_flags " $qarg"
5445	>	prev=
5446	>	func_append compile_command " $qarg"
5447	>	func_append finalize_command " $qarg"
5448	>	continue
5449	>	;;
5450	>	xcompiler)
5451	>	func_append compiler_flags " $qarg"
5452	>	prev=
5453	>	func_append compile_command " $qarg"
5454	>	func_append finalize_command " $qarg"
5455	>	continue
5456	>	;;
5457	>	xlinker)
5458	>	func_append linker_flags " $qarg"
5459	>	func_append compiler_flags " $wl$qarg"
5460		prev=
5461	<	compile_command="$compile_command $qarg"
5462	<	finalize_command="$finalize_command $qarg"
5461	>	func_append compile_command " $wl$qarg"
5462	>	func_append finalize_command " $wl$qarg"
5463		continue
5464		;;
5465		*)
#	Line 1178 | Line 5475 | EOF
5475		case $arg in
5476		-all-static)
5477		if test -n "$link_static_flag"; then
5478	<	compile_command="$compile_command $link_static_flag"
5479	<	finalize_command="$finalize_command $link_static_flag"
5478	>	# See comment for -static flag below, for more details.
5479	>	func_append compile_command " $link_static_flag"
5480	>	func_append finalize_command " $link_static_flag"
5481		fi
5482		continue
5483		;;
5484
5485		-allow-undefined)
5486		# FIXME: remove this flag sometime in the future.
5487	<	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1190	<	continue
5487	>	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5488		;;
5489
5490		-avoid-version)
#	Line 1195 | Line 5492 | EOF
5492		continue
5493		;;
5494
5495	+	-bindir)
5496	+	prev=bindir
5497	+	continue
5498	+	;;
5499	+
5500		-dlopen)
5501		prev=dlfiles
5502		continue
#	Line 1212 | Line 5514 | EOF
5514
5515		-export-symbols | -export-symbols-regex)
5516		if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5517	<	$echo "$modename: more than one -exported-symbols argument is not allowed"
1216	<	exit 1
5517	>	func_fatal_error "more than one -exported-symbols argument is not allowed"
5518		fi
5519		if test "X$arg" = "X-export-symbols"; then
5520		prev=expsyms
#	Line 1223 | Line 5524 | EOF
5524		continue
5525		;;
5526
5527	+	-framework)
5528	+	prev=framework
5529	+	continue
5530	+	;;
5531	+
5532		-inst-prefix-dir)
5533		prev=inst_prefix
5534		continue
#	Line 1233 | Line 5539 | EOF
5539		-L[A-Z][A-Z]*:*)
5540		case $with_gcc/$host in
5541		no/*-*-irix* | /*-*-irix*)
5542	<	compile_command="$compile_command $arg"
5543	<	finalize_command="$finalize_command $arg"
5542	>	func_append compile_command " $arg"
5543	>	func_append finalize_command " $arg"
5544		;;
5545		esac
5546		continue
5547		;;
5548
5549		-L*)
5550	<	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
5550	>	func_stripname "-L" '' "$arg"
5551	>	if test -z "$func_stripname_result"; then
5552	>	if test "$#" -gt 0; then
5553	>	func_fatal_error "require no space between \`-L' and \`$1'"
5554	>	else
5555	>	func_fatal_error "need path for \`-L' option"
5556	>	fi
5557	>	fi
5558	>	func_resolve_sysroot "$func_stripname_result"
5559	>	dir=$func_resolve_sysroot_result
5560		# We need an absolute path.
5561		case $dir in
5562		[\\/]* | [A-Za-z]:[\\/]*) ;;
5563		*)
5564		absdir=`cd "$dir" && pwd`
5565	<	if test -z "$absdir"; then
5566	<	$echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1252	<	exit 1
1253	<	fi
5565	>	test -z "$absdir" && \
5566	>	func_fatal_error "cannot determine absolute directory name of \`$dir'"
5567		dir="$absdir"
5568		;;
5569		esac
5570		case "$deplibs " in
5571	<	*" -L$dir "*) ;;
5571	>	*" -L$dir "* | *" $arg "*)
5572	>	# Will only happen for absolute or sysroot arguments
5573	>	;;
5574		*)
5575	<	deplibs="$deplibs -L$dir"
5576	<	lib_search_path="$lib_search_path $dir"
5575	>	# Preserve sysroot, but never include relative directories
5576	>	case $dir in
5577	>	[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5578	>	*) func_append deplibs " -L$dir" ;;
5579	>	esac
5580	>	func_append lib_search_path " $dir"
5581		;;
5582		esac
5583		case $host in
5584	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
5584	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5585	>	testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5586		case :$dllsearchpath: in
5587		*":$dir:"*) ;;
5588	<	*) dllsearchpath="$dllsearchpath:$dir";;
5588	>	::) dllsearchpath=$dir;;
5589	>	*) func_append dllsearchpath ":$dir";;
5590	>	esac
5591	>	case :$dllsearchpath: in
5592	>	*":$testbindir:"*) ;;
5593	>	::) dllsearchpath=$testbindir;;
5594	>	*) func_append dllsearchpath ":$testbindir";;
5595		esac
5596		;;
5597		esac
#	Line 1275 | Line 5601 | EOF
5601		-l*)
5602		if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5603		case $host in
5604	<	*-*-cygwin* | *-*-pw32* | *-*-beos*)
5604	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5605		# These systems don't actually have a C or math library (as such)
5606		continue
5607		;;
5608	<	*-*-mingw* | *-*-os2*)
5608	>	*-*-os2*)
5609		# These systems don't actually have a C library (as such)
5610		test "X$arg" = "X-lc" && continue
5611		;;
5612	<	*-*-openbsd* | *-*-freebsd*)
5612	>	*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5613		# Do not include libc due to us having libc/libc_r.
5614		test "X$arg" = "X-lc" && continue
5615		;;
5616		*-*-rhapsody* | *-*-darwin1.[012])
5617		# Rhapsody C and math libraries are in the System framework
5618	<	deplibs="$deplibs -framework System"
5618	>	func_append deplibs " System.ltframework"
5619		continue
5620	+	;;
5621	+	*-*-sco3.2v5* | *-*-sco5v6*)
5622	+	# Causes problems with __ctype
5623	+	test "X$arg" = "X-lc" && continue
5624	+	;;
5625	+	*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5626	+	# Compiler inserts libc in the correct place for threads to work
5627	+	test "X$arg" = "X-lc" && continue
5628	+	;;
5629		esac
5630		elif test "X$arg" = "X-lc_r"; then
5631		case $host in
5632	<	*-*-openbsd* | *-*-freebsd*)
5632	>	*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5633		# Do not include libc_r directly, use -pthread flag.
5634		continue
5635		;;
5636		esac
5637		fi
5638	<	deplibs="$deplibs $arg"
5638	>	func_append deplibs " $arg"
5639		continue
5640		;;
5641
#	Line 1309 | Line 5644 | EOF
5644		continue
5645		;;
5646
5647	<	# gcc -m* arguments should be passed to the linker via $compiler_flags
5648	<	# in order to pass architecture information to the linker
5649	<	# (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
5650	<	# but this is not reliable with gcc because gcc may use -mfoo to
5651	<	# select a different linker, different libraries, etc, while
5652	<	# -Wl,-mfoo simply passes -mfoo to the linker.
5653	<	-m*)
5654	<	# Unknown arguments in both finalize_command and compile_command need
5655	<	# to be aesthetically quoted because they are evaled later.
5656	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5657	<	case $arg in
5658	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
5659	<	arg="\"$arg\""
5660	<	;;
5647	>	# Tru64 UNIX uses -model [arg] to determine the layout of C++
5648	>	# classes, name mangling, and exception handling.
5649	>	# Darwin uses the -arch flag to determine output architecture.
5650	>	-model|-arch|-isysroot|--sysroot)
5651	>	func_append compiler_flags " $arg"
5652	>	func_append compile_command " $arg"
5653	>	func_append finalize_command " $arg"
5654	>	prev=xcompiler
5655	>	continue
5656	>	;;
5657	>
5658	>	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659	>	|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660	>	func_append compiler_flags " $arg"
5661	>	func_append compile_command " $arg"
5662	>	func_append finalize_command " $arg"
5663	>	case "$new_inherited_linker_flags " in
5664	>	*" $arg "*) ;;
5665	>	* ) func_append new_inherited_linker_flags " $arg" ;;
5666		esac
5667	<	compile_command="$compile_command $arg"
5668	<	finalize_command="$finalize_command $arg"
1329	<	if test "$with_gcc" = "yes" ; then
1330	<	compiler_flags="$compiler_flags $arg"
1331	<	fi
1332	<	continue
1333	<	;;
5667	>	continue
5668	>	;;
5669
5670	<	-shrext)
5671	<	prev=shrext
5670	>	-multi_module)
5671	>	single_module="${wl}-multi_module"
5672		continue
5673		;;
5674
#	Line 1344 | Line 5679 | EOF
5679
5680		-no-install)
5681		case $host in
5682	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
5682	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5683		# The PATH hackery in wrapper scripts is required on Windows
5684	<	# in order for the loader to find any dlls it needs.
5685	<	$echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
5686	<	$echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
5684	>	# and Darwin in order for the loader to find any dlls it needs.
5685	>	func_warning "\`-no-install' is ignored for $host"
5686	>	func_warning "assuming \`-no-fast-install' instead"
5687		fast_install=no
5688		;;
5689		*) no_install=yes ;;
#	Line 1368 | Line 5703 | EOF
5703
5704		-o) prev=output ;;
5705
5706	+	-precious-files-regex)
5707	+	prev=precious_regex
5708	+	continue
5709	+	;;
5710	+
5711		-release)
5712		prev=release
5713		continue
#	Line 1384 | Line 5724 | EOF
5724		;;
5725
5726		-R*)
5727	<	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
5727	>	func_stripname '-R' '' "$arg"
5728	>	dir=$func_stripname_result
5729		# We need an absolute path.
5730		case $dir in
5731		[\\/]* | [A-Za-z]:[\\/]*) ;;
5732	+	=*)
5733	+	func_stripname '=' '' "$dir"
5734	+	dir=$lt_sysroot$func_stripname_result
5735	+	;;
5736		*)
5737	<	$echo "$modename: only absolute run-paths are allowed" 1>&2
1393	<	exit 1
5737	>	func_fatal_error "only absolute run-paths are allowed"
5738		;;
5739		esac
5740		case "$xrpath " in
5741		*" $dir "*) ;;
5742	<	*) xrpath="$xrpath $dir" ;;
5742	>	*) func_append xrpath " $dir" ;;
5743		esac
5744		continue
5745		;;
5746
5747	<	-static)
5747	>	-shared)
5748	>	# The effects of -shared are defined in a previous loop.
5749	>	continue
5750	>	;;
5751	>
5752	>	-shrext)
5753	>	prev=shrext
5754	>	continue
5755	>	;;
5756	>
5757	>	-static | -static-libtool-libs)
5758		# The effects of -static are defined in a previous loop.
5759		# We used to do the same as -all-static on platforms that
5760		# didn't have a PIC flag, but the assumption that the effects
#	Line 1418 | Line 5772 | EOF
5772		prev=vinfo
5773		continue
5774		;;
5775	+
5776		-version-number)
5777		prev=vinfo
5778		vinfo_number=yes
5779		continue
5780		;;
5781
5782	+	-weak)
5783	+	prev=weak
5784	+	continue
5785	+	;;
5786	+
5787		-Wc,*)
5788	<	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
5788	>	func_stripname '-Wc,' '' "$arg"
5789	>	args=$func_stripname_result
5790		arg=
5791		save_ifs="$IFS"; IFS=','
5792		for flag in $args; do
5793		IFS="$save_ifs"
5794	<	case $flag in
5795	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5796	<	flag="\"$flag\""
1436	<	;;
1437	<	esac
1438	<	arg="$arg $wl$flag"
1439	<	compiler_flags="$compiler_flags $flag"
5794	>	func_quote_for_eval "$flag"
5795	>	func_append arg " $func_quote_for_eval_result"
5796	>	func_append compiler_flags " $func_quote_for_eval_result"
5797		done
5798		IFS="$save_ifs"
5799	<	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
5799	>	func_stripname ' ' '' "$arg"
5800	>	arg=$func_stripname_result
5801		;;
5802
5803		-Wl,*)
5804	<	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
5804	>	func_stripname '-Wl,' '' "$arg"
5805	>	args=$func_stripname_result
5806		arg=
5807		save_ifs="$IFS"; IFS=','
5808		for flag in $args; do
5809		IFS="$save_ifs"
5810	<	case $flag in
5811	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5812	<	flag="\"$flag\""
5813	<	;;
1455	<	esac
1456	<	arg="$arg $wl$flag"
1457	<	compiler_flags="$compiler_flags $wl$flag"
1458	<	linker_flags="$linker_flags $flag"
5810	>	func_quote_for_eval "$flag"
5811	>	func_append arg " $wl$func_quote_for_eval_result"
5812	>	func_append compiler_flags " $wl$func_quote_for_eval_result"
5813	>	func_append linker_flags " $func_quote_for_eval_result"
5814		done
5815		IFS="$save_ifs"
5816	<	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
5816	>	func_stripname ' ' '' "$arg"
5817	>	arg=$func_stripname_result
5818		;;
5819
5820		-Xcompiler)
#	Line 1476 | Line 5832 | EOF
5832		continue
5833		;;
5834
5835	+	# -msg_* for osf cc
5836	+	-msg_*)
5837	+	func_quote_for_eval "$arg"
5838	+	arg="$func_quote_for_eval_result"
5839	+	;;
5840	+
5841	+	# Flags to be passed through unchanged, with rationale:
5842	+	# -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
5843	+	# -r[0-9][0-9]*        specify processor for the SGI compiler
5844	+	# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5845	+	# +DA*, +DD*           enable 64-bit mode for the HP compiler
5846	+	# -q*                  compiler args for the IBM compiler
5847	+	# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5848	+	# -F/path              path to uninstalled frameworks, gcc on darwin
5849	+	# -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
5850	+	# @file                GCC response files
5851	+	# -tp=*                Portland pgcc target processor selection
5852	+	# --sysroot=*          for sysroot support
5853	+	# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5854	+	-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5855	+	-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856	+	-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5857	+	func_quote_for_eval "$arg"
5858	+	arg="$func_quote_for_eval_result"
5859	+	func_append compile_command " $arg"
5860	+	func_append finalize_command " $arg"
5861	+	func_append compiler_flags " $arg"
5862	+	continue
5863	+	;;
5864	+
5865		# Some other compiler flag.
5866		-* | +*)
5867	<	# Unknown arguments in both finalize_command and compile_command need
5868	<	# to be aesthetically quoted because they are evaled later.
1483	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1484	<	case $arg in
1485	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1486	<	arg="\"$arg\""
1487	<	;;
1488	<	esac
5867	>	func_quote_for_eval "$arg"
5868	>	arg="$func_quote_for_eval_result"
5869		;;
5870
5871		*.$objext)
5872		# A standard object.
5873	<	objs="$objs $arg"
5873	>	func_append objs " $arg"
5874		;;
5875
5876		*.lo)
5877		# A libtool-controlled object.
5878
5879		# Check to see that this really is a libtool object.
5880	<	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5880	>	if func_lalib_unsafe_p "$arg"; then
5881		pic_object=
5882		non_pic_object=
5883
5884		# Read the .lo file
5885	<	# If there is no directory component, then add one.
1506	<	case $arg in
1507	<	*/* | *\\*) . $arg ;;
1508	<	*) . ./$arg ;;
1509	<	esac
5885	>	func_source "$arg"
5886
5887	<	if test -z "$pic_object" || \
5887	>	if test -z "$pic_object" ||
5888		test -z "$non_pic_object" ||
5889	<	test "$pic_object" = none && \
5889	>	test "$pic_object" = none &&
5890		test "$non_pic_object" = none; then
5891	<	$echo "$modename: cannot find name of object for \`$arg'" 1>&2
1516	<	exit 1
5891	>	func_fatal_error "cannot find name of object for \`$arg'"
5892		fi
5893
5894		# Extract subdirectory from the argument.
5895	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
5896	<	if test "X$xdir" = "X$arg"; then
1522	<	xdir=
1523	<	else
1524	<	xdir="$xdir/"
1525	<	fi
5895	>	func_dirname "$arg" "/" ""
5896	>	xdir="$func_dirname_result"
5897
5898		if test "$pic_object" != none; then
5899		# Prepend the subdirectory the object is found in.
#	Line 1530 | Line 5901 | EOF
5901
5902		if test "$prev" = dlfiles; then
5903		if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5904	<	dlfiles="$dlfiles $pic_object"
5904	>	func_append dlfiles " $pic_object"
5905		prev=
5906		continue
5907		else
#	Line 1542 | Line 5913 | EOF
5913		# CHECK ME:  I think I busted this.  -Ossama
5914		if test "$prev" = dlprefiles; then
5915		# Preload the old-style object.
5916	<	dlprefiles="$dlprefiles $pic_object"
5916	>	func_append dlprefiles " $pic_object"
5917		prev=
5918		fi
5919
5920		# A PIC object.
5921	<	libobjs="$libobjs $pic_object"
5921	>	func_append libobjs " $pic_object"
5922		arg="$pic_object"
5923		fi
5924
#	Line 1557 | Line 5928 | EOF
5928		non_pic_object="$xdir$non_pic_object"
5929
5930		# A standard non-PIC object
5931	<	non_pic_objects="$non_pic_objects $non_pic_object"
5931	>	func_append non_pic_objects " $non_pic_object"
5932		if test -z "$pic_object" || test "$pic_object" = none ; then
5933		arg="$non_pic_object"
5934		fi
5935	+	else
5936	+	# If the PIC object exists, use it instead.
5937	+	# $xdir was prepended to $pic_object above.
5938	+	non_pic_object="$pic_object"
5939	+	func_append non_pic_objects " $non_pic_object"
5940		fi
5941		else
5942		# Only an error if not doing a dry-run.
5943	<	if test -z "$run"; then
1568	<	$echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1569	<	exit 1
1570	<	else
1571	<	# Dry-run case.
1572	<
5943	>	if $opt_dry_run; then
5944		# Extract subdirectory from the argument.
5945	<	xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
5946	<	if test "X$xdir" = "X$arg"; then
1576	<	xdir=
1577	<	else
1578	<	xdir="$xdir/"
1579	<	fi
5945	>	func_dirname "$arg" "/" ""
5946	>	xdir="$func_dirname_result"
5947
5948	<	pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
5949	<	non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
5950	<	libobjs="$libobjs $pic_object"
5951	<	non_pic_objects="$non_pic_objects $non_pic_object"
5948	>	func_lo2o "$arg"
5949	>	pic_object=$xdir$objdir/$func_lo2o_result
5950	>	non_pic_object=$xdir$func_lo2o_result
5951	>	func_append libobjs " $pic_object"
5952	>	func_append non_pic_objects " $non_pic_object"
5953	>	else
5954	>	func_fatal_error "\`$arg' is not a valid libtool object"
5955		fi
5956		fi
5957		;;
5958
5959		*.$libext)
5960		# An archive.
5961	<	deplibs="$deplibs $arg"
5962	<	old_deplibs="$old_deplibs $arg"
5961	>	func_append deplibs " $arg"
5962	>	func_append old_deplibs " $arg"
5963		continue
5964		;;
5965
5966		*.la)
5967		# A libtool-controlled library.
5968
5969	+	func_resolve_sysroot "$arg"
5970		if test "$prev" = dlfiles; then
5971		# This library was specified with -dlopen.
5972	<	dlfiles="$dlfiles $arg"
5972	>	func_append dlfiles " $func_resolve_sysroot_result"
5973		prev=
5974		elif test "$prev" = dlprefiles; then
5975		# The library was specified with -dlpreopen.
5976	<	dlprefiles="$dlprefiles $arg"
5976	>	func_append dlprefiles " $func_resolve_sysroot_result"
5977		prev=
5978		else
5979	<	deplibs="$deplibs $arg"
5979	>	func_append deplibs " $func_resolve_sysroot_result"
5980		fi
5981		continue
5982		;;
#	Line 1614 | Line 5985 | EOF
5985		*)
5986		# Unknown arguments in both finalize_command and compile_command need
5987		# to be aesthetically quoted because they are evaled later.
5988	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5989	<	case $arg in
1619	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1620	<	arg="\"$arg\""
1621	<	;;
1622	<	esac
5988	>	func_quote_for_eval "$arg"
5989	>	arg="$func_quote_for_eval_result"
5990		;;
5991		esac # arg
5992
5993		# Now actually substitute the argument into the commands.
5994		if test -n "$arg"; then
5995	<	compile_command="$compile_command $arg"
5996	<	finalize_command="$finalize_command $arg"
5995	>	func_append compile_command " $arg"
5996	>	func_append finalize_command " $arg"
5997		fi
5998		done # argument parsing loop
5999
6000	<	if test -n "$prev"; then
6001	<	$echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1635	<	$echo "$help" 1>&2
1636	<	exit 1
1637	<	fi
1638	<
1639	<	# Infer tagged configuration to use if any are available and
1640	<	# if one wasn't chosen via the "--tag" command line option.
1641	<	# Only attempt this if the compiler in the base link
1642	<	# command doesn't match the default compiler.
1643	<	if test -n "$available_tags" && test -z "$tagname"; then
1644	<	case $base_compile in
1645	<	# Blanks in the command may have been stripped by the calling shell,
1646	<	# but not from the CC environment variable when configure was run.
1647	<	"$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
1648	<	# Blanks at the start of $base_compile will cause this to fail
1649	<	# if we don't check for them as well.
1650	<	*)
1651	<	for z in $available_tags; do
1652	<	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1653	<	# Evaluate the configuration.
1654	<	eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1655	<	case $base_compile in
1656	<	"$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
1657	<	# The compiler in $compile_command matches
1658	<	# the one in the tagged configuration.
1659	<	# Assume this is the tagged configuration we want.
1660	<	tagname=$z
1661	<	break
1662	<	;;
1663	<	esac
1664	<	fi
1665	<	done
1666	<	# If $tagname still isn't set, then no tagged configuration
1667	<	# was found and let the user know that the "--tag" command
1668	<	# line option must be used.
1669	<	if test -z "$tagname"; then
1670	<	$echo "$modename: unable to infer tagged configuration"
1671	<	$echo "$modename: specify a tag with \`--tag'" 1>&2
1672	<	exit 1
1673	<	#       else
1674	<	#         $echo "$modename: using $tagname tagged configuration"
1675	<	fi
1676	<	;;
1677	<	esac
1678	<	fi
6000	>	test -n "$prev" && \
6001	>	func_fatal_help "the \`$prevarg' option requires an argument"
6002
6003		if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6004		eval arg=\"$export_dynamic_flag_spec\"
6005	<	compile_command="$compile_command $arg"
6006	<	finalize_command="$finalize_command $arg"
6005	>	func_append compile_command " $arg"
6006	>	func_append finalize_command " $arg"
6007		fi
6008
6009		oldlibs=
6010		# calculate the name of the file, without its directory
6011	<	outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
6011	>	func_basename "$output"
6012	>	outputname="$func_basename_result"
6013		libobjs_save="$libobjs"
6014
6015		if test -n "$shlibpath_var"; then
6016		# get the directories listed in $shlibpath_var
6017	<	eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
6017	>	eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6018		else
6019		shlib_search_path=
6020		fi
6021		eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6022		eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6023
6024	<	output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
6025	<	if test "X$output_objdir" = "X$output"; then
6026	<	output_objdir="$objdir"
6027	<	else
1704	<	output_objdir="$output_objdir/$objdir"
1705	<	fi
6024	>	func_dirname "$output" "/" ""
6025	>	output_objdir="$func_dirname_result$objdir"
6026	>	func_to_tool_file "$output_objdir/"
6027	>	tool_output_objdir=$func_to_tool_file_result
6028		# Create the object directory.
6029	<	if test ! -d "$output_objdir"; then
1708	<	$show "$mkdir $output_objdir"
1709	<	$run $mkdir $output_objdir
1710	<	status=$?
1711	<	if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1712	<	exit $status
1713	<	fi
1714	<	fi
6029	>	func_mkdir_p "$output_objdir"
6030
6031		# Determine the type of output
6032		case $output in
6033		"")
6034	<	$echo "$modename: you must specify an output file" 1>&2
1720	<	$echo "$help" 1>&2
1721	<	exit 1
6034	>	func_fatal_help "you must specify an output file"
6035		;;
6036		*.$libext) linkmode=oldlib ;;
6037		*.lo | *.$objext) linkmode=obj ;;
#	Line 1726 | Line 6039 | EOF
6039		*) linkmode=prog ;; # Anything else should be a program.
6040		esac
6041
1729	–	case $host in
1730	–	*cygwin* | *mingw* | *pw32*)
1731	–	# don't eliminate duplcations in $postdeps and $predeps
1732	–	duplicate_compiler_generated_deps=yes
1733	–	;;
1734	–	*)
1735	–	duplicate_compiler_generated_deps=$duplicate_deps
1736	–	;;
1737	–	esac
6042		specialdeplibs=
6043
6044		libs=
6045		# Find all interdependent deplibs by searching for libraries
6046		# that are linked more than once (e.g. -la -lb -la)
6047		for deplib in $deplibs; do
6048	<	if test "X$duplicate_deps" = "Xyes" ; then
6048	>	if $opt_preserve_dup_deps ; then
6049		case "$libs " in
6050	<	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6050	>	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6051		esac
6052		fi
6053	<	libs="$libs $deplib"
6053	>	func_append libs " $deplib"
6054		done
6055
6056		if test "$linkmode" = lib; then
#	Line 1756 | Line 6060 | EOF
6060		# $postdeps and mark them as special (i.e., whose duplicates are
6061		# not to be eliminated).
6062		pre_post_deps=
6063	<	if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
6063	>	if $opt_duplicate_compiler_generated_deps; then
6064		for pre_post_dep in $predeps $postdeps; do
6065		case "$pre_post_deps " in
6066	<	*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
6066	>	*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6067		esac
6068	<	pre_post_deps="$pre_post_deps $pre_post_dep"
6068	>	func_append pre_post_deps " $pre_post_dep"
6069		done
6070		fi
6071		pre_post_deps=
#	Line 1773 | Line 6077 | EOF
6077		need_relink=no # whether we're linking any uninstalled libtool libraries
6078		notinst_deplibs= # not-installed libtool libraries
6079		notinst_path= # paths that contain not-installed libtool libraries
6080	+
6081		case $linkmode in
6082		lib)
6083	<	passes="conv link"
6083	>	passes="conv dlpreopen link"
6084		for file in $dlfiles $dlprefiles; do
6085		case $file in
6086		*.la) ;;
6087		*)
6088	<	$echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1784	<	exit 1
6088	>	func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6089		;;
6090		esac
6091		done
#	Line 1797 | Line 6101 | EOF
6101		*)  passes="conv"
6102		;;
6103		esac
6104	+
6105		for pass in $passes; do
6106	+	# The preopen pass in lib mode reverses $deplibs; put it back here
6107	+	# so that -L comes before libs that need it for instance...
6108	+	if test "$linkmode,$pass" = "lib,link"; then
6109	+	## FIXME: Find the place where the list is rebuilt in the wrong
6110	+	##        order, and fix it there properly
6111	+	tmp_deplibs=
6112	+	for deplib in $deplibs; do
6113	+	tmp_deplibs="$deplib $tmp_deplibs"
6114	+	done
6115	+	deplibs="$tmp_deplibs"
6116	+	fi
6117	+
6118		if test "$linkmode,$pass" = "lib,link" ||
6119		test "$linkmode,$pass" = "prog,scan"; then
6120		libs="$deplibs"
#	Line 1810 | Line 6127 | EOF
6127		link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6128		esac
6129		fi
6130	+	if test "$linkmode,$pass" = "lib,dlpreopen"; then
6131	+	# Collect and forward deplibs of preopened libtool libs
6132	+	for lib in $dlprefiles; do
6133	+	# Ignore non-libtool-libs
6134	+	dependency_libs=
6135	+	func_resolve_sysroot "$lib"
6136	+	case $lib in
6137	+	*.la) func_source "$func_resolve_sysroot_result" ;;
6138	+	esac
6139	+
6140	+	# Collect preopened libtool deplibs, except any this library
6141	+	# has declared as weak libs
6142	+	for deplib in $dependency_libs; do
6143	+	func_basename "$deplib"
6144	+	deplib_base=$func_basename_result
6145	+	case " $weak_libs " in
6146	+	*" $deplib_base "*) ;;
6147	+	*) func_append deplibs " $deplib" ;;
6148	+	esac
6149	+	done
6150	+	done
6151	+	libs="$dlprefiles"
6152	+	fi
6153		if test "$pass" = dlopen; then
6154		# Collect dlpreopened libraries
6155		save_deplibs="$deplibs"
6156		deplibs=
6157		fi
6158	+
6159		for deplib in $libs; do
6160		lib=
6161		found=no
6162		case $deplib in
6163	+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6164	+	|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6165	+	if test "$linkmode,$pass" = "prog,link"; then
6166	+	compile_deplibs="$deplib $compile_deplibs"
6167	+	finalize_deplibs="$deplib $finalize_deplibs"
6168	+	else
6169	+	func_append compiler_flags " $deplib"
6170	+	if test "$linkmode" = lib ; then
6171	+	case "$new_inherited_linker_flags " in
6172	+	*" $deplib "*) ;;
6173	+	* ) func_append new_inherited_linker_flags " $deplib" ;;
6174	+	esac
6175	+	fi
6176	+	fi
6177	+	continue
6178	+	;;
6179		-l*)
6180		if test "$linkmode" != lib && test "$linkmode" != prog; then
6181	<	$echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
6181	>	func_warning "\`-l' is ignored for archives/objects"
6182		continue
6183		fi
6184	<	if test "$pass" = conv; then
6185	<	deplibs="$deplib $deplibs"
6186	<	continue
6184	>	func_stripname '-l' '' "$deplib"
6185	>	name=$func_stripname_result
6186	>	if test "$linkmode" = lib; then
6187	>	searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6188	>	else
6189	>	searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6190		fi
6191	<	name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
6192	<	for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
6193	<	# Search the libtool library
6194	<	lib="$searchdir/lib${name}.la"
6195	<	if test -f "$lib"; then
6196	<	found=yes
6197	<	break
6198	<	fi
6191	>	for searchdir in $searchdirs; do
6192	>	for search_ext in .la $std_shrext .so .a; do
6193	>	# Search the libtool library
6194	>	lib="$searchdir/lib${name}${search_ext}"
6195	>	if test -f "$lib"; then
6196	>	if test "$search_ext" = ".la"; then
6197	>	found=yes
6198	>	else
6199	>	found=no
6200	>	fi
6201	>	break 2
6202	>	fi
6203	>	done
6204		done
6205		if test "$found" != yes; then
6206		# deplib doesn't seem to be a libtool library
#	Line 1853 | Line 6218 | EOF
6218		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6219		case " $predeps $postdeps " in
6220		*" $deplib "*)
6221	<	if (${SED} -e '2q' $lib |
1857	<	grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6221	>	if func_lalib_p "$lib"; then
6222		library_names=
6223		old_library=
6224	<	case $lib in
1861	<	*/* | *\\*) . $lib ;;
1862	<	*) . ./$lib ;;
1863	<	esac
6224	>	func_source "$lib"
6225		for l in $old_library $library_names; do
6226		ll="$l"
6227		done
6228		if test "X$ll" = "X$old_library" ; then # only static version available
6229		found=no
6230	<	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
6231	<	test "X$ladir" = "X$lib" && ladir="."
6230	>	func_dirname "$lib" "" "."
6231	>	ladir="$func_dirname_result"
6232		lib=$ladir/$old_library
6233		if test "$linkmode,$pass" = "prog,link"; then
6234		compile_deplibs="$deplib $compile_deplibs"
#	Line 1879 | Line 6240 | EOF
6240		continue
6241		fi
6242		fi
6243	<	;;
6243	>	;;
6244		*) ;;
6245		esac
6246		fi
6247		fi
6248		;; # -l
6249	+	*.ltframework)
6250	+	if test "$linkmode,$pass" = "prog,link"; then
6251	+	compile_deplibs="$deplib $compile_deplibs"
6252	+	finalize_deplibs="$deplib $finalize_deplibs"
6253	+	else
6254	+	deplibs="$deplib $deplibs"
6255	+	if test "$linkmode" = lib ; then
6256	+	case "$new_inherited_linker_flags " in
6257	+	*" $deplib "*) ;;
6258	+	* ) func_append new_inherited_linker_flags " $deplib" ;;
6259	+	esac
6260	+	fi
6261	+	fi
6262	+	continue
6263	+	;;
6264		-L*)
6265		case $linkmode in
6266		lib)
6267		deplibs="$deplib $deplibs"
6268		test "$pass" = conv && continue
6269		newdependency_libs="$deplib $newdependency_libs"
6270	<	newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
6270	>	func_stripname '-L' '' "$deplib"
6271	>	func_resolve_sysroot "$func_stripname_result"
6272	>	func_append newlib_search_path " $func_resolve_sysroot_result"
6273		;;
6274		prog)
6275		if test "$pass" = conv; then
#	Line 1900 | Line 6278 | EOF
6278		fi
6279		if test "$pass" = scan; then
6280		deplibs="$deplib $deplibs"
1903	–	newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
6281		else
6282		compile_deplibs="$deplib $compile_deplibs"
6283		finalize_deplibs="$deplib $finalize_deplibs"
6284		fi
6285	+	func_stripname '-L' '' "$deplib"
6286	+	func_resolve_sysroot "$func_stripname_result"
6287	+	func_append newlib_search_path " $func_resolve_sysroot_result"
6288		;;
6289		*)
6290	<	$echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
6290	>	func_warning "\`-L' is ignored for archives/objects"
6291		;;
6292		esac # linkmode
6293		continue
6294		;; # -L
6295		-R*)
6296		if test "$pass" = link; then
6297	<	dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
6297	>	func_stripname '-R' '' "$deplib"
6298	>	func_resolve_sysroot "$func_stripname_result"
6299	>	dir=$func_resolve_sysroot_result
6300		# Make sure the xrpath contains only unique directories.
6301		case "$xrpath " in
6302		*" $dir "*) ;;
6303	<	*) xrpath="$xrpath $dir" ;;
6303	>	*) func_append xrpath " $dir" ;;
6304		esac
6305		fi
6306		deplibs="$deplib $deplibs"
6307		continue
6308		;;
6309	<	*.la) lib="$deplib" ;;
6309	>	*.la)
6310	>	func_resolve_sysroot "$deplib"
6311	>	lib=$func_resolve_sysroot_result
6312	>	;;
6313		*.$libext)
6314		if test "$pass" = conv; then
6315		deplibs="$deplib $deplibs"
#	Line 1932 | Line 6317 | EOF
6317		fi
6318		case $linkmode in
6319		lib)
6320	<	if test "$deplibs_check_method" != pass_all; then
6321	<	$echo
6322	<	$echo "*** Warning: Trying to link with static lib archive $deplib."
6323	<	$echo "*** I have the capability to make that library automatically link in when"
6324	<	$echo "*** you link to this library.  But I can only do this if you have a"
6325	<	$echo "*** shared version of the library, which you do not appear to have"
6326	<	$echo "*** because the file extensions .$libext of this argument makes me believe"
6327	<	$echo "*** that it is just a static archive that I should not used here."
6328	<	else
6329	<	$echo
6330	<	$echo "*** Warning: Linking the shared library $output against the"
6331	<	$echo "*** static library $deplib is not portable!"
6332	<	deplibs="$deplib $deplibs"
6333	<	fi
6320	>	# Linking convenience modules into shared libraries is allowed,
6321	>	# but linking other static libraries is non-portable.
6322	>	case " $dlpreconveniencelibs " in
6323	>	*" $deplib "*) ;;
6324	>	*)
6325	>	valid_a_lib=no
6326	>	case $deplibs_check_method in
6327	>	match_pattern*)
6328	>	set dummy $deplibs_check_method; shift
6329	>	match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6330	>	if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6331	>	| $EGREP "$match_pattern_regex" > /dev/null; then
6332	>	valid_a_lib=yes
6333	>	fi
6334	>	;;
6335	>	pass_all)
6336	>	valid_a_lib=yes
6337	>	;;
6338	>	esac
6339	>	if test "$valid_a_lib" != yes; then
6340	>	echo
6341	>	$ECHO "*** Warning: Trying to link with static lib archive $deplib."
6342	>	echo "*** I have the capability to make that library automatically link in when"
6343	>	echo "*** you link to this library.  But I can only do this if you have a"
6344	>	echo "*** shared version of the library, which you do not appear to have"
6345	>	echo "*** because the file extensions .$libext of this argument makes me believe"
6346	>	echo "*** that it is just a static archive that I should not use here."
6347	>	else
6348	>	echo
6349	>	$ECHO "*** Warning: Linking the shared library $output against the"
6350	>	$ECHO "*** static library $deplib is not portable!"
6351	>	deplibs="$deplib $deplibs"
6352	>	fi
6353	>	;;
6354	>	esac
6355		continue
6356		;;
6357		prog)
#	Line 1966 | Line 6372 | EOF
6372		if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6373		# If there is no dlopen support or we're linking statically,
6374		# we need to preload.
6375	<	newdlprefiles="$newdlprefiles $deplib"
6375	>	func_append newdlprefiles " $deplib"
6376		compile_deplibs="$deplib $compile_deplibs"
6377		finalize_deplibs="$deplib $finalize_deplibs"
6378		else
6379	<	newdlfiles="$newdlfiles $deplib"
6379	>	func_append newdlfiles " $deplib"
6380		fi
6381		fi
6382		continue
#	Line 1980 | Line 6386 | EOF
6386		continue
6387		;;
6388		esac # case $deplib
6389	+
6390		if test "$found" = yes || test -f "$lib"; then :
6391		else
6392	<	$echo "$modename: cannot find the library \`$lib'" 1>&2
1986	<	exit 1
6392	>	func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6393		fi
6394
6395		# Check to see that this really is a libtool archive.
6396	<	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6397	<	else
1992	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1993	<	exit 1
1994	<	fi
6396	>	func_lalib_unsafe_p "$lib" \
6397	>	|| func_fatal_error "\`$lib' is not a valid libtool archive"
6398
6399	<	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
6400	<	test "X$ladir" = "X$lib" && ladir="."
6399	>	func_dirname "$lib" "" "."
6400	>	ladir="$func_dirname_result"
6401
6402		dlname=
6403		dlopen=
#	Line 2002 | Line 6405 | EOF
6405		libdir=
6406		library_names=
6407		old_library=
6408	+	inherited_linker_flags=
6409		# If the library was installed with an old release of libtool,
6410		# it will not redefine variables installed, or shouldnotlink
6411		installed=yes
6412		shouldnotlink=no
6413	+	avoidtemprpath=
6414	+
6415
6416		# Read the .la file
6417	<	case $lib in
2012	<	*/* | *\\*) . $lib ;;
2013	<	*) . ./$lib ;;
2014	<	esac
6417	>	func_source "$lib"
6418
6419	+	# Convert "-framework foo" to "foo.ltframework"
6420	+	if test -n "$inherited_linker_flags"; then
6421	+	tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6422	+	for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6423	+	case " $new_inherited_linker_flags " in
6424	+	*" $tmp_inherited_linker_flag "*) ;;
6425	+	*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6426	+	esac
6427	+	done
6428	+	fi
6429	+	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6430		if test "$linkmode,$pass" = "lib,link" ||
6431		test "$linkmode,$pass" = "prog,scan" ||
6432		{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
6433	<	test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
6434	<	test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
6433	>	test -n "$dlopen" && func_append dlfiles " $dlopen"
6434	>	test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6435		fi
6436
6437		if test "$pass" = conv; then
#	Line 2025 | Line 6439 | EOF
6439		deplibs="$lib $deplibs"
6440		if test -z "$libdir"; then
6441		if test -z "$old_library"; then
6442	<	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2029	<	exit 1
6442	>	func_fatal_error "cannot find name of link library for \`$lib'"
6443		fi
6444		# It is a libtool convenience library, so add in its objects.
6445	<	convenience="$convenience $ladir/$objdir/$old_library"
6446	<	old_convenience="$old_convenience $ladir/$objdir/$old_library"
2034	<	tmp_libs=
2035	<	for deplib in $dependency_libs; do
2036	<	deplibs="$deplib $deplibs"
2037	<	if test "X$duplicate_deps" = "Xyes" ; then
2038	<	case "$tmp_libs " in
2039	<	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2040	<	esac
2041	<	fi
2042	<	tmp_libs="$tmp_libs $deplib"
2043	<	done
6445	>	func_append convenience " $ladir/$objdir/$old_library"
6446	>	func_append old_convenience " $ladir/$objdir/$old_library"
6447		elif test "$linkmode" != prog && test "$linkmode" != lib; then
6448	<	$echo "$modename: \`$lib' is not a convenience library" 1>&2
2046	<	exit 1
6448	>	func_fatal_error "\`$lib' is not a convenience library"
6449		fi
6450	+	tmp_libs=
6451	+	for deplib in $dependency_libs; do
6452	+	deplibs="$deplib $deplibs"
6453	+	if $opt_preserve_dup_deps ; then
6454	+	case "$tmp_libs " in
6455	+	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6456	+	esac
6457	+	fi
6458	+	func_append tmp_libs " $deplib"
6459	+	done
6460		continue
6461		fi # $pass = conv
6462
6463	<
6463	>
6464		# Get the name of the library we link against.
6465		linklib=
6466	<	for l in $old_library $library_names; do
6467	<	linklib="$l"
6468	<	done
6466	>	if test -n "$old_library" &&
6467	>	{ test "$prefer_static_libs" = yes ||
6468	>	test "$prefer_static_libs,$installed" = "built,no"; }; then
6469	>	linklib=$old_library
6470	>	else
6471	>	for l in $old_library $library_names; do
6472	>	linklib="$l"
6473	>	done
6474	>	fi
6475		if test -z "$linklib"; then
6476	<	$echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2059	<	exit 1
6476	>	func_fatal_error "cannot find name of link library for \`$lib'"
6477		fi
6478
6479		# This library was specified with -dlopen.
6480		if test "$pass" = dlopen; then
6481		if test -z "$libdir"; then
6482	<	$echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2066	<	exit 1
6482	>	func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6483		fi
6484	<	if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6484	>	if test -z "$dlname" ||
6485	>	test "$dlopen_support" != yes ||
6486	>	test "$build_libtool_libs" = no; then
6487		# If there is no dlname, no dlopen support or we're linking
6488		# statically, we need to preload.  We also need to preload any
6489		# dependent libraries so libltdl's deplib preloader doesn't
6490		# bomb out in the load deplibs phase.
6491	<	dlprefiles="$dlprefiles $lib $dependency_libs"
6491	>	func_append dlprefiles " $lib $dependency_libs"
6492		else
6493	<	newdlfiles="$newdlfiles $lib"
6493	>	func_append newdlfiles " $lib"
6494		fi
6495		continue
6496		fi # $pass = dlopen
#	Line 2083 | Line 6501 | EOF
6501		*)
6502		abs_ladir=`cd "$ladir" && pwd`
6503		if test -z "$abs_ladir"; then
6504	<	$echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
6505	<	$echo "$modename: passing it literally to the linker, although it might fail" 1>&2
6504	>	func_warning "cannot determine absolute directory name of \`$ladir'"
6505	>	func_warning "passing it literally to the linker, although it might fail"
6506		abs_ladir="$ladir"
6507		fi
6508		;;
6509		esac
6510	<	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
6510	>	func_basename "$lib"
6511	>	laname="$func_basename_result"
6512
6513		# Find the relevant object directory and library name.
6514		if test "X$installed" = Xyes; then
6515	<	if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6516	<	$echo "$modename: warning: library \`$lib' was moved." 1>&2
6515	>	if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6516	>	func_warning "library \`$lib' was moved."
6517		dir="$ladir"
6518		absdir="$abs_ladir"
6519		libdir="$abs_ladir"
6520		else
6521	<	dir="$libdir"
6522	<	absdir="$libdir"
6521	>	dir="$lt_sysroot$libdir"
6522	>	absdir="$lt_sysroot$libdir"
6523		fi
6524	+	test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6525		else
6526	<	dir="$ladir/$objdir"
6527	<	absdir="$abs_ladir/$objdir"
6528	<	# Remove this search path later
6529	<	notinst_path="$notinst_path $abs_ladir"
6526	>	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6527	>	dir="$ladir"
6528	>	absdir="$abs_ladir"
6529	>	# Remove this search path later
6530	>	func_append notinst_path " $abs_ladir"
6531	>	else
6532	>	dir="$ladir/$objdir"
6533	>	absdir="$abs_ladir/$objdir"
6534	>	# Remove this search path later
6535	>	func_append notinst_path " $abs_ladir"
6536	>	fi
6537		fi # $installed = yes
6538	<	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
6538	>	func_stripname 'lib' '.la' "$laname"
6539	>	name=$func_stripname_result
6540
6541		# This library was specified with -dlpreopen.
6542		if test "$pass" = dlpreopen; then
6543	<	if test -z "$libdir"; then
6544	<	$echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2117	<	exit 1
2118	<	fi
2119	<	# Prefer using a static library (so that no silly _DYNAMIC symbols
2120	<	# are required to link).
2121	<	if test -n "$old_library"; then
2122	<	newdlprefiles="$newdlprefiles $dir/$old_library"
2123	<	# Otherwise, use the dlname, so that lt_dlopen finds it.
2124	<	elif test -n "$dlname"; then
2125	<	newdlprefiles="$newdlprefiles $dir/$dlname"
2126	<	else
2127	<	newdlprefiles="$newdlprefiles $dir/$linklib"
6543	>	if test -z "$libdir" && test "$linkmode" = prog; then
6544	>	func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6545		fi
6546	+	case "$host" in
6547	+	# special handling for platforms with PE-DLLs.
6548	+	*cygwin* | *mingw* | *cegcc* )
6549	+	# Linker will automatically link against shared library if both
6550	+	# static and shared are present.  Therefore, ensure we extract
6551	+	# symbols from the import library if a shared library is present
6552	+	# (otherwise, the dlopen module name will be incorrect).  We do
6553	+	# this by putting the import library name into $newdlprefiles.
6554	+	# We recover the dlopen module name by 'saving' the la file
6555	+	# name in a special purpose variable, and (later) extracting the
6556	+	# dlname from the la file.
6557	+	if test -n "$dlname"; then
6558	+	func_tr_sh "$dir/$linklib"
6559	+	eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6560	+	func_append newdlprefiles " $dir/$linklib"
6561	+	else
6562	+	func_append newdlprefiles " $dir/$old_library"
6563	+	# Keep a list of preopened convenience libraries to check
6564	+	# that they are being used correctly in the link pass.
6565	+	test -z "$libdir" && \
6566	+	func_append dlpreconveniencelibs " $dir/$old_library"
6567	+	fi
6568	+	;;
6569	+	* )
6570	+	# Prefer using a static library (so that no silly _DYNAMIC symbols
6571	+	# are required to link).
6572	+	if test -n "$old_library"; then
6573	+	func_append newdlprefiles " $dir/$old_library"
6574	+	# Keep a list of preopened convenience libraries to check
6575	+	# that they are being used correctly in the link pass.
6576	+	test -z "$libdir" && \
6577	+	func_append dlpreconveniencelibs " $dir/$old_library"
6578	+	# Otherwise, use the dlname, so that lt_dlopen finds it.
6579	+	elif test -n "$dlname"; then
6580	+	func_append newdlprefiles " $dir/$dlname"
6581	+	else
6582	+	func_append newdlprefiles " $dir/$linklib"
6583	+	fi
6584	+	;;
6585	+	esac
6586		fi # $pass = dlpreopen
6587
6588		if test -z "$libdir"; then
#	Line 2141 | Line 6598 | EOF
6598		continue
6599		fi
6600
6601	<
6601	>
6602		if test "$linkmode" = prog && test "$pass" != link; then
6603	<	newlib_search_path="$newlib_search_path $ladir"
6603	>	func_append newlib_search_path " $ladir"
6604		deplibs="$lib $deplibs"
6605
6606		linkalldeplibs=no
#	Line 2155 | Line 6612 | EOF
6612		tmp_libs=
6613		for deplib in $dependency_libs; do
6614		case $deplib in
6615	<	-L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
6615	>	-L*) func_stripname '-L' '' "$deplib"
6616	>	func_resolve_sysroot "$func_stripname_result"
6617	>	func_append newlib_search_path " $func_resolve_sysroot_result"
6618	>	;;
6619		esac
6620		# Need to link against all dependency_libs?
6621		if test "$linkalldeplibs" = yes; then
#	Line 2165 | Line 6625 | EOF
6625		# or/and link against static libraries
6626		newdependency_libs="$deplib $newdependency_libs"
6627		fi
6628	<	if test "X$duplicate_deps" = "Xyes" ; then
6628	>	if $opt_preserve_dup_deps ; then
6629		case "$tmp_libs " in
6630	<	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6630	>	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6631		esac
6632		fi
6633	<	tmp_libs="$tmp_libs $deplib"
6633	>	func_append tmp_libs " $deplib"
6634		done # for deplib
6635		continue
6636		fi # $linkmode = prog...
6637
6638		if test "$linkmode,$pass" = "prog,link"; then
6639		if test -n "$library_names" &&
6640	<	{ test "$prefer_static_libs" = no || test -z "$old_library"; }; then
6640	>	{ { test "$prefer_static_libs" = no ||
6641	>	test "$prefer_static_libs,$installed" = "built,yes"; } ||
6642	>	test -z "$old_library"; }; then
6643		# We need to hardcode the library path
6644	<	if test -n "$shlibpath_var"; then
6644	>	if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6645		# Make sure the rpath contains only unique directories.
6646	<	case "$temp_rpath " in
6647	<	*" $dir "*) ;;
6648	<	*" $absdir "*) ;;
2187	<	*) temp_rpath="$temp_rpath $dir" ;;
6646	>	case "$temp_rpath:" in
6647	>	*"$absdir:"*) ;;
6648	>	*) func_append temp_rpath "$absdir:" ;;
6649		esac
6650		fi
6651
#	Line 2196 | Line 6657 | EOF
6657		*)
6658		case "$compile_rpath " in
6659		*" $absdir "*) ;;
6660	<	*) compile_rpath="$compile_rpath $absdir"
6660	>	*) func_append compile_rpath " $absdir" ;;
6661		esac
6662		;;
6663		esac
#	Line 2205 | Line 6666 | EOF
6666		*)
6667		case "$finalize_rpath " in
6668		*" $libdir "*) ;;
6669	<	*) finalize_rpath="$finalize_rpath $libdir"
6669	>	*) func_append finalize_rpath " $libdir" ;;
6670		esac
6671		;;
6672		esac
#	Line 2221 | Line 6682 | EOF
6682		fi
6683
6684		link_static=no # Whether the deplib will be linked statically
6685	+	use_static_libs=$prefer_static_libs
6686	+	if test "$use_static_libs" = built && test "$installed" = yes; then
6687	+	use_static_libs=no
6688	+	fi
6689		if test -n "$library_names" &&
6690	<	{ test "$prefer_static_libs" = no || test -z "$old_library"; }; then
6691	<	if test "$installed" = no; then
6692	<	notinst_deplibs="$notinst_deplibs $lib"
6693	<	need_relink=yes
6694	<	fi
6690	>	{ test "$use_static_libs" = no || test -z "$old_library"; }; then
6691	>	case $host in
6692	>	*cygwin* | *mingw* | *cegcc*)
6693	>	# No point in relinking DLLs because paths are not encoded
6694	>	func_append notinst_deplibs " $lib"
6695	>	need_relink=no
6696	>	;;
6697	>	*)
6698	>	if test "$installed" = no; then
6699	>	func_append notinst_deplibs " $lib"
6700	>	need_relink=yes
6701	>	fi
6702	>	;;
6703	>	esac
6704		# This is a shared library
6705	<
6706	<	# Warn about portability, can't link against -module's on some systems (darwin)
6707	<	if test "$shouldnotlink" = yes && test "$pass" = link ; then
6708	<	$echo
6705	>
6706	>	# Warn about portability, can't link against -module's on some
6707	>	# systems (darwin).  Don't bleat about dlopened modules though!
6708	>	dlopenmodule=""
6709	>	for dlpremoduletest in $dlprefiles; do
6710	>	if test "X$dlpremoduletest" = "X$lib"; then
6711	>	dlopenmodule="$dlpremoduletest"
6712	>	break
6713	>	fi
6714	>	done
6715	>	if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6716	>	echo
6717		if test "$linkmode" = prog; then
6718	<	$echo "*** Warning: Linking the executable $output against the loadable module"
6718	>	$ECHO "*** Warning: Linking the executable $output against the loadable module"
6719		else
6720	<	$echo "*** Warning: Linking the shared library $output against the loadable module"
6720	>	$ECHO "*** Warning: Linking the shared library $output against the loadable module"
6721		fi
6722	<	$echo "*** $linklib is not portable!"
6723	<	fi
6722	>	$ECHO "*** $linklib is not portable!"
6723	>	fi
6724		if test "$linkmode" = lib &&
6725		test "$hardcode_into_libs" = yes; then
6726		# Hardcode the library path.
#	Line 2249 | Line 6731 | EOF
6731		*)
6732		case "$compile_rpath " in
6733		*" $absdir "*) ;;
6734	<	*) compile_rpath="$compile_rpath $absdir"
6734	>	*) func_append compile_rpath " $absdir" ;;
6735		esac
6736		;;
6737		esac
#	Line 2258 | Line 6740 | EOF
6740		*)
6741		case "$finalize_rpath " in
6742		*" $libdir "*) ;;
6743	<	*) finalize_rpath="$finalize_rpath $libdir"
6743	>	*) func_append finalize_rpath " $libdir" ;;
6744		esac
6745		;;
6746		esac
#	Line 2267 | Line 6749 | EOF
6749		if test -n "$old_archive_from_expsyms_cmds"; then
6750		# figure out the soname
6751		set dummy $library_names
6752	<	realname="$2"
6753	<	shift; shift
6754	<	libname=`eval \\$echo \"$libname_spec\"`
6752	>	shift
6753	>	realname="$1"
6754	>	shift
6755	>	libname=`eval "\\$ECHO \"$libname_spec\""`
6756		# use dlname if we got it. it's perfectly good, no?
6757		if test -n "$dlname"; then
6758		soname="$dlname"
6759		elif test -n "$soname_spec"; then
6760		# bleh windows
6761		case $host in
6762	<	*cygwin* | mingw*)
6763	<	major=`expr $current - $age`
6762	>	*cygwin* | mingw* | *cegcc*)
6763	>	func_arith $current - $age
6764	>	major=$func_arith_result
6765		versuffix="-$major"
6766		;;
6767		esac
#	Line 2288 | Line 6772 | EOF
6772
6773		# Make a new name for the extract_expsyms_cmds to use
6774		soroot="$soname"
6775	<	soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
6776	<	newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
6775	>	func_basename "$soroot"
6776	>	soname="$func_basename_result"
6777	>	func_stripname 'lib' '.dll' "$soname"
6778	>	newlib=libimp-$func_stripname_result.a
6779
6780		# If the library has no export list, then create one now
6781		if test -f "$output_objdir/$soname-def"; then :
6782		else
6783	<	$show "extracting exported symbol list from \`$soname'"
6784	<	save_ifs="$IFS"; IFS=$_S_
2299	<	eval cmds=\"$extract_expsyms_cmds\"
2300	<	for cmd in $cmds; do
2301	<	IFS="$save_ifs"
2302	<	$show "$cmd"
2303	<	$run eval "$cmd" || exit $?
2304	<	done
2305	<	IFS="$save_ifs"
6783	>	func_verbose "extracting exported symbol list from \`$soname'"
6784	>	func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6785		fi
6786
6787		# Create $newlib
6788		if test -f "$output_objdir/$newlib"; then :; else
6789	<	$show "generating import library for \`$soname'"
6790	<	save_ifs="$IFS"; IFS=$_S_
2312	<	eval cmds=\"$old_archive_from_expsyms_cmds\"
2313	<	for cmd in $cmds; do
2314	<	IFS="$save_ifs"
2315	<	$show "$cmd"
2316	<	$run eval "$cmd" || exit $?
2317	<	done
2318	<	IFS="$save_ifs"
6789	>	func_verbose "generating import library for \`$soname'"
6790	>	func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6791		fi
6792		# make sure the library variables are pointing to the new library
6793		dir=$output_objdir
6794		linklib=$newlib
6795		fi # test -n "$old_archive_from_expsyms_cmds"
6796
6797	<	if test "$linkmode" = prog || test "$mode" != relink; then
6797	>	if test "$linkmode" = prog || test "$opt_mode" != relink; then
6798		add_shlibpath=
6799		add_dir=
6800		add=
#	Line 2332 | Line 6804 | EOF
6804		if test "$hardcode_direct" = no; then
6805		add="$dir/$linklib"
6806		case $host in
6807	<	*-*-sco3.2v5* ) add_dir="-L$dir" ;;
6807	>	*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6808	>	*-*-sysv4*uw2*) add_dir="-L$dir" ;;
6809	>	*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6810	>	*-*-unixware7*) add_dir="-L$dir" ;;
6811		*-*-darwin* )
6812	<	# if the lib is a module then we can not link against it, someone
6813	<	# is ignoring the new warnings I added
6814	<	if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
6815	<	$echo "** Warning, lib $linklib is a module, not a shared library"
6816	<	if test -z "$old_library" ; then
6817	<	$echo
6818	<	$echo "** And there doesn't seem to be a static archive available"
6819	<	$echo "** The link will probably fail, sorry"
6820	<	else
6821	<	add="$dir/$old_library"
6822	<	fi
6812	>	# if the lib is a (non-dlopened) module then we can not
6813	>	# link against it, someone is ignoring the earlier warnings
6814	>	if /usr/bin/file -L $add 2> /dev/null |
6815	>	$GREP ": [^:]* bundle" >/dev/null ; then
6816	>	if test "X$dlopenmodule" != "X$lib"; then
6817	>	$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6818	>	if test -z "$old_library" ; then
6819	>	echo
6820	>	echo "*** And there doesn't seem to be a static archive available"
6821	>	echo "*** The link will probably fail, sorry"
6822	>	else
6823	>	add="$dir/$old_library"
6824	>	fi
6825	>	elif test -n "$old_library"; then
6826	>	add="$dir/$old_library"
6827	>	fi
6828		fi
6829		esac
6830		elif test "$hardcode_minus_L" = no; then
#	Line 2361 | Line 6841 | EOF
6841		fi
6842		;;
6843		relink)
6844	<	if test "$hardcode_direct" = yes; then
6844	>	if test "$hardcode_direct" = yes &&
6845	>	test "$hardcode_direct_absolute" = no; then
6846		add="$dir/$linklib"
6847		elif test "$hardcode_minus_L" = yes; then
6848	<	add_dir="-L$dir"
6848	>	add_dir="-L$absdir"
6849		# Try looking first in the location we're being installed to.
6850		if test -n "$inst_prefix_dir"; then
6851	<	case "$libdir" in
6851	>	case $libdir in
6852		[\\/]*)
6853	<	add_dir="-L$inst_prefix_dir$libdir $add_dir"
6853	>	func_append add_dir " -L$inst_prefix_dir$libdir"
6854		;;
6855		esac
6856		fi
#	Line 2385 | Line 6866 | EOF
6866		esac
6867
6868		if test "$lib_linked" != yes; then
6869	<	$echo "$modename: configuration error: unsupported hardcode properties"
2389	<	exit 1
6869	>	func_fatal_configuration "unsupported hardcode properties"
6870		fi
6871
6872		if test -n "$add_shlibpath"; then
6873		case :$compile_shlibpath: in
6874		*":$add_shlibpath:"*) ;;
6875	<	*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6875	>	*) func_append compile_shlibpath "$add_shlibpath:" ;;
6876		esac
6877		fi
6878		if test "$linkmode" = prog; then
#	Line 2401 | Line 6881 | EOF
6881		else
6882		test -n "$add_dir" && deplibs="$add_dir $deplibs"
6883		test -n "$add" && deplibs="$add $deplibs"
6884	<	if test "$hardcode_direct" != yes && \
6885	<	test "$hardcode_minus_L" != yes && \
6884	>	if test "$hardcode_direct" != yes &&
6885	>	test "$hardcode_minus_L" != yes &&
6886		test "$hardcode_shlibpath_var" = yes; then
6887		case :$finalize_shlibpath: in
6888		*":$libdir:"*) ;;
6889	<	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6889	>	*) func_append finalize_shlibpath "$libdir:" ;;
6890		esac
6891		fi
6892		fi
6893		fi
6894
6895	<	if test "$linkmode" = prog || test "$mode" = relink; then
6895	>	if test "$linkmode" = prog || test "$opt_mode" = relink; then
6896		add_shlibpath=
6897		add_dir=
6898		add=
6899		# Finalize command for both is simple: just hardcode it.
6900	<	if test "$hardcode_direct" = yes; then
6900	>	if test "$hardcode_direct" = yes &&
6901	>	test "$hardcode_direct_absolute" = no; then
6902		add="$libdir/$linklib"
6903		elif test "$hardcode_minus_L" = yes; then
6904		add_dir="-L$libdir"
#	Line 2425 | Line 6906 | EOF
6906		elif test "$hardcode_shlibpath_var" = yes; then
6907		case :$finalize_shlibpath: in
6908		*":$libdir:"*) ;;
6909	<	*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6909	>	*) func_append finalize_shlibpath "$libdir:" ;;
6910		esac
6911		add="-l$name"
6912		elif test "$hardcode_automatic" = yes; then
6913	<	if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
6914	<	add="$inst_prefix_dir$libdir/$linklib"
6913	>	if test -n "$inst_prefix_dir" &&
6914	>	test -f "$inst_prefix_dir$libdir/$linklib" ; then
6915	>	add="$inst_prefix_dir$libdir/$linklib"
6916		else
6917	<	add="$libdir/$linklib"
6917	>	add="$libdir/$linklib"
6918		fi
6919		else
6920		# We cannot seem to hardcode it, guess we'll fake it.
6921		add_dir="-L$libdir"
6922		# Try looking first in the location we're being installed to.
6923		if test -n "$inst_prefix_dir"; then
6924	<	case "$libdir" in
6924	>	case $libdir in
6925		[\\/]*)
6926	<	add_dir="-L$inst_prefix_dir$libdir $add_dir"
6926	>	func_append add_dir " -L$inst_prefix_dir$libdir"
6927		;;
6928		esac
6929		fi
#	Line 2476 | Line 6958 | EOF
6958
6959		# Just print a warning and add the library to dependency_libs so
6960		# that the program can be linked against the static library.
6961	<	$echo
6962	<	$echo "*** Warning: This system can not link to static lib archive $lib."
6963	<	$echo "*** I have the capability to make that library automatically link in when"
6964	<	$echo "*** you link to this library.  But I can only do this if you have a"
6965	<	$echo "*** shared version of the library, which you do not appear to have."
6961	>	echo
6962	>	$ECHO "*** Warning: This system can not link to static lib archive $lib."
6963	>	echo "*** I have the capability to make that library automatically link in when"
6964	>	echo "*** you link to this library.  But I can only do this if you have a"
6965	>	echo "*** shared version of the library, which you do not appear to have."
6966		if test "$module" = yes; then
6967	<	$echo "*** But as you try to build a module library, libtool will still create "
6968	<	$echo "*** a static module, that should work as long as the dlopening application"
6969	<	$echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6967	>	echo "*** But as you try to build a module library, libtool will still create "
6968	>	echo "*** a static module, that should work as long as the dlopening application"
6969	>	echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6970		if test -z "$global_symbol_pipe"; then
6971	<	$echo
6972	<	$echo "*** However, this would only work if libtool was able to extract symbol"
6973	<	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6974	<	$echo "*** not find such a program.  So, this module is probably useless."
6975	<	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
6971	>	echo
6972	>	echo "*** However, this would only work if libtool was able to extract symbol"
6973	>	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6974	>	echo "*** not find such a program.  So, this module is probably useless."
6975	>	echo "*** \`nm' from GNU binutils and a full rebuild may help."
6976		fi
6977		if test "$build_old_libs" = no; then
6978		build_libtool_libs=module
#	Line 2500 | Line 6982 | EOF
6982		fi
6983		fi
6984		else
2503	–	convenience="$convenience $dir/$old_library"
2504	–	old_convenience="$old_convenience $dir/$old_library"
6985		deplibs="$dir/$old_library $deplibs"
6986		link_static=yes
6987		fi
#	Line 2509 | Line 6989 | EOF
6989
6990		if test "$linkmode" = lib; then
6991		if test -n "$dependency_libs" &&
6992	<	{ test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
6992	>	{ test "$hardcode_into_libs" != yes ||
6993	>	test "$build_old_libs" = yes ||
6994		test "$link_static" = yes; }; then
6995		# Extract -R from dependency_libs
6996		temp_deplibs=
6997		for libdir in $dependency_libs; do
6998		case $libdir in
6999	<	-R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
6999	>	-R*) func_stripname '-R' '' "$libdir"
7000	>	temp_xrpath=$func_stripname_result
7001		case " $xrpath " in
7002		*" $temp_xrpath "*) ;;
7003	<	*) xrpath="$xrpath $temp_xrpath";;
7003	>	*) func_append xrpath " $temp_xrpath";;
7004		esac;;
7005	<	*) temp_deplibs="$temp_deplibs $libdir";;
7005	>	*) func_append temp_deplibs " $libdir";;
7006		esac
7007		done
7008		dependency_libs="$temp_deplibs"
7009		fi
7010
7011	<	newlib_search_path="$newlib_search_path $absdir"
7011	>	func_append newlib_search_path " $absdir"
7012		# Link against this library
7013		test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7014		# ... and its dependency_libs
7015		tmp_libs=
7016		for deplib in $dependency_libs; do
7017		newdependency_libs="$deplib $newdependency_libs"
7018	<	if test "X$duplicate_deps" = "Xyes" ; then
7018	>	case $deplib in
7019	>	-L*) func_stripname '-L' '' "$deplib"
7020	>	func_resolve_sysroot "$func_stripname_result";;
7021	>	*) func_resolve_sysroot "$deplib" ;;
7022	>	esac
7023	>	if $opt_preserve_dup_deps ; then
7024		case "$tmp_libs " in
7025	<	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
7025	>	*" $func_resolve_sysroot_result "*)
7026	>	func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7027		esac
7028		fi
7029	<	tmp_libs="$tmp_libs $deplib"
7029	>	func_append tmp_libs " $func_resolve_sysroot_result"
7030		done
7031
7032		if test "$link_all_deplibs" != no; then
7033		# Add the search paths of all dependency libraries
7034		for deplib in $dependency_libs; do
7035	+	path=
7036		case $deplib in
7037		-L*) path="$deplib" ;;
7038		*.la)
7039	<	dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
7040	<	test "X$dir" = "X$deplib" && dir="."
7039	>	func_resolve_sysroot "$deplib"
7040	>	deplib=$func_resolve_sysroot_result
7041	>	func_dirname "$deplib" "" "."
7042	>	dir=$func_dirname_result
7043		# We need an absolute path.
7044		case $dir in
7045		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7046		*)
7047		absdir=`cd "$dir" && pwd`
7048		if test -z "$absdir"; then
7049	<	$echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
7049	>	func_warning "cannot determine absolute directory name of \`$dir'"
7050		absdir="$dir"
7051		fi
7052		;;
7053		esac
7054	<	if grep "^installed=no" $deplib > /dev/null; then
2564	<	path="$absdir/$objdir"
2565	<	else
2566	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2567	<	if test -z "$libdir"; then
2568	<	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2569	<	exit 1
2570	<	fi
2571	<	if test "$absdir" != "$libdir"; then
2572	<	$echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2573	<	fi
2574	<	path="$absdir"
2575	<	fi
2576	<	depdepl=
7054	>	if $GREP "^installed=no" $deplib > /dev/null; then
7055		case $host in
7056		*-*-darwin*)
7057	<	# we do not want to link against static libs, but need to link against shared
7057	>	depdepl=
7058		eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7059		if test -n "$deplibrary_names" ; then
7060		for tmp in $deplibrary_names ; do
7061		depdepl=$tmp
7062		done
7063	<	if test -f "$path/$depdepl" ; then
7064	<	depdepl="$path/$depdepl"
7065	<	fi
7066	<	newlib_search_path="$newlib_search_path $path"
7067	<	path=""
7063	>	if test -f "$absdir/$objdir/$depdepl" ; then
7064	>	depdepl="$absdir/$objdir/$depdepl"
7065	>	darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7066	>	if test -z "$darwin_install_name"; then
7067	>	darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
7068	>	fi
7069	>	func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7070	>	func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7071	>	path=
7072	>	fi
7073		fi
7074		;;
7075		*)
7076	<	path="-L$path"
2594	<	;;
2595	<	esac
2596	<
2597	<	;;
2598	<	-l*)
2599	<	case $host in
2600	<	*-*-darwin*)
2601	<	# Again, we only want to link against shared libraries
2602	<	eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2603	<	for tmp in $newlib_search_path ; do
2604	<	if test -f "$tmp/lib$tmp_libs.dylib" ; then
2605	<	eval depdepl="$tmp/lib$tmp_libs.dylib"
2606	<	break
2607	<	fi
2608	<	done
2609	<	path=""
7076	>	path="-L$absdir/$objdir"
7077		;;
7078	<	*) continue ;;
7079	<	esac
7078	>	esac
7079	>	else
7080	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7081	>	test -z "$libdir" && \
7082	>	func_fatal_error "\`$deplib' is not a valid libtool archive"
7083	>	test "$absdir" != "$libdir" && \
7084	>	func_warning "\`$deplib' seems to be moved"
7085	>
7086	>	path="-L$absdir"
7087	>	fi
7088		;;
2614	–	*) continue ;;
7089		esac
7090		case " $deplibs " in
2617	–	*" $depdepl "*) ;;
2618	–	*) deplibs="$deplibs $depdepl" ;;
2619	–	esac
2620	–	case " $deplibs " in
7091		*" $path "*) ;;
7092	<	*) deplibs="$deplibs $path" ;;
7092	>	*) deplibs="$path $deplibs" ;;
7093		esac
7094		done
7095		fi # link_all_deplibs != no
7096		fi # linkmode = lib
7097		done # for deplib in $libs
7098	+	if test "$pass" = link; then
7099	+	if test "$linkmode" = "prog"; then
7100	+	compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7101	+	finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7102	+	else
7103	+	compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7104	+	fi
7105	+	fi
7106		dependency_libs="$newdependency_libs"
7107		if test "$pass" = dlpreopen; then
7108		# Link the dlpreopened libraries before other libraries
#	Line 2639 | Line 7117 | EOF
7117		for dir in $newlib_search_path; do
7118		case "$lib_search_path " in
7119		*" $dir "*) ;;
7120	<	*) lib_search_path="$lib_search_path $dir" ;;
7120	>	*) func_append lib_search_path " $dir" ;;
7121		esac
7122		done
7123		newlib_search_path=
#	Line 2697 | Line 7175 | EOF
7175		-L*)
7176		case " $tmp_libs " in
7177		*" $deplib "*) ;;
7178	<	*) tmp_libs="$tmp_libs $deplib" ;;
7178	>	*) func_append tmp_libs " $deplib" ;;
7179		esac
7180		;;
7181	<	*) tmp_libs="$tmp_libs $deplib" ;;
7181	>	*) func_append tmp_libs " $deplib" ;;
7182		esac
7183		done
7184		eval $var=\"$tmp_libs\"
7185		done # for var
7186		fi
7187	<	# Last step: remove runtime libs from dependency_libs (they stay in deplibs)
7187	>	# Last step: remove runtime libs from dependency_libs
7188	>	# (they stay in deplibs)
7189		tmp_libs=
7190		for i in $dependency_libs ; do
7191		case " $predeps $postdeps $compiler_lib_search_path " in
#	Line 2715 | Line 7194 | EOF
7194		;;
7195		esac
7196		if test -n "$i" ; then
7197	<	tmp_libs="$tmp_libs $i"
7197	>	func_append tmp_libs " $i"
7198		fi
7199		done
7200		dependency_libs=$tmp_libs
7201		done # for pass
7202		if test "$linkmode" = prog; then
7203		dlfiles="$newdlfiles"
7204	+	fi
7205	+	if test "$linkmode" = prog || test "$linkmode" = lib; then
7206		dlprefiles="$newdlprefiles"
7207		fi
7208
7209		case $linkmode in
7210		oldlib)
2730	–	if test -n "$deplibs"; then
2731	–	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2732	–	fi
2733	–
7211		if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7212	<	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
7212	>	func_warning "\`-dlopen' is ignored for archives"
7213		fi
7214
7215	<	if test -n "$rpath"; then
7216	<	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
7217	<	fi
7215	>	case " $deplibs" in
7216	>	*\ -l* | *\ -L*)
7217	>	func_warning "\`-l' and \`-L' are ignored for archives" ;;
7218	>	esac
7219
7220	<	if test -n "$xrpath"; then
7221	<	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2744	<	fi
7220	>	test -n "$rpath" && \
7221	>	func_warning "\`-rpath' is ignored for archives"
7222
7223	<	if test -n "$vinfo"; then
7224	<	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2748	<	fi
7223	>	test -n "$xrpath" && \
7224	>	func_warning "\`-R' is ignored for archives"
7225
7226	<	if test -n "$release"; then
7227	<	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2752	<	fi
7226	>	test -n "$vinfo" && \
7227	>	func_warning "\`-version-info/-version-number' is ignored for archives"
7228
7229	<	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
7230	<	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
7231	<	fi
7229	>	test -n "$release" && \
7230	>	func_warning "\`-release' is ignored for archives"
7231	>
7232	>	test -n "$export_symbols$export_symbols_regex" && \
7233	>	func_warning "\`-export-symbols' is ignored for archives"
7234
7235		# Now set the variables for building old libraries.
7236		build_libtool_libs=no
7237		oldlibs="$output"
7238	<	objs="$objs$old_deplibs"
7238	>	func_append objs "$old_deplibs"
7239		;;
7240
7241		lib)
7242		# Make sure we only generate libraries of the form `libNAME.la'.
7243		case $outputname in
7244		lib*)
7245	<	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
7246	<	eval shared_ext=\"$shrext\"
7245	>	func_stripname 'lib' '.la' "$outputname"
7246	>	name=$func_stripname_result
7247	>	eval shared_ext=\"$shrext_cmds\"
7248		eval libname=\"$libname_spec\"
7249		;;
7250		*)
7251	<	if test "$module" = no; then
7252	<	$echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
7253	<	$echo "$help" 1>&2
2776	<	exit 1
2777	<	fi
7251	>	test "$module" = no && \
7252	>	func_fatal_help "libtool library \`$output' must begin with \`lib'"
7253	>
7254		if test "$need_lib_prefix" != no; then
7255		# Add the "lib" prefix for modules if required
7256	<	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
7257	<	eval shared_ext=\"$shrext\"
7256	>	func_stripname '' '.la' "$outputname"
7257	>	name=$func_stripname_result
7258	>	eval shared_ext=\"$shrext_cmds\"
7259		eval libname=\"$libname_spec\"
7260		else
7261	<	libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
7261	>	func_stripname '' '.la' "$outputname"
7262	>	libname=$func_stripname_result
7263		fi
7264		;;
7265		esac
7266
7267		if test -n "$objs"; then
7268		if test "$deplibs_check_method" != pass_all; then
7269	<	$echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2792	<	exit 1
7269	>	func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7270		else
7271	<	$echo
7272	<	$echo "*** Warning: Linking the shared library $output against the non-libtool"
7273	<	$echo "*** objects $objs is not portable!"
7274	<	libobjs="$libobjs $objs"
7271	>	echo
7272	>	$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7273	>	$ECHO "*** objects $objs is not portable!"
7274	>	func_append libobjs " $objs"
7275		fi
7276		fi
7277
7278	<	if test "$dlself" != no; then
7279	<	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2803	<	fi
7278	>	test "$dlself" != no && \
7279	>	func_warning "\`-dlopen self' is ignored for libtool libraries"
7280
7281		set dummy $rpath
7282	<	if test "$#" -gt 2; then
7283	<	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
7284	<	fi
7285	<	install_libdir="$2"
7282	>	shift
7283	>	test "$#" -gt 1 && \
7284	>	func_warning "ignoring multiple \`-rpath's for a libtool library"
7285	>
7286	>	install_libdir="$1"
7287
7288		oldlibs=
7289		if test -z "$rpath"; then
#	Line 2820 | Line 7297 | EOF
7297		build_old_libs=yes
7298		fi
7299
7300	<	if test -n "$vinfo"; then
7301	<	$echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2825	<	fi
7300	>	test -n "$vinfo" && \
7301	>	func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7302
7303	<	if test -n "$release"; then
7304	<	$echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2829	<	fi
7303	>	test -n "$release" && \
7304	>	func_warning "\`-release' is ignored for convenience libraries"
7305		else
7306
7307		# Parse the version information argument.
7308		save_ifs="$IFS"; IFS=':'
7309		set dummy $vinfo 0 0 0
7310	+	shift
7311		IFS="$save_ifs"
7312
7313	<	if test -n "$8"; then
7314	<	$echo "$modename: too many parameters to \`-version-info'" 1>&2
2839	<	$echo "$help" 1>&2
2840	<	exit 1
2841	<	fi
7313	>	test -n "$7" && \
7314	>	func_fatal_help "too many parameters to \`-version-info'"
7315
7316		# convert absolute version numbers to libtool ages
7317		# this retains compatibility with .la files and attempts
7318		# to make the code below a bit more comprehensible
7319	<
7319	>
7320		case $vinfo_number in
7321		yes)
7322	<	number_major="$2"
7323	<	number_minor="$3"
7324	<	number_revision="$4"
7322	>	number_major="$1"
7323	>	number_minor="$2"
7324	>	number_revision="$3"
7325		#
7326		# There are really only two kinds -- those that
7327		# use the current revision as the major version
#	Line 2857 | Line 7330 | EOF
7330		# which has an extra 1 added just for fun
7331		#
7332		case $version_type in
7333	<	darwin|linux|osf|windows)
7334	<	current=`expr $number_major + $number_minor`
7333	>	# correct linux to gnu/linux during the next big refactor
7334	>	darwin|linux|osf|windows|none)
7335	>	func_arith $number_major + $number_minor
7336	>	current=$func_arith_result
7337		age="$number_minor"
7338		revision="$number_revision"
7339		;;
7340	<	freebsd-aout|freebsd-elf|sunos)
7340	>	freebsd-aout|freebsd-elf|qnx|sunos)
7341		current="$number_major"
7342		revision="$number_minor"
7343		age="0"
7344		;;
7345		irix|nonstopux)
7346	<	current=`expr $number_major + $number_minor - 1`
7346	>	func_arith $number_major + $number_minor
7347	>	current=$func_arith_result
7348		age="$number_minor"
7349		revision="$number_minor"
7350	+	lt_irix_increment=no
7351		;;
7352		esac
7353		;;
7354		no)
7355	<	current="$2"
7356	<	revision="$3"
7357	<	age="$4"
7355	>	current="$1"
7356	>	revision="$2"
7357	>	age="$3"
7358		;;
7359		esac
7360
7361		# Check that each of the things are valid numbers.
7362		case $current in
7363	<	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
7363	>	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]) ;;
7364		*)
7365	<	$echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
7366	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
2890	<	exit 1
7365	>	func_error "CURRENT \`$current' must be a nonnegative integer"
7366	>	func_fatal_error "\`$vinfo' is not valid version information"
7367		;;
7368		esac
7369
7370		case $revision in
7371	<	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
7371	>	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]) ;;
7372		*)
7373	<	$echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
7374	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
2899	<	exit 1
7373	>	func_error "REVISION \`$revision' must be a nonnegative integer"
7374	>	func_fatal_error "\`$vinfo' is not valid version information"
7375		;;
7376		esac
7377
7378		case $age in
7379	<	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
7379	>	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]) ;;
7380		*)
7381	<	$echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
7382	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
2908	<	exit 1
7381	>	func_error "AGE \`$age' must be a nonnegative integer"
7382	>	func_fatal_error "\`$vinfo' is not valid version information"
7383		;;
7384		esac
7385
7386		if test "$age" -gt "$current"; then
7387	<	$echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
7388	<	$echo "$modename: \`$vinfo' is not valid version information" 1>&2
2915	<	exit 1
7387	>	func_error "AGE \`$age' is greater than the current interface number \`$current'"
7388	>	func_fatal_error "\`$vinfo' is not valid version information"
7389		fi
7390
7391		# Calculate the version variables.
#	Line 2925 | Line 7398 | EOF
7398		darwin)
7399		# Like Linux, but with the current version available in
7400		# verstring for coding it into the library header
7401	<	major=.`expr $current - $age`
7401	>	func_arith $current - $age
7402	>	major=.$func_arith_result
7403		versuffix="$major.$age.$revision"
7404		# Darwin ld doesn't like 0 for these options...
7405	<	minor_current=`expr $current + 1`
7405	>	func_arith $current + 1
7406	>	minor_current=$func_arith_result
7407	>	xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7408		verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7409		;;
7410
#	Line 2939 | Line 7415 | EOF
7415
7416		freebsd-elf)
7417		major=".$current"
7418	<	versuffix=".$current";
7418	>	versuffix=".$current"
7419		;;
7420
7421		irix | nonstopux)
7422	<	major=`expr $current - $age + 1`
7422	>	if test "X$lt_irix_increment" = "Xno"; then
7423	>	func_arith $current - $age
7424	>	else
7425	>	func_arith $current - $age + 1
7426	>	fi
7427	>	major=$func_arith_result
7428
7429		case $version_type in
7430		nonstopux) verstring_prefix=nonstopux ;;
#	Line 2954 | Line 7435 | EOF
7435		# Add in all the interfaces that we are compatible with.
7436		loop=$revision
7437		while test "$loop" -ne 0; do
7438	<	iface=`expr $revision - $loop`
7439	<	loop=`expr $loop - 1`
7438	>	func_arith $revision - $loop
7439	>	iface=$func_arith_result
7440	>	func_arith $loop - 1
7441	>	loop=$func_arith_result
7442		verstring="$verstring_prefix$major.$iface:$verstring"
7443		done
7444
#	Line 2964 | Line 7447 | EOF
7447		versuffix="$major.$revision"
7448		;;
7449
7450	<	linux)
7451	<	major=.`expr $current - $age`
7450	>	linux) # correct to gnu/linux during the next big refactor
7451	>	func_arith $current - $age
7452	>	major=.$func_arith_result
7453		versuffix="$major.$age.$revision"
7454		;;
7455
7456		osf)
7457	<	major=.`expr $current - $age`
7457	>	func_arith $current - $age
7458	>	major=.$func_arith_result
7459		versuffix=".$current.$age.$revision"
7460		verstring="$current.$age.$revision"
7461
7462		# Add in all the interfaces that we are compatible with.
7463		loop=$age
7464		while test "$loop" -ne 0; do
7465	<	iface=`expr $current - $loop`
7466	<	loop=`expr $loop - 1`
7465	>	func_arith $current - $loop
7466	>	iface=$func_arith_result
7467	>	func_arith $loop - 1
7468	>	loop=$func_arith_result
7469		verstring="$verstring:${iface}.0"
7470		done
7471
7472		# Make executables depend on our current version.
7473	<	verstring="$verstring:${current}.0"
7473	>	func_append verstring ":${current}.0"
7474	>	;;
7475	>
7476	>	qnx)
7477	>	major=".$current"
7478	>	versuffix=".$current"
7479		;;
7480
7481		sunos)
#	Line 2994 | Line 7486 | EOF
7486		windows)
7487		# Use '-' rather than '.', since we only want one
7488		# extension on DOS 8.3 filesystems.
7489	<	major=`expr $current - $age`
7489	>	func_arith $current - $age
7490	>	major=$func_arith_result
7491		versuffix="-$major"
7492		;;
7493
7494		*)
7495	<	$echo "$modename: unknown library version type \`$version_type'" 1>&2
3003	<	$echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3004	<	exit 1
7495	>	func_fatal_configuration "unknown library version type \`$version_type'"
7496		;;
7497		esac
7498
#	Line 3035 | Line 7526 | EOF
7526		# Check to see if the archive will have undefined symbols.
7527		if test "$allow_undefined" = yes; then
7528		if test "$allow_undefined_flag" = unsupported; then
7529	<	$echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
7529	>	func_warning "undefined symbols not allowed in $host shared libraries"
7530		build_libtool_libs=no
7531		build_old_libs=yes
7532		fi
#	Line 3043 | Line 7534 | EOF
7534		# Don't allow undefined symbols.
7535		allow_undefined_flag="$no_undefined_flag"
7536		fi
7537	+
7538		fi
7539
7540	<	if test "$mode" != relink; then
7540	>	func_generate_dlsyms "$libname" "$libname" "yes"
7541	>	func_append libobjs " $symfileobj"
7542	>	test "X$libobjs" = "X " && libobjs=
7543	>
7544	>	if test "$opt_mode" != relink; then
7545		# Remove our outputs, but don't remove object files since they
7546		# may have been created when compiling PIC objects.
7547		removelist=
7548	<	tempremovelist=`$echo "$output_objdir/*"`
7548	>	tempremovelist=`$ECHO "$output_objdir/*"`
7549		for p in $tempremovelist; do
7550		case $p in
7551	<	*.$objext)
7551	>	*.$objext | *.gcno)
7552		;;
7553		$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7554	<	removelist="$removelist $p"
7554	>	if test "X$precious_files_regex" != "X"; then
7555	>	if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7556	>	then
7557	>	continue
7558	>	fi
7559	>	fi
7560	>	func_append removelist " $p"
7561		;;
7562		*) ;;
7563		esac
7564		done
7565	<	if test -n "$removelist"; then
7566	<	$show "${rm}r $removelist"
3065	<	$run ${rm}r $removelist
3066	<	fi
7565	>	test -n "$removelist" && \
7566	>	func_show_eval "${RM}r \$removelist"
7567		fi
7568
7569		# Now set the variables for building old libraries.
7570		if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7571	<	oldlibs="$oldlibs $output_objdir/$libname.$libext"
7571	>	func_append oldlibs " $output_objdir/$libname.$libext"
7572
7573		# Transform .lo files to .o files.
7574	<	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
7574	>	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7575		fi
7576
7577		# Eliminate all temporary directories.
7578	<	for path in $notinst_path; do
7579	<	lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
7580	<	deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
7581	<	dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
7582	<	done
7578	>	#for path in $notinst_path; do
7579	>	# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7580	>	# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7581	>	# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7582	>	#done
7583
7584		if test -n "$xrpath"; then
7585		# If the user specified any rpath flags, then add them.
7586		temp_xrpath=
7587		for libdir in $xrpath; do
7588	<	temp_xrpath="$temp_xrpath -R$libdir"
7588	>	func_replace_sysroot "$libdir"
7589	>	func_append temp_xrpath " -R$func_replace_sysroot_result"
7590		case "$finalize_rpath " in
7591		*" $libdir "*) ;;
7592	<	*) finalize_rpath="$finalize_rpath $libdir" ;;
7592	>	*) func_append finalize_rpath " $libdir" ;;
7593		esac
7594		done
7595		if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
#	Line 3102 | Line 7603 | EOF
7603		for lib in $old_dlfiles; do
7604		case " $dlprefiles $dlfiles " in
7605		*" $lib "*) ;;
7606	<	*) dlfiles="$dlfiles $lib" ;;
7606	>	*) func_append dlfiles " $lib" ;;
7607		esac
7608		done
7609
#	Line 3112 | Line 7613 | EOF
7613		for lib in $old_dlprefiles; do
7614		case "$dlprefiles " in
7615		*" $lib "*) ;;
7616	<	*) dlprefiles="$dlprefiles $lib" ;;
7616	>	*) func_append dlprefiles " $lib" ;;
7617		esac
7618		done
7619
7620		if test "$build_libtool_libs" = yes; then
7621		if test -n "$rpath"; then
7622		case $host in
7623	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
7623	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7624		# these systems don't actually have a c library (as such)!
7625		;;
7626		*-*-rhapsody* | *-*-darwin1.[012])
7627		# Rhapsody C library is in the System framework
7628	<	deplibs="$deplibs -framework System"
7628	>	func_append deplibs " System.ltframework"
7629		;;
7630		*-*-netbsd*)
7631		# Don't link with libc until the a.out ld.so is fixed.
7632		;;
7633	<	*-*-openbsd* | *-*-freebsd*)
7633	>	*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7634		# Do not include libc due to us having libc/libc_r.
3134	–	test "X$arg" = "X-lc" && continue
7635		;;
7636	<	*)
7636	>	*-*-sco3.2v5* | *-*-sco5v6*)
7637	>	# Causes problems with __ctype
7638	>	;;
7639	>	*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7640	>	# Compiler inserts libc in the correct place for threads to work
7641	>	;;
7642	>	*)
7643		# Add libc to deplibs on all other systems if necessary.
7644		if test "$build_libtool_need_lc" = "yes"; then
7645	<	deplibs="$deplibs -lc"
7645	>	func_append deplibs " -lc"
7646		fi
7647		;;
7648		esac
#	Line 3170 | Line 7676 | EOF
7676		# limits. Maybe even breaks it.  We compile a program, linking it
7677		# against the deplibs as a proxy for the library.  Then we can check
7678		# whether they linked in statically or dynamically with ldd.
7679	<	$rm conftest.c
7679	>	$opt_dry_run || $RM conftest.c
7680		cat > conftest.c <<EOF
7681		int main() { return 0; }
7682		EOF
7683	<	$rm conftest
7684	<	$LTCC $archargs -o conftest conftest.c $deplibs
3179	<	if test "$?" -eq 0 ; then
7683	>	$opt_dry_run || $RM conftest
7684	>	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7685		ldd_output=`ldd conftest`
7686		for i in $deplibs; do
7687	<	name="`expr $i : '-l\(.*\)'`"
7688	<	# If $name is empty we are operating on a -L argument.
7689	<	if test "$name" != "" && test "$name" -ne "0"; then
7687	>	case $i in
7688	>	-l*)
7689	>	func_stripname -l '' "$i"
7690	>	name=$func_stripname_result
7691		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7692		case " $predeps $postdeps " in
7693		*" $i "*)
7694	<	newdeplibs="$newdeplibs $i"
7694	>	func_append newdeplibs " $i"
7695		i=""
7696		;;
7697		esac
7698	<	fi
7698	>	fi
7699		if test -n "$i" ; then
7700	<	libname=`eval \\$echo \"$libname_spec\"`
7701	<	deplib_matches=`eval \\$echo \"$library_names_spec\"`
7702	<	set dummy $deplib_matches
7703	<	deplib_match=$2
7700	>	libname=`eval "\\$ECHO \"$libname_spec\""`
7701	>	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7702	>	set dummy $deplib_matches; shift
7703	>	deplib_match=$1
7704		if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7705	<	newdeplibs="$newdeplibs $i"
7705	>	func_append newdeplibs " $i"
7706		else
7707		droppeddeps=yes
7708	<	$echo
7709	<	$echo "*** Warning: dynamic linker does not accept needed library $i."
7710	<	$echo "*** I have the capability to make that library automatically link in when"
7711	<	$echo "*** you link to this library.  But I can only do this if you have a"
7712	<	$echo "*** shared version of the library, which I believe you do not have"
7713	<	$echo "*** because a test_compile did reveal that the linker did not use it for"
7714	<	$echo "*** its dynamic dependency list that programs get resolved with at runtime."
7708	>	echo
7709	>	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7710	>	echo "*** I have the capability to make that library automatically link in when"
7711	>	echo "*** you link to this library.  But I can only do this if you have a"
7712	>	echo "*** shared version of the library, which I believe you do not have"
7713	>	echo "*** because a test_compile did reveal that the linker did not use it for"
7714	>	echo "*** its dynamic dependency list that programs get resolved with at runtime."
7715		fi
7716		fi
7717	<	else
7718	<	newdeplibs="$newdeplibs $i"
7719	<	fi
7717	>	;;
7718	>	*)
7719	>	func_append newdeplibs " $i"
7720	>	;;
7721	>	esac
7722		done
7723		else
7724		# Error occurred in the first compile.  Let's try to salvage
7725		# the situation: Compile a separate program for each library.
7726		for i in $deplibs; do
7727	<	name="`expr $i : '-l\(.*\)'`"
7728	<	# If $name is empty we are operating on a -L argument.
7729	<	if test "$name" != "" && test "$name" != "0"; then
7730	<	$rm conftest
7731	<	$LTCC $archargs -o conftest conftest.c $i
7732	<	# Did it work?
3225	<	if test "$?" -eq 0 ; then
7727	>	case $i in
7728	>	-l*)
7729	>	func_stripname -l '' "$i"
7730	>	name=$func_stripname_result
7731	>	$opt_dry_run || $RM conftest
7732	>	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7733		ldd_output=`ldd conftest`
7734		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7735		case " $predeps $postdeps " in
7736		*" $i "*)
7737	<	newdeplibs="$newdeplibs $i"
7737	>	func_append newdeplibs " $i"
7738		i=""
7739		;;
7740		esac
7741		fi
7742		if test -n "$i" ; then
7743	<	libname=`eval \\$echo \"$libname_spec\"`
7744	<	deplib_matches=`eval \\$echo \"$library_names_spec\"`
7745	<	set dummy $deplib_matches
7746	<	deplib_match=$2
7743	>	libname=`eval "\\$ECHO \"$libname_spec\""`
7744	>	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7745	>	set dummy $deplib_matches; shift
7746	>	deplib_match=$1
7747		if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7748	<	newdeplibs="$newdeplibs $i"
7748	>	func_append newdeplibs " $i"
7749		else
7750		droppeddeps=yes
7751	<	$echo
7752	<	$echo "*** Warning: dynamic linker does not accept needed library $i."
7753	<	$echo "*** I have the capability to make that library automatically link in when"
7754	<	$echo "*** you link to this library.  But I can only do this if you have a"
7755	<	$echo "*** shared version of the library, which you do not appear to have"
7756	<	$echo "*** because a test_compile did reveal that the linker did not use this one"
7757	<	$echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7751	>	echo
7752	>	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7753	>	echo "*** I have the capability to make that library automatically link in when"
7754	>	echo "*** you link to this library.  But I can only do this if you have a"
7755	>	echo "*** shared version of the library, which you do not appear to have"
7756	>	echo "*** because a test_compile did reveal that the linker did not use this one"
7757	>	echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7758		fi
7759		fi
7760		else
7761		droppeddeps=yes
7762	<	$echo
7763	<	$echo "*** Warning!  Library $i is needed by this library but I was not able to"
7764	<	$echo "***  make it link in!  You will probably need to install it or some"
7765	<	$echo "*** library that it depends on before this library will be fully"
7766	<	$echo "*** functional.  Installing it before continuing would be even better."
7762	>	echo
7763	>	$ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7764	>	echo "*** make it link in!  You will probably need to install it or some"
7765	>	echo "*** library that it depends on before this library will be fully"
7766	>	echo "*** functional.  Installing it before continuing would be even better."
7767		fi
7768	<	else
7769	<	newdeplibs="$newdeplibs $i"
7770	<	fi
7768	>	;;
7769	>	*)
7770	>	func_append newdeplibs " $i"
7771	>	;;
7772	>	esac
7773		done
7774		fi
7775		;;
7776		file_magic*)
7777	<	set dummy $deplibs_check_method
7778	<	file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
7777	>	set dummy $deplibs_check_method; shift
7778	>	file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7779		for a_deplib in $deplibs; do
7780	<	name="`expr $a_deplib : '-l\(.*\)'`"
7781	<	# If $name is empty we are operating on a -L argument.
7782	<	if test "$name" != "" && test  "$name" != "0"; then
7780	>	case $a_deplib in
7781	>	-l*)
7782	>	func_stripname -l '' "$a_deplib"
7783	>	name=$func_stripname_result
7784		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7785		case " $predeps $postdeps " in
7786		*" $a_deplib "*)
7787	<	newdeplibs="$newdeplibs $a_deplib"
7787	>	func_append newdeplibs " $a_deplib"
7788		a_deplib=""
7789		;;
7790		esac
7791		fi
7792		if test -n "$a_deplib" ; then
7793	<	libname=`eval \\$echo \"$libname_spec\"`
7793	>	libname=`eval "\\$ECHO \"$libname_spec\""`
7794	>	if test -n "$file_magic_glob"; then
7795	>	libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7796	>	else
7797	>	libnameglob=$libname
7798	>	fi
7799	>	test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7800		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7801	<	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7801	>	if test "$want_nocaseglob" = yes; then
7802	>	shopt -s nocaseglob
7803	>	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7804	>	$nocaseglob
7805	>	else
7806	>	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7807	>	fi
7808		for potent_lib in $potential_libs; do
7809		# Follow soft links.
7810	<	if ls -lLd "$potent_lib" 2>/dev/null \
7811	<	| grep " -> " >/dev/null; then
7810	>	if ls -lLd "$potent_lib" 2>/dev/null |
7811	>	$GREP " -> " >/dev/null; then
7812		continue
7813		fi
7814		# The statement above tries to avoid entering an
#	Line 3299 | Line 7821 | EOF
7821		potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7822		case $potliblink in
7823		[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7824	<	*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7824	>	*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7825		esac
7826		done
7827	<	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
7828	<	| ${SED} 10q \
7829	<	| $EGREP "$file_magic_regex" > /dev/null; then
7830	<	newdeplibs="$newdeplibs $a_deplib"
7827	>	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7828	>	$SED -e 10q |
7829	>	$EGREP "$file_magic_regex" > /dev/null; then
7830	>	func_append newdeplibs " $a_deplib"
7831		a_deplib=""
7832		break 2
7833		fi
#	Line 3314 | Line 7836 | EOF
7836		fi
7837		if test -n "$a_deplib" ; then
7838		droppeddeps=yes
7839	<	$echo
7840	<	$echo "*** Warning: linker path does not have real file for library $a_deplib."
7841	<	$echo "*** I have the capability to make that library automatically link in when"
7842	<	$echo "*** you link to this library.  But I can only do this if you have a"
7843	<	$echo "*** shared version of the library, which you do not appear to have"
7844	<	$echo "*** because I did check the linker path looking for a file starting"
7839	>	echo
7840	>	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7841	>	echo "*** I have the capability to make that library automatically link in when"
7842	>	echo "*** you link to this library.  But I can only do this if you have a"
7843	>	echo "*** shared version of the library, which you do not appear to have"
7844	>	echo "*** because I did check the linker path looking for a file starting"
7845		if test -z "$potlib" ; then
7846	<	$echo "*** with $libname but no candidates were found. (...for file magic test)"
7846	>	$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7847		else
7848	<	$echo "*** with $libname and none of the candidates passed a file format test"
7849	<	$echo "*** using a file magic. Last file checked: $potlib"
7848	>	$ECHO "*** with $libname and none of the candidates passed a file format test"
7849	>	$ECHO "*** using a file magic. Last file checked: $potlib"
7850		fi
7851		fi
7852	<	else
7852	>	;;
7853	>	*)
7854		# Add a -L argument.
7855	<	newdeplibs="$newdeplibs $a_deplib"
7856	<	fi
7855	>	func_append newdeplibs " $a_deplib"
7856	>	;;
7857	>	esac
7858		done # Gone through all deplibs.
7859		;;
7860		match_pattern*)
7861	<	set dummy $deplibs_check_method
7862	<	match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
7861	>	set dummy $deplibs_check_method; shift
7862	>	match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7863		for a_deplib in $deplibs; do
7864	<	name="`expr $a_deplib : '-l\(.*\)'`"
7865	<	# If $name is empty we are operating on a -L argument.
7866	<	if test -n "$name" && test "$name" != "0"; then
7864	>	case $a_deplib in
7865	>	-l*)
7866	>	func_stripname -l '' "$a_deplib"
7867	>	name=$func_stripname_result
7868		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7869		case " $predeps $postdeps " in
7870		*" $a_deplib "*)
7871	<	newdeplibs="$newdeplibs $a_deplib"
7871	>	func_append newdeplibs " $a_deplib"
7872		a_deplib=""
7873		;;
7874		esac
7875		fi
7876		if test -n "$a_deplib" ; then
7877	<	libname=`eval \\$echo \"$libname_spec\"`
7877	>	libname=`eval "\\$ECHO \"$libname_spec\""`
7878		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7879		potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7880		for potent_lib in $potential_libs; do
7881		potlib="$potent_lib" # see symlink-check above in file_magic test
7882	<	if eval $echo \"$potent_lib\" 2>/dev/null \
7883	<	| ${SED} 10q \
7884	<	| $EGREP "$match_pattern_regex" > /dev/null; then
3360	<	newdeplibs="$newdeplibs $a_deplib"
7882	>	if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7883	>	$EGREP "$match_pattern_regex" > /dev/null; then
7884	>	func_append newdeplibs " $a_deplib"
7885		a_deplib=""
7886		break 2
7887		fi
#	Line 3366 | Line 7890 | EOF
7890		fi
7891		if test -n "$a_deplib" ; then
7892		droppeddeps=yes
7893	<	$echo
7894	<	$echo "*** Warning: linker path does not have real file for library $a_deplib."
7895	<	$echo "*** I have the capability to make that library automatically link in when"
7896	<	$echo "*** you link to this library.  But I can only do this if you have a"
7897	<	$echo "*** shared version of the library, which you do not appear to have"
7898	<	$echo "*** because I did check the linker path looking for a file starting"
7893	>	echo
7894	>	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7895	>	echo "*** I have the capability to make that library automatically link in when"
7896	>	echo "*** you link to this library.  But I can only do this if you have a"
7897	>	echo "*** shared version of the library, which you do not appear to have"
7898	>	echo "*** because I did check the linker path looking for a file starting"
7899		if test -z "$potlib" ; then
7900	<	$echo "*** with $libname but no candidates were found. (...for regex pattern test)"
7900	>	$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7901		else
7902	<	$echo "*** with $libname and none of the candidates passed a file format test"
7903	<	$echo "*** using a regex pattern. Last file checked: $potlib"
7902	>	$ECHO "*** with $libname and none of the candidates passed a file format test"
7903	>	$ECHO "*** using a regex pattern. Last file checked: $potlib"
7904		fi
7905		fi
7906	<	else
7906	>	;;
7907	>	*)
7908		# Add a -L argument.
7909	<	newdeplibs="$newdeplibs $a_deplib"
7910	<	fi
7909	>	func_append newdeplibs " $a_deplib"
7910	>	;;
7911	>	esac
7912		done # Gone through all deplibs.
7913		;;
7914		none | unknown | *)
7915		newdeplibs=""
7916	<	tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3391	<	-e 's/ -[LR][^ ]*//g'`
7916	>	tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7917		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7918		for i in $predeps $postdeps ; do
7919		# can't use Xsed below, because $i might contain '/'
7920	<	tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
7920	>	tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7921		done
7922		fi
7923	<	if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
7924	<	| grep . >/dev/null; then
7925	<	$echo
7923	>	case $tmp_deplibs in
7924	>	*[!\  \ ]*)
7925	>	echo
7926		if test "X$deplibs_check_method" = "Xnone"; then
7927	<	$echo "*** Warning: inter-library dependencies are not supported in this platform."
7927	>	echo "*** Warning: inter-library dependencies are not supported in this platform."
7928		else
7929	<	$echo "*** Warning: inter-library dependencies are not known to be supported."
7929	>	echo "*** Warning: inter-library dependencies are not known to be supported."
7930		fi
7931	<	$echo "*** All declared inter-library dependencies are being dropped."
7931	>	echo "*** All declared inter-library dependencies are being dropped."
7932		droppeddeps=yes
7933	<	fi
7933	>	;;
7934	>	esac
7935		;;
7936		esac
7937		versuffix=$versuffix_save
#	Line 3416 | Line 7942 | EOF
7942
7943		case $host in
7944		*-*-rhapsody* | *-*-darwin1.[012])
7945	<	# On Rhapsody replace the C library is the System framework
7946	<	newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
7945	>	# On Rhapsody replace the C library with the System framework
7946	>	newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7947		;;
7948		esac
7949
7950		if test "$droppeddeps" = yes; then
7951		if test "$module" = yes; then
7952	<	$echo
7953	<	$echo "*** Warning: libtool could not satisfy all declared inter-library"
7954	<	$echo "*** dependencies of module $libname.  Therefore, libtool will create"
7955	<	$echo "*** a static module, that should work as long as the dlopening"
7956	<	$echo "*** application is linked with the -dlopen flag."
7952	>	echo
7953	>	echo "*** Warning: libtool could not satisfy all declared inter-library"
7954	>	$ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7955	>	echo "*** a static module, that should work as long as the dlopening"
7956	>	echo "*** application is linked with the -dlopen flag."
7957		if test -z "$global_symbol_pipe"; then
7958	<	$echo
7959	<	$echo "*** However, this would only work if libtool was able to extract symbol"
7960	<	$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7961	<	$echo "*** not find such a program.  So, this module is probably useless."
7962	<	$echo "*** \`nm' from GNU binutils and a full rebuild may help."
7958	>	echo
7959	>	echo "*** However, this would only work if libtool was able to extract symbol"
7960	>	echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7961	>	echo "*** not find such a program.  So, this module is probably useless."
7962	>	echo "*** \`nm' from GNU binutils and a full rebuild may help."
7963		fi
7964		if test "$build_old_libs" = no; then
7965		oldlibs="$output_objdir/$libname.$libext"
#	Line 3443 | Line 7969 | EOF
7969		build_libtool_libs=no
7970		fi
7971		else
7972	<	$echo "*** The inter-library dependencies that have been dropped here will be"
7973	<	$echo "*** automatically added whenever a program is linked with this library"
7974	<	$echo "*** or is declared to -dlopen it."
7972	>	echo "*** The inter-library dependencies that have been dropped here will be"
7973	>	echo "*** automatically added whenever a program is linked with this library"
7974	>	echo "*** or is declared to -dlopen it."
7975
7976		if test "$allow_undefined" = no; then
7977	<	$echo
7978	<	$echo "*** Since this library must not contain undefined symbols,"
7979	<	$echo "*** because either the platform does not support them or"
7980	<	$echo "*** it was explicitly requested with -no-undefined,"
7981	<	$echo "*** libtool will only create a static version of it."
7977	>	echo
7978	>	echo "*** Since this library must not contain undefined symbols,"
7979	>	echo "*** because either the platform does not support them or"
7980	>	echo "*** it was explicitly requested with -no-undefined,"
7981	>	echo "*** libtool will only create a static version of it."
7982		if test "$build_old_libs" = no; then
7983		oldlibs="$output_objdir/$libname.$libext"
7984		build_libtool_libs=module
#	Line 3466 | Line 7992 | EOF
7992		# Done checking deplibs!
7993		deplibs=$newdeplibs
7994		fi
7995	+	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7996	+	case $host in
7997	+	*-*-darwin*)
7998	+	newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7999	+	new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8000	+	deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8001	+	;;
8002	+	esac
8003	+
8004	+	# move library search paths that coincide with paths to not yet
8005	+	# installed libraries to the beginning of the library search list
8006	+	new_libs=
8007	+	for path in $notinst_path; do
8008	+	case " $new_libs " in
8009	+	*" -L$path/$objdir "*) ;;
8010	+	*)
8011	+	case " $deplibs " in
8012	+	*" -L$path/$objdir "*)
8013	+	func_append new_libs " -L$path/$objdir" ;;
8014	+	esac
8015	+	;;
8016	+	esac
8017	+	done
8018	+	for deplib in $deplibs; do
8019	+	case $deplib in
8020	+	-L*)
8021	+	case " $new_libs " in
8022	+	*" $deplib "*) ;;
8023	+	*) func_append new_libs " $deplib" ;;
8024	+	esac
8025	+	;;
8026	+	*) func_append new_libs " $deplib" ;;
8027	+	esac
8028	+	done
8029	+	deplibs="$new_libs"
8030
8031		# All the library-specific variables (install_libdir is set above).
8032		library_names=
#	Line 3474 | Line 8035 | EOF
8035
8036		# Test again, we may have decided not to build it any more
8037		if test "$build_libtool_libs" = yes; then
8038	+	# Remove ${wl} instances when linking with ld.
8039	+	# FIXME: should test the right _cmds variable.
8040	+	case $archive_cmds in
8041	+	*\$LD\ *) wl= ;;
8042	+	esac
8043		if test "$hardcode_into_libs" = yes; then
8044		# Hardcode the library paths
8045		hardcode_libdirs=
8046		dep_rpath=
8047		rpath="$finalize_rpath"
8048	<	test "$mode" != relink && rpath="$compile_rpath$rpath"
8048	>	test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8049		for libdir in $rpath; do
8050		if test -n "$hardcode_libdir_flag_spec"; then
8051		if test -n "$hardcode_libdir_separator"; then
8052	+	func_replace_sysroot "$libdir"
8053	+	libdir=$func_replace_sysroot_result
8054		if test -z "$hardcode_libdirs"; then
8055		hardcode_libdirs="$libdir"
8056		else
#	Line 3491 | Line 8059 | EOF
8059		*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8060		;;
8061		*)
8062	<	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8062	>	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8063		;;
8064		esac
8065		fi
8066		else
8067		eval flag=\"$hardcode_libdir_flag_spec\"
8068	<	dep_rpath="$dep_rpath $flag"
8068	>	func_append dep_rpath " $flag"
8069		fi
8070		elif test -n "$runpath_var"; then
8071		case "$perm_rpath " in
8072		*" $libdir "*) ;;
8073	<	*) perm_rpath="$perm_rpath $libdir" ;;
8073	>	*) func_append perm_rpath " $libdir" ;;
8074		esac
8075		fi
8076		done
#	Line 3510 | Line 8078 | EOF
8078		if test -n "$hardcode_libdir_separator" &&
8079		test -n "$hardcode_libdirs"; then
8080		libdir="$hardcode_libdirs"
8081	<	if test -n "$hardcode_libdir_flag_spec_ld"; then
3514	<	eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3515	<	else
3516	<	eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3517	<	fi
8081	>	eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8082		fi
8083		if test -n "$runpath_var" && test -n "$perm_rpath"; then
8084		# We should set the runpath_var.
8085		rpath=
8086		for dir in $perm_rpath; do
8087	<	rpath="$rpath$dir:"
8087	>	func_append rpath "$dir:"
8088		done
8089		eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8090		fi
#	Line 3528 | Line 8092 | EOF
8092		fi
8093
8094		shlibpath="$finalize_shlibpath"
8095	<	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8095	>	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8096		if test -n "$shlibpath"; then
8097		eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8098		fi
8099
8100		# Get the real and link names of the library.
8101	<	eval shared_ext=\"$shrext\"
8101	>	eval shared_ext=\"$shrext_cmds\"
8102		eval library_names=\"$library_names_spec\"
8103		set dummy $library_names
8104	<	realname="$2"
8105	<	shift; shift
8104	>	shift
8105	>	realname="$1"
8106	>	shift
8107
8108		if test -n "$soname_spec"; then
8109		eval soname=\"$soname_spec\"
#	Line 3550 | Line 8115 | EOF
8115		fi
8116
8117		lib="$output_objdir/$realname"
8118	+	linknames=
8119		for link
8120		do
8121	<	linknames="$linknames $link"
8121	>	func_append linknames " $link"
8122		done
8123
8124		# Use standard objects if they are pic
8125	<	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8125	>	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8126	>	test "X$libobjs" = "X " && libobjs=
8127	>
8128	>	delfiles=
8129	>	if test -n "$export_symbols" && test -n "$include_expsyms"; then
8130	>	$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8131	>	export_symbols="$output_objdir/$libname.uexp"
8132	>	func_append delfiles " $export_symbols"
8133	>	fi
8134	>
8135	>	orig_export_symbols=
8136	>	case $host_os in
8137	>	cygwin* | mingw* | cegcc*)
8138	>	if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8139	>	# exporting using user supplied symfile
8140	>	if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8141	>	# and it's NOT already a .def file. Must figure out
8142	>	# which of the given symbols are data symbols and tag
8143	>	# them as such. So, trigger use of export_symbols_cmds.
8144	>	# export_symbols gets reassigned inside the "prepare
8145	>	# the list of exported symbols" if statement, so the
8146	>	# include_expsyms logic still works.
8147	>	orig_export_symbols="$export_symbols"
8148	>	export_symbols=
8149	>	always_export_symbols=yes
8150	>	fi
8151	>	fi
8152	>	;;
8153	>	esac
8154
8155		# Prepare the list of exported symbols
8156		if test -z "$export_symbols"; then
8157		if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8158	<	$show "generating symbol list for \`$libname.la'"
8158	>	func_verbose "generating symbol list for \`$libname.la'"
8159		export_symbols="$output_objdir/$libname.exp"
8160	<	$run $rm $export_symbols
8161	<	eval cmds=\"$export_symbols_cmds\"
8162	<	save_ifs="$IFS"; IFS=$_S_
8163	<	for cmd in $cmds; do
8160	>	$opt_dry_run || $RM $export_symbols
8161	>	cmds=$export_symbols_cmds
8162	>	save_ifs="$IFS"; IFS='~'
8163	>	for cmd1 in $cmds; do
8164		IFS="$save_ifs"
8165	<	if len=`expr "X$cmd" : ".*"` &&
8166	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8167	<	$show "$cmd"
8168	<	$run eval "$cmd" || exit $?
8169	<	skipped_export=false
8165	>	# Take the normal branch if the nm_file_list_spec branch
8166	>	# doesn't work or if tool conversion is not needed.
8167	>	case $nm_file_list_spec~$to_tool_file_cmd in
8168	>	*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8169	>	try_normal_branch=yes
8170	>	eval cmd=\"$cmd1\"
8171	>	func_len " $cmd"
8172	>	len=$func_len_result
8173	>	;;
8174	>	*)
8175	>	try_normal_branch=no
8176	>	;;
8177	>	esac
8178	>	if test "$try_normal_branch" = yes \
8179	>	&& { test "$len" -lt "$max_cmd_len" \
8180	>	|| test "$max_cmd_len" -le -1; }
8181	>	then
8182	>	func_show_eval "$cmd" 'exit $?'
8183	>	skipped_export=false
8184	>	elif test -n "$nm_file_list_spec"; then
8185	>	func_basename "$output"
8186	>	output_la=$func_basename_result
8187	>	save_libobjs=$libobjs
8188	>	save_output=$output
8189	>	output=${output_objdir}/${output_la}.nm
8190	>	func_to_tool_file "$output"
8191	>	libobjs=$nm_file_list_spec$func_to_tool_file_result
8192	>	func_append delfiles " $output"
8193	>	func_verbose "creating $NM input file list: $output"
8194	>	for obj in $save_libobjs; do
8195	>	func_to_tool_file "$obj"
8196	>	$ECHO "$func_to_tool_file_result"
8197	>	done > "$output"
8198	>	eval cmd=\"$cmd1\"
8199	>	func_show_eval "$cmd" 'exit $?'
8200	>	output=$save_output
8201	>	libobjs=$save_libobjs
8202	>	skipped_export=false
8203		else
8204	<	# The command line is too long to execute in one step.
8205	<	$show "using reloadable object file for export list..."
8206	<	skipped_export=:
8204	>	# The command line is too long to execute in one step.
8205	>	func_verbose "using reloadable object file for export list..."
8206	>	skipped_export=:
8207	>	# Break out early, otherwise skipped_export may be
8208	>	# set to false by a later but shorter cmd.
8209	>	break
8210		fi
8211		done
8212		IFS="$save_ifs"
8213	<	if test -n "$export_symbols_regex"; then
8214	<	$show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
8215	<	$run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3586	<	$show "$mv \"${export_symbols}T\" \"$export_symbols\""
3587	<	$run eval '$mv "${export_symbols}T" "$export_symbols"'
8213	>	if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8214	>	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8215	>	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8216		fi
8217		fi
8218		fi
8219
8220		if test -n "$export_symbols" && test -n "$include_expsyms"; then
8221	<	$run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
8221	>	tmp_export_symbols="$export_symbols"
8222	>	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8223	>	$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8224	>	fi
8225	>
8226	>	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8227	>	# The given exports_symbols file has to be filtered, so filter it.
8228	>	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8229	>	# FIXME: $output_objdir/$libname.filter potentially contains lots of
8230	>	# 's' commands which not all seds can handle. GNU sed should be fine
8231	>	# though. Also, the filter scales superlinearly with the number of
8232	>	# global variables. join(1) would be nice here, but unfortunately
8233	>	# isn't a blessed tool.
8234	>	$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8235	>	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8236	>	export_symbols=$output_objdir/$libname.def
8237	>	$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8238		fi
8239
8240		tmp_deplibs=
8241		for test_deplib in $deplibs; do
8242	<	case " $convenience " in
8243	<	*" $test_deplib "*) ;;
8244	<	*)
8245	<	tmp_deplibs="$tmp_deplibs $test_deplib"
8246	<	;;
8247	<	esac
8242	>	case " $convenience " in
8243	>	*" $test_deplib "*) ;;
8244	>	*)
8245	>	func_append tmp_deplibs " $test_deplib"
8246	>	;;
8247	>	esac
8248		done
8249	<	deplibs="$tmp_deplibs"
8249	>	deplibs="$tmp_deplibs"
8250
8251		if test -n "$convenience"; then
8252	+	if test -n "$whole_archive_flag_spec" &&
8253	+	test "$compiler_needs_object" = yes &&
8254	+	test -z "$libobjs"; then
8255	+	# extract the archives, so we have objects to list.
8256	+	# TODO: could optimize this to just extract one archive.
8257	+	whole_archive_flag_spec=
8258	+	fi
8259		if test -n "$whole_archive_flag_spec"; then
8260		save_libobjs=$libobjs
8261		eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8262	+	test "X$libobjs" = "X " && libobjs=
8263		else
8264		gentop="$output_objdir/${outputname}x"
8265	<	$show "${rm}r $gentop"
3614	<	$run ${rm}r "$gentop"
3615	<	$show "$mkdir $gentop"
3616	<	$run $mkdir "$gentop"
3617	<	status=$?
3618	<	if test "$status" -ne 0 && test ! -d "$gentop"; then
3619	<	exit $status
3620	<	fi
3621	<	generated="$generated $gentop"
3622	<
3623	<	for xlib in $convenience; do
3624	<	# Extract the objects.
3625	<	case $xlib in
3626	<	[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3627	<	*) xabs=`pwd`"/$xlib" ;;
3628	<	esac
3629	<	xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3630	<	xdir="$gentop/$xlib"
3631	<
3632	<	$show "${rm}r $xdir"
3633	<	$run ${rm}r "$xdir"
3634	<	$show "$mkdir $xdir"
3635	<	$run $mkdir "$xdir"
3636	<	status=$?
3637	<	if test "$status" -ne 0 && test ! -d "$xdir"; then
3638	<	exit $status
3639	<	fi
3640	<	case $host in
3641	<	*-*-darwin*)
3642	<	# ranlib-ed archives of fat binaries are converted to a fat xabs that
3643	<	# ar can't use.  So we to split the fat xabs into non-fat ones to unpack.
3644	<	# We can't deal with duplicate names, since 'ar xN' and 'uniq -cd' don't work.
3645	<	d_archs=`lipo -info $xabs 2> /dev/null | grep '^Architectures' | sed 's/^.*: //'`
3646	<	if test -n "$d_archs"; then
3647	<	$echo "$modename: manually unpacking fat archive $xabs" 1>&2
3648	<	d_name=`basename $xabs`
3649	<	d_dir="/tmp/fat_ar.$$"
3650	<	d_files=''
3651	<
3652	<	for d_arch in $d_archs; do
3653	<	d_archdir="$d_dir/$d_arch"
3654	<	$show "$mkdir -p $d_archdir"
3655	<	$run $mkdir -p "$d_archdir"
3656	<
3657	<	$show "lipo -thin $d_arch $xabs -o $d_dir/$d_name"
3658	<	$run lipo -thin $d_arch "$xabs" -o "$d_dir/$d_name"
3659	<
3660	<	$show "(cd $d_archdir && $AR x $d_dir/$d_name)"
3661	<	$run eval "(cd \$d_archdir && \$AR x \$d_dir/\$d_name)" || exit $?
3662	<
3663	<	$show "${rm} $d_dir/$d_name"
3664	<	$run ${rm} "$d_dir/$d_name"
3665	<	done
3666	<
3667	<	# Can't deal with blanks in file names
3668	<	$run eval "d_files=\`find \$d_dir -type f | sed -e 's,.*/,,' -e '/ /d' | sort -u\`" || exit $?
3669	<
3670	<	for d_file in $d_files; do
3671	<	$run eval "d_f=\`find \$d_dir -name \$d_file -print\`" || exit $?
3672	<	$show "lipo -create $d_f -o $xdir/$d_file"
3673	<	$run eval "lipo -create \$d_f -o \"\$xdir/\$d_file\"" || exit $?
3674	<	done
3675	<
3676	<	$show "${rm}r $d_dir"
3677	<	$run ${rm}r "$d_dir"
3678	<	else
3679	<	$show "(cd $xdir && $AR x $xabs)"
3680	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3681	<	fi
3682	<	;;
3683	<	*)
3684	<	# We will extract separately just the conflicting names and we will no
3685	<	# longer touch any unique names. It is faster to leave these extract
3686	<	# automatically by $AR in one run.
3687	<	$show "(cd $xdir && $AR x $xabs)"
3688	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3689	<	if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3690	<	:
3691	<	else
3692	<	$echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3693	<	$echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3694	<	$AR t "$xabs" | sort | uniq -cd | while read -r count name
3695	<	do
3696	<	i=1
3697	<	while test "$i" -le "$count"
3698	<	do
3699	<	# Put our $i before any first dot (extension)
3700	<	# Never overwrite any file
3701	<	name_to="$name"
3702	<	while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3703	<	do
3704	<	name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3705	<	done
3706	<	$show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3707	<	$run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3708	<	i=`expr $i + 1`
3709	<	done
3710	<	done
3711	<	fi
3712	<	;;
3713	<	esac
8265	>	func_append generated " $gentop"
8266
8267	<	libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
8268	<	done
8267	>	func_extract_archives $gentop $convenience
8268	>	func_append libobjs " $func_extract_archives_result"
8269	>	test "X$libobjs" = "X " && libobjs=
8270		fi
8271		fi
8272
8273		if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8274		eval flag=\"$thread_safe_flag_spec\"
8275	<	linker_flags="$linker_flags $flag"
8275	>	func_append linker_flags " $flag"
8276		fi
8277
8278		# Make a backup of the uninstalled library when relinking
8279	<	if test "$mode" = relink; then
8280	<	$run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
8279	>	if test "$opt_mode" = relink; then
8280	>	$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8281		fi
8282
8283		# Do each of the archive commands.
8284		if test "$module" = yes && test -n "$module_cmds" ; then
8285		if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8286	<	eval cmds=\"$module_expsym_cmds\"
8286	>	eval test_cmds=\"$module_expsym_cmds\"
8287	>	cmds=$module_expsym_cmds
8288		else
8289	<	eval cmds=\"$module_cmds\"
8289	>	eval test_cmds=\"$module_cmds\"
8290	>	cmds=$module_cmds
8291		fi
8292		else
8293	<	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8294	<	eval cmds=\"$archive_expsym_cmds\"
8295	<	else
8296	<	eval cmds=\"$archive_cmds\"
8293	>	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8294	>	eval test_cmds=\"$archive_expsym_cmds\"
8295	>	cmds=$archive_expsym_cmds
8296	>	else
8297	>	eval test_cmds=\"$archive_cmds\"
8298	>	cmds=$archive_cmds
8299		fi
8300		fi
8301
8302	<	if test "X$skipped_export" != "X:" && len=`expr "X$cmds" : ".*"` &&
8303	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8302	>	if test "X$skipped_export" != "X:" &&
8303	>	func_len " $test_cmds" &&
8304	>	len=$func_len_result &&
8305	>	test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8306		:
8307		else
8308	<	# The command line is too long to link in one step, link piecewise.
8309	<	$echo "creating reloadable object files..."
8308	>	# The command line is too long to link in one step, link piecewise
8309	>	# or, if using GNU ld and skipped_export is not :, use a linker
8310	>	# script.
8311
8312		# Save the value of $output and $libobjs because we want to
8313		# use them later.  If we have whole_archive_flag_spec, we
#	Line 3761 | Line 8321 | EOF
8321		save_libobjs=$libobjs
8322		fi
8323		save_output=$output
8324	+	func_basename "$output"
8325	+	output_la=$func_basename_result
8326
8327		# Clear the reloadable object creation command queue and
8328		# initialize k to one.
8329		test_cmds=
8330		concat_cmds=
8331		objlist=
3770	–	delfiles=
8332		last_robj=
8333		k=1
8334	<	output=$output_objdir/$save_output-${k}.$objext
8335	<	# Loop over the list of objects to be linked.
8336	<	for obj in $save_libobjs
8337	<	do
8338	<	eval test_cmds=\"$reload_cmds $objlist $last_robj\"
8339	<	if test "X$objlist" = X ||
8340	<	{ len=`expr "X$test_cmds" : ".*"` &&
8341	<	test "$len" -le "$max_cmd_len"; }; then
8342	<	objlist="$objlist $obj"
8334	>
8335	>	if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8336	>	output=${output_objdir}/${output_la}.lnkscript
8337	>	func_verbose "creating GNU ld script: $output"
8338	>	echo 'INPUT (' > $output
8339	>	for obj in $save_libobjs
8340	>	do
8341	>	func_to_tool_file "$obj"
8342	>	$ECHO "$func_to_tool_file_result" >> $output
8343	>	done
8344	>	echo ')' >> $output
8345	>	func_append delfiles " $output"
8346	>	func_to_tool_file "$output"
8347	>	output=$func_to_tool_file_result
8348	>	elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8349	>	output=${output_objdir}/${output_la}.lnk
8350	>	func_verbose "creating linker input file list: $output"
8351	>	: > $output
8352	>	set x $save_libobjs
8353	>	shift
8354	>	firstobj=
8355	>	if test "$compiler_needs_object" = yes; then
8356	>	firstobj="$1 "
8357	>	shift
8358	>	fi
8359	>	for obj
8360	>	do
8361	>	func_to_tool_file "$obj"
8362	>	$ECHO "$func_to_tool_file_result" >> $output
8363	>	done
8364	>	func_append delfiles " $output"
8365	>	func_to_tool_file "$output"
8366	>	output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8367	>	else
8368	>	if test -n "$save_libobjs"; then
8369	>	func_verbose "creating reloadable object files..."
8370	>	output=$output_objdir/$output_la-${k}.$objext
8371	>	eval test_cmds=\"$reload_cmds\"
8372	>	func_len " $test_cmds"
8373	>	len0=$func_len_result
8374	>	len=$len0
8375	>
8376	>	# Loop over the list of objects to be linked.
8377	>	for obj in $save_libobjs
8378	>	do
8379	>	func_len " $obj"
8380	>	func_arith $len + $func_len_result
8381	>	len=$func_arith_result
8382	>	if test "X$objlist" = X ||
8383	>	test "$len" -lt "$max_cmd_len"; then
8384	>	func_append objlist " $obj"
8385	>	else
8386	>	# The command $test_cmds is almost too long, add a
8387	>	# command to the queue.
8388	>	if test "$k" -eq 1 ; then
8389	>	# The first file doesn't have a previous command to add.
8390	>	reload_objs=$objlist
8391	>	eval concat_cmds=\"$reload_cmds\"
8392	>	else
8393	>	# All subsequent reloadable object files will link in
8394	>	# the last one created.
8395	>	reload_objs="$objlist $last_robj"
8396	>	eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8397	>	fi
8398	>	last_robj=$output_objdir/$output_la-${k}.$objext
8399	>	func_arith $k + 1
8400	>	k=$func_arith_result
8401	>	output=$output_objdir/$output_la-${k}.$objext
8402	>	objlist=" $obj"
8403	>	func_len " $last_robj"
8404	>	func_arith $len0 + $func_len_result
8405	>	len=$func_arith_result
8406	>	fi
8407	>	done
8408	>	# Handle the remaining objects by creating one last
8409	>	# reloadable object file.  All subsequent reloadable object
8410	>	# files will link in the last one created.
8411	>	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8412	>	reload_objs="$objlist $last_robj"
8413	>	eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8414	>	if test -n "$last_robj"; then
8415	>	eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8416	>	fi
8417	>	func_append delfiles " $output"
8418	>
8419		else
8420	<	# The command $test_cmds is almost too long, add a
8421	<	# command to the queue.
8422	<	if test "$k" -eq 1 ; then
8423	<	# The first file doesn't have a previous command to add.
8424	<	eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
8425	<	else
8426	<	# All subsequent reloadable object files will link in
8427	<	# the last one created.
8428	<	eval concat_cmds=\"\$concat_cmds${_S_}$reload_cmds $objlist $last_robj\"
8420	>	output=
8421	>	fi
8422	>
8423	>	if ${skipped_export-false}; then
8424	>	func_verbose "generating symbol list for \`$libname.la'"
8425	>	export_symbols="$output_objdir/$libname.exp"
8426	>	$opt_dry_run || $RM $export_symbols
8427	>	libobjs=$output
8428	>	# Append the command to create the export file.
8429	>	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8430	>	eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8431	>	if test -n "$last_robj"; then
8432	>	eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8433		fi
3793	–	last_robj=$output_objdir/$save_output-${k}.$objext
3794	–	k=`expr $k + 1`
3795	–	output=$output_objdir/$save_output-${k}.$objext
3796	–	objlist=$obj
3797	–	len=1
8434		fi
3799	–	done
3800	–	# Handle the remaining objects by creating one last
3801	–	# reloadable object file.  All subsequent reloadable object
3802	–	# files will link in the last one created.
3803	–	test -z "$concat_cmds" || concat_cmds=$concat_cmds${_S_}
3804	–	eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
8435
8436	<	if ${skipped_export-false}; then
8437	<	$show "generating symbol list for \`$libname.la'"
3808	<	export_symbols="$output_objdir/$libname.exp"
3809	<	$run $rm $export_symbols
3810	<	libobjs=$output
3811	<	# Append the command to create the export file.
3812	<	eval concat_cmds=\"\$concat_cmds${_S_}$export_symbols_cmds\"
3813	<	fi
3814	<
3815	<	# Set up a command to remove the reloadale object files
3816	<	# after they are used.
3817	<	i=0
3818	<	while test "$i" -lt "$k"
3819	<	do
3820	<	i=`expr $i + 1`
3821	<	delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3822	<	done
8436	>	test -n "$save_libobjs" &&
8437	>	func_verbose "creating a temporary reloadable object file: $output"
8438
8439	<	$echo "creating a temporary reloadable object file: $output"
8439	>	# Loop through the commands generated above and execute them.
8440	>	save_ifs="$IFS"; IFS='~'
8441	>	for cmd in $concat_cmds; do
8442	>	IFS="$save_ifs"
8443	>	$opt_silent || {
8444	>	func_quote_for_expand "$cmd"
8445	>	eval "func_echo $func_quote_for_expand_result"
8446	>	}
8447	>	$opt_dry_run || eval "$cmd" || {
8448	>	lt_exit=$?
8449	>
8450	>	# Restore the uninstalled library and exit
8451	>	if test "$opt_mode" = relink; then
8452	>	( cd "$output_objdir" && \
8453	>	$RM "${realname}T" && \
8454	>	$MV "${realname}U" "$realname" )
8455	>	fi
8456
8457	<	# Loop through the commands generated above and execute them.
8458	<	save_ifs="$IFS"; IFS=$_S_
8459	<	for cmd in $concat_cmds; do
8457	>	exit $lt_exit
8458	>	}
8459	>	done
8460		IFS="$save_ifs"
8461	<	$show "$cmd"
8462	<	$run eval "$cmd" || exit $?
8463	<	done
8464	<	IFS="$save_ifs"
8461	>
8462	>	if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8463	>	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8464	>	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8465	>	fi
8466	>	fi
8467	>
8468	>	if ${skipped_export-false}; then
8469	>	if test -n "$export_symbols" && test -n "$include_expsyms"; then
8470	>	tmp_export_symbols="$export_symbols"
8471	>	test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8472	>	$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8473	>	fi
8474	>
8475	>	if test -n "$orig_export_symbols"; then
8476	>	# The given exports_symbols file has to be filtered, so filter it.
8477	>	func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8478	>	# FIXME: $output_objdir/$libname.filter potentially contains lots of
8479	>	# 's' commands which not all seds can handle. GNU sed should be fine
8480	>	# though. Also, the filter scales superlinearly with the number of
8481	>	# global variables. join(1) would be nice here, but unfortunately
8482	>	# isn't a blessed tool.
8483	>	$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8484	>	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8485	>	export_symbols=$output_objdir/$libname.def
8486	>	$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8487	>	fi
8488	>	fi
8489
8490		libobjs=$output
8491		# Restore the value of output.
#	Line 3838 | Line 8493 | EOF
8493
8494		if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8495		eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8496	+	test "X$libobjs" = "X " && libobjs=
8497		fi
8498		# Expand the library linking commands again to reset the
8499		# value of $libobjs for piecewise linking.
8500
8501		# Do each of the archive commands.
8502	<	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8503	<	eval cmds=\"$archive_expsym_cmds\"
8502	>	if test "$module" = yes && test -n "$module_cmds" ; then
8503	>	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8504	>	cmds=$module_expsym_cmds
8505	>	else
8506	>	cmds=$module_cmds
8507	>	fi
8508		else
8509	<	eval cmds=\"$archive_cmds\"
8509	>	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8510	>	cmds=$archive_expsym_cmds
8511	>	else
8512	>	cmds=$archive_cmds
8513	>	fi
8514		fi
8515	+	fi
8516	+
8517	+	if test -n "$delfiles"; then
8518	+	# Append the command to remove temporary files to $cmds.
8519	+	eval cmds=\"\$cmds~\$RM $delfiles\"
8520	+	fi
8521	+
8522	+	# Add any objects from preloaded convenience libraries
8523	+	if test -n "$dlprefiles"; then
8524	+	gentop="$output_objdir/${outputname}x"
8525	+	func_append generated " $gentop"
8526
8527	<	# Append the command to remove the reloadable object files
8528	<	# to the just-reset $cmds.
8529	<	eval cmds=\"\$cmds${_S_}$rm $delfiles\"
8527	>	func_extract_archives $gentop $dlprefiles
8528	>	func_append libobjs " $func_extract_archives_result"
8529	>	test "X$libobjs" = "X " && libobjs=
8530		fi
8531	<	save_ifs="$IFS"; IFS=$_S_
8531	>
8532	>	save_ifs="$IFS"; IFS='~'
8533		for cmd in $cmds; do
8534		IFS="$save_ifs"
8535	<	$show "$cmd"
8536	<	$run eval "$cmd" || exit $?
8535	>	eval cmd=\"$cmd\"
8536	>	$opt_silent || {
8537	>	func_quote_for_expand "$cmd"
8538	>	eval "func_echo $func_quote_for_expand_result"
8539	>	}
8540	>	$opt_dry_run || eval "$cmd" || {
8541	>	lt_exit=$?
8542	>
8543	>	# Restore the uninstalled library and exit
8544	>	if test "$opt_mode" = relink; then
8545	>	( cd "$output_objdir" && \
8546	>	$RM "${realname}T" && \
8547	>	$MV "${realname}U" "$realname" )
8548	>	fi
8549	>
8550	>	exit $lt_exit
8551	>	}
8552		done
8553		IFS="$save_ifs"
8554
8555		# Restore the uninstalled library and exit
8556	<	if test "$mode" = relink; then
8557	<	$run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
8558	<	exit 0
8556	>	if test "$opt_mode" = relink; then
8557	>	$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8558	>
8559	>	if test -n "$convenience"; then
8560	>	if test -z "$whole_archive_flag_spec"; then
8561	>	func_show_eval '${RM}r "$gentop"'
8562	>	fi
8563	>	fi
8564	>
8565	>	exit $EXIT_SUCCESS
8566		fi
8567
8568		# Create links to the real library.
8569		for linkname in $linknames; do
8570		if test "$realname" != "$linkname"; then
8571	<	$show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3874	<	$run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
8571	>	func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8572		fi
8573		done
8574
#	Line 3884 | Line 8581 | EOF
8581		;;
8582
8583		obj)
3887	–	if test -n "$deplibs"; then
3888	–	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3889	–	fi
3890	–
8584		if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8585	<	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
8585	>	func_warning "\`-dlopen' is ignored for objects"
8586		fi
8587
8588	<	if test -n "$rpath"; then
8589	<	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
8590	<	fi
8588	>	case " $deplibs" in
8589	>	*\ -l* | *\ -L*)
8590	>	func_warning "\`-l' and \`-L' are ignored for objects" ;;
8591	>	esac
8592
8593	<	if test -n "$xrpath"; then
8594	<	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3901	<	fi
8593	>	test -n "$rpath" && \
8594	>	func_warning "\`-rpath' is ignored for objects"
8595
8596	<	if test -n "$vinfo"; then
8597	<	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3905	<	fi
8596	>	test -n "$xrpath" && \
8597	>	func_warning "\`-R' is ignored for objects"
8598
8599	<	if test -n "$release"; then
8600	<	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
8601	<	fi
8599	>	test -n "$vinfo" && \
8600	>	func_warning "\`-version-info' is ignored for objects"
8601	>
8602	>	test -n "$release" && \
8603	>	func_warning "\`-release' is ignored for objects"
8604
8605		case $output in
8606		*.lo)
8607	<	if test -n "$objs$old_deplibs"; then
8608	<	$echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
8609	<	exit 1
8610	<	fi
8611	<	libobj="$output"
8612	<	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
8607	>	test -n "$objs$old_deplibs" && \
8608	>	func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8609	>
8610	>	libobj=$output
8611	>	func_lo2o "$libobj"
8612	>	obj=$func_lo2o_result
8613		;;
8614		*)
8615		libobj=
#	Line 3924 | Line 8618 | EOF
8618		esac
8619
8620		# Delete the old objects.
8621	<	$run $rm $obj $libobj
8621	>	$opt_dry_run || $RM $obj $libobj
8622
8623		# Objects from convenience libraries.  This assumes
8624		# single-version convenience libraries.  Whenever we create
#	Line 3933 | Line 8627 | EOF
8627		reload_conv_objs=
8628		gentop=
8629		# reload_cmds runs $LD directly, so let us get rid of
8630	<	# -Wl from whole_archive_flag_spec
8630	>	# -Wl from whole_archive_flag_spec and hope we can get by with
8631	>	# turning comma into space..
8632		wl=
8633
8634		if test -n "$convenience"; then
8635		if test -n "$whole_archive_flag_spec"; then
8636	<	eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
8636	>	eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8637	>	reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8638		else
8639		gentop="$output_objdir/${obj}x"
8640	<	$show "${rm}r $gentop"
3945	<	$run ${rm}r "$gentop"
3946	<	$show "$mkdir $gentop"
3947	<	$run $mkdir "$gentop"
3948	<	status=$?
3949	<	if test "$status" -ne 0 && test ! -d "$gentop"; then
3950	<	exit $status
3951	<	fi
3952	<	generated="$generated $gentop"
3953	<
3954	<	for xlib in $convenience; do
3955	<	# Extract the objects.
3956	<	case $xlib in
3957	<	[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3958	<	*) xabs=`pwd`"/$xlib" ;;
3959	<	esac
3960	<	xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3961	<	xdir="$gentop/$xlib"
8640	>	func_append generated " $gentop"
8641
8642	<	$show "${rm}r $xdir"
8643	<	$run ${rm}r "$xdir"
3965	<	$show "$mkdir $xdir"
3966	<	$run $mkdir "$xdir"
3967	<	status=$?
3968	<	if test "$status" -ne 0 && test ! -d "$xdir"; then
3969	<	exit $status
3970	<	fi
3971	<	case $host in
3972	<	*-*-darwin*)
3973	<	# ranlib-ed archives of fat binaries are converted to a fat xabs that
3974	<	# ar can't use.  So we to split the fat xabs into non-fat ones to unpack.
3975	<	# We can't deal with duplicate names, since 'ar xN' and 'uniq -cd' don't work.
3976	<	d_archs=`lipo -info $xabs 2> /dev/null | grep '^Architectures' | sed 's/^.*: //'`
3977	<	if test -n "$d_archs"; then
3978	<	$echo "$modename: manually unpacking fat archive $xabs" 1>&2
3979	<	d_name=`basename $xabs`
3980	<	d_dir="/tmp/fat_ar.$$"
3981	<	d_files=''
3982	<
3983	<	for d_arch in $d_archs; do
3984	<	d_archdir="$d_dir/$d_arch"
3985	<	$show "$mkdir -p $d_archdir"
3986	<	$run $mkdir -p "$d_archdir"
3987	<
3988	<	$show "lipo -thin $d_arch $xabs -o $d_dir/$d_name"
3989	<	$run lipo -thin $d_arch "$xabs" -o "$d_dir/$d_name"
3990	<
3991	<	$show "(cd $d_archdir && $AR x $d_dir/$d_name)"
3992	<	$run eval "(cd \$d_archdir && \$AR x \$d_dir/\$d_name)" || exit $?
3993	<
3994	<	$show "${rm} $d_dir/$d_name"
3995	<	$run ${rm} "$d_dir/$d_name"
3996	<	done
3997	<
3998	<	# Can't deal with blanks in file names
3999	<	$run eval "d_files=\`find \$d_dir -type f | sed -e 's,.*/,,' -e '/ /d' | sort -u\`" || exit $?
4000	<
4001	<	for d_file in $d_files; do
4002	<	$run eval "d_f=\`find \$d_dir -name \$d_file -print\`" || exit $?
4003	<	$show "lipo -create $d_f -o $xdir/$d_file"
4004	<	$run eval "lipo -create \$d_f -o \"\$xdir/\$d_file\"" || exit $?
4005	<	done
4006	<
4007	<	$show "${rm}r $d_dir"
4008	<	$run ${rm}r "$d_dir"
4009	<	else
4010	<	$show "(cd $xdir && $AR x $xabs)"
4011	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4012	<	fi
4013	<	;;
4014	<	*)
4015	<	# We will extract separately just the conflicting names and we will no
4016	<	# longer touch any unique names. It is faster to leave these extract
4017	<	# automatically by $AR in one run.
4018	<	$show "(cd $xdir && $AR x $xabs)"
4019	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4020	<	if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
4021	<	:
4022	<	else
4023	<	$echo "$modename: warning: object name conflicts; renaming object files" 1>&2
4024	<	$echo "$modename: warning: to ensure that they will not overwrite" 1>&2
4025	<	$AR t "$xabs" | sort | uniq -cd | while read -r count name
4026	<	do
4027	<	i=1
4028	<	while test "$i" -le "$count"
4029	<	do
4030	<	# Put our $i before any first dot (extension)
4031	<	# Never overwrite any file
4032	<	name_to="$name"
4033	<	while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
4034	<	do
4035	<	name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
4036	<	done
4037	<	$show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
4038	<	$run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
4039	<	i=`expr $i + 1`
4040	<	done
4041	<	done
4042	<	fi
4043	<	;;
4044	<	esac
4045	<
4046	<	reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
4047	<	done
8642	>	func_extract_archives $gentop $convenience
8643	>	reload_conv_objs="$reload_objs $func_extract_archives_result"
8644		fi
8645		fi
8646
8647	+	# If we're not building shared, we need to use non_pic_objs
8648	+	test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8649	+
8650		# Create the old-style object.
8651	<	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
8651	>	reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8652
8653		output="$obj"
8654	<	eval cmds=\"$reload_cmds\"
4056	<	save_ifs="$IFS"; IFS=$_S_
4057	<	for cmd in $cmds; do
4058	<	IFS="$save_ifs"
4059	<	$show "$cmd"
4060	<	$run eval "$cmd" || exit $?
4061	<	done
4062	<	IFS="$save_ifs"
8654	>	func_execute_cmds "$reload_cmds" 'exit $?'
8655
8656		# Exit if we aren't doing a library object file.
8657		if test -z "$libobj"; then
8658		if test -n "$gentop"; then
8659	<	$show "${rm}r $gentop"
4068	<	$run ${rm}r $gentop
8659	>	func_show_eval '${RM}r "$gentop"'
8660		fi
8661
8662	<	exit 0
8662	>	exit $EXIT_SUCCESS
8663		fi
8664
8665		if test "$build_libtool_libs" != yes; then
8666		if test -n "$gentop"; then
8667	<	$show "${rm}r $gentop"
4077	<	$run ${rm}r $gentop
8667	>	func_show_eval '${RM}r "$gentop"'
8668		fi
8669
8670		# Create an invalid libtool object if no PIC, so that we don't
8671		# accidentally link it into a program.
8672		# $show "echo timestamp > $libobj"
8673	<	# $run eval "echo timestamp > $libobj" || exit $?
8674	<	exit 0
8673	>	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8674	>	exit $EXIT_SUCCESS
8675		fi
8676
8677		if test -n "$pic_flag" || test "$pic_mode" != default; then
8678		# Only do commands if we really have different PIC objects.
8679		reload_objs="$libobjs $reload_conv_objs"
8680		output="$libobj"
8681	<	eval cmds=\"$reload_cmds\"
4092	<	save_ifs="$IFS"; IFS=$_S_
4093	<	for cmd in $cmds; do
4094	<	IFS="$save_ifs"
4095	<	$show "$cmd"
4096	<	$run eval "$cmd" || exit $?
4097	<	done
4098	<	IFS="$save_ifs"
8681	>	func_execute_cmds "$reload_cmds" 'exit $?'
8682		fi
8683
8684		if test -n "$gentop"; then
8685	<	$show "${rm}r $gentop"
4103	<	$run ${rm}r $gentop
8685	>	func_show_eval '${RM}r "$gentop"'
8686		fi
8687
8688	<	exit 0
8688	>	exit $EXIT_SUCCESS
8689		;;
8690
8691		prog)
8692		case $host in
8693	<	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
8693	>	*cygwin*) func_stripname '' '.exe' "$output"
8694	>	output=$func_stripname_result.exe;;
8695		esac
8696	<	if test -n "$vinfo"; then
8697	<	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4115	<	fi
8696	>	test -n "$vinfo" && \
8697	>	func_warning "\`-version-info' is ignored for programs"
8698
8699	<	if test -n "$release"; then
8700	<	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4119	<	fi
8699	>	test -n "$release" && \
8700	>	func_warning "\`-release' is ignored for programs"
8701
8702	<	if test "$preload" = yes; then
8703	<	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
8704	<	test "$dlopen_self_static" = unknown; then
8705	<	$echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
8706	<	fi
4126	<	fi
8702	>	test "$preload" = yes \
8703	>	&& test "$dlopen_support" = unknown \
8704	>	&& test "$dlopen_self" = unknown \
8705	>	&& test "$dlopen_self_static" = unknown && \
8706	>	func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8707
8708		case $host in
8709		*-*-rhapsody* | *-*-darwin1.[012])
8710		# On Rhapsody replace the C library is the System framework
8711	<	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
8712	<	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
8711	>	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8712	>	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8713		;;
8714		esac
8715
8716		case $host in
8717	<	*darwin*)
8718	<	# Don't allow lazy linking, it breaks C++ global constructors
8719	<	if test "$tagname" = CXX ; then
8720	<	compile_command="$compile_command ${wl}-bind_at_load"
8721	<	finalize_command="$finalize_command ${wl}-bind_at_load"
8722	<	fi
8723	<	;;
8717	>	*-*-darwin*)
8718	>	# Don't allow lazy linking, it breaks C++ global constructors
8719	>	# But is supposedly fixed on 10.4 or later (yay!).
8720	>	if test "$tagname" = CXX ; then
8721	>	case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8722	>	10.[0123])
8723	>	func_append compile_command " ${wl}-bind_at_load"
8724	>	func_append finalize_command " ${wl}-bind_at_load"
8725	>	;;
8726	>	esac
8727	>	fi
8728	>	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8729	>	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730	>	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8731	>	;;
8732		esac
8733
8734	<	compile_command="$compile_command $compile_deplibs"
8735	<	finalize_command="$finalize_command $finalize_deplibs"
8734	>
8735	>	# move library search paths that coincide with paths to not yet
8736	>	# installed libraries to the beginning of the library search list
8737	>	new_libs=
8738	>	for path in $notinst_path; do
8739	>	case " $new_libs " in
8740	>	*" -L$path/$objdir "*) ;;
8741	>	*)
8742	>	case " $compile_deplibs " in
8743	>	*" -L$path/$objdir "*)
8744	>	func_append new_libs " -L$path/$objdir" ;;
8745	>	esac
8746	>	;;
8747	>	esac
8748	>	done
8749	>	for deplib in $compile_deplibs; do
8750	>	case $deplib in
8751	>	-L*)
8752	>	case " $new_libs " in
8753	>	*" $deplib "*) ;;
8754	>	*) func_append new_libs " $deplib" ;;
8755	>	esac
8756	>	;;
8757	>	*) func_append new_libs " $deplib" ;;
8758	>	esac
8759	>	done
8760	>	compile_deplibs="$new_libs"
8761	>
8762	>
8763	>	func_append compile_command " $compile_deplibs"
8764	>	func_append finalize_command " $finalize_deplibs"
8765
8766		if test -n "$rpath$xrpath"; then
8767		# If the user specified any rpath flags, then add them.
#	Line 4152 | Line 8769 | EOF
8769		# This is the magic to use -rpath.
8770		case "$finalize_rpath " in
8771		*" $libdir "*) ;;
8772	<	*) finalize_rpath="$finalize_rpath $libdir" ;;
8772	>	*) func_append finalize_rpath " $libdir" ;;
8773		esac
8774		done
8775		fi
#	Line 4171 | Line 8788 | EOF
8788		*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8789		;;
8790		*)
8791	<	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8791	>	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8792		;;
8793		esac
8794		fi
8795		else
8796		eval flag=\"$hardcode_libdir_flag_spec\"
8797	<	rpath="$rpath $flag"
8797	>	func_append rpath " $flag"
8798		fi
8799		elif test -n "$runpath_var"; then
8800		case "$perm_rpath " in
8801		*" $libdir "*) ;;
8802	<	*) perm_rpath="$perm_rpath $libdir" ;;
8802	>	*) func_append perm_rpath " $libdir" ;;
8803		esac
8804		fi
8805		case $host in
8806	<	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
8806	>	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8807	>	testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8808		case :$dllsearchpath: in
8809		*":$libdir:"*) ;;
8810	<	*) dllsearchpath="$dllsearchpath:$libdir";;
8810	>	::) dllsearchpath=$libdir;;
8811	>	*) func_append dllsearchpath ":$libdir";;
8812	>	esac
8813	>	case :$dllsearchpath: in
8814	>	*":$testbindir:"*) ;;
8815	>	::) dllsearchpath=$testbindir;;
8816	>	*) func_append dllsearchpath ":$testbindir";;
8817		esac
8818		;;
8819		esac
#	Line 4215 | Line 8839 | EOF
8839		*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8840		;;
8841		*)
8842	<	hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8842	>	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8843		;;
8844		esac
8845		fi
8846		else
8847		eval flag=\"$hardcode_libdir_flag_spec\"
8848	<	rpath="$rpath $flag"
8848	>	func_append rpath " $flag"
8849		fi
8850		elif test -n "$runpath_var"; then
8851		case "$finalize_perm_rpath " in
8852		*" $libdir "*) ;;
8853	<	*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8853	>	*) func_append finalize_perm_rpath " $libdir" ;;
8854		esac
8855		fi
8856		done
#	Line 4240 | Line 8864 | EOF
8864
8865		if test -n "$libobjs" && test "$build_old_libs" = yes; then
8866		# Transform all the library objects into standard objects.
8867	<	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8868	<	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8867	>	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8868	>	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8869		fi
8870
8871	<	dlsyms=
4248	<	if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4249	<	if test -n "$NM" && test -n "$global_symbol_pipe"; then
4250	<	dlsyms="${outputname}S.c"
4251	<	else
4252	<	$echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4253	<	fi
4254	<	fi
4255	<
4256	<	if test -n "$dlsyms"; then
4257	<	case $dlsyms in
4258	<	"") ;;
4259	<	*.c)
4260	<	# Discover the nlist of each of the dlfiles.
4261	<	nlist="$output_objdir/${outputname}.nm"
4262	<
4263	<	$show "$rm $nlist ${nlist}S ${nlist}T"
4264	<	$run $rm "$nlist" "${nlist}S" "${nlist}T"
4265	<
4266	<	# Parse the name list into a source file.
4267	<	$show "creating $output_objdir/$dlsyms"
4268	<
4269	<	test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4270	<	/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4271	<	/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4272	<
4273	<	#ifdef __cplusplus
4274	<	extern \"C\" {
4275	<	#endif
4276	<
4277	<	/* Prevent the only kind of declaration conflicts we can make. */
4278	<	#define lt_preloaded_symbols some_other_symbol
4279	<
4280	<	/* External symbol declarations for the compiler. */\
4281	<	"
4282	<
4283	<	if test "$dlself" = yes; then
4284	<	$show "generating symbol list for \`$output'"
4285	<
4286	<	test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4287	<
4288	<	# Add our own program objects to the symbol list.
4289	<	progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4290	<	for arg in $progfiles; do
4291	<	$show "extracting global C symbols from \`$arg'"
4292	<	$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4293	<	done
4294	<
4295	<	if test -n "$exclude_expsyms"; then
4296	<	$run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4297	<	$run eval '$mv "$nlist"T "$nlist"'
4298	<	fi
4299	<
4300	<	if test -n "$export_symbols_regex"; then
4301	<	$run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4302	<	$run eval '$mv "$nlist"T "$nlist"'
4303	<	fi
4304	<
4305	<	# Prepare the list of exported symbols
4306	<	if test -z "$export_symbols"; then
4307	<	export_symbols="$output_objdir/$output.exp"
4308	<	$run $rm $export_symbols
4309	<	$run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4310	<	else
4311	<	$run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
4312	<	$run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
4313	<	$run eval 'mv "$nlist"T "$nlist"'
4314	<	fi
4315	<	fi
4316	<
4317	<	for arg in $dlprefiles; do
4318	<	$show "extracting global C symbols from \`$arg'"
4319	<	name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4320	<	$run eval '$echo ": $name " >> "$nlist"'
4321	<	$run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4322	<	done
4323	<
4324	<	if test -z "$run"; then
4325	<	# Make sure we have at least an empty file.
4326	<	test -f "$nlist" || : > "$nlist"
4327	<
4328	<	if test -n "$exclude_expsyms"; then
4329	<	$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4330	<	$mv "$nlist"T "$nlist"
4331	<	fi
4332	<
4333	<	# Try sorting and uniquifying the output.
4334	<	if grep -v "^: " < "$nlist" |
4335	<	if sort -k 3 </dev/null >/dev/null 2>&1; then
4336	<	sort -k 3
4337	<	else
4338	<	sort +2
4339	<	fi |
4340	<	uniq > "$nlist"S; then
4341	<	:
4342	<	else
4343	<	grep -v "^: " < "$nlist" > "$nlist"S
4344	<	fi
4345	<
4346	<	if test -f "$nlist"S; then
4347	<	eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4348	<	else
4349	<	$echo '/* NONE */' >> "$output_objdir/$dlsyms"
4350	<	fi
4351	<
4352	<	$echo >> "$output_objdir/$dlsyms" "\
4353	<
4354	<	#undef lt_preloaded_symbols
8871	>	func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8872
8873	<	#if defined (__STDC__) && __STDC__
8874	<	# define lt_ptr void *
8875	<	#else
4359	<	# define lt_ptr char *
4360	<	# define const
4361	<	#endif
4362	<
4363	<	/* The mapping between symbol names and symbols. */
4364	<	const struct {
4365	<	const char *name;
4366	<	lt_ptr address;
4367	<	}
4368	<	lt_preloaded_symbols[] =
4369	<	{\
4370	<	"
4371	<
4372	<	eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4373	<
4374	<	$echo >> "$output_objdir/$dlsyms" "\
4375	<	{0, (lt_ptr) 0}
4376	<	};
4377	<
4378	<	/* This works around a problem in FreeBSD linker */
4379	<	#ifdef FREEBSD_WORKAROUND
4380	<	static const void *lt_preloaded_setup() {
4381	<	return lt_preloaded_symbols;
4382	<	}
4383	<	#endif
4384	<
4385	<	#ifdef __cplusplus
4386	<	}
4387	<	#endif\
4388	<	"
4389	<	fi
4390	<
4391	<	pic_flag_for_symtable=
4392	<	case $host in
4393	<	# compiling the symbol table file with pic_flag works around
4394	<	# a FreeBSD bug that causes programs to crash when -lm is
4395	<	# linked before any other PIC object.  But we must not use
4396	<	# pic_flag when linking with -static.  The problem exists in
4397	<	# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4398	<	*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4399	<	case "$compile_command " in
4400	<	*" -static "*) ;;
4401	<	*) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4402	<	esac;;
4403	<	*-*-hpux*)
4404	<	case "$compile_command " in
4405	<	*" -static "*) ;;
4406	<	*) pic_flag_for_symtable=" $pic_flag";;
4407	<	esac
4408	<	esac
4409	<
4410	<	# Now compile the dynamic symbol file.
4411	<	$show "(cd $output_objdir && $LTCC $archargs -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4412	<	$run eval '(cd $output_objdir && $LTCC $archargs -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4413	<
4414	<	# Clean up the generated files.
4415	<	$show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4416	<	$run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4417	<
4418	<	# Transform the symbol file into the correct name.
4419	<	compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4420	<	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4421	<	;;
4422	<	*)
4423	<	$echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4424	<	exit 1
4425	<	;;
4426	<	esac
4427	<	else
4428	<	# We keep going just in case the user didn't refer to
4429	<	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4430	<	# really was required.
4431	<
4432	<	# Nullify the symbol file.
4433	<	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4434	<	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
8873	>	# template prelinking step
8874	>	if test -n "$prelink_cmds"; then
8875	>	func_execute_cmds "$prelink_cmds" 'exit $?'
8876		fi
8877
8878	<	if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8878	>	wrappers_required=yes
8879	>	case $host in
8880	>	*cegcc* | *mingw32ce*)
8881	>	# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8882	>	wrappers_required=no
8883	>	;;
8884	>	*cygwin* | *mingw* )
8885	>	if test "$build_libtool_libs" != yes; then
8886	>	wrappers_required=no
8887	>	fi
8888	>	;;
8889	>	*)
8890	>	if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8891	>	wrappers_required=no
8892	>	fi
8893	>	;;
8894	>	esac
8895	>	if test "$wrappers_required" = no; then
8896		# Replace the output file specification.
8897	<	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8897	>	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8898		link_command="$compile_command$compile_rpath"
8899
8900		# We have no uninstalled library dependencies, so finalize right now.
8901	<	$show "$link_command"
8902	<	$run eval "$link_command"
8903	<	status=$?
8901	>	exit_status=0
8902	>	func_show_eval "$link_command" 'exit_status=$?'
8903	>
8904	>	if test -n "$postlink_cmds"; then
8905	>	func_to_tool_file "$output"
8906	>	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8907	>	func_execute_cmds "$postlink_cmds" 'exit $?'
8908	>	fi
8909
8910		# Delete the generated files.
8911	<	if test -n "$dlsyms"; then
8912	<	$show "$rm $output_objdir/${outputname}S.${objext}"
4450	<	$run $rm "$output_objdir/${outputname}S.${objext}"
8911	>	if test -f "$output_objdir/${outputname}S.${objext}"; then
8912	>	func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8913		fi
8914
8915	<	exit $status
4454	<	fi
4455	<
4456	<	if test -n "$shlibpath_var"; then
4457	<	# We should set the shlibpath_var
4458	<	rpath=
4459	<	for dir in $temp_rpath; do
4460	<	case $dir in
4461	<	[\\/]* | [A-Za-z]:[\\/]*)
4462	<	# Absolute path.
4463	<	rpath="$rpath$dir:"
4464	<	;;
4465	<	*)
4466	<	# Relative path: add a thisdir entry.
4467	<	rpath="$rpath\$thisdir/$dir:"
4468	<	;;
4469	<	esac
4470	<	done
4471	<	temp_rpath="$rpath"
8915	>	exit $exit_status
8916		fi
8917
8918		if test -n "$compile_shlibpath$finalize_shlibpath"; then
#	Line 4485 | Line 8929 | static const void *lt_preloaded_setup()
8929		# We should set the runpath_var.
8930		rpath=
8931		for dir in $perm_rpath; do
8932	<	rpath="$rpath$dir:"
8932	>	func_append rpath "$dir:"
8933		done
8934		compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8935		fi
#	Line 4493 | Line 8937 | static const void *lt_preloaded_setup()
8937		# We should set the runpath_var.
8938		rpath=
8939		for dir in $finalize_perm_rpath; do
8940	<	rpath="$rpath$dir:"
8940	>	func_append rpath "$dir:"
8941		done
8942		finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8943		fi
#	Line 4503 | Line 8947 | static const void *lt_preloaded_setup()
8947		# We don't need to create a wrapper script.
8948		link_command="$compile_var$compile_command$compile_rpath"
8949		# Replace the output file specification.
8950	<	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8950	>	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8951		# Delete the old output file.
8952	<	$run $rm $output
8952	>	$opt_dry_run || $RM $output
8953		# Link the executable and exit
8954	<	$show "$link_command"
8955	<	$run eval "$link_command" || exit $?
8956	<	exit 0
8954	>	func_show_eval "$link_command" 'exit $?'
8955	>
8956	>	if test -n "$postlink_cmds"; then
8957	>	func_to_tool_file "$output"
8958	>	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8959	>	func_execute_cmds "$postlink_cmds" 'exit $?'
8960	>	fi
8961	>
8962	>	exit $EXIT_SUCCESS
8963		fi
8964
8965		if test "$hardcode_action" = relink; then
#	Line 4517 | Line 8967 | static const void *lt_preloaded_setup()
8967		link_command="$compile_var$compile_command$compile_rpath"
8968		relink_command="$finalize_var$finalize_command$finalize_rpath"
8969
8970	<	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
8971	<	$echo "$modename: \`$output' will be relinked during installation" 1>&2
8970	>	func_warning "this platform does not like uninstalled shared libraries"
8971	>	func_warning "\`$output' will be relinked during installation"
8972		else
8973		if test "$fast_install" != no; then
8974		link_command="$finalize_var$compile_command$finalize_rpath"
8975		if test "$fast_install" = yes; then
8976	<	relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8976	>	relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8977		else
8978		# fast_install is set to needless
8979		relink_command=
#	Line 4535 | Line 8985 | static const void *lt_preloaded_setup()
8985		fi
8986
8987		# Replace the output file specification.
8988	<	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8988	>	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8989
8990		# Delete the old output files.
8991	<	$run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
8991	>	$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8992	>
8993	>	func_show_eval "$link_command" 'exit $?'
8994
8995	<	$show "$link_command"
8996	<	$run eval "$link_command" || exit $?
8995	>	if test -n "$postlink_cmds"; then
8996	>	func_to_tool_file "$output_objdir/$outputname"
8997	>	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8998	>	func_execute_cmds "$postlink_cmds" 'exit $?'
8999	>	fi
9000
9001		# Now create the wrapper script.
9002	<	$show "creating $output"
9002	>	func_verbose "creating $output"
9003
9004		# Quote the relink command for shipping.
9005		if test -n "$relink_command"; then
9006		# Preserve any variables that may affect compiler behavior
9007		for var in $variables_saved_for_relink; do
9008		if eval test -z \"\${$var+set}\"; then
9009	<	relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
9009	>	relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9010		elif eval var_value=\$$var; test -z "$var_value"; then
9011		relink_command="$var=; export $var; $relink_command"
9012		else
9013	<	var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
9014	<	relink_command="$var=\"$var_value\"; export $var; $relink_command"
9013	>	func_quote_for_eval "$var_value"
9014	>	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9015		fi
9016		done
9017		relink_command="(cd `pwd`; $relink_command)"
9018	<	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
9018	>	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9019		fi
9020
9021	<	# Quote $echo for shipping.
9022	<	if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
4568	<	case $0 in
4569	<	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
4570	<	*) qecho="$SHELL `pwd`/$0 --fallback-echo";;
4571	<	esac
4572	<	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4573	<	else
4574	<	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4575	<	fi
4576	<
4577	<	# Only actually do things if our run command is non-null.
4578	<	if test -z "$run"; then
9021	>	# Only actually do things if not in dry run mode.
9022	>	$opt_dry_run || {
9023		# win32 will think the script is a binary if it has
9024		# a .exe suffix, so we strip it off here.
9025		case $output in
9026	<	*.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
9026	>	*.exe) func_stripname '' '.exe' "$output"
9027	>	output=$func_stripname_result ;;
9028		esac
9029		# test for cygwin because mv fails w/o .exe extensions
9030		case $host in
9031		*cygwin*)
9032		exeext=.exe
9033	<	outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
9033	>	func_stripname '' '.exe' "$outputname"
9034	>	outputname=$func_stripname_result ;;
9035		*) exeext= ;;
9036		esac
9037		case $host in
9038		*cygwin* | *mingw* )
9039	<	cwrappersource=`$echo ${objdir}/lt-${output}.c`
9040	<	cwrapper=`$echo ${output}.exe`
9041	<	$rm $cwrappersource $cwrapper
9042	<	trap "$rm $cwrappersource $cwrapper; exit 1" 1 2 15
9043	<
9044	<	cat > $cwrappersource <<EOF
9045	<
9046	<	/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
9047	<	Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
9048	<
9049	<	The $output program cannot be directly executed until all the libtool
9050	<	libraries that it depends on are installed.
9051	<
9052	<	This wrapper executable should never be moved out of the build directory.
9053	<	If it is, it will not operate correctly.
9054	<
9055	<	Currently, it simply execs the wrapper *script* "/bin/sh $output",
9056	<	but could eventually absorb all of the scripts functionality and
9057	<	exec $objdir/$outputname directly.
9058	<	*/
9059	<	EOF
9060	<	cat >> $cwrappersource<<"EOF"
9061	<	#include <stdio.h>
9062	<	#include <stdlib.h>
9063	<	#include <unistd.h>
9064	<	#include <malloc.h>
9065	<	#include <stdarg.h>
9066	<	#include <assert.h>
9067	<
9068	<	#if defined(PATH_MAX)
9069	<	# define LT_PATHMAX PATH_MAX
4624	<	#elif defined(MAXPATHLEN)
4625	<	# define LT_PATHMAX MAXPATHLEN
4626	<	#else
4627	<	# define LT_PATHMAX 1024
4628	<	#endif
4629	<
4630	<	#ifndef DIR_SEPARATOR
4631	<	#define DIR_SEPARATOR '/'
4632	<	#endif
4633	<
4634	<	#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4635	<	defined (__OS2__)
4636	<	#define HAVE_DOS_BASED_FILE_SYSTEM
4637	<	#ifndef DIR_SEPARATOR_2
4638	<	#define DIR_SEPARATOR_2 '\\'
4639	<	#endif
4640	<	#endif
4641	<
4642	<	#ifndef DIR_SEPARATOR_2
4643	<	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4644	<	#else /* DIR_SEPARATOR_2 */
4645	<	# define IS_DIR_SEPARATOR(ch) \
4646	<	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4647	<	#endif /* DIR_SEPARATOR_2 */
4648	<
4649	<	#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4650	<	#define XFREE(stale) do { \
4651	<	if (stale) { free ((void *) stale); stale = 0; } \
4652	<	} while (0)
4653	<
4654	<	const char *program_name = NULL;
4655	<
4656	<	void * xmalloc (size_t num);
4657	<	char * xstrdup (const char *string);
4658	<	char * basename (const char *name);
4659	<	char * fnqualify(const char *path);
4660	<	char * strendzap(char *str, const char *pat);
4661	<	void lt_fatal (const char *message, ...);
4662	<
4663	<	int
4664	<	main (int argc, char *argv[])
4665	<	{
4666	<	char **newargz;
4667	<	int i;
4668	<
4669	<	program_name = (char *) xstrdup ((char *) basename (argv[0]));
4670	<	newargz = XMALLOC(char *, argc+2);
4671	<	EOF
4672	<
4673	<	cat >> $cwrappersource <<EOF
4674	<	newargz[0] = "$SHELL";
4675	<	EOF
4676	<
4677	<	cat >> $cwrappersource <<"EOF"
4678	<	newargz[1] = fnqualify(argv[0]);
4679	<	/* we know the script has the same name, without the .exe */
4680	<	/* so make sure newargz[1] doesn't end in .exe */
4681	<	strendzap(newargz[1],".exe");
4682	<	for (i = 1; i < argc; i++)
4683	<	newargz[i+1] = xstrdup(argv[i]);
4684	<	newargz[argc+1] = NULL;
4685	<	EOF
4686	<
4687	<	cat >> $cwrappersource <<EOF
4688	<	execv("$SHELL",newargz);
4689	<	EOF
4690	<
4691	<	cat >> $cwrappersource <<"EOF"
4692	<	}
4693	<
4694	<	void *
4695	<	xmalloc (size_t num)
4696	<	{
4697	<	void * p = (void *) malloc (num);
4698	<	if (!p)
4699	<	lt_fatal ("Memory exhausted");
4700	<
4701	<	return p;
4702	<	}
4703	<
4704	<	char *
4705	<	xstrdup (const char *string)
4706	<	{
4707	<	return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4708	<	;
4709	<	}
4710	<
4711	<	char *
4712	<	basename (const char *name)
4713	<	{
4714	<	const char *base;
4715	<
4716	<	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4717	<	/* Skip over the disk name in MSDOS pathnames. */
4718	<	if (isalpha (name[0]) && name[1] == ':')
4719	<	name += 2;
4720	<	#endif
4721	<
4722	<	for (base = name; *name; name++)
4723	<	if (IS_DIR_SEPARATOR (*name))
4724	<	base = name + 1;
4725	<	return (char *) base;
4726	<	}
4727	<
4728	<	char *
4729	<	fnqualify(const char *path)
4730	<	{
4731	<	size_t size;
4732	<	char *p;
4733	<	char tmp[LT_PATHMAX + 1];
4734	<
4735	<	assert(path != NULL);
4736	<
4737	<	/* Is it qualified already? */
4738	<	#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4739	<	if (isalpha (path[0]) && path[1] == ':')
4740	<	return xstrdup (path);
4741	<	#endif
4742	<	if (IS_DIR_SEPARATOR (path[0]))
4743	<	return xstrdup (path);
4744	<
4745	<	/* prepend the current directory */
4746	<	/* doesn't handle '~' */
4747	<	if (getcwd (tmp, LT_PATHMAX) == NULL)
4748	<	lt_fatal ("getcwd failed");
4749	<	size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4750	<	p = XMALLOC(char, size);
4751	<	sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4752	<	return p;
4753	<	}
4754	<
4755	<	char *
4756	<	strendzap(char *str, const char *pat)
4757	<	{
4758	<	size_t len, patlen;
4759	<
4760	<	assert(str != NULL);
4761	<	assert(pat != NULL);
4762	<
4763	<	len = strlen(str);
4764	<	patlen = strlen(pat);
4765	<
4766	<	if (patlen <= len)
4767	<	{
4768	<	str += len - patlen;
4769	<	if (strcmp(str, pat) == 0)
4770	<	*str = '\0';
4771	<	}
4772	<	return str;
4773	<	}
4774	<
4775	<	static void
4776	<	lt_error_core (int exit_status, const char * mode,
4777	<	const char * message, va_list ap)
4778	<	{
4779	<	fprintf (stderr, "%s: %s: ", program_name, mode);
4780	<	vfprintf (stderr, message, ap);
4781	<	fprintf (stderr, ".\n");
4782	<
4783	<	if (exit_status >= 0)
4784	<	exit (exit_status);
4785	<	}
4786	<
4787	<	void
4788	<	lt_fatal (const char *message, ...)
4789	<	{
4790	<	va_list ap;
4791	<	va_start (ap, message);
4792	<	lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4793	<	va_end (ap);
4794	<	}
4795	<	EOF
4796	<	# we should really use a build-platform specific compiler
4797	<	# here, but OTOH, the wrappers (shell script and this C one)
4798	<	# are only useful if you want to execute the "real" binary.
4799	<	# Since the "real" binary is built for $host, then this
4800	<	# wrapper might as well be built for $host, too.
4801	<	$run $LTCC $archargs -s -o $cwrapper $cwrappersource
4802	<	;;
4803	<	esac
4804	<	$rm $output
4805	<	trap "$rm $output; exit 1" 1 2 15
4806	<
4807	<	$echo > $output "\
4808	<	#! $SHELL
4809	<
4810	<	# $output - temporary wrapper script for $objdir/$outputname
4811	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4812	<	#
4813	<	# The $output program cannot be directly executed until all the libtool
4814	<	# libraries that it depends on are installed.
4815	<	#
4816	<	# This wrapper script should never be moved out of the build directory.
4817	<	# If it is, it will not operate correctly.
4818	<
4819	<	# Sed substitution that helps us do robust quoting.  It backslashifies
4820	<	# metacharacters that are still active within double-quoted strings.
4821	<	Xsed='${SED} -e 1s/^X//'
4822	<	sed_quote_subst='$sed_quote_subst'
4823	<
4824	<	# The HP-UX ksh and POSIX shell print the target directory to stdout
4825	<	# if CDPATH is set.
4826	<	if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
4827	<
4828	<	relink_command=\"$relink_command\"
4829	<
4830	<	# This environment variable determines our operation mode.
4831	<	if test \"\$libtool_install_magic\" = \"$magic\"; then
4832	<	# install mode needs the following variable:
4833	<	notinst_deplibs='$notinst_deplibs'
4834	<	else
4835	<	# When we are sourced in execute mode, \$file and \$echo are already set.
4836	<	if test \"\$libtool_execute_magic\" != \"$magic\"; then
4837	<	echo=\"$qecho\"
4838	<	file=\"\$0\"
4839	<	# Make sure echo works.
4840	<	if test \"X\$1\" = X--no-reexec; then
4841	<	# Discard the --no-reexec flag, and continue.
4842	<	shift
4843	<	elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4844	<	# Yippee, \$echo works!
4845	<	:
4846	<	else
4847	<	# Restart under the correct shell, and then maybe \$echo will work.
4848	<	exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4849	<	fi
4850	<	fi\
4851	<	"
4852	<	$echo >> $output "\
4853	<
4854	<	# Find the directory that this script lives in.
4855	<	thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4856	<	test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4857	<
4858	<	# Follow symbolic links until we get to the real thisdir.
4859	<	file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4860	<	while test -n \"\$file\"; do
4861	<	destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4862	<
4863	<	# If there was a directory component, then change thisdir.
4864	<	if test \"x\$destdir\" != \"x\$file\"; then
4865	<	case \"\$destdir\" in
4866	<	[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4867	<	*) thisdir=\"\$thisdir/\$destdir\" ;;
4868	<	esac
4869	<	fi
4870	<
4871	<	file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4872	<	file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4873	<	done
4874	<
4875	<	# Try to get the absolute directory name.
4876	<	absdir=\`cd \"\$thisdir\" && pwd\`
4877	<	test -n \"\$absdir\" && thisdir=\"\$absdir\"
4878	<	"
4879	<
4880	<	if test "$fast_install" = yes; then
4881	<	$echo >> $output "\
4882	<	program=lt-'$outputname'$exeext
4883	<	progdir=\"\$thisdir/$objdir\"
4884	<
4885	<	if test ! -f \"\$progdir/\$program\" || \\
4886	<	{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4887	<	test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4888	<
4889	<	file=\"\$\$-\$program\"
4890	<
4891	<	if test ! -d \"\$progdir\"; then
4892	<	$mkdir \"\$progdir\"
4893	<	else
4894	<	$rm \"\$progdir/\$file\"
4895	<	fi"
4896	<
4897	<	$echo >> $output "\
4898	<
4899	<	# relink executable if necessary
4900	<	if test -n \"\$relink_command\"; then
4901	<	if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4902	<	else
4903	<	$echo \"\$relink_command_output\" >&2
4904	<	$rm \"\$progdir/\$file\"
4905	<	exit 1
4906	<	fi
4907	<	fi
4908	<
4909	<	$mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4910	<	{ $rm \"\$progdir/\$program\";
4911	<	$mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4912	<	$rm \"\$progdir/\$file\"
4913	<	fi"
4914	<	else
4915	<	$echo >> $output "\
4916	<	program='$outputname'
4917	<	progdir=\"\$thisdir/$objdir\"
4918	<	"
4919	<	fi
4920	<
4921	<	$echo >> $output "\
4922	<
4923	<	if test -f \"\$progdir/\$program\"; then"
4924	<
4925	<	# Export our shlibpath_var if we have one.
4926	<	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4927	<	$echo >> $output "\
4928	<	# Add our own library path to $shlibpath_var
4929	<	$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4930	<
4931	<	# Some systems cannot cope with colon-terminated $shlibpath_var
4932	<	# The second colon is a workaround for a bug in BeOS R4 sed
4933	<	$shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4934	<
4935	<	export $shlibpath_var
4936	<	"
4937	<	fi
4938	<
4939	<	# fixup the dll searchpath if we need to.
4940	<	if test -n "$dllsearchpath"; then
4941	<	$echo >> $output "\
4942	<	# Add the dll search path components to the executable PATH
4943	<	PATH=$dllsearchpath:\$PATH
4944	<	"
4945	<	fi
4946	<
4947	<	$echo >> $output "\
4948	<	if test \"\$libtool_execute_magic\" != \"$magic\"; then
4949	<	# Run the actual program with our arguments.
4950	<	"
4951	<	case $host in
4952	<	# Backslashes separate directories on plain windows
4953	<	*-*-mingw | *-*-os2*)
4954	<	$echo >> $output "\
4955	<	exec \$progdir\\\\\$program \${1+\"\$@\"}
4956	<	"
9039	>	func_dirname_and_basename "$output" "" "."
9040	>	output_name=$func_basename_result
9041	>	output_path=$func_dirname_result
9042	>	cwrappersource="$output_path/$objdir/lt-$output_name.c"
9043	>	cwrapper="$output_path/$output_name.exe"
9044	>	$RM $cwrappersource $cwrapper
9045	>	trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9046	>
9047	>	func_emit_cwrapperexe_src > $cwrappersource
9048	>
9049	>	# The wrapper executable is built using the $host compiler,
9050	>	# because it contains $host paths and files. If cross-
9051	>	# compiling, it, like the target executable, must be
9052	>	# executed on the $host or under an emulation environment.
9053	>	$opt_dry_run || {
9054	>	$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9055	>	$STRIP $cwrapper
9056	>	}
9057	>
9058	>	# Now, create the wrapper script for func_source use:
9059	>	func_ltwrapper_scriptname $cwrapper
9060	>	$RM $func_ltwrapper_scriptname_result
9061	>	trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9062	>	$opt_dry_run || {
9063	>	# note: this script will not be executed, so do not chmod.
9064	>	if test "x$build" = "x$host" ; then
9065	>	$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9066	>	else
9067	>	func_emit_wrapper no > $func_ltwrapper_scriptname_result
9068	>	fi
9069	>	}
9070		;;
9071	+	* )
9072	+	$RM $output
9073	+	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9074
9075	<	*)
9076	<	$echo >> $output "\
4961	<	exec \$progdir/\$program \${1+\"\$@\"}
4962	<	"
9075	>	func_emit_wrapper no > $output
9076	>	chmod +x $output
9077		;;
9078		esac
9079	<	$echo >> $output "\
9080	<	\$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4967	<	exit 1
4968	<	fi
4969	<	else
4970	<	# The program doesn't exist.
4971	<	\$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4972	<	\$echo \"This script is just a wrapper for \$program.\" 1>&2
4973	<	$echo \"See the $PACKAGE documentation for more information.\" 1>&2
4974	<	exit 1
4975	<	fi
4976	<	fi\
4977	<	"
4978	<	chmod +x $output
4979	<	fi
4980	<	exit 0
9079	>	}
9080	>	exit $EXIT_SUCCESS
9081		;;
9082		esac
9083
#	Line 4985 | Line 9085 | fi\
9085		for oldlib in $oldlibs; do
9086
9087		if test "$build_libtool_libs" = convenience; then
9088	<	oldobjs="$libobjs_save"
9088	>	oldobjs="$libobjs_save $symfileobj"
9089		addlibs="$convenience"
9090		build_libtool_libs=no
9091		else
#	Line 4994 | Line 9094 | fi\
9094		build_libtool_libs=no
9095		else
9096		oldobjs="$old_deplibs $non_pic_objects"
9097	+	if test "$preload" = yes && test -f "$symfileobj"; then
9098	+	func_append oldobjs " $symfileobj"
9099	+	fi
9100		fi
9101		addlibs="$old_convenience"
9102		fi
9103
9104		if test -n "$addlibs"; then
9105		gentop="$output_objdir/${outputname}x"
9106	<	$show "${rm}r $gentop"
5004	<	$run ${rm}r "$gentop"
5005	<	$show "$mkdir $gentop"
5006	<	$run $mkdir "$gentop"
5007	<	status=$?
5008	<	if test "$status" -ne 0 && test ! -d "$gentop"; then
5009	<	exit $status
5010	<	fi
5011	<	generated="$generated $gentop"
5012	<
5013	<	# Add in members from convenience archives.
5014	<	for xlib in $addlibs; do
5015	<	# Extract the objects.
5016	<	case $xlib in
5017	<	[\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
5018	<	*) xabs=`pwd`"/$xlib" ;;
5019	<	esac
5020	<	xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
5021	<	xdir="$gentop/$xlib"
5022	<
5023	<	$show "${rm}r $xdir"
5024	<	$run ${rm}r "$xdir"
5025	<	$show "$mkdir $xdir"
5026	<	$run $mkdir "$xdir"
5027	<	status=$?
5028	<	if test "$status" -ne 0 && test ! -d "$xdir"; then
5029	<	exit $status
5030	<	fi
5031	<	case $host in
5032	<	*-*-darwin*)
5033	<	# ranlib-ed archives of fat binaries are converted to a fat xabs that
5034	<	# ar can't use.  So we to split the fat xabs into non-fat ones to unpack.
5035	<	# We can't deal with duplicate names, since 'ar xN' and 'uniq -cd' don't work.
5036	<	d_archs=`lipo -info $xabs 2> /dev/null | grep '^Architectures' | sed 's/^.*: //'`
5037	<	if test -n "$d_archs"; then
5038	<	$echo "$modename: manually unpacking fat archive $xabs" 1>&2
5039	<	d_name=`basename $xabs`
5040	<	d_dir="/tmp/fat_ar.$$"
5041	<	d_files=''
5042	<
5043	<	for d_arch in $d_archs; do
5044	<	d_archdir="$d_dir/$d_arch"
5045	<	$show "$mkdir -p $d_archdir"
5046	<	$run $mkdir -p "$d_archdir"
5047	<
5048	<	$show "lipo -thin $d_arch $xabs -o $d_dir/$d_name"
5049	<	$run lipo -thin $d_arch "$xabs" -o "$d_dir/$d_name"
5050	<
5051	<	$show "(cd $d_archdir && $AR x $d_dir/$d_name)"
5052	<	$run eval "(cd \$d_archdir && \$AR x \$d_dir/\$d_name)" || exit $?
5053	<
5054	<	$show "${rm} $d_dir/$d_name"
5055	<	$run ${rm} "$d_dir/$d_name"
5056	<	done
5057	<
5058	<	# Can't deal with blanks in file names
5059	<	$run eval "d_files=\`find \$d_dir -type f | sed -e 's,.*/,,' -e '/ /d' | sort -u\`" || exit $?
5060	<
5061	<	for d_file in $d_files; do
5062	<	$run eval "d_f=\`find \$d_dir -name \$d_file -print\`" || exit $?
5063	<	$show "lipo -create $d_f -o $xdir/$d_file"
5064	<	$run eval "lipo -create \$d_f -o \"\$xdir/\$d_file\"" || exit $?
5065	<	done
9106	>	func_append generated " $gentop"
9107
9108	<	$show "${rm}r $d_dir"
9109	<	$run ${rm}r "$d_dir"
5069	<	else
5070	<	$show "(cd $xdir && $AR x $xabs)"
5071	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
5072	<	fi
5073	<	;;
5074	<	*)
5075	<	# We will extract separately just the conflicting names and we will no
5076	<	# longer touch any unique names. It is faster to leave these extract
5077	<	# automatically by $AR in one run.
5078	<	$show "(cd $xdir && $AR x $xabs)"
5079	<	$run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
5080	<	if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
5081	<	:
5082	<	else
5083	<	$echo "$modename: warning: object name conflicts; renaming object files" 1>&2
5084	<	$echo "$modename: warning: to ensure that they will not overwrite" 1>&2
5085	<	$AR t "$xabs" | sort | uniq -cd | while read -r count name
5086	<	do
5087	<	i=1
5088	<	while test "$i" -le "$count"
5089	<	do
5090	<	# Put our $i before any first dot (extension)
5091	<	# Never overwrite any file
5092	<	name_to="$name"
5093	<	while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
5094	<	do
5095	<	name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
5096	<	done
5097	<	$show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
5098	<	$run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
5099	<	i=`expr $i + 1`
5100	<	done
5101	<	done
5102	<	fi
5103	<	;;
5104	<	esac
5105	<
5106	<	oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
5107	<	done
9108	>	func_extract_archives $gentop $addlibs
9109	>	func_append oldobjs " $func_extract_archives_result"
9110		fi
9111
9112		# Do each command in the archive commands.
9113		if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9114	<	eval cmds=\"$old_archive_from_new_cmds\"
9114	>	cmds=$old_archive_from_new_cmds
9115		else
5114	–	eval cmds=\"$old_archive_cmds\"
9116
9117	<	if len=`expr "X$cmds" : ".*"` &&
9118	<	test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9117	>	# Add any objects from preloaded convenience libraries
9118	>	if test -n "$dlprefiles"; then
9119	>	gentop="$output_objdir/${outputname}x"
9120	>	func_append generated " $gentop"
9121	>
9122	>	func_extract_archives $gentop $dlprefiles
9123	>	func_append oldobjs " $func_extract_archives_result"
9124	>	fi
9125	>
9126	>	# POSIX demands no paths to be encoded in archives.  We have
9127	>	# to avoid creating archives with duplicate basenames if we
9128	>	# might have to extract them afterwards, e.g., when creating a
9129	>	# static archive out of a convenience library, or when linking
9130	>	# the entirety of a libtool archive into another (currently
9131	>	# not supported by libtool).
9132	>	if (for obj in $oldobjs
9133	>	do
9134	>	func_basename "$obj"
9135	>	$ECHO "$func_basename_result"
9136	>	done | sort | sort -uc >/dev/null 2>&1); then
9137		:
9138		else
9139	+	echo "copying selected object files to avoid basename conflicts..."
9140	+	gentop="$output_objdir/${outputname}x"
9141	+	func_append generated " $gentop"
9142	+	func_mkdir_p "$gentop"
9143	+	save_oldobjs=$oldobjs
9144	+	oldobjs=
9145	+	counter=1
9146	+	for obj in $save_oldobjs
9147	+	do
9148	+	func_basename "$obj"
9149	+	objbase="$func_basename_result"
9150	+	case " $oldobjs " in
9151	+	" ") oldobjs=$obj ;;
9152	+	*[\ /]"$objbase "*)
9153	+	while :; do
9154	+	# Make sure we don't pick an alternate name that also
9155	+	# overlaps.
9156	+	newobj=lt$counter-$objbase
9157	+	func_arith $counter + 1
9158	+	counter=$func_arith_result
9159	+	case " $oldobjs " in
9160	+	*[\ /]"$newobj "*) ;;
9161	+	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
9162	+	esac
9163	+	done
9164	+	func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9165	+	func_append oldobjs " $gentop/$newobj"
9166	+	;;
9167	+	*) func_append oldobjs " $obj" ;;
9168	+	esac
9169	+	done
9170	+	fi
9171	+	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9172	+	tool_oldlib=$func_to_tool_file_result
9173	+	eval cmds=\"$old_archive_cmds\"
9174	+
9175	+	func_len " $cmds"
9176	+	len=$func_len_result
9177	+	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9178	+	cmds=$old_archive_cmds
9179	+	elif test -n "$archiver_list_spec"; then
9180	+	func_verbose "using command file archive linking..."
9181	+	for obj in $oldobjs
9182	+	do
9183	+	func_to_tool_file "$obj"
9184	+	$ECHO "$func_to_tool_file_result"
9185	+	done > $output_objdir/$libname.libcmd
9186	+	func_to_tool_file "$output_objdir/$libname.libcmd"
9187	+	oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9188	+	cmds=$old_archive_cmds
9189	+	else
9190		# the command line is too long to link in one step, link in parts
9191	<	$echo "using piecewise archive linking..."
9191	>	func_verbose "using piecewise archive linking..."
9192		save_RANLIB=$RANLIB
9193		RANLIB=:
9194		objlist=
9195		concat_cmds=
9196		save_oldobjs=$oldobjs
9197	<	# GNU ar 2.10+ was changed to match POSIX; thus no paths are
5128	<	# encoded into archives.  This makes 'ar r' malfunction in
5129	<	# this piecewise linking case whenever conflicting object
5130	<	# names appear in distinct ar calls; check, warn and compensate.
5131	<	if (for obj in $save_oldobjs
5132	<	do
5133	<	$echo "X$obj" | $Xsed -e 's%^.*/%%'
5134	<	done | sort | sort -uc >/dev/null 2>&1); then
5135	<	:
5136	<	else
5137	<	$echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
5138	<	$echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
5139	<	AR_FLAGS=cq
5140	<	fi
9197	>	oldobjs=
9198		# Is there a better way of finding the last object in the list?
9199		for obj in $save_oldobjs
9200		do
9201		last_oldobj=$obj
9202	<	done
9202	>	done
9203	>	eval test_cmds=\"$old_archive_cmds\"
9204	>	func_len " $test_cmds"
9205	>	len0=$func_len_result
9206	>	len=$len0
9207		for obj in $save_oldobjs
9208		do
9209	<	oldobjs="$objlist $obj"
9210	<	objlist="$objlist $obj"
9211	<	eval test_cmds=\"$old_archive_cmds\"
9212	<	if len=`expr "X$test_cmds" : ".*"` &&
9213	<	test "$len" -le "$max_cmd_len"; then
9209	>	func_len " $obj"
9210	>	func_arith $len + $func_len_result
9211	>	len=$func_arith_result
9212	>	func_append objlist " $obj"
9213	>	if test "$len" -lt "$max_cmd_len"; then
9214		:
9215		else
9216		# the above command should be used before it gets too long
9217		oldobjs=$objlist
9218		if test "$obj" = "$last_oldobj" ; then
9219	<	RANLIB=$save_RANLIB
9220	<	fi
9221	<	test -z "$concat_cmds" || concat_cmds=$concat_cmds${_S_}
9219	>	RANLIB=$save_RANLIB
9220	>	fi
9221	>	test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9222		eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9223		objlist=
9224	+	len=$len0
9225		fi
9226		done
9227		RANLIB=$save_RANLIB
#	Line 5167 | Line 9229 | fi\
9229		if test "X$oldobjs" = "X" ; then
9230		eval cmds=\"\$concat_cmds\"
9231		else
9232	<	eval cmds=\"\$concat_cmds${_S_}$old_archive_cmds\"
9232	>	eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9233		fi
9234		fi
9235		fi
9236	<	save_ifs="$IFS"; IFS=$_S_
5175	<	for cmd in $cmds; do
5176	<	IFS="$save_ifs"
5177	<	$show "$cmd"
5178	<	$run eval "$cmd" || exit $?
5179	<	done
5180	<	IFS="$save_ifs"
9236	>	func_execute_cmds "$cmds" 'exit $?'
9237		done
9238
9239	<	if test -n "$generated"; then
9240	<	$show "${rm}r$generated"
5185	<	$run ${rm}r$generated
5186	<	fi
9239	>	test -n "$generated" && \
9240	>	func_show_eval "${RM}r$generated"
9241
9242		# Now create the libtool archive.
9243		case $output in
9244		*.la)
9245		old_library=
9246		test "$build_old_libs" = yes && old_library="$libname.$libext"
9247	<	$show "creating $output"
9247	>	func_verbose "creating $output"
9248
9249		# Preserve any variables that may affect compiler behavior
9250		for var in $variables_saved_for_relink; do
9251		if eval test -z \"\${$var+set}\"; then
9252	<	relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
9252	>	relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9253		elif eval var_value=\$$var; test -z "$var_value"; then
9254		relink_command="$var=; export $var; $relink_command"
9255		else
9256	<	var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
9257	<	relink_command="$var=\"$var_value\"; export $var; $relink_command"
9256	>	func_quote_for_eval "$var_value"
9257	>	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9258		fi
9259		done
9260		# Quote the link command for shipping.
9261	<	relink_command="(cd `pwd`; $SHELL $0 --mode=relink $libtool_args @inst_prefix_dir@)"
9262	<	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
9261	>	relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9262	>	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9263	>	if test "$hardcode_automatic" = yes ; then
9264	>	relink_command=
9265	>	fi
9266
9267		# Only create the output if not a dry run.
9268	<	if test -z "$run"; then
9268	>	$opt_dry_run || {
9269		for installed in no yes; do
9270		if test "$installed" = yes; then
9271		if test -z "$install_libdir"; then
#	Line 5220 | Line 9277 | fi\
9277		for deplib in $dependency_libs; do
9278		case $deplib in
9279		*.la)
9280	<	name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
9281	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9282	<	if test -z "$libdir"; then
9283	<	$echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
9284	<	exit 1
9285	<	fi
9286	<	newdependency_libs="$newdependency_libs $libdir/$name"
9280	>	func_basename "$deplib"
9281	>	name="$func_basename_result"
9282	>	func_resolve_sysroot "$deplib"
9283	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9284	>	test -z "$libdir" && \
9285	>	func_fatal_error "\`$deplib' is not a valid libtool archive"
9286	>	func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9287	>	;;
9288	>	-L*)
9289	>	func_stripname -L '' "$deplib"
9290	>	func_replace_sysroot "$func_stripname_result"
9291	>	func_append newdependency_libs " -L$func_replace_sysroot_result"
9292	>	;;
9293	>	-R*)
9294	>	func_stripname -R '' "$deplib"
9295	>	func_replace_sysroot "$func_stripname_result"
9296	>	func_append newdependency_libs " -R$func_replace_sysroot_result"
9297		;;
9298	<	*) newdependency_libs="$newdependency_libs $deplib" ;;
9298	>	*) func_append newdependency_libs " $deplib" ;;
9299		esac
9300		done
9301		dependency_libs="$newdependency_libs"
9302		newdlfiles=
9303	+
9304		for lib in $dlfiles; do
9305	<	name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
9306	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9307	<	if test -z "$libdir"; then
9308	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
9309	<	exit 1
9310	<	fi
9311	<	newdlfiles="$newdlfiles $libdir/$name"
9305	>	case $lib in
9306	>	*.la)
9307	>	func_basename "$lib"
9308	>	name="$func_basename_result"
9309	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310	>	test -z "$libdir" && \
9311	>	func_fatal_error "\`$lib' is not a valid libtool archive"
9312	>	func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9313	>	;;
9314	>	*) func_append newdlfiles " $lib" ;;
9315	>	esac
9316		done
9317		dlfiles="$newdlfiles"
9318		newdlprefiles=
9319		for lib in $dlprefiles; do
9320	<	name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
9321	<	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9322	<	if test -z "$libdir"; then
9323	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
9324	<	exit 1
9325	<	fi
9326	<	newdlprefiles="$newdlprefiles $libdir/$name"
9320	>	case $lib in
9321	>	*.la)
9322	>	# Only pass preopened files to the pseudo-archive (for
9323	>	# eventual linking with the app. that links it) if we
9324	>	# didn't already link the preopened objects directly into
9325	>	# the library:
9326	>	func_basename "$lib"
9327	>	name="$func_basename_result"
9328	>	eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9329	>	test -z "$libdir" && \
9330	>	func_fatal_error "\`$lib' is not a valid libtool archive"
9331	>	func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9332	>	;;
9333	>	esac
9334	>	done
9335	>	dlprefiles="$newdlprefiles"
9336	>	else
9337	>	newdlfiles=
9338	>	for lib in $dlfiles; do
9339	>	case $lib in
9340	>	[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9341	>	*) abs=`pwd`"/$lib" ;;
9342	>	esac
9343	>	func_append newdlfiles " $abs"
9344	>	done
9345	>	dlfiles="$newdlfiles"
9346	>	newdlprefiles=
9347	>	for lib in $dlprefiles; do
9348	>	case $lib in
9349	>	[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9350	>	*) abs=`pwd`"/$lib" ;;
9351	>	esac
9352	>	func_append newdlprefiles " $abs"
9353		done
9354		dlprefiles="$newdlprefiles"
9355		fi
9356	<	$rm $output
9356	>	$RM $output
9357		# place dlname in correct position for cygwin
9358	+	# In fact, it would be nice if we could use this code for all target
9359	+	# systems that can't hard-code library paths into their executables
9360	+	# and that have no shared library path variable independent of PATH,
9361	+	# but it turns out we can't easily determine that from inspecting
9362	+	# libtool variables, so we have to hard-code the OSs to which it
9363	+	# applies here; at the moment, that means platforms that use the PE
9364	+	# object format with DLL files.  See the long comment at the top of
9365	+	# tests/bindir.at for full details.
9366		tdlname=$dlname
9367		case $host,$output,$installed,$module,$dlname in
9368	<	*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
9368	>	*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9369	>	# If a -bindir argument was supplied, place the dll there.
9370	>	if test "x$bindir" != x ;
9371	>	then
9372	>	func_relative_path "$install_libdir" "$bindir"
9373	>	tdlname=$func_relative_path_result$dlname
9374	>	else
9375	>	# Otherwise fall back on heuristic.
9376	>	tdlname=../bin/$dlname
9377	>	fi
9378	>	;;
9379		esac
9380	<	$echo > $output "\
9380	>	$ECHO > $output "\
9381		# $outputname - a libtool library file
9382	<	# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
9382	>	# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9383		#
9384		# Please DO NOT delete this file!
9385		# It is necessary for linking the library.
#	Line 5277 | Line 9393 | library_names='$library_names'
9393		# The name of the static archive.
9394		old_library='$old_library'
9395
9396	+	# Linker flags that can not go in dependency_libs.
9397	+	inherited_linker_flags='$new_inherited_linker_flags'
9398	+
9399		# Libraries that this one depends upon.
9400		dependency_libs='$dependency_libs'
9401
9402	+	# Names of additional weak libraries provided by this library
9403	+	weak_library_names='$weak_libs'
9404	+
9405		# Version information for $libname.
9406		current=$current
9407		age=$age
#	Line 5298 | Line 9420 | dlpreopen='$dlprefiles'
9420		# Directory that this library needs to be installed in:
9421		libdir='$install_libdir'"
9422		if test "$installed" = no && test "$need_relink" = yes; then
9423	<	$echo >> $output "\
9423	>	$ECHO >> $output "\
9424		relink_command=\"$relink_command\""
9425		fi
9426		done
9427	<	fi
9427	>	}
9428
9429		# Do a symbolic link so that the libtool archive can be found in
9430		# LD_LIBRARY_PATH before the program is installed.
9431	<	$show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5310	<	$run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5311	<	;;
5312	<	esac
5313	<	exit 0
5314	<	;;
5315	<
5316	<	# libtool install mode
5317	<	install)
5318	<	modename="$modename: install"
5319	<
5320	<	# There may be an optional sh(1) argument at the beginning of
5321	<	# install_prog (especially on Windows NT).
5322	<	if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5323	<	# Allow the use of GNU shtool's install command.
5324	<	$echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5325	<	# Aesthetically quote it.
5326	<	arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5327	<	case $arg in
5328	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5329	<	arg="\"$arg\""
5330	<	;;
5331	<	esac
5332	<	install_prog="$arg "
5333	<	arg="$1"
5334	<	shift
5335	<	else
5336	<	install_prog=
5337	<	arg="$nonopt"
5338	<	fi
5339	<
5340	<	# The real first argument should be the name of the installation program.
5341	<	# Aesthetically quote it.
5342	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5343	<	case $arg in
5344	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
5345	<	arg="\"$arg\""
9431	>	func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9432		;;
9433		esac
9434	<	install_prog="$install_prog$arg"
9435	<
5350	<	# We need to accept at least all the BSD install flags.
5351	<	dest=
5352	<	files=
5353	<	opts=
5354	<	prev=
5355	<	install_type=
5356	<	isdir=no
5357	<	stripme=
5358	<	for arg
5359	<	do
5360	<	if test -n "$dest"; then
5361	<	files="$files $dest"
5362	<	dest="$arg"
5363	<	continue
5364	<	fi
5365	<
5366	<	case $arg in
5367	<	-d) isdir=yes ;;
5368	<	-f) prev="-f" ;;
5369	<	-g) prev="-g" ;;
5370	<	-m) prev="-m" ;;
5371	<	-o) prev="-o" ;;
5372	<	-s)
5373	<	stripme=" -s"
5374	<	continue
5375	<	;;
5376	<	-*) ;;
5377	<
5378	<	*)
5379	<	# If the previous option needed an argument, then skip it.
5380	<	if test -n "$prev"; then
5381	<	prev=
5382	<	else
5383	<	dest="$arg"
5384	<	continue
5385	<	fi
5386	<	;;
5387	<	esac
5388	<
5389	<	# Aesthetically quote the argument.
5390	<	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5391	<	case $arg in
5392	<	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5393	<	arg="\"$arg\""
5394	<	;;
5395	<	esac
5396	<	install_prog="$install_prog $arg"
5397	<	done
5398	<
5399	<	if test -z "$install_prog"; then
5400	<	$echo "$modename: you must specify an install program" 1>&2
5401	<	$echo "$help" 1>&2
5402	<	exit 1
5403	<	fi
5404	<
5405	<	if test -n "$prev"; then
5406	<	$echo "$modename: the \`$prev' option requires an argument" 1>&2
5407	<	$echo "$help" 1>&2
5408	<	exit 1
5409	<	fi
5410	<
5411	<	if test -z "$files"; then
5412	<	if test -z "$dest"; then
5413	<	$echo "$modename: no file or destination specified" 1>&2
5414	<	else
5415	<	$echo "$modename: you must specify a destination" 1>&2
5416	<	fi
5417	<	$echo "$help" 1>&2
5418	<	exit 1
5419	<	fi
5420	<
5421	<	# Strip any trailing slash from the destination.
5422	<	dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5423	<
5424	<	# Check to see that the destination is a directory.
5425	<	test -d "$dest" && isdir=yes
5426	<	if test "$isdir" = yes; then
5427	<	destdir="$dest"
5428	<	destname=
5429	<	else
5430	<	destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5431	<	test "X$destdir" = "X$dest" && destdir=.
5432	<	destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5433	<
5434	<	# Not a directory, so check to see that there is only one file specified.
5435	<	set dummy $files
5436	<	if test "$#" -gt 2; then
5437	<	$echo "$modename: \`$dest' is not a directory" 1>&2
5438	<	$echo "$help" 1>&2
5439	<	exit 1
5440	<	fi
5441	<	fi
5442	<	case $destdir in
5443	<	[\\/]* | [A-Za-z]:[\\/]*) ;;
5444	<	*)
5445	<	for file in $files; do
5446	<	case $file in
5447	<	*.lo) ;;
5448	<	*)
5449	<	$echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5450	<	$echo "$help" 1>&2
5451	<	exit 1
5452	<	;;
5453	<	esac
5454	<	done
5455	<	;;
5456	<	esac
5457	<
5458	<	# This variable tells wrapper scripts just to set variables rather
5459	<	# than running their programs.
5460	<	libtool_install_magic="$magic"
5461	<
5462	<	staticlibs=
5463	<	future_libdirs=
5464	<	current_libdirs=
5465	<	for file in $files; do
5466	<
5467	<	# Do each installation.
5468	<	case $file in
5469	<	*.$libext)
5470	<	# Do the static libraries later.
5471	<	staticlibs="$staticlibs $file"
5472	<	;;
5473	<
5474	<	*.la)
5475	<	# Check to see that this really is a libtool archive.
5476	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5477	<	else
5478	<	$echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5479	<	$echo "$help" 1>&2
5480	<	exit 1
5481	<	fi
5482	<
5483	<	library_names=
5484	<	old_library=
5485	<	relink_command=
5486	<	# If there is no directory component, then add one.
5487	<	case $file in
5488	<	*/* | *\\*) . $file ;;
5489	<	*) . ./$file ;;
5490	<	esac
5491	<
5492	<	# Add the libdir to current_libdirs if it is the destination.
5493	<	if test "X$destdir" = "X$libdir"; then
5494	<	case "$current_libdirs " in
5495	<	*" $libdir "*) ;;
5496	<	*) current_libdirs="$current_libdirs $libdir" ;;
5497	<	esac
5498	<	else
5499	<	# Note the libdir as a future libdir.
5500	<	case "$future_libdirs " in
5501	<	*" $libdir "*) ;;
5502	<	*) future_libdirs="$future_libdirs $libdir" ;;
5503	<	esac
5504	<	fi
5505	<
5506	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5507	<	test "X$dir" = "X$file/" && dir=
5508	<	dir="$dir$objdir"
5509	<
5510	<	if test -n "$relink_command"; then
5511	<	# Determine the prefix the user has applied to our future dir.
5512	<	inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5513	<
5514	<	# Don't allow the user to place us outside of our expected
5515	<	# location b/c this prevents finding dependent libraries that
5516	<	# are installed to the same prefix.
5517	<	# At present, this check doesn't affect windows .dll's that
5518	<	# are installed into $libdir/../bin (currently, that works fine)
5519	<	# but it's something to keep an eye on.
5520	<	if test "$inst_prefix_dir" = "$destdir"; then
5521	<	$echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5522	<	exit 1
5523	<	fi
5524	<
5525	<	if test -n "$inst_prefix_dir"; then
5526	<	# Stick the inst_prefix_dir data into the link command.
5527	<	relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5528	<	else
5529	<	relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5530	<	fi
5531	<
5532	<	$echo "$modename: warning: relinking \`$file'" 1>&2
5533	<	$show "$relink_command"
5534	<	if $run eval "$relink_command"; then :
5535	<	else
5536	<	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5537	<	exit 1
5538	<	fi
5539	<	fi
5540	<
5541	<	# See the names of the shared library.
5542	<	set dummy $library_names
5543	<	if test -n "$2"; then
5544	<	realname="$2"
5545	<	shift
5546	<	shift
5547	<
5548	<	srcname="$realname"
5549	<	test -n "$relink_command" && srcname="$realname"T
5550	<
5551	<	# Install the shared library and build the symlinks.
5552	<	$show "$install_prog $dir/$srcname $destdir/$realname"
5553	<	$run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5554	<	if test -n "$stripme" && test -n "$striplib"; then
5555	<	$show "$striplib $destdir/$realname"
5556	<	$run eval "$striplib $destdir/$realname" || exit $?
5557	<	fi
5558	<
5559	<	if test "$#" -gt 0; then
5560	<	# Delete the old symlinks, and create new ones.
5561	<	for linkname
5562	<	do
5563	<	if test "$linkname" != "$realname"; then
5564	<	$show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5565	<	$run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5566	<	fi
5567	<	done
5568	<	fi
5569	<
5570	<	# Do each command in the postinstall commands.
5571	<	lib="$destdir/$realname"
5572	<	eval cmds=\"$postinstall_cmds\"
5573	<	save_ifs="$IFS"; IFS=$_S_
5574	<	for cmd in $cmds; do
5575	<	IFS="$save_ifs"
5576	<	$show "$cmd"
5577	<	$run eval "$cmd" || exit $?
5578	<	done
5579	<	IFS="$save_ifs"
5580	<	fi
5581	<
5582	<	# Install the pseudo-library for information purposes.
5583	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5584	<	instname="$dir/$name"i
5585	<	$show "$install_prog $instname $destdir/$name"
5586	<	$run eval "$install_prog $instname $destdir/$name" || exit $?
5587	<
5588	<	# Maybe install the static library, too.
5589	<	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5590	<	;;
5591	<
5592	<	*.lo)
5593	<	# Install (i.e. copy) a libtool object.
5594	<
5595	<	# Figure out destination file name, if it wasn't already specified.
5596	<	if test -n "$destname"; then
5597	<	destfile="$destdir/$destname"
5598	<	else
5599	<	destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5600	<	destfile="$destdir/$destfile"
5601	<	fi
5602	<
5603	<	# Deduce the name of the destination old-style object file.
5604	<	case $destfile in
5605	<	*.lo)
5606	<	staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5607	<	;;
5608	<	*.$objext)
5609	<	staticdest="$destfile"
5610	<	destfile=
5611	<	;;
5612	<	*)
5613	<	$echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5614	<	$echo "$help" 1>&2
5615	<	exit 1
5616	<	;;
5617	<	esac
5618	<
5619	<	# Install the libtool object if requested.
5620	<	if test -n "$destfile"; then
5621	<	$show "$install_prog $file $destfile"
5622	<	$run eval "$install_prog $file $destfile" || exit $?
5623	<	fi
5624	<
5625	<	# Install the old object if enabled.
5626	<	if test "$build_old_libs" = yes; then
5627	<	# Deduce the name of the old-style object file.
5628	<	staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5629	<
5630	<	$show "$install_prog $staticobj $staticdest"
5631	<	$run eval "$install_prog \$staticobj \$staticdest" || exit $?
5632	<	fi
5633	<	exit 0
5634	<	;;
5635	<
5636	<	*)
5637	<	# Figure out destination file name, if it wasn't already specified.
5638	<	if test -n "$destname"; then
5639	<	destfile="$destdir/$destname"
5640	<	else
5641	<	destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5642	<	destfile="$destdir/$destfile"
5643	<	fi
5644	<
5645	<	# If the file is missing, and there is a .exe on the end, strip it
5646	<	# because it is most likely a libtool script we actually want to
5647	<	# install
5648	<	stripped_ext=""
5649	<	case $file in
5650	<	*.exe)
5651	<	if test ! -f "$file"; then
5652	<	file=`$echo $file|${SED} 's,.exe$,,'`
5653	<	stripped_ext=".exe"
5654	<	fi
5655	<	;;
5656	<	esac
5657	<
5658	<	# Do a test to see if this is really a libtool program.
5659	<	case $host in
5660	<	*cygwin*|*mingw*)
5661	<	wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5662	<	;;
5663	<	*)
5664	<	wrapper=$file
5665	<	;;
5666	<	esac
5667	<	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5668	<	notinst_deplibs=
5669	<	relink_command=
5670	<
5671	<	# To insure that "foo" is sourced, and not "foo.exe",
5672	<	# finese the cygwin/MSYS system by explicitly sourcing "foo."
5673	<	# which disallows the automatic-append-.exe behavior.
5674	<	case $build in
5675	<	*cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5676	<	*) wrapperdot=${wrapper} ;;
5677	<	esac
5678	<	# If there is no directory component, then add one.
5679	<	case $file in
5680	<	*/* | *\\*) . ${wrapperdot} ;;
5681	<	*) . ./${wrapperdot} ;;
5682	<	esac
5683	<
5684	<	# Check the variables that should have been set.
5685	<	if test -z "$notinst_deplibs"; then
5686	<	$echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5687	<	exit 1
5688	<	fi
5689	<
5690	<	finalize=yes
5691	<	for lib in $notinst_deplibs; do
5692	<	# Check to see that each library is installed.
5693	<	libdir=
5694	<	if test -f "$lib"; then
5695	<	# If there is no directory component, then add one.
5696	<	case $lib in
5697	<	*/* | *\\*) . $lib ;;
5698	<	*) . ./$lib ;;
5699	<	esac
5700	<	fi
5701	<	libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5702	<	if test -n "$libdir" && test ! -f "$libfile"; then
5703	<	$echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5704	<	finalize=no
5705	<	fi
5706	<	done
5707	<
5708	<	relink_command=
5709	<	# To insure that "foo" is sourced, and not "foo.exe",
5710	<	# finese the cygwin/MSYS system by explicitly sourcing "foo."
5711	<	# which disallows the automatic-append-.exe behavior.
5712	<	case $build in
5713	<	*cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5714	<	*) wrapperdot=${wrapper} ;;
5715	<	esac
5716	<	# If there is no directory component, then add one.
5717	<	case $file in
5718	<	*/* | *\\*) . ${wrapperdot} ;;
5719	<	*) . ./${wrapperdot} ;;
5720	<	esac
5721	<
5722	<	outputname=
5723	<	if test "$fast_install" = no && test -n "$relink_command"; then
5724	<	if test "$finalize" = yes && test -z "$run"; then
5725	<	tmpdir="/tmp"
5726	<	test -n "$TMPDIR" && tmpdir="$TMPDIR"
5727	<	tmpdir="$tmpdir/libtool-$$"
5728	<	if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
5729	<	else
5730	<	$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5731	<	continue
5732	<	fi
5733	<	file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5734	<	outputname="$tmpdir/$file"
5735	<	# Replace the output file specification.
5736	<	relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5737	<
5738	<	$show "$relink_command"
5739	<	if $run eval "$relink_command"; then :
5740	<	else
5741	<	$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5742	<	${rm}r "$tmpdir"
5743	<	continue
5744	<	fi
5745	<	file="$outputname"
5746	<	else
5747	<	$echo "$modename: warning: cannot relink \`$file'" 1>&2
5748	<	fi
5749	<	else
5750	<	# Install the binary that we compiled earlier.
5751	<	file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5752	<	fi
5753	<	fi
5754	<
5755	<	# remove .exe since cygwin /usr/bin/install will append another
5756	<	# one anyways
5757	<	case $install_prog,$host in
5758	<	*/usr/bin/install*,*cygwin*)
5759	<	case $file:$destfile in
5760	<	*.exe:*.exe)
5761	<	# this is ok
5762	<	;;
5763	<	*.exe:*)
5764	<	destfile=$destfile.exe
5765	<	;;
5766	<	*:*.exe)
5767	<	destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5768	<	;;
5769	<	esac
5770	<	;;
5771	<	esac
5772	<	$show "$install_prog$stripme $file $destfile"
5773	<	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5774	<	test -n "$outputname" && ${rm}r "$tmpdir"
5775	<	;;
5776	<	esac
5777	<	done
5778	<
5779	<	for file in $staticlibs; do
5780	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5781	<
5782	<	# Set up the ranlib parameters.
5783	<	oldlib="$destdir/$name"
5784	<
5785	<	$show "$install_prog $file $oldlib"
5786	<	$run eval "$install_prog \$file \$oldlib" || exit $?
5787	<
5788	<	if test -n "$stripme" && test -n "$striplib"; then
5789	<	$show "$old_striplib $oldlib"
5790	<	$run eval "$old_striplib $oldlib" || exit $?
5791	<	fi
5792	<
5793	<	# Do each command in the postinstall commands.
5794	<	eval cmds=\"$old_postinstall_cmds\"
5795	<	save_ifs="$IFS"; IFS=$_S_
5796	<	for cmd in $cmds; do
5797	<	IFS="$save_ifs"
5798	<	$show "$cmd"
5799	<	$run eval "$cmd" || exit $?
5800	<	done
5801	<	IFS="$save_ifs"
5802	<	done
5803	<
5804	<	if test -n "$future_libdirs"; then
5805	<	$echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5806	<	fi
5807	<
5808	<	if test -n "$current_libdirs"; then
5809	<	# Maybe just do a dry run.
5810	<	test -n "$run" && current_libdirs=" -n$current_libdirs"
5811	<	exec_cmd='$SHELL $0 --finish$current_libdirs'
5812	<	else
5813	<	exit 0
5814	<	fi
5815	<	;;
5816	<
5817	<	# libtool finish mode
5818	<	finish)
5819	<	modename="$modename: finish"
5820	<	libdirs="$nonopt"
5821	<	admincmds=
5822	<
5823	<	if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5824	<	for dir
5825	<	do
5826	<	libdirs="$libdirs $dir"
5827	<	done
5828	<
5829	<	for libdir in $libdirs; do
5830	<	if test -n "$finish_cmds"; then
5831	<	# Do each command in the finish commands.
5832	<	eval cmds=\"$finish_cmds\"
5833	<	save_ifs="$IFS"; IFS=$_S_
5834	<	for cmd in $cmds; do
5835	<	IFS="$save_ifs"
5836	<	$show "$cmd"
5837	<	$run eval "$cmd" || admincmds="$admincmds
5838	<	$cmd"
5839	<	done
5840	<	IFS="$save_ifs"
5841	<	fi
5842	<	if test -n "$finish_eval"; then
5843	<	# Do the single finish_eval.
5844	<	eval cmds=\"$finish_eval\"
5845	<	$run eval "$cmds" || admincmds="$admincmds
5846	<	$cmds"
5847	<	fi
5848	<	done
5849	<	fi
5850	<
5851	<	# Exit here if they wanted silent mode.
5852	<	test "$show" = : && exit 0
5853	<
5854	<	$echo "----------------------------------------------------------------------"
5855	<	$echo "Libraries have been installed in:"
5856	<	for libdir in $libdirs; do
5857	<	$echo "   $libdir"
5858	<	done
5859	<	$echo
5860	<	$echo "If you ever happen to want to link against installed libraries"
5861	<	$echo "in a given directory, LIBDIR, you must either use libtool, and"
5862	<	$echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5863	<	$echo "flag during linking and do at least one of the following:"
5864	<	if test -n "$shlibpath_var"; then
5865	<	$echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
5866	<	$echo "     during execution"
5867	<	fi
5868	<	if test -n "$runpath_var"; then
5869	<	$echo "   - add LIBDIR to the \`$runpath_var' environment variable"
5870	<	$echo "     during linking"
5871	<	fi
5872	<	if test -n "$hardcode_libdir_flag_spec"; then
5873	<	libdir=LIBDIR
5874	<	eval flag=\"$hardcode_libdir_flag_spec\"
5875	<
5876	<	$echo "   - use the \`$flag' linker flag"
5877	<	fi
5878	<	if test -n "$admincmds"; then
5879	<	$echo "   - have your system administrator run these commands:$admincmds"
5880	<	fi
5881	<	if test -f /etc/ld.so.conf; then
5882	<	$echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5883	<	fi
5884	<	$echo
5885	<	$echo "See any operating system documentation about shared libraries for"
5886	<	$echo "more information, such as the ld(1) and ld.so(8) manual pages."
5887	<	$echo "----------------------------------------------------------------------"
5888	<	exit 0
5889	<	;;
5890	<
5891	<	# libtool execute mode
5892	<	execute)
5893	<	modename="$modename: execute"
5894	<
5895	<	# The first argument is the command name.
5896	<	cmd="$nonopt"
5897	<	if test -z "$cmd"; then
5898	<	$echo "$modename: you must specify a COMMAND" 1>&2
5899	<	$echo "$help"
5900	<	exit 1
5901	<	fi
5902	<
5903	<	# Handle -dlopen flags immediately.
5904	<	for file in $execute_dlfiles; do
5905	<	if test ! -f "$file"; then
5906	<	$echo "$modename: \`$file' is not a file" 1>&2
5907	<	$echo "$help" 1>&2
5908	<	exit 1
5909	<	fi
5910	<
5911	<	dir=
5912	<	case $file in
5913	<	*.la)
5914	<	# Check to see that this really is a libtool archive.
5915	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5916	<	else
5917	<	$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5918	<	$echo "$help" 1>&2
5919	<	exit 1
5920	<	fi
5921	<
5922	<	# Read the libtool library.
5923	<	dlname=
5924	<	library_names=
5925	<
5926	<	# If there is no directory component, then add one.
5927	<	case $file in
5928	<	*/* | *\\*) . $file ;;
5929	<	*) . ./$file ;;
5930	<	esac
5931	<
5932	<	# Skip this library if it cannot be dlopened.
5933	<	if test -z "$dlname"; then
5934	<	# Warn if it was a shared library.
5935	<	test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5936	<	continue
5937	<	fi
5938	<
5939	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5940	<	test "X$dir" = "X$file" && dir=.
5941	<
5942	<	if test -f "$dir/$objdir/$dlname"; then
5943	<	dir="$dir/$objdir"
5944	<	else
5945	<	$echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5946	<	exit 1
5947	<	fi
5948	<	;;
5949	<
5950	<	*.lo)
5951	<	# Just add the directory containing the .lo file.
5952	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5953	<	test "X$dir" = "X$file" && dir=.
5954	<	;;
5955	<
5956	<	*)
5957	<	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5958	<	continue
5959	<	;;
5960	<	esac
5961	<
5962	<	# Get the absolute pathname.
5963	<	absdir=`cd "$dir" && pwd`
5964	<	test -n "$absdir" && dir="$absdir"
5965	<
5966	<	# Now add the directory to shlibpath_var.
5967	<	if eval "test -z \"\$$shlibpath_var\""; then
5968	<	eval "$shlibpath_var=\"\$dir\""
5969	<	else
5970	<	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5971	<	fi
5972	<	done
5973	<
5974	<	# This variable tells wrapper scripts just to set shlibpath_var
5975	<	# rather than running their programs.
5976	<	libtool_execute_magic="$magic"
5977	<
5978	<	# Check if any of the arguments is a wrapper script.
5979	<	args=
5980	<	for file
5981	<	do
5982	<	case $file in
5983	<	-*) ;;
5984	<	*)
5985	<	# Do a test to see if this is really a libtool program.
5986	<	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5987	<	# If there is no directory component, then add one.
5988	<	case $file in
5989	<	*/* | *\\*) . $file ;;
5990	<	*) . ./$file ;;
5991	<	esac
5992	<
5993	<	# Transform arg to wrapped name.
5994	<	file="$progdir/$program"
5995	<	fi
5996	<	;;
5997	<	esac
5998	<	# Quote arguments (to preserve shell metacharacters).
5999	<	file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6000	<	args="$args \"$file\""
6001	<	done
6002	<
6003	<	if test -z "$run"; then
6004	<	if test -n "$shlibpath_var"; then
6005	<	# Export the shlibpath_var.
6006	<	eval "export $shlibpath_var"
6007	<	fi
9434	>	exit $EXIT_SUCCESS
9435	>	}
9436
9437	<	# Restore saved environment variables
9438	<	if test "${save_LC_ALL+set}" = set; then
6011	<	LC_ALL="$save_LC_ALL"; export LC_ALL
6012	<	fi
6013	<	if test "${save_LANG+set}" = set; then
6014	<	LANG="$save_LANG"; export LANG
6015	<	fi
9437	>	{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9438	>	func_mode_link ${1+"$@"}
9439
6017	–	# Now prepare to actually exec the command.
6018	–	exec_cmd="\$cmd$args"
6019	–	else
6020	–	# Display what would be done.
6021	–	if test -n "$shlibpath_var"; then
6022	–	eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6023	–	$echo "export $shlibpath_var"
6024	–	fi
6025	–	$echo "$cmd$args"
6026	–	exit 0
6027	–	fi
6028	–	;;
9440
9441	<	# libtool clean and uninstall mode
9442	<	clean | uninstall)
9443	<	modename="$modename: $mode"
9444	<	rm="$nonopt"
9441	>	# func_mode_uninstall arg...
9442	>	func_mode_uninstall ()
9443	>	{
9444	>	$opt_debug
9445	>	RM="$nonopt"
9446		files=
9447		rmforce=
9448		exit_status=0
#	Line 6042 | Line 9454 | relink_command=\"$relink_command\""
9454		for arg
9455		do
9456		case $arg in
9457	<	-f) rm="$rm $arg"; rmforce=yes ;;
9458	<	-*) rm="$rm $arg" ;;
9459	<	*) files="$files $arg" ;;
9457	>	-f) func_append RM " $arg"; rmforce=yes ;;
9458	>	-*) func_append RM " $arg" ;;
9459	>	*) func_append files " $arg" ;;
9460		esac
9461		done
9462
9463	<	if test -z "$rm"; then
9464	<	$echo "$modename: you must specify an RM program" 1>&2
6053	<	$echo "$help" 1>&2
6054	<	exit 1
6055	<	fi
9463	>	test -z "$RM" && \
9464	>	func_fatal_help "you must specify an RM program"
9465
9466		rmdirs=
9467
6059	–	origobjdir="$objdir"
9468		for file in $files; do
9469	<	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
9470	<	if test "X$dir" = "X$file"; then
9471	<	dir=.
9472	<	objdir="$origobjdir"
9469	>	func_dirname "$file" "" "."
9470	>	dir="$func_dirname_result"
9471	>	if test "X$dir" = X.; then
9472	>	odir="$objdir"
9473		else
9474	<	objdir="$dir/$origobjdir"
9474	>	odir="$dir/$objdir"
9475		fi
9476	<	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
9477	<	test "$mode" = uninstall && objdir="$dir"
9476	>	func_basename "$file"
9477	>	name="$func_basename_result"
9478	>	test "$opt_mode" = uninstall && odir="$dir"
9479
9480	<	# Remember objdir for removal later, being careful to avoid duplicates
9481	<	if test "$mode" = clean; then
9480	>	# Remember odir for removal later, being careful to avoid duplicates
9481	>	if test "$opt_mode" = clean; then
9482		case " $rmdirs " in
9483	<	*" $objdir "*) ;;
9484	<	*) rmdirs="$rmdirs $objdir" ;;
9483	>	*" $odir "*) ;;
9484	>	*) func_append rmdirs " $odir" ;;
9485		esac
9486		fi
9487
9488		# Don't error if the file doesn't exist and rm -f was used.
9489	<	if (test -L "$file") >/dev/null 2>&1 \
9490	<	|| (test -h "$file") >/dev/null 2>&1 \
9491	<	|| test -f "$file"; then
9489	>	if { test -L "$file"; } >/dev/null 2>&1 ||
9490	>	{ test -h "$file"; } >/dev/null 2>&1 ||
9491	>	test -f "$file"; then
9492		:
9493		elif test -d "$file"; then
9494		exit_status=1
#	Line 6093 | Line 9502 | relink_command=\"$relink_command\""
9502		case $name in
9503		*.la)
9504		# Possibly a libtool archive, so verify it.
9505	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
9506	<	. $dir/$name
9505	>	if func_lalib_p "$file"; then
9506	>	func_source $dir/$name
9507
9508		# Delete the libtool libraries and symlinks.
9509		for n in $library_names; do
9510	<	rmfiles="$rmfiles $objdir/$n"
9510	>	func_append rmfiles " $odir/$n"
9511		done
9512	<	test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6104	<	test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
9512	>	test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9513
9514	<	if test "$mode" = uninstall; then
9514	>	case "$opt_mode" in
9515	>	clean)
9516	>	case " $library_names " in
9517	>	*" $dlname "*) ;;
9518	>	*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9519	>	esac
9520	>	test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9521	>	;;
9522	>	uninstall)
9523		if test -n "$library_names"; then
9524		# Do each command in the postuninstall commands.
9525	<	eval cmds=\"$postuninstall_cmds\"
6110	<	save_ifs="$IFS"; IFS=$_S_
6111	<	for cmd in $cmds; do
6112	<	IFS="$save_ifs"
6113	<	$show "$cmd"
6114	<	$run eval "$cmd"
6115	<	if test "$?" -ne 0 && test "$rmforce" != yes; then
6116	<	exit_status=1
6117	<	fi
6118	<	done
6119	<	IFS="$save_ifs"
9525	>	func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9526		fi
9527
9528		if test -n "$old_library"; then
9529		# Do each command in the old_postuninstall commands.
9530	<	eval cmds=\"$old_postuninstall_cmds\"
6125	<	save_ifs="$IFS"; IFS=$_S_
6126	<	for cmd in $cmds; do
6127	<	IFS="$save_ifs"
6128	<	$show "$cmd"
6129	<	$run eval "$cmd"
6130	<	if test "$?" -ne 0 && test "$rmforce" != yes; then
6131	<	exit_status=1
6132	<	fi
6133	<	done
6134	<	IFS="$save_ifs"
9530	>	func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9531		fi
9532		# FIXME: should reinstall the best remaining shared library.
9533	<	fi
9533	>	;;
9534	>	esac
9535		fi
9536		;;
9537
9538		*.lo)
9539		# Possibly a libtool object, so verify it.
9540	<	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
9540	>	if func_lalib_p "$file"; then
9541
9542		# Read the .lo file
9543	<	. $dir/$name
9543	>	func_source $dir/$name
9544
9545		# Add PIC object to the list of files to remove.
9546	<	if test -n "$pic_object" \
9547	<	&& test "$pic_object" != none; then
9548	<	rmfiles="$rmfiles $dir/$pic_object"
9546	>	if test -n "$pic_object" &&
9547	>	test "$pic_object" != none; then
9548	>	func_append rmfiles " $dir/$pic_object"
9549		fi
9550
9551		# Add non-PIC object to the list of files to remove.
9552	<	if test -n "$non_pic_object" \
9553	<	&& test "$non_pic_object" != none; then
9554	<	rmfiles="$rmfiles $dir/$non_pic_object"
9552	>	if test -n "$non_pic_object" &&
9553	>	test "$non_pic_object" != none; then
9554	>	func_append rmfiles " $dir/$non_pic_object"
9555		fi
9556		fi
9557		;;
9558
9559		*)
9560	<	if test "$mode" = clean ; then
9560	>	if test "$opt_mode" = clean ; then
9561		noexename=$name
9562		case $file in
9563	<	*.exe)
9564	<	file=`$echo $file|${SED} 's,.exe$,,'`
9565	<	noexename=`$echo $name|${SED} 's,.exe$,,'`
9563	>	*.exe)
9564	>	func_stripname '' '.exe' "$file"
9565	>	file=$func_stripname_result
9566	>	func_stripname '' '.exe' "$name"
9567	>	noexename=$func_stripname_result
9568		# $file with .exe has already been added to rmfiles,
9569		# add $file without .exe
9570	<	rmfiles="$rmfiles $file"
9570	>	func_append rmfiles " $file"
9571		;;
9572		esac
9573		# Do a test to see if this is a libtool program.
9574	<	if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
9575	<	relink_command=
9576	<	. $dir/$noexename
9574	>	if func_ltwrapper_p "$file"; then
9575	>	if func_ltwrapper_executable_p "$file"; then
9576	>	func_ltwrapper_scriptname "$file"
9577	>	relink_command=
9578	>	func_source $func_ltwrapper_scriptname_result
9579	>	func_append rmfiles " $func_ltwrapper_scriptname_result"
9580	>	else
9581	>	relink_command=
9582	>	func_source $dir/$noexename
9583	>	fi
9584
9585		# note $name still contains .exe if it was in $file originally
9586		# as does the version of $file that was added into $rmfiles
9587	<	rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
9587	>	func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9588		if test "$fast_install" = yes && test -n "$relink_command"; then
9589	<	rmfiles="$rmfiles $objdir/lt-$name"
9589	>	func_append rmfiles " $odir/lt-$name"
9590		fi
9591		if test "X$noexename" != "X$name" ; then
9592	<	rmfiles="$rmfiles $objdir/lt-${noexename}.c"
9592	>	func_append rmfiles " $odir/lt-${noexename}.c"
9593		fi
9594		fi
9595		fi
9596		;;
9597		esac
9598	<	$show "$rm $rmfiles"
6193	<	$run $rm $rmfiles || exit_status=1
9598	>	func_show_eval "$RM $rmfiles" 'exit_status=1'
9599		done
6195	–	objdir="$origobjdir"
9600
9601		# Try to remove the ${objdir}s in the directories where we deleted files
9602		for dir in $rmdirs; do
9603		if test -d "$dir"; then
9604	<	$show "rmdir $dir"
6201	<	$run rmdir $dir >/dev/null 2>&1
9604	>	func_show_eval "rmdir $dir >/dev/null 2>&1"
9605		fi
9606		done
9607
9608		exit $exit_status
9609	<	;;
9609	>	}
9610
9611	<	"")
9612	<	$echo "$modename: you must specify a MODE" 1>&2
6210	<	$echo "$generic_help" 1>&2
6211	<	exit 1
6212	<	;;
6213	<	esac
9611	>	{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9612	>	func_mode_uninstall ${1+"$@"}
9613
9614	<	if test -z "$exec_cmd"; then
9615	<	$echo "$modename: invalid operation mode \`$mode'" 1>&2
9616	<	$echo "$generic_help" 1>&2
9617	<	exit 1
9618	<	fi
9619	<	fi # test -z "$show_help"
9614	>	test -z "$opt_mode" && {
9615	>	help="$generic_help"
9616	>	func_fatal_help "you must specify a MODE"
9617	>	}
9618	>
9619	>	test -z "$exec_cmd" && \
9620	>	func_fatal_help "invalid operation mode \`$opt_mode'"
9621
9622		if test -n "$exec_cmd"; then
9623	<	eval exec $exec_cmd
9624	<	exit 1
9623	>	eval exec "$exec_cmd"
9624	>	exit $EXIT_FAILURE
9625		fi
9626
9627	<	# We need to display help for each of the modes.
6228	<	case $mode in
6229	<	"") $echo \
6230	<	"Usage: $modename [OPTION]... [MODE-ARG]...
6231	<
6232	<	Provide generalized library-building support services.
6233	<
6234	<	--config          show all configuration variables
6235	<	--debug           enable verbose shell tracing
6236	<	-n, --dry-run         display commands without modifying any files
6237	<	--features        display basic configuration information and exit
6238	<	--finish          same as \`--mode=finish'
6239	<	--help            display this help message and exit
6240	<	--mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6241	<	--quiet           same as \`--silent'
6242	<	--silent          don't print informational messages
6243	<	--tag=TAG         use configuration variables from tag TAG
6244	<	--version         print version information
6245	<
6246	<	MODE must be one of the following:
6247	<
6248	<	clean           remove files from the build directory
6249	<	compile         compile a source file into a libtool object
6250	<	execute         automatically set library path, then run a program
6251	<	finish          complete the installation of libtool libraries
6252	<	install         install libraries or executables
6253	<	link            create a library or an executable
6254	<	uninstall       remove libraries from an installed directory
9627	>	exit $exit_status
9628
6256	–	MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6257	–	a more detailed description of MODE.
6258	–
6259	–	Report bugs to <bug-libtool@gnu.org>."
6260	–	exit 0
6261	–	;;
6262	–
6263	–	clean)
6264	–	$echo \
6265	–	"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6266	–
6267	–	Remove files from the build directory.
6268	–
6269	–	RM is the name of the program to use to delete files associated with each FILE
6270	–	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6271	–	to RM.
6272	–
6273	–	If FILE is a libtool library, object or program, all the files associated
6274	–	with it are deleted. Otherwise, only FILE itself is deleted using RM."
6275	–	;;
6276	–
6277	–	compile)
6278	–	$echo \
6279	–	"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6280	–
6281	–	Compile a source file into a libtool library object.
6282	–
6283	–	This mode accepts the following additional options:
6284	–
6285	–	-o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6286	–	-prefer-pic       try to building PIC objects only
6287	–	-prefer-non-pic   try to building non-PIC objects only
6288	–	-static           always build a \`.o' file suitable for static linking
6289	–
6290	–	COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6291	–	from the given SOURCEFILE.
6292	–
6293	–	The output file name is determined by removing the directory component from
6294	–	SOURCEFILE, then substituting the C source code suffix \`.c' with the
6295	–	library object suffix, \`.lo'."
6296	–	;;
6297	–
6298	–	execute)
6299	–	$echo \
6300	–	"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6301	–
6302	–	Automatically set library path, then run a program.
6303	–
6304	–	This mode accepts the following additional options:
6305	–
6306	–	-dlopen FILE      add the directory containing FILE to the library path
6307	–
6308	–	This mode sets the library path environment variable according to \`-dlopen'
6309	–	flags.
6310	–
6311	–	If any of the ARGS are libtool executable wrappers, then they are translated
6312	–	into their corresponding uninstalled binary, and any of their required library
6313	–	directories are added to the library path.
6314	–
6315	–	Then, COMMAND is executed, with ARGS as arguments."
6316	–	;;
6317	–
6318	–	finish)
6319	–	$echo \
6320	–	"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6321	–
6322	–	Complete the installation of libtool libraries.
6323	–
6324	–	Each LIBDIR is a directory that contains libtool libraries.
6325	–
6326	–	The commands that this mode executes may require superuser privileges.  Use
6327	–	the \`--dry-run' option if you just want to see what would be executed."
6328	–	;;
6329	–
6330	–	install)
6331	–	$echo \
6332	–	"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6333	–
6334	–	Install executables or libraries.
6335	–
6336	–	INSTALL-COMMAND is the installation command.  The first component should be
6337	–	either the \`install' or \`cp' program.
6338	–
6339	–	The rest of the components are interpreted as arguments to that command (only
6340	–	BSD-compatible install options are recognized)."
6341	–	;;
6342	–
6343	–	link)
6344	–	$echo \
6345	–	"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6346	–
6347	–	Link object files or libraries together to form another library, or to
6348	–	create an executable program.
6349	–
6350	–	LINK-COMMAND is a command using the C compiler that you would use to create
6351	–	a program from several object files.
6352	–
6353	–	The following components of LINK-COMMAND are treated specially:
6354	–
6355	–	-all-static       do not do any dynamic linking at all
6356	–	-avoid-version    do not add a version suffix if possible
6357	–	-dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6358	–	-dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6359	–	-export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6360	–	-export-symbols SYMFILE
6361	–	try to export only the symbols listed in SYMFILE
6362	–	-export-symbols-regex REGEX
6363	–	try to export only the symbols matching REGEX
6364	–	-LLIBDIR          search LIBDIR for required installed libraries
6365	–	-lNAME            OUTPUT-FILE requires the installed library libNAME
6366	–	-module           build a library that can dlopened
6367	–	-no-fast-install  disable the fast-install mode
6368	–	-no-install       link a not-installable executable
6369	–	-no-undefined     declare that a library does not refer to external symbols
6370	–	-o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6371	–	-objectlist FILE  Use a list of object files found in FILE to specify objects
6372	–	-release RELEASE  specify package release information
6373	–	-rpath LIBDIR     the created library will eventually be installed in LIBDIR
6374	–	-R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6375	–	-static           do not do any dynamic linking of libtool libraries
6376	–	-version-info CURRENT[:REVISION[:AGE]]
6377	–	specify library version info [each variable defaults to 0]
6378	–
6379	–	All other options (arguments beginning with \`-') are ignored.
6380	–
6381	–	Every other argument is treated as a filename.  Files ending in \`.la' are
6382	–	treated as uninstalled libtool libraries, other files are standard or library
6383	–	object files.
6384	–
6385	–	If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6386	–	only library objects (\`.lo' files) may be specified, and \`-rpath' is
6387	–	required, except when creating a convenience library.
6388	–
6389	–	If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6390	–	using \`ar' and \`ranlib', or on Windows using \`lib'.
6391	–
6392	–	If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6393	–	is created, otherwise an executable program is created."
6394	–	;;
6395	–
6396	–	uninstall)
6397	–	$echo \
6398	–	"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6399	–
6400	–	Remove libraries from an installation directory.
6401	–
6402	–	RM is the name of the program to use to delete files associated with each FILE
6403	–	(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6404	–	to RM.
6405	–
6406	–	If FILE is a libtool library, all the files associated with it are deleted.
6407	–	Otherwise, only FILE itself is deleted using RM."
6408	–	;;
6409	–
6410	–	*)
6411	–	$echo "$modename: invalid operation mode \`$mode'" 1>&2
6412	–	$echo "$help" 1>&2
6413	–	exit 1
6414	–	;;
6415	–	esac
6416	–
6417	–	$echo
6418	–	$echo "Try \`$modename --help' for more information about other modes."
6419	–
6420	–	exit 0
9629
9630		# The TAGs below are defined such that we never get into a situation
9631		# in which we disable both kinds of libraries.  Given conflicting
#	Line 6436 | Line 9644 | build_old_libs=yes
9644		# ### END LIBTOOL TAG CONFIG: disable-shared
9645
9646		# ### BEGIN LIBTOOL TAG CONFIG: disable-static
9647	<	build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
9647	>	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9648		# ### END LIBTOOL TAG CONFIG: disable-static
9649
9650		# Local Variables:
9651		# mode:shell-script
9652		# sh-indentation:2
9653		# End:
9654	+	# vi:sw=2
9655	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines