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