Context Navigation

Back to Ticket #43947

Ticket #43947: libtool

File libtool, 287.0 KB (added by xman00@…, 10 years ago)
dbus-glib libtool file

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

Download in other formats:

Original Format