WebSVN – Vertical – Blame – /trunk/ltmain.sh

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

Subversion Repositories Vertical

(root)/trunk/ltmain.sh – Rev 2