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