path: root/libtool (plain)
blob: c6e6f064d3c8fcbf5b6869da5d3cd90b6c4fc4e7

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