ltmain.sh@ 99132

Last change on this file since 99132 was 96468, checked in by vboxsync, 2 years ago
libs/libvorbis-1.3.7: Re-exporting, hopefully this time everything is there. bugref:10275
Property svn:eol-style set to `LF` Property svn:executable set to ``* Property svn:keywords set to `Author Date Id Revision`
File size: 319.6 KB

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

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

source: vbox/trunk/src/libs/libvorbis-1.3.7/ltmain.sh@ 99132

Download in other formats: