Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

ltmain.sh @ 673

Last change on this file since 673 was 444, checked in by satin@…, 6 years ago
add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc
File size: 243.9 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/libs/newlib/src/ltmain.sh @ 673

Download in other formats: