ltmain.sh@ 75439

最後變更在這個檔案從75439是 58796,由 vboxsync 提交於 9 年前
libpng 1.2.54 unmodified
屬性 svn:eol-style 設為 `LF` 屬性 svn:executable 設為 ``*
檔案大小: 316.5 KB

行
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 <[email protected]>, 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 [email protected].
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 [email protected].
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 <[email protected]>.
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 \| 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* \| 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* \| 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 \| 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)
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 \| 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 \| 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 \| 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 \| 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 <io.h>
5542	# endif
5543	#endif
5544	#include <malloc.h>
5545	#include <stdarg.h>
5546	#include <assert.h>
5547	#include <string.h>
5548	#include <ctype.h>
5549	#include <errno.h>
5550	#include <fcntl.h>
5551	#include <sys/stat.h>
5552
5553	#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
5554
5555	/* declarations of non-ANSI functions */
5556	#if defined __MINGW32__
5557	# ifdef __STRICT_ANSI__
5558	int _putenv (const char *);
5559	# endif
5560	#elif defined __CYGWIN__
5561	# ifdef __STRICT_ANSI__
5562	char realpath (const char , char *);
5563	int putenv (char *);
5564	int setenv (const char , const char , int);
5565	# endif
5566	/* #elif defined other_platform \|\| defined ... */
5567	#endif
5568
5569	/* portability defines, excluding path handling macros */
5570	#if defined _MSC_VER
5571	# define setmode _setmode
5572	# define stat _stat
5573	# define chmod _chmod
5574	# define getcwd _getcwd
5575	# define putenv _putenv
5576	# define S_IXUSR _S_IEXEC
5577	#elif defined __MINGW32__
5578	# define setmode _setmode
5579	# define stat _stat
5580	# define chmod _chmod
5581	# define getcwd _getcwd
5582	# define putenv _putenv
5583	#elif defined __CYGWIN__
5584	# define HAVE_SETENV
5585	# define FOPEN_WB "wb"
5586	/* #elif defined other platforms ... */
5587	#endif
5588
5589	#if defined PATH_MAX
5590	# define LT_PATHMAX PATH_MAX
5591	#elif defined MAXPATHLEN
5592	# define LT_PATHMAX MAXPATHLEN
5593	#else
5594	# define LT_PATHMAX 1024
5595	#endif
5596
5597	#ifndef S_IXOTH
5598	# define S_IXOTH 0
5599	#endif
5600	#ifndef S_IXGRP
5601	# define S_IXGRP 0
5602	#endif
5603
5604	/* path handling portability macros */
5605	#ifndef DIR_SEPARATOR
5606	# define DIR_SEPARATOR '/'
5607	# define PATH_SEPARATOR ':'
5608	#endif
5609
5610	#if defined _WIN32 \|\| defined __MSDOS__ \|\| defined __DJGPP__ \|\| \
5611	defined __OS2__
5612	# define HAVE_DOS_BASED_FILE_SYSTEM
5613	# define FOPEN_WB "wb"
5614	# ifndef DIR_SEPARATOR_2
5615	# define DIR_SEPARATOR_2 '\\'
5616	# endif
5617	# ifndef PATH_SEPARATOR_2
5618	# define PATH_SEPARATOR_2 ';'
5619	# endif
5620	#endif
5621
5622	#ifndef DIR_SEPARATOR_2
5623	# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5624	#else /* DIR_SEPARATOR_2 */
5625	# define IS_DIR_SEPARATOR(ch) \
5626	(((ch) == DIR_SEPARATOR) \|\| ((ch) == DIR_SEPARATOR_2))
5627	#endif /* DIR_SEPARATOR_2 */
5628
5629	#ifndef PATH_SEPARATOR_2
5630	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5631	#else /* PATH_SEPARATOR_2 */
5632	# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5633	#endif /* PATH_SEPARATOR_2 */
5634
5635	#ifndef FOPEN_WB
5636	# define FOPEN_WB "w"
5637	#endif
5638	#ifndef _O_BINARY
5639	# define _O_BINARY 0
5640	#endif
5641
5642	#define XMALLOC(type, num) ((type ) xmalloc ((num) sizeof(type)))
5643	#define XFREE(stale) do { \
5644	if (stale) { free (stale); stale = 0; } \
5645	} while (0)
5646
5647	#if defined LT_DEBUGWRAPPER
5648	static int lt_debug = 1;
5649	#else
5650	static int lt_debug = 0;
5651	#endif
5652
5653	const char program_name = "libtool-wrapper"; / in case xstrdup fails */
5654
5655	void *xmalloc (size_t num);
5656	char xstrdup (const char string);
5657	const char base_name (const char name);
5658	char find_executable (const char wrapper);
5659	char chase_symlinks (const char pathspec);
5660	int make_executable (const char *path);
5661	int check_executable (const char *path);
5662	char strendzap (char str, const char *pat);
5663	void lt_debugprintf (const char file, int line, const char fmt, ...);
5664	void lt_fatal (const char file, int line, const char message, ...);
5665	static const char nonnull (const char s);
5666	static const char nonempty (const char s);
5667	void lt_setenv (const char name, const char value);
5668	char lt_extend_str (const char orig_value, const char *add, int to_end);
5669	void lt_update_exe_path (const char name, const char value);
5670	void lt_update_lib_path (const char name, const char value);
5671	char prepare_spawn (char argv);
5672	void lt_dump_script (FILE *f);
5673	EOF
5674
5675	cat <<EOF
5676	#if __GNUC__ < 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
5677	# define externally_visible volatile
5678	#else
5679	# define externally_visible __attribute__((externally_visible)) volatile
5680	#endif
5681	externally_visible const char * MAGIC_EXE = "$magic_exe";
5682	const char * LIB_PATH_VARNAME = "$shlibpath_var";
5683	EOF
5684
5685	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5686	func_to_host_path "$temp_rpath"
5687	cat <<EOF
5688	const char * LIB_PATH_VALUE = "$func_to_host_path_result";
5689	EOF
5690	else
5691	cat <<"EOF"
5692	const char * LIB_PATH_VALUE = "";
5693	EOF
5694	fi
5695
5696	if test -n "$dllsearchpath"; then
5697	func_to_host_path "$dllsearchpath:"
5698	cat <<EOF
5699	const char * EXE_PATH_VARNAME = "PATH";
5700	const char * EXE_PATH_VALUE = "$func_to_host_path_result";
5701	EOF
5702	else
5703	cat <<"EOF"
5704	const char * EXE_PATH_VARNAME = "";
5705	const char * EXE_PATH_VALUE = "";
5706	EOF
5707	fi
5708
5709	if test yes = "$fast_install"; then
5710	cat <<EOF
5711	const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
5712	EOF
5713	else
5714	cat <<EOF
5715	const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
5716	EOF
5717	fi
5718
5719
5720	cat <<"EOF"
5721
5722	#define LTWRAPPER_OPTION_PREFIX "--lt-"
5723
5724	static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
5725	static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
5726	static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
5727
5728	int
5729	main (int argc, char *argv[])
5730	{
5731	char **newargz;
5732	int newargc;
5733	char *tmp_pathspec;
5734	char *actual_cwrapper_path;
5735	char *actual_cwrapper_name;
5736	char *target_name;
5737	char *lt_argv_zero;
5738	int rval = 127;
5739
5740	int i;
5741
5742	program_name = (char *) xstrdup (base_name (argv[0]));
5743	newargz = XMALLOC (char *, (size_t) argc + 1);
5744
5745	/* very simple arg parsing; don't want to rely on getopt
5746	* also, copy all non cwrapper options to newargz, except
5747	* argz[0], which is handled differently
5748	*/
5749	newargc=0;
5750	for (i = 1; i < argc; i++)
5751	{
5752	if (STREQ (argv[i], dumpscript_opt))
5753	{
5754	EOF
5755	case $host in
5756	mingw \| cygwin )
5757	# make stdout use "unix" line endings
5758	echo " setmode(1,_O_BINARY);"
5759	;;
5760	esac
5761
5762	cat <<"EOF"
5763	lt_dump_script (stdout);
5764	return 0;
5765	}
5766	if (STREQ (argv[i], debug_opt))
5767	{
5768	lt_debug = 1;
5769	continue;
5770	}
5771	if (STREQ (argv[i], ltwrapper_option_prefix))
5772	{
5773	/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
5774	namespace, but it is not one of the ones we know about and
5775	have already dealt with, above (inluding dump-script), then
5776	report an error. Otherwise, targets might begin to believe
5777	they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
5778	namespace. The first time any user complains about this, we'll
5779	need to make LTWRAPPER_OPTION_PREFIX a configure-time option
5780	or a configure.ac-settable value.
5781	*/
5782	lt_fatal (__FILE__, __LINE__,
5783	"unrecognized %s option: '%s'",
5784	ltwrapper_option_prefix, argv[i]);
5785	}
5786	/* otherwise ... */
5787	newargz[++newargc] = xstrdup (argv[i]);
5788	}
5789	newargz[++newargc] = NULL;
5790
5791	EOF
5792	cat <<EOF
5793	/* The GNU banner must be the first non-error debug message */
5794	lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
5795	EOF
5796	cat <<"EOF"
5797	lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
5798	lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
5799
5800	tmp_pathspec = find_executable (argv[0]);
5801	if (tmp_pathspec == NULL)
5802	lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
5803	lt_debugprintf (__FILE__, __LINE__,
5804	"(main) found exe (before symlink chase) at: %s\n",
5805	tmp_pathspec);
5806
5807	actual_cwrapper_path = chase_symlinks (tmp_pathspec);
5808	lt_debugprintf (__FILE__, __LINE__,
5809	"(main) found exe (after symlink chase) at: %s\n",
5810	actual_cwrapper_path);
5811	XFREE (tmp_pathspec);
5812
5813	actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
5814	strendzap (actual_cwrapper_path, actual_cwrapper_name);
5815
5816	/* wrapper name transforms */
5817	strendzap (actual_cwrapper_name, ".exe");
5818	tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
5819	XFREE (actual_cwrapper_name);
5820	actual_cwrapper_name = tmp_pathspec;
5821	tmp_pathspec = 0;
5822
5823	/* target_name transforms -- use actual target program name; might have lt- prefix */
5824	target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
5825	strendzap (target_name, ".exe");
5826	tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
5827	XFREE (target_name);
5828	target_name = tmp_pathspec;
5829	tmp_pathspec = 0;
5830
5831	lt_debugprintf (__FILE__, __LINE__,
5832	"(main) libtool target name: %s\n",
5833	target_name);
5834	EOF
5835
5836	cat <<EOF
5837	newargz[0] =
5838	XMALLOC (char, (strlen (actual_cwrapper_path) +
5839	strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
5840	strcpy (newargz[0], actual_cwrapper_path);
5841	strcat (newargz[0], "$objdir");
5842	strcat (newargz[0], "/");
5843	EOF
5844
5845	cat <<"EOF"
5846	/* stop here, and copy so we don't have to do this twice */
5847	tmp_pathspec = xstrdup (newargz[0]);
5848
5849	/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
5850	strcat (newargz[0], actual_cwrapper_name);
5851
5852	/* DO want the lt- prefix here if it exists, so use target_name */
5853	lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
5854	XFREE (tmp_pathspec);
5855	tmp_pathspec = NULL;
5856	EOF
5857
5858	case $host_os in
5859	mingw*)
5860	cat <<"EOF"
5861	{
5862	char* p;
5863	while ((p = strchr (newargz[0], '\\')) != NULL)
5864	{
5865	*p = '/';
5866	}
5867	while ((p = strchr (lt_argv_zero, '\\')) != NULL)
5868	{
5869	*p = '/';
5870	}
5871	}
5872	EOF
5873	;;
5874	esac
5875
5876	cat <<"EOF"
5877	XFREE (target_name);
5878	XFREE (actual_cwrapper_path);
5879	XFREE (actual_cwrapper_name);
5880
5881	lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
5882	lt_setenv ("DUALCASE", "1"); /* for MSK sh */
5883	/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
5884	be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
5885	because on Windows, both *_VARNAMEs are PATH but uninstalled
5886	libraries must come first. */
5887	lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
5888	lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
5889
5890	lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
5891	nonnull (lt_argv_zero));
5892	for (i = 0; i < newargc; i++)
5893	{
5894	lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
5895	i, nonnull (newargz[i]));
5896	}
5897
5898	EOF
5899
5900	case $host_os in
5901	mingw*)
5902	cat <<"EOF"
5903	/* execv doesn't actually work on mingw as expected on unix */
5904	newargz = prepare_spawn (newargz);
5905	rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
5906	if (rval == -1)
5907	{
5908	/* failed to start process */
5909	lt_debugprintf (__FILE__, __LINE__,
5910	"(main) failed to launch target \"%s\": %s\n",
5911	lt_argv_zero, nonnull (strerror (errno)));
5912	return 127;
5913	}
5914	return rval;
5915	EOF
5916	;;
5917	*)
5918	cat <<"EOF"
5919	execv (lt_argv_zero, newargz);
5920	return rval; /* =127, but avoids unused variable warning */
5921	EOF
5922	;;
5923	esac
5924
5925	cat <<"EOF"
5926	}
5927
5928	void *
5929	xmalloc (size_t num)
5930	{
5931	void p = (void ) malloc (num);
5932	if (!p)
5933	lt_fatal (__FILE__, __LINE__, "memory exhausted");
5934
5935	return p;
5936	}
5937
5938	char *
5939	xstrdup (const char *string)
5940	{
5941	return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
5942	string) : NULL;
5943	}
5944
5945	const char *
5946	base_name (const char *name)
5947	{
5948	const char *base;
5949
5950	#if defined HAVE_DOS_BASED_FILE_SYSTEM
5951	/* Skip over the disk name in MSDOS pathnames. */
5952	if (isalpha ((unsigned char) name[0]) && name[1] == ':')
5953	name += 2;
5954	#endif
5955
5956	for (base = name; *name; name++)
5957	if (IS_DIR_SEPARATOR (*name))
5958	base = name + 1;
5959	return base;
5960	}
5961
5962	int
5963	check_executable (const char *path)
5964	{
5965	struct stat st;
5966
5967	lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
5968	nonempty (path));
5969	if ((!path) \|\| (!*path))
5970	return 0;
5971
5972	if ((stat (path, &st) >= 0)
5973	&& (st.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH)))
5974	return 1;
5975	else
5976	return 0;
5977	}
5978
5979	int
5980	make_executable (const char *path)
5981	{
5982	int rval = 0;
5983	struct stat st;
5984
5985	lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
5986	nonempty (path));
5987	if ((!path) \|\| (!*path))
5988	return 0;
5989
5990	if (stat (path, &st) >= 0)
5991	{
5992	rval = chmod (path, st.st_mode \| S_IXOTH \| S_IXGRP \| S_IXUSR);
5993	}
5994	return rval;
5995	}
5996
5997	/* Searches for the full path of the wrapper. Returns
5998	newly allocated full path name if found, NULL otherwise
5999	Does not chase symlinks, even on platforms that support them.
6000	*/
6001	char *
6002	find_executable (const char *wrapper)
6003	{
6004	int has_slash = 0;
6005	const char *p;
6006	const char *p_next;
6007	/* static buffer for getcwd */
6008	char tmp[LT_PATHMAX + 1];
6009	size_t tmp_len;
6010	char *concat_name;
6011
6012	lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
6013	nonempty (wrapper));
6014
6015	if ((wrapper == NULL) \|\| (*wrapper == '\0'))
6016	return NULL;
6017
6018	/* Absolute path? */
6019	#if defined HAVE_DOS_BASED_FILE_SYSTEM
6020	if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
6021	{
6022	concat_name = xstrdup (wrapper);
6023	if (check_executable (concat_name))
6024	return concat_name;
6025	XFREE (concat_name);
6026	}
6027	else
6028	{
6029	#endif
6030	if (IS_DIR_SEPARATOR (wrapper[0]))
6031	{
6032	concat_name = xstrdup (wrapper);
6033	if (check_executable (concat_name))
6034	return concat_name;
6035	XFREE (concat_name);
6036	}
6037	#if defined HAVE_DOS_BASED_FILE_SYSTEM
6038	}
6039	#endif
6040
6041	for (p = wrapper; *p; p++)
6042	if (*p == '/')
6043	{
6044	has_slash = 1;
6045	break;
6046	}
6047	if (!has_slash)
6048	{
6049	/* no slashes; search PATH */
6050	const char *path = getenv ("PATH");
6051	if (path != NULL)
6052	{
6053	for (p = path; *p; p = p_next)
6054	{
6055	const char *q;
6056	size_t p_len;
6057	for (q = p; *q; q++)
6058	if (IS_PATH_SEPARATOR (*q))
6059	break;
6060	p_len = (size_t) (q - p);
6061	p_next = (*q == '\0' ? q : q + 1);
6062	if (p_len == 0)
6063	{
6064	/* empty path: current directory */
6065	if (getcwd (tmp, LT_PATHMAX) == NULL)
6066	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6067	nonnull (strerror (errno)));
6068	tmp_len = strlen (tmp);
6069	concat_name =
6070	XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6071	memcpy (concat_name, tmp, tmp_len);
6072	concat_name[tmp_len] = '/';
6073	strcpy (concat_name + tmp_len + 1, wrapper);
6074	}
6075	else
6076	{
6077	concat_name =
6078	XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
6079	memcpy (concat_name, p, p_len);
6080	concat_name[p_len] = '/';
6081	strcpy (concat_name + p_len + 1, wrapper);
6082	}
6083	if (check_executable (concat_name))
6084	return concat_name;
6085	XFREE (concat_name);
6086	}
6087	}
6088	/* not found in PATH; assume curdir */
6089	}
6090	/* Relative path \| not found in path: prepend cwd */
6091	if (getcwd (tmp, LT_PATHMAX) == NULL)
6092	lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6093	nonnull (strerror (errno)));
6094	tmp_len = strlen (tmp);
6095	concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6096	memcpy (concat_name, tmp, tmp_len);
6097	concat_name[tmp_len] = '/';
6098	strcpy (concat_name + tmp_len + 1, wrapper);
6099
6100	if (check_executable (concat_name))
6101	return concat_name;
6102	XFREE (concat_name);
6103	return NULL;
6104	}
6105
6106	char *
6107	chase_symlinks (const char *pathspec)
6108	{
6109	#ifndef S_ISLNK
6110	return xstrdup (pathspec);
6111	#else
6112	char buf[LT_PATHMAX];
6113	struct stat s;
6114	char *tmp_pathspec = xstrdup (pathspec);
6115	char *p;
6116	int has_symlinks = 0;
6117	while (strlen (tmp_pathspec) && !has_symlinks)
6118	{
6119	lt_debugprintf (__FILE__, __LINE__,
6120	"checking path component for symlinks: %s\n",
6121	tmp_pathspec);
6122	if (lstat (tmp_pathspec, &s) == 0)
6123	{
6124	if (S_ISLNK (s.st_mode) != 0)
6125	{
6126	has_symlinks = 1;
6127	break;
6128	}
6129
6130	/* search backwards for last DIR_SEPARATOR */
6131	p = tmp_pathspec + strlen (tmp_pathspec) - 1;
6132	while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6133	p--;
6134	if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6135	{
6136	/* no more DIR_SEPARATORS left */
6137	break;
6138	}
6139	*p = '\0';
6140	}
6141	else
6142	{
6143	lt_fatal (__FILE__, __LINE__,
6144	"error accessing file \"%s\": %s",
6145	tmp_pathspec, nonnull (strerror (errno)));
6146	}
6147	}
6148	XFREE (tmp_pathspec);
6149
6150	if (!has_symlinks)
6151	{
6152	return xstrdup (pathspec);
6153	}
6154
6155	tmp_pathspec = realpath (pathspec, buf);
6156	if (tmp_pathspec == 0)
6157	{
6158	lt_fatal (__FILE__, __LINE__,
6159	"could not follow symlinks for %s", pathspec);
6160	}
6161	return xstrdup (tmp_pathspec);
6162	#endif
6163	}
6164
6165	char *
6166	strendzap (char str, const char pat)
6167	{
6168	size_t len, patlen;
6169
6170	assert (str != NULL);
6171	assert (pat != NULL);
6172
6173	len = strlen (str);
6174	patlen = strlen (pat);
6175
6176	if (patlen <= len)
6177	{
6178	str += len - patlen;
6179	if (STREQ (str, pat))
6180	*str = '\0';
6181	}
6182	return str;
6183	}
6184
6185	void
6186	lt_debugprintf (const char file, int line, const char fmt, ...)
6187	{
6188	va_list args;
6189	if (lt_debug)
6190	{
6191	(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
6192	va_start (args, fmt);
6193	(void) vfprintf (stderr, fmt, args);
6194	va_end (args);
6195	}
6196	}
6197
6198	static void
6199	lt_error_core (int exit_status, const char *file,
6200	int line, const char *mode,
6201	const char *message, va_list ap)
6202	{
6203	fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
6204	vfprintf (stderr, message, ap);
6205	fprintf (stderr, ".\n");
6206
6207	if (exit_status >= 0)
6208	exit (exit_status);
6209	}
6210
6211	void
6212	lt_fatal (const char file, int line, const char message, ...)
6213	{
6214	va_list ap;
6215	va_start (ap, message);
6216	lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
6217	va_end (ap);
6218	}
6219
6220	static const char *
6221	nonnull (const char *s)
6222	{
6223	return s ? s : "(null)";
6224	}
6225
6226	static const char *
6227	nonempty (const char *s)
6228	{
6229	return (s && !*s) ? "(empty)" : nonnull (s);
6230	}
6231
6232	void
6233	lt_setenv (const char name, const char value)
6234	{
6235	lt_debugprintf (__FILE__, __LINE__,
6236	"(lt_setenv) setting '%s' to '%s'\n",
6237	nonnull (name), nonnull (value));
6238	{
6239	#ifdef HAVE_SETENV
6240	/* always make a copy, for consistency with !HAVE_SETENV */
6241	char *str = xstrdup (value);
6242	setenv (name, str, 1);
6243	#else
6244	size_t len = strlen (name) + 1 + strlen (value) + 1;
6245	char *str = XMALLOC (char, len);
6246	sprintf (str, "%s=%s", name, value);
6247	if (putenv (str) != EXIT_SUCCESS)
6248	{
6249	XFREE (str);
6250	}
6251	#endif
6252	}
6253	}
6254
6255	char *
6256	lt_extend_str (const char orig_value, const char add, int to_end)
6257	{
6258	char *new_value;
6259	if (orig_value && *orig_value)
6260	{
6261	size_t orig_value_len = strlen (orig_value);
6262	size_t add_len = strlen (add);
6263	new_value = XMALLOC (char, add_len + orig_value_len + 1);
6264	if (to_end)
6265	{
6266	strcpy (new_value, orig_value);
6267	strcpy (new_value + orig_value_len, add);
6268	}
6269	else
6270	{
6271	strcpy (new_value, add);
6272	strcpy (new_value + add_len, orig_value);
6273	}
6274	}
6275	else
6276	{
6277	new_value = xstrdup (add);
6278	}
6279	return new_value;
6280	}
6281
6282	void
6283	lt_update_exe_path (const char name, const char value)
6284	{
6285	lt_debugprintf (__FILE__, __LINE__,
6286	"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
6287	nonnull (name), nonnull (value));
6288
6289	if (name && name && value && value)
6290	{
6291	char *new_value = lt_extend_str (getenv (name), value, 0);
6292	/* some systems can't cope with a ':'-terminated path #' */
6293	size_t len = strlen (new_value);
6294	while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
6295	{
6296	new_value[--len] = '\0';
6297	}
6298	lt_setenv (name, new_value);
6299	XFREE (new_value);
6300	}
6301	}
6302
6303	void
6304	lt_update_lib_path (const char name, const char value)
6305	{
6306	lt_debugprintf (__FILE__, __LINE__,
6307	"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
6308	nonnull (name), nonnull (value));
6309
6310	if (name && name && value && value)
6311	{
6312	char *new_value = lt_extend_str (getenv (name), value, 0);
6313	lt_setenv (name, new_value);
6314	XFREE (new_value);
6315	}
6316	}
6317
6318	EOF
6319	case $host_os in
6320	mingw*)
6321	cat <<"EOF"
6322
6323	/* Prepares an argument vector before calling spawn().
6324	Note that spawn() does not by itself call the command interpreter
6325	(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
6326	({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
6327	GetVersionEx(&v);
6328	v.dwPlatformId == VER_PLATFORM_WIN32_NT;
6329	}) ? "cmd.exe" : "command.com").
6330	Instead it simply concatenates the arguments, separated by ' ', and calls
6331	CreateProcess(). We must quote the arguments since Win32 CreateProcess()
6332	interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
6333	special way:
6334	- Space and tab are interpreted as delimiters. They are not treated as
6335	delimiters if they are surrounded by double quotes: "...".
6336	- Unescaped double quotes are removed from the input. Their only effect is
6337	that within double quotes, space and tab are treated like normal
6338	characters.
6339	- Backslashes not followed by double quotes are not special.
6340	- But 2*n+1 backslashes followed by a double quote become
6341	n backslashes followed by a double quote (n >= 0):
6342	\" -> "
6343	\\\" -> \"
6344	\\\\\" -> \\"
6345	*/
6346	#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"
6347	#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"
6348	char **
6349	prepare_spawn (char **argv)
6350	{
6351	size_t argc;
6352	char **new_argv;
6353	size_t i;
6354
6355	/* Count number of arguments. */
6356	for (argc = 0; argv[argc] != NULL; argc++)
6357	;
6358
6359	/* Allocate new argument vector. */
6360	new_argv = XMALLOC (char *, argc + 1);
6361
6362	/* Put quoted arguments into the new argument vector. */
6363	for (i = 0; i < argc; i++)
6364	{
6365	const char *string = argv[i];
6366
6367	if (string[0] == '\0')
6368	new_argv[i] = xstrdup ("\"\"");
6369	else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
6370	{
6371	int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
6372	size_t length;
6373	unsigned int backslashes;
6374	const char *s;
6375	char *quoted_string;
6376	char *p;
6377
6378	length = 0;
6379	backslashes = 0;
6380	if (quote_around)
6381	length++;
6382	for (s = string; *s != '\0'; s++)
6383	{
6384	char c = *s;
6385	if (c == '"')
6386	length += backslashes + 1;
6387	length++;
6388	if (c == '\\')
6389	backslashes++;
6390	else
6391	backslashes = 0;
6392	}
6393	if (quote_around)
6394	length += backslashes + 1;
6395
6396	quoted_string = XMALLOC (char, length + 1);
6397
6398	p = quoted_string;
6399	backslashes = 0;
6400	if (quote_around)
6401	*p++ = '"';
6402	for (s = string; *s != '\0'; s++)
6403	{
6404	char c = *s;
6405	if (c == '"')
6406	{
6407	unsigned int j;
6408	for (j = backslashes + 1; j > 0; j--)
6409	*p++ = '\\';
6410	}
6411	*p++ = c;
6412	if (c == '\\')
6413	backslashes++;
6414	else
6415	backslashes = 0;
6416	}
6417	if (quote_around)
6418	{
6419	unsigned int j;
6420	for (j = backslashes; j > 0; j--)
6421	*p++ = '\\';
6422	*p++ = '"';
6423	}
6424	*p = '\0';
6425
6426	new_argv[i] = quoted_string;
6427	}
6428	else
6429	new_argv[i] = (char *) string;
6430	}
6431	new_argv[argc] = NULL;
6432
6433	return new_argv;
6434	}
6435	EOF
6436	;;
6437	esac
6438
6439	cat <<"EOF"
6440	void lt_dump_script (FILE* f)
6441	{
6442	EOF
6443	func_emit_wrapper yes \|
6444	$SED -n -e '
6445	s/^$.\{79\}$$..*$/\1\
6446	\2/
6447	h
6448	s/$[\\"]$/\\\1/g
6449	s/$/\\n/
6450	s/$[^\n]$./ fputs ("\1", f);/p
6451	g
6452	D'
6453	cat <<"EOF"
6454	}
6455	EOF
6456	}
6457	# end: func_emit_cwrapperexe_src
6458
6459	# func_win32_import_lib_p ARG
6460	# True if ARG is an import lib, as indicated by $file_magic_cmd
6461	func_win32_import_lib_p ()
6462	{
6463	$debug_cmd
6464
6465	case `eval $file_magic_cmd \"\$1\" 2>/dev/null \| $SED -e 10q` in
6466	import) : ;;
6467	*) false ;;
6468	esac
6469	}
6470
6471	# func_suncc_cstd_abi
6472	# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
6473	# Several compiler flags select an ABI that is incompatible with the
6474	# Cstd library. Avoid specifying it if any are in CXXFLAGS.
6475	func_suncc_cstd_abi ()
6476	{
6477	$debug_cmd
6478
6479	case " $compile_command " in
6480	" -compat=g "\|\ -std=c++[0-9][0-9]\ \|" -library=stdcxx4 "\|" -library=stlport4 ")
6481	suncc_use_cstd_abi=no
6482	;;
6483	*)
6484	suncc_use_cstd_abi=yes
6485	;;
6486	esac
6487	}
6488
6489	# func_mode_link arg...
6490	func_mode_link ()
6491	{
6492	$debug_cmd
6493
6494	case $host in
6495	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
6496	# It is impossible to link a dll without this setting, and
6497	# we shouldn't force the makefile maintainer to figure out
6498	# what system we are compiling for in order to pass an extra
6499	# flag for every libtool invocation.
6500	# allow_undefined=no
6501
6502	# FIXME: Unfortunately, there are problems with the above when trying
6503	# to make a dll that has undefined symbols, in which case not
6504	# even a static library is built. For now, we need to specify
6505	# -no-undefined on the libtool link line when we can be certain
6506	# that all symbols are satisfied, otherwise we get a static library.
6507	allow_undefined=yes
6508	;;
6509	*)
6510	allow_undefined=yes
6511	;;
6512	esac
6513	libtool_args=$nonopt
6514	base_compile="$nonopt $@"
6515	compile_command=$nonopt
6516	finalize_command=$nonopt
6517
6518	compile_rpath=
6519	finalize_rpath=
6520	compile_shlibpath=
6521	finalize_shlibpath=
6522	convenience=
6523	old_convenience=
6524	deplibs=
6525	old_deplibs=
6526	compiler_flags=
6527	linker_flags=
6528	dllsearchpath=
6529	lib_search_path=`pwd`
6530	inst_prefix_dir=
6531	new_inherited_linker_flags=
6532
6533	avoid_version=no
6534	bindir=
6535	dlfiles=
6536	dlprefiles=
6537	dlself=no
6538	export_dynamic=no
6539	export_symbols=
6540	export_symbols_regex=
6541	generated=
6542	libobjs=
6543	ltlibs=
6544	module=no
6545	no_install=no
6546	objs=
6547	os2dllname=
6548	non_pic_objects=
6549	precious_files_regex=
6550	prefer_static_libs=no
6551	preload=false
6552	prev=
6553	prevarg=
6554	release=
6555	rpath=
6556	xrpath=
6557	perm_rpath=
6558	temp_rpath=
6559	thread_safe=no
6560	vinfo=
6561	vinfo_number=no
6562	weak_libs=
6563	single_module=$wl-single_module
6564	func_infer_tag $base_compile
6565
6566	# We need to know -static, to get the right output filenames.
6567	for arg
6568	do
6569	case $arg in
6570	-shared)
6571	test yes != "$build_libtool_libs" \
6572	&& func_fatal_configuration "cannot build a shared library"
6573	build_old_libs=no
6574	break
6575	;;
6576	-all-static \| -static \| -static-libtool-libs)
6577	case $arg in
6578	-all-static)
6579	if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
6580	func_warning "complete static linking is impossible in this configuration"
6581	fi
6582	if test -n "$link_static_flag"; then
6583	dlopen_self=$dlopen_self_static
6584	fi
6585	prefer_static_libs=yes
6586	;;
6587	-static)
6588	if test -z "$pic_flag" && test -n "$link_static_flag"; then
6589	dlopen_self=$dlopen_self_static
6590	fi
6591	prefer_static_libs=built
6592	;;
6593	-static-libtool-libs)
6594	if test -z "$pic_flag" && test -n "$link_static_flag"; then
6595	dlopen_self=$dlopen_self_static
6596	fi
6597	prefer_static_libs=yes
6598	;;
6599	esac
6600	build_libtool_libs=no
6601	build_old_libs=yes
6602	break
6603	;;
6604	esac
6605	done
6606
6607	# See if our shared archives depend on static archives.
6608	test -n "$old_archive_from_new_cmds" && build_old_libs=yes
6609
6610	# Go through the arguments, transforming them on the way.
6611	while test "$#" -gt 0; do
6612	arg=$1
6613	shift
6614	func_quote_for_eval "$arg"
6615	qarg=$func_quote_for_eval_unquoted_result
6616	func_append libtool_args " $func_quote_for_eval_result"
6617
6618	# If the previous option needs an argument, assign it.
6619	if test -n "$prev"; then
6620	case $prev in
6621	output)
6622	func_append compile_command " @OUTPUT@"
6623	func_append finalize_command " @OUTPUT@"
6624	;;
6625	esac
6626
6627	case $prev in
6628	bindir)
6629	bindir=$arg
6630	prev=
6631	continue
6632	;;
6633	dlfiles\|dlprefiles)
6634	$preload \|\| {
6635	# Add the symbol object into the linking commands.
6636	func_append compile_command " @SYMFILE@"
6637	func_append finalize_command " @SYMFILE@"
6638	preload=:
6639	}
6640	case $arg in
6641	.la \| .lo) ;; # We handle these cases below.
6642	force)
6643	if test no = "$dlself"; then
6644	dlself=needless
6645	export_dynamic=yes
6646	fi
6647	prev=
6648	continue
6649	;;
6650	self)
6651	if test dlprefiles = "$prev"; then
6652	dlself=yes
6653	elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
6654	dlself=yes
6655	else
6656	dlself=needless
6657	export_dynamic=yes
6658	fi
6659	prev=
6660	continue
6661	;;
6662	*)
6663	if test dlfiles = "$prev"; then
6664	func_append dlfiles " $arg"
6665	else
6666	func_append dlprefiles " $arg"
6667	fi
6668	prev=
6669	continue
6670	;;
6671	esac
6672	;;
6673	expsyms)
6674	export_symbols=$arg
6675	test -f "$arg" \
6676	\|\| func_fatal_error "symbol file '$arg' does not exist"
6677	prev=
6678	continue
6679	;;
6680	expsyms_regex)
6681	export_symbols_regex=$arg
6682	prev=
6683	continue
6684	;;
6685	framework)
6686	case $host in
6687	--darwin*)
6688	case "$deplibs " in
6689	" $qarg.ltframework ") ;;
6690	*) func_append deplibs " $qarg.ltframework" # this is fixed later
6691	;;
6692	esac
6693	;;
6694	esac
6695	prev=
6696	continue
6697	;;
6698	inst_prefix)
6699	inst_prefix_dir=$arg
6700	prev=
6701	continue
6702	;;
6703	mllvm)
6704	# Clang does not use LLVM to link, so we can simply discard any
6705	# '-mllvm $arg' options when doing the link step.
6706	prev=
6707	continue
6708	;;
6709	objectlist)
6710	if test -f "$arg"; then
6711	save_arg=$arg
6712	moreargs=
6713	for fil in `cat "$save_arg"`
6714	do
6715	# func_append moreargs " $fil"
6716	arg=$fil
6717	# A libtool-controlled object.
6718
6719	# Check to see that this really is a libtool object.
6720	if func_lalib_unsafe_p "$arg"; then
6721	pic_object=
6722	non_pic_object=
6723
6724	# Read the .lo file
6725	func_source "$arg"
6726
6727	if test -z "$pic_object" \|\|
6728	test -z "$non_pic_object" \|\|
6729	test none = "$pic_object" &&
6730	test none = "$non_pic_object"; then
6731	func_fatal_error "cannot find name of object for '$arg'"
6732	fi
6733
6734	# Extract subdirectory from the argument.
6735	func_dirname "$arg" "/" ""
6736	xdir=$func_dirname_result
6737
6738	if test none != "$pic_object"; then
6739	# Prepend the subdirectory the object is found in.
6740	pic_object=$xdir$pic_object
6741
6742	if test dlfiles = "$prev"; then
6743	if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
6744	func_append dlfiles " $pic_object"
6745	prev=
6746	continue
6747	else
6748	# If libtool objects are unsupported, then we need to preload.
6749	prev=dlprefiles
6750	fi
6751	fi
6752
6753	# CHECK ME: I think I busted this. -Ossama
6754	if test dlprefiles = "$prev"; then
6755	# Preload the old-style object.
6756	func_append dlprefiles " $pic_object"
6757	prev=
6758	fi
6759
6760	# A PIC object.
6761	func_append libobjs " $pic_object"
6762	arg=$pic_object
6763	fi
6764
6765	# Non-PIC object.
6766	if test none != "$non_pic_object"; then
6767	# Prepend the subdirectory the object is found in.
6768	non_pic_object=$xdir$non_pic_object
6769
6770	# A standard non-PIC object
6771	func_append non_pic_objects " $non_pic_object"
6772	if test -z "$pic_object" \|\| test none = "$pic_object"; then
6773	arg=$non_pic_object
6774	fi
6775	else
6776	# If the PIC object exists, use it instead.
6777	# $xdir was prepended to $pic_object above.
6778	non_pic_object=$pic_object
6779	func_append non_pic_objects " $non_pic_object"
6780	fi
6781	else
6782	# Only an error if not doing a dry-run.
6783	if $opt_dry_run; then
6784	# Extract subdirectory from the argument.
6785	func_dirname "$arg" "/" ""
6786	xdir=$func_dirname_result
6787
6788	func_lo2o "$arg"
6789	pic_object=$xdir$objdir/$func_lo2o_result
6790	non_pic_object=$xdir$func_lo2o_result
6791	func_append libobjs " $pic_object"
6792	func_append non_pic_objects " $non_pic_object"
6793	else
6794	func_fatal_error "'$arg' is not a valid libtool object"
6795	fi
6796	fi
6797	done
6798	else
6799	func_fatal_error "link input file '$arg' does not exist"
6800	fi
6801	arg=$save_arg
6802	prev=
6803	continue
6804	;;
6805	os2dllname)
6806	os2dllname=$arg
6807	prev=
6808	continue
6809	;;
6810	precious_regex)
6811	precious_files_regex=$arg
6812	prev=
6813	continue
6814	;;
6815	release)
6816	release=-$arg
6817	prev=
6818	continue
6819	;;
6820	rpath \| xrpath)
6821	# We need an absolute path.
6822	case $arg in
6823	[\\/]* \| [A-Za-z]:[\\/]*) ;;
6824	*)
6825	func_fatal_error "only absolute run-paths are allowed"
6826	;;
6827	esac
6828	if test rpath = "$prev"; then
6829	case "$rpath " in
6830	" $arg ") ;;
6831	*) func_append rpath " $arg" ;;
6832	esac
6833	else
6834	case "$xrpath " in
6835	" $arg ") ;;
6836	*) func_append xrpath " $arg" ;;
6837	esac
6838	fi
6839	prev=
6840	continue
6841	;;
6842	shrext)
6843	shrext_cmds=$arg
6844	prev=
6845	continue
6846	;;
6847	weak)
6848	func_append weak_libs " $arg"
6849	prev=
6850	continue
6851	;;
6852	xcclinker)
6853	func_append linker_flags " $qarg"
6854	func_append compiler_flags " $qarg"
6855	prev=
6856	func_append compile_command " $qarg"
6857	func_append finalize_command " $qarg"
6858	continue
6859	;;
6860	xcompiler)
6861	func_append compiler_flags " $qarg"
6862	prev=
6863	func_append compile_command " $qarg"
6864	func_append finalize_command " $qarg"
6865	continue
6866	;;
6867	xlinker)
6868	func_append linker_flags " $qarg"
6869	func_append compiler_flags " $wl$qarg"
6870	prev=
6871	func_append compile_command " $wl$qarg"
6872	func_append finalize_command " $wl$qarg"
6873	continue
6874	;;
6875	*)
6876	eval "$prev=\"\$arg\""
6877	prev=
6878	continue
6879	;;
6880	esac
6881	fi # test -n "$prev"
6882
6883	prevarg=$arg
6884
6885	case $arg in
6886	-all-static)
6887	if test -n "$link_static_flag"; then
6888	# See comment for -static flag below, for more details.
6889	func_append compile_command " $link_static_flag"
6890	func_append finalize_command " $link_static_flag"
6891	fi
6892	continue
6893	;;
6894
6895	-allow-undefined)
6896	# FIXME: remove this flag sometime in the future.
6897	func_fatal_error "'-allow-undefined' must not be used because it is the default"
6898	;;
6899
6900	-avoid-version)
6901	avoid_version=yes
6902	continue
6903	;;
6904
6905	-bindir)
6906	prev=bindir
6907	continue
6908	;;
6909
6910	-dlopen)
6911	prev=dlfiles
6912	continue
6913	;;
6914
6915	-dlpreopen)
6916	prev=dlprefiles
6917	continue
6918	;;
6919
6920	-export-dynamic)
6921	export_dynamic=yes
6922	continue
6923	;;
6924
6925	-export-symbols \| -export-symbols-regex)
6926	if test -n "$export_symbols" \|\| test -n "$export_symbols_regex"; then
6927	func_fatal_error "more than one -exported-symbols argument is not allowed"
6928	fi
6929	if test X-export-symbols = "X$arg"; then
6930	prev=expsyms
6931	else
6932	prev=expsyms_regex
6933	fi
6934	continue
6935	;;
6936
6937	-framework)
6938	prev=framework
6939	continue
6940	;;
6941
6942	-inst-prefix-dir)
6943	prev=inst_prefix
6944	continue
6945	;;
6946
6947	# The native IRIX linker understands -LANG:, -LIST: and -LNO:*
6948	# so, if we see these flags be careful not to treat them like -L
6949	-L[A-Z][A-Z]:)
6950	case $with_gcc/$host in
6951	no/--irix* \| /--irix*)
6952	func_append compile_command " $arg"
6953	func_append finalize_command " $arg"
6954	;;
6955	esac
6956	continue
6957	;;
6958
6959	-L*)
6960	func_stripname "-L" '' "$arg"
6961	if test -z "$func_stripname_result"; then
6962	if test "$#" -gt 0; then
6963	func_fatal_error "require no space between '-L' and '$1'"
6964	else
6965	func_fatal_error "need path for '-L' option"
6966	fi
6967	fi
6968	func_resolve_sysroot "$func_stripname_result"
6969	dir=$func_resolve_sysroot_result
6970	# We need an absolute path.
6971	case $dir in
6972	[\\/]* \| [A-Za-z]:[\\/]*) ;;
6973	*)
6974	absdir=`cd "$dir" && pwd`
6975	test -z "$absdir" && \
6976	func_fatal_error "cannot determine absolute directory name of '$dir'"
6977	dir=$absdir
6978	;;
6979	esac
6980	case "$deplibs " in
6981	" -L$dir " \| " $arg ")
6982	# Will only happen for absolute or sysroot arguments
6983	;;
6984	*)
6985	# Preserve sysroot, but never include relative directories
6986	case $dir in
6987	[\\/]* \| [A-Za-z]:[\\/]* \| =*) func_append deplibs " $arg" ;;
6988	*) func_append deplibs " -L$dir" ;;
6989	esac
6990	func_append lib_search_path " $dir"
6991	;;
6992	esac
6993	case $host in
6994	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
6995	testbindir=`$ECHO "$dir" \| $SED 's/lib$/bin*'`
6996	case :$dllsearchpath: in
6997	":$dir:") ;;
6998	::) dllsearchpath=$dir;;
6999	*) func_append dllsearchpath ":$dir";;
7000	esac
7001	case :$dllsearchpath: in
7002	":$testbindir:") ;;
7003	::) dllsearchpath=$testbindir;;
7004	*) func_append dllsearchpath ":$testbindir";;
7005	esac
7006	;;
7007	esac
7008	continue
7009	;;
7010
7011	-l*)
7012	if test X-lc = "X$arg" \|\| test X-lm = "X$arg"; then
7013	case $host in
7014	--cygwin* \| --mingw* \| --pw32* \| --beos* \| -cegcc \| --haiku*)
7015	# These systems don't actually have a C or math library (as such)
7016	continue
7017	;;
7018	--os2*)
7019	# These systems don't actually have a C library (as such)
7020	test X-lc = "X$arg" && continue
7021	;;
7022	--openbsd* \| --freebsd* \| --dragonfly* \| --bitrig*)
7023	# Do not include libc due to us having libc/libc_r.
7024	test X-lc = "X$arg" && continue
7025	;;
7026	--rhapsody* \| --darwin1.[012])
7027	# Rhapsody C and math libraries are in the System framework
7028	func_append deplibs " System.ltframework"
7029	continue
7030	;;
7031	--sco3.2v5* \| --sco5v6*)
7032	# Causes problems with __ctype
7033	test X-lc = "X$arg" && continue
7034	;;
7035	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
7036	# Compiler inserts libc in the correct place for threads to work
7037	test X-lc = "X$arg" && continue
7038	;;
7039	esac
7040	elif test X-lc_r = "X$arg"; then
7041	case $host in
7042	--openbsd* \| --freebsd* \| --dragonfly* \| --bitrig*)
7043	# Do not include libc_r directly, use -pthread flag.
7044	continue
7045	;;
7046	esac
7047	fi
7048	func_append deplibs " $arg"
7049	continue
7050	;;
7051
7052	-mllvm)
7053	prev=mllvm
7054	continue
7055	;;
7056
7057	-module)
7058	module=yes
7059	continue
7060	;;
7061
7062	# Tru64 UNIX uses -model [arg] to determine the layout of C++
7063	# classes, name mangling, and exception handling.
7064	# Darwin uses the -arch flag to determine output architecture.
7065	-model\|-arch\|-isysroot\|--sysroot)
7066	func_append compiler_flags " $arg"
7067	func_append compile_command " $arg"
7068	func_append finalize_command " $arg"
7069	prev=xcompiler
7070	continue
7071	;;
7072
7073	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe \
7074	\|-threads\|-fopenmp\|-openmp\|-mp\|-xopenmp\|-omp\|-qsmp=*)
7075	func_append compiler_flags " $arg"
7076	func_append compile_command " $arg"
7077	func_append finalize_command " $arg"
7078	case "$new_inherited_linker_flags " in
7079	" $arg ") ;;
7080	* ) func_append new_inherited_linker_flags " $arg" ;;
7081	esac
7082	continue
7083	;;
7084
7085	-multi_module)
7086	single_module=$wl-multi_module
7087	continue
7088	;;
7089
7090	-no-fast-install)
7091	fast_install=no
7092	continue
7093	;;
7094
7095	-no-install)
7096	case $host in
7097	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --darwin* \| -cegcc)
7098	# The PATH hackery in wrapper scripts is required on Windows
7099	# and Darwin in order for the loader to find any dlls it needs.
7100	func_warning "'-no-install' is ignored for $host"
7101	func_warning "assuming '-no-fast-install' instead"
7102	fast_install=no
7103	;;
7104	*) no_install=yes ;;
7105	esac
7106	continue
7107	;;
7108
7109	-no-undefined)
7110	allow_undefined=no
7111	continue
7112	;;
7113
7114	-objectlist)
7115	prev=objectlist
7116	continue
7117	;;
7118
7119	-os2dllname)
7120	prev=os2dllname
7121	continue
7122	;;
7123
7124	-o) prev=output ;;
7125
7126	-precious-files-regex)
7127	prev=precious_regex
7128	continue
7129	;;
7130
7131	-release)
7132	prev=release
7133	continue
7134	;;
7135
7136	-rpath)
7137	prev=rpath
7138	continue
7139	;;
7140
7141	-R)
7142	prev=xrpath
7143	continue
7144	;;
7145
7146	-R*)
7147	func_stripname '-R' '' "$arg"
7148	dir=$func_stripname_result
7149	# We need an absolute path.
7150	case $dir in
7151	[\\/]* \| [A-Za-z]:[\\/]*) ;;
7152	=*)
7153	func_stripname '=' '' "$dir"
7154	dir=$lt_sysroot$func_stripname_result
7155	;;
7156	*)
7157	func_fatal_error "only absolute run-paths are allowed"
7158	;;
7159	esac
7160	case "$xrpath " in
7161	" $dir ") ;;
7162	*) func_append xrpath " $dir" ;;
7163	esac
7164	continue
7165	;;
7166
7167	-shared)
7168	# The effects of -shared are defined in a previous loop.
7169	continue
7170	;;
7171
7172	-shrext)
7173	prev=shrext
7174	continue
7175	;;
7176
7177	-static \| -static-libtool-libs)
7178	# The effects of -static are defined in a previous loop.
7179	# We used to do the same as -all-static on platforms that
7180	# didn't have a PIC flag, but the assumption that the effects
7181	# would be equivalent was wrong. It would break on at least
7182	# Digital Unix and AIX.
7183	continue
7184	;;
7185
7186	-thread-safe)
7187	thread_safe=yes
7188	continue
7189	;;
7190
7191	-version-info)
7192	prev=vinfo
7193	continue
7194	;;
7195
7196	-version-number)
7197	prev=vinfo
7198	vinfo_number=yes
7199	continue
7200	;;
7201
7202	-weak)
7203	prev=weak
7204	continue
7205	;;
7206
7207	-Wc,*)
7208	func_stripname '-Wc,' '' "$arg"
7209	args=$func_stripname_result
7210	arg=
7211	save_ifs=$IFS; IFS=,
7212	for flag in $args; do
7213	IFS=$save_ifs
7214	func_quote_for_eval "$flag"
7215	func_append arg " $func_quote_for_eval_result"
7216	func_append compiler_flags " $func_quote_for_eval_result"
7217	done
7218	IFS=$save_ifs
7219	func_stripname ' ' '' "$arg"
7220	arg=$func_stripname_result
7221	;;
7222
7223	-Wl,*)
7224	func_stripname '-Wl,' '' "$arg"
7225	args=$func_stripname_result
7226	arg=
7227	save_ifs=$IFS; IFS=,
7228	for flag in $args; do
7229	IFS=$save_ifs
7230	func_quote_for_eval "$flag"
7231	func_append arg " $wl$func_quote_for_eval_result"
7232	func_append compiler_flags " $wl$func_quote_for_eval_result"
7233	func_append linker_flags " $func_quote_for_eval_result"
7234	done
7235	IFS=$save_ifs
7236	func_stripname ' ' '' "$arg"
7237	arg=$func_stripname_result
7238	;;
7239
7240	-Xcompiler)
7241	prev=xcompiler
7242	continue
7243	;;
7244
7245	-Xlinker)
7246	prev=xlinker
7247	continue
7248	;;
7249
7250	-XCClinker)
7251	prev=xcclinker
7252	continue
7253	;;
7254
7255	# -msg_* for osf cc
7256	-msg_*)
7257	func_quote_for_eval "$arg"
7258	arg=$func_quote_for_eval_result
7259	;;
7260
7261	# Flags to be passed through unchanged, with rationale:
7262	# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
7263	# -r[0-9][0-9]* specify processor for the SGI compiler
7264	# -xarch=, -xtarget= enable 64-bit mode for the Sun compiler
7265	# +DA, +DD enable 64-bit mode for the HP compiler
7266	# -q* compiler args for the IBM compiler
7267	# -m, -t[45], -txscale* architecture-specific flags for GCC
7268	# -F/path path to uninstalled frameworks, gcc on darwin
7269	# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
7270	# -fstack-protector* stack protector flags for GCC
7271	# @file GCC response files
7272	# -tp=* Portland pgcc target processor selection
7273	# --sysroot=* for sysroot support
7274	# -O, -g, -flto, -fwhopr, -fuse-linker-plugin GCC link-time optimization
7275	# -stdlib=* select c++ std lib with clang
7276	-64\|-mips[0-9]\|-r[0-9][0-9]\|-xarch=\|-xtarget=\|+DA\|+DD\|-q\|-m*\| \
7277	-t[45]\|-txscale\|-p\|-pg\|--coverage\|-fprofile-\|-F\|@\|-tp=\|--sysroot=*\| \
7278	-O\|-g\|-flto\|-fwhopr\|-fuse-linker-plugin\|-fstack-protector\|-stdlib=)
7279	func_quote_for_eval "$arg"
7280	arg=$func_quote_for_eval_result
7281	func_append compile_command " $arg"
7282	func_append finalize_command " $arg"
7283	func_append compiler_flags " $arg"
7284	continue
7285	;;
7286
7287	-Z*)
7288	if test os2 = "`expr $host : '.*$os2$'`"; then
7289	# OS/2 uses -Zxxx to specify OS/2-specific options
7290	compiler_flags="$compiler_flags $arg"
7291	func_append compile_command " $arg"
7292	func_append finalize_command " $arg"
7293	case $arg in
7294	-Zlinker \| -Zstack)
7295	prev=xcompiler
7296	;;
7297	esac
7298	continue
7299	else
7300	# Otherwise treat like 'Some other compiler flag' below
7301	func_quote_for_eval "$arg"
7302	arg=$func_quote_for_eval_result
7303	fi
7304	;;
7305
7306	# Some other compiler flag.
7307	-* \| +*)
7308	func_quote_for_eval "$arg"
7309	arg=$func_quote_for_eval_result
7310	;;
7311
7312	*.$objext)
7313	# A standard object.
7314	func_append objs " $arg"
7315	;;
7316
7317	*.lo)
7318	# A libtool-controlled object.
7319
7320	# Check to see that this really is a libtool object.
7321	if func_lalib_unsafe_p "$arg"; then
7322	pic_object=
7323	non_pic_object=
7324
7325	# Read the .lo file
7326	func_source "$arg"
7327
7328	if test -z "$pic_object" \|\|
7329	test -z "$non_pic_object" \|\|
7330	test none = "$pic_object" &&
7331	test none = "$non_pic_object"; then
7332	func_fatal_error "cannot find name of object for '$arg'"
7333	fi
7334
7335	# Extract subdirectory from the argument.
7336	func_dirname "$arg" "/" ""
7337	xdir=$func_dirname_result
7338
7339	test none = "$pic_object" \|\| {
7340	# Prepend the subdirectory the object is found in.
7341	pic_object=$xdir$pic_object
7342
7343	if test dlfiles = "$prev"; then
7344	if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7345	func_append dlfiles " $pic_object"
7346	prev=
7347	continue
7348	else
7349	# If libtool objects are unsupported, then we need to preload.
7350	prev=dlprefiles
7351	fi
7352	fi
7353
7354	# CHECK ME: I think I busted this. -Ossama
7355	if test dlprefiles = "$prev"; then
7356	# Preload the old-style object.
7357	func_append dlprefiles " $pic_object"
7358	prev=
7359	fi
7360
7361	# A PIC object.
7362	func_append libobjs " $pic_object"
7363	arg=$pic_object
7364	}
7365
7366	# Non-PIC object.
7367	if test none != "$non_pic_object"; then
7368	# Prepend the subdirectory the object is found in.
7369	non_pic_object=$xdir$non_pic_object
7370
7371	# A standard non-PIC object
7372	func_append non_pic_objects " $non_pic_object"
7373	if test -z "$pic_object" \|\| test none = "$pic_object"; then
7374	arg=$non_pic_object
7375	fi
7376	else
7377	# If the PIC object exists, use it instead.
7378	# $xdir was prepended to $pic_object above.
7379	non_pic_object=$pic_object
7380	func_append non_pic_objects " $non_pic_object"
7381	fi
7382	else
7383	# Only an error if not doing a dry-run.
7384	if $opt_dry_run; then
7385	# Extract subdirectory from the argument.
7386	func_dirname "$arg" "/" ""
7387	xdir=$func_dirname_result
7388
7389	func_lo2o "$arg"
7390	pic_object=$xdir$objdir/$func_lo2o_result
7391	non_pic_object=$xdir$func_lo2o_result
7392	func_append libobjs " $pic_object"
7393	func_append non_pic_objects " $non_pic_object"
7394	else
7395	func_fatal_error "'$arg' is not a valid libtool object"
7396	fi
7397	fi
7398	;;
7399
7400	*.$libext)
7401	# An archive.
7402	func_append deplibs " $arg"
7403	func_append old_deplibs " $arg"
7404	continue
7405	;;
7406
7407	*.la)
7408	# A libtool-controlled library.
7409
7410	func_resolve_sysroot "$arg"
7411	if test dlfiles = "$prev"; then
7412	# This library was specified with -dlopen.
7413	func_append dlfiles " $func_resolve_sysroot_result"
7414	prev=
7415	elif test dlprefiles = "$prev"; then
7416	# The library was specified with -dlpreopen.
7417	func_append dlprefiles " $func_resolve_sysroot_result"
7418	prev=
7419	else
7420	func_append deplibs " $func_resolve_sysroot_result"
7421	fi
7422	continue
7423	;;
7424
7425	# Some other compiler argument.
7426	*)
7427	# Unknown arguments in both finalize_command and compile_command need
7428	# to be aesthetically quoted because they are evaled later.
7429	func_quote_for_eval "$arg"
7430	arg=$func_quote_for_eval_result
7431	;;
7432	esac # arg
7433
7434	# Now actually substitute the argument into the commands.
7435	if test -n "$arg"; then
7436	func_append compile_command " $arg"
7437	func_append finalize_command " $arg"
7438	fi
7439	done # argument parsing loop
7440
7441	test -n "$prev" && \
7442	func_fatal_help "the '$prevarg' option requires an argument"
7443
7444	if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
7445	eval arg=\"$export_dynamic_flag_spec\"
7446	func_append compile_command " $arg"
7447	func_append finalize_command " $arg"
7448	fi
7449
7450	oldlibs=
7451	# calculate the name of the file, without its directory
7452	func_basename "$output"
7453	outputname=$func_basename_result
7454	libobjs_save=$libobjs
7455
7456	if test -n "$shlibpath_var"; then
7457	# get the directories listed in $shlibpath_var
7458	eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \\| \$SED \'s/:/ /g\'\`
7459	else
7460	shlib_search_path=
7461	fi
7462	eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
7463	eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
7464
7465	# Definition is injected by LT_CONFIG during libtool generation.
7466	func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
7467
7468	func_dirname "$output" "/" ""
7469	output_objdir=$func_dirname_result$objdir
7470	func_to_tool_file "$output_objdir/"
7471	tool_output_objdir=$func_to_tool_file_result
7472	# Create the object directory.
7473	func_mkdir_p "$output_objdir"
7474
7475	# Determine the type of output
7476	case $output in
7477	"")
7478	func_fatal_help "you must specify an output file"
7479	;;
7480	*.$libext) linkmode=oldlib ;;
7481	.lo \| .$objext) linkmode=obj ;;
7482	*.la) linkmode=lib ;;
7483	*) linkmode=prog ;; # Anything else should be a program.
7484	esac
7485
7486	specialdeplibs=
7487
7488	libs=
7489	# Find all interdependent deplibs by searching for libraries
7490	# that are linked more than once (e.g. -la -lb -la)
7491	for deplib in $deplibs; do
7492	if $opt_preserve_dup_deps; then
7493	case "$libs " in
7494	" $deplib ") func_append specialdeplibs " $deplib" ;;
7495	esac
7496	fi
7497	func_append libs " $deplib"
7498	done
7499
7500	if test lib = "$linkmode"; then
7501	libs="$predeps $libs $compiler_lib_search_path $postdeps"
7502
7503	# Compute libraries that are listed more than once in $predeps
7504	# $postdeps and mark them as special (i.e., whose duplicates are
7505	# not to be eliminated).
7506	pre_post_deps=
7507	if $opt_duplicate_compiler_generated_deps; then
7508	for pre_post_dep in $predeps $postdeps; do
7509	case "$pre_post_deps " in
7510	" $pre_post_dep ") func_append specialdeplibs " $pre_post_deps" ;;
7511	esac
7512	func_append pre_post_deps " $pre_post_dep"
7513	done
7514	fi
7515	pre_post_deps=
7516	fi
7517
7518	deplibs=
7519	newdependency_libs=
7520	newlib_search_path=
7521	need_relink=no # whether we're linking any uninstalled libtool libraries
7522	notinst_deplibs= # not-installed libtool libraries
7523	notinst_path= # paths that contain not-installed libtool libraries
7524
7525	case $linkmode in
7526	lib)
7527	passes="conv dlpreopen link"
7528	for file in $dlfiles $dlprefiles; do
7529	case $file in
7530	*.la) ;;
7531	*)
7532	func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
7533	;;
7534	esac
7535	done
7536	;;
7537	prog)
7538	compile_deplibs=
7539	finalize_deplibs=
7540	alldeplibs=false
7541	newdlfiles=
7542	newdlprefiles=
7543	passes="conv scan dlopen dlpreopen link"
7544	;;
7545	*) passes="conv"
7546	;;
7547	esac
7548
7549	for pass in $passes; do
7550	# The preopen pass in lib mode reverses $deplibs; put it back here
7551	# so that -L comes before libs that need it for instance...
7552	if test lib,link = "$linkmode,$pass"; then
7553	## FIXME: Find the place where the list is rebuilt in the wrong
7554	## order, and fix it there properly
7555	tmp_deplibs=
7556	for deplib in $deplibs; do
7557	tmp_deplibs="$deplib $tmp_deplibs"
7558	done
7559	deplibs=$tmp_deplibs
7560	fi
7561
7562	if test lib,link = "$linkmode,$pass" \|\|
7563	test prog,scan = "$linkmode,$pass"; then
7564	libs=$deplibs
7565	deplibs=
7566	fi
7567	if test prog = "$linkmode"; then
7568	case $pass in
7569	dlopen) libs=$dlfiles ;;
7570	dlpreopen) libs=$dlprefiles ;;
7571	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
7572	esac
7573	fi
7574	if test lib,dlpreopen = "$linkmode,$pass"; then
7575	# Collect and forward deplibs of preopened libtool libs
7576	for lib in $dlprefiles; do
7577	# Ignore non-libtool-libs
7578	dependency_libs=
7579	func_resolve_sysroot "$lib"
7580	case $lib in
7581	*.la) func_source "$func_resolve_sysroot_result" ;;
7582	esac
7583
7584	# Collect preopened libtool deplibs, except any this library
7585	# has declared as weak libs
7586	for deplib in $dependency_libs; do
7587	func_basename "$deplib"
7588	deplib_base=$func_basename_result
7589	case " $weak_libs " in
7590	" $deplib_base ") ;;
7591	*) func_append deplibs " $deplib" ;;
7592	esac
7593	done
7594	done
7595	libs=$dlprefiles
7596	fi
7597	if test dlopen = "$pass"; then
7598	# Collect dlpreopened libraries
7599	save_deplibs=$deplibs
7600	deplibs=
7601	fi
7602
7603	for deplib in $libs; do
7604	lib=
7605	found=false
7606	case $deplib in
7607	-mt\|-mthreads\|-kthread\|-Kthread\|-pthread\|-pthreads\|--thread-safe \
7608	\|-threads\|-fopenmp\|-openmp\|-mp\|-xopenmp\|-omp\|-qsmp=*)
7609	if test prog,link = "$linkmode,$pass"; then
7610	compile_deplibs="$deplib $compile_deplibs"
7611	finalize_deplibs="$deplib $finalize_deplibs"
7612	else
7613	func_append compiler_flags " $deplib"
7614	if test lib = "$linkmode"; then
7615	case "$new_inherited_linker_flags " in
7616	" $deplib ") ;;
7617	* ) func_append new_inherited_linker_flags " $deplib" ;;
7618	esac
7619	fi
7620	fi
7621	continue
7622	;;
7623	-l*)
7624	if test lib != "$linkmode" && test prog != "$linkmode"; then
7625	func_warning "'-l' is ignored for archives/objects"
7626	continue
7627	fi
7628	func_stripname '-l' '' "$deplib"
7629	name=$func_stripname_result
7630	if test lib = "$linkmode"; then
7631	searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
7632	else
7633	searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
7634	fi
7635	for searchdir in $searchdirs; do
7636	for search_ext in .la $std_shrext .so .a; do
7637	# Search the libtool library
7638	lib=$searchdir/lib$name$search_ext
7639	if test -f "$lib"; then
7640	if test .la = "$search_ext"; then
7641	found=:
7642	else
7643	found=false
7644	fi
7645	break 2
7646	fi
7647	done
7648	done
7649	if $found; then
7650	# deplib is a libtool library
7651	# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
7652	# We need to do some special things here, and not later.
7653	if test yes = "$allow_libtool_libs_with_static_runtimes"; then
7654	case " $predeps $postdeps " in
7655	" $deplib ")
7656	if func_lalib_p "$lib"; then
7657	library_names=
7658	old_library=
7659	func_source "$lib"
7660	for l in $old_library $library_names; do
7661	ll=$l
7662	done
7663	if test "X$ll" = "X$old_library"; then # only static version available
7664	found=false
7665	func_dirname "$lib" "" "."
7666	ladir=$func_dirname_result
7667	lib=$ladir/$old_library
7668	if test prog,link = "$linkmode,$pass"; then
7669	compile_deplibs="$deplib $compile_deplibs"
7670	finalize_deplibs="$deplib $finalize_deplibs"
7671	else
7672	deplibs="$deplib $deplibs"
7673	test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7674	fi
7675	continue
7676	fi
7677	fi
7678	;;
7679	*) ;;
7680	esac
7681	fi
7682	else
7683	# deplib doesn't seem to be a libtool library
7684	if test prog,link = "$linkmode,$pass"; then
7685	compile_deplibs="$deplib $compile_deplibs"
7686	finalize_deplibs="$deplib $finalize_deplibs"
7687	else
7688	deplibs="$deplib $deplibs"
7689	test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7690	fi
7691	continue
7692	fi
7693	;; # -l
7694	*.ltframework)
7695	if test prog,link = "$linkmode,$pass"; then
7696	compile_deplibs="$deplib $compile_deplibs"
7697	finalize_deplibs="$deplib $finalize_deplibs"
7698	else
7699	deplibs="$deplib $deplibs"
7700	if test lib = "$linkmode"; then
7701	case "$new_inherited_linker_flags " in
7702	" $deplib ") ;;
7703	* ) func_append new_inherited_linker_flags " $deplib" ;;
7704	esac
7705	fi
7706	fi
7707	continue
7708	;;
7709	-L*)
7710	case $linkmode in
7711	lib)
7712	deplibs="$deplib $deplibs"
7713	test conv = "$pass" && continue
7714	newdependency_libs="$deplib $newdependency_libs"
7715	func_stripname '-L' '' "$deplib"
7716	func_resolve_sysroot "$func_stripname_result"
7717	func_append newlib_search_path " $func_resolve_sysroot_result"
7718	;;
7719	prog)
7720	if test conv = "$pass"; then
7721	deplibs="$deplib $deplibs"
7722	continue
7723	fi
7724	if test scan = "$pass"; then
7725	deplibs="$deplib $deplibs"
7726	else
7727	compile_deplibs="$deplib $compile_deplibs"
7728	finalize_deplibs="$deplib $finalize_deplibs"
7729	fi
7730	func_stripname '-L' '' "$deplib"
7731	func_resolve_sysroot "$func_stripname_result"
7732	func_append newlib_search_path " $func_resolve_sysroot_result"
7733	;;
7734	*)
7735	func_warning "'-L' is ignored for archives/objects"
7736	;;
7737	esac # linkmode
7738	continue
7739	;; # -L
7740	-R*)
7741	if test link = "$pass"; then
7742	func_stripname '-R' '' "$deplib"
7743	func_resolve_sysroot "$func_stripname_result"
7744	dir=$func_resolve_sysroot_result
7745	# Make sure the xrpath contains only unique directories.
7746	case "$xrpath " in
7747	" $dir ") ;;
7748	*) func_append xrpath " $dir" ;;
7749	esac
7750	fi
7751	deplibs="$deplib $deplibs"
7752	continue
7753	;;
7754	*.la)
7755	func_resolve_sysroot "$deplib"
7756	lib=$func_resolve_sysroot_result
7757	;;
7758	*.$libext)
7759	if test conv = "$pass"; then
7760	deplibs="$deplib $deplibs"
7761	continue
7762	fi
7763	case $linkmode in
7764	lib)
7765	# Linking convenience modules into shared libraries is allowed,
7766	# but linking other static libraries is non-portable.
7767	case " $dlpreconveniencelibs " in
7768	" $deplib ") ;;
7769	*)
7770	valid_a_lib=false
7771	case $deplibs_check_method in
7772	match_pattern*)
7773	set dummy $deplibs_check_method; shift
7774	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
7775	if eval "\$ECHO \"$deplib\"" 2>/dev/null \| $SED 10q \
7776	\| $EGREP "$match_pattern_regex" > /dev/null; then
7777	valid_a_lib=:
7778	fi
7779	;;
7780	pass_all)
7781	valid_a_lib=:
7782	;;
7783	esac
7784	if $valid_a_lib; then
7785	echo
7786	$ECHO "*** Warning: Linking the shared library $output against the"
7787	$ECHO "*** static library $deplib is not portable!"
7788	deplibs="$deplib $deplibs"
7789	else
7790	echo
7791	$ECHO "*** Warning: Trying to link with static lib archive $deplib."
7792	echo "*** I have the capability to make that library automatically link in when"
7793	echo "*** you link to this library. But I can only do this if you have a"
7794	echo "*** shared version of the library, which you do not appear to have"
7795	echo "*** because the file extensions .$libext of this argument makes me believe"
7796	echo "*** that it is just a static archive that I should not use here."
7797	fi
7798	;;
7799	esac
7800	continue
7801	;;
7802	prog)
7803	if test link != "$pass"; then
7804	deplibs="$deplib $deplibs"
7805	else
7806	compile_deplibs="$deplib $compile_deplibs"
7807	finalize_deplibs="$deplib $finalize_deplibs"
7808	fi
7809	continue
7810	;;
7811	esac # linkmode
7812	;; # *.$libext
7813	.lo \| .$objext)
7814	if test conv = "$pass"; then
7815	deplibs="$deplib $deplibs"
7816	elif test prog = "$linkmode"; then
7817	if test dlpreopen = "$pass" \|\| test yes != "$dlopen_support" \|\| test no = "$build_libtool_libs"; then
7818	# If there is no dlopen support or we're linking statically,
7819	# we need to preload.
7820	func_append newdlprefiles " $deplib"
7821	compile_deplibs="$deplib $compile_deplibs"
7822	finalize_deplibs="$deplib $finalize_deplibs"
7823	else
7824	func_append newdlfiles " $deplib"
7825	fi
7826	fi
7827	continue
7828	;;
7829	%DEPLIBS%)
7830	alldeplibs=:
7831	continue
7832	;;
7833	esac # case $deplib
7834
7835	$found \|\| test -f "$lib" \
7836	\|\| func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
7837
7838	# Check to see that this really is a libtool archive.
7839	func_lalib_unsafe_p "$lib" \
7840	\|\| func_fatal_error "'$lib' is not a valid libtool archive"
7841
7842	func_dirname "$lib" "" "."
7843	ladir=$func_dirname_result
7844
7845	dlname=
7846	dlopen=
7847	dlpreopen=
7848	libdir=
7849	library_names=
7850	old_library=
7851	inherited_linker_flags=
7852	# If the library was installed with an old release of libtool,
7853	# it will not redefine variables installed, or shouldnotlink
7854	installed=yes
7855	shouldnotlink=no
7856	avoidtemprpath=
7857
7858
7859	# Read the .la file
7860	func_source "$lib"
7861
7862	# Convert "-framework foo" to "foo.ltframework"
7863	if test -n "$inherited_linker_flags"; then
7864	tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" \| $SED 's/-framework $[^ $]*$/\1.ltframework/g'`
7865	for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
7866	case " $new_inherited_linker_flags " in
7867	" $tmp_inherited_linker_flag ") ;;
7868	*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
7869	esac
7870	done
7871	fi
7872	dependency_libs=`$ECHO " $dependency_libs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
7873	if test lib,link = "$linkmode,$pass" \|\|
7874	test prog,scan = "$linkmode,$pass" \|\|
7875	{ test prog != "$linkmode" && test lib != "$linkmode"; }; then
7876	test -n "$dlopen" && func_append dlfiles " $dlopen"
7877	test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
7878	fi
7879
7880	if test conv = "$pass"; then
7881	# Only check for convenience libraries
7882	deplibs="$lib $deplibs"
7883	if test -z "$libdir"; then
7884	if test -z "$old_library"; then
7885	func_fatal_error "cannot find name of link library for '$lib'"
7886	fi
7887	# It is a libtool convenience library, so add in its objects.
7888	func_append convenience " $ladir/$objdir/$old_library"
7889	func_append old_convenience " $ladir/$objdir/$old_library"
7890	elif test prog != "$linkmode" && test lib != "$linkmode"; then
7891	func_fatal_error "'$lib' is not a convenience library"
7892	fi
7893	tmp_libs=
7894	for deplib in $dependency_libs; do
7895	deplibs="$deplib $deplibs"
7896	if $opt_preserve_dup_deps; then
7897	case "$tmp_libs " in
7898	" $deplib ") func_append specialdeplibs " $deplib" ;;
7899	esac
7900	fi
7901	func_append tmp_libs " $deplib"
7902	done
7903	continue
7904	fi # $pass = conv
7905
7906
7907	# Get the name of the library we link against.
7908	linklib=
7909	if test -n "$old_library" &&
7910	{ test yes = "$prefer_static_libs" \|\|
7911	test built,no = "$prefer_static_libs,$installed"; }; then
7912	linklib=$old_library
7913	else
7914	for l in $old_library $library_names; do
7915	linklib=$l
7916	done
7917	fi
7918	if test -z "$linklib"; then
7919	func_fatal_error "cannot find name of link library for '$lib'"
7920	fi
7921
7922	# This library was specified with -dlopen.
7923	if test dlopen = "$pass"; then
7924	test -z "$libdir" \
7925	&& func_fatal_error "cannot -dlopen a convenience library: '$lib'"
7926	if test -z "$dlname" \|\|
7927	test yes != "$dlopen_support" \|\|
7928	test no = "$build_libtool_libs"
7929	then
7930	# If there is no dlname, no dlopen support or we're linking
7931	# statically, we need to preload. We also need to preload any
7932	# dependent libraries so libltdl's deplib preloader doesn't
7933	# bomb out in the load deplibs phase.
7934	func_append dlprefiles " $lib $dependency_libs"
7935	else
7936	func_append newdlfiles " $lib"
7937	fi
7938	continue
7939	fi # $pass = dlopen
7940
7941	# We need an absolute path.
7942	case $ladir in
7943	[\\/]* \| [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
7944	*)
7945	abs_ladir=`cd "$ladir" && pwd`
7946	if test -z "$abs_ladir"; then
7947	func_warning "cannot determine absolute directory name of '$ladir'"
7948	func_warning "passing it literally to the linker, although it might fail"
7949	abs_ladir=$ladir
7950	fi
7951	;;
7952	esac
7953	func_basename "$lib"
7954	laname=$func_basename_result
7955
7956	# Find the relevant object directory and library name.
7957	if test yes = "$installed"; then
7958	if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
7959	func_warning "library '$lib' was moved."
7960	dir=$ladir
7961	absdir=$abs_ladir
7962	libdir=$abs_ladir
7963	else
7964	dir=$lt_sysroot$libdir
7965	absdir=$lt_sysroot$libdir
7966	fi
7967	test yes = "$hardcode_automatic" && avoidtemprpath=yes
7968	else
7969	if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
7970	dir=$ladir
7971	absdir=$abs_ladir
7972	# Remove this search path later
7973	func_append notinst_path " $abs_ladir"
7974	else
7975	dir=$ladir/$objdir
7976	absdir=$abs_ladir/$objdir
7977	# Remove this search path later
7978	func_append notinst_path " $abs_ladir"
7979	fi
7980	fi # $installed = yes
7981	func_stripname 'lib' '.la' "$laname"
7982	name=$func_stripname_result
7983
7984	# This library was specified with -dlpreopen.
7985	if test dlpreopen = "$pass"; then
7986	if test -z "$libdir" && test prog = "$linkmode"; then
7987	func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
7988	fi
7989	case $host in
7990	# special handling for platforms with PE-DLLs.
7991	cygwin \| mingw \| cegcc )
7992	# Linker will automatically link against shared library if both
7993	# static and shared are present. Therefore, ensure we extract
7994	# symbols from the import library if a shared library is present
7995	# (otherwise, the dlopen module name will be incorrect). We do
7996	# this by putting the import library name into $newdlprefiles.
7997	# We recover the dlopen module name by 'saving' the la file
7998	# name in a special purpose variable, and (later) extracting the
7999	# dlname from the la file.
8000	if test -n "$dlname"; then
8001	func_tr_sh "$dir/$linklib"
8002	eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
8003	func_append newdlprefiles " $dir/$linklib"
8004	else
8005	func_append newdlprefiles " $dir/$old_library"
8006	# Keep a list of preopened convenience libraries to check
8007	# that they are being used correctly in the link pass.
8008	test -z "$libdir" && \
8009	func_append dlpreconveniencelibs " $dir/$old_library"
8010	fi
8011	;;
8012	* )
8013	# Prefer using a static library (so that no silly _DYNAMIC symbols
8014	# are required to link).
8015	if test -n "$old_library"; then
8016	func_append newdlprefiles " $dir/$old_library"
8017	# Keep a list of preopened convenience libraries to check
8018	# that they are being used correctly in the link pass.
8019	test -z "$libdir" && \
8020	func_append dlpreconveniencelibs " $dir/$old_library"
8021	# Otherwise, use the dlname, so that lt_dlopen finds it.
8022	elif test -n "$dlname"; then
8023	func_append newdlprefiles " $dir/$dlname"
8024	else
8025	func_append newdlprefiles " $dir/$linklib"
8026	fi
8027	;;
8028	esac
8029	fi # $pass = dlpreopen
8030
8031	if test -z "$libdir"; then
8032	# Link the convenience library
8033	if test lib = "$linkmode"; then
8034	deplibs="$dir/$old_library $deplibs"
8035	elif test prog,link = "$linkmode,$pass"; then
8036	compile_deplibs="$dir/$old_library $compile_deplibs"
8037	finalize_deplibs="$dir/$old_library $finalize_deplibs"
8038	else
8039	deplibs="$lib $deplibs" # used for prog,scan pass
8040	fi
8041	continue
8042	fi
8043
8044
8045	if test prog = "$linkmode" && test link != "$pass"; then
8046	func_append newlib_search_path " $ladir"
8047	deplibs="$lib $deplibs"
8048
8049	linkalldeplibs=false
8050	if test no != "$link_all_deplibs" \|\| test -z "$library_names" \|\|
8051	test no = "$build_libtool_libs"; then
8052	linkalldeplibs=:
8053	fi
8054
8055	tmp_libs=
8056	for deplib in $dependency_libs; do
8057	case $deplib in
8058	-L*) func_stripname '-L' '' "$deplib"
8059	func_resolve_sysroot "$func_stripname_result"
8060	func_append newlib_search_path " $func_resolve_sysroot_result"
8061	;;
8062	esac
8063	# Need to link against all dependency_libs?
8064	if $linkalldeplibs; then
8065	deplibs="$deplib $deplibs"
8066	else
8067	# Need to hardcode shared library paths
8068	# or/and link against static libraries
8069	newdependency_libs="$deplib $newdependency_libs"
8070	fi
8071	if $opt_preserve_dup_deps; then
8072	case "$tmp_libs " in
8073	" $deplib ") func_append specialdeplibs " $deplib" ;;
8074	esac
8075	fi
8076	func_append tmp_libs " $deplib"
8077	done # for deplib
8078	continue
8079	fi # $linkmode = prog...
8080
8081	if test prog,link = "$linkmode,$pass"; then
8082	if test -n "$library_names" &&
8083	{ { test no = "$prefer_static_libs" \|\|
8084	test built,yes = "$prefer_static_libs,$installed"; } \|\|
8085	test -z "$old_library"; }; then
8086	# We need to hardcode the library path
8087	if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
8088	# Make sure the rpath contains only unique directories.
8089	case $temp_rpath: in
8090	"$absdir:") ;;
8091	*) func_append temp_rpath "$absdir:" ;;
8092	esac
8093	fi
8094
8095	# Hardcode the library path.
8096	# Skip directories that are in the system default run-time
8097	# search path.
8098	case " $sys_lib_dlsearch_path " in
8099	" $absdir ") ;;
8100	*)
8101	case "$compile_rpath " in
8102	" $absdir ") ;;
8103	*) func_append compile_rpath " $absdir" ;;
8104	esac
8105	;;
8106	esac
8107	case " $sys_lib_dlsearch_path " in
8108	" $libdir ") ;;
8109	*)
8110	case "$finalize_rpath " in
8111	" $libdir ") ;;
8112	*) func_append finalize_rpath " $libdir" ;;
8113	esac
8114	;;
8115	esac
8116	fi # $linkmode,$pass = prog,link...
8117
8118	if $alldeplibs &&
8119	{ test pass_all = "$deplibs_check_method" \|\|
8120	{ test yes = "$build_libtool_libs" &&
8121	test -n "$library_names"; }; }; then
8122	# We only need to search for static libraries
8123	continue
8124	fi
8125	fi
8126
8127	link_static=no # Whether the deplib will be linked statically
8128	use_static_libs=$prefer_static_libs
8129	if test built = "$use_static_libs" && test yes = "$installed"; then
8130	use_static_libs=no
8131	fi
8132	if test -n "$library_names" &&
8133	{ test no = "$use_static_libs" \|\| test -z "$old_library"; }; then
8134	case $host in
8135	cygwin \| mingw \| cegcc \| os2)
8136	# No point in relinking DLLs because paths are not encoded
8137	func_append notinst_deplibs " $lib"
8138	need_relink=no
8139	;;
8140	*)
8141	if test no = "$installed"; then
8142	func_append notinst_deplibs " $lib"
8143	need_relink=yes
8144	fi
8145	;;
8146	esac
8147	# This is a shared library
8148
8149	# Warn about portability, can't link against -module's on some
8150	# systems (darwin). Don't bleat about dlopened modules though!
8151	dlopenmodule=
8152	for dlpremoduletest in $dlprefiles; do
8153	if test "X$dlpremoduletest" = "X$lib"; then
8154	dlopenmodule=$dlpremoduletest
8155	break
8156	fi
8157	done
8158	if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
8159	echo
8160	if test prog = "$linkmode"; then
8161	$ECHO "*** Warning: Linking the executable $output against the loadable module"
8162	else
8163	$ECHO "*** Warning: Linking the shared library $output against the loadable module"
8164	fi
8165	$ECHO "*** $linklib is not portable!"
8166	fi
8167	if test lib = "$linkmode" &&
8168	test yes = "$hardcode_into_libs"; then
8169	# Hardcode the library path.
8170	# Skip directories that are in the system default run-time
8171	# search path.
8172	case " $sys_lib_dlsearch_path " in
8173	" $absdir ") ;;
8174	*)
8175	case "$compile_rpath " in
8176	" $absdir ") ;;
8177	*) func_append compile_rpath " $absdir" ;;
8178	esac
8179	;;
8180	esac
8181	case " $sys_lib_dlsearch_path " in
8182	" $libdir ") ;;
8183	*)
8184	case "$finalize_rpath " in
8185	" $libdir ") ;;
8186	*) func_append finalize_rpath " $libdir" ;;
8187	esac
8188	;;
8189	esac
8190	fi
8191
8192	if test -n "$old_archive_from_expsyms_cmds"; then
8193	# figure out the soname
8194	set dummy $library_names
8195	shift
8196	realname=$1
8197	shift
8198	libname=`eval "\\$ECHO \"$libname_spec\""`
8199	# use dlname if we got it. it's perfectly good, no?
8200	if test -n "$dlname"; then
8201	soname=$dlname
8202	elif test -n "$soname_spec"; then
8203	# bleh windows
8204	case $host in
8205	cygwin \| mingw* \| cegcc \| os2)
8206	func_arith $current - $age
8207	major=$func_arith_result
8208	versuffix=-$major
8209	;;
8210	esac
8211	eval soname=\"$soname_spec\"
8212	else
8213	soname=$realname
8214	fi
8215
8216	# Make a new name for the extract_expsyms_cmds to use
8217	soroot=$soname
8218	func_basename "$soroot"
8219	soname=$func_basename_result
8220	func_stripname 'lib' '.dll' "$soname"
8221	newlib=libimp-$func_stripname_result.a
8222
8223	# If the library has no export list, then create one now
8224	if test -f "$output_objdir/$soname-def"; then :
8225	else
8226	func_verbose "extracting exported symbol list from '$soname'"
8227	func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
8228	fi
8229
8230	# Create $newlib
8231	if test -f "$output_objdir/$newlib"; then :; else
8232	func_verbose "generating import library for '$soname'"
8233	func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
8234	fi
8235	# make sure the library variables are pointing to the new library
8236	dir=$output_objdir
8237	linklib=$newlib
8238	fi # test -n "$old_archive_from_expsyms_cmds"
8239
8240	if test prog = "$linkmode" \|\| test relink != "$opt_mode"; then
8241	add_shlibpath=
8242	add_dir=
8243	add=
8244	lib_linked=yes
8245	case $hardcode_action in
8246	immediate \| unsupported)
8247	if test no = "$hardcode_direct"; then
8248	add=$dir/$linklib
8249	case $host in
8250	--sco3.2v5.0.[024]*) add_dir=-L$dir ;;
8251	--sysv4uw2) add_dir=-L$dir ;;
8252	--sysv5OpenUNIX* \| --sysv5UnixWare7.[01].[10]* \| \
8253	--unixware7*) add_dir=-L$dir ;;
8254	--darwin* )
8255	# if the lib is a (non-dlopened) module then we cannot
8256	# link against it, someone is ignoring the earlier warnings
8257	if /usr/bin/file -L $add 2> /dev/null \|
8258	$GREP ": [^:]* bundle" >/dev/null; then
8259	if test "X$dlopenmodule" != "X$lib"; then
8260	$ECHO "*** Warning: lib $linklib is a module, not a shared library"
8261	if test -z "$old_library"; then
8262	echo
8263	echo "*** And there doesn't seem to be a static archive available"
8264	echo "*** The link will probably fail, sorry"
8265	else
8266	add=$dir/$old_library
8267	fi
8268	elif test -n "$old_library"; then
8269	add=$dir/$old_library
8270	fi
8271	fi
8272	esac
8273	elif test no = "$hardcode_minus_L"; then
8274	case $host in
8275	--sunos*) add_shlibpath=$dir ;;
8276	esac
8277	add_dir=-L$dir
8278	add=-l$name
8279	elif test no = "$hardcode_shlibpath_var"; then
8280	add_shlibpath=$dir
8281	add=-l$name
8282	else
8283	lib_linked=no
8284	fi
8285	;;
8286	relink)
8287	if test yes = "$hardcode_direct" &&
8288	test no = "$hardcode_direct_absolute"; then
8289	add=$dir/$linklib
8290	elif test yes = "$hardcode_minus_L"; then
8291	add_dir=-L$absdir
8292	# Try looking first in the location we're being installed to.
8293	if test -n "$inst_prefix_dir"; then
8294	case $libdir in
8295	[\\/]*)
8296	func_append add_dir " -L$inst_prefix_dir$libdir"
8297	;;
8298	esac
8299	fi
8300	add=-l$name
8301	elif test yes = "$hardcode_shlibpath_var"; then
8302	add_shlibpath=$dir
8303	add=-l$name
8304	else
8305	lib_linked=no
8306	fi
8307	;;
8308	*) lib_linked=no ;;
8309	esac
8310
8311	if test yes != "$lib_linked"; then
8312	func_fatal_configuration "unsupported hardcode properties"
8313	fi
8314
8315	if test -n "$add_shlibpath"; then
8316	case :$compile_shlibpath: in
8317	":$add_shlibpath:") ;;
8318	*) func_append compile_shlibpath "$add_shlibpath:" ;;
8319	esac
8320	fi
8321	if test prog = "$linkmode"; then
8322	test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
8323	test -n "$add" && compile_deplibs="$add $compile_deplibs"
8324	else
8325	test -n "$add_dir" && deplibs="$add_dir $deplibs"
8326	test -n "$add" && deplibs="$add $deplibs"
8327	if test yes != "$hardcode_direct" &&
8328	test yes != "$hardcode_minus_L" &&
8329	test yes = "$hardcode_shlibpath_var"; then
8330	case :$finalize_shlibpath: in
8331	":$libdir:") ;;
8332	*) func_append finalize_shlibpath "$libdir:" ;;
8333	esac
8334	fi
8335	fi
8336	fi
8337
8338	if test prog = "$linkmode" \|\| test relink = "$opt_mode"; then
8339	add_shlibpath=
8340	add_dir=
8341	add=
8342	# Finalize command for both is simple: just hardcode it.
8343	if test yes = "$hardcode_direct" &&
8344	test no = "$hardcode_direct_absolute"; then
8345	add=$libdir/$linklib
8346	elif test yes = "$hardcode_minus_L"; then
8347	add_dir=-L$libdir
8348	add=-l$name
8349	elif test yes = "$hardcode_shlibpath_var"; then
8350	case :$finalize_shlibpath: in
8351	":$libdir:") ;;
8352	*) func_append finalize_shlibpath "$libdir:" ;;
8353	esac
8354	add=-l$name
8355	elif test yes = "$hardcode_automatic"; then
8356	if test -n "$inst_prefix_dir" &&
8357	test -f "$inst_prefix_dir$libdir/$linklib"; then
8358	add=$inst_prefix_dir$libdir/$linklib
8359	else
8360	add=$libdir/$linklib
8361	fi
8362	else
8363	# We cannot seem to hardcode it, guess we'll fake it.
8364	add_dir=-L$libdir
8365	# Try looking first in the location we're being installed to.
8366	if test -n "$inst_prefix_dir"; then
8367	case $libdir in
8368	[\\/]*)
8369	func_append add_dir " -L$inst_prefix_dir$libdir"
8370	;;
8371	esac
8372	fi
8373	add=-l$name
8374	fi
8375
8376	if test prog = "$linkmode"; then
8377	test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
8378	test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
8379	else
8380	test -n "$add_dir" && deplibs="$add_dir $deplibs"
8381	test -n "$add" && deplibs="$add $deplibs"
8382	fi
8383	fi
8384	elif test prog = "$linkmode"; then
8385	# Here we assume that one of hardcode_direct or hardcode_minus_L
8386	# is not unsupported. This is valid on all known static and
8387	# shared platforms.
8388	if test unsupported != "$hardcode_direct"; then
8389	test -n "$old_library" && linklib=$old_library
8390	compile_deplibs="$dir/$linklib $compile_deplibs"
8391	finalize_deplibs="$dir/$linklib $finalize_deplibs"
8392	else
8393	compile_deplibs="-l$name -L$dir $compile_deplibs"
8394	finalize_deplibs="-l$name -L$dir $finalize_deplibs"
8395	fi
8396	elif test yes = "$build_libtool_libs"; then
8397	# Not a shared library
8398	if test pass_all != "$deplibs_check_method"; then
8399	# We're trying link a shared library against a static one
8400	# but the system doesn't support it.
8401
8402	# Just print a warning and add the library to dependency_libs so
8403	# that the program can be linked against the static library.
8404	echo
8405	$ECHO "*** Warning: This system cannot link to static lib archive $lib."
8406	echo "*** I have the capability to make that library automatically link in when"
8407	echo "*** you link to this library. But I can only do this if you have a"
8408	echo "*** shared version of the library, which you do not appear to have."
8409	if test yes = "$module"; then
8410	echo "*** But as you try to build a module library, libtool will still create "
8411	echo "*** a static module, that should work as long as the dlopening application"
8412	echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
8413	if test -z "$global_symbol_pipe"; then
8414	echo
8415	echo "*** However, this would only work if libtool was able to extract symbol"
8416	echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
8417	echo "*** not find such a program. So, this module is probably useless."
8418	echo "*** 'nm' from GNU binutils and a full rebuild may help."
8419	fi
8420	if test no = "$build_old_libs"; then
8421	build_libtool_libs=module
8422	build_old_libs=yes
8423	else
8424	build_libtool_libs=no
8425	fi
8426	fi
8427	else
8428	deplibs="$dir/$old_library $deplibs"
8429	link_static=yes
8430	fi
8431	fi # link shared/static library?
8432
8433	if test lib = "$linkmode"; then
8434	if test -n "$dependency_libs" &&
8435	{ test yes != "$hardcode_into_libs" \|\|
8436	test yes = "$build_old_libs" \|\|
8437	test yes = "$link_static"; }; then
8438	# Extract -R from dependency_libs
8439	temp_deplibs=
8440	for libdir in $dependency_libs; do
8441	case $libdir in
8442	-R*) func_stripname '-R' '' "$libdir"
8443	temp_xrpath=$func_stripname_result
8444	case " $xrpath " in
8445	" $temp_xrpath ") ;;
8446	*) func_append xrpath " $temp_xrpath";;
8447	esac;;
8448	*) func_append temp_deplibs " $libdir";;
8449	esac
8450	done
8451	dependency_libs=$temp_deplibs
8452	fi
8453
8454	func_append newlib_search_path " $absdir"
8455	# Link against this library
8456	test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
8457	# ... and its dependency_libs
8458	tmp_libs=
8459	for deplib in $dependency_libs; do
8460	newdependency_libs="$deplib $newdependency_libs"
8461	case $deplib in
8462	-L*) func_stripname '-L' '' "$deplib"
8463	func_resolve_sysroot "$func_stripname_result";;
8464	*) func_resolve_sysroot "$deplib" ;;
8465	esac
8466	if $opt_preserve_dup_deps; then
8467	case "$tmp_libs " in
8468	" $func_resolve_sysroot_result ")
8469	func_append specialdeplibs " $func_resolve_sysroot_result" ;;
8470	esac
8471	fi
8472	func_append tmp_libs " $func_resolve_sysroot_result"
8473	done
8474
8475	if test no != "$link_all_deplibs"; then
8476	# Add the search paths of all dependency libraries
8477	for deplib in $dependency_libs; do
8478	path=
8479	case $deplib in
8480	-L*) path=$deplib ;;
8481	*.la)
8482	func_resolve_sysroot "$deplib"
8483	deplib=$func_resolve_sysroot_result
8484	func_dirname "$deplib" "" "."
8485	dir=$func_dirname_result
8486	# We need an absolute path.
8487	case $dir in
8488	[\\/]* \| [A-Za-z]:[\\/]*) absdir=$dir ;;
8489	*)
8490	absdir=`cd "$dir" && pwd`
8491	if test -z "$absdir"; then
8492	func_warning "cannot determine absolute directory name of '$dir'"
8493	absdir=$dir
8494	fi
8495	;;
8496	esac
8497	if $GREP "^installed=no" $deplib > /dev/null; then
8498	case $host in
8499	--darwin*)
8500	depdepl=
8501	eval deplibrary_names=`$SED -n -e 's/^library_names=$.*$$/\1/p' $deplib`
8502	if test -n "$deplibrary_names"; then
8503	for tmp in $deplibrary_names; do
8504	depdepl=$tmp
8505	done
8506	if test -f "$absdir/$objdir/$depdepl"; then
8507	depdepl=$absdir/$objdir/$depdepl
8508	darwin_install_name=`$OTOOL -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
8509	if test -z "$darwin_install_name"; then
8510	darwin_install_name=`$OTOOL64 -L $depdepl \| awk '{if (NR == 2) {print $1;exit}}'`
8511	fi
8512	func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
8513	func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
8514	path=
8515	fi
8516	fi
8517	;;
8518	*)
8519	path=-L$absdir/$objdir
8520	;;
8521	esac
8522	else
8523	eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $deplib`
8524	test -z "$libdir" && \
8525	func_fatal_error "'$deplib' is not a valid libtool archive"
8526	test "$absdir" != "$libdir" && \
8527	func_warning "'$deplib' seems to be moved"
8528
8529	path=-L$absdir
8530	fi
8531	;;
8532	esac
8533	case " $deplibs " in
8534	" $path ") ;;
8535	*) deplibs="$path $deplibs" ;;
8536	esac
8537	done
8538	fi # link_all_deplibs != no
8539	fi # linkmode = lib
8540	done # for deplib in $libs
8541	if test link = "$pass"; then
8542	if test prog = "$linkmode"; then
8543	compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
8544	finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
8545	else
8546	compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
8547	fi
8548	fi
8549	dependency_libs=$newdependency_libs
8550	if test dlpreopen = "$pass"; then
8551	# Link the dlpreopened libraries before other libraries
8552	for deplib in $save_deplibs; do
8553	deplibs="$deplib $deplibs"
8554	done
8555	fi
8556	if test dlopen != "$pass"; then
8557	test conv = "$pass" \|\| {
8558	# Make sure lib_search_path contains only unique directories.
8559	lib_search_path=
8560	for dir in $newlib_search_path; do
8561	case "$lib_search_path " in
8562	" $dir ") ;;
8563	*) func_append lib_search_path " $dir" ;;
8564	esac
8565	done
8566	newlib_search_path=
8567	}
8568
8569	if test prog,link = "$linkmode,$pass"; then
8570	vars="compile_deplibs finalize_deplibs"
8571	else
8572	vars=deplibs
8573	fi
8574	for var in $vars dependency_libs; do
8575	# Add libraries to $var in reverse order
8576	eval tmp_libs=\"\$$var\"
8577	new_libs=
8578	for deplib in $tmp_libs; do
8579	# FIXME: Pedantically, this is the right thing to do, so
8580	# that some nasty dependency loop isn't accidentally
8581	# broken:
8582	#new_libs="$deplib $new_libs"
8583	# Pragmatically, this seems to cause very few problems in
8584	# practice:
8585	case $deplib in
8586	-L*) new_libs="$deplib $new_libs" ;;
8587	-R*) ;;
8588	*)
8589	# And here is the reason: when a library appears more
8590	# than once as an explicit dependence of a library, or
8591	# is implicitly linked in more than once by the
8592	# compiler, it is considered special, and multiple
8593	# occurrences thereof are not removed. Compare this
8594	# with having the same library being listed as a
8595	# dependency of multiple other libraries: in this case,
8596	# we know (pedantically, we assume) the library does not
8597	# need to be listed more than once, so we keep only the
8598	# last copy. This is not always right, but it is rare
8599	# enough that we require users that really mean to play
8600	# such unportable linking tricks to link the library
8601	# using -Wl,-lname, so that libtool does not consider it
8602	# for duplicate removal.
8603	case " $specialdeplibs " in
8604	" $deplib ") new_libs="$deplib $new_libs" ;;
8605	*)
8606	case " $new_libs " in
8607	" $deplib ") ;;
8608	*) new_libs="$deplib $new_libs" ;;
8609	esac
8610	;;
8611	esac
8612	;;
8613	esac
8614	done
8615	tmp_libs=
8616	for deplib in $new_libs; do
8617	case $deplib in
8618	-L*)
8619	case " $tmp_libs " in
8620	" $deplib ") ;;
8621	*) func_append tmp_libs " $deplib" ;;
8622	esac
8623	;;
8624	*) func_append tmp_libs " $deplib" ;;
8625	esac
8626	done
8627	eval $var=\"$tmp_libs\"
8628	done # for var
8629	fi
8630
8631	# Add Sun CC postdeps if required:
8632	test CXX = "$tagname" && {
8633	case $host_os in
8634	linux*)
8635	case `$CC -V 2>&1 \| sed 5q` in
8636	Sun\ C) # Sun C++ 5.9
8637	func_suncc_cstd_abi
8638
8639	if test no != "$suncc_use_cstd_abi"; then
8640	func_append postdeps ' -library=Cstd -library=Crun'
8641	fi
8642	;;
8643	esac
8644	;;
8645
8646	solaris*)
8647	func_cc_basename "$CC"
8648	case $func_cc_basename_result in
8649	CC* \| sunCC*)
8650	func_suncc_cstd_abi
8651
8652	if test no != "$suncc_use_cstd_abi"; then
8653	func_append postdeps ' -library=Cstd -library=Crun'
8654	fi
8655	;;
8656	esac
8657	;;
8658	esac
8659	}
8660
8661	# Last step: remove runtime libs from dependency_libs
8662	# (they stay in deplibs)
8663	tmp_libs=
8664	for i in $dependency_libs; do
8665	case " $predeps $postdeps $compiler_lib_search_path " in
8666	" $i ")
8667	i=
8668	;;
8669	esac
8670	if test -n "$i"; then
8671	func_append tmp_libs " $i"
8672	fi
8673	done
8674	dependency_libs=$tmp_libs
8675	done # for pass
8676	if test prog = "$linkmode"; then
8677	dlfiles=$newdlfiles
8678	fi
8679	if test prog = "$linkmode" \|\| test lib = "$linkmode"; then
8680	dlprefiles=$newdlprefiles
8681	fi
8682
8683	case $linkmode in
8684	oldlib)
8685	if test -n "$dlfiles$dlprefiles" \|\| test no != "$dlself"; then
8686	func_warning "'-dlopen' is ignored for archives"
8687	fi
8688
8689	case " $deplibs" in
8690	\ -l \| \ -L)
8691	func_warning "'-l' and '-L' are ignored for archives" ;;
8692	esac
8693
8694	test -n "$rpath" && \
8695	func_warning "'-rpath' is ignored for archives"
8696
8697	test -n "$xrpath" && \
8698	func_warning "'-R' is ignored for archives"
8699
8700	test -n "$vinfo" && \
8701	func_warning "'-version-info/-version-number' is ignored for archives"
8702
8703	test -n "$release" && \
8704	func_warning "'-release' is ignored for archives"
8705
8706	test -n "$export_symbols$export_symbols_regex" && \
8707	func_warning "'-export-symbols' is ignored for archives"
8708
8709	# Now set the variables for building old libraries.
8710	build_libtool_libs=no
8711	oldlibs=$output
8712	func_append objs "$old_deplibs"
8713	;;
8714
8715	lib)
8716	# Make sure we only generate libraries of the form 'libNAME.la'.
8717	case $outputname in
8718	lib*)
8719	func_stripname 'lib' '.la' "$outputname"
8720	name=$func_stripname_result
8721	eval shared_ext=\"$shrext_cmds\"
8722	eval libname=\"$libname_spec\"
8723	;;
8724	*)
8725	test no = "$module" \
8726	&& func_fatal_help "libtool library '$output' must begin with 'lib'"
8727
8728	if test no != "$need_lib_prefix"; then
8729	# Add the "lib" prefix for modules if required
8730	func_stripname '' '.la' "$outputname"
8731	name=$func_stripname_result
8732	eval shared_ext=\"$shrext_cmds\"
8733	eval libname=\"$libname_spec\"
8734	else
8735	func_stripname '' '.la' "$outputname"
8736	libname=$func_stripname_result
8737	fi
8738	;;
8739	esac
8740
8741	if test -n "$objs"; then
8742	if test pass_all != "$deplibs_check_method"; then
8743	func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
8744	else
8745	echo
8746	$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
8747	$ECHO "*** objects $objs is not portable!"
8748	func_append libobjs " $objs"
8749	fi
8750	fi
8751
8752	test no = "$dlself" \
8753	\|\| func_warning "'-dlopen self' is ignored for libtool libraries"
8754
8755	set dummy $rpath
8756	shift
8757	test 1 -lt "$#" \
8758	&& func_warning "ignoring multiple '-rpath's for a libtool library"
8759
8760	install_libdir=$1
8761
8762	oldlibs=
8763	if test -z "$rpath"; then
8764	if test yes = "$build_libtool_libs"; then
8765	# Building a libtool convenience library.
8766	# Some compilers have problems with a '.al' extension so
8767	# convenience libraries should have the same extension an
8768	# archive normally would.
8769	oldlibs="$output_objdir/$libname.$libext $oldlibs"
8770	build_libtool_libs=convenience
8771	build_old_libs=yes
8772	fi
8773
8774	test -n "$vinfo" && \
8775	func_warning "'-version-info/-version-number' is ignored for convenience libraries"
8776
8777	test -n "$release" && \
8778	func_warning "'-release' is ignored for convenience libraries"
8779	else
8780
8781	# Parse the version information argument.
8782	save_ifs=$IFS; IFS=:
8783	set dummy $vinfo 0 0 0
8784	shift
8785	IFS=$save_ifs
8786
8787	test -n "$7" && \
8788	func_fatal_help "too many parameters to '-version-info'"
8789
8790	# convert absolute version numbers to libtool ages
8791	# this retains compatibility with .la files and attempts
8792	# to make the code below a bit more comprehensible
8793
8794	case $vinfo_number in
8795	yes)
8796	number_major=$1
8797	number_minor=$2
8798	number_revision=$3
8799	#
8800	# There are really only two kinds -- those that
8801	# use the current revision as the major version
8802	# and those that subtract age and use age as
8803	# a minor version. But, then there is irix
8804	# that has an extra 1 added just for fun
8805	#
8806	case $version_type in
8807	# correct linux to gnu/linux during the next big refactor
8808	darwin\|freebsd-elf\|linux\|osf\|windows\|none)
8809	func_arith $number_major + $number_minor
8810	current=$func_arith_result
8811	age=$number_minor
8812	revision=$number_revision
8813	;;
8814	freebsd-aout\|qnx\|sunos)
8815	current=$number_major
8816	revision=$number_minor
8817	age=0
8818	;;
8819	irix\|nonstopux)
8820	func_arith $number_major + $number_minor
8821	current=$func_arith_result
8822	age=$number_minor
8823	revision=$number_minor
8824	lt_irix_increment=no
8825	;;
8826	esac
8827	;;
8828	no)
8829	current=$1
8830	revision=$2
8831	age=$3
8832	;;
8833	esac
8834
8835	# Check that each of the things are valid numbers.
8836	case $current in
8837	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]) ;;
8838	*)
8839	func_error "CURRENT '$current' must be a nonnegative integer"
8840	func_fatal_error "'$vinfo' is not valid version information"
8841	;;
8842	esac
8843
8844	case $revision in
8845	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]) ;;
8846	*)
8847	func_error "REVISION '$revision' must be a nonnegative integer"
8848	func_fatal_error "'$vinfo' is not valid version information"
8849	;;
8850	esac
8851
8852	case $age in
8853	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]) ;;
8854	*)
8855	func_error "AGE '$age' must be a nonnegative integer"
8856	func_fatal_error "'$vinfo' is not valid version information"
8857	;;
8858	esac
8859
8860	if test "$age" -gt "$current"; then
8861	func_error "AGE '$age' is greater than the current interface number '$current'"
8862	func_fatal_error "'$vinfo' is not valid version information"
8863	fi
8864
8865	# Calculate the version variables.
8866	major=
8867	versuffix=
8868	verstring=
8869	case $version_type in
8870	none) ;;
8871
8872	darwin)
8873	# Like Linux, but with the current version available in
8874	# verstring for coding it into the library header
8875	func_arith $current - $age
8876	major=.$func_arith_result
8877	versuffix=$major.$age.$revision
8878	# Darwin ld doesn't like 0 for these options...
8879	func_arith $current + 1
8880	minor_current=$func_arith_result
8881	xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
8882	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
8883	# On Darwin other compilers
8884	case $CC in
8885	nagfor*)
8886	verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
8887	;;
8888	*)
8889	verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
8890	;;
8891	esac
8892	;;
8893
8894	freebsd-aout)
8895	major=.$current
8896	versuffix=.$current.$revision
8897	;;
8898
8899	freebsd-elf)
8900	func_arith $current - $age
8901	major=.$func_arith_result
8902	versuffix=$major.$age.$revision
8903	;;
8904
8905	irix \| nonstopux)
8906	if test no = "$lt_irix_increment"; then
8907	func_arith $current - $age
8908	else
8909	func_arith $current - $age + 1
8910	fi
8911	major=$func_arith_result
8912
8913	case $version_type in
8914	nonstopux) verstring_prefix=nonstopux ;;
8915	*) verstring_prefix=sgi ;;
8916	esac
8917	verstring=$verstring_prefix$major.$revision
8918
8919	# Add in all the interfaces that we are compatible with.
8920	loop=$revision
8921	while test 0 -ne "$loop"; do
8922	func_arith $revision - $loop
8923	iface=$func_arith_result
8924	func_arith $loop - 1
8925	loop=$func_arith_result
8926	verstring=$verstring_prefix$major.$iface:$verstring
8927	done
8928
8929	# Before this point, $major must not contain '.'.
8930	major=.$major
8931	versuffix=$major.$revision
8932	;;
8933
8934	linux) # correct to gnu/linux during the next big refactor
8935	func_arith $current - $age
8936	major=.$func_arith_result
8937	versuffix=$major.$age.$revision
8938	;;
8939
8940	osf)
8941	func_arith $current - $age
8942	major=.$func_arith_result
8943	versuffix=.$current.$age.$revision
8944	verstring=$current.$age.$revision
8945
8946	# Add in all the interfaces that we are compatible with.
8947	loop=$age
8948	while test 0 -ne "$loop"; do
8949	func_arith $current - $loop
8950	iface=$func_arith_result
8951	func_arith $loop - 1
8952	loop=$func_arith_result
8953	verstring=$verstring:$iface.0
8954	done
8955
8956	# Make executables depend on our current version.
8957	func_append verstring ":$current.0"
8958	;;
8959
8960	qnx)
8961	major=.$current
8962	versuffix=.$current
8963	;;
8964
8965	sco)
8966	major=.$current
8967	versuffix=.$current
8968	;;
8969
8970	sunos)
8971	major=.$current
8972	versuffix=.$current.$revision
8973	;;
8974
8975	windows)
8976	# Use '-' rather than '.', since we only want one
8977	# extension on DOS 8.3 file systems.
8978	func_arith $current - $age
8979	major=$func_arith_result
8980	versuffix=-$major
8981	;;
8982
8983	*)
8984	func_fatal_configuration "unknown library version type '$version_type'"
8985	;;
8986	esac
8987
8988	# Clear the version info if we defaulted, and they specified a release.
8989	if test -z "$vinfo" && test -n "$release"; then
8990	major=
8991	case $version_type in
8992	darwin)
8993	# we can't check for "0.0" in archive_cmds due to quoting
8994	# problems, so we reset it completely
8995	verstring=
8996	;;
8997	*)
8998	verstring=0.0
8999	;;
9000	esac
9001	if test no = "$need_version"; then
9002	versuffix=
9003	else
9004	versuffix=.0.0
9005	fi
9006	fi
9007
9008	# Remove version info from name if versioning should be avoided
9009	if test yes,no = "$avoid_version,$need_version"; then
9010	major=
9011	versuffix=
9012	verstring=
9013	fi
9014
9015	# Check to see if the archive will have undefined symbols.
9016	if test yes = "$allow_undefined"; then
9017	if test unsupported = "$allow_undefined_flag"; then
9018	if test yes = "$build_old_libs"; then
9019	func_warning "undefined symbols not allowed in $host shared libraries; building static only"
9020	build_libtool_libs=no
9021	else
9022	func_fatal_error "can't build $host shared library unless -no-undefined is specified"
9023	fi
9024	fi
9025	else
9026	# Don't allow undefined symbols.
9027	allow_undefined_flag=$no_undefined_flag
9028	fi
9029
9030	fi
9031
9032	func_generate_dlsyms "$libname" "$libname" :
9033	func_append libobjs " $symfileobj"
9034	test " " = "$libobjs" && libobjs=
9035
9036	if test relink != "$opt_mode"; then
9037	# Remove our outputs, but don't remove object files since they
9038	# may have been created when compiling PIC objects.
9039	removelist=
9040	tempremovelist=`$ECHO "$output_objdir/*"`
9041	for p in $tempremovelist; do
9042	case $p in
9043	.$objext \| .gcno)
9044	;;
9045	$output_objdir/$outputname \| $output_objdir/$libname.* \| $output_objdir/$libname$release.*)
9046	if test -n "$precious_files_regex"; then
9047	if $ECHO "$p" \| $EGREP -e "$precious_files_regex" >/dev/null 2>&1
9048	then
9049	continue
9050	fi
9051	fi
9052	func_append removelist " $p"
9053	;;
9054	*) ;;
9055	esac
9056	done
9057	test -n "$removelist" && \
9058	func_show_eval "${RM}r \$removelist"
9059	fi
9060
9061	# Now set the variables for building old libraries.
9062	if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
9063	func_append oldlibs " $output_objdir/$libname.$libext"
9064
9065	# Transform .lo files to .o files.
9066	oldobjs="$objs "`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.$libext$/d; $lo2o" \| $NL2SP`
9067	fi
9068
9069	# Eliminate all temporary directories.
9070	#for path in $notinst_path; do
9071	# lib_search_path=`$ECHO "$lib_search_path " \| $SED "s% $path % %g"`
9072	# deplibs=`$ECHO "$deplibs " \| $SED "s% -L$path % %g"`
9073	# dependency_libs=`$ECHO "$dependency_libs " \| $SED "s% -L$path % %g"`
9074	#done
9075
9076	if test -n "$xrpath"; then
9077	# If the user specified any rpath flags, then add them.
9078	temp_xrpath=
9079	for libdir in $xrpath; do
9080	func_replace_sysroot "$libdir"
9081	func_append temp_xrpath " -R$func_replace_sysroot_result"
9082	case "$finalize_rpath " in
9083	" $libdir ") ;;
9084	*) func_append finalize_rpath " $libdir" ;;
9085	esac
9086	done
9087	if test yes != "$hardcode_into_libs" \|\| test yes = "$build_old_libs"; then
9088	dependency_libs="$temp_xrpath $dependency_libs"
9089	fi
9090	fi
9091
9092	# Make sure dlfiles contains only unique files that won't be dlpreopened
9093	old_dlfiles=$dlfiles
9094	dlfiles=
9095	for lib in $old_dlfiles; do
9096	case " $dlprefiles $dlfiles " in
9097	" $lib ") ;;
9098	*) func_append dlfiles " $lib" ;;
9099	esac
9100	done
9101
9102	# Make sure dlprefiles contains only unique files
9103	old_dlprefiles=$dlprefiles
9104	dlprefiles=
9105	for lib in $old_dlprefiles; do
9106	case "$dlprefiles " in
9107	" $lib ") ;;
9108	*) func_append dlprefiles " $lib" ;;
9109	esac
9110	done
9111
9112	if test yes = "$build_libtool_libs"; then
9113	if test -n "$rpath"; then
9114	case $host in
9115	--cygwin* \| --mingw* \| --pw32* \| --os2* \| --beos* \| -cegcc \| --haiku*)
9116	# these systems don't actually have a c library (as such)!
9117	;;
9118	--rhapsody* \| --darwin1.[012])
9119	# Rhapsody C library is in the System framework
9120	func_append deplibs " System.ltframework"
9121	;;
9122	--netbsd*)
9123	# Don't link with libc until the a.out ld.so is fixed.
9124	;;
9125	--openbsd* \| --freebsd* \| --dragonfly*)
9126	# Do not include libc due to us having libc/libc_r.
9127	;;
9128	--sco3.2v5* \| --sco5v6*)
9129	# Causes problems with __ctype
9130	;;
9131	--sysv4.2uw2* \| --sysv5* \| --unixware* \| --OpenUNIX*)
9132	# Compiler inserts libc in the correct place for threads to work
9133	;;
9134	*)
9135	# Add libc to deplibs on all other systems if necessary.
9136	if test yes = "$build_libtool_need_lc"; then
9137	func_append deplibs " -lc"
9138	fi
9139	;;
9140	esac
9141	fi
9142
9143	# Transform deplibs into only deplibs that can be linked in shared.
9144	name_save=$name
9145	libname_save=$libname
9146	release_save=$release
9147	versuffix_save=$versuffix
9148	major_save=$major
9149	# I'm not sure if I'm treating the release correctly. I think
9150	# release should show up in the -l (ie -lgmp5) so we don't want to
9151	# add it in twice. Is that correct?
9152	release=
9153	versuffix=
9154	major=
9155	newdeplibs=
9156	droppeddeps=no
9157	case $deplibs_check_method in
9158	pass_all)
9159	# Don't check for shared/static. Everything works.
9160	# This might be a little naive. We might want to check
9161	# whether the library exists or not. But this is on
9162	# osf3 & osf4 and I'm not really sure... Just
9163	# implementing what was already the behavior.
9164	newdeplibs=$deplibs
9165	;;
9166	test_compile)
9167	# This code stresses the "libraries are programs" paradigm to its
9168	# limits. Maybe even breaks it. We compile a program, linking it
9169	# against the deplibs as a proxy for the library. Then we can check
9170	# whether they linked in statically or dynamically with ldd.
9171	$opt_dry_run \|\| $RM conftest.c
9172	cat > conftest.c <<EOF
9173	int main() { return 0; }
9174	EOF
9175	$opt_dry_run \|\| $RM conftest
9176	if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
9177	ldd_output=`ldd conftest`
9178	for i in $deplibs; do
9179	case $i in
9180	-l*)
9181	func_stripname -l '' "$i"
9182	name=$func_stripname_result
9183	if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9184	case " $predeps $postdeps " in
9185	" $i ")
9186	func_append newdeplibs " $i"
9187	i=
9188	;;
9189	esac
9190	fi
9191	if test -n "$i"; then
9192	libname=`eval "\\$ECHO \"$libname_spec\""`
9193	deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
9194	set dummy $deplib_matches; shift
9195	deplib_match=$1
9196	if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
9197	func_append newdeplibs " $i"
9198	else
9199	droppeddeps=yes
9200	echo
9201	$ECHO "*** Warning: dynamic linker does not accept needed library $i."
9202	echo "*** I have the capability to make that library automatically link in when"
9203	echo "*** you link to this library. But I can only do this if you have a"
9204	echo "*** shared version of the library, which I believe you do not have"
9205	echo "*** because a test_compile did reveal that the linker did not use it for"
9206	echo "*** its dynamic dependency list that programs get resolved with at runtime."
9207	fi
9208	fi
9209	;;
9210	*)
9211	func_append newdeplibs " $i"
9212	;;
9213	esac
9214	done
9215	else
9216	# Error occurred in the first compile. Let's try to salvage
9217	# the situation: Compile a separate program for each library.
9218	for i in $deplibs; do
9219	case $i in
9220	-l*)
9221	func_stripname -l '' "$i"
9222	name=$func_stripname_result
9223	$opt_dry_run \|\| $RM conftest
9224	if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
9225	ldd_output=`ldd conftest`
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 you do not appear to have"
9248	echo "*** because a test_compile did reveal that the linker did not use this one"
9249	echo "*** as a dynamic dependency that programs can get resolved with at runtime."
9250	fi
9251	fi
9252	else
9253	droppeddeps=yes
9254	echo
9255	$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
9256	echo "*** make it link in! You will probably need to install it or some"
9257	echo "*** library that it depends on before this library will be fully"
9258	echo "*** functional. Installing it before continuing would be even better."
9259	fi
9260	;;
9261	*)
9262	func_append newdeplibs " $i"
9263	;;
9264	esac
9265	done
9266	fi
9267	;;
9268	file_magic*)
9269	set dummy $deplibs_check_method; shift
9270	file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
9271	for a_deplib in $deplibs; do
9272	case $a_deplib in
9273	-l*)
9274	func_stripname -l '' "$a_deplib"
9275	name=$func_stripname_result
9276	if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9277	case " $predeps $postdeps " in
9278	" $a_deplib ")
9279	func_append newdeplibs " $a_deplib"
9280	a_deplib=
9281	;;
9282	esac
9283	fi
9284	if test -n "$a_deplib"; then
9285	libname=`eval "\\$ECHO \"$libname_spec\""`
9286	if test -n "$file_magic_glob"; then
9287	libnameglob=`func_echo_all "$libname" \| $SED -e $file_magic_glob`
9288	else
9289	libnameglob=$libname
9290	fi
9291	test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
9292	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9293	if test yes = "$want_nocaseglob"; then
9294	shopt -s nocaseglob
9295	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9296	$nocaseglob
9297	else
9298	potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9299	fi
9300	for potent_lib in $potential_libs; do
9301	# Follow soft links.
9302	if ls -lLd "$potent_lib" 2>/dev/null \|
9303	$GREP " -> " >/dev/null; then
9304	continue
9305	fi
9306	# The statement above tries to avoid entering an
9307	# endless loop below, in case of cyclic links.
9308	# We might still enter an endless loop, since a link
9309	# loop can be closed while we follow links,
9310	# but so what?
9311	potlib=$potent_lib
9312	while test -h "$potlib" 2>/dev/null; do
9313	potliblink=`ls -ld $potlib \| $SED 's/.* -> //'`
9314	case $potliblink in
9315	[\\/]* \| [A-Za-z]:[\\/]*) potlib=$potliblink;;
9316	) potlib=`$ECHO "$potlib" \| $SED 's\|[^/]$\|\|'`"$potliblink";;
9317	esac
9318	done
9319	if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \|
9320	$SED -e 10q \|
9321	$EGREP "$file_magic_regex" > /dev/null; then
9322	func_append newdeplibs " $a_deplib"
9323	a_deplib=
9324	break 2
9325	fi
9326	done
9327	done
9328	fi
9329	if test -n "$a_deplib"; then
9330	droppeddeps=yes
9331	echo
9332	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9333	echo "*** I have the capability to make that library automatically link in when"
9334	echo "*** you link to this library. But I can only do this if you have a"
9335	echo "*** shared version of the library, which you do not appear to have"
9336	echo "*** because I did check the linker path looking for a file starting"
9337	if test -z "$potlib"; then
9338	$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
9339	else
9340	$ECHO "*** with $libname and none of the candidates passed a file format test"
9341	$ECHO "*** using a file magic. Last file checked: $potlib"
9342	fi
9343	fi
9344	;;
9345	*)
9346	# Add a -L argument.
9347	func_append newdeplibs " $a_deplib"
9348	;;
9349	esac
9350	done # Gone through all deplibs.
9351	;;
9352	match_pattern*)
9353	set dummy $deplibs_check_method; shift
9354	match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
9355	for a_deplib in $deplibs; do
9356	case $a_deplib in
9357	-l*)
9358	func_stripname -l '' "$a_deplib"
9359	name=$func_stripname_result
9360	if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9361	case " $predeps $postdeps " in
9362	" $a_deplib ")
9363	func_append newdeplibs " $a_deplib"
9364	a_deplib=
9365	;;
9366	esac
9367	fi
9368	if test -n "$a_deplib"; then
9369	libname=`eval "\\$ECHO \"$libname_spec\""`
9370	for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9371	potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
9372	for potent_lib in $potential_libs; do
9373	potlib=$potent_lib # see symlink-check above in file_magic test
9374	if eval "\$ECHO \"$potent_lib\"" 2>/dev/null \| $SED 10q \| \
9375	$EGREP "$match_pattern_regex" > /dev/null; then
9376	func_append newdeplibs " $a_deplib"
9377	a_deplib=
9378	break 2
9379	fi
9380	done
9381	done
9382	fi
9383	if test -n "$a_deplib"; then
9384	droppeddeps=yes
9385	echo
9386	$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9387	echo "*** I have the capability to make that library automatically link in when"
9388	echo "*** you link to this library. But I can only do this if you have a"
9389	echo "*** shared version of the library, which you do not appear to have"
9390	echo "*** because I did check the linker path looking for a file starting"
9391	if test -z "$potlib"; then
9392	$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
9393	else
9394	$ECHO "*** with $libname and none of the candidates passed a file format test"
9395	$ECHO "*** using a regex pattern. Last file checked: $potlib"
9396	fi
9397	fi
9398	;;
9399	*)
9400	# Add a -L argument.
9401	func_append newdeplibs " $a_deplib"
9402	;;
9403	esac
9404	done # Gone through all deplibs.
9405	;;
9406	none \| unknown \| *)
9407	newdeplibs=
9408	tmp_deplibs=`$ECHO " $deplibs" \| $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
9409	if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9410	for i in $predeps $postdeps; do
9411	# can't use Xsed below, because $i might contain '/'
9412	tmp_deplibs=`$ECHO " $tmp_deplibs" \| $SED "s\|$i\|\|"`
9413	done
9414	fi
9415	case $tmp_deplibs in
9416	[!\ \ ])
9417	echo
9418	if test none = "$deplibs_check_method"; then
9419	echo "*** Warning: inter-library dependencies are not supported in this platform."
9420	else
9421	echo "*** Warning: inter-library dependencies are not known to be supported."
9422	fi
9423	echo "*** All declared inter-library dependencies are being dropped."
9424	droppeddeps=yes
9425	;;
9426	esac
9427	;;
9428	esac
9429	versuffix=$versuffix_save
9430	major=$major_save
9431	release=$release_save
9432	libname=$libname_save
9433	name=$name_save
9434
9435	case $host in
9436	--rhapsody* \| --darwin1.[012])
9437	# On Rhapsody replace the C library with the System framework
9438	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's/ -lc / System.ltframework /'`
9439	;;
9440	esac
9441
9442	if test yes = "$droppeddeps"; then
9443	if test yes = "$module"; then
9444	echo
9445	echo "*** Warning: libtool could not satisfy all declared inter-library"
9446	$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
9447	echo "*** a static module, that should work as long as the dlopening"
9448	echo "*** application is linked with the -dlopen flag."
9449	if test -z "$global_symbol_pipe"; then
9450	echo
9451	echo "*** However, this would only work if libtool was able to extract symbol"
9452	echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
9453	echo "*** not find such a program. So, this module is probably useless."
9454	echo "*** 'nm' from GNU binutils and a full rebuild may help."
9455	fi
9456	if test no = "$build_old_libs"; then
9457	oldlibs=$output_objdir/$libname.$libext
9458	build_libtool_libs=module
9459	build_old_libs=yes
9460	else
9461	build_libtool_libs=no
9462	fi
9463	else
9464	echo "*** The inter-library dependencies that have been dropped here will be"
9465	echo "*** automatically added whenever a program is linked with this library"
9466	echo "*** or is declared to -dlopen it."
9467
9468	if test no = "$allow_undefined"; then
9469	echo
9470	echo "*** Since this library must not contain undefined symbols,"
9471	echo "*** because either the platform does not support them or"
9472	echo "*** it was explicitly requested with -no-undefined,"
9473	echo "*** libtool will only create a static version of it."
9474	if test no = "$build_old_libs"; then
9475	oldlibs=$output_objdir/$libname.$libext
9476	build_libtool_libs=module
9477	build_old_libs=yes
9478	else
9479	build_libtool_libs=no
9480	fi
9481	fi
9482	fi
9483	fi
9484	# Done checking deplibs!
9485	deplibs=$newdeplibs
9486	fi
9487	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
9488	case $host in
9489	--darwin*)
9490	newdeplibs=`$ECHO " $newdeplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
9491	new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
9492	deplibs=`$ECHO " $deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
9493	;;
9494	esac
9495
9496	# move library search paths that coincide with paths to not yet
9497	# installed libraries to the beginning of the library search list
9498	new_libs=
9499	for path in $notinst_path; do
9500	case " $new_libs " in
9501	" -L$path/$objdir ") ;;
9502	*)
9503	case " $deplibs " in
9504	" -L$path/$objdir ")
9505	func_append new_libs " -L$path/$objdir" ;;
9506	esac
9507	;;
9508	esac
9509	done
9510	for deplib in $deplibs; do
9511	case $deplib in
9512	-L*)
9513	case " $new_libs " in
9514	" $deplib ") ;;
9515	*) func_append new_libs " $deplib" ;;
9516	esac
9517	;;
9518	*) func_append new_libs " $deplib" ;;
9519	esac
9520	done
9521	deplibs=$new_libs
9522
9523	# All the library-specific variables (install_libdir is set above).
9524	library_names=
9525	old_library=
9526	dlname=
9527
9528	# Test again, we may have decided not to build it any more
9529	if test yes = "$build_libtool_libs"; then
9530	# Remove $wl instances when linking with ld.
9531	# FIXME: should test the right _cmds variable.
9532	case $archive_cmds in
9533	\$LD\ ) wl= ;;
9534	esac
9535	if test yes = "$hardcode_into_libs"; then
9536	# Hardcode the library paths
9537	hardcode_libdirs=
9538	dep_rpath=
9539	rpath=$finalize_rpath
9540	test relink = "$opt_mode" \|\| rpath=$compile_rpath$rpath
9541	for libdir in $rpath; do
9542	if test -n "$hardcode_libdir_flag_spec"; then
9543	if test -n "$hardcode_libdir_separator"; then
9544	func_replace_sysroot "$libdir"
9545	libdir=$func_replace_sysroot_result
9546	if test -z "$hardcode_libdirs"; then
9547	hardcode_libdirs=$libdir
9548	else
9549	# Just accumulate the unique libdirs.
9550	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
9551	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
9552	;;
9553	*)
9554	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
9555	;;
9556	esac
9557	fi
9558	else
9559	eval flag=\"$hardcode_libdir_flag_spec\"
9560	func_append dep_rpath " $flag"
9561	fi
9562	elif test -n "$runpath_var"; then
9563	case "$perm_rpath " in
9564	" $libdir ") ;;
9565	*) func_append perm_rpath " $libdir" ;;
9566	esac
9567	fi
9568	done
9569	# Substitute the hardcoded libdirs into the rpath.
9570	if test -n "$hardcode_libdir_separator" &&
9571	test -n "$hardcode_libdirs"; then
9572	libdir=$hardcode_libdirs
9573	eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
9574	fi
9575	if test -n "$runpath_var" && test -n "$perm_rpath"; then
9576	# We should set the runpath_var.
9577	rpath=
9578	for dir in $perm_rpath; do
9579	func_append rpath "$dir:"
9580	done
9581	eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
9582	fi
9583	test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
9584	fi
9585
9586	shlibpath=$finalize_shlibpath
9587	test relink = "$opt_mode" \|\| shlibpath=$compile_shlibpath$shlibpath
9588	if test -n "$shlibpath"; then
9589	eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
9590	fi
9591
9592	# Get the real and link names of the library.
9593	eval shared_ext=\"$shrext_cmds\"
9594	eval library_names=\"$library_names_spec\"
9595	set dummy $library_names
9596	shift
9597	realname=$1
9598	shift
9599
9600	if test -n "$soname_spec"; then
9601	eval soname=\"$soname_spec\"
9602	else
9603	soname=$realname
9604	fi
9605	if test -z "$dlname"; then
9606	dlname=$soname
9607	fi
9608
9609	lib=$output_objdir/$realname
9610	linknames=
9611	for link
9612	do
9613	func_append linknames " $link"
9614	done
9615
9616	# Use standard objects if they are pic
9617	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
9618	test "X$libobjs" = "X " && libobjs=
9619
9620	delfiles=
9621	if test -n "$export_symbols" && test -n "$include_expsyms"; then
9622	$opt_dry_run \|\| cp "$export_symbols" "$output_objdir/$libname.uexp"
9623	export_symbols=$output_objdir/$libname.uexp
9624	func_append delfiles " $export_symbols"
9625	fi
9626
9627	orig_export_symbols=
9628	case $host_os in
9629	cygwin* \| mingw* \| cegcc*)
9630	if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
9631	# exporting using user supplied symfile
9632	func_dll_def_p "$export_symbols" \|\| {
9633	# and it's NOT already a .def file. Must figure out
9634	# which of the given symbols are data symbols and tag
9635	# them as such. So, trigger use of export_symbols_cmds.
9636	# export_symbols gets reassigned inside the "prepare
9637	# the list of exported symbols" if statement, so the
9638	# include_expsyms logic still works.
9639	orig_export_symbols=$export_symbols
9640	export_symbols=
9641	always_export_symbols=yes
9642	}
9643	fi
9644	;;
9645	esac
9646
9647	# Prepare the list of exported symbols
9648	if test -z "$export_symbols"; then
9649	if test yes = "$always_export_symbols" \|\| test -n "$export_symbols_regex"; then
9650	func_verbose "generating symbol list for '$libname.la'"
9651	export_symbols=$output_objdir/$libname.exp
9652	$opt_dry_run \|\| $RM $export_symbols
9653	cmds=$export_symbols_cmds
9654	save_ifs=$IFS; IFS='~'
9655	for cmd1 in $cmds; do
9656	IFS=$save_ifs
9657	# Take the normal branch if the nm_file_list_spec branch
9658	# doesn't work or if tool conversion is not needed.
9659	case $nm_file_list_spec~$to_tool_file_cmd in
9660	~func_convert_file_noop \| ~func_convert_file_msys_to_w32 \| ~*)
9661	try_normal_branch=yes
9662	eval cmd=\"$cmd1\"
9663	func_len " $cmd"
9664	len=$func_len_result
9665	;;
9666	*)
9667	try_normal_branch=no
9668	;;
9669	esac
9670	if test yes = "$try_normal_branch" \
9671	&& { test "$len" -lt "$max_cmd_len" \
9672	\|\| test "$max_cmd_len" -le -1; }
9673	then
9674	func_show_eval "$cmd" 'exit $?'
9675	skipped_export=false
9676	elif test -n "$nm_file_list_spec"; then
9677	func_basename "$output"
9678	output_la=$func_basename_result
9679	save_libobjs=$libobjs
9680	save_output=$output
9681	output=$output_objdir/$output_la.nm
9682	func_to_tool_file "$output"
9683	libobjs=$nm_file_list_spec$func_to_tool_file_result
9684	func_append delfiles " $output"
9685	func_verbose "creating $NM input file list: $output"
9686	for obj in $save_libobjs; do
9687	func_to_tool_file "$obj"
9688	$ECHO "$func_to_tool_file_result"
9689	done > "$output"
9690	eval cmd=\"$cmd1\"
9691	func_show_eval "$cmd" 'exit $?'
9692	output=$save_output
9693	libobjs=$save_libobjs
9694	skipped_export=false
9695	else
9696	# The command line is too long to execute in one step.
9697	func_verbose "using reloadable object file for export list..."
9698	skipped_export=:
9699	# Break out early, otherwise skipped_export may be
9700	# set to false by a later but shorter cmd.
9701	break
9702	fi
9703	done
9704	IFS=$save_ifs
9705	if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
9706	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
9707	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
9708	fi
9709	fi
9710	fi
9711
9712	if test -n "$export_symbols" && test -n "$include_expsyms"; then
9713	tmp_export_symbols=$export_symbols
9714	test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
9715	$opt_dry_run \|\| eval '$ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"'
9716	fi
9717
9718	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
9719	# The given exports_symbols file has to be filtered, so filter it.
9720	func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
9721	# FIXME: $output_objdir/$libname.filter potentially contains lots of
9722	# 's' commands, which not all seds can handle. GNU sed should be fine
9723	# though. Also, the filter scales superlinearly with the number of
9724	# global variables. join(1) would be nice here, but unfortunately
9725	# isn't a blessed tool.
9726	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
9727	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
9728	export_symbols=$output_objdir/$libname.def
9729	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
9730	fi
9731
9732	tmp_deplibs=
9733	for test_deplib in $deplibs; do
9734	case " $convenience " in
9735	" $test_deplib ") ;;
9736	*)
9737	func_append tmp_deplibs " $test_deplib"
9738	;;
9739	esac
9740	done
9741	deplibs=$tmp_deplibs
9742
9743	if test -n "$convenience"; then
9744	if test -n "$whole_archive_flag_spec" &&
9745	test yes = "$compiler_needs_object" &&
9746	test -z "$libobjs"; then
9747	# extract the archives, so we have objects to list.
9748	# TODO: could optimize this to just extract one archive.
9749	whole_archive_flag_spec=
9750	fi
9751	if test -n "$whole_archive_flag_spec"; then
9752	save_libobjs=$libobjs
9753	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
9754	test "X$libobjs" = "X " && libobjs=
9755	else
9756	gentop=$output_objdir/${outputname}x
9757	func_append generated " $gentop"
9758
9759	func_extract_archives $gentop $convenience
9760	func_append libobjs " $func_extract_archives_result"
9761	test "X$libobjs" = "X " && libobjs=
9762	fi
9763	fi
9764
9765	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
9766	eval flag=\"$thread_safe_flag_spec\"
9767	func_append linker_flags " $flag"
9768	fi
9769
9770	# Make a backup of the uninstalled library when relinking
9771	if test relink = "$opt_mode"; then
9772	$opt_dry_run \|\| eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' \|\| exit $?
9773	fi
9774
9775	# Do each of the archive commands.
9776	if test yes = "$module" && test -n "$module_cmds"; then
9777	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
9778	eval test_cmds=\"$module_expsym_cmds\"
9779	cmds=$module_expsym_cmds
9780	else
9781	eval test_cmds=\"$module_cmds\"
9782	cmds=$module_cmds
9783	fi
9784	else
9785	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
9786	eval test_cmds=\"$archive_expsym_cmds\"
9787	cmds=$archive_expsym_cmds
9788	else
9789	eval test_cmds=\"$archive_cmds\"
9790	cmds=$archive_cmds
9791	fi
9792	fi
9793
9794	if test : != "$skipped_export" &&
9795	func_len " $test_cmds" &&
9796	len=$func_len_result &&
9797	test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
9798	:
9799	else
9800	# The command line is too long to link in one step, link piecewise
9801	# or, if using GNU ld and skipped_export is not :, use a linker
9802	# script.
9803
9804	# Save the value of $output and $libobjs because we want to
9805	# use them later. If we have whole_archive_flag_spec, we
9806	# want to use save_libobjs as it was before
9807	# whole_archive_flag_spec was expanded, because we can't
9808	# assume the linker understands whole_archive_flag_spec.
9809	# This may have to be revisited, in case too many
9810	# convenience libraries get linked in and end up exceeding
9811	# the spec.
9812	if test -z "$convenience" \|\| test -z "$whole_archive_flag_spec"; then
9813	save_libobjs=$libobjs
9814	fi
9815	save_output=$output
9816	func_basename "$output"
9817	output_la=$func_basename_result
9818
9819	# Clear the reloadable object creation command queue and
9820	# initialize k to one.
9821	test_cmds=
9822	concat_cmds=
9823	objlist=
9824	last_robj=
9825	k=1
9826
9827	if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
9828	output=$output_objdir/$output_la.lnkscript
9829	func_verbose "creating GNU ld script: $output"
9830	echo 'INPUT (' > $output
9831	for obj in $save_libobjs
9832	do
9833	func_to_tool_file "$obj"
9834	$ECHO "$func_to_tool_file_result" >> $output
9835	done
9836	echo ')' >> $output
9837	func_append delfiles " $output"
9838	func_to_tool_file "$output"
9839	output=$func_to_tool_file_result
9840	elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
9841	output=$output_objdir/$output_la.lnk
9842	func_verbose "creating linker input file list: $output"
9843	: > $output
9844	set x $save_libobjs
9845	shift
9846	firstobj=
9847	if test yes = "$compiler_needs_object"; then
9848	firstobj="$1 "
9849	shift
9850	fi
9851	for obj
9852	do
9853	func_to_tool_file "$obj"
9854	$ECHO "$func_to_tool_file_result" >> $output
9855	done
9856	func_append delfiles " $output"
9857	func_to_tool_file "$output"
9858	output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
9859	else
9860	if test -n "$save_libobjs"; then
9861	func_verbose "creating reloadable object files..."
9862	output=$output_objdir/$output_la-$k.$objext
9863	eval test_cmds=\"$reload_cmds\"
9864	func_len " $test_cmds"
9865	len0=$func_len_result
9866	len=$len0
9867
9868	# Loop over the list of objects to be linked.
9869	for obj in $save_libobjs
9870	do
9871	func_len " $obj"
9872	func_arith $len + $func_len_result
9873	len=$func_arith_result
9874	if test -z "$objlist" \|\|
9875	test "$len" -lt "$max_cmd_len"; then
9876	func_append objlist " $obj"
9877	else
9878	# The command $test_cmds is almost too long, add a
9879	# command to the queue.
9880	if test 1 -eq "$k"; then
9881	# The first file doesn't have a previous command to add.
9882	reload_objs=$objlist
9883	eval concat_cmds=\"$reload_cmds\"
9884	else
9885	# All subsequent reloadable object files will link in
9886	# the last one created.
9887	reload_objs="$objlist $last_robj"
9888	eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
9889	fi
9890	last_robj=$output_objdir/$output_la-$k.$objext
9891	func_arith $k + 1
9892	k=$func_arith_result
9893	output=$output_objdir/$output_la-$k.$objext
9894	objlist=" $obj"
9895	func_len " $last_robj"
9896	func_arith $len0 + $func_len_result
9897	len=$func_arith_result
9898	fi
9899	done
9900	# Handle the remaining objects by creating one last
9901	# reloadable object file. All subsequent reloadable object
9902	# files will link in the last one created.
9903	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
9904	reload_objs="$objlist $last_robj"
9905	eval concat_cmds=\"\$concat_cmds$reload_cmds\"
9906	if test -n "$last_robj"; then
9907	eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
9908	fi
9909	func_append delfiles " $output"
9910
9911	else
9912	output=
9913	fi
9914
9915	${skipped_export-false} && {
9916	func_verbose "generating symbol list for '$libname.la'"
9917	export_symbols=$output_objdir/$libname.exp
9918	$opt_dry_run \|\| $RM $export_symbols
9919	libobjs=$output
9920	# Append the command to create the export file.
9921	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
9922	eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
9923	if test -n "$last_robj"; then
9924	eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
9925	fi
9926	}
9927
9928	test -n "$save_libobjs" &&
9929	func_verbose "creating a temporary reloadable object file: $output"
9930
9931	# Loop through the commands generated above and execute them.
9932	save_ifs=$IFS; IFS='~'
9933	for cmd in $concat_cmds; do
9934	IFS=$save_ifs
9935	$opt_quiet \|\| {
9936	func_quote_for_expand "$cmd"
9937	eval "func_echo $func_quote_for_expand_result"
9938	}
9939	$opt_dry_run \|\| eval "$cmd" \|\| {
9940	lt_exit=$?
9941
9942	# Restore the uninstalled library and exit
9943	if test relink = "$opt_mode"; then
9944	( cd "$output_objdir" && \
9945	$RM "${realname}T" && \
9946	$MV "${realname}U" "$realname" )
9947	fi
9948
9949	exit $lt_exit
9950	}
9951	done
9952	IFS=$save_ifs
9953
9954	if test -n "$export_symbols_regex" && ${skipped_export-false}; then
9955	func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
9956	func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
9957	fi
9958	fi
9959
9960	${skipped_export-false} && {
9961	if test -n "$export_symbols" && test -n "$include_expsyms"; then
9962	tmp_export_symbols=$export_symbols
9963	test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
9964	$opt_dry_run \|\| eval '$ECHO "$include_expsyms" \| $SP2NL >> "$tmp_export_symbols"'
9965	fi
9966
9967	if test -n "$orig_export_symbols"; then
9968	# The given exports_symbols file has to be filtered, so filter it.
9969	func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
9970	# FIXME: $output_objdir/$libname.filter potentially contains lots of
9971	# 's' commands, which not all seds can handle. GNU sed should be fine
9972	# though. Also, the filter scales superlinearly with the number of
9973	# global variables. join(1) would be nice here, but unfortunately
9974	# isn't a blessed tool.
9975	$opt_dry_run \|\| $SED -e '/[ ,]DATA/!d;s,$.$$[ \,].$,s\|^\1$\|\1\2\|,' < $export_symbols > $output_objdir/$libname.filter
9976	func_append delfiles " $export_symbols $output_objdir/$libname.filter"
9977	export_symbols=$output_objdir/$libname.def
9978	$opt_dry_run \|\| $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
9979	fi
9980	}
9981
9982	libobjs=$output
9983	# Restore the value of output.
9984	output=$save_output
9985
9986	if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
9987	eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
9988	test "X$libobjs" = "X " && libobjs=
9989	fi
9990	# Expand the library linking commands again to reset the
9991	# value of $libobjs for piecewise linking.
9992
9993	# Do each of the archive commands.
9994	if test yes = "$module" && test -n "$module_cmds"; then
9995	if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
9996	cmds=$module_expsym_cmds
9997	else
9998	cmds=$module_cmds
9999	fi
10000	else
10001	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
10002	cmds=$archive_expsym_cmds
10003	else
10004	cmds=$archive_cmds
10005	fi
10006	fi
10007	fi
10008
10009	if test -n "$delfiles"; then
10010	# Append the command to remove temporary files to $cmds.
10011	eval cmds=\"\$cmds~\$RM $delfiles\"
10012	fi
10013
10014	# Add any objects from preloaded convenience libraries
10015	if test -n "$dlprefiles"; then
10016	gentop=$output_objdir/${outputname}x
10017	func_append generated " $gentop"
10018
10019	func_extract_archives $gentop $dlprefiles
10020	func_append libobjs " $func_extract_archives_result"
10021	test "X$libobjs" = "X " && libobjs=
10022	fi
10023
10024	save_ifs=$IFS; IFS='~'
10025	for cmd in $cmds; do
10026	IFS=$sp$nl
10027	eval cmd=\"$cmd\"
10028	IFS=$save_ifs
10029	$opt_quiet \|\| {
10030	func_quote_for_expand "$cmd"
10031	eval "func_echo $func_quote_for_expand_result"
10032	}
10033	$opt_dry_run \|\| eval "$cmd" \|\| {
10034	lt_exit=$?
10035
10036	# Restore the uninstalled library and exit
10037	if test relink = "$opt_mode"; then
10038	( cd "$output_objdir" && \
10039	$RM "${realname}T" && \
10040	$MV "${realname}U" "$realname" )
10041	fi
10042
10043	exit $lt_exit
10044	}
10045	done
10046	IFS=$save_ifs
10047
10048	# Restore the uninstalled library and exit
10049	if test relink = "$opt_mode"; then
10050	$opt_dry_run \|\| eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' \|\| exit $?
10051
10052	if test -n "$convenience"; then
10053	if test -z "$whole_archive_flag_spec"; then
10054	func_show_eval '${RM}r "$gentop"'
10055	fi
10056	fi
10057
10058	exit $EXIT_SUCCESS
10059	fi
10060
10061	# Create links to the real library.
10062	for linkname in $linknames; do
10063	if test "$realname" != "$linkname"; then
10064	func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
10065	fi
10066	done
10067
10068	# If -module or -export-dynamic was specified, set the dlname.
10069	if test yes = "$module" \|\| test yes = "$export_dynamic"; then
10070	# On all known operating systems, these are identical.
10071	dlname=$soname
10072	fi
10073	fi
10074	;;
10075
10076	obj)
10077	if test -n "$dlfiles$dlprefiles" \|\| test no != "$dlself"; then
10078	func_warning "'-dlopen' is ignored for objects"
10079	fi
10080
10081	case " $deplibs" in
10082	\ -l \| \ -L)
10083	func_warning "'-l' and '-L' are ignored for objects" ;;
10084	esac
10085
10086	test -n "$rpath" && \
10087	func_warning "'-rpath' is ignored for objects"
10088
10089	test -n "$xrpath" && \
10090	func_warning "'-R' is ignored for objects"
10091
10092	test -n "$vinfo" && \
10093	func_warning "'-version-info' is ignored for objects"
10094
10095	test -n "$release" && \
10096	func_warning "'-release' is ignored for objects"
10097
10098	case $output in
10099	*.lo)
10100	test -n "$objs$old_deplibs" && \
10101	func_fatal_error "cannot build library object '$output' from non-libtool objects"
10102
10103	libobj=$output
10104	func_lo2o "$libobj"
10105	obj=$func_lo2o_result
10106	;;
10107	*)
10108	libobj=
10109	obj=$output
10110	;;
10111	esac
10112
10113	# Delete the old objects.
10114	$opt_dry_run \|\| $RM $obj $libobj
10115
10116	# Objects from convenience libraries. This assumes
10117	# single-version convenience libraries. Whenever we create
10118	# different ones for PIC/non-PIC, this we'll have to duplicate
10119	# the extraction.
10120	reload_conv_objs=
10121	gentop=
10122	# if reload_cmds runs $LD directly, get rid of -Wl from
10123	# whole_archive_flag_spec and hope we can get by with turning comma
10124	# into space.
10125	case $reload_cmds in
10126	\$LD[\ \$]) wl= ;;
10127	esac
10128	if test -n "$convenience"; then
10129	if test -n "$whole_archive_flag_spec"; then
10130	eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
10131	test -n "$wl" \|\| tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" \| $SED 's\|,\| \|g'`
10132	reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
10133	else
10134	gentop=$output_objdir/${obj}x
10135	func_append generated " $gentop"
10136
10137	func_extract_archives $gentop $convenience
10138	reload_conv_objs="$reload_objs $func_extract_archives_result"
10139	fi
10140	fi
10141
10142	# If we're not building shared, we need to use non_pic_objs
10143	test yes = "$build_libtool_libs" \|\| libobjs=$non_pic_objects
10144
10145	# Create the old-style object.
10146	reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" \| $SP2NL \| $SED "/\.$libext$/d; /\.lib$/d; $lo2o" \| $NL2SP`' '$reload_conv_objs
10147
10148	output=$obj
10149	func_execute_cmds "$reload_cmds" 'exit $?'
10150
10151	# Exit if we aren't doing a library object file.
10152	if test -z "$libobj"; then
10153	if test -n "$gentop"; then
10154	func_show_eval '${RM}r "$gentop"'
10155	fi
10156
10157	exit $EXIT_SUCCESS
10158	fi
10159
10160	test yes = "$build_libtool_libs" \|\| {
10161	if test -n "$gentop"; then
10162	func_show_eval '${RM}r "$gentop"'
10163	fi
10164
10165	# Create an invalid libtool object if no PIC, so that we don't
10166	# accidentally link it into a program.
10167	# $show "echo timestamp > $libobj"
10168	# $opt_dry_run \|\| eval "echo timestamp > $libobj" \|\| exit $?
10169	exit $EXIT_SUCCESS
10170	}
10171
10172	if test -n "$pic_flag" \|\| test default != "$pic_mode"; then
10173	# Only do commands if we really have different PIC objects.
10174	reload_objs="$libobjs $reload_conv_objs"
10175	output=$libobj
10176	func_execute_cmds "$reload_cmds" 'exit $?'
10177	fi
10178
10179	if test -n "$gentop"; then
10180	func_show_eval '${RM}r "$gentop"'
10181	fi
10182
10183	exit $EXIT_SUCCESS
10184	;;
10185
10186	prog)
10187	case $host in
10188	cygwin) func_stripname '' '.exe' "$output"
10189	output=$func_stripname_result.exe;;
10190	esac
10191	test -n "$vinfo" && \
10192	func_warning "'-version-info' is ignored for programs"
10193
10194	test -n "$release" && \
10195	func_warning "'-release' is ignored for programs"
10196
10197	$preload \
10198	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
10199	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
10200
10201	case $host in
10202	--rhapsody* \| --darwin1.[012])
10203	# On Rhapsody replace the C library is the System framework
10204	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's/ -lc / System.ltframework /'`
10205	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's/ -lc / System.ltframework /'`
10206	;;
10207	esac
10208
10209	case $host in
10210	--darwin*)
10211	# Don't allow lazy linking, it breaks C++ global constructors
10212	# But is supposedly fixed on 10.4 or later (yay!).
10213	if test CXX = "$tagname"; then
10214	case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
10215	10.[0123])
10216	func_append compile_command " $wl-bind_at_load"
10217	func_append finalize_command " $wl-bind_at_load"
10218	;;
10219	esac
10220	fi
10221	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
10222	compile_deplibs=`$ECHO " $compile_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
10223	finalize_deplibs=`$ECHO " $finalize_deplibs" \| $SED 's% $[^ $]*$.ltframework% -framework \1%g'`
10224	;;
10225	esac
10226
10227
10228	# move library search paths that coincide with paths to not yet
10229	# installed libraries to the beginning of the library search list
10230	new_libs=
10231	for path in $notinst_path; do
10232	case " $new_libs " in
10233	" -L$path/$objdir ") ;;
10234	*)
10235	case " $compile_deplibs " in
10236	" -L$path/$objdir ")
10237	func_append new_libs " -L$path/$objdir" ;;
10238	esac
10239	;;
10240	esac
10241	done
10242	for deplib in $compile_deplibs; do
10243	case $deplib in
10244	-L*)
10245	case " $new_libs " in
10246	" $deplib ") ;;
10247	*) func_append new_libs " $deplib" ;;
10248	esac
10249	;;
10250	*) func_append new_libs " $deplib" ;;
10251	esac
10252	done
10253	compile_deplibs=$new_libs
10254
10255
10256	func_append compile_command " $compile_deplibs"
10257	func_append finalize_command " $finalize_deplibs"
10258
10259	if test -n "$rpath$xrpath"; then
10260	# If the user specified any rpath flags, then add them.
10261	for libdir in $rpath $xrpath; do
10262	# This is the magic to use -rpath.
10263	case "$finalize_rpath " in
10264	" $libdir ") ;;
10265	*) func_append finalize_rpath " $libdir" ;;
10266	esac
10267	done
10268	fi
10269
10270	# Now hardcode the library paths
10271	rpath=
10272	hardcode_libdirs=
10273	for libdir in $compile_rpath $finalize_rpath; do
10274	if test -n "$hardcode_libdir_flag_spec"; then
10275	if test -n "$hardcode_libdir_separator"; then
10276	if test -z "$hardcode_libdirs"; then
10277	hardcode_libdirs=$libdir
10278	else
10279	# Just accumulate the unique libdirs.
10280	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10281	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
10282	;;
10283	*)
10284	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10285	;;
10286	esac
10287	fi
10288	else
10289	eval flag=\"$hardcode_libdir_flag_spec\"
10290	func_append rpath " $flag"
10291	fi
10292	elif test -n "$runpath_var"; then
10293	case "$perm_rpath " in
10294	" $libdir ") ;;
10295	*) func_append perm_rpath " $libdir" ;;
10296	esac
10297	fi
10298	case $host in
10299	--cygwin* \| --mingw* \| --pw32* \| --os2* \| -cegcc)
10300	testbindir=`$ECHO "$libdir" \| $SED -e 's/lib$/bin*'`
10301	case :$dllsearchpath: in
10302	":$libdir:") ;;
10303	::) dllsearchpath=$libdir;;
10304	*) func_append dllsearchpath ":$libdir";;
10305	esac
10306	case :$dllsearchpath: in
10307	":$testbindir:") ;;
10308	::) dllsearchpath=$testbindir;;
10309	*) func_append dllsearchpath ":$testbindir";;
10310	esac
10311	;;
10312	esac
10313	done
10314	# Substitute the hardcoded libdirs into the rpath.
10315	if test -n "$hardcode_libdir_separator" &&
10316	test -n "$hardcode_libdirs"; then
10317	libdir=$hardcode_libdirs
10318	eval rpath=\" $hardcode_libdir_flag_spec\"
10319	fi
10320	compile_rpath=$rpath
10321
10322	rpath=
10323	hardcode_libdirs=
10324	for libdir in $finalize_rpath; do
10325	if test -n "$hardcode_libdir_flag_spec"; then
10326	if test -n "$hardcode_libdir_separator"; then
10327	if test -z "$hardcode_libdirs"; then
10328	hardcode_libdirs=$libdir
10329	else
10330	# Just accumulate the unique libdirs.
10331	case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10332	"$hardcode_libdir_separator$libdir$hardcode_libdir_separator")
10333	;;
10334	*)
10335	func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10336	;;
10337	esac
10338	fi
10339	else
10340	eval flag=\"$hardcode_libdir_flag_spec\"
10341	func_append rpath " $flag"
10342	fi
10343	elif test -n "$runpath_var"; then
10344	case "$finalize_perm_rpath " in
10345	" $libdir ") ;;
10346	*) func_append finalize_perm_rpath " $libdir" ;;
10347	esac
10348	fi
10349	done
10350	# Substitute the hardcoded libdirs into the rpath.
10351	if test -n "$hardcode_libdir_separator" &&
10352	test -n "$hardcode_libdirs"; then
10353	libdir=$hardcode_libdirs
10354	eval rpath=\" $hardcode_libdir_flag_spec\"
10355	fi
10356	finalize_rpath=$rpath
10357
10358	if test -n "$libobjs" && test yes = "$build_old_libs"; then
10359	# Transform all the library objects into standard objects.
10360	compile_command=`$ECHO "$compile_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
10361	finalize_command=`$ECHO "$finalize_command" \| $SP2NL \| $SED "$lo2o" \| $NL2SP`
10362	fi
10363
10364	func_generate_dlsyms "$outputname" "@PROGRAM@" false
10365
10366	# template prelinking step
10367	if test -n "$prelink_cmds"; then
10368	func_execute_cmds "$prelink_cmds" 'exit $?'
10369	fi
10370
10371	wrappers_required=:
10372	case $host in
10373	cegcc \| mingw32ce)
10374	# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
10375	wrappers_required=false
10376	;;
10377	cygwin \| mingw )
10378	test yes = "$build_libtool_libs" \|\| wrappers_required=false
10379	;;
10380	*)
10381	if test no = "$need_relink" \|\| test yes != "$build_libtool_libs"; then
10382	wrappers_required=false
10383	fi
10384	;;
10385	esac
10386	$wrappers_required \|\| {
10387	# Replace the output file specification.
10388	compile_command=`$ECHO "$compile_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
10389	link_command=$compile_command$compile_rpath
10390
10391	# We have no uninstalled library dependencies, so finalize right now.
10392	exit_status=0
10393	func_show_eval "$link_command" 'exit_status=$?'
10394
10395	if test -n "$postlink_cmds"; then
10396	func_to_tool_file "$output"
10397	postlink_cmds=`func_echo_all "$postlink_cmds" \| $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10398	func_execute_cmds "$postlink_cmds" 'exit $?'
10399	fi
10400
10401	# Delete the generated files.
10402	if test -f "$output_objdir/${outputname}S.$objext"; then
10403	func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
10404	fi
10405
10406	exit $exit_status
10407	}
10408
10409	if test -n "$compile_shlibpath$finalize_shlibpath"; then
10410	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
10411	fi
10412	if test -n "$finalize_shlibpath"; then
10413	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
10414	fi
10415
10416	compile_var=
10417	finalize_var=
10418	if test -n "$runpath_var"; then
10419	if test -n "$perm_rpath"; then
10420	# We should set the runpath_var.
10421	rpath=
10422	for dir in $perm_rpath; do
10423	func_append rpath "$dir:"
10424	done
10425	compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
10426	fi
10427	if test -n "$finalize_perm_rpath"; then
10428	# We should set the runpath_var.
10429	rpath=
10430	for dir in $finalize_perm_rpath; do
10431	func_append rpath "$dir:"
10432	done
10433	finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
10434	fi
10435	fi
10436
10437	if test yes = "$no_install"; then
10438	# We don't need to create a wrapper script.
10439	link_command=$compile_var$compile_command$compile_rpath
10440	# Replace the output file specification.
10441	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output"'%g'`
10442	# Delete the old output file.
10443	$opt_dry_run \|\| $RM $output
10444	# Link the executable and exit
10445	func_show_eval "$link_command" 'exit $?'
10446
10447	if test -n "$postlink_cmds"; then
10448	func_to_tool_file "$output"
10449	postlink_cmds=`func_echo_all "$postlink_cmds" \| $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10450	func_execute_cmds "$postlink_cmds" 'exit $?'
10451	fi
10452
10453	exit $EXIT_SUCCESS
10454	fi
10455
10456	case $hardcode_action,$fast_install in
10457	relink,*)
10458	# Fast installation is not supported
10459	link_command=$compile_var$compile_command$compile_rpath
10460	relink_command=$finalize_var$finalize_command$finalize_rpath
10461
10462	func_warning "this platform does not like uninstalled shared libraries"
10463	func_warning "'$output' will be relinked during installation"
10464	;;
10465	*,yes)
10466	link_command=$finalize_var$compile_command$finalize_rpath
10467	relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" \| $SED 's%@OUTPUT@%\$progdir/\$file%g'`
10468	;;
10469	*,no)
10470	link_command=$compile_var$compile_command$compile_rpath
10471	relink_command=$finalize_var$finalize_command$finalize_rpath
10472	;;
10473	*,needless)
10474	link_command=$finalize_var$compile_command$finalize_rpath
10475	relink_command=
10476	;;
10477	esac
10478
10479	# Replace the output file specification.
10480	link_command=`$ECHO "$link_command" \| $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
10481
10482	# Delete the old output files.
10483	$opt_dry_run \|\| $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
10484
10485	func_show_eval "$link_command" 'exit $?'
10486
10487	if test -n "$postlink_cmds"; then
10488	func_to_tool_file "$output_objdir/$outputname"
10489	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'`
10490	func_execute_cmds "$postlink_cmds" 'exit $?'
10491	fi
10492
10493	# Now create the wrapper script.
10494	func_verbose "creating $output"
10495
10496	# Quote the relink command for shipping.
10497	if test -n "$relink_command"; then
10498	# Preserve any variables that may affect compiler behavior
10499	for var in $variables_saved_for_relink; do
10500	if eval test -z \"\${$var+set}\"; then
10501	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
10502	elif eval var_value=\$$var; test -z "$var_value"; then
10503	relink_command="$var=; export $var; $relink_command"
10504	else
10505	func_quote_for_eval "$var_value"
10506	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
10507	fi
10508	done
10509	relink_command="(cd `pwd`; $relink_command)"
10510	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
10511	fi
10512
10513	# Only actually do things if not in dry run mode.
10514	$opt_dry_run \|\| {
10515	# win32 will think the script is a binary if it has
10516	# a .exe suffix, so we strip it off here.
10517	case $output in
10518	*.exe) func_stripname '' '.exe' "$output"
10519	output=$func_stripname_result ;;
10520	esac
10521	# test for cygwin because mv fails w/o .exe extensions
10522	case $host in
10523	cygwin)
10524	exeext=.exe
10525	func_stripname '' '.exe' "$outputname"
10526	outputname=$func_stripname_result ;;
10527	*) exeext= ;;
10528	esac
10529	case $host in
10530	cygwin \| mingw )
10531	func_dirname_and_basename "$output" "" "."
10532	output_name=$func_basename_result
10533	output_path=$func_dirname_result
10534	cwrappersource=$output_path/$objdir/lt-$output_name.c
10535	cwrapper=$output_path/$output_name.exe
10536	$RM $cwrappersource $cwrapper
10537	trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
10538
10539	func_emit_cwrapperexe_src > $cwrappersource
10540
10541	# The wrapper executable is built using the $host compiler,
10542	# because it contains $host paths and files. If cross-
10543	# compiling, it, like the target executable, must be
10544	# executed on the $host or under an emulation environment.
10545	$opt_dry_run \|\| {
10546	$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
10547	$STRIP $cwrapper
10548	}
10549
10550	# Now, create the wrapper script for func_source use:
10551	func_ltwrapper_scriptname $cwrapper
10552	$RM $func_ltwrapper_scriptname_result
10553	trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
10554	$opt_dry_run \|\| {
10555	# note: this script will not be executed, so do not chmod.
10556	if test "x$build" = "x$host"; then
10557	$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
10558	else
10559	func_emit_wrapper no > $func_ltwrapper_scriptname_result
10560	fi
10561	}
10562	;;
10563	* )
10564	$RM $output
10565	trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
10566
10567	func_emit_wrapper no > $output
10568	chmod +x $output
10569	;;
10570	esac
10571	}
10572	exit $EXIT_SUCCESS
10573	;;
10574	esac
10575
10576	# See if we need to build an old-fashioned archive.
10577	for oldlib in $oldlibs; do
10578
10579	case $build_libtool_libs in
10580	convenience)
10581	oldobjs="$libobjs_save $symfileobj"
10582	addlibs=$convenience
10583	build_libtool_libs=no
10584	;;
10585	module)
10586	oldobjs=$libobjs_save
10587	addlibs=$old_convenience
10588	build_libtool_libs=no
10589	;;
10590	*)
10591	oldobjs="$old_deplibs $non_pic_objects"
10592	$preload && test -f "$symfileobj" \
10593	&& func_append oldobjs " $symfileobj"
10594	addlibs=$old_convenience
10595	;;
10596	esac
10597
10598	if test -n "$addlibs"; then
10599	gentop=$output_objdir/${outputname}x
10600	func_append generated " $gentop"
10601
10602	func_extract_archives $gentop $addlibs
10603	func_append oldobjs " $func_extract_archives_result"
10604	fi
10605
10606	# Do each command in the archive commands.
10607	if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
10608	cmds=$old_archive_from_new_cmds
10609	else
10610
10611	# Add any objects from preloaded convenience libraries
10612	if test -n "$dlprefiles"; then
10613	gentop=$output_objdir/${outputname}x
10614	func_append generated " $gentop"
10615
10616	func_extract_archives $gentop $dlprefiles
10617	func_append oldobjs " $func_extract_archives_result"
10618	fi
10619
10620	# POSIX demands no paths to be encoded in archives. We have
10621	# to avoid creating archives with duplicate basenames if we
10622	# might have to extract them afterwards, e.g., when creating a
10623	# static archive out of a convenience library, or when linking
10624	# the entirety of a libtool archive into another (currently
10625	# not supported by libtool).
10626	if (for obj in $oldobjs
10627	do
10628	func_basename "$obj"
10629	$ECHO "$func_basename_result"
10630	done \| sort \| sort -uc >/dev/null 2>&1); then
10631	:
10632	else
10633	echo "copying selected object files to avoid basename conflicts..."
10634	gentop=$output_objdir/${outputname}x
10635	func_append generated " $gentop"
10636	func_mkdir_p "$gentop"
10637	save_oldobjs=$oldobjs
10638	oldobjs=
10639	counter=1
10640	for obj in $save_oldobjs
10641	do
10642	func_basename "$obj"
10643	objbase=$func_basename_result
10644	case " $oldobjs " in
10645	" ") oldobjs=$obj ;;
10646	[\ /]"$objbase ")
10647	while :; do
10648	# Make sure we don't pick an alternate name that also
10649	# overlaps.
10650	newobj=lt$counter-$objbase
10651	func_arith $counter + 1
10652	counter=$func_arith_result
10653	case " $oldobjs " in
10654	[\ /]"$newobj ") ;;
10655	*) if test ! -f "$gentop/$newobj"; then break; fi ;;
10656	esac
10657	done
10658	func_show_eval "ln $obj $gentop/$newobj \|\| cp $obj $gentop/$newobj"
10659	func_append oldobjs " $gentop/$newobj"
10660	;;
10661	*) func_append oldobjs " $obj" ;;
10662	esac
10663	done
10664	fi
10665	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
10666	tool_oldlib=$func_to_tool_file_result
10667	eval cmds=\"$old_archive_cmds\"
10668
10669	func_len " $cmds"
10670	len=$func_len_result
10671	if test "$len" -lt "$max_cmd_len" \|\| test "$max_cmd_len" -le -1; then
10672	cmds=$old_archive_cmds
10673	elif test -n "$archiver_list_spec"; then
10674	func_verbose "using command file archive linking..."
10675	for obj in $oldobjs
10676	do
10677	func_to_tool_file "$obj"
10678	$ECHO "$func_to_tool_file_result"
10679	done > $output_objdir/$libname.libcmd
10680	func_to_tool_file "$output_objdir/$libname.libcmd"
10681	oldobjs=" $archiver_list_spec$func_to_tool_file_result"
10682	cmds=$old_archive_cmds
10683	else
10684	# the command line is too long to link in one step, link in parts
10685	func_verbose "using piecewise archive linking..."
10686	save_RANLIB=$RANLIB
10687	RANLIB=:
10688	objlist=
10689	concat_cmds=
10690	save_oldobjs=$oldobjs
10691	oldobjs=
10692	# Is there a better way of finding the last object in the list?
10693	for obj in $save_oldobjs
10694	do
10695	last_oldobj=$obj
10696	done
10697	eval test_cmds=\"$old_archive_cmds\"
10698	func_len " $test_cmds"
10699	len0=$func_len_result
10700	len=$len0
10701	for obj in $save_oldobjs
10702	do
10703	func_len " $obj"
10704	func_arith $len + $func_len_result
10705	len=$func_arith_result
10706	func_append objlist " $obj"
10707	if test "$len" -lt "$max_cmd_len"; then
10708	:
10709	else
10710	# the above command should be used before it gets too long
10711	oldobjs=$objlist
10712	if test "$obj" = "$last_oldobj"; then
10713	RANLIB=$save_RANLIB
10714	fi
10715	test -z "$concat_cmds" \|\| concat_cmds=$concat_cmds~
10716	eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
10717	objlist=
10718	len=$len0
10719	fi
10720	done
10721	RANLIB=$save_RANLIB
10722	oldobjs=$objlist
10723	if test -z "$oldobjs"; then
10724	eval cmds=\"\$concat_cmds\"
10725	else
10726	eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
10727	fi
10728	fi
10729	fi
10730	func_execute_cmds "$cmds" 'exit $?'
10731	done
10732
10733	test -n "$generated" && \
10734	func_show_eval "${RM}r$generated"
10735
10736	# Now create the libtool archive.
10737	case $output in
10738	*.la)
10739	old_library=
10740	test yes = "$build_old_libs" && old_library=$libname.$libext
10741	func_verbose "creating $output"
10742
10743	# Preserve any variables that may affect compiler behavior
10744	for var in $variables_saved_for_relink; do
10745	if eval test -z \"\${$var+set}\"; then
10746	relink_command="{ test -z \"\${$var+set}\" \|\| $lt_unset $var \|\| { $var=; export $var; }; }; $relink_command"
10747	elif eval var_value=\$$var; test -z "$var_value"; then
10748	relink_command="$var=; export $var; $relink_command"
10749	else
10750	func_quote_for_eval "$var_value"
10751	relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
10752	fi
10753	done
10754	# Quote the link command for shipping.
10755	relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
10756	relink_command=`$ECHO "$relink_command" \| $SED "$sed_quote_subst"`
10757	if test yes = "$hardcode_automatic"; then
10758	relink_command=
10759	fi
10760
10761	# Only create the output if not a dry run.
10762	$opt_dry_run \|\| {
10763	for installed in no yes; do
10764	if test yes = "$installed"; then
10765	if test -z "$install_libdir"; then
10766	break
10767	fi
10768	output=$output_objdir/${outputname}i
10769	# Replace all uninstalled libtool libraries with the installed ones
10770	newdependency_libs=
10771	for deplib in $dependency_libs; do
10772	case $deplib in
10773	*.la)
10774	func_basename "$deplib"
10775	name=$func_basename_result
10776	func_resolve_sysroot "$deplib"
10777	eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $func_resolve_sysroot_result`
10778	test -z "$libdir" && \
10779	func_fatal_error "'$deplib' is not a valid libtool archive"
10780	func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
10781	;;
10782	-L*)
10783	func_stripname -L '' "$deplib"
10784	func_replace_sysroot "$func_stripname_result"
10785	func_append newdependency_libs " -L$func_replace_sysroot_result"
10786	;;
10787	-R*)
10788	func_stripname -R '' "$deplib"
10789	func_replace_sysroot "$func_stripname_result"
10790	func_append newdependency_libs " -R$func_replace_sysroot_result"
10791	;;
10792	*) func_append newdependency_libs " $deplib" ;;
10793	esac
10794	done
10795	dependency_libs=$newdependency_libs
10796	newdlfiles=
10797
10798	for lib in $dlfiles; do
10799	case $lib in
10800	*.la)
10801	func_basename "$lib"
10802	name=$func_basename_result
10803	eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $lib`
10804	test -z "$libdir" && \
10805	func_fatal_error "'$lib' is not a valid libtool archive"
10806	func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
10807	;;
10808	*) func_append newdlfiles " $lib" ;;
10809	esac
10810	done
10811	dlfiles=$newdlfiles
10812	newdlprefiles=
10813	for lib in $dlprefiles; do
10814	case $lib in
10815	*.la)
10816	# Only pass preopened files to the pseudo-archive (for
10817	# eventual linking with the app. that links it) if we
10818	# didn't already link the preopened objects directly into
10819	# the library:
10820	func_basename "$lib"
10821	name=$func_basename_result
10822	eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $lib`
10823	test -z "$libdir" && \
10824	func_fatal_error "'$lib' is not a valid libtool archive"
10825	func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
10826	;;
10827	esac
10828	done
10829	dlprefiles=$newdlprefiles
10830	else
10831	newdlfiles=
10832	for lib in $dlfiles; do
10833	case $lib in
10834	[\\/]* \| [A-Za-z]:[\\/]*) abs=$lib ;;
10835	*) abs=`pwd`"/$lib" ;;
10836	esac
10837	func_append newdlfiles " $abs"
10838	done
10839	dlfiles=$newdlfiles
10840	newdlprefiles=
10841	for lib in $dlprefiles; do
10842	case $lib in
10843	[\\/]* \| [A-Za-z]:[\\/]*) abs=$lib ;;
10844	*) abs=`pwd`"/$lib" ;;
10845	esac
10846	func_append newdlprefiles " $abs"
10847	done
10848	dlprefiles=$newdlprefiles
10849	fi
10850	$RM $output
10851	# place dlname in correct position for cygwin
10852	# In fact, it would be nice if we could use this code for all target
10853	# systems that can't hard-code library paths into their executables
10854	# and that have no shared library path variable independent of PATH,
10855	# but it turns out we can't easily determine that from inspecting
10856	# libtool variables, so we have to hard-code the OSs to which it
10857	# applies here; at the moment, that means platforms that use the PE
10858	# object format with DLL files. See the long comment at the top of
10859	# tests/bindir.at for full details.
10860	tdlname=$dlname
10861	case $host,$output,$installed,$module,$dlname in
10862	cygwin,lai,yes,no,.dll \| mingw,lai,yes,no,.dll \| cegcc,lai,yes,no,.dll)
10863	# If a -bindir argument was supplied, place the dll there.
10864	if test -n "$bindir"; then
10865	func_relative_path "$install_libdir" "$bindir"
10866	tdlname=$func_relative_path_result/$dlname
10867	else
10868	# Otherwise fall back on heuristic.
10869	tdlname=../bin/$dlname
10870	fi
10871	;;
10872	esac
10873	$ECHO > $output "\
10874	# $outputname - a libtool library file
10875	# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
10876	#
10877	# Please DO NOT delete this file!
10878	# It is necessary for linking the library.
10879
10880	# The name that we can dlopen(3).
10881	dlname='$tdlname'
10882
10883	# Names of this library.
10884	library_names='$library_names'
10885
10886	# The name of the static archive.
10887	old_library='$old_library'
10888
10889	# Linker flags that cannot go in dependency_libs.
10890	inherited_linker_flags='$new_inherited_linker_flags'
10891
10892	# Libraries that this one depends upon.
10893	dependency_libs='$dependency_libs'
10894
10895	# Names of additional weak libraries provided by this library
10896	weak_library_names='$weak_libs'
10897
10898	# Version information for $libname.
10899	current=$current
10900	age=$age
10901	revision=$revision
10902
10903	# Is this an already installed library?
10904	installed=$installed
10905
10906	# Should we warn about portability when linking against -modules?
10907	shouldnotlink=$module
10908
10909	# Files to dlopen/dlpreopen
10910	dlopen='$dlfiles'
10911	dlpreopen='$dlprefiles'
10912
10913	# Directory that this library needs to be installed in:
10914	libdir='$install_libdir'"
10915	if test no,yes = "$installed,$need_relink"; then
10916	$ECHO >> $output "\
10917	relink_command=\"$relink_command\""
10918	fi
10919	done
10920	}
10921
10922	# Do a symbolic link so that the libtool archive can be found in
10923	# LD_LIBRARY_PATH before the program is installed.
10924	func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
10925	;;
10926	esac
10927	exit $EXIT_SUCCESS
10928	}
10929
10930	if test link = "$opt_mode" \|\| test relink = "$opt_mode"; then
10931	func_mode_link ${1+"$@"}
10932	fi
10933
10934
10935	# func_mode_uninstall arg...
10936	func_mode_uninstall ()
10937	{
10938	$debug_cmd
10939
10940	RM=$nonopt
10941	files=
10942	rmforce=false
10943	exit_status=0
10944
10945	# This variable tells wrapper scripts just to set variables rather
10946	# than running their programs.
10947	libtool_install_magic=$magic
10948
10949	for arg
10950	do
10951	case $arg in
10952	-f) func_append RM " $arg"; rmforce=: ;;
10953	-*) func_append RM " $arg" ;;
10954	*) func_append files " $arg" ;;
10955	esac
10956	done
10957
10958	test -z "$RM" && \
10959	func_fatal_help "you must specify an RM program"
10960
10961	rmdirs=
10962
10963	for file in $files; do
10964	func_dirname "$file" "" "."
10965	dir=$func_dirname_result
10966	if test . = "$dir"; then
10967	odir=$objdir
10968	else
10969	odir=$dir/$objdir
10970	fi
10971	func_basename "$file"
10972	name=$func_basename_result
10973	test uninstall = "$opt_mode" && odir=$dir
10974
10975	# Remember odir for removal later, being careful to avoid duplicates
10976	if test clean = "$opt_mode"; then
10977	case " $rmdirs " in
10978	" $odir ") ;;
10979	*) func_append rmdirs " $odir" ;;
10980	esac
10981	fi
10982
10983	# Don't error if the file doesn't exist and rm -f was used.
10984	if { test -L "$file"; } >/dev/null 2>&1 \|\|
10985	{ test -h "$file"; } >/dev/null 2>&1 \|\|
10986	test -f "$file"; then
10987	:
10988	elif test -d "$file"; then
10989	exit_status=1
10990	continue
10991	elif $rmforce; then
10992	continue
10993	fi
10994
10995	rmfiles=$file
10996
10997	case $name in
10998	*.la)
10999	# Possibly a libtool archive, so verify it.
11000	if func_lalib_p "$file"; then
11001	func_source $dir/$name
11002
11003	# Delete the libtool libraries and symlinks.
11004	for n in $library_names; do
11005	func_append rmfiles " $odir/$n"
11006	done
11007	test -n "$old_library" && func_append rmfiles " $odir/$old_library"
11008
11009	case $opt_mode in
11010	clean)
11011	case " $library_names " in
11012	" $dlname ") ;;
11013	*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
11014	esac
11015	test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
11016	;;
11017	uninstall)
11018	if test -n "$library_names"; then
11019	# Do each command in the postuninstall commands.
11020	func_execute_cmds "$postuninstall_cmds" '$rmforce \|\| exit_status=1'
11021	fi
11022
11023	if test -n "$old_library"; then
11024	# Do each command in the old_postuninstall commands.
11025	func_execute_cmds "$old_postuninstall_cmds" '$rmforce \|\| exit_status=1'
11026	fi
11027	# FIXME: should reinstall the best remaining shared library.
11028	;;
11029	esac
11030	fi
11031	;;
11032
11033	*.lo)
11034	# Possibly a libtool object, so verify it.
11035	if func_lalib_p "$file"; then
11036
11037	# Read the .lo file
11038	func_source $dir/$name
11039
11040	# Add PIC object to the list of files to remove.
11041	if test -n "$pic_object" && test none != "$pic_object"; then
11042	func_append rmfiles " $dir/$pic_object"
11043	fi
11044
11045	# Add non-PIC object to the list of files to remove.
11046	if test -n "$non_pic_object" && test none != "$non_pic_object"; then
11047	func_append rmfiles " $dir/$non_pic_object"
11048	fi
11049	fi
11050	;;
11051
11052	*)
11053	if test clean = "$opt_mode"; then
11054	noexename=$name
11055	case $file in
11056	*.exe)
11057	func_stripname '' '.exe' "$file"
11058	file=$func_stripname_result
11059	func_stripname '' '.exe' "$name"
11060	noexename=$func_stripname_result
11061	# $file with .exe has already been added to rmfiles,
11062	# add $file without .exe
11063	func_append rmfiles " $file"
11064	;;
11065	esac
11066	# Do a test to see if this is a libtool program.
11067	if func_ltwrapper_p "$file"; then
11068	if func_ltwrapper_executable_p "$file"; then
11069	func_ltwrapper_scriptname "$file"
11070	relink_command=
11071	func_source $func_ltwrapper_scriptname_result
11072	func_append rmfiles " $func_ltwrapper_scriptname_result"
11073	else
11074	relink_command=
11075	func_source $dir/$noexename
11076	fi
11077
11078	# note $name still contains .exe if it was in $file originally
11079	# as does the version of $file that was added into $rmfiles
11080	func_append rmfiles " $odir/$name $odir/${name}S.$objext"
11081	if test yes = "$fast_install" && test -n "$relink_command"; then
11082	func_append rmfiles " $odir/lt-$name"
11083	fi
11084	if test "X$noexename" != "X$name"; then
11085	func_append rmfiles " $odir/lt-$noexename.c"
11086	fi
11087	fi
11088	fi
11089	;;
11090	esac
11091	func_show_eval "$RM $rmfiles" 'exit_status=1'
11092	done
11093
11094	# Try to remove the $objdir's in the directories where we deleted files
11095	for dir in $rmdirs; do
11096	if test -d "$dir"; then
11097	func_show_eval "rmdir $dir >/dev/null 2>&1"
11098	fi
11099	done
11100
11101	exit $exit_status
11102	}
11103
11104	if test uninstall = "$opt_mode" \|\| test clean = "$opt_mode"; then
11105	func_mode_uninstall ${1+"$@"}
11106	fi
11107
11108	test -z "$opt_mode" && {
11109	help=$generic_help
11110	func_fatal_help "you must specify a MODE"
11111	}
11112
11113	test -z "$exec_cmd" && \
11114	func_fatal_help "invalid operation mode '$opt_mode'"
11115
11116	if test -n "$exec_cmd"; then
11117	eval exec "$exec_cmd"
11118	exit $EXIT_FAILURE
11119	fi
11120
11121	exit $exit_status
11122
11123
11124	# The TAGs below are defined such that we never get into a situation
11125	# where we disable both kinds of libraries. Given conflicting
11126	# choices, we go for a static library, that is the most portable,
11127	# since we can't tell whether shared libraries were disabled because
11128	# the user asked for that or because the platform doesn't support
11129	# them. This is particularly important on AIX, because we don't
11130	# support having both static and shared libraries enabled at the same
11131	# time on that platform, so we default to a shared-only configuration.
11132	# If a disable-shared tag is given, we'll fallback to a static-only
11133	# configuration. But we'll never go from static-only to shared-only.
11134
11135	# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
11136	build_libtool_libs=no
11137	build_old_libs=yes
11138	# ### END LIBTOOL TAG CONFIG: disable-shared
11139
11140	# ### BEGIN LIBTOOL TAG CONFIG: disable-static
11141	build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
11142	# ### END LIBTOOL TAG CONFIG: disable-static
11143
11144	# Local Variables:
11145	# mode:shell-script
11146	# sh-indentation:2
11147	# End:

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/libpng-1.2.54/ltmain.sh@ 75439

以其他格式下載: