ltmain.sh@ 107935

Last change on this file since 107935 was 107813, checked in by vboxsync, 3 weeks ago
libpng-1.6.45: Applied and adjusted our libpng changes to 1.6.45. bugref:8515
Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 329.6 KB

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

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

source: vbox/trunk/src/libs/libpng-1.6.45/ltmain.sh@ 107935

Download in other formats: