2
# libtool (GNU libtool) 2.4
3
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6
# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
7
# This is free software; see the source for copying conditions. There is NO
8
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10
# GNU Libtool is free software; you can redistribute it and/or modify
11
# it under the terms of the GNU General Public License as published by
12
# the Free Software Foundation; either version 2 of the License, or
13
# (at your option) any later version.
15
# As a special exception to the GNU General Public License,
16
# if you distribute this file as part of a program or library that
17
# is built using GNU Libtool, you may include this file under the
18
# same distribution terms that you use for the rest of that program.
20
# GNU Libtool is distributed in the hope that it will be useful, but
21
# WITHOUT ANY WARRANTY; without even the implied warranty of
22
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
# General Public License for more details.
25
# You should have received a copy of the GNU General Public License
26
# along with GNU Libtool; see the file COPYING. If not, a copy
27
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
28
# or obtained by writing to the Free Software Foundation, Inc.,
29
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31
# Usage: $progname [OPTION]... [MODE-ARG]...
33
# Provide generalized library-building support services.
35
# --config show all configuration variables
36
# --debug enable verbose shell tracing
37
# -n, --dry-run display commands without modifying any files
38
# --features display basic configuration information and exit
39
# --mode=MODE use operation mode MODE
40
# --preserve-dup-deps don't remove duplicate dependency libraries
41
# --quiet, --silent don't print informational messages
42
# --no-quiet, --no-silent
43
# print informational messages (default)
44
# --tag=TAG use configuration variables from tag TAG
45
# -v, --verbose print more informational messages than default
46
# --no-verbose don't print the extra informational messages
47
# --version print version information
48
# -h, --help, --help-all print short, long, or detailed help message
50
# MODE must be one of the following:
52
# clean remove files from the build directory
53
# compile compile a source file into a libtool object
54
# execute automatically set library path, then run a program
55
# finish complete the installation of libtool libraries
56
# install install libraries or executables
57
# link create a library or an executable
58
# uninstall remove libraries from an installed directory
60
# MODE-ARGS vary depending on the MODE. When passed as first option,
61
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
62
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64
# When reporting a bug, please describe a test case to reproduce it and
65
# include the following information:
70
# compiler flags: $LTCFLAGS
71
# linker: $LD (gnu? $with_gnu_ld)
72
# $progname: (GNU libtool) 2.4 Debian-2.4-2ubuntu1
73
# automake: $automake_version
74
# autoconf: $autoconf_version
76
# Report bugs to <bug-libtool@gnu.org>.
77
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
78
# General help using GNU software: <http://www.gnu.org/gethelp/>.
82
VERSION="2.4 Debian-2.4-2ubuntu1"
84
package_revision=1.3293
86
# Be Bourne compatible
87
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
90
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91
# is contrary to our usage. Disable this feature.
92
alias -g '${1+"$@"}'='"$@"'
95
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97
BIN_SH=xpg4; export BIN_SH # for Tru64
98
DUALCASE=1; export DUALCASE # for MKS sh
100
# A function that is used when there is no print builtin or printf.
101
func_fallback_echo ()
103
eval 'cat <<_LTECHO_EOF
108
# NLS nuisances: We save the old values to restore during execute mode.
111
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113
eval "if test \"\${$lt_var+set}\" = set; then
114
save_$lt_var=\$$lt_var
117
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
118
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
123
export LANGUAGE LC_ALL
128
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
129
# is ksh but when the shell is invoked as "sh" and the current value of
130
# the _XPG environment variable is not equal to 1 (one), the special
131
# positional parameter $0, within a function call, is the name of the
138
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
139
: ${EGREP="/bin/grep -E"}
140
: ${FGREP="/bin/grep -F"}
141
: ${GREP="/bin/grep"}
148
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
149
: ${Xsed="$SED -e 1s/^X//"}
154
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
155
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
157
exit_status=$EXIT_SUCCESS
159
# Make sure IFS has a sensible default
164
dirname="s,/[^/]*$,,"
167
# func_dirname file append nondir_replacement
168
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
169
# otherwise set result to NONDIR_REPLACEMENT.
172
func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
173
if test "X$func_dirname_result" = "X${1}"; then
174
func_dirname_result="${3}"
176
func_dirname_result="$func_dirname_result${2}"
178
} # func_dirname may be replaced by extended shell implementation
184
func_basename_result=`$ECHO "${1}" | $SED "$basename"`
185
} # func_basename may be replaced by extended shell implementation
188
# func_dirname_and_basename file append nondir_replacement
189
# perform func_basename and func_dirname in a single function
191
# dirname: Compute the dirname of FILE. If nonempty,
192
# add APPEND to the result, otherwise set result
193
# to NONDIR_REPLACEMENT.
194
# value returned in "$func_dirname_result"
195
# basename: Compute filename of FILE.
196
# value retuned in "$func_basename_result"
197
# Implementation must be kept synchronized with func_dirname
198
# and func_basename. For efficiency, we do not delegate to
199
# those functions but instead duplicate the functionality here.
200
func_dirname_and_basename ()
202
# Extract subdirectory from the argument.
203
func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
204
if test "X$func_dirname_result" = "X${1}"; then
205
func_dirname_result="${3}"
207
func_dirname_result="$func_dirname_result${2}"
209
func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
210
} # func_dirname_and_basename may be replaced by extended shell implementation
213
# func_stripname prefix suffix name
214
# strip PREFIX and SUFFIX off of NAME.
215
# PREFIX and SUFFIX must not contain globbing or regex special
216
# characters, hashes, percent signs, but SUFFIX may contain a leading
217
# dot (in which case that matches only a dot).
218
# func_strip_suffix prefix name
222
.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
223
*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
225
} # func_stripname may be replaced by extended shell implementation
228
# These SED scripts presuppose an absolute path with a trailing slash.
229
pathcar='s,^/\([^/]*\).*$,\1,'
230
pathcdr='s,^/[^/]*,,'
231
removedotparts=':dotsl
235
collapseslashes='s@/\{1,\}@/@g'
236
finalslash='s,/*$,/,'
238
# func_normal_abspath PATH
239
# Remove doubled-up and trailing slashes, "." path components,
240
# and cancel out any ".." path components in PATH after making
241
# it an absolute path.
242
# value returned in "$func_normal_abspath_result"
243
func_normal_abspath ()
245
# Start from root dir and reassemble the path.
246
func_normal_abspath_result=
247
func_normal_abspath_tpath=$1
248
func_normal_abspath_altnamespace=
249
case $func_normal_abspath_tpath in
251
# Empty path, that just means $cwd.
252
func_stripname '' '/' "`pwd`"
253
func_normal_abspath_result=$func_stripname_result
256
# The next three entries are used to spot a run of precisely
257
# two leading slashes without using negated character classes;
258
# we take advantage of case's first-match behaviour.
260
# Unusual form of absolute path, do nothing.
263
# Not necessarily an ordinary path; POSIX reserves leading '//'
264
# and for example Cygwin uses it to access remote file shares
265
# over CIFS/SMB, so we conserve a leading double slash if found.
266
func_normal_abspath_altnamespace=/
269
# Absolute path, do nothing.
272
# Relative path, prepend $cwd.
273
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
276
# Cancel out all the simple stuff to save iterations. We also want
277
# the path to end with a slash for ease of parsing, so make sure
278
# there is one (and only one) here.
279
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
280
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
282
# Processed it all yet?
283
if test "$func_normal_abspath_tpath" = / ; then
284
# If we ascended to the root using ".." the result may be empty now.
285
if test -z "$func_normal_abspath_result" ; then
286
func_normal_abspath_result=/
290
func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
292
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
294
# Figure out what to do with it
295
case $func_normal_abspath_tcomponent in
297
# Trailing empty path component, ignore it.
300
# Parent dir; strip last assembled component from result.
301
func_dirname "$func_normal_abspath_result"
302
func_normal_abspath_result=$func_dirname_result
305
# Actual path component, append it.
306
func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
310
# Restore leading double-slash if one was found on entry.
311
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
314
# func_relative_path SRCDIR DSTDIR
315
# generates a relative path from SRCDIR to DSTDIR, with a trailing
316
# slash if non-empty, suitable for immediately appending a filename
317
# without needing to append a separator.
318
# value returned in "$func_relative_path_result"
319
func_relative_path ()
321
func_relative_path_result=
322
func_normal_abspath "$1"
323
func_relative_path_tlibdir=$func_normal_abspath_result
324
func_normal_abspath "$2"
325
func_relative_path_tbindir=$func_normal_abspath_result
327
# Ascend the tree starting from libdir
329
# check if we have found a prefix of bindir
330
case $func_relative_path_tbindir in
331
$func_relative_path_tlibdir)
332
# found an exact match
333
func_relative_path_tcancelled=
336
$func_relative_path_tlibdir*)
337
# found a matching prefix
338
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
339
func_relative_path_tcancelled=$func_stripname_result
340
if test -z "$func_relative_path_result"; then
341
func_relative_path_result=.
346
func_dirname $func_relative_path_tlibdir
347
func_relative_path_tlibdir=${func_dirname_result}
348
if test "x$func_relative_path_tlibdir" = x ; then
349
# Have to descend all the way to the root!
350
func_relative_path_result=../$func_relative_path_result
351
func_relative_path_tcancelled=$func_relative_path_tbindir
354
func_relative_path_result=../$func_relative_path_result
359
# Now calculate path; take care to avoid doubling-up slashes.
360
func_stripname '' '/' "$func_relative_path_result"
361
func_relative_path_result=$func_stripname_result
362
func_stripname '/' '/' "$func_relative_path_tcancelled"
363
if test "x$func_stripname_result" != x ; then
364
func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
367
# Normalisation. If bindir is libdir, return empty string,
368
# else relative path ending with a slash; either way, target
369
# file name can be directly appended.
370
if test ! -z "$func_relative_path_result"; then
371
func_stripname './' '' "$func_relative_path_result/"
372
func_relative_path_result=$func_stripname_result
376
# The name of this program:
377
func_dirname_and_basename "$progpath"
378
progname=$func_basename_result
380
# Make sure we have an absolute path for reexecution:
382
[\\/]*|[A-Za-z]:\\*) ;;
384
progdir=$func_dirname_result
385
progdir=`cd "$progdir" && pwd`
386
progpath="$progdir/$progname"
391
for progdir in $PATH; do
393
test -x "$progdir/$progname" && break
396
test -n "$progdir" || progdir=`pwd`
397
progpath="$progdir/$progname"
401
# Sed substitution that helps us do robust quoting. It backslashifies
402
# metacharacters that are still active within double-quoted strings.
403
Xsed="${SED}"' -e 1s/^X//'
404
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
406
# Same as above, but do not quote variable references.
407
double_quote_subst='s/\(["`\\]\)/\\\1/g'
409
# Sed substitution that turns a string into a regex matching for the
411
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
413
# Sed substitution that converts a w32 file name or path
414
# which contains forward slashes, into one that contains
415
# (escaped) backslashes. A very naive implementation.
416
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
418
# Re-`\' parameter expansions in output of double_quote_subst that were
419
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
420
# in input to double_quote_subst, that '$' was protected from expansion.
421
# Since each input `\' is now two `\'s, look for any number of runs of
422
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
427
sed_double_backslash="\
431
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
442
# Echo program name prefixed message, along with the current mode
443
# name if it has been set yet.
446
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
449
# func_verbose arg...
450
# Echo program name prefixed message in verbose mode only.
453
$opt_verbose && func_echo ${1+"$@"}
455
# A bug in bash halts the script if the last line of a function
456
# fails when set -e is in force, so we need another command to
461
# func_echo_all arg...
462
# Invoke $ECHO with all args, space-separated.
469
# Echo program name prefixed message to standard error.
472
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
475
# func_warning arg...
476
# Echo program name prefixed warning message to standard error.
479
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
485
# func_fatal_error arg...
486
# Echo program name prefixed message to standard error, and exit.
493
# func_fatal_help arg...
494
# Echo program name prefixed message to standard error, followed by
495
# a help hint, and exit.
499
func_fatal_error "$help"
501
help="Try \`$progname --help' for more information." ## default
504
# func_grep expression filename
505
# Check whether EXPRESSION matches any line of FILENAME, without output.
508
$GREP "$1" "$2" >/dev/null 2>&1
512
# func_mkdir_p directory-path
513
# Make sure the entire path to DIRECTORY-PATH is available.
516
my_directory_path="$1"
519
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
521
# Protect directory names starting with `-'
522
case $my_directory_path in
523
-*) my_directory_path="./$my_directory_path" ;;
526
# While some portion of DIR does not yet exist...
527
while test ! -d "$my_directory_path"; do
528
# ...make a list in topmost first order. Use a colon delimited
529
# list incase some portion of path contains whitespace.
530
my_dir_list="$my_directory_path:$my_dir_list"
532
# If the last portion added has no slash in it, the list is done
533
case $my_directory_path in */*) ;; *) break ;; esac
535
# ...otherwise throw away the child directory and loop
536
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
538
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
540
save_mkdir_p_IFS="$IFS"; IFS=':'
541
for my_dir in $my_dir_list; do
542
IFS="$save_mkdir_p_IFS"
543
# mkdir can fail with a `File exist' error if two processes
544
# try to create one of the directories concurrently. Don't
546
$MKDIR "$my_dir" 2>/dev/null || :
548
IFS="$save_mkdir_p_IFS"
550
# Bail out if we (or some other process) failed to create a directory.
551
test -d "$my_directory_path" || \
552
func_fatal_error "Failed to create \`$1'"
557
# func_mktempdir [string]
558
# Make a temporary directory that won't clash with other running
559
# libtool processes, and avoids race conditions if possible. If
560
# given, STRING is the basename for that directory.
563
my_template="${TMPDIR-/tmp}/${1-$progname}"
565
if test "$opt_dry_run" = ":"; then
566
# Return a directory name, but don't create it in dry-run mode
567
my_tmpdir="${my_template}-$$"
570
# If mktemp works, use that first and foremost
571
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
573
if test ! -d "$my_tmpdir"; then
574
# Failing that, at least try and use $RANDOM to avoid a race
575
my_tmpdir="${my_template}-${RANDOM-0}$$"
577
save_mktempdir_umask=`umask`
580
umask $save_mktempdir_umask
583
# If we're not in dry-run mode, bomb out on failure
584
test -d "$my_tmpdir" || \
585
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
592
# func_quote_for_eval arg
593
# Aesthetically quote ARG to be evaled later.
594
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
595
# is double-quoted, suitable for a subsequent eval, whereas
596
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
597
# which are still active within double quotes backslashified.
598
func_quote_for_eval ()
602
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
604
func_quote_for_eval_unquoted_result="$1" ;;
607
case $func_quote_for_eval_unquoted_result in
608
# Double-quote args containing shell metacharacters to delay
609
# word splitting, command substitution and and variable
610
# expansion for a subsequent eval.
611
# Many Bourne shells cannot handle close brackets correctly
612
# in scan sets, so we specify it separately.
613
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
614
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
617
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
622
# func_quote_for_expand arg
623
# Aesthetically quote ARG to be evaled later; same as above,
624
# but do not quote variable references.
625
func_quote_for_expand ()
629
my_arg=`$ECHO "$1" | $SED \
630
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
636
# Double-quote args containing shell metacharacters to delay
637
# word splitting and command substitution for a subsequent eval.
638
# Many Bourne shells cannot handle close brackets correctly
639
# in scan sets, so we specify it separately.
640
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
645
func_quote_for_expand_result="$my_arg"
649
# func_show_eval cmd [fail_exp]
650
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
651
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
652
# is given, then evaluate it.
658
${opt_silent-false} || {
659
func_quote_for_expand "$my_cmd"
660
eval "func_echo $func_quote_for_expand_result"
663
if ${opt_dry_run-false}; then :; else
666
if test "$my_status" -eq 0; then :; else
667
eval "(exit $my_status); $my_fail_exp"
673
# func_show_eval_locale cmd [fail_exp]
674
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
675
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
676
# is given, then evaluate it. Use the saved locale for evaluation.
677
func_show_eval_locale ()
682
${opt_silent-false} || {
683
func_quote_for_expand "$my_cmd"
684
eval "func_echo $func_quote_for_expand_result"
687
if ${opt_dry_run-false}; then :; else
688
eval "$lt_user_locale
691
eval "$lt_safe_locale"
692
if test "$my_status" -eq 0; then :; else
693
eval "(exit $my_status); $my_fail_exp"
699
# Turn $1 into a string suitable for a shell variable name.
700
# Result is stored in $func_tr_sh_result. All characters
701
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
702
# if $1 begins with a digit, a '_' is prepended as well.
706
[0-9]* | *[!a-zA-Z0-9_]*)
707
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
717
# Echo version message to standard output and exit.
730
/^# '$PROGRAM' (GNU /,/# warranty; / {
733
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
740
# Echo short help message to standard output and exit.
745
$SED -n '/^# Usage:/,/^# *.*--help/ {
748
s/\$progname/'$progname'/
752
$ECHO "run \`$progname --help | more' for full usage"
757
# Echo long help message to standard output and exit,
758
# unless 'noexit' is passed as argument.
763
$SED -n '/^# Usage:/,/# Report bugs to/ {
767
s*\$progname*'$progname'*
769
s*\$SHELL*'"$SHELL"'*
771
s*\$LTCFLAGS*'"$LTCFLAGS"'*
773
s/\$with_gnu_ld/'"$with_gnu_ld"'/
774
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
775
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
779
/^# .* home page:/b print
780
/^# General help using/b print
783
if test -z "$1"; then
788
# func_missing_arg argname
789
# Echo program name prefixed message to standard error and set global
795
func_error "missing argument for $1."
800
# func_split_short_opt shortopt
801
# Set func_split_short_opt_name and func_split_short_opt_arg shell
802
# variables after splitting SHORTOPT after the 2nd character.
803
func_split_short_opt ()
805
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
806
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
808
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
809
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
810
} # func_split_short_opt may be replaced by extended shell implementation
813
# func_split_long_opt longopt
814
# Set func_split_long_opt_name and func_split_long_opt_arg shell
815
# variables after splitting LONGOPT at the `=' sign.
816
func_split_long_opt ()
818
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
819
my_sed_long_arg='1s/^--[^=]*=//'
821
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
822
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
823
} # func_split_long_opt may be replaced by extended shell implementation
831
magic="%%%MAGIC variable%%%"
832
magic_exe="%%%MAGIC EXE variable%%%"
837
lo2o="s/\\.lo\$/.${objext}/"
838
o2lo="s/\\.${objext}\$/.lo/"
842
# If this variable is set in any of the actions, the command in it
843
# will be execed at the end. This prevents here-documents from being
844
# left over by shells.
847
# func_append var value
848
# Append VALUE to the end of shell variable VAR.
851
eval "${1}=\$${1}\${2}"
852
} # func_append may be replaced by extended shell implementation
854
# func_append_quoted var value
855
# Quote VALUE and append to the end of shell variable VAR, separated
857
func_append_quoted ()
859
func_quote_for_eval "${2}"
860
eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
861
} # func_append_quoted may be replaced by extended shell implementation
864
# func_arith arithmetic-term...
867
func_arith_result=`expr "${@}"`
868
} # func_arith may be replaced by extended shell implementation
872
# STRING may not start with a hyphen.
875
func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
876
} # func_len may be replaced by extended shell implementation
882
func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
883
} # func_lo2o may be replaced by extended shell implementation
886
# func_xform libobj-or-source
889
func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
890
} # func_xform may be replaced by extended shell implementation
893
# func_fatal_configuration arg...
894
# Echo program name prefixed message to standard error, followed by
895
# a configuration failure hint, and exit.
896
func_fatal_configuration ()
899
func_error "See the $PACKAGE documentation for more information."
900
func_fatal_error "Fatal configuration error."
905
# Display the configuration for all the tags in this script.
908
re_begincf='^# ### BEGIN LIBTOOL'
909
re_endcf='^# ### END LIBTOOL'
911
# Default configuration.
912
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
914
# Now print the configurations for the tags.
915
for tagname in $taglist; do
916
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
923
# Display the features supported by this script.
927
if test "$build_libtool_libs" = yes; then
928
echo "enable shared libraries"
930
echo "disable shared libraries"
932
if test "$build_old_libs" = yes; then
933
echo "enable static libraries"
935
echo "disable static libraries"
941
# func_enable_tag tagname
942
# Verify that TAGNAME is valid, and either flag an error and exit, or
943
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
950
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
951
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
952
sed_extractcf="/$re_begincf/,/$re_endcf/p"
957
func_fatal_error "invalid tag name: $tagname"
961
# Don't test for the "default" C tag, as we know it's
962
# there but not specially marked.
966
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
967
taglist="$taglist $tagname"
969
# Evaluate the configuration. Be careful to quote the path
970
# and the sed script, to avoid splitting on whitespace, but
971
# also don't use non-portable quotes within backquotes within
972
# quotes we have to do it in 2 steps:
973
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
976
func_error "ignoring unknown tag $tagname"
982
# func_check_version_match
983
# Ensure that we are using m4 macros, and libtool script from the same
984
# release of libtool.
985
func_check_version_match ()
987
if test "$package_revision" != "$macro_revision"; then
988
if test "$VERSION" != "$macro_version"; then
989
if test -z "$macro_version"; then
991
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
992
$progname: definition of this LT_INIT comes from an older release.
993
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
994
$progname: and run autoconf again.
998
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
999
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1000
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1001
$progname: and run autoconf again.
1006
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1007
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1008
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1009
$progname: of $PACKAGE $VERSION and run autoconf again.
1018
# Shorthand for --mode=foo, only valid as the first argument
1021
shift; set dummy --mode clean ${1+"$@"}; shift
1023
compile|compil|compi|comp|com|co|c)
1024
shift; set dummy --mode compile ${1+"$@"}; shift
1026
execute|execut|execu|exec|exe|ex|e)
1027
shift; set dummy --mode execute ${1+"$@"}; shift
1029
finish|finis|fini|fin|fi|f)
1030
shift; set dummy --mode finish ${1+"$@"}; shift
1032
install|instal|insta|inst|ins|in|i)
1033
shift; set dummy --mode install ${1+"$@"}; shift
1036
shift; set dummy --mode link ${1+"$@"}; shift
1038
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1039
shift; set dummy --mode uninstall ${1+"$@"}; shift
1049
opt_preserve_dup_deps=false
1060
# Parse options once, thoroughly. This comes as soon as possible in the
1061
# script to make things like `--version' happen as quickly as we can.
1063
# this just eases exit handling
1064
while test $# -gt 0; do
1068
--debug|-x) opt_debug='set -x'
1069
func_echo "enabling shell trace mode"
1072
--dry-run|--dryrun|-n)
1081
opt_dlopen="${opt_dlopen+$opt_dlopen
1085
--preserve-dup-deps)
1086
opt_preserve_dup_deps=:
1094
set dummy --mode finish ${1+"$@"}; shift
1101
opt_help=': help-all'
1104
test $# = 0 && func_missing_arg $opt && break
1108
# Valid mode arguments:
1109
clean|compile|execute|finish|install|link|relink|uninstall) ;;
1111
# Catch anything else as an error
1112
*) func_error "invalid argument for $opt"
1119
--no-silent|--no-quiet)
1121
func_append preserve_args " $opt"
1125
func_append preserve_args " $opt"
1129
func_append preserve_args " $opt"
1134
func_append preserve_args " $opt"
1138
test $# = 0 && func_missing_arg $opt && break
1141
func_append preserve_args " $opt $optarg"
1142
func_enable_tag "$optarg"
1146
-\?|-h) func_usage ;;
1147
--help) func_help ;;
1148
--version) func_version ;;
1150
# Separate optargs to long options:
1152
func_split_long_opt "$opt"
1153
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1157
# Separate non-argument short options:
1159
func_split_short_opt "$opt"
1160
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1165
-*) func_fatal_help "unrecognized option \`$opt'" ;;
1166
*) set dummy "$opt" ${1+"$@"}; shift; break ;;
1172
# save first non-option argument
1173
if test "$#" -gt 0; then
1179
test "$opt_debug" = : || func_append preserve_args " --debug"
1182
*cygwin* | *mingw* | *pw32* | *cegcc*)
1183
# don't eliminate duplications in $postdeps and $predeps
1184
opt_duplicate_compiler_generated_deps=:
1187
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1192
# Sanity checks first:
1193
func_check_version_match
1195
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1196
func_fatal_configuration "not configured to build any kind of library"
1200
eval std_shrext=\"$shrext_cmds\"
1202
# Only execute mode is allowed to have -dlopen flags.
1203
if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1204
func_error "unrecognized option \`-dlopen'"
1209
# Change the help message to a mode-specific one.
1210
generic_help="$help"
1211
help="Try \`$progname --help --mode=$opt_mode' for more information."
1215
# Bail if the options were screwed
1216
$exit_cmd $EXIT_FAILURE
1227
# True iff FILE is a libtool `.la' library or `.lo' object file.
1228
# This function is only a basic sanity check; it will hardly flush out
1229
# determined imposters.
1233
$SED -e 4q "$1" 2>/dev/null \
1234
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1237
# func_lalib_unsafe_p file
1238
# True iff FILE is a libtool `.la' library or `.lo' object file.
1239
# This function implements the same check as func_lalib_p without
1240
# resorting to external programs. To this end, it redirects stdin and
1241
# closes it afterwards, without saving the original file descriptor.
1242
# As a safety measure, use it only where a negative result would be
1243
# fatal anyway. Works if `file' does not exist.
1244
func_lalib_unsafe_p ()
1247
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1248
for lalib_p_l in 1 2 3 4
1251
case "$lalib_p_line" in
1252
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1257
test "$lalib_p" = yes
1260
# func_ltwrapper_script_p file
1261
# True iff FILE is a libtool wrapper script
1262
# This function is only a basic sanity check; it will hardly flush out
1263
# determined imposters.
1264
func_ltwrapper_script_p ()
1269
# func_ltwrapper_executable_p file
1270
# True iff FILE is a libtool wrapper executable
1271
# This function is only a basic sanity check; it will hardly flush out
1272
# determined imposters.
1273
func_ltwrapper_executable_p ()
1275
func_ltwrapper_exec_suffix=
1278
*) func_ltwrapper_exec_suffix=.exe ;;
1280
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1283
# func_ltwrapper_scriptname file
1284
# Assumes file is an ltwrapper_executable
1285
# uses $file to determine the appropriate filename for a
1286
# temporary ltwrapper_script.
1287
func_ltwrapper_scriptname ()
1289
func_dirname_and_basename "$1" "" "."
1290
func_stripname '' '.exe' "$func_basename_result"
1291
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1294
# func_ltwrapper_p file
1295
# True iff FILE is a libtool wrapper script or wrapper executable
1296
# This function is only a basic sanity check; it will hardly flush out
1297
# determined imposters.
1300
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1304
# func_execute_cmds commands fail_cmd
1305
# Execute tilde-delimited COMMANDS.
1306
# If FAIL_CMD is given, eval that upon failure.
1307
# FAIL_CMD may read-access the current command in variable CMD!
1308
func_execute_cmds ()
1311
save_ifs=$IFS; IFS='~'
1315
func_show_eval "$cmd" "${2-:}"
1322
# Source FILE, adding directory component if necessary.
1323
# Note that it is not necessary on cygwin/mingw to append a dot to
1324
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1325
# behavior happens only for exec(3), not for open(2)! Also, sourcing
1326
# `FILE.' does not work on cygwin managed mounts.
1331
*/* | *\\*) . "$1" ;;
1337
# func_resolve_sysroot PATH
1338
# Replace a leading = in PATH with a sysroot. Store the result into
1339
# func_resolve_sysroot_result
1340
func_resolve_sysroot ()
1342
func_resolve_sysroot_result=$1
1343
case $func_resolve_sysroot_result in
1345
func_stripname '=' '' "$func_resolve_sysroot_result"
1346
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1351
# func_replace_sysroot PATH
1352
# If PATH begins with the sysroot, replace it with = and
1353
# store the result into func_replace_sysroot_result.
1354
func_replace_sysroot ()
1356
case "$lt_sysroot:$1" in
1358
func_stripname "$lt_sysroot" '' "$1"
1359
func_replace_sysroot_result="=$func_stripname_result"
1362
# Including no sysroot.
1363
func_replace_sysroot_result=$1
1368
# func_infer_tag arg
1369
# Infer tagged configuration to use if any are available and
1370
# if one wasn't chosen via the "--tag" command line option.
1371
# Only attempt this if the compiler in the base compile
1372
# command doesn't match the default compiler.
1373
# arg is usually of the form 'gcc ...'
1377
if test -n "$available_tags" && test -z "$tagname"; then
1380
func_append_quoted CC_quoted "$arg"
1382
CC_expanded=`func_echo_all $CC`
1383
CC_quoted_expanded=`func_echo_all $CC_quoted`
1385
# Blanks in the command may have been stripped by the calling shell,
1386
# but not from the CC environment variable when configure was run.
1387
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1389
# Blanks at the start of $base_compile will cause this to fail
1390
# if we don't check for them as well.
1392
for z in $available_tags; do
1393
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1394
# Evaluate the configuration.
1395
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1398
# Double-quote args containing other shell metacharacters.
1399
func_append_quoted CC_quoted "$arg"
1401
CC_expanded=`func_echo_all $CC`
1402
CC_quoted_expanded=`func_echo_all $CC_quoted`
1404
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1406
# The compiler in the base compile command matches
1407
# the one in the tagged configuration.
1408
# Assume this is the tagged configuration we want.
1415
# If $tagname still isn't set, then no tagged configuration
1416
# was found and let the user know that the "--tag" command
1417
# line option must be used.
1418
if test -z "$tagname"; then
1419
func_echo "unable to infer tagged configuration"
1420
func_fatal_error "specify a tag with \`--tag'"
1422
# func_verbose "using $tagname tagged configuration"
1431
# func_write_libtool_object output_name pic_name nonpic_name
1432
# Create a libtool object file (analogous to a ".la" file),
1433
# but don't create it if we're doing a dry run.
1434
func_write_libtool_object ()
1437
if test "$build_libtool_libs" = yes; then
1443
if test "$build_old_libs" = yes; then
1444
write_oldobj=\'${3}\'
1450
cat >${write_libobj}T <<EOF
1451
# $write_libobj - a libtool object file
1452
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454
# Please DO NOT delete this file!
1455
# It is necessary for linking the library.
1457
# Name of the PIC object.
1458
pic_object=$write_lobj
1460
# Name of the non-PIC object
1461
non_pic_object=$write_oldobj
1464
$MV "${write_libobj}T" "${write_libobj}"
1469
##################################################
1470
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1471
##################################################
1473
# func_convert_core_file_wine_to_w32 ARG
1474
# Helper function used by file name conversion functions when $build is *nix,
1475
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
1476
# correctly configured wine environment available, with the winepath program
1477
# in $build's $PATH.
1479
# ARG is the $build file name to be converted to w32 format.
1480
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
1481
# be empty on error (or when ARG is empty)
1482
func_convert_core_file_wine_to_w32 ()
1485
func_convert_core_file_wine_to_w32_result="$1"
1486
if test -n "$1"; then
1487
# Unfortunately, winepath does not exit with a non-zero error code, so we
1488
# are forced to check the contents of stdout. On the other hand, if the
1489
# command is not found, the shell will set an exit code of 127 and print
1490
# *an error message* to stdout. So we must check for both error code of
1491
# zero AND non-empty stdout, which explains the odd construction:
1492
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1493
if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1494
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1495
$SED -e "$lt_sed_naive_backslashify"`
1497
func_convert_core_file_wine_to_w32_result=
1501
# end: func_convert_core_file_wine_to_w32
1504
# func_convert_core_path_wine_to_w32 ARG
1505
# Helper function used by path conversion functions when $build is *nix, and
1506
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1507
# configured wine environment available, with the winepath program in $build's
1508
# $PATH. Assumes ARG has no leading or trailing path separator characters.
1510
# ARG is path to be converted from $build format to win32.
1511
# Result is available in $func_convert_core_path_wine_to_w32_result.
1512
# Unconvertible file (directory) names in ARG are skipped; if no directory names
1513
# are convertible, then the result may be empty.
1514
func_convert_core_path_wine_to_w32 ()
1517
# unfortunately, winepath doesn't convert paths, only file names
1518
func_convert_core_path_wine_to_w32_result=""
1519
if test -n "$1"; then
1522
for func_convert_core_path_wine_to_w32_f in $1; do
1524
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1525
if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1526
if test -z "$func_convert_core_path_wine_to_w32_result"; then
1527
func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1536
# end: func_convert_core_path_wine_to_w32
1539
# func_cygpath ARGS...
1540
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1541
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1542
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1543
# (2), returns the Cygwin file name or path in func_cygpath_result (input
1544
# file name or path is assumed to be in w32 format, as previously converted
1545
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
1546
# or path in func_cygpath_result (input file name or path is assumed to be in
1547
# Cygwin format). Returns an empty string on error.
1549
# ARGS are passed to cygpath, with the last one being the file name or path to
1552
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1553
# environment variable; do not put it in $PATH.
1557
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1558
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1559
if test "$?" -ne 0; then
1560
# on failure, ensure result is empty
1561
func_cygpath_result=
1564
func_cygpath_result=
1565
func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1571
# func_convert_core_msys_to_w32 ARG
1572
# Convert file name or path ARG from MSYS format to w32 format. Return
1573
# result in func_convert_core_msys_to_w32_result.
1574
func_convert_core_msys_to_w32 ()
1577
# awkward: cmd appends spaces to result
1578
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1579
$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581
#end: func_convert_core_msys_to_w32
1584
# func_convert_file_check ARG1 ARG2
1585
# Verify that ARG1 (a file name in $build format) was converted to $host
1586
# format in ARG2. Otherwise, emit an error message, but continue (resetting
1587
# func_to_host_file_result to ARG1).
1588
func_convert_file_check ()
1591
if test -z "$2" && test -n "$1" ; then
1592
func_error "Could not determine host file name corresponding to"
1594
func_error "Continuing, but uninstalled executables may not work."
1596
func_to_host_file_result="$1"
1599
# end func_convert_file_check
1602
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1603
# Verify that FROM_PATH (a path in $build format) was converted to $host
1604
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1605
# func_to_host_file_result to a simplistic fallback value (see below).
1606
func_convert_path_check ()
1609
if test -z "$4" && test -n "$3"; then
1610
func_error "Could not determine the host path corresponding to"
1612
func_error "Continuing, but uninstalled executables may not work."
1613
# Fallback. This is a deliberately simplistic "conversion" and
1614
# should not be "improved". See libtool.info.
1615
if test "x$1" != "x$2"; then
1616
lt_replace_pathsep_chars="s|$1|$2|g"
1617
func_to_host_path_result=`echo "$3" |
1618
$SED -e "$lt_replace_pathsep_chars"`
1620
func_to_host_path_result="$3"
1624
# end func_convert_path_check
1627
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1628
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1629
# and appending REPL if ORIG matches BACKPAT.
1630
func_convert_path_front_back_pathsep ()
1634
$1 ) func_to_host_path_result="$3$func_to_host_path_result"
1638
$2 ) func_append func_to_host_path_result "$3"
1642
# end func_convert_path_front_back_pathsep
1645
##################################################
1646
# $build to $host FILE NAME CONVERSION FUNCTIONS #
1647
##################################################
1648
# invoked via `$to_host_file_cmd ARG'
1650
# In each case, ARG is the path to be converted from $build to $host format.
1651
# Result will be available in $func_to_host_file_result.
1654
# func_to_host_file ARG
1655
# Converts the file name ARG from $build format to $host format. Return result
1656
# in func_to_host_file_result.
1657
func_to_host_file ()
1660
$to_host_file_cmd "$1"
1662
# end func_to_host_file
1665
# func_to_tool_file ARG LAZY
1666
# converts the file name ARG from $build format to toolchain format. Return
1667
# result in func_to_tool_file_result. If the conversion in use is listed
1668
# in (the comma separated) LAZY, no conversion takes place.
1669
func_to_tool_file ()
1673
*,"$to_tool_file_cmd",*)
1674
func_to_tool_file_result=$1
1677
$to_tool_file_cmd "$1"
1678
func_to_tool_file_result=$func_to_host_file_result
1682
# end func_to_tool_file
1685
# func_convert_file_noop ARG
1686
# Copy ARG to func_to_host_file_result.
1687
func_convert_file_noop ()
1689
func_to_host_file_result="$1"
1691
# end func_convert_file_noop
1694
# func_convert_file_msys_to_w32 ARG
1695
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1696
# conversion to w32 is not available inside the cwrapper. Returns result in
1697
# func_to_host_file_result.
1698
func_convert_file_msys_to_w32 ()
1701
func_to_host_file_result="$1"
1702
if test -n "$1"; then
1703
func_convert_core_msys_to_w32 "$1"
1704
func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706
func_convert_file_check "$1" "$func_to_host_file_result"
1708
# end func_convert_file_msys_to_w32
1711
# func_convert_file_cygwin_to_w32 ARG
1712
# Convert file name ARG from Cygwin to w32 format. Returns result in
1713
# func_to_host_file_result.
1714
func_convert_file_cygwin_to_w32 ()
1717
func_to_host_file_result="$1"
1718
if test -n "$1"; then
1719
# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1720
# LT_CYGPATH in this case.
1721
func_to_host_file_result=`cygpath -m "$1"`
1723
func_convert_file_check "$1" "$func_to_host_file_result"
1725
# end func_convert_file_cygwin_to_w32
1728
# func_convert_file_nix_to_w32 ARG
1729
# Convert file name ARG from *nix to w32 format. Requires a wine environment
1730
# and a working winepath. Returns result in func_to_host_file_result.
1731
func_convert_file_nix_to_w32 ()
1734
func_to_host_file_result="$1"
1735
if test -n "$1"; then
1736
func_convert_core_file_wine_to_w32 "$1"
1737
func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739
func_convert_file_check "$1" "$func_to_host_file_result"
1741
# end func_convert_file_nix_to_w32
1744
# func_convert_file_msys_to_cygwin ARG
1745
# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1746
# Returns result in func_to_host_file_result.
1747
func_convert_file_msys_to_cygwin ()
1750
func_to_host_file_result="$1"
1751
if test -n "$1"; then
1752
func_convert_core_msys_to_w32 "$1"
1753
func_cygpath -u "$func_convert_core_msys_to_w32_result"
1754
func_to_host_file_result="$func_cygpath_result"
1756
func_convert_file_check "$1" "$func_to_host_file_result"
1758
# end func_convert_file_msys_to_cygwin
1761
# func_convert_file_nix_to_cygwin ARG
1762
# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1763
# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1764
# in func_to_host_file_result.
1765
func_convert_file_nix_to_cygwin ()
1768
func_to_host_file_result="$1"
1769
if test -n "$1"; then
1770
# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1771
func_convert_core_file_wine_to_w32 "$1"
1772
func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1773
func_to_host_file_result="$func_cygpath_result"
1775
func_convert_file_check "$1" "$func_to_host_file_result"
1777
# end func_convert_file_nix_to_cygwin
1780
#############################################
1781
# $build to $host PATH CONVERSION FUNCTIONS #
1782
#############################################
1783
# invoked via `$to_host_path_cmd ARG'
1785
# In each case, ARG is the path to be converted from $build to $host format.
1786
# The result will be available in $func_to_host_path_result.
1788
# Path separators are also converted from $build format to $host format. If
1789
# ARG begins or ends with a path separator character, it is preserved (but
1790
# converted to $host format) on output.
1792
# All path conversion functions are named using the following convention:
1793
# file name conversion function : func_convert_file_X_to_Y ()
1794
# path conversion function : func_convert_path_X_to_Y ()
1795
# where, for any given $build/$host combination the 'X_to_Y' value is the
1796
# same. If conversion functions are added for new $build/$host combinations,
1797
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
1801
# func_init_to_host_path_cmd
1802
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
1803
# appropriate value, based on the value of $to_host_file_cmd.
1805
func_init_to_host_path_cmd ()
1808
if test -z "$to_host_path_cmd"; then
1809
func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1810
to_host_path_cmd="func_convert_path_${func_stripname_result}"
1815
# func_to_host_path ARG
1816
# Converts the path ARG from $build format to $host format. Return result
1817
# in func_to_host_path_result.
1818
func_to_host_path ()
1821
func_init_to_host_path_cmd
1822
$to_host_path_cmd "$1"
1824
# end func_to_host_path
1827
# func_convert_path_noop ARG
1828
# Copy ARG to func_to_host_path_result.
1829
func_convert_path_noop ()
1831
func_to_host_path_result="$1"
1833
# end func_convert_path_noop
1836
# func_convert_path_msys_to_w32 ARG
1837
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1838
# conversion to w32 is not available inside the cwrapper. Returns result in
1839
# func_to_host_path_result.
1840
func_convert_path_msys_to_w32 ()
1843
func_to_host_path_result="$1"
1844
if test -n "$1"; then
1845
# Remove leading and trailing path separator characters from ARG. MSYS
1846
# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1847
# and winepath ignores them completely.
1848
func_stripname : : "$1"
1849
func_to_host_path_tmp1=$func_stripname_result
1850
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1851
func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1852
func_convert_path_check : ";" \
1853
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1854
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1857
# end func_convert_path_msys_to_w32
1860
# func_convert_path_cygwin_to_w32 ARG
1861
# Convert path ARG from Cygwin to w32 format. Returns result in
1862
# func_to_host_file_result.
1863
func_convert_path_cygwin_to_w32 ()
1866
func_to_host_path_result="$1"
1867
if test -n "$1"; then
1868
# See func_convert_path_msys_to_w32:
1869
func_stripname : : "$1"
1870
func_to_host_path_tmp1=$func_stripname_result
1871
func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1872
func_convert_path_check : ";" \
1873
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1874
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1877
# end func_convert_path_cygwin_to_w32
1880
# func_convert_path_nix_to_w32 ARG
1881
# Convert path ARG from *nix to w32 format. Requires a wine environment and
1882
# a working winepath. Returns result in func_to_host_file_result.
1883
func_convert_path_nix_to_w32 ()
1886
func_to_host_path_result="$1"
1887
if test -n "$1"; then
1888
# See func_convert_path_msys_to_w32:
1889
func_stripname : : "$1"
1890
func_to_host_path_tmp1=$func_stripname_result
1891
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1892
func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1893
func_convert_path_check : ";" \
1894
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1895
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1898
# end func_convert_path_nix_to_w32
1901
# func_convert_path_msys_to_cygwin ARG
1902
# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1903
# Returns result in func_to_host_file_result.
1904
func_convert_path_msys_to_cygwin ()
1907
func_to_host_path_result="$1"
1908
if test -n "$1"; then
1909
# See func_convert_path_msys_to_w32:
1910
func_stripname : : "$1"
1911
func_to_host_path_tmp1=$func_stripname_result
1912
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1913
func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1914
func_to_host_path_result="$func_cygpath_result"
1915
func_convert_path_check : : \
1916
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1917
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1920
# end func_convert_path_msys_to_cygwin
1923
# func_convert_path_nix_to_cygwin ARG
1924
# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1925
# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1926
# func_to_host_file_result.
1927
func_convert_path_nix_to_cygwin ()
1930
func_to_host_path_result="$1"
1931
if test -n "$1"; then
1932
# Remove leading and trailing path separator characters from
1933
# ARG. msys behavior is inconsistent here, cygpath turns them
1934
# into '.;' and ';.', and winepath ignores them completely.
1935
func_stripname : : "$1"
1936
func_to_host_path_tmp1=$func_stripname_result
1937
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1938
func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1939
func_to_host_path_result="$func_cygpath_result"
1940
func_convert_path_check : : \
1941
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1942
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1945
# end func_convert_path_nix_to_cygwin
1948
# func_mode_compile arg...
1949
func_mode_compile ()
1952
# Get the compilation command and the source file.
1954
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1966
# do not "continue". Instead, add this to base_compile
1978
# Accept any command-line options.
1981
test -n "$libobj" && \
1982
func_fatal_error "you cannot specify \`-o' more than once"
1987
-pie | -fpie | -fPIE)
1988
func_append pie_flag " $arg"
1992
-shared | -static | -prefer-pic | -prefer-non-pic)
1993
func_append later " $arg"
2003
arg_mode=arg # the next one goes into the "base_compile" arg list
2004
continue # The current "srcfile" will either be retained or
2005
;; # replaced later. I would guess that would be a bug.
2008
func_stripname '-Wc,' '' "$arg"
2009
args=$func_stripname_result
2011
save_ifs="$IFS"; IFS=','
2012
for arg in $args; do
2014
func_append_quoted lastarg "$arg"
2017
func_stripname ' ' '' "$lastarg"
2018
lastarg=$func_stripname_result
2020
# Add the arguments to base_compile.
2021
func_append base_compile " $lastarg"
2026
# Accept the current argument as the source file.
2027
# The previous "srcfile" becomes the current argument.
2034
esac # case $arg_mode
2036
# Aesthetically quote the previous argument.
2037
func_append_quoted base_compile "$lastarg"
2042
func_fatal_error "you must specify an argument for -Xcompile"
2045
func_fatal_error "you must specify a target with \`-o'"
2048
# Get the name of the library object.
2049
test -z "$libobj" && {
2050
func_basename "$srcfile"
2051
libobj="$func_basename_result"
2056
# Recognize several different file suffixes.
2057
# If the user specifies -o file.o, it is replaced with file.lo
2060
*.ada | *.adb | *.ads | *.asm | \
2061
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2062
*.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
2063
func_xform "$libobj"
2064
libobj=$func_xform_result
2069
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071
func_fatal_error "cannot determine name of library object from \`$libobj'"
2075
func_infer_tag $base_compile
2077
for arg in $later; do
2080
test "$build_libtool_libs" != yes && \
2081
func_fatal_configuration "can not build a shared library"
2087
build_libtool_libs=no
2104
func_quote_for_eval "$libobj"
2105
test "X$libobj" != "X$func_quote_for_eval_result" \
2106
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2107
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
2108
func_dirname_and_basename "$obj" "/" ""
2109
objname="$func_basename_result"
2110
xdir="$func_dirname_result"
2111
lobj=${xdir}$objdir/$objname
2113
test -z "$base_compile" && \
2114
func_fatal_help "you must specify a compilation command"
2116
# Delete any leftover library objects.
2117
if test "$build_old_libs" = yes; then
2118
removelist="$obj $lobj $libobj ${libobj}T"
2120
removelist="$lobj $libobj ${libobj}T"
2123
# On Cygwin there's no "real" PIC flag so we must build both object types
2125
cygwin* | mingw* | pw32* | os2* | cegcc*)
2129
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2130
# non-PIC code in shared libraries is not supported
2134
# Calculate the filename of the output object if compiler does
2135
# not support -o with -c
2136
if test "$compiler_c_o" = no; then
2137
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2138
lockfile="$output_obj.lock"
2145
# Lock this critical section if it is needed
2146
# We use this script file to make the link, it avoids creating a new file
2147
if test "$need_locks" = yes; then
2148
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2149
func_echo "Waiting for $lockfile to be removed"
2152
elif test "$need_locks" = warn; then
2153
if test -f "$lockfile"; then
2155
*** ERROR, $lockfile exists and contains:
2156
`cat $lockfile 2>/dev/null`
2158
This indicates that another process is trying to use the same
2159
temporary object file, and libtool could not work around it because
2160
your compiler does not support \`-c' and \`-o' together. If you
2161
repeat this compilation, it may succeed, by chance, but you had better
2162
avoid parallel builds (make -j) in this platform, or get a better
2165
$opt_dry_run || $RM $removelist
2168
func_append removelist " $output_obj"
2169
$ECHO "$srcfile" > "$lockfile"
2172
$opt_dry_run || $RM $removelist
2173
func_append removelist " $lockfile"
2174
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177
srcfile=$func_to_tool_file_result
2178
func_quote_for_eval "$srcfile"
2179
qsrcfile=$func_quote_for_eval_result
2181
# Only build a PIC object if we are building libtool libraries.
2182
if test "$build_libtool_libs" = yes; then
2183
# Without this assignment, base_compile gets emptied.
2184
fbsd_hideous_sh_bug=$base_compile
2186
if test "$pic_mode" != no; then
2187
command="$base_compile $qsrcfile $pic_flag"
2189
# Don't build PIC code
2190
command="$base_compile $qsrcfile"
2193
func_mkdir_p "$xdir$objdir"
2195
if test -z "$output_obj"; then
2196
# Place PIC objects in $objdir
2197
func_append command " -o $lobj"
2200
func_show_eval_locale "$command" \
2201
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203
if test "$need_locks" = warn &&
2204
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206
*** ERROR, $lockfile contains:
2207
`cat $lockfile 2>/dev/null`
2209
but it should contain:
2212
This indicates that another process is trying to use the same
2213
temporary object file, and libtool could not work around it because
2214
your compiler does not support \`-c' and \`-o' together. If you
2215
repeat this compilation, it may succeed, by chance, but you had better
2216
avoid parallel builds (make -j) in this platform, or get a better
2219
$opt_dry_run || $RM $removelist
2223
# Just move the object if needed, then go on to compile the next one
2224
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2225
func_show_eval '$MV "$output_obj" "$lobj"' \
2226
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2229
# Allow error messages only from the first compilation.
2230
if test "$suppress_opt" = yes; then
2231
suppress_output=' >/dev/null 2>&1'
2235
# Only build a position-dependent object if we build old libraries.
2236
if test "$build_old_libs" = yes; then
2237
if test "$pic_mode" != yes; then
2238
# Don't build PIC code
2239
command="$base_compile $qsrcfile$pie_flag"
2241
command="$base_compile $qsrcfile $pic_flag"
2243
if test "$compiler_c_o" = yes; then
2244
func_append command " -o $obj"
2247
# Suppress compiler output if we already did a PIC compilation.
2248
func_append command "$suppress_output"
2249
func_show_eval_locale "$command" \
2250
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252
if test "$need_locks" = warn &&
2253
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255
*** ERROR, $lockfile contains:
2256
`cat $lockfile 2>/dev/null`
2258
but it should contain:
2261
This indicates that another process is trying to use the same
2262
temporary object file, and libtool could not work around it because
2263
your compiler does not support \`-c' and \`-o' together. If you
2264
repeat this compilation, it may succeed, by chance, but you had better
2265
avoid parallel builds (make -j) in this platform, or get a better
2268
$opt_dry_run || $RM $removelist
2272
# Just move the object if needed
2273
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2274
func_show_eval '$MV "$output_obj" "$obj"' \
2275
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2280
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282
# Unlock the critical section if it was locked
2283
if test "$need_locks" != no; then
2284
removelist=$lockfile
2293
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2298
# We need to display help for each of the modes.
2301
# Generic help is extracted from the usage comments
2302
# at the start of this file.
2308
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310
Remove files from the build directory.
2312
RM is the name of the program to use to delete files associated with each FILE
2313
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2316
If FILE is a libtool library, object or program, all the files associated
2317
with it are deleted. Otherwise, only FILE itself is deleted using RM."
2322
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324
Compile a source file into a libtool library object.
2326
This mode accepts the following additional options:
2328
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
2329
-no-suppress do not suppress compiler output for multiple passes
2330
-prefer-pic try to build PIC objects only
2331
-prefer-non-pic try to build non-PIC objects only
2332
-shared do not build a \`.o' file suitable for static linking
2333
-static only build a \`.o' file suitable for static linking
2334
-Wc,FLAG pass FLAG directly to the compiler
2336
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2337
from the given SOURCEFILE.
2339
The output file name is determined by removing the directory component from
2340
SOURCEFILE, then substituting the C source code suffix \`.c' with the
2341
library object suffix, \`.lo'."
2346
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348
Automatically set library path, then run a program.
2350
This mode accepts the following additional options:
2352
-dlopen FILE add the directory containing FILE to the library path
2354
This mode sets the library path environment variable according to \`-dlopen'
2357
If any of the ARGS are libtool executable wrappers, then they are translated
2358
into their corresponding uninstalled binary, and any of their required library
2359
directories are added to the library path.
2361
Then, COMMAND is executed, with ARGS as arguments."
2366
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368
Complete the installation of libtool libraries.
2370
Each LIBDIR is a directory that contains libtool libraries.
2372
The commands that this mode executes may require superuser privileges. Use
2373
the \`--dry-run' option if you just want to see what would be executed."
2378
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380
Install executables or libraries.
2382
INSTALL-COMMAND is the installation command. The first component should be
2383
either the \`install' or \`cp' program.
2385
The following components of INSTALL-COMMAND are treated specially:
2387
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2389
The rest of the components are interpreted as arguments to that command (only
2390
BSD-compatible install options are recognized)."
2395
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397
Link object files or libraries together to form another library, or to
2398
create an executable program.
2400
LINK-COMMAND is a command using the C compiler that you would use to create
2401
a program from several object files.
2403
The following components of LINK-COMMAND are treated specially:
2405
-all-static do not do any dynamic linking at all
2406
-avoid-version do not add a version suffix if possible
2407
-bindir BINDIR specify path to binaries directory (for systems where
2408
libraries must be found in the PATH setting at runtime)
2409
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2410
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2411
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2412
-export-symbols SYMFILE
2413
try to export only the symbols listed in SYMFILE
2414
-export-symbols-regex REGEX
2415
try to export only the symbols matching REGEX
2416
-LLIBDIR search LIBDIR for required installed libraries
2417
-lNAME OUTPUT-FILE requires the installed library libNAME
2418
-module build a library that can dlopened
2419
-no-fast-install disable the fast-install mode
2420
-no-install link a not-installable executable
2421
-no-undefined declare that a library does not refer to external symbols
2422
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2423
-objectlist FILE Use a list of object files found in FILE to specify objects
2424
-precious-files-regex REGEX
2425
don't remove output files matching REGEX
2426
-release RELEASE specify package release information
2427
-rpath LIBDIR the created library will eventually be installed in LIBDIR
2428
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2429
-shared only do dynamic linking of libtool libraries
2430
-shrext SUFFIX override the standard shared library file extension
2431
-static do not do any dynamic linking of uninstalled libtool libraries
2432
-static-libtool-libs
2433
do not do any dynamic linking of libtool libraries
2434
-version-info CURRENT[:REVISION[:AGE]]
2435
specify library version info [each variable defaults to 0]
2436
-weak LIBNAME declare that the target provides the LIBNAME interface
2438
-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2440
-Xlinker FLAG pass linker-specific FLAG directly to the linker
2441
-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2443
All other options (arguments beginning with \`-') are ignored.
2445
Every other argument is treated as a filename. Files ending in \`.la' are
2446
treated as uninstalled libtool libraries, other files are standard or library
2449
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2450
only library objects (\`.lo' files) may be specified, and \`-rpath' is
2451
required, except when creating a convenience library.
2453
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2454
using \`ar' and \`ranlib', or on Windows using \`lib'.
2456
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2457
is created, otherwise an executable program is created."
2462
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464
Remove libraries from an installation directory.
2466
RM is the name of the program to use to delete files associated with each FILE
2467
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2470
If FILE is a libtool library, all the files associated with it are deleted.
2471
Otherwise, only FILE itself is deleted using RM."
2475
func_fatal_help "invalid operation mode \`$opt_mode'"
2480
$ECHO "Try \`$progname --help' for more information about other modes."
2483
# Now that we've collected a possible --mode arg, show help if necessary
2485
if test "$opt_help" = :; then
2490
for opt_mode in compile link execute install finish uninstall clean; do
2493
} | sed -n '1p; 2,$s/^Usage:/ or: /p'
2496
for opt_mode in compile link execute install finish uninstall clean; do
2502
/^When reporting/,/^Report/{
2507
/information about other modes/d
2508
/more detailed .*MODE/d
2509
s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2515
# func_mode_execute arg...
2516
func_mode_execute ()
2519
# The first argument is the command name.
2522
func_fatal_help "you must specify a COMMAND"
2524
# Handle -dlopen flags immediately.
2525
for file in $opt_dlopen; do
2527
|| func_fatal_help "\`$file' is not a file"
2532
func_resolve_sysroot "$file"
2533
file=$func_resolve_sysroot_result
2535
# Check to see that this really is a libtool archive.
2536
func_lalib_unsafe_p "$file" \
2537
|| func_fatal_help "\`$lib' is not a valid libtool archive"
2539
# Read the libtool library.
2544
# Skip this library if it cannot be dlopened.
2545
if test -z "$dlname"; then
2546
# Warn if it was a shared library.
2547
test -n "$library_names" && \
2548
func_warning "\`$file' was not linked with \`-export-dynamic'"
2552
func_dirname "$file" "" "."
2553
dir="$func_dirname_result"
2555
if test -f "$dir/$objdir/$dlname"; then
2556
func_append dir "/$objdir"
2558
if test ! -f "$dir/$dlname"; then
2559
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2565
# Just add the directory containing the .lo file.
2566
func_dirname "$file" "" "."
2567
dir="$func_dirname_result"
2571
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2576
# Get the absolute pathname.
2577
absdir=`cd "$dir" && pwd`
2578
test -n "$absdir" && dir="$absdir"
2580
# Now add the directory to shlibpath_var.
2581
if eval "test -z \"\$$shlibpath_var\""; then
2582
eval "$shlibpath_var=\"\$dir\""
2584
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2588
# This variable tells wrapper scripts just to set shlibpath_var
2589
# rather than running their programs.
2590
libtool_execute_magic="$magic"
2592
# Check if any of the arguments is a wrapper script.
2597
-* | *.la | *.lo ) ;;
2599
# Do a test to see if this is really a libtool program.
2600
if func_ltwrapper_script_p "$file"; then
2602
# Transform arg to wrapped name.
2603
file="$progdir/$program"
2604
elif func_ltwrapper_executable_p "$file"; then
2605
func_ltwrapper_scriptname "$file"
2606
func_source "$func_ltwrapper_scriptname_result"
2607
# Transform arg to wrapped name.
2608
file="$progdir/$program"
2612
# Quote arguments (to preserve shell metacharacters).
2613
func_append_quoted args "$file"
2616
if test "X$opt_dry_run" = Xfalse; then
2617
if test -n "$shlibpath_var"; then
2618
# Export the shlibpath_var.
2619
eval "export $shlibpath_var"
2622
# Restore saved environment variables
2623
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625
eval "if test \"\${save_$lt_var+set}\" = set; then
2626
$lt_var=\$save_$lt_var; export $lt_var
2632
# Now prepare to actually exec the command.
2633
exec_cmd="\$cmd$args"
2635
# Display what would be done.
2636
if test -n "$shlibpath_var"; then
2637
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2638
echo "export $shlibpath_var"
2645
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2648
# func_mode_finish arg...
2656
for opt in "$nonopt" ${1+"$@"}
2658
if test -d "$opt"; then
2659
func_append libdirs " $opt"
2661
elif test -f "$opt"; then
2662
if func_lalib_unsafe_p "$opt"; then
2663
func_append libs " $opt"
2665
func_warning "\`$opt' is not a valid libtool archive"
2669
func_fatal_error "invalid argument \`$opt'"
2673
if test -n "$libs"; then
2674
if test -n "$lt_sysroot"; then
2675
sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2676
sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2681
# Remove sysroot references
2682
if $opt_dry_run; then
2683
for lib in $libs; do
2684
echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2687
tmpdir=`func_mktempdir`
2688
for lib in $libs; do
2689
sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691
mv -f $tmpdir/tmp-la $lib
2697
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2698
for libdir in $libdirs; do
2699
if test -n "$finish_cmds"; then
2700
# Do each command in the finish commands.
2701
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2704
if test -n "$finish_eval"; then
2705
# Do the single finish_eval.
2706
eval cmds=\"$finish_eval\"
2707
$opt_dry_run || eval "$cmds" || func_append admincmds "
2713
# Exit here if they wanted silent mode.
2714
$opt_silent && exit $EXIT_SUCCESS
2716
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2717
echo "----------------------------------------------------------------------"
2718
echo "Libraries have been installed in:"
2719
for libdir in $libdirs; do
2723
echo "If you ever happen to want to link against installed libraries"
2724
echo "in a given directory, LIBDIR, you must either use libtool, and"
2725
echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2726
echo "flag during linking and do at least one of the following:"
2727
if test -n "$shlibpath_var"; then
2728
echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2729
echo " during execution"
2731
if test -n "$runpath_var"; then
2732
echo " - add LIBDIR to the \`$runpath_var' environment variable"
2733
echo " during linking"
2735
if test -n "$hardcode_libdir_flag_spec"; then
2737
eval flag=\"$hardcode_libdir_flag_spec\"
2739
$ECHO " - use the \`$flag' linker flag"
2741
if test -n "$admincmds"; then
2742
$ECHO " - have your system administrator run these commands:$admincmds"
2744
if test -f /etc/ld.so.conf; then
2745
echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2749
echo "See any operating system documentation about shared libraries for"
2751
solaris2.[6789]|solaris2.1[0-9])
2752
echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2756
echo "more information, such as the ld(1) and ld.so(8) manual pages."
2759
echo "----------------------------------------------------------------------"
2764
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2767
# func_mode_install arg...
2768
func_mode_install ()
2771
# There may be an optional sh(1) argument at the beginning of
2772
# install_prog (especially on Windows NT).
2773
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2774
# Allow the use of GNU shtool's install command.
2775
case $nonopt in *shtool*) :;; *) false;; esac; then
2776
# Aesthetically quote it.
2777
func_quote_for_eval "$nonopt"
2778
install_prog="$func_quote_for_eval_result "
2786
# The real first argument should be the name of the installation program.
2787
# Aesthetically quote it.
2788
func_quote_for_eval "$arg"
2789
func_append install_prog "$func_quote_for_eval_result"
2790
install_shared_prog=$install_prog
2791
case " $install_prog " in
2792
*[\\\ /]cp\ *) install_cp=: ;;
2793
*) install_cp=false ;;
2796
# We need to accept at least all the BSD install flags.
2808
if test -n "$dest"; then
2809
func_append files " $dest"
2817
if $install_cp; then :; else
2831
# If the previous option needed an argument, then skip it.
2832
if test -n "$prev"; then
2833
if test "x$prev" = x-m && test -n "$install_override_mode"; then
2834
arg2=$install_override_mode
2845
# Aesthetically quote the argument.
2846
func_quote_for_eval "$arg"
2847
func_append install_prog " $func_quote_for_eval_result"
2848
if test -n "$arg2"; then
2849
func_quote_for_eval "$arg2"
2851
func_append install_shared_prog " $func_quote_for_eval_result"
2854
test -z "$install_prog" && \
2855
func_fatal_help "you must specify an install program"
2857
test -n "$prev" && \
2858
func_fatal_help "the \`$prev' option requires an argument"
2860
if test -n "$install_override_mode" && $no_mode; then
2861
if $install_cp; then :; else
2862
func_quote_for_eval "$install_override_mode"
2863
func_append install_shared_prog " -m $func_quote_for_eval_result"
2867
if test -z "$files"; then
2868
if test -z "$dest"; then
2869
func_fatal_help "no file or destination specified"
2871
func_fatal_help "you must specify a destination"
2875
# Strip any trailing slash from the destination.
2876
func_stripname '' '/' "$dest"
2877
dest=$func_stripname_result
2879
# Check to see that the destination is a directory.
2880
test -d "$dest" && isdir=yes
2881
if test "$isdir" = yes; then
2885
func_dirname_and_basename "$dest" "" "."
2886
destdir="$func_dirname_result"
2887
destname="$func_basename_result"
2889
# Not a directory, so check to see that there is only one file specified.
2890
set dummy $files; shift
2891
test "$#" -gt 1 && \
2892
func_fatal_help "\`$dest' is not a directory"
2895
[\\/]* | [A-Za-z]:[\\/]*) ;;
2897
for file in $files; do
2901
func_fatal_help "\`$destdir' must be an absolute directory name"
2908
# This variable tells wrapper scripts just to set variables rather
2909
# than running their programs.
2910
libtool_install_magic="$magic"
2915
for file in $files; do
2917
# Do each installation.
2920
# Do the static libraries later.
2921
func_append staticlibs " $file"
2925
func_resolve_sysroot "$file"
2926
file=$func_resolve_sysroot_result
2928
# Check to see that this really is a libtool archive.
2929
func_lalib_unsafe_p "$file" \
2930
|| func_fatal_help "\`$file' is not a valid libtool archive"
2937
# Add the libdir to current_libdirs if it is the destination.
2938
if test "X$destdir" = "X$libdir"; then
2939
case "$current_libdirs " in
2941
*) func_append current_libdirs " $libdir" ;;
2944
# Note the libdir as a future libdir.
2945
case "$future_libdirs " in
2947
*) func_append future_libdirs " $libdir" ;;
2951
func_dirname "$file" "/" ""
2952
dir="$func_dirname_result"
2953
func_append dir "$objdir"
2955
if test -n "$relink_command"; then
2956
# Determine the prefix the user has applied to our future dir.
2957
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959
# Don't allow the user to place us outside of our expected
2960
# location b/c this prevents finding dependent libraries that
2961
# are installed to the same prefix.
2962
# At present, this check doesn't affect windows .dll's that
2963
# are installed into $libdir/../bin (currently, that works fine)
2964
# but it's something to keep an eye on.
2965
test "$inst_prefix_dir" = "$destdir" && \
2966
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968
if test -n "$inst_prefix_dir"; then
2969
# Stick the inst_prefix_dir data into the link command.
2970
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2975
func_warning "relinking \`$file'"
2976
func_show_eval "$relink_command" \
2977
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2980
# See the names of the shared library.
2981
set dummy $library_names; shift
2982
if test -n "$1"; then
2987
test -n "$relink_command" && srcname="$realname"T
2989
# Install the shared library and build the symlinks.
2990
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2994
cygwin* | mingw* | pw32* | cegcc*)
3002
if test -n "$tstripme" && test -n "$striplib"; then
3003
func_show_eval "$striplib $destdir/$realname" 'exit $?'
3006
if test "$#" -gt 0; then
3007
# Delete the old symlinks, and create new ones.
3008
# Try `ln -sf' first, because the `ln' binary might depend on
3009
# the symlink we replace! Solaris /bin/ln does not understand -f,
3010
# so we also need to try rm && ln -s.
3013
test "$linkname" != "$realname" \
3014
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3018
# Do each command in the postinstall commands.
3019
lib="$destdir/$realname"
3020
func_execute_cmds "$postinstall_cmds" 'exit $?'
3023
# Install the pseudo-library for information purposes.
3024
func_basename "$file"
3025
name="$func_basename_result"
3026
instname="$dir/$name"i
3027
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029
# Maybe install the static library, too.
3030
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3034
# Install (i.e. copy) a libtool object.
3036
# Figure out destination file name, if it wasn't already specified.
3037
if test -n "$destname"; then
3038
destfile="$destdir/$destname"
3040
func_basename "$file"
3041
destfile="$func_basename_result"
3042
destfile="$destdir/$destfile"
3045
# Deduce the name of the destination old-style object file.
3048
func_lo2o "$destfile"
3049
staticdest=$func_lo2o_result
3052
staticdest="$destfile"
3056
func_fatal_help "cannot copy a libtool object to \`$destfile'"
3060
# Install the libtool object if requested.
3061
test -n "$destfile" && \
3062
func_show_eval "$install_prog $file $destfile" 'exit $?'
3064
# Install the old object if enabled.
3065
if test "$build_old_libs" = yes; then
3066
# Deduce the name of the old-style object file.
3068
staticobj=$func_lo2o_result
3069
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3075
# Figure out destination file name, if it wasn't already specified.
3076
if test -n "$destname"; then
3077
destfile="$destdir/$destname"
3079
func_basename "$file"
3080
destfile="$func_basename_result"
3081
destfile="$destdir/$destfile"
3084
# If the file is missing, and there is a .exe on the end, strip it
3085
# because it is most likely a libtool script we actually want to
3090
if test ! -f "$file"; then
3091
func_stripname '' '.exe' "$file"
3092
file=$func_stripname_result
3098
# Do a test to see if this is really a libtool program.
3101
if func_ltwrapper_executable_p "$file"; then
3102
func_ltwrapper_scriptname "$file"
3103
wrapper=$func_ltwrapper_scriptname_result
3105
func_stripname '' '.exe' "$file"
3106
wrapper=$func_stripname_result
3113
if func_ltwrapper_script_p "$wrapper"; then
3117
func_source "$wrapper"
3119
# Check the variables that should have been set.
3120
test -z "$generated_by_libtool_version" && \
3121
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3124
for lib in $notinst_deplibs; do
3125
# Check to see that each library is installed.
3127
if test -f "$lib"; then
3130
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3131
if test -n "$libdir" && test ! -f "$libfile"; then
3132
func_warning "\`$lib' has not been installed in \`$libdir'"
3138
func_source "$wrapper"
3141
if test "$fast_install" = no && test -n "$relink_command"; then
3143
if test "$finalize" = yes; then
3144
tmpdir=`func_mktempdir`
3145
func_basename "$file$stripped_ext"
3146
file="$func_basename_result"
3147
outputname="$tmpdir/$file"
3148
# Replace the output file specification.
3149
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3152
func_quote_for_expand "$relink_command"
3153
eval "func_echo $func_quote_for_expand_result"
3155
if eval "$relink_command"; then :
3157
func_error "error: relink \`$file' with the above command before installing it"
3158
$opt_dry_run || ${RM}r "$tmpdir"
3163
func_warning "cannot relink \`$file'"
3167
# Install the binary that we compiled earlier.
3168
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3172
# remove .exe since cygwin /usr/bin/install will append another
3174
case $install_prog,$host in
3175
*/usr/bin/install*,*cygwin*)
3176
case $file:$destfile in
3181
destfile=$destfile.exe
3184
func_stripname '' '.exe' "$destfile"
3185
destfile=$func_stripname_result
3190
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3191
$opt_dry_run || if test -n "$outputname"; then
3198
for file in $staticlibs; do
3199
func_basename "$file"
3200
name="$func_basename_result"
3202
# Set up the ranlib parameters.
3203
oldlib="$destdir/$name"
3205
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3207
if test -n "$stripme" && test -n "$old_striplib"; then
3208
func_show_eval "$old_striplib $oldlib" 'exit $?'
3211
# Do each command in the postinstall commands.
3212
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3215
test -n "$future_libdirs" && \
3216
func_warning "remember to run \`$progname --finish$future_libdirs'"
3218
if test -n "$current_libdirs"; then
3219
# Maybe just do a dry run.
3220
$opt_dry_run && current_libdirs=" -n$current_libdirs"
3221
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3227
test "$opt_mode" = install && func_mode_install ${1+"$@"}
3230
# func_generate_dlsyms outputname originator pic_p
3231
# Extract symbols from dlprefiles and create ${outputname}S.o with
3232
# a dlpreopen symbol table.
3233
func_generate_dlsyms ()
3239
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3242
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3243
if test -n "$NM" && test -n "$global_symbol_pipe"; then
3244
my_dlsyms="${my_outputname}S.c"
3246
func_error "not configured to extract global symbols from dlpreopened files"
3250
if test -n "$my_dlsyms"; then
3254
# Discover the nlist of each of the dlfiles.
3255
nlist="$output_objdir/${my_outputname}.nm"
3257
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3259
# Parse the name list into a source file.
3260
func_verbose "creating $output_objdir/$my_dlsyms"
3262
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3263
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3264
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3270
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3271
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3274
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3275
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3276
/* DATA imports from DLLs on WIN32 con't be const, because runtime
3277
relocations are performed -- see ld's documentation on pseudo-relocs. */
3278
# define LT_DLSYM_CONST
3279
#elif defined(__osf__)
3280
/* This system does not cope well with relocations in const data. */
3281
# define LT_DLSYM_CONST
3283
# define LT_DLSYM_CONST const
3286
/* External symbol declarations for the compiler. */\
3289
if test "$dlself" = yes; then
3290
func_verbose "generating symbol list for \`$output'"
3292
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3294
# Add our own program objects to the symbol list.
3295
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3296
for progfile in $progfiles; do
3297
func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3298
func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3299
$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3302
if test -n "$exclude_expsyms"; then
3304
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3305
eval '$MV "$nlist"T "$nlist"'
3309
if test -n "$export_symbols_regex"; then
3311
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3312
eval '$MV "$nlist"T "$nlist"'
3316
# Prepare the list of exported symbols
3317
if test -z "$export_symbols"; then
3318
export_symbols="$output_objdir/$outputname.exp"
3321
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3323
*cygwin* | *mingw* | *cegcc* )
3324
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3325
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3331
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3332
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3333
eval '$MV "$nlist"T "$nlist"'
3335
*cygwin* | *mingw* | *cegcc* )
3336
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3337
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3344
for dlprefile in $dlprefiles; do
3345
func_verbose "extracting global C symbols from \`$dlprefile'"
3346
func_basename "$dlprefile"
3347
name="$func_basename_result"
3349
*cygwin* | *mingw* | *cegcc* )
3350
# if an import library, we need to obtain dlname
3351
if func_win32_import_lib_p "$dlprefile"; then
3352
func_tr_sh "$dlprefile"
3353
eval "curr_lafile=\$libfile_$func_tr_sh_result"
3354
dlprefile_dlbasename=""
3355
if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3356
# Use subshell, to avoid clobbering current variable values
3357
dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3358
if test -n "$dlprefile_dlname" ; then
3359
func_basename "$dlprefile_dlname"
3360
dlprefile_dlbasename="$func_basename_result"
3362
# no lafile. user explicitly requested -dlpreopen <import library>.
3363
$sharedlib_from_linklib_cmd "$dlprefile"
3364
dlprefile_dlbasename=$sharedlib_from_linklib_result
3368
if test -n "$dlprefile_dlbasename" ; then
3369
eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3371
func_warning "Could not compute DLL name from $name"
3372
eval '$ECHO ": $name " >> "$nlist"'
3374
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3375
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3376
$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3378
else # not an import lib
3380
eval '$ECHO ": $name " >> "$nlist"'
3381
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3382
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3388
eval '$ECHO ": $name " >> "$nlist"'
3389
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3390
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3397
# Make sure we have at least an empty file.
3398
test -f "$nlist" || : > "$nlist"
3400
if test -n "$exclude_expsyms"; then
3401
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3402
$MV "$nlist"T "$nlist"
3405
# Try sorting and uniquifying the output.
3406
if $GREP -v "^: " < "$nlist" |
3407
if sort -k 3 </dev/null >/dev/null 2>&1; then
3412
uniq > "$nlist"S; then
3415
$GREP -v "^: " < "$nlist" > "$nlist"S
3418
if test -f "$nlist"S; then
3419
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3421
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3424
echo >> "$output_objdir/$my_dlsyms" "\
3426
/* The mapping between symbol names and symbols. */
3431
extern LT_DLSYM_CONST lt_dlsymlist
3432
lt_${my_prefix}_LTX_preloaded_symbols[];
3433
LT_DLSYM_CONST lt_dlsymlist
3434
lt_${my_prefix}_LTX_preloaded_symbols[] =
3436
{ \"$my_originator\", (void *) 0 },"
3438
case $need_lib_prefix in
3440
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3443
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3446
echo >> "$output_objdir/$my_dlsyms" "\
3450
/* This works around a problem in FreeBSD linker */
3451
#ifdef FREEBSD_WORKAROUND
3452
static const void *lt_preloaded_setup() {
3453
return lt_${my_prefix}_LTX_preloaded_symbols;
3463
pic_flag_for_symtable=
3464
case "$compile_command " in
3468
# compiling the symbol table file with pic_flag works around
3469
# a FreeBSD bug that causes programs to crash when -lm is
3470
# linked before any other PIC object. But we must not use
3471
# pic_flag when linking with -static. The problem exists in
3472
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3473
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3474
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3476
pic_flag_for_symtable=" $pic_flag" ;;
3478
if test "X$my_pic_p" != Xno; then
3479
pic_flag_for_symtable=" $pic_flag"
3486
for arg in $LTCFLAGS; do
3488
-pie | -fpie | -fPIE) ;;
3489
*) func_append symtab_cflags " $arg" ;;
3493
# Now compile the dynamic symbol file.
3494
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3496
# Clean up the generated files.
3497
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3499
# Transform the symbol file into the correct name.
3500
symfileobj="$output_objdir/${my_outputname}S.$objext"
3502
*cygwin* | *mingw* | *cegcc* )
3503
if test -f "$output_objdir/$my_outputname.def"; then
3504
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3505
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3507
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3508
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3518
func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522
# We keep going just in case the user didn't refer to
3523
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3524
# really was required.
3526
# Nullify the symbol file.
3527
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3528
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532
# func_win32_libid arg
3533
# return the library type of file 'arg'
3535
# Need a lot of goo to handle *both* DLLs and import libs
3536
# Has to be a shell function in order to 'eat' the argument
3537
# that is supplied when $file_magic_command is called.
3538
# Despite the name, also deal with 64 bit binaries.
3542
win32_libid_type="unknown"
3543
win32_fileres=`file -L $1 2>/dev/null`
3544
case $win32_fileres in
3545
*ar\ archive\ import\ library*) # definitely import
3546
win32_libid_type="x86 archive import"
3548
*ar\ archive*) # could be an import, or static
3549
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3550
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3551
$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3552
func_to_tool_file "$1" func_convert_file_msys_to_w32
3553
win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3562
case $win32_nmres in
3563
import*) win32_libid_type="x86 archive import";;
3564
*) win32_libid_type="x86 archive static";;
3569
win32_libid_type="x86 DLL"
3571
*executable*) # but shell scripts are "executable" too...
3572
case $win32_fileres in
3573
*MS\ Windows\ PE\ Intel*)
3574
win32_libid_type="x86 DLL"
3579
$ECHO "$win32_libid_type"
3582
# func_cygming_dll_for_implib ARG
3584
# Platform-specific function to extract the
3585
# name of the DLL associated with the specified
3586
# import library ARG.
3587
# Invoked by eval'ing the libtool variable
3588
# $sharedlib_from_linklib_cmd
3589
# Result is available in the variable
3590
# $sharedlib_from_linklib_result
3591
func_cygming_dll_for_implib ()
3594
sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3597
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3599
# The is the core of a fallback implementation of a
3600
# platform-specific function to extract the name of the
3601
# DLL associated with the specified import library LIBNAME.
3603
# SECTION_NAME is either .idata$6 or .idata$7, depending
3604
# on the platform and compiler that created the implib.
3606
# Echos the name of the DLL associated with the
3607
# specified import library.
3608
func_cygming_dll_for_implib_fallback_core ()
3611
match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3612
$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3613
$SED '/^Contents of section '"$match_literal"':/{
3614
# Place marker at beginning of archive member dllname section
3619
# These lines can sometimes be longer than 43 characters, but
3620
# are always uninteresting
3621
/:[ ]*file format pe[i]\{,1\}-/d
3622
/^In archive [^:]*:/d
3623
# Ensure marker is printed
3625
# Remove all lines with less than 43 characters
3627
# From remaining lines, remove first 43 characters
3630
# Join marker and all lines until next marker into a single line
3631
/^====MARK====/ b para
3640
# Remove trailing dots and whitespace
3644
# we now have a list, one entry per line, of the stringified
3645
# contents of the appropriate section of all members of the
3646
# archive which possess that section. Heuristic: eliminate
3647
# all those which have a first or second character that is
3648
# a '.' (that is, objdump's representation of an unprintable
3649
# character.) This should work for all archives with less than
3650
# 0x302f exports -- but will fail for DLLs whose name actually
3651
# begins with a literal '.' or a single character followed by
3654
# Of those that remain, print the first one.
3655
$SED -e '/^\./d;/^.\./d;q'
3658
# func_cygming_gnu_implib_p ARG
3659
# This predicate returns with zero status (TRUE) if
3660
# ARG is a GNU/binutils-style import library. Returns
3661
# with nonzero status (FALSE) otherwise.
3662
func_cygming_gnu_implib_p ()
3665
func_to_tool_file "$1" func_convert_file_msys_to_w32
3666
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)$'`
3667
test -n "$func_cygming_gnu_implib_tmp"
3670
# func_cygming_ms_implib_p ARG
3671
# This predicate returns with zero status (TRUE) if
3672
# ARG is an MS-style import library. Returns
3673
# with nonzero status (FALSE) otherwise.
3674
func_cygming_ms_implib_p ()
3677
func_to_tool_file "$1" func_convert_file_msys_to_w32
3678
func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3679
test -n "$func_cygming_ms_implib_tmp"
3682
# func_cygming_dll_for_implib_fallback ARG
3683
# Platform-specific function to extract the
3684
# name of the DLL associated with the specified
3685
# import library ARG.
3687
# This fallback implementation is for use when $DLLTOOL
3688
# does not support the --identify-strict option.
3689
# Invoked by eval'ing the libtool variable
3690
# $sharedlib_from_linklib_cmd
3691
# Result is available in the variable
3692
# $sharedlib_from_linklib_result
3693
func_cygming_dll_for_implib_fallback ()
3696
if func_cygming_gnu_implib_p "$1" ; then
3697
# binutils import library
3698
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3699
elif func_cygming_ms_implib_p "$1" ; then
3700
# ms-generated import library
3701
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3704
sharedlib_from_linklib_result=""
3709
# func_extract_an_archive dir oldlib
3710
func_extract_an_archive ()
3713
f_ex_an_ar_dir="$1"; shift
3714
f_ex_an_ar_oldlib="$1"
3715
if test "$lock_old_archive_extraction" = yes; then
3716
lockfile=$f_ex_an_ar_oldlib.lock
3717
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3718
func_echo "Waiting for $lockfile to be removed"
3722
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3723
'stat=$?; rm -f "$lockfile"; exit $stat'
3724
if test "$lock_old_archive_extraction" = yes; then
3725
$opt_dry_run || rm -f "$lockfile"
3727
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3730
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3735
# func_extract_archives gentop oldlib ...
3736
func_extract_archives ()
3739
my_gentop="$1"; shift
3740
my_oldlibs=${1+"$@"}
3746
for my_xlib in $my_oldlibs; do
3747
# Extract the objects.
3749
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3750
*) my_xabs=`pwd`"/$my_xlib" ;;
3752
func_basename "$my_xlib"
3753
my_xlib="$func_basename_result"
3756
case " $extracted_archives " in
3758
func_arith $extracted_serial + 1
3759
extracted_serial=$func_arith_result
3760
my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764
extracted_archives="$extracted_archives $my_xlib_u"
3765
my_xdir="$my_gentop/$my_xlib_u"
3767
func_mkdir_p "$my_xdir"
3771
func_verbose "Extracting $my_xabs"
3772
# Do not bother doing anything if just a dry run
3774
darwin_orig_dir=`pwd`
3775
cd $my_xdir || exit $?
3776
darwin_archive=$my_xabs
3778
darwin_base_archive=`basename "$darwin_archive"`
3779
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3780
if test -n "$darwin_arches"; then
3781
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3783
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3784
for darwin_arch in $darwin_arches ; do
3785
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3786
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3787
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3788
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3790
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3791
done # $darwin_arches
3792
## Okay now we've a bunch of thin objects, gotta fatten them up :)
3793
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3796
for darwin_file in $darwin_filelist; do
3797
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3798
$LIPO -create -output "$darwin_file" $darwin_files
3799
done # $darwin_filelist
3801
cd "$darwin_orig_dir"
3804
func_extract_an_archive "$my_xdir" "$my_xabs"
3809
func_extract_an_archive "$my_xdir" "$my_xabs"
3812
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3815
func_extract_archives_result="$my_oldobjs"
3819
# func_emit_wrapper [arg=no]
3821
# Emit a libtool wrapper script on stdout.
3822
# Don't directly open a file because we may want to
3823
# incorporate the script contents within a cygwin/mingw
3824
# wrapper executable. Must ONLY be called from within
3825
# func_mode_link because it depends on a number of variables
3828
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3829
# variable will take. If 'yes', then the emitted script
3830
# will assume that the directory in which it is stored is
3831
# the $objdir directory. This is a cygwin/mingw-specific
3833
func_emit_wrapper ()
3835
func_emit_wrapper_arg1=${1-no}
3840
# $output - temporary wrapper script for $objdir/$outputname
3841
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3843
# The $output program cannot be directly executed until all the libtool
3844
# libraries that it depends on are installed.
3846
# This wrapper script should never be moved out of the build directory.
3847
# If it is, it will not operate correctly.
3849
# Sed substitution that helps us do robust quoting. It backslashifies
3850
# metacharacters that are still active within double-quoted strings.
3851
sed_quote_subst='$sed_quote_subst'
3853
# Be Bourne compatible
3854
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3857
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3858
# is contrary to our usage. Disable this feature.
3859
alias -g '\${1+\"\$@\"}'='\"\$@\"'
3860
setopt NO_GLOB_SUBST
3862
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3864
BIN_SH=xpg4; export BIN_SH # for Tru64
3865
DUALCASE=1; export DUALCASE # for MKS sh
3867
# The HP-UX ksh and POSIX shell print the target directory to stdout
3869
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3871
relink_command=\"$relink_command\"
3873
# This environment variable determines our operation mode.
3874
if test \"\$libtool_install_magic\" = \"$magic\"; then
3875
# install mode needs the following variables:
3876
generated_by_libtool_version='$macro_version'
3877
notinst_deplibs='$notinst_deplibs'
3879
# When we are sourced in execute mode, \$file and \$ECHO are already set.
3880
if test \"\$libtool_execute_magic\" != \"$magic\"; then
3883
qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3886
# A function that is used when there is no print builtin or printf.
3887
func_fallback_echo ()
3889
eval 'cat <<_LTECHO_EOF
3896
# Very basic option parsing. These options are (a) specific to
3897
# the libtool wrapper, (b) are identical between the wrapper
3898
# /script/ and the wrapper /executable/ which is used only on
3899
# windows platforms, and (c) all begin with the string "--lt-"
3900
# (application programs are unlikely to have options which match
3903
# There are only two supported options: --lt-debug and
3904
# --lt-dump-script. There is, deliberately, no --lt-help.
3906
# The first argument to this parsing function should be the
3907
# script's $0 value, followed by "$@".
3909
func_parse_lt_options ()
3915
case \"\$lt_opt\" in
3916
--lt-debug) lt_option_debug=1 ;;
3918
lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3919
test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3920
lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3921
cat \"\$lt_dump_D/\$lt_dump_F\"
3925
\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3931
# Print the debug banner immediately:
3932
if test -n \"\$lt_option_debug\"; then
3933
echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937
# Used when --lt-debug. Prints its arguments to stdout
3938
# (redirection is the responsibility of the caller)
3939
func_lt_dump_args ()
3944
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3945
lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949
# Core function for launching the target application
3950
func_exec_program_core ()
3954
# Backslashes separate directories on plain windows
3955
*-*-mingw | *-*-os2* | *-cegcc*)
3957
if test -n \"\$lt_option_debug\"; then
3958
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3959
func_lt_dump_args \${1+\"\$@\"} 1>&2
3961
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3967
if test -n \"\$lt_option_debug\"; then
3968
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3969
func_lt_dump_args \${1+\"\$@\"} 1>&2
3971
exec \"\$progdir/\$program\" \${1+\"\$@\"}
3976
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3980
# A function to encapsulate launching the target application
3981
# Strips options in the --lt-* namespace from \$@ and
3982
# launches target application with the remaining arguments.
3983
func_exec_program ()
3989
*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3993
func_exec_program_core \${1+\"\$@\"}
3997
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3999
# Find the directory that this script lives in.
4000
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4001
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4003
# Follow symbolic links until we get to the real thisdir.
4004
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4005
while test -n \"\$file\"; do
4006
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4008
# If there was a directory component, then change thisdir.
4009
if test \"x\$destdir\" != \"x\$file\"; then
4010
case \"\$destdir\" in
4011
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4012
*) thisdir=\"\$thisdir/\$destdir\" ;;
4016
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4017
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4020
# Usually 'no', except on cygwin/mingw when embedded into
4022
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4023
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4024
# special case for '.'
4025
if test \"\$thisdir\" = \".\"; then
4028
# remove .libs from thisdir
4029
case \"\$thisdir\" in
4030
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4031
$objdir ) thisdir=. ;;
4035
# Try to get the absolute directory name.
4036
absdir=\`cd \"\$thisdir\" && pwd\`
4037
test -n \"\$absdir\" && thisdir=\"\$absdir\"
4040
if test "$fast_install" = yes; then
4042
program=lt-'$outputname'$exeext
4043
progdir=\"\$thisdir/$objdir\"
4045
if test ! -f \"\$progdir/\$program\" ||
4046
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4047
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4049
file=\"\$\$-\$program\"
4051
if test ! -d \"\$progdir\"; then
4052
$MKDIR \"\$progdir\"
4054
$RM \"\$progdir/\$file\"
4059
# relink executable if necessary
4060
if test -n \"\$relink_command\"; then
4061
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4063
$ECHO \"\$relink_command_output\" >&2
4064
$RM \"\$progdir/\$file\"
4069
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4070
{ $RM \"\$progdir/\$program\";
4071
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4072
$RM \"\$progdir/\$file\"
4076
program='$outputname'
4077
progdir=\"\$thisdir/$objdir\"
4083
if test -f \"\$progdir/\$program\"; then"
4085
# fixup the dll searchpath if we need to.
4087
# Fix the DLL searchpath if we need to. Do this before prepending
4088
# to shlibpath, because on Windows, both are PATH and uninstalled
4089
# libraries must come first.
4090
if test -n "$dllsearchpath"; then
4092
# Add the dll search path components to the executable PATH
4093
PATH=$dllsearchpath:\$PATH
4097
# Export our shlibpath_var if we have one.
4098
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4100
# Add our own library path to $shlibpath_var
4101
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4103
# Some systems cannot cope with colon-terminated $shlibpath_var
4104
# The second colon is a workaround for a bug in BeOS R4 sed
4105
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4107
export $shlibpath_var
4112
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4113
# Run the actual program with our arguments.
4114
func_exec_program \${1+\"\$@\"}
4117
# The program doesn't exist.
4118
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4119
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4120
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4128
# func_emit_cwrapperexe_src
4129
# emit the source code for a wrapper executable on stdout
4130
# Must ONLY be called from within func_mode_link because
4131
# it depends on a number of variable set therein.
4132
func_emit_cwrapperexe_src ()
4136
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4137
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4139
The $output program cannot be directly executed until all the libtool
4140
libraries that it depends on are installed.
4142
This wrapper executable should never be moved out of the build directory.
4143
If it is, it will not operate correctly.
4148
# define _CRT_SECURE_NO_DEPRECATE 1
4153
# include <direct.h>
4154
# include <process.h>
4157
# include <unistd.h>
4158
# include <stdint.h>
4170
#include <sys/stat.h>
4172
/* declarations of non-ANSI functions */
4173
#if defined(__MINGW32__)
4174
# ifdef __STRICT_ANSI__
4175
int _putenv (const char *);
4177
#elif defined(__CYGWIN__)
4178
# ifdef __STRICT_ANSI__
4179
char *realpath (const char *, char *);
4180
int putenv (char *);
4181
int setenv (const char *, const char *, int);
4183
/* #elif defined (other platforms) ... */
4186
/* portability defines, excluding path handling macros */
4187
#if defined(_MSC_VER)
4188
# define setmode _setmode
4190
# define chmod _chmod
4191
# define getcwd _getcwd
4192
# define putenv _putenv
4193
# define S_IXUSR _S_IEXEC
4194
# ifndef _INTPTR_T_DEFINED
4195
# define _INTPTR_T_DEFINED
4196
# define intptr_t int
4198
#elif defined(__MINGW32__)
4199
# define setmode _setmode
4201
# define chmod _chmod
4202
# define getcwd _getcwd
4203
# define putenv _putenv
4204
#elif defined(__CYGWIN__)
4205
# define HAVE_SETENV
4206
# define FOPEN_WB "wb"
4207
/* #elif defined (other platforms) ... */
4210
#if defined(PATH_MAX)
4211
# define LT_PATHMAX PATH_MAX
4212
#elif defined(MAXPATHLEN)
4213
# define LT_PATHMAX MAXPATHLEN
4215
# define LT_PATHMAX 1024
4225
/* path handling portability macros */
4226
#ifndef DIR_SEPARATOR
4227
# define DIR_SEPARATOR '/'
4228
# define PATH_SEPARATOR ':'
4231
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4233
# define HAVE_DOS_BASED_FILE_SYSTEM
4234
# define FOPEN_WB "wb"
4235
# ifndef DIR_SEPARATOR_2
4236
# define DIR_SEPARATOR_2 '\\'
4238
# ifndef PATH_SEPARATOR_2
4239
# define PATH_SEPARATOR_2 ';'
4243
#ifndef DIR_SEPARATOR_2
4244
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4245
#else /* DIR_SEPARATOR_2 */
4246
# define IS_DIR_SEPARATOR(ch) \
4247
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4248
#endif /* DIR_SEPARATOR_2 */
4250
#ifndef PATH_SEPARATOR_2
4251
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4252
#else /* PATH_SEPARATOR_2 */
4253
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4254
#endif /* PATH_SEPARATOR_2 */
4257
# define FOPEN_WB "w"
4260
# define _O_BINARY 0
4263
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4264
#define XFREE(stale) do { \
4265
if (stale) { free ((void *) stale); stale = 0; } \
4268
#if defined(LT_DEBUGWRAPPER)
4269
static int lt_debug = 1;
4271
static int lt_debug = 0;
4274
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4276
void *xmalloc (size_t num);
4277
char *xstrdup (const char *string);
4278
const char *base_name (const char *name);
4279
char *find_executable (const char *wrapper);
4280
char *chase_symlinks (const char *pathspec);
4281
int make_executable (const char *path);
4282
int check_executable (const char *path);
4283
char *strendzap (char *str, const char *pat);
4284
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4285
void lt_fatal (const char *file, int line, const char *message, ...);
4286
static const char *nonnull (const char *s);
4287
static const char *nonempty (const char *s);
4288
void lt_setenv (const char *name, const char *value);
4289
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4290
void lt_update_exe_path (const char *name, const char *value);
4291
void lt_update_lib_path (const char *name, const char *value);
4292
char **prepare_spawn (char **argv);
4293
void lt_dump_script (FILE *f);
4297
volatile const char * MAGIC_EXE = "$magic_exe";
4298
const char * LIB_PATH_VARNAME = "$shlibpath_var";
4301
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4302
func_to_host_path "$temp_rpath"
4304
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4308
const char * LIB_PATH_VALUE = "";
4312
if test -n "$dllsearchpath"; then
4313
func_to_host_path "$dllsearchpath:"
4315
const char * EXE_PATH_VARNAME = "PATH";
4316
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4320
const char * EXE_PATH_VARNAME = "";
4321
const char * EXE_PATH_VALUE = "";
4325
if test "$fast_install" = yes; then
4327
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4331
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4338
#define LTWRAPPER_OPTION_PREFIX "--lt-"
4340
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4341
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4342
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
4345
main (int argc, char *argv[])
4350
char *actual_cwrapper_path;
4351
char *actual_cwrapper_name;
4354
intptr_t rval = 127;
4358
program_name = (char *) xstrdup (base_name (argv[0]));
4359
newargz = XMALLOC (char *, argc + 1);
4361
/* very simple arg parsing; don't want to rely on getopt
4362
* also, copy all non cwrapper options to newargz, except
4363
* argz[0], which is handled differently
4366
for (i = 1; i < argc; i++)
4368
if (strcmp (argv[i], dumpscript_opt) == 0)
4372
*mingw* | *cygwin* )
4373
# make stdout use "unix" line endings
4374
echo " setmode(1,_O_BINARY);"
4379
lt_dump_script (stdout);
4382
if (strcmp (argv[i], debug_opt) == 0)
4387
if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4389
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4390
namespace, but it is not one of the ones we know about and
4391
have already dealt with, above (inluding dump-script), then
4392
report an error. Otherwise, targets might begin to believe
4393
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4394
namespace. The first time any user complains about this, we'll
4395
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4396
or a configure.ac-settable value.
4398
lt_fatal (__FILE__, __LINE__,
4399
"unrecognized %s option: '%s'",
4400
ltwrapper_option_prefix, argv[i]);
4403
newargz[++newargc] = xstrdup (argv[i]);
4405
newargz[++newargc] = NULL;
4409
/* The GNU banner must be the first non-error debug message */
4410
lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4413
lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4414
lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4416
tmp_pathspec = find_executable (argv[0]);
4417
if (tmp_pathspec == NULL)
4418
lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4419
lt_debugprintf (__FILE__, __LINE__,
4420
"(main) found exe (before symlink chase) at: %s\n",
4423
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4424
lt_debugprintf (__FILE__, __LINE__,
4425
"(main) found exe (after symlink chase) at: %s\n",
4426
actual_cwrapper_path);
4427
XFREE (tmp_pathspec);
4429
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4430
strendzap (actual_cwrapper_path, actual_cwrapper_name);
4432
/* wrapper name transforms */
4433
strendzap (actual_cwrapper_name, ".exe");
4434
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4435
XFREE (actual_cwrapper_name);
4436
actual_cwrapper_name = tmp_pathspec;
4439
/* target_name transforms -- use actual target program name; might have lt- prefix */
4440
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4441
strendzap (target_name, ".exe");
4442
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4443
XFREE (target_name);
4444
target_name = tmp_pathspec;
4447
lt_debugprintf (__FILE__, __LINE__,
4448
"(main) libtool target name: %s\n",
4454
XMALLOC (char, (strlen (actual_cwrapper_path) +
4455
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4456
strcpy (newargz[0], actual_cwrapper_path);
4457
strcat (newargz[0], "$objdir");
4458
strcat (newargz[0], "/");
4462
/* stop here, and copy so we don't have to do this twice */
4463
tmp_pathspec = xstrdup (newargz[0]);
4465
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4466
strcat (newargz[0], actual_cwrapper_name);
4468
/* DO want the lt- prefix here if it exists, so use target_name */
4469
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4470
XFREE (tmp_pathspec);
4471
tmp_pathspec = NULL;
4479
while ((p = strchr (newargz[0], '\\')) != NULL)
4483
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4493
XFREE (target_name);
4494
XFREE (actual_cwrapper_path);
4495
XFREE (actual_cwrapper_name);
4497
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4498
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4499
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4500
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4501
because on Windows, both *_VARNAMEs are PATH but uninstalled
4502
libraries must come first. */
4503
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4504
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4506
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4507
nonnull (lt_argv_zero));
4508
for (i = 0; i < newargc; i++)
4510
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4511
i, nonnull (newargz[i]));
4519
/* execv doesn't actually work on mingw as expected on unix */
4520
newargz = prepare_spawn (newargz);
4521
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4524
/* failed to start process */
4525
lt_debugprintf (__FILE__, __LINE__,
4526
"(main) failed to launch target \"%s\": %s\n",
4527
lt_argv_zero, nonnull (strerror (errno)));
4535
execv (lt_argv_zero, newargz);
4536
return rval; /* =127, but avoids unused variable warning */
4545
xmalloc (size_t num)
4547
void *p = (void *) malloc (num);
4549
lt_fatal (__FILE__, __LINE__, "memory exhausted");
4555
xstrdup (const char *string)
4557
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4562
base_name (const char *name)
4566
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4567
/* Skip over the disk name in MSDOS pathnames. */
4568
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4572
for (base = name; *name; name++)
4573
if (IS_DIR_SEPARATOR (*name))
4579
check_executable (const char *path)
4583
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4585
if ((!path) || (!*path))
4588
if ((stat (path, &st) >= 0)
4589
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4596
make_executable (const char *path)
4601
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4603
if ((!path) || (!*path))
4606
if (stat (path, &st) >= 0)
4608
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4613
/* Searches for the full path of the wrapper. Returns
4614
newly allocated full path name if found, NULL otherwise
4615
Does not chase symlinks, even on platforms that support them.
4618
find_executable (const char *wrapper)
4623
/* static buffer for getcwd */
4624
char tmp[LT_PATHMAX + 1];
4628
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4629
nonempty (wrapper));
4631
if ((wrapper == NULL) || (*wrapper == '\0'))
4634
/* Absolute path? */
4635
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4636
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4638
concat_name = xstrdup (wrapper);
4639
if (check_executable (concat_name))
4641
XFREE (concat_name);
4646
if (IS_DIR_SEPARATOR (wrapper[0]))
4648
concat_name = xstrdup (wrapper);
4649
if (check_executable (concat_name))
4651
XFREE (concat_name);
4653
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4657
for (p = wrapper; *p; p++)
4665
/* no slashes; search PATH */
4666
const char *path = getenv ("PATH");
4669
for (p = path; *p; p = p_next)
4673
for (q = p; *q; q++)
4674
if (IS_PATH_SEPARATOR (*q))
4677
p_next = (*q == '\0' ? q : q + 1);
4680
/* empty path: current directory */
4681
if (getcwd (tmp, LT_PATHMAX) == NULL)
4682
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4683
nonnull (strerror (errno)));
4684
tmp_len = strlen (tmp);
4686
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4687
memcpy (concat_name, tmp, tmp_len);
4688
concat_name[tmp_len] = '/';
4689
strcpy (concat_name + tmp_len + 1, wrapper);
4694
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4695
memcpy (concat_name, p, p_len);
4696
concat_name[p_len] = '/';
4697
strcpy (concat_name + p_len + 1, wrapper);
4699
if (check_executable (concat_name))
4701
XFREE (concat_name);
4704
/* not found in PATH; assume curdir */
4706
/* Relative path | not found in path: prepend cwd */
4707
if (getcwd (tmp, LT_PATHMAX) == NULL)
4708
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4709
nonnull (strerror (errno)));
4710
tmp_len = strlen (tmp);
4711
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4712
memcpy (concat_name, tmp, tmp_len);
4713
concat_name[tmp_len] = '/';
4714
strcpy (concat_name + tmp_len + 1, wrapper);
4716
if (check_executable (concat_name))
4718
XFREE (concat_name);
4723
chase_symlinks (const char *pathspec)
4726
return xstrdup (pathspec);
4728
char buf[LT_PATHMAX];
4730
char *tmp_pathspec = xstrdup (pathspec);
4732
int has_symlinks = 0;
4733
while (strlen (tmp_pathspec) && !has_symlinks)
4735
lt_debugprintf (__FILE__, __LINE__,
4736
"checking path component for symlinks: %s\n",
4738
if (lstat (tmp_pathspec, &s) == 0)
4740
if (S_ISLNK (s.st_mode) != 0)
4746
/* search backwards for last DIR_SEPARATOR */
4747
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4748
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4750
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4752
/* no more DIR_SEPARATORS left */
4759
lt_fatal (__FILE__, __LINE__,
4760
"error accessing file \"%s\": %s",
4761
tmp_pathspec, nonnull (strerror (errno)));
4764
XFREE (tmp_pathspec);
4768
return xstrdup (pathspec);
4771
tmp_pathspec = realpath (pathspec, buf);
4772
if (tmp_pathspec == 0)
4774
lt_fatal (__FILE__, __LINE__,
4775
"could not follow symlinks for %s", pathspec);
4777
return xstrdup (tmp_pathspec);
4782
strendzap (char *str, const char *pat)
4786
assert (str != NULL);
4787
assert (pat != NULL);
4790
patlen = strlen (pat);
4794
str += len - patlen;
4795
if (strcmp (str, pat) == 0)
4802
lt_debugprintf (const char *file, int line, const char *fmt, ...)
4807
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4808
va_start (args, fmt);
4809
(void) vfprintf (stderr, fmt, args);
4815
lt_error_core (int exit_status, const char *file,
4816
int line, const char *mode,
4817
const char *message, va_list ap)
4819
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4820
vfprintf (stderr, message, ap);
4821
fprintf (stderr, ".\n");
4823
if (exit_status >= 0)
4828
lt_fatal (const char *file, int line, const char *message, ...)
4831
va_start (ap, message);
4832
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4837
nonnull (const char *s)
4839
return s ? s : "(null)";
4843
nonempty (const char *s)
4845
return (s && !*s) ? "(empty)" : nonnull (s);
4849
lt_setenv (const char *name, const char *value)
4851
lt_debugprintf (__FILE__, __LINE__,
4852
"(lt_setenv) setting '%s' to '%s'\n",
4853
nonnull (name), nonnull (value));
4856
/* always make a copy, for consistency with !HAVE_SETENV */
4857
char *str = xstrdup (value);
4858
setenv (name, str, 1);
4860
int len = strlen (name) + 1 + strlen (value) + 1;
4861
char *str = XMALLOC (char, len);
4862
sprintf (str, "%s=%s", name, value);
4863
if (putenv (str) != EXIT_SUCCESS)
4872
lt_extend_str (const char *orig_value, const char *add, int to_end)
4875
if (orig_value && *orig_value)
4877
int orig_value_len = strlen (orig_value);
4878
int add_len = strlen (add);
4879
new_value = XMALLOC (char, add_len + orig_value_len + 1);
4882
strcpy (new_value, orig_value);
4883
strcpy (new_value + orig_value_len, add);
4887
strcpy (new_value, add);
4888
strcpy (new_value + add_len, orig_value);
4893
new_value = xstrdup (add);
4899
lt_update_exe_path (const char *name, const char *value)
4901
lt_debugprintf (__FILE__, __LINE__,
4902
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4903
nonnull (name), nonnull (value));
4905
if (name && *name && value && *value)
4907
char *new_value = lt_extend_str (getenv (name), value, 0);
4908
/* some systems can't cope with a ':'-terminated path #' */
4909
int len = strlen (new_value);
4910
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4912
new_value[len-1] = '\0';
4914
lt_setenv (name, new_value);
4920
lt_update_lib_path (const char *name, const char *value)
4922
lt_debugprintf (__FILE__, __LINE__,
4923
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4924
nonnull (name), nonnull (value));
4926
if (name && *name && value && *value)
4928
char *new_value = lt_extend_str (getenv (name), value, 0);
4929
lt_setenv (name, new_value);
4939
/* Prepares an argument vector before calling spawn().
4940
Note that spawn() does not by itself call the command interpreter
4941
(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4942
({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4944
v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4945
}) ? "cmd.exe" : "command.com").
4946
Instead it simply concatenates the arguments, separated by ' ', and calls
4947
CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4948
interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4950
- Space and tab are interpreted as delimiters. They are not treated as
4951
delimiters if they are surrounded by double quotes: "...".
4952
- Unescaped double quotes are removed from the input. Their only effect is
4953
that within double quotes, space and tab are treated like normal
4955
- Backslashes not followed by double quotes are not special.
4956
- But 2*n+1 backslashes followed by a double quote become
4957
n backslashes followed by a double quote (n >= 0):
4962
#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"
4963
#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"
4965
prepare_spawn (char **argv)
4971
/* Count number of arguments. */
4972
for (argc = 0; argv[argc] != NULL; argc++)
4975
/* Allocate new argument vector. */
4976
new_argv = XMALLOC (char *, argc + 1);
4978
/* Put quoted arguments into the new argument vector. */
4979
for (i = 0; i < argc; i++)
4981
const char *string = argv[i];
4983
if (string[0] == '\0')
4984
new_argv[i] = xstrdup ("\"\"");
4985
else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4987
int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4989
unsigned int backslashes;
4991
char *quoted_string;
4998
for (s = string; *s != '\0'; s++)
5002
length += backslashes + 1;
5010
length += backslashes + 1;
5012
quoted_string = XMALLOC (char, length + 1);
5018
for (s = string; *s != '\0'; s++)
5024
for (j = backslashes + 1; j > 0; j--)
5036
for (j = backslashes; j > 0; j--)
5042
new_argv[i] = quoted_string;
5045
new_argv[i] = (char *) string;
5047
new_argv[argc] = NULL;
5056
void lt_dump_script (FILE* f)
5059
func_emit_wrapper yes |
5060
$SED -e 's/\([\\"]\)/\\\1/g' \
5061
-e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
5067
# end: func_emit_cwrapperexe_src
5069
# func_win32_import_lib_p ARG
5070
# True if ARG is an import lib, as indicated by $file_magic_cmd
5071
func_win32_import_lib_p ()
5074
case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5080
# func_mode_link arg...
5085
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5086
# It is impossible to link a dll without this setting, and
5087
# we shouldn't force the makefile maintainer to figure out
5088
# which system we are compiling for in order to pass an extra
5089
# flag for every libtool invocation.
5090
# allow_undefined=no
5092
# FIXME: Unfortunately, there are problems with the above when trying
5093
# to make a dll which has undefined symbols, in which case not
5094
# even a static library is built. For now, we need to specify
5095
# -no-undefined on the libtool link line when we can be certain
5096
# that all symbols are satisfied, otherwise we get a static library.
5103
libtool_args=$nonopt
5104
base_compile="$nonopt $@"
5105
compile_command=$nonopt
5106
finalize_command=$nonopt
5119
lib_search_path=`pwd`
5121
new_inherited_linker_flags=
5130
export_symbols_regex=
5138
precious_files_regex=
5139
prefer_static_libs=no
5152
single_module="${wl}-single_module"
5153
func_infer_tag $base_compile
5155
# We need to know -static, to get the right output filenames.
5160
test "$build_libtool_libs" != yes && \
5161
func_fatal_configuration "can not build a shared library"
5165
-all-static | -static | -static-libtool-libs)
5168
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5169
func_warning "complete static linking is impossible in this configuration"
5171
if test -n "$link_static_flag"; then
5172
dlopen_self=$dlopen_self_static
5174
prefer_static_libs=yes
5177
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5178
dlopen_self=$dlopen_self_static
5180
prefer_static_libs=built
5182
-static-libtool-libs)
5183
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5184
dlopen_self=$dlopen_self_static
5186
prefer_static_libs=yes
5189
build_libtool_libs=no
5196
# See if our shared archives depend on static archives.
5197
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5199
# Go through the arguments, transforming them on the way.
5200
while test "$#" -gt 0; do
5203
func_quote_for_eval "$arg"
5204
qarg=$func_quote_for_eval_unquoted_result
5205
func_append libtool_args " $func_quote_for_eval_result"
5207
# If the previous option needs an argument, assign it.
5208
if test -n "$prev"; then
5211
func_append compile_command " @OUTPUT@"
5212
func_append finalize_command " @OUTPUT@"
5223
if test "$preload" = no; then
5224
# Add the symbol object into the linking commands.
5225
func_append compile_command " @SYMFILE@"
5226
func_append finalize_command " @SYMFILE@"
5230
*.la | *.lo) ;; # We handle these cases below.
5232
if test "$dlself" = no; then
5240
if test "$prev" = dlprefiles; then
5242
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5252
if test "$prev" = dlfiles; then
5253
func_append dlfiles " $arg"
5255
func_append dlprefiles " $arg"
5263
export_symbols="$arg"
5265
|| func_fatal_error "symbol file \`$arg' does not exist"
5270
export_symbols_regex="$arg"
5278
*" $qarg.ltframework "*) ;;
5279
*) func_append deplibs " $qarg.ltframework" # this is fixed later
5288
inst_prefix_dir="$arg"
5293
if test -f "$arg"; then
5296
for fil in `cat "$save_arg"`
5298
# func_append moreargs " $fil"
5300
# A libtool-controlled object.
5302
# Check to see that this really is a libtool object.
5303
if func_lalib_unsafe_p "$arg"; then
5310
if test -z "$pic_object" ||
5311
test -z "$non_pic_object" ||
5312
test "$pic_object" = none &&
5313
test "$non_pic_object" = none; then
5314
func_fatal_error "cannot find name of object for \`$arg'"
5317
# Extract subdirectory from the argument.
5318
func_dirname "$arg" "/" ""
5319
xdir="$func_dirname_result"
5321
if test "$pic_object" != none; then
5322
# Prepend the subdirectory the object is found in.
5323
pic_object="$xdir$pic_object"
5325
if test "$prev" = dlfiles; then
5326
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5327
func_append dlfiles " $pic_object"
5331
# If libtool objects are unsupported, then we need to preload.
5336
# CHECK ME: I think I busted this. -Ossama
5337
if test "$prev" = dlprefiles; then
5338
# Preload the old-style object.
5339
func_append dlprefiles " $pic_object"
5344
func_append libobjs " $pic_object"
5349
if test "$non_pic_object" != none; then
5350
# Prepend the subdirectory the object is found in.
5351
non_pic_object="$xdir$non_pic_object"
5353
# A standard non-PIC object
5354
func_append non_pic_objects " $non_pic_object"
5355
if test -z "$pic_object" || test "$pic_object" = none ; then
5356
arg="$non_pic_object"
5359
# If the PIC object exists, use it instead.
5360
# $xdir was prepended to $pic_object above.
5361
non_pic_object="$pic_object"
5362
func_append non_pic_objects " $non_pic_object"
5365
# Only an error if not doing a dry-run.
5366
if $opt_dry_run; then
5367
# Extract subdirectory from the argument.
5368
func_dirname "$arg" "/" ""
5369
xdir="$func_dirname_result"
5372
pic_object=$xdir$objdir/$func_lo2o_result
5373
non_pic_object=$xdir$func_lo2o_result
5374
func_append libobjs " $pic_object"
5375
func_append non_pic_objects " $non_pic_object"
5377
func_fatal_error "\`$arg' is not a valid libtool object"
5382
func_fatal_error "link input file \`$arg' does not exist"
5389
precious_files_regex="$arg"
5399
# We need an absolute path.
5401
[\\/]* | [A-Za-z]:[\\/]*) ;;
5403
func_fatal_error "only absolute run-paths are allowed"
5406
if test "$prev" = rpath; then
5409
*) func_append rpath " $arg" ;;
5414
*) func_append xrpath " $arg" ;;
5426
func_append weak_libs " $arg"
5431
func_append linker_flags " $qarg"
5432
func_append compiler_flags " $qarg"
5434
func_append compile_command " $qarg"
5435
func_append finalize_command " $qarg"
5439
func_append compiler_flags " $qarg"
5441
func_append compile_command " $qarg"
5442
func_append finalize_command " $qarg"
5446
func_append linker_flags " $qarg"
5447
func_append compiler_flags " $wl$qarg"
5449
func_append compile_command " $wl$qarg"
5450
func_append finalize_command " $wl$qarg"
5454
eval "$prev=\"\$arg\""
5459
fi # test -n "$prev"
5465
if test -n "$link_static_flag"; then
5466
# See comment for -static flag below, for more details.
5467
func_append compile_command " $link_static_flag"
5468
func_append finalize_command " $link_static_flag"
5474
# FIXME: remove this flag sometime in the future.
5475
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5503
-export-symbols | -export-symbols-regex)
5504
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5505
func_fatal_error "more than one -exported-symbols argument is not allowed"
5507
if test "X$arg" = "X-export-symbols"; then
5525
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5526
# so, if we see these flags be careful not to treat them like -L
5528
case $with_gcc/$host in
5529
no/*-*-irix* | /*-*-irix*)
5530
func_append compile_command " $arg"
5531
func_append finalize_command " $arg"
5538
func_stripname "-L" '' "$arg"
5539
if test -z "$func_stripname_result"; then
5540
if test "$#" -gt 0; then
5541
func_fatal_error "require no space between \`-L' and \`$1'"
5543
func_fatal_error "need path for \`-L' option"
5546
func_resolve_sysroot "$func_stripname_result"
5547
dir=$func_resolve_sysroot_result
5548
# We need an absolute path.
5550
[\\/]* | [A-Za-z]:[\\/]*) ;;
5552
absdir=`cd "$dir" && pwd`
5553
test -z "$absdir" && \
5554
func_fatal_error "cannot determine absolute directory name of \`$dir'"
5559
*" -L$dir "* | *" $arg "*)
5560
# Will only happen for absolute or sysroot arguments
5563
# Preserve sysroot, but never include relative directories
5565
[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5566
*) func_append deplibs " -L$dir" ;;
5568
func_append lib_search_path " $dir"
5572
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5573
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5574
case :$dllsearchpath: in
5576
::) dllsearchpath=$dir;;
5577
*) func_append dllsearchpath ":$dir";;
5579
case :$dllsearchpath: in
5580
*":$testbindir:"*) ;;
5581
::) dllsearchpath=$testbindir;;
5582
*) func_append dllsearchpath ":$testbindir";;
5590
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5592
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5593
# These systems don't actually have a C or math library (as such)
5597
# These systems don't actually have a C library (as such)
5598
test "X$arg" = "X-lc" && continue
5600
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5601
# Do not include libc due to us having libc/libc_r.
5602
test "X$arg" = "X-lc" && continue
5604
*-*-rhapsody* | *-*-darwin1.[012])
5605
# Rhapsody C and math libraries are in the System framework
5606
func_append deplibs " System.ltframework"
5609
*-*-sco3.2v5* | *-*-sco5v6*)
5610
# Causes problems with __ctype
5611
test "X$arg" = "X-lc" && continue
5613
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5614
# Compiler inserts libc in the correct place for threads to work
5615
test "X$arg" = "X-lc" && continue
5618
elif test "X$arg" = "X-lc_r"; then
5620
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5621
# Do not include libc_r directly, use -pthread flag.
5626
func_append deplibs " $arg"
5635
# Tru64 UNIX uses -model [arg] to determine the layout of C++
5636
# classes, name mangling, and exception handling.
5637
# Darwin uses the -arch flag to determine output architecture.
5638
-model|-arch|-isysroot|--sysroot)
5639
func_append compiler_flags " $arg"
5640
func_append compile_command " $arg"
5641
func_append finalize_command " $arg"
5646
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5647
func_append compiler_flags " $arg"
5648
func_append compile_command " $arg"
5649
func_append finalize_command " $arg"
5650
case "$new_inherited_linker_flags " in
5652
* ) func_append new_inherited_linker_flags " $arg" ;;
5658
single_module="${wl}-multi_module"
5669
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5670
# The PATH hackery in wrapper scripts is required on Windows
5671
# and Darwin in order for the loader to find any dlls it needs.
5672
func_warning "\`-no-install' is ignored for $host"
5673
func_warning "assuming \`-no-fast-install' instead"
5676
*) no_install=yes ;;
5693
-precious-files-regex)
5714
func_stripname '-R' '' "$arg"
5715
dir=$func_stripname_result
5716
# We need an absolute path.
5718
[\\/]* | [A-Za-z]:[\\/]*) ;;
5720
func_stripname '=' '' "$dir"
5721
dir=$lt_sysroot$func_stripname_result
5724
func_fatal_error "only absolute run-paths are allowed"
5729
*) func_append xrpath " $dir" ;;
5735
# The effects of -shared are defined in a previous loop.
5744
-static | -static-libtool-libs)
5745
# The effects of -static are defined in a previous loop.
5746
# We used to do the same as -all-static on platforms that
5747
# didn't have a PIC flag, but the assumption that the effects
5748
# would be equivalent was wrong. It would break on at least
5749
# Digital Unix and AIX.
5775
func_stripname '-Wc,' '' "$arg"
5776
args=$func_stripname_result
5778
save_ifs="$IFS"; IFS=','
5779
for flag in $args; do
5781
func_quote_for_eval "$flag"
5782
func_append arg " $func_quote_for_eval_result"
5783
func_append compiler_flags " $func_quote_for_eval_result"
5786
func_stripname ' ' '' "$arg"
5787
arg=$func_stripname_result
5791
func_stripname '-Wl,' '' "$arg"
5792
args=$func_stripname_result
5794
save_ifs="$IFS"; IFS=','
5795
for flag in $args; do
5797
func_quote_for_eval "$flag"
5798
func_append arg " $wl$func_quote_for_eval_result"
5799
func_append compiler_flags " $wl$func_quote_for_eval_result"
5800
func_append linker_flags " $func_quote_for_eval_result"
5803
func_stripname ' ' '' "$arg"
5804
arg=$func_stripname_result
5824
func_quote_for_eval "$arg"
5825
arg="$func_quote_for_eval_result"
5828
# Flags to be passed through unchanged, with rationale:
5829
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5830
# -r[0-9][0-9]* specify processor for the SGI compiler
5831
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5832
# +DA*, +DD* enable 64-bit mode for the HP compiler
5833
# -q* compiler args for the IBM compiler
5834
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5835
# -F/path path to uninstalled frameworks, gcc on darwin
5836
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5837
# @file GCC response files
5838
# -tp=* Portland pgcc target processor selection
5839
# --sysroot=* for sysroot support
5840
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5841
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5842
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5843
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5844
func_quote_for_eval "$arg"
5845
arg="$func_quote_for_eval_result"
5846
func_append compile_command " $arg"
5847
func_append finalize_command " $arg"
5848
func_append compiler_flags " $arg"
5852
# Some other compiler flag.
5854
func_quote_for_eval "$arg"
5855
arg="$func_quote_for_eval_result"
5859
# A standard object.
5860
func_append objs " $arg"
5864
# A libtool-controlled object.
5866
# Check to see that this really is a libtool object.
5867
if func_lalib_unsafe_p "$arg"; then
5874
if test -z "$pic_object" ||
5875
test -z "$non_pic_object" ||
5876
test "$pic_object" = none &&
5877
test "$non_pic_object" = none; then
5878
func_fatal_error "cannot find name of object for \`$arg'"
5881
# Extract subdirectory from the argument.
5882
func_dirname "$arg" "/" ""
5883
xdir="$func_dirname_result"
5885
if test "$pic_object" != none; then
5886
# Prepend the subdirectory the object is found in.
5887
pic_object="$xdir$pic_object"
5889
if test "$prev" = dlfiles; then
5890
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5891
func_append dlfiles " $pic_object"
5895
# If libtool objects are unsupported, then we need to preload.
5900
# CHECK ME: I think I busted this. -Ossama
5901
if test "$prev" = dlprefiles; then
5902
# Preload the old-style object.
5903
func_append dlprefiles " $pic_object"
5908
func_append libobjs " $pic_object"
5913
if test "$non_pic_object" != none; then
5914
# Prepend the subdirectory the object is found in.
5915
non_pic_object="$xdir$non_pic_object"
5917
# A standard non-PIC object
5918
func_append non_pic_objects " $non_pic_object"
5919
if test -z "$pic_object" || test "$pic_object" = none ; then
5920
arg="$non_pic_object"
5923
# If the PIC object exists, use it instead.
5924
# $xdir was prepended to $pic_object above.
5925
non_pic_object="$pic_object"
5926
func_append non_pic_objects " $non_pic_object"
5929
# Only an error if not doing a dry-run.
5930
if $opt_dry_run; then
5931
# Extract subdirectory from the argument.
5932
func_dirname "$arg" "/" ""
5933
xdir="$func_dirname_result"
5936
pic_object=$xdir$objdir/$func_lo2o_result
5937
non_pic_object=$xdir$func_lo2o_result
5938
func_append libobjs " $pic_object"
5939
func_append non_pic_objects " $non_pic_object"
5941
func_fatal_error "\`$arg' is not a valid libtool object"
5948
func_append deplibs " $arg"
5949
func_append old_deplibs " $arg"
5954
# A libtool-controlled library.
5956
func_resolve_sysroot "$arg"
5957
if test "$prev" = dlfiles; then
5958
# This library was specified with -dlopen.
5959
func_append dlfiles " $func_resolve_sysroot_result"
5961
elif test "$prev" = dlprefiles; then
5962
# The library was specified with -dlpreopen.
5963
func_append dlprefiles " $func_resolve_sysroot_result"
5966
func_append deplibs " $func_resolve_sysroot_result"
5971
# Some other compiler argument.
5973
# Unknown arguments in both finalize_command and compile_command need
5974
# to be aesthetically quoted because they are evaled later.
5975
func_quote_for_eval "$arg"
5976
arg="$func_quote_for_eval_result"
5980
# Now actually substitute the argument into the commands.
5981
if test -n "$arg"; then
5982
func_append compile_command " $arg"
5983
func_append finalize_command " $arg"
5985
done # argument parsing loop
5987
test -n "$prev" && \
5988
func_fatal_help "the \`$prevarg' option requires an argument"
5990
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5991
eval arg=\"$export_dynamic_flag_spec\"
5992
func_append compile_command " $arg"
5993
func_append finalize_command " $arg"
5997
# calculate the name of the file, without its directory
5998
func_basename "$output"
5999
outputname="$func_basename_result"
6000
libobjs_save="$libobjs"
6002
if test -n "$shlibpath_var"; then
6003
# get the directories listed in $shlibpath_var
6004
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6008
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6009
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6011
func_dirname "$output" "/" ""
6012
output_objdir="$func_dirname_result$objdir"
6013
func_to_tool_file "$output_objdir/"
6014
tool_output_objdir=$func_to_tool_file_result
6015
# Create the object directory.
6016
func_mkdir_p "$output_objdir"
6018
# Determine the type of output
6021
func_fatal_help "you must specify an output file"
6023
*.$libext) linkmode=oldlib ;;
6024
*.lo | *.$objext) linkmode=obj ;;
6025
*.la) linkmode=lib ;;
6026
*) linkmode=prog ;; # Anything else should be a program.
6032
# Find all interdependent deplibs by searching for libraries
6033
# that are linked more than once (e.g. -la -lb -la)
6034
for deplib in $deplibs; do
6035
if $opt_preserve_dup_deps ; then
6037
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6040
func_append libs " $deplib"
6043
if test "$linkmode" = lib; then
6044
libs="$predeps $libs $compiler_lib_search_path $postdeps"
6046
# Compute libraries that are listed more than once in $predeps
6047
# $postdeps and mark them as special (i.e., whose duplicates are
6048
# not to be eliminated).
6050
if $opt_duplicate_compiler_generated_deps; then
6051
for pre_post_dep in $predeps $postdeps; do
6052
case "$pre_post_deps " in
6053
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6055
func_append pre_post_deps " $pre_post_dep"
6064
need_relink=no # whether we're linking any uninstalled libtool libraries
6065
notinst_deplibs= # not-installed libtool libraries
6066
notinst_path= # paths that contain not-installed libtool libraries
6070
passes="conv dlpreopen link"
6071
for file in $dlfiles $dlprefiles; do
6075
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6086
passes="conv scan dlopen dlpreopen link"
6092
for pass in $passes; do
6093
# The preopen pass in lib mode reverses $deplibs; put it back here
6094
# so that -L comes before libs that need it for instance...
6095
if test "$linkmode,$pass" = "lib,link"; then
6096
## FIXME: Find the place where the list is rebuilt in the wrong
6097
## order, and fix it there properly
6099
for deplib in $deplibs; do
6100
tmp_deplibs="$deplib $tmp_deplibs"
6102
deplibs="$tmp_deplibs"
6105
if test "$linkmode,$pass" = "lib,link" ||
6106
test "$linkmode,$pass" = "prog,scan"; then
6110
if test "$linkmode" = prog; then
6112
dlopen) libs="$dlfiles" ;;
6113
dlpreopen) libs="$dlprefiles" ;;
6115
libs="$deplibs %DEPLIBS%"
6116
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
6120
if test "$linkmode,$pass" = "lib,dlpreopen"; then
6121
# Collect and forward deplibs of preopened libtool libs
6122
for lib in $dlprefiles; do
6123
# Ignore non-libtool-libs
6125
func_resolve_sysroot "$lib"
6127
*.la) func_source "$func_resolve_sysroot_result" ;;
6130
# Collect preopened libtool deplibs, except any this library
6131
# has declared as weak libs
6132
for deplib in $dependency_libs; do
6133
func_basename "$deplib"
6134
deplib_base=$func_basename_result
6135
case " $weak_libs " in
6136
*" $deplib_base "*) ;;
6137
*) func_append deplibs " $deplib" ;;
6143
if test "$pass" = dlopen; then
6144
# Collect dlpreopened libraries
6145
save_deplibs="$deplibs"
6149
for deplib in $libs; do
6153
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
6154
if test "$linkmode,$pass" = "prog,link"; then
6155
compile_deplibs="$deplib $compile_deplibs"
6156
finalize_deplibs="$deplib $finalize_deplibs"
6158
func_append compiler_flags " $deplib"
6159
if test "$linkmode" = lib ; then
6160
case "$new_inherited_linker_flags " in
6162
* ) func_append new_inherited_linker_flags " $deplib" ;;
6169
if test "$linkmode" != lib && test "$linkmode" != prog; then
6170
func_warning "\`-l' is ignored for archives/objects"
6173
func_stripname '-l' '' "$deplib"
6174
name=$func_stripname_result
6175
if test "$linkmode" = lib; then
6176
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6178
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6180
for searchdir in $searchdirs; do
6181
for search_ext in .la $std_shrext .so .a; do
6182
# Search the libtool library
6183
lib="$searchdir/lib${name}${search_ext}"
6184
if test -f "$lib"; then
6185
if test "$search_ext" = ".la"; then
6194
if test "$found" != yes; then
6195
# deplib doesn't seem to be a libtool library
6196
if test "$linkmode,$pass" = "prog,link"; then
6197
compile_deplibs="$deplib $compile_deplibs"
6198
finalize_deplibs="$deplib $finalize_deplibs"
6200
deplibs="$deplib $deplibs"
6201
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6204
else # deplib is a libtool library
6205
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6206
# We need to do some special things here, and not later.
6207
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6208
case " $predeps $postdeps " in
6210
if func_lalib_p "$lib"; then
6214
for l in $old_library $library_names; do
6217
if test "X$ll" = "X$old_library" ; then # only static version available
6219
func_dirname "$lib" "" "."
6220
ladir="$func_dirname_result"
6221
lib=$ladir/$old_library
6222
if test "$linkmode,$pass" = "prog,link"; then
6223
compile_deplibs="$deplib $compile_deplibs"
6224
finalize_deplibs="$deplib $finalize_deplibs"
6226
deplibs="$deplib $deplibs"
6227
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6239
if test "$linkmode,$pass" = "prog,link"; then
6240
compile_deplibs="$deplib $compile_deplibs"
6241
finalize_deplibs="$deplib $finalize_deplibs"
6243
deplibs="$deplib $deplibs"
6244
if test "$linkmode" = lib ; then
6245
case "$new_inherited_linker_flags " in
6247
* ) func_append new_inherited_linker_flags " $deplib" ;;
6256
deplibs="$deplib $deplibs"
6257
test "$pass" = conv && continue
6258
newdependency_libs="$deplib $newdependency_libs"
6259
func_stripname '-L' '' "$deplib"
6260
func_resolve_sysroot "$func_stripname_result"
6261
func_append newlib_search_path " $func_resolve_sysroot_result"
6264
if test "$pass" = conv; then
6265
deplibs="$deplib $deplibs"
6268
if test "$pass" = scan; then
6269
deplibs="$deplib $deplibs"
6271
compile_deplibs="$deplib $compile_deplibs"
6272
finalize_deplibs="$deplib $finalize_deplibs"
6274
func_stripname '-L' '' "$deplib"
6275
func_resolve_sysroot "$func_stripname_result"
6276
func_append newlib_search_path " $func_resolve_sysroot_result"
6279
func_warning "\`-L' is ignored for archives/objects"
6285
if test "$pass" = link; then
6286
func_stripname '-R' '' "$deplib"
6287
func_resolve_sysroot "$func_stripname_result"
6288
dir=$func_resolve_sysroot_result
6289
# Make sure the xrpath contains only unique directories.
6292
*) func_append xrpath " $dir" ;;
6295
deplibs="$deplib $deplibs"
6299
func_resolve_sysroot "$deplib"
6300
lib=$func_resolve_sysroot_result
6303
if test "$pass" = conv; then
6304
deplibs="$deplib $deplibs"
6309
# Linking convenience modules into shared libraries is allowed,
6310
# but linking other static libraries is non-portable.
6311
case " $dlpreconveniencelibs " in
6315
case $deplibs_check_method in
6317
set dummy $deplibs_check_method; shift
6318
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6319
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6320
| $EGREP "$match_pattern_regex" > /dev/null; then
6328
if test "$valid_a_lib" != yes; then
6330
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
6331
echo "*** I have the capability to make that library automatically link in when"
6332
echo "*** you link to this library. But I can only do this if you have a"
6333
echo "*** shared version of the library, which you do not appear to have"
6334
echo "*** because the file extensions .$libext of this argument makes me believe"
6335
echo "*** that it is just a static archive that I should not use here."
6338
$ECHO "*** Warning: Linking the shared library $output against the"
6339
$ECHO "*** static library $deplib is not portable!"
6340
deplibs="$deplib $deplibs"
6347
if test "$pass" != link; then
6348
deplibs="$deplib $deplibs"
6350
compile_deplibs="$deplib $compile_deplibs"
6351
finalize_deplibs="$deplib $finalize_deplibs"
6358
if test "$pass" = conv; then
6359
deplibs="$deplib $deplibs"
6360
elif test "$linkmode" = prog; then
6361
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6362
# If there is no dlopen support or we're linking statically,
6363
# we need to preload.
6364
func_append newdlprefiles " $deplib"
6365
compile_deplibs="$deplib $compile_deplibs"
6366
finalize_deplibs="$deplib $finalize_deplibs"
6368
func_append newdlfiles " $deplib"
6379
if test "$found" = yes || test -f "$lib"; then :
6381
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6384
# Check to see that this really is a libtool archive.
6385
func_lalib_unsafe_p "$lib" \
6386
|| func_fatal_error "\`$lib' is not a valid libtool archive"
6388
func_dirname "$lib" "" "."
6389
ladir="$func_dirname_result"
6397
inherited_linker_flags=
6398
# If the library was installed with an old release of libtool,
6399
# it will not redefine variables installed, or shouldnotlink
6408
# Convert "-framework foo" to "foo.ltframework"
6409
if test -n "$inherited_linker_flags"; then
6410
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6411
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6412
case " $new_inherited_linker_flags " in
6413
*" $tmp_inherited_linker_flag "*) ;;
6414
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6418
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6419
if test "$linkmode,$pass" = "lib,link" ||
6420
test "$linkmode,$pass" = "prog,scan" ||
6421
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
6422
test -n "$dlopen" && func_append dlfiles " $dlopen"
6423
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6426
if test "$pass" = conv; then
6427
# Only check for convenience libraries
6428
deplibs="$lib $deplibs"
6429
if test -z "$libdir"; then
6430
if test -z "$old_library"; then
6431
func_fatal_error "cannot find name of link library for \`$lib'"
6433
# It is a libtool convenience library, so add in its objects.
6434
func_append convenience " $ladir/$objdir/$old_library"
6435
func_append old_convenience " $ladir/$objdir/$old_library"
6437
for deplib in $dependency_libs; do
6438
deplibs="$deplib $deplibs"
6439
if $opt_preserve_dup_deps ; then
6440
case "$tmp_libs " in
6441
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6444
func_append tmp_libs " $deplib"
6446
elif test "$linkmode" != prog && test "$linkmode" != lib; then
6447
func_fatal_error "\`$lib' is not a convenience library"
6453
# Get the name of the library we link against.
6455
if test -n "$old_library" &&
6456
{ test "$prefer_static_libs" = yes ||
6457
test "$prefer_static_libs,$installed" = "built,no"; }; then
6458
linklib=$old_library
6460
for l in $old_library $library_names; do
6464
if test -z "$linklib"; then
6465
func_fatal_error "cannot find name of link library for \`$lib'"
6468
# This library was specified with -dlopen.
6469
if test "$pass" = dlopen; then
6470
if test -z "$libdir"; then
6471
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6473
if test -z "$dlname" ||
6474
test "$dlopen_support" != yes ||
6475
test "$build_libtool_libs" = no; then
6476
# If there is no dlname, no dlopen support or we're linking
6477
# statically, we need to preload. We also need to preload any
6478
# dependent libraries so libltdl's deplib preloader doesn't
6479
# bomb out in the load deplibs phase.
6480
func_append dlprefiles " $lib $dependency_libs"
6482
func_append newdlfiles " $lib"
6487
# We need an absolute path.
6489
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6491
abs_ladir=`cd "$ladir" && pwd`
6492
if test -z "$abs_ladir"; then
6493
func_warning "cannot determine absolute directory name of \`$ladir'"
6494
func_warning "passing it literally to the linker, although it might fail"
6499
func_basename "$lib"
6500
laname="$func_basename_result"
6502
# Find the relevant object directory and library name.
6503
if test "X$installed" = Xyes; then
6504
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6505
func_warning "library \`$lib' was moved."
6510
dir="$lt_sysroot$libdir"
6511
absdir="$lt_sysroot$libdir"
6513
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6515
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6518
# Remove this search path later
6519
func_append notinst_path " $abs_ladir"
6521
dir="$ladir/$objdir"
6522
absdir="$abs_ladir/$objdir"
6523
# Remove this search path later
6524
func_append notinst_path " $abs_ladir"
6526
fi # $installed = yes
6527
func_stripname 'lib' '.la' "$laname"
6528
name=$func_stripname_result
6530
# This library was specified with -dlpreopen.
6531
if test "$pass" = dlpreopen; then
6532
if test -z "$libdir" && test "$linkmode" = prog; then
6533
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6536
# special handling for platforms with PE-DLLs.
6537
*cygwin* | *mingw* | *cegcc* )
6538
# Linker will automatically link against shared library if both
6539
# static and shared are present. Therefore, ensure we extract
6540
# symbols from the import library if a shared library is present
6541
# (otherwise, the dlopen module name will be incorrect). We do
6542
# this by putting the import library name into $newdlprefiles.
6543
# We recover the dlopen module name by 'saving' the la file
6544
# name in a special purpose variable, and (later) extracting the
6545
# dlname from the la file.
6546
if test -n "$dlname"; then
6547
func_tr_sh "$dir/$linklib"
6548
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6549
func_append newdlprefiles " $dir/$linklib"
6551
func_append newdlprefiles " $dir/$old_library"
6552
# Keep a list of preopened convenience libraries to check
6553
# that they are being used correctly in the link pass.
6554
test -z "$libdir" && \
6555
func_append dlpreconveniencelibs " $dir/$old_library"
6559
# Prefer using a static library (so that no silly _DYNAMIC symbols
6560
# are required to link).
6561
if test -n "$old_library"; then
6562
func_append newdlprefiles " $dir/$old_library"
6563
# Keep a list of preopened convenience libraries to check
6564
# that they are being used correctly in the link pass.
6565
test -z "$libdir" && \
6566
func_append dlpreconveniencelibs " $dir/$old_library"
6567
# Otherwise, use the dlname, so that lt_dlopen finds it.
6568
elif test -n "$dlname"; then
6569
func_append newdlprefiles " $dir/$dlname"
6571
func_append newdlprefiles " $dir/$linklib"
6575
fi # $pass = dlpreopen
6577
if test -z "$libdir"; then
6578
# Link the convenience library
6579
if test "$linkmode" = lib; then
6580
deplibs="$dir/$old_library $deplibs"
6581
elif test "$linkmode,$pass" = "prog,link"; then
6582
compile_deplibs="$dir/$old_library $compile_deplibs"
6583
finalize_deplibs="$dir/$old_library $finalize_deplibs"
6585
deplibs="$lib $deplibs" # used for prog,scan pass
6591
if test "$linkmode" = prog && test "$pass" != link; then
6592
func_append newlib_search_path " $ladir"
6593
deplibs="$lib $deplibs"
6596
if test "$link_all_deplibs" != no || test -z "$library_names" ||
6597
test "$build_libtool_libs" = no; then
6602
for deplib in $dependency_libs; do
6604
-L*) func_stripname '-L' '' "$deplib"
6605
func_resolve_sysroot "$func_stripname_result"
6606
func_append newlib_search_path " $func_resolve_sysroot_result"
6609
# Need to link against all dependency_libs?
6610
if test "$linkalldeplibs" = yes; then
6611
deplibs="$deplib $deplibs"
6613
# Need to hardcode shared library paths
6614
# or/and link against static libraries
6615
newdependency_libs="$deplib $newdependency_libs"
6617
if $opt_preserve_dup_deps ; then
6618
case "$tmp_libs " in
6619
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6622
func_append tmp_libs " $deplib"
6625
fi # $linkmode = prog...
6627
if test "$linkmode,$pass" = "prog,link"; then
6628
if test -n "$library_names" &&
6629
{ { test "$prefer_static_libs" = no ||
6630
test "$prefer_static_libs,$installed" = "built,yes"; } ||
6631
test -z "$old_library"; }; then
6632
# We need to hardcode the library path
6633
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6634
# Make sure the rpath contains only unique directories.
6635
case "$temp_rpath:" in
6637
*) func_append temp_rpath "$absdir:" ;;
6641
# Hardcode the library path.
6642
# Skip directories that are in the system default run-time
6644
case " $sys_lib_dlsearch_path " in
6647
case "$compile_rpath " in
6649
*) func_append compile_rpath " $absdir" ;;
6653
case " $sys_lib_dlsearch_path " in
6656
case "$finalize_rpath " in
6658
*) func_append finalize_rpath " $libdir" ;;
6662
fi # $linkmode,$pass = prog,link...
6664
if test "$alldeplibs" = yes &&
6665
{ test "$deplibs_check_method" = pass_all ||
6666
{ test "$build_libtool_libs" = yes &&
6667
test -n "$library_names"; }; }; then
6668
# We only need to search for static libraries
6673
link_static=no # Whether the deplib will be linked statically
6674
use_static_libs=$prefer_static_libs
6675
if test "$use_static_libs" = built && test "$installed" = yes; then
6678
if test -n "$library_names" &&
6679
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
6681
*cygwin* | *mingw* | *cegcc*)
6682
# No point in relinking DLLs because paths are not encoded
6683
func_append notinst_deplibs " $lib"
6687
if test "$installed" = no; then
6688
func_append notinst_deplibs " $lib"
6693
# This is a shared library
6695
# Warn about portability, can't link against -module's on some
6696
# systems (darwin). Don't bleat about dlopened modules though!
6698
for dlpremoduletest in $dlprefiles; do
6699
if test "X$dlpremoduletest" = "X$lib"; then
6700
dlopenmodule="$dlpremoduletest"
6704
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6706
if test "$linkmode" = prog; then
6707
$ECHO "*** Warning: Linking the executable $output against the loadable module"
6709
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
6711
$ECHO "*** $linklib is not portable!"
6713
if test "$linkmode" = lib &&
6714
test "$hardcode_into_libs" = yes; then
6715
# Hardcode the library path.
6716
# Skip directories that are in the system default run-time
6718
case " $sys_lib_dlsearch_path " in
6721
case "$compile_rpath " in
6723
*) func_append compile_rpath " $absdir" ;;
6727
case " $sys_lib_dlsearch_path " in
6730
case "$finalize_rpath " in
6732
*) func_append finalize_rpath " $libdir" ;;
6738
if test -n "$old_archive_from_expsyms_cmds"; then
6739
# figure out the soname
6740
set dummy $library_names
6744
libname=`eval "\\$ECHO \"$libname_spec\""`
6745
# use dlname if we got it. it's perfectly good, no?
6746
if test -n "$dlname"; then
6748
elif test -n "$soname_spec"; then
6751
*cygwin* | mingw* | *cegcc*)
6752
func_arith $current - $age
6753
major=$func_arith_result
6757
eval soname=\"$soname_spec\"
6762
# Make a new name for the extract_expsyms_cmds to use
6764
func_basename "$soroot"
6765
soname="$func_basename_result"
6766
func_stripname 'lib' '.dll' "$soname"
6767
newlib=libimp-$func_stripname_result.a
6769
# If the library has no export list, then create one now
6770
if test -f "$output_objdir/$soname-def"; then :
6772
func_verbose "extracting exported symbol list from \`$soname'"
6773
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6777
if test -f "$output_objdir/$newlib"; then :; else
6778
func_verbose "generating import library for \`$soname'"
6779
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6781
# make sure the library variables are pointing to the new library
6784
fi # test -n "$old_archive_from_expsyms_cmds"
6786
if test "$linkmode" = prog || test "$opt_mode" != relink; then
6791
case $hardcode_action in
6792
immediate | unsupported)
6793
if test "$hardcode_direct" = no; then
6796
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6797
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
6798
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6799
*-*-unixware7*) add_dir="-L$dir" ;;
6801
# if the lib is a (non-dlopened) module then we can not
6802
# link against it, someone is ignoring the earlier warnings
6803
if /usr/bin/file -L $add 2> /dev/null |
6804
$GREP ": [^:]* bundle" >/dev/null ; then
6805
if test "X$dlopenmodule" != "X$lib"; then
6806
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6807
if test -z "$old_library" ; then
6809
echo "*** And there doesn't seem to be a static archive available"
6810
echo "*** The link will probably fail, sorry"
6812
add="$dir/$old_library"
6814
elif test -n "$old_library"; then
6815
add="$dir/$old_library"
6819
elif test "$hardcode_minus_L" = no; then
6821
*-*-sunos*) add_shlibpath="$dir" ;;
6825
elif test "$hardcode_shlibpath_var" = no; then
6826
add_shlibpath="$dir"
6833
if test "$hardcode_direct" = yes &&
6834
test "$hardcode_direct_absolute" = no; then
6836
elif test "$hardcode_minus_L" = yes; then
6838
# Try looking first in the location we're being installed to.
6839
if test -n "$inst_prefix_dir"; then
6842
func_append add_dir " -L$inst_prefix_dir$libdir"
6847
elif test "$hardcode_shlibpath_var" = yes; then
6848
add_shlibpath="$dir"
6857
if test "$lib_linked" != yes; then
6858
func_fatal_configuration "unsupported hardcode properties"
6861
if test -n "$add_shlibpath"; then
6862
case :$compile_shlibpath: in
6863
*":$add_shlibpath:"*) ;;
6864
*) func_append compile_shlibpath "$add_shlibpath:" ;;
6867
if test "$linkmode" = prog; then
6868
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6869
test -n "$add" && compile_deplibs="$add $compile_deplibs"
6871
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6872
test -n "$add" && deplibs="$add $deplibs"
6873
if test "$hardcode_direct" != yes &&
6874
test "$hardcode_minus_L" != yes &&
6875
test "$hardcode_shlibpath_var" = yes; then
6876
case :$finalize_shlibpath: in
6878
*) func_append finalize_shlibpath "$libdir:" ;;
6884
if test "$linkmode" = prog || test "$opt_mode" = relink; then
6888
# Finalize command for both is simple: just hardcode it.
6889
if test "$hardcode_direct" = yes &&
6890
test "$hardcode_direct_absolute" = no; then
6891
add="$libdir/$linklib"
6892
elif test "$hardcode_minus_L" = yes; then
6895
elif test "$hardcode_shlibpath_var" = yes; then
6896
case :$finalize_shlibpath: in
6898
*) func_append finalize_shlibpath "$libdir:" ;;
6901
elif test "$hardcode_automatic" = yes; then
6902
if test -n "$inst_prefix_dir" &&
6903
test -f "$inst_prefix_dir$libdir/$linklib" ; then
6904
add="$inst_prefix_dir$libdir/$linklib"
6906
add="$libdir/$linklib"
6909
# We cannot seem to hardcode it, guess we'll fake it.
6911
# Try looking first in the location we're being installed to.
6912
if test -n "$inst_prefix_dir"; then
6915
func_append add_dir " -L$inst_prefix_dir$libdir"
6922
if test "$linkmode" = prog; then
6923
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6924
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6926
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6927
test -n "$add" && deplibs="$add $deplibs"
6930
elif test "$linkmode" = prog; then
6931
# Here we assume that one of hardcode_direct or hardcode_minus_L
6932
# is not unsupported. This is valid on all known static and
6934
if test "$hardcode_direct" != unsupported; then
6935
test -n "$old_library" && linklib="$old_library"
6936
compile_deplibs="$dir/$linklib $compile_deplibs"
6937
finalize_deplibs="$dir/$linklib $finalize_deplibs"
6939
compile_deplibs="-l$name -L$dir $compile_deplibs"
6940
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6942
elif test "$build_libtool_libs" = yes; then
6943
# Not a shared library
6944
if test "$deplibs_check_method" != pass_all; then
6945
# We're trying link a shared library against a static one
6946
# but the system doesn't support it.
6948
# Just print a warning and add the library to dependency_libs so
6949
# that the program can be linked against the static library.
6951
$ECHO "*** Warning: This system can not link to static lib archive $lib."
6952
echo "*** I have the capability to make that library automatically link in when"
6953
echo "*** you link to this library. But I can only do this if you have a"
6954
echo "*** shared version of the library, which you do not appear to have."
6955
if test "$module" = yes; then
6956
echo "*** But as you try to build a module library, libtool will still create "
6957
echo "*** a static module, that should work as long as the dlopening application"
6958
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6959
if test -z "$global_symbol_pipe"; then
6961
echo "*** However, this would only work if libtool was able to extract symbol"
6962
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6963
echo "*** not find such a program. So, this module is probably useless."
6964
echo "*** \`nm' from GNU binutils and a full rebuild may help."
6966
if test "$build_old_libs" = no; then
6967
build_libtool_libs=module
6970
build_libtool_libs=no
6974
deplibs="$dir/$old_library $deplibs"
6977
fi # link shared/static library?
6979
if test "$linkmode" = lib; then
6980
if test -n "$dependency_libs" &&
6981
{ test "$hardcode_into_libs" != yes ||
6982
test "$build_old_libs" = yes ||
6983
test "$link_static" = yes; }; then
6984
# Extract -R from dependency_libs
6986
for libdir in $dependency_libs; do
6988
-R*) func_stripname '-R' '' "$libdir"
6989
temp_xrpath=$func_stripname_result
6991
*" $temp_xrpath "*) ;;
6992
*) func_append xrpath " $temp_xrpath";;
6994
*) func_append temp_deplibs " $libdir";;
6997
dependency_libs="$temp_deplibs"
7000
func_append newlib_search_path " $absdir"
7001
# Link against this library
7002
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7003
# ... and its dependency_libs
7005
for deplib in $dependency_libs; do
7006
newdependency_libs="$deplib $newdependency_libs"
7008
-L*) func_stripname '-L' '' "$deplib"
7009
func_resolve_sysroot "$func_stripname_result";;
7010
*) func_resolve_sysroot "$deplib" ;;
7012
if $opt_preserve_dup_deps ; then
7013
case "$tmp_libs " in
7014
*" $func_resolve_sysroot_result "*)
7015
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7018
func_append tmp_libs " $func_resolve_sysroot_result"
7021
if test "$link_all_deplibs" != no; then
7022
# Add the search paths of all dependency libraries
7023
for deplib in $dependency_libs; do
7026
-L*) path="$deplib" ;;
7028
func_resolve_sysroot "$deplib"
7029
deplib=$func_resolve_sysroot_result
7030
func_dirname "$deplib" "" "."
7031
dir=$func_dirname_result
7032
# We need an absolute path.
7034
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7036
absdir=`cd "$dir" && pwd`
7037
if test -z "$absdir"; then
7038
func_warning "cannot determine absolute directory name of \`$dir'"
7043
if $GREP "^installed=no" $deplib > /dev/null; then
7047
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7048
if test -n "$deplibrary_names" ; then
7049
for tmp in $deplibrary_names ; do
7052
if test -f "$absdir/$objdir/$depdepl" ; then
7053
depdepl="$absdir/$objdir/$depdepl"
7054
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7055
if test -z "$darwin_install_name"; then
7056
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7058
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7059
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7065
path="-L$absdir/$objdir"
7069
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7070
test -z "$libdir" && \
7071
func_fatal_error "\`$deplib' is not a valid libtool archive"
7072
test "$absdir" != "$libdir" && \
7073
func_warning "\`$deplib' seems to be moved"
7079
case " $deplibs " in
7081
*) deplibs="$path $deplibs" ;;
7084
fi # link_all_deplibs != no
7086
done # for deplib in $libs
7087
if test "$pass" = link; then
7088
if test "$linkmode" = "prog"; then
7089
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7090
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7092
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7095
dependency_libs="$newdependency_libs"
7096
if test "$pass" = dlpreopen; then
7097
# Link the dlpreopened libraries before other libraries
7098
for deplib in $save_deplibs; do
7099
deplibs="$deplib $deplibs"
7102
if test "$pass" != dlopen; then
7103
if test "$pass" != conv; then
7104
# Make sure lib_search_path contains only unique directories.
7106
for dir in $newlib_search_path; do
7107
case "$lib_search_path " in
7109
*) func_append lib_search_path " $dir" ;;
7115
if test "$linkmode,$pass" != "prog,link"; then
7118
vars="compile_deplibs finalize_deplibs"
7120
for var in $vars dependency_libs; do
7121
# Add libraries to $var in reverse order
7122
eval tmp_libs=\"\$$var\"
7124
for deplib in $tmp_libs; do
7125
# FIXME: Pedantically, this is the right thing to do, so
7126
# that some nasty dependency loop isn't accidentally
7128
#new_libs="$deplib $new_libs"
7129
# Pragmatically, this seems to cause very few problems in
7132
-L*) new_libs="$deplib $new_libs" ;;
7135
# And here is the reason: when a library appears more
7136
# than once as an explicit dependence of a library, or
7137
# is implicitly linked in more than once by the
7138
# compiler, it is considered special, and multiple
7139
# occurrences thereof are not removed. Compare this
7140
# with having the same library being listed as a
7141
# dependency of multiple other libraries: in this case,
7142
# we know (pedantically, we assume) the library does not
7143
# need to be listed more than once, so we keep only the
7144
# last copy. This is not always right, but it is rare
7145
# enough that we require users that really mean to play
7146
# such unportable linking tricks to link the library
7147
# using -Wl,-lname, so that libtool does not consider it
7148
# for duplicate removal.
7149
case " $specialdeplibs " in
7150
*" $deplib "*) new_libs="$deplib $new_libs" ;;
7152
case " $new_libs " in
7154
*) new_libs="$deplib $new_libs" ;;
7162
for deplib in $new_libs; do
7165
case " $tmp_libs " in
7167
*) func_append tmp_libs " $deplib" ;;
7170
*) func_append tmp_libs " $deplib" ;;
7173
eval $var=\"$tmp_libs\"
7176
# Last step: remove runtime libs from dependency_libs
7177
# (they stay in deplibs)
7179
for i in $dependency_libs ; do
7180
case " $predeps $postdeps $compiler_lib_search_path " in
7185
if test -n "$i" ; then
7186
func_append tmp_libs " $i"
7189
dependency_libs=$tmp_libs
7191
if test "$linkmode" = prog; then
7192
dlfiles="$newdlfiles"
7194
if test "$linkmode" = prog || test "$linkmode" = lib; then
7195
dlprefiles="$newdlprefiles"
7200
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7201
func_warning "\`-dlopen' is ignored for archives"
7206
func_warning "\`-l' and \`-L' are ignored for archives" ;;
7209
test -n "$rpath" && \
7210
func_warning "\`-rpath' is ignored for archives"
7212
test -n "$xrpath" && \
7213
func_warning "\`-R' is ignored for archives"
7215
test -n "$vinfo" && \
7216
func_warning "\`-version-info/-version-number' is ignored for archives"
7218
test -n "$release" && \
7219
func_warning "\`-release' is ignored for archives"
7221
test -n "$export_symbols$export_symbols_regex" && \
7222
func_warning "\`-export-symbols' is ignored for archives"
7224
# Now set the variables for building old libraries.
7225
build_libtool_libs=no
7227
func_append objs "$old_deplibs"
7231
# Make sure we only generate libraries of the form `libNAME.la'.
7234
func_stripname 'lib' '.la' "$outputname"
7235
name=$func_stripname_result
7236
eval shared_ext=\"$shrext_cmds\"
7237
eval libname=\"$libname_spec\"
7240
test "$module" = no && \
7241
func_fatal_help "libtool library \`$output' must begin with \`lib'"
7243
if test "$need_lib_prefix" != no; then
7244
# Add the "lib" prefix for modules if required
7245
func_stripname '' '.la' "$outputname"
7246
name=$func_stripname_result
7247
eval shared_ext=\"$shrext_cmds\"
7248
eval libname=\"$libname_spec\"
7250
func_stripname '' '.la' "$outputname"
7251
libname=$func_stripname_result
7256
if test -n "$objs"; then
7257
if test "$deplibs_check_method" != pass_all; then
7258
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7261
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7262
$ECHO "*** objects $objs is not portable!"
7263
func_append libobjs " $objs"
7267
test "$dlself" != no && \
7268
func_warning "\`-dlopen self' is ignored for libtool libraries"
7272
test "$#" -gt 1 && \
7273
func_warning "ignoring multiple \`-rpath's for a libtool library"
7278
if test -z "$rpath"; then
7279
if test "$build_libtool_libs" = yes; then
7280
# Building a libtool convenience library.
7281
# Some compilers have problems with a `.al' extension so
7282
# convenience libraries should have the same extension an
7283
# archive normally would.
7284
oldlibs="$output_objdir/$libname.$libext $oldlibs"
7285
build_libtool_libs=convenience
7289
test -n "$vinfo" && \
7290
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7292
test -n "$release" && \
7293
func_warning "\`-release' is ignored for convenience libraries"
7296
# Parse the version information argument.
7297
save_ifs="$IFS"; IFS=':'
7298
set dummy $vinfo 0 0 0
7303
func_fatal_help "too many parameters to \`-version-info'"
7305
# convert absolute version numbers to libtool ages
7306
# this retains compatibility with .la files and attempts
7307
# to make the code below a bit more comprehensible
7309
case $vinfo_number in
7313
number_revision="$3"
7315
# There are really only two kinds -- those that
7316
# use the current revision as the major version
7317
# and those that subtract age and use age as
7318
# a minor version. But, then there is irix
7319
# which has an extra 1 added just for fun
7321
case $version_type in
7322
darwin|linux|osf|windows|none)
7323
func_arith $number_major + $number_minor
7324
current=$func_arith_result
7326
revision="$number_revision"
7328
freebsd-aout|freebsd-elf|qnx|sunos)
7329
current="$number_major"
7330
revision="$number_minor"
7334
func_arith $number_major + $number_minor
7335
current=$func_arith_result
7337
revision="$number_minor"
7338
lt_irix_increment=no
7341
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
7352
# Check that each of the things are valid numbers.
7354
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]) ;;
7356
func_error "CURRENT \`$current' must be a nonnegative integer"
7357
func_fatal_error "\`$vinfo' is not valid version information"
7362
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]) ;;
7364
func_error "REVISION \`$revision' must be a nonnegative integer"
7365
func_fatal_error "\`$vinfo' is not valid version information"
7370
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]) ;;
7372
func_error "AGE \`$age' must be a nonnegative integer"
7373
func_fatal_error "\`$vinfo' is not valid version information"
7377
if test "$age" -gt "$current"; then
7378
func_error "AGE \`$age' is greater than the current interface number \`$current'"
7379
func_fatal_error "\`$vinfo' is not valid version information"
7382
# Calculate the version variables.
7386
case $version_type in
7390
# Like Linux, but with the current version available in
7391
# verstring for coding it into the library header
7392
func_arith $current - $age
7393
major=.$func_arith_result
7394
versuffix="$major.$age.$revision"
7395
# Darwin ld doesn't like 0 for these options...
7396
func_arith $current + 1
7397
minor_current=$func_arith_result
7398
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7399
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7404
versuffix=".$current.$revision";
7409
versuffix=".$current"
7413
if test "X$lt_irix_increment" = "Xno"; then
7414
func_arith $current - $age
7416
func_arith $current - $age + 1
7418
major=$func_arith_result
7420
case $version_type in
7421
nonstopux) verstring_prefix=nonstopux ;;
7422
*) verstring_prefix=sgi ;;
7424
verstring="$verstring_prefix$major.$revision"
7426
# Add in all the interfaces that we are compatible with.
7428
while test "$loop" -ne 0; do
7429
func_arith $revision - $loop
7430
iface=$func_arith_result
7431
func_arith $loop - 1
7432
loop=$func_arith_result
7433
verstring="$verstring_prefix$major.$iface:$verstring"
7436
# Before this point, $major must not contain `.'.
7438
versuffix="$major.$revision"
7442
func_arith $current - $age
7443
major=.$func_arith_result
7444
versuffix="$major.$age.$revision"
7448
func_arith $current - $age
7449
major=.$func_arith_result
7450
versuffix=".$current.$age.$revision"
7451
verstring="$current.$age.$revision"
7453
# Add in all the interfaces that we are compatible with.
7455
while test "$loop" -ne 0; do
7456
func_arith $current - $loop
7457
iface=$func_arith_result
7458
func_arith $loop - 1
7459
loop=$func_arith_result
7460
verstring="$verstring:${iface}.0"
7463
# Make executables depend on our current version.
7464
func_append verstring ":${current}.0"
7469
versuffix=".$current"
7474
versuffix=".$current.$revision"
7478
# Use '-' rather than '.', since we only want one
7479
# extension on DOS 8.3 filesystems.
7480
func_arith $current - $age
7481
major=$func_arith_result
7486
func_fatal_configuration "unknown library version type \`$version_type'"
7490
# Clear the version info if we defaulted, and they specified a release.
7491
if test -z "$vinfo" && test -n "$release"; then
7493
case $version_type in
7495
# we can't check for "0.0" in archive_cmds due to quoting
7496
# problems, so we reset it completely
7503
if test "$need_version" = no; then
7510
# Remove version info from name if versioning should be avoided
7511
if test "$avoid_version" = yes && test "$need_version" = no; then
7517
# Check to see if the archive will have undefined symbols.
7518
if test "$allow_undefined" = yes; then
7519
if test "$allow_undefined_flag" = unsupported; then
7520
func_warning "undefined symbols not allowed in $host shared libraries"
7521
build_libtool_libs=no
7525
# Don't allow undefined symbols.
7526
allow_undefined_flag="$no_undefined_flag"
7531
func_generate_dlsyms "$libname" "$libname" "yes"
7532
func_append libobjs " $symfileobj"
7533
test "X$libobjs" = "X " && libobjs=
7535
if test "$opt_mode" != relink; then
7536
# Remove our outputs, but don't remove object files since they
7537
# may have been created when compiling PIC objects.
7539
tempremovelist=`$ECHO "$output_objdir/*"`
7540
for p in $tempremovelist; do
7544
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7545
if test "X$precious_files_regex" != "X"; then
7546
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7551
func_append removelist " $p"
7556
test -n "$removelist" && \
7557
func_show_eval "${RM}r \$removelist"
7560
# Now set the variables for building old libraries.
7561
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7562
func_append oldlibs " $output_objdir/$libname.$libext"
7564
# Transform .lo files to .o files.
7565
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7568
# Eliminate all temporary directories.
7569
#for path in $notinst_path; do
7570
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7571
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7572
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7575
if test -n "$xrpath"; then
7576
# If the user specified any rpath flags, then add them.
7578
for libdir in $xrpath; do
7579
func_replace_sysroot "$libdir"
7580
func_append temp_xrpath " -R$func_replace_sysroot_result"
7581
case "$finalize_rpath " in
7583
*) func_append finalize_rpath " $libdir" ;;
7586
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7587
dependency_libs="$temp_xrpath $dependency_libs"
7591
# Make sure dlfiles contains only unique files that won't be dlpreopened
7592
old_dlfiles="$dlfiles"
7594
for lib in $old_dlfiles; do
7595
case " $dlprefiles $dlfiles " in
7597
*) func_append dlfiles " $lib" ;;
7601
# Make sure dlprefiles contains only unique files
7602
old_dlprefiles="$dlprefiles"
7604
for lib in $old_dlprefiles; do
7605
case "$dlprefiles " in
7607
*) func_append dlprefiles " $lib" ;;
7611
if test "$build_libtool_libs" = yes; then
7612
if test -n "$rpath"; then
7614
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7615
# these systems don't actually have a c library (as such)!
7617
*-*-rhapsody* | *-*-darwin1.[012])
7618
# Rhapsody C library is in the System framework
7619
func_append deplibs " System.ltframework"
7622
# Don't link with libc until the a.out ld.so is fixed.
7624
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7625
# Do not include libc due to us having libc/libc_r.
7627
*-*-sco3.2v5* | *-*-sco5v6*)
7628
# Causes problems with __ctype
7630
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7631
# Compiler inserts libc in the correct place for threads to work
7634
# Add libc to deplibs on all other systems if necessary.
7635
if test "$build_libtool_need_lc" = "yes"; then
7636
func_append deplibs " -lc"
7642
# Transform deplibs into only deplibs that can be linked in shared.
7644
libname_save=$libname
7645
release_save=$release
7646
versuffix_save=$versuffix
7648
# I'm not sure if I'm treating the release correctly. I think
7649
# release should show up in the -l (ie -lgmp5) so we don't want to
7650
# add it in twice. Is that correct?
7656
case $deplibs_check_method in
7658
# Don't check for shared/static. Everything works.
7659
# This might be a little naive. We might want to check
7660
# whether the library exists or not. But this is on
7661
# osf3 & osf4 and I'm not really sure... Just
7662
# implementing what was already the behavior.
7666
# This code stresses the "libraries are programs" paradigm to its
7667
# limits. Maybe even breaks it. We compile a program, linking it
7668
# against the deplibs as a proxy for the library. Then we can check
7669
# whether they linked in statically or dynamically with ldd.
7670
$opt_dry_run || $RM conftest.c
7671
cat > conftest.c <<EOF
7672
int main() { return 0; }
7674
$opt_dry_run || $RM conftest
7675
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7676
ldd_output=`ldd conftest`
7677
for i in $deplibs; do
7680
func_stripname -l '' "$i"
7681
name=$func_stripname_result
7682
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7683
case " $predeps $postdeps " in
7685
func_append newdeplibs " $i"
7690
if test -n "$i" ; then
7691
libname=`eval "\\$ECHO \"$libname_spec\""`
7692
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7693
set dummy $deplib_matches; shift
7695
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7696
func_append newdeplibs " $i"
7700
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7701
echo "*** I have the capability to make that library automatically link in when"
7702
echo "*** you link to this library. But I can only do this if you have a"
7703
echo "*** shared version of the library, which I believe you do not have"
7704
echo "*** because a test_compile did reveal that the linker did not use it for"
7705
echo "*** its dynamic dependency list that programs get resolved with at runtime."
7710
func_append newdeplibs " $i"
7715
# Error occurred in the first compile. Let's try to salvage
7716
# the situation: Compile a separate program for each library.
7717
for i in $deplibs; do
7720
func_stripname -l '' "$i"
7721
name=$func_stripname_result
7722
$opt_dry_run || $RM conftest
7723
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7724
ldd_output=`ldd conftest`
7725
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7726
case " $predeps $postdeps " in
7728
func_append newdeplibs " $i"
7733
if test -n "$i" ; then
7734
libname=`eval "\\$ECHO \"$libname_spec\""`
7735
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7736
set dummy $deplib_matches; shift
7738
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7739
func_append newdeplibs " $i"
7743
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7744
echo "*** I have the capability to make that library automatically link in when"
7745
echo "*** you link to this library. But I can only do this if you have a"
7746
echo "*** shared version of the library, which you do not appear to have"
7747
echo "*** because a test_compile did reveal that the linker did not use this one"
7748
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7754
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7755
echo "*** make it link in! You will probably need to install it or some"
7756
echo "*** library that it depends on before this library will be fully"
7757
echo "*** functional. Installing it before continuing would be even better."
7761
func_append newdeplibs " $i"
7768
set dummy $deplibs_check_method; shift
7769
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7770
for a_deplib in $deplibs; do
7773
func_stripname -l '' "$a_deplib"
7774
name=$func_stripname_result
7775
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7776
case " $predeps $postdeps " in
7778
func_append newdeplibs " $a_deplib"
7783
if test -n "$a_deplib" ; then
7784
libname=`eval "\\$ECHO \"$libname_spec\""`
7785
if test -n "$file_magic_glob"; then
7786
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7788
libnameglob=$libname
7790
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7791
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7792
if test "$want_nocaseglob" = yes; then
7794
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7797
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7799
for potent_lib in $potential_libs; do
7800
# Follow soft links.
7801
if ls -lLd "$potent_lib" 2>/dev/null |
7802
$GREP " -> " >/dev/null; then
7805
# The statement above tries to avoid entering an
7806
# endless loop below, in case of cyclic links.
7807
# We might still enter an endless loop, since a link
7808
# loop can be closed while we follow links,
7810
potlib="$potent_lib"
7811
while test -h "$potlib" 2>/dev/null; do
7812
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7814
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7815
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7818
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7820
$EGREP "$file_magic_regex" > /dev/null; then
7821
func_append newdeplibs " $a_deplib"
7828
if test -n "$a_deplib" ; then
7831
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7832
echo "*** I have the capability to make that library automatically link in when"
7833
echo "*** you link to this library. But I can only do this if you have a"
7834
echo "*** shared version of the library, which you do not appear to have"
7835
echo "*** because I did check the linker path looking for a file starting"
7836
if test -z "$potlib" ; then
7837
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7839
$ECHO "*** with $libname and none of the candidates passed a file format test"
7840
$ECHO "*** using a file magic. Last file checked: $potlib"
7845
# Add a -L argument.
7846
func_append newdeplibs " $a_deplib"
7849
done # Gone through all deplibs.
7852
set dummy $deplibs_check_method; shift
7853
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7854
for a_deplib in $deplibs; do
7857
func_stripname -l '' "$a_deplib"
7858
name=$func_stripname_result
7859
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7860
case " $predeps $postdeps " in
7862
func_append newdeplibs " $a_deplib"
7867
if test -n "$a_deplib" ; then
7868
libname=`eval "\\$ECHO \"$libname_spec\""`
7869
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7870
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7871
for potent_lib in $potential_libs; do
7872
potlib="$potent_lib" # see symlink-check above in file_magic test
7873
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7874
$EGREP "$match_pattern_regex" > /dev/null; then
7875
func_append newdeplibs " $a_deplib"
7882
if test -n "$a_deplib" ; then
7885
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7886
echo "*** I have the capability to make that library automatically link in when"
7887
echo "*** you link to this library. But I can only do this if you have a"
7888
echo "*** shared version of the library, which you do not appear to have"
7889
echo "*** because I did check the linker path looking for a file starting"
7890
if test -z "$potlib" ; then
7891
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7893
$ECHO "*** with $libname and none of the candidates passed a file format test"
7894
$ECHO "*** using a regex pattern. Last file checked: $potlib"
7899
# Add a -L argument.
7900
func_append newdeplibs " $a_deplib"
7903
done # Gone through all deplibs.
7907
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7908
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7909
for i in $predeps $postdeps ; do
7910
# can't use Xsed below, because $i might contain '/'
7911
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7914
case $tmp_deplibs in
7917
if test "X$deplibs_check_method" = "Xnone"; then
7918
echo "*** Warning: inter-library dependencies are not supported in this platform."
7920
echo "*** Warning: inter-library dependencies are not known to be supported."
7922
echo "*** All declared inter-library dependencies are being dropped."
7928
versuffix=$versuffix_save
7930
release=$release_save
7931
libname=$libname_save
7935
*-*-rhapsody* | *-*-darwin1.[012])
7936
# On Rhapsody replace the C library with the System framework
7937
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7941
if test "$droppeddeps" = yes; then
7942
if test "$module" = yes; then
7944
echo "*** Warning: libtool could not satisfy all declared inter-library"
7945
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7946
echo "*** a static module, that should work as long as the dlopening"
7947
echo "*** application is linked with the -dlopen flag."
7948
if test -z "$global_symbol_pipe"; then
7950
echo "*** However, this would only work if libtool was able to extract symbol"
7951
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7952
echo "*** not find such a program. So, this module is probably useless."
7953
echo "*** \`nm' from GNU binutils and a full rebuild may help."
7955
if test "$build_old_libs" = no; then
7956
oldlibs="$output_objdir/$libname.$libext"
7957
build_libtool_libs=module
7960
build_libtool_libs=no
7963
echo "*** The inter-library dependencies that have been dropped here will be"
7964
echo "*** automatically added whenever a program is linked with this library"
7965
echo "*** or is declared to -dlopen it."
7967
if test "$allow_undefined" = no; then
7969
echo "*** Since this library must not contain undefined symbols,"
7970
echo "*** because either the platform does not support them or"
7971
echo "*** it was explicitly requested with -no-undefined,"
7972
echo "*** libtool will only create a static version of it."
7973
if test "$build_old_libs" = no; then
7974
oldlibs="$output_objdir/$libname.$libext"
7975
build_libtool_libs=module
7978
build_libtool_libs=no
7983
# Done checking deplibs!
7986
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7989
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7990
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7991
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7995
# move library search paths that coincide with paths to not yet
7996
# installed libraries to the beginning of the library search list
7998
for path in $notinst_path; do
7999
case " $new_libs " in
8000
*" -L$path/$objdir "*) ;;
8002
case " $deplibs " in
8003
*" -L$path/$objdir "*)
8004
func_append new_libs " -L$path/$objdir" ;;
8009
for deplib in $deplibs; do
8012
case " $new_libs " in
8014
*) func_append new_libs " $deplib" ;;
8017
*) func_append new_libs " $deplib" ;;
8022
# All the library-specific variables (install_libdir is set above).
8027
# Test again, we may have decided not to build it any more
8028
if test "$build_libtool_libs" = yes; then
8029
if test "$hardcode_into_libs" = yes; then
8030
# Hardcode the library paths
8033
rpath="$finalize_rpath"
8034
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8035
for libdir in $rpath; do
8036
if test -n "$hardcode_libdir_flag_spec"; then
8037
if test -n "$hardcode_libdir_separator"; then
8038
func_replace_sysroot "$libdir"
8039
libdir=$func_replace_sysroot_result
8040
if test -z "$hardcode_libdirs"; then
8041
hardcode_libdirs="$libdir"
8043
# Just accumulate the unique libdirs.
8044
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8045
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8048
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8053
eval flag=\"$hardcode_libdir_flag_spec\"
8054
func_append dep_rpath " $flag"
8056
elif test -n "$runpath_var"; then
8057
case "$perm_rpath " in
8059
*) func_apped perm_rpath " $libdir" ;;
8063
# Substitute the hardcoded libdirs into the rpath.
8064
if test -n "$hardcode_libdir_separator" &&
8065
test -n "$hardcode_libdirs"; then
8066
libdir="$hardcode_libdirs"
8067
if test -n "$hardcode_libdir_flag_spec_ld"; then
8068
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
8070
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
8073
if test -n "$runpath_var" && test -n "$perm_rpath"; then
8074
# We should set the runpath_var.
8076
for dir in $perm_rpath; do
8077
func_append rpath "$dir:"
8079
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8081
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8084
shlibpath="$finalize_shlibpath"
8085
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8086
if test -n "$shlibpath"; then
8087
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8090
# Get the real and link names of the library.
8091
eval shared_ext=\"$shrext_cmds\"
8092
eval library_names=\"$library_names_spec\"
8093
set dummy $library_names
8098
if test -n "$soname_spec"; then
8099
eval soname=\"$soname_spec\"
8103
if test -z "$dlname"; then
8107
lib="$output_objdir/$realname"
8111
func_append linknames " $link"
8114
# Use standard objects if they are pic
8115
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8116
test "X$libobjs" = "X " && libobjs=
8119
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8120
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8121
export_symbols="$output_objdir/$libname.uexp"
8122
func_append delfiles " $export_symbols"
8125
orig_export_symbols=
8127
cygwin* | mingw* | cegcc*)
8128
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8129
# exporting using user supplied symfile
8130
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8131
# and it's NOT already a .def file. Must figure out
8132
# which of the given symbols are data symbols and tag
8133
# them as such. So, trigger use of export_symbols_cmds.
8134
# export_symbols gets reassigned inside the "prepare
8135
# the list of exported symbols" if statement, so the
8136
# include_expsyms logic still works.
8137
orig_export_symbols="$export_symbols"
8139
always_export_symbols=yes
8145
# Prepare the list of exported symbols
8146
if test -z "$export_symbols"; then
8147
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8148
func_verbose "generating symbol list for \`$libname.la'"
8149
export_symbols="$output_objdir/$libname.exp"
8150
$opt_dry_run || $RM $export_symbols
8151
cmds=$export_symbols_cmds
8152
save_ifs="$IFS"; IFS='~'
8153
for cmd1 in $cmds; do
8155
# Take the normal branch if the nm_file_list_spec branch
8156
# doesn't work or if tool conversion is not needed.
8157
case $nm_file_list_spec~$to_tool_file_cmd in
8158
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8159
try_normal_branch=yes
8162
len=$func_len_result
8165
try_normal_branch=no
8168
if test "$try_normal_branch" = yes \
8169
&& { test "$len" -lt "$max_cmd_len" \
8170
|| test "$max_cmd_len" -le -1; }
8172
func_show_eval "$cmd" 'exit $?'
8173
skipped_export=false
8174
elif test -n "$nm_file_list_spec"; then
8175
func_basename "$output"
8176
output_la=$func_basename_result
8177
save_libobjs=$libobjs
8179
output=${output_objdir}/${output_la}.nm
8180
func_to_tool_file "$output"
8181
libobjs=$nm_file_list_spec$func_to_tool_file_result
8182
func_append delfiles " $output"
8183
func_verbose "creating $NM input file list: $output"
8184
for obj in $save_libobjs; do
8185
func_to_tool_file "$obj"
8186
$ECHO "$func_to_tool_file_result"
8189
func_show_eval "$cmd" 'exit $?'
8191
libobjs=$save_libobjs
8192
skipped_export=false
8194
# The command line is too long to execute in one step.
8195
func_verbose "using reloadable object file for export list..."
8197
# Break out early, otherwise skipped_export may be
8198
# set to false by a later but shorter cmd.
8203
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8204
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8205
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8210
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8211
tmp_export_symbols="$export_symbols"
8212
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8213
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8216
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8217
# The given exports_symbols file has to be filtered, so filter it.
8218
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8219
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8220
# 's' commands which not all seds can handle. GNU sed should be fine
8221
# though. Also, the filter scales superlinearly with the number of
8222
# global variables. join(1) would be nice here, but unfortunately
8223
# isn't a blessed tool.
8224
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8225
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8226
export_symbols=$output_objdir/$libname.def
8227
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8231
for test_deplib in $deplibs; do
8232
case " $convenience " in
8233
*" $test_deplib "*) ;;
8235
func_append tmp_deplibs " $test_deplib"
8239
deplibs="$tmp_deplibs"
8241
if test -n "$convenience"; then
8242
if test -n "$whole_archive_flag_spec" &&
8243
test "$compiler_needs_object" = yes &&
8244
test -z "$libobjs"; then
8245
# extract the archives, so we have objects to list.
8246
# TODO: could optimize this to just extract one archive.
8247
whole_archive_flag_spec=
8249
if test -n "$whole_archive_flag_spec"; then
8250
save_libobjs=$libobjs
8251
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8252
test "X$libobjs" = "X " && libobjs=
8254
gentop="$output_objdir/${outputname}x"
8255
func_append generated " $gentop"
8257
func_extract_archives $gentop $convenience
8258
func_append libobjs " $func_extract_archives_result"
8259
test "X$libobjs" = "X " && libobjs=
8263
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8264
eval flag=\"$thread_safe_flag_spec\"
8265
func_append linker_flags " $flag"
8268
# Make a backup of the uninstalled library when relinking
8269
if test "$opt_mode" = relink; then
8270
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8273
# Do each of the archive commands.
8274
if test "$module" = yes && test -n "$module_cmds" ; then
8275
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8276
eval test_cmds=\"$module_expsym_cmds\"
8277
cmds=$module_expsym_cmds
8279
eval test_cmds=\"$module_cmds\"
8283
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8284
eval test_cmds=\"$archive_expsym_cmds\"
8285
cmds=$archive_expsym_cmds
8287
eval test_cmds=\"$archive_cmds\"
8292
if test "X$skipped_export" != "X:" &&
8293
func_len " $test_cmds" &&
8294
len=$func_len_result &&
8295
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8298
# The command line is too long to link in one step, link piecewise
8299
# or, if using GNU ld and skipped_export is not :, use a linker
8302
# Save the value of $output and $libobjs because we want to
8303
# use them later. If we have whole_archive_flag_spec, we
8304
# want to use save_libobjs as it was before
8305
# whole_archive_flag_spec was expanded, because we can't
8306
# assume the linker understands whole_archive_flag_spec.
8307
# This may have to be revisited, in case too many
8308
# convenience libraries get linked in and end up exceeding
8310
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8311
save_libobjs=$libobjs
8314
func_basename "$output"
8315
output_la=$func_basename_result
8317
# Clear the reloadable object creation command queue and
8318
# initialize k to one.
8325
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8326
output=${output_objdir}/${output_la}.lnkscript
8327
func_verbose "creating GNU ld script: $output"
8328
echo 'INPUT (' > $output
8329
for obj in $save_libobjs
8331
func_to_tool_file "$obj"
8332
$ECHO "$func_to_tool_file_result" >> $output
8335
func_append delfiles " $output"
8336
func_to_tool_file "$output"
8337
output=$func_to_tool_file_result
8338
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8339
output=${output_objdir}/${output_la}.lnk
8340
func_verbose "creating linker input file list: $output"
8345
if test "$compiler_needs_object" = yes; then
8351
func_to_tool_file "$obj"
8352
$ECHO "$func_to_tool_file_result" >> $output
8354
func_append delfiles " $output"
8355
func_to_tool_file "$output"
8356
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8358
if test -n "$save_libobjs"; then
8359
func_verbose "creating reloadable object files..."
8360
output=$output_objdir/$output_la-${k}.$objext
8361
eval test_cmds=\"$reload_cmds\"
8362
func_len " $test_cmds"
8363
len0=$func_len_result
8366
# Loop over the list of objects to be linked.
8367
for obj in $save_libobjs
8370
func_arith $len + $func_len_result
8371
len=$func_arith_result
8372
if test "X$objlist" = X ||
8373
test "$len" -lt "$max_cmd_len"; then
8374
func_append objlist " $obj"
8376
# The command $test_cmds is almost too long, add a
8377
# command to the queue.
8378
if test "$k" -eq 1 ; then
8379
# The first file doesn't have a previous command to add.
8380
reload_objs=$objlist
8381
eval concat_cmds=\"$reload_cmds\"
8383
# All subsequent reloadable object files will link in
8384
# the last one created.
8385
reload_objs="$objlist $last_robj"
8386
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8388
last_robj=$output_objdir/$output_la-${k}.$objext
8390
k=$func_arith_result
8391
output=$output_objdir/$output_la-${k}.$objext
8393
func_len " $last_robj"
8394
func_arith $len0 + $func_len_result
8395
len=$func_arith_result
8398
# Handle the remaining objects by creating one last
8399
# reloadable object file. All subsequent reloadable object
8400
# files will link in the last one created.
8401
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8402
reload_objs="$objlist $last_robj"
8403
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8404
if test -n "$last_robj"; then
8405
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8407
func_append delfiles " $output"
8413
if ${skipped_export-false}; then
8414
func_verbose "generating symbol list for \`$libname.la'"
8415
export_symbols="$output_objdir/$libname.exp"
8416
$opt_dry_run || $RM $export_symbols
8418
# Append the command to create the export file.
8419
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8420
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8421
if test -n "$last_robj"; then
8422
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8426
test -n "$save_libobjs" &&
8427
func_verbose "creating a temporary reloadable object file: $output"
8429
# Loop through the commands generated above and execute them.
8430
save_ifs="$IFS"; IFS='~'
8431
for cmd in $concat_cmds; do
8434
func_quote_for_expand "$cmd"
8435
eval "func_echo $func_quote_for_expand_result"
8437
$opt_dry_run || eval "$cmd" || {
8440
# Restore the uninstalled library and exit
8441
if test "$opt_mode" = relink; then
8442
( cd "$output_objdir" && \
8443
$RM "${realname}T" && \
8444
$MV "${realname}U" "$realname" )
8452
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8453
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8454
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8458
if ${skipped_export-false}; then
8459
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8460
tmp_export_symbols="$export_symbols"
8461
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8462
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8465
if test -n "$orig_export_symbols"; then
8466
# The given exports_symbols file has to be filtered, so filter it.
8467
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8468
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8469
# 's' commands which not all seds can handle. GNU sed should be fine
8470
# though. Also, the filter scales superlinearly with the number of
8471
# global variables. join(1) would be nice here, but unfortunately
8472
# isn't a blessed tool.
8473
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8474
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8475
export_symbols=$output_objdir/$libname.def
8476
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8481
# Restore the value of output.
8484
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8485
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8486
test "X$libobjs" = "X " && libobjs=
8488
# Expand the library linking commands again to reset the
8489
# value of $libobjs for piecewise linking.
8491
# Do each of the archive commands.
8492
if test "$module" = yes && test -n "$module_cmds" ; then
8493
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8494
cmds=$module_expsym_cmds
8499
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8500
cmds=$archive_expsym_cmds
8507
if test -n "$delfiles"; then
8508
# Append the command to remove temporary files to $cmds.
8509
eval cmds=\"\$cmds~\$RM $delfiles\"
8512
# Add any objects from preloaded convenience libraries
8513
if test -n "$dlprefiles"; then
8514
gentop="$output_objdir/${outputname}x"
8515
func_append generated " $gentop"
8517
func_extract_archives $gentop $dlprefiles
8518
func_append libobjs " $func_extract_archives_result"
8519
test "X$libobjs" = "X " && libobjs=
8522
save_ifs="$IFS"; IFS='~'
8523
for cmd in $cmds; do
8527
func_quote_for_expand "$cmd"
8528
eval "func_echo $func_quote_for_expand_result"
8530
$opt_dry_run || eval "$cmd" || {
8533
# Restore the uninstalled library and exit
8534
if test "$opt_mode" = relink; then
8535
( cd "$output_objdir" && \
8536
$RM "${realname}T" && \
8537
$MV "${realname}U" "$realname" )
8545
# Restore the uninstalled library and exit
8546
if test "$opt_mode" = relink; then
8547
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8549
if test -n "$convenience"; then
8550
if test -z "$whole_archive_flag_spec"; then
8551
func_show_eval '${RM}r "$gentop"'
8558
# Create links to the real library.
8559
for linkname in $linknames; do
8560
if test "$realname" != "$linkname"; then
8561
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8565
# If -module or -export-dynamic was specified, set the dlname.
8566
if test "$module" = yes || test "$export_dynamic" = yes; then
8567
# On all known operating systems, these are identical.
8574
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8575
func_warning "\`-dlopen' is ignored for objects"
8580
func_warning "\`-l' and \`-L' are ignored for objects" ;;
8583
test -n "$rpath" && \
8584
func_warning "\`-rpath' is ignored for objects"
8586
test -n "$xrpath" && \
8587
func_warning "\`-R' is ignored for objects"
8589
test -n "$vinfo" && \
8590
func_warning "\`-version-info' is ignored for objects"
8592
test -n "$release" && \
8593
func_warning "\`-release' is ignored for objects"
8597
test -n "$objs$old_deplibs" && \
8598
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8602
obj=$func_lo2o_result
8610
# Delete the old objects.
8611
$opt_dry_run || $RM $obj $libobj
8613
# Objects from convenience libraries. This assumes
8614
# single-version convenience libraries. Whenever we create
8615
# different ones for PIC/non-PIC, this we'll have to duplicate
8619
# reload_cmds runs $LD directly, so let us get rid of
8620
# -Wl from whole_archive_flag_spec and hope we can get by with
8621
# turning comma into space..
8624
if test -n "$convenience"; then
8625
if test -n "$whole_archive_flag_spec"; then
8626
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8627
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8629
gentop="$output_objdir/${obj}x"
8630
func_append generated " $gentop"
8632
func_extract_archives $gentop $convenience
8633
reload_conv_objs="$reload_objs $func_extract_archives_result"
8637
# If we're not building shared, we need to use non_pic_objs
8638
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8640
# Create the old-style object.
8641
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8644
func_execute_cmds "$reload_cmds" 'exit $?'
8646
# Exit if we aren't doing a library object file.
8647
if test -z "$libobj"; then
8648
if test -n "$gentop"; then
8649
func_show_eval '${RM}r "$gentop"'
8655
if test "$build_libtool_libs" != yes; then
8656
if test -n "$gentop"; then
8657
func_show_eval '${RM}r "$gentop"'
8660
# Create an invalid libtool object if no PIC, so that we don't
8661
# accidentally link it into a program.
8662
# $show "echo timestamp > $libobj"
8663
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8667
if test -n "$pic_flag" || test "$pic_mode" != default; then
8668
# Only do commands if we really have different PIC objects.
8669
reload_objs="$libobjs $reload_conv_objs"
8671
func_execute_cmds "$reload_cmds" 'exit $?'
8674
if test -n "$gentop"; then
8675
func_show_eval '${RM}r "$gentop"'
8683
*cygwin*) func_stripname '' '.exe' "$output"
8684
output=$func_stripname_result.exe;;
8686
test -n "$vinfo" && \
8687
func_warning "\`-version-info' is ignored for programs"
8689
test -n "$release" && \
8690
func_warning "\`-release' is ignored for programs"
8692
test "$preload" = yes \
8693
&& test "$dlopen_support" = unknown \
8694
&& test "$dlopen_self" = unknown \
8695
&& test "$dlopen_self_static" = unknown && \
8696
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8699
*-*-rhapsody* | *-*-darwin1.[012])
8700
# On Rhapsody replace the C library is the System framework
8701
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8702
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8708
# Don't allow lazy linking, it breaks C++ global constructors
8709
# But is supposedly fixed on 10.4 or later (yay!).
8710
if test "$tagname" = CXX ; then
8711
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8713
func_append compile_command " ${wl}-bind_at_load"
8714
func_append finalize_command " ${wl}-bind_at_load"
8718
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8719
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8720
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8725
# move library search paths that coincide with paths to not yet
8726
# installed libraries to the beginning of the library search list
8728
for path in $notinst_path; do
8729
case " $new_libs " in
8730
*" -L$path/$objdir "*) ;;
8732
case " $compile_deplibs " in
8733
*" -L$path/$objdir "*)
8734
func_append new_libs " -L$path/$objdir" ;;
8739
for deplib in $compile_deplibs; do
8742
case " $new_libs " in
8744
*) func_append new_libs " $deplib" ;;
8747
*) func_append new_libs " $deplib" ;;
8750
compile_deplibs="$new_libs"
8753
func_append compile_command " $compile_deplibs"
8754
func_append finalize_command " $finalize_deplibs"
8756
if test -n "$rpath$xrpath"; then
8757
# If the user specified any rpath flags, then add them.
8758
for libdir in $rpath $xrpath; do
8759
# This is the magic to use -rpath.
8760
case "$finalize_rpath " in
8762
*) func_append finalize_rpath " $libdir" ;;
8767
# Now hardcode the library paths
8770
for libdir in $compile_rpath $finalize_rpath; do
8771
if test -n "$hardcode_libdir_flag_spec"; then
8772
if test -n "$hardcode_libdir_separator"; then
8773
if test -z "$hardcode_libdirs"; then
8774
hardcode_libdirs="$libdir"
8776
# Just accumulate the unique libdirs.
8777
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8778
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8781
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8786
eval flag=\"$hardcode_libdir_flag_spec\"
8787
func_append rpath " $flag"
8789
elif test -n "$runpath_var"; then
8790
case "$perm_rpath " in
8792
*) func_append perm_rpath " $libdir" ;;
8796
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8797
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8798
case :$dllsearchpath: in
8800
::) dllsearchpath=$libdir;;
8801
*) func_append dllsearchpath ":$libdir";;
8803
case :$dllsearchpath: in
8804
*":$testbindir:"*) ;;
8805
::) dllsearchpath=$testbindir;;
8806
*) func_append dllsearchpath ":$testbindir";;
8811
# Substitute the hardcoded libdirs into the rpath.
8812
if test -n "$hardcode_libdir_separator" &&
8813
test -n "$hardcode_libdirs"; then
8814
libdir="$hardcode_libdirs"
8815
eval rpath=\" $hardcode_libdir_flag_spec\"
8817
compile_rpath="$rpath"
8821
for libdir in $finalize_rpath; do
8822
if test -n "$hardcode_libdir_flag_spec"; then
8823
if test -n "$hardcode_libdir_separator"; then
8824
if test -z "$hardcode_libdirs"; then
8825
hardcode_libdirs="$libdir"
8827
# Just accumulate the unique libdirs.
8828
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8829
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8832
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8837
eval flag=\"$hardcode_libdir_flag_spec\"
8838
func_append rpath " $flag"
8840
elif test -n "$runpath_var"; then
8841
case "$finalize_perm_rpath " in
8843
*) func_append finalize_perm_rpath " $libdir" ;;
8847
# Substitute the hardcoded libdirs into the rpath.
8848
if test -n "$hardcode_libdir_separator" &&
8849
test -n "$hardcode_libdirs"; then
8850
libdir="$hardcode_libdirs"
8851
eval rpath=\" $hardcode_libdir_flag_spec\"
8853
finalize_rpath="$rpath"
8855
if test -n "$libobjs" && test "$build_old_libs" = yes; then
8856
# Transform all the library objects into standard objects.
8857
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8858
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8861
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8863
# template prelinking step
8864
if test -n "$prelink_cmds"; then
8865
func_execute_cmds "$prelink_cmds" 'exit $?'
8868
wrappers_required=yes
8870
*cegcc* | *mingw32ce*)
8871
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8872
wrappers_required=no
8874
*cygwin* | *mingw* )
8875
if test "$build_libtool_libs" != yes; then
8876
wrappers_required=no
8880
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8881
wrappers_required=no
8885
if test "$wrappers_required" = no; then
8886
# Replace the output file specification.
8887
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8888
link_command="$compile_command$compile_rpath"
8890
# We have no uninstalled library dependencies, so finalize right now.
8892
func_show_eval "$link_command" 'exit_status=$?'
8894
if test -n "$postlink_cmds"; then
8895
func_to_tool_file "$output"
8896
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8897
func_execute_cmds "$postlink_cmds" 'exit $?'
8900
# Delete the generated files.
8901
if test -f "$output_objdir/${outputname}S.${objext}"; then
8902
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8908
if test -n "$compile_shlibpath$finalize_shlibpath"; then
8909
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8911
if test -n "$finalize_shlibpath"; then
8912
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8917
if test -n "$runpath_var"; then
8918
if test -n "$perm_rpath"; then
8919
# We should set the runpath_var.
8921
for dir in $perm_rpath; do
8922
func_append rpath "$dir:"
8924
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8926
if test -n "$finalize_perm_rpath"; then
8927
# We should set the runpath_var.
8929
for dir in $finalize_perm_rpath; do
8930
func_append rpath "$dir:"
8932
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8936
if test "$no_install" = yes; then
8937
# We don't need to create a wrapper script.
8938
link_command="$compile_var$compile_command$compile_rpath"
8939
# Replace the output file specification.
8940
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8941
# Delete the old output file.
8942
$opt_dry_run || $RM $output
8943
# Link the executable and exit
8944
func_show_eval "$link_command" 'exit $?'
8946
if test -n "$postlink_cmds"; then
8947
func_to_tool_file "$output"
8948
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8949
func_execute_cmds "$postlink_cmds" 'exit $?'
8955
if test "$hardcode_action" = relink; then
8956
# Fast installation is not supported
8957
link_command="$compile_var$compile_command$compile_rpath"
8958
relink_command="$finalize_var$finalize_command$finalize_rpath"
8960
func_warning "this platform does not like uninstalled shared libraries"
8961
func_warning "\`$output' will be relinked during installation"
8963
if test "$fast_install" != no; then
8964
link_command="$finalize_var$compile_command$finalize_rpath"
8965
if test "$fast_install" = yes; then
8966
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8968
# fast_install is set to needless
8972
link_command="$compile_var$compile_command$compile_rpath"
8973
relink_command="$finalize_var$finalize_command$finalize_rpath"
8977
# Replace the output file specification.
8978
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8980
# Delete the old output files.
8981
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8983
func_show_eval "$link_command" 'exit $?'
8985
if test -n "$postlink_cmds"; then
8986
func_to_tool_file "$output_objdir/$outputname"
8987
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'`
8988
func_execute_cmds "$postlink_cmds" 'exit $?'
8991
# Now create the wrapper script.
8992
func_verbose "creating $output"
8994
# Quote the relink command for shipping.
8995
if test -n "$relink_command"; then
8996
# Preserve any variables that may affect compiler behavior
8997
for var in $variables_saved_for_relink; do
8998
if eval test -z \"\${$var+set}\"; then
8999
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9000
elif eval var_value=\$$var; test -z "$var_value"; then
9001
relink_command="$var=; export $var; $relink_command"
9003
func_quote_for_eval "$var_value"
9004
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9007
relink_command="(cd `pwd`; $relink_command)"
9008
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9011
# Only actually do things if not in dry run mode.
9013
# win32 will think the script is a binary if it has
9014
# a .exe suffix, so we strip it off here.
9016
*.exe) func_stripname '' '.exe' "$output"
9017
output=$func_stripname_result ;;
9019
# test for cygwin because mv fails w/o .exe extensions
9023
func_stripname '' '.exe' "$outputname"
9024
outputname=$func_stripname_result ;;
9028
*cygwin* | *mingw* )
9029
func_dirname_and_basename "$output" "" "."
9030
output_name=$func_basename_result
9031
output_path=$func_dirname_result
9032
cwrappersource="$output_path/$objdir/lt-$output_name.c"
9033
cwrapper="$output_path/$output_name.exe"
9034
$RM $cwrappersource $cwrapper
9035
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9037
func_emit_cwrapperexe_src > $cwrappersource
9039
# The wrapper executable is built using the $host compiler,
9040
# because it contains $host paths and files. If cross-
9041
# compiling, it, like the target executable, must be
9042
# executed on the $host or under an emulation environment.
9044
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9048
# Now, create the wrapper script for func_source use:
9049
func_ltwrapper_scriptname $cwrapper
9050
$RM $func_ltwrapper_scriptname_result
9051
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9053
# note: this script will not be executed, so do not chmod.
9054
if test "x$build" = "x$host" ; then
9055
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9057
func_emit_wrapper no > $func_ltwrapper_scriptname_result
9063
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9065
func_emit_wrapper no > $output
9074
# See if we need to build an old-fashioned archive.
9075
for oldlib in $oldlibs; do
9077
if test "$build_libtool_libs" = convenience; then
9078
oldobjs="$libobjs_save $symfileobj"
9079
addlibs="$convenience"
9080
build_libtool_libs=no
9082
if test "$build_libtool_libs" = module; then
9083
oldobjs="$libobjs_save"
9084
build_libtool_libs=no
9086
oldobjs="$old_deplibs $non_pic_objects"
9087
if test "$preload" = yes && test -f "$symfileobj"; then
9088
func_append oldobjs " $symfileobj"
9091
addlibs="$old_convenience"
9094
if test -n "$addlibs"; then
9095
gentop="$output_objdir/${outputname}x"
9096
func_append generated " $gentop"
9098
func_extract_archives $gentop $addlibs
9099
func_append oldobjs " $func_extract_archives_result"
9102
# Do each command in the archive commands.
9103
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9104
cmds=$old_archive_from_new_cmds
9107
# Add any objects from preloaded convenience libraries
9108
if test -n "$dlprefiles"; then
9109
gentop="$output_objdir/${outputname}x"
9110
func_append generated " $gentop"
9112
func_extract_archives $gentop $dlprefiles
9113
func_append oldobjs " $func_extract_archives_result"
9116
# POSIX demands no paths to be encoded in archives. We have
9117
# to avoid creating archives with duplicate basenames if we
9118
# might have to extract them afterwards, e.g., when creating a
9119
# static archive out of a convenience library, or when linking
9120
# the entirety of a libtool archive into another (currently
9121
# not supported by libtool).
9122
if (for obj in $oldobjs
9124
func_basename "$obj"
9125
$ECHO "$func_basename_result"
9126
done | sort | sort -uc >/dev/null 2>&1); then
9129
echo "copying selected object files to avoid basename conflicts..."
9130
gentop="$output_objdir/${outputname}x"
9131
func_append generated " $gentop"
9132
func_mkdir_p "$gentop"
9133
save_oldobjs=$oldobjs
9136
for obj in $save_oldobjs
9138
func_basename "$obj"
9139
objbase="$func_basename_result"
9140
case " $oldobjs " in
9141
" ") oldobjs=$obj ;;
9144
# Make sure we don't pick an alternate name that also
9146
newobj=lt$counter-$objbase
9147
func_arith $counter + 1
9148
counter=$func_arith_result
9149
case " $oldobjs " in
9150
*[\ /]"$newobj "*) ;;
9151
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
9154
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9155
func_append oldobjs " $gentop/$newobj"
9157
*) func_append oldobjs " $obj" ;;
9161
eval cmds=\"$old_archive_cmds\"
9164
len=$func_len_result
9165
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9166
cmds=$old_archive_cmds
9167
elif test -n "$archiver_list_spec"; then
9168
func_verbose "using command file archive linking..."
9171
func_to_tool_file "$obj"
9172
$ECHO "$func_to_tool_file_result"
9173
done > $output_objdir/$libname.libcmd
9174
func_to_tool_file "$output_objdir/$libname.libcmd"
9175
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9176
cmds=$old_archive_cmds
9178
# the command line is too long to link in one step, link in parts
9179
func_verbose "using piecewise archive linking..."
9184
save_oldobjs=$oldobjs
9186
# Is there a better way of finding the last object in the list?
9187
for obj in $save_oldobjs
9191
eval test_cmds=\"$old_archive_cmds\"
9192
func_len " $test_cmds"
9193
len0=$func_len_result
9195
for obj in $save_oldobjs
9198
func_arith $len + $func_len_result
9199
len=$func_arith_result
9200
func_append objlist " $obj"
9201
if test "$len" -lt "$max_cmd_len"; then
9204
# the above command should be used before it gets too long
9206
if test "$obj" = "$last_oldobj" ; then
9209
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9210
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9217
if test "X$oldobjs" = "X" ; then
9218
eval cmds=\"\$concat_cmds\"
9220
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9224
func_execute_cmds "$cmds" 'exit $?'
9227
test -n "$generated" && \
9228
func_show_eval "${RM}r$generated"
9230
# Now create the libtool archive.
9234
test "$build_old_libs" = yes && old_library="$libname.$libext"
9235
func_verbose "creating $output"
9237
# Preserve any variables that may affect compiler behavior
9238
for var in $variables_saved_for_relink; do
9239
if eval test -z \"\${$var+set}\"; then
9240
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9241
elif eval var_value=\$$var; test -z "$var_value"; then
9242
relink_command="$var=; export $var; $relink_command"
9244
func_quote_for_eval "$var_value"
9245
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9248
# Quote the link command for shipping.
9249
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9250
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9251
if test "$hardcode_automatic" = yes ; then
9255
# Only create the output if not a dry run.
9257
for installed in no yes; do
9258
if test "$installed" = yes; then
9259
if test -z "$install_libdir"; then
9262
output="$output_objdir/$outputname"i
9263
# Replace all uninstalled libtool libraries with the installed ones
9265
for deplib in $dependency_libs; do
9268
func_basename "$deplib"
9269
name="$func_basename_result"
9270
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9271
test -z "$libdir" && \
9272
func_fatal_error "\`$deplib' is not a valid libtool archive"
9273
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9276
func_stripname -L '' "$deplib"
9277
func_replace_sysroot "$func_stripname_result"
9278
func_append newdependency_libs " -L$func_replace_sysroot_result"
9281
func_stripname -R '' "$deplib"
9282
func_replace_sysroot "$func_stripname_result"
9283
func_append newdependency_libs " -R$func_replace_sysroot_result"
9285
*) func_append newdependency_libs " $deplib" ;;
9288
dependency_libs="$newdependency_libs"
9291
for lib in $dlfiles; do
9294
func_basename "$lib"
9295
name="$func_basename_result"
9296
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9297
test -z "$libdir" && \
9298
func_fatal_error "\`$lib' is not a valid libtool archive"
9299
func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9301
*) func_append newdlfiles " $lib" ;;
9304
dlfiles="$newdlfiles"
9306
for lib in $dlprefiles; do
9309
# Only pass preopened files to the pseudo-archive (for
9310
# eventual linking with the app. that links it) if we
9311
# didn't already link the preopened objects directly into
9313
func_basename "$lib"
9314
name="$func_basename_result"
9315
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9316
test -z "$libdir" && \
9317
func_fatal_error "\`$lib' is not a valid libtool archive"
9318
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9322
dlprefiles="$newdlprefiles"
9325
for lib in $dlfiles; do
9327
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9328
*) abs=`pwd`"/$lib" ;;
9330
func_append newdlfiles " $abs"
9332
dlfiles="$newdlfiles"
9334
for lib in $dlprefiles; do
9336
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9337
*) abs=`pwd`"/$lib" ;;
9339
func_append newdlprefiles " $abs"
9341
dlprefiles="$newdlprefiles"
9344
# place dlname in correct position for cygwin
9345
# In fact, it would be nice if we could use this code for all target
9346
# systems that can't hard-code library paths into their executables
9347
# and that have no shared library path variable independent of PATH,
9348
# but it turns out we can't easily determine that from inspecting
9349
# libtool variables, so we have to hard-code the OSs to which it
9350
# applies here; at the moment, that means platforms that use the PE
9351
# object format with DLL files. See the long comment at the top of
9352
# tests/bindir.at for full details.
9354
case $host,$output,$installed,$module,$dlname in
9355
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9356
# If a -bindir argument was supplied, place the dll there.
9357
if test "x$bindir" != x ;
9359
func_relative_path "$install_libdir" "$bindir"
9360
tdlname=$func_relative_path_result$dlname
9362
# Otherwise fall back on heuristic.
9363
tdlname=../bin/$dlname
9368
# $outputname - a libtool library file
9369
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9371
# Please DO NOT delete this file!
9372
# It is necessary for linking the library.
9374
# The name that we can dlopen(3).
9377
# Names of this library.
9378
library_names='$library_names'
9380
# The name of the static archive.
9381
old_library='$old_library'
9383
# Linker flags that can not go in dependency_libs.
9384
inherited_linker_flags='$new_inherited_linker_flags'
9386
# Libraries that this one depends upon.
9387
dependency_libs='$dependency_libs'
9389
# Names of additional weak libraries provided by this library
9390
weak_library_names='$weak_libs'
9392
# Version information for $libname.
9397
# Is this an already installed library?
9398
installed=$installed
9400
# Should we warn about portability when linking against -modules?
9401
shouldnotlink=$module
9403
# Files to dlopen/dlpreopen
9405
dlpreopen='$dlprefiles'
9407
# Directory that this library needs to be installed in:
9408
libdir='$install_libdir'"
9409
if test "$installed" = no && test "$need_relink" = yes; then
9411
relink_command=\"$relink_command\""
9416
# Do a symbolic link so that the libtool archive can be found in
9417
# LD_LIBRARY_PATH before the program is installed.
9418
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9424
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9425
func_mode_link ${1+"$@"}
9428
# func_mode_uninstall arg...
9429
func_mode_uninstall ()
9437
# This variable tells wrapper scripts just to set variables rather
9438
# than running their programs.
9439
libtool_install_magic="$magic"
9444
-f) func_append RM " $arg"; rmforce=yes ;;
9445
-*) func_append RM " $arg" ;;
9446
*) func_append files " $arg" ;;
9451
func_fatal_help "you must specify an RM program"
9455
for file in $files; do
9456
func_dirname "$file" "" "."
9457
dir="$func_dirname_result"
9458
if test "X$dir" = X.; then
9463
func_basename "$file"
9464
name="$func_basename_result"
9465
test "$opt_mode" = uninstall && odir="$dir"
9467
# Remember odir for removal later, being careful to avoid duplicates
9468
if test "$opt_mode" = clean; then
9471
*) func_append rmdirs " $odir" ;;
9475
# Don't error if the file doesn't exist and rm -f was used.
9476
if { test -L "$file"; } >/dev/null 2>&1 ||
9477
{ test -h "$file"; } >/dev/null 2>&1 ||
9478
test -f "$file"; then
9480
elif test -d "$file"; then
9483
elif test "$rmforce" = yes; then
9491
# Possibly a libtool archive, so verify it.
9492
if func_lalib_p "$file"; then
9493
func_source $dir/$name
9495
# Delete the libtool libraries and symlinks.
9496
for n in $library_names; do
9497
func_append rmfiles " $odir/$n"
9499
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9503
case " $library_names " in
9505
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9507
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9510
if test -n "$library_names"; then
9511
# Do each command in the postuninstall commands.
9512
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9515
if test -n "$old_library"; then
9516
# Do each command in the old_postuninstall commands.
9517
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9519
# FIXME: should reinstall the best remaining shared library.
9526
# Possibly a libtool object, so verify it.
9527
if func_lalib_p "$file"; then
9530
func_source $dir/$name
9532
# Add PIC object to the list of files to remove.
9533
if test -n "$pic_object" &&
9534
test "$pic_object" != none; then
9535
func_append rmfiles " $dir/$pic_object"
9538
# Add non-PIC object to the list of files to remove.
9539
if test -n "$non_pic_object" &&
9540
test "$non_pic_object" != none; then
9541
func_append rmfiles " $dir/$non_pic_object"
9547
if test "$opt_mode" = clean ; then
9551
func_stripname '' '.exe' "$file"
9552
file=$func_stripname_result
9553
func_stripname '' '.exe' "$name"
9554
noexename=$func_stripname_result
9555
# $file with .exe has already been added to rmfiles,
9556
# add $file without .exe
9557
func_append rmfiles " $file"
9560
# Do a test to see if this is a libtool program.
9561
if func_ltwrapper_p "$file"; then
9562
if func_ltwrapper_executable_p "$file"; then
9563
func_ltwrapper_scriptname "$file"
9565
func_source $func_ltwrapper_scriptname_result
9566
func_append rmfiles " $func_ltwrapper_scriptname_result"
9569
func_source $dir/$noexename
9572
# note $name still contains .exe if it was in $file originally
9573
# as does the version of $file that was added into $rmfiles
9574
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9575
if test "$fast_install" = yes && test -n "$relink_command"; then
9576
func_append rmfiles " $odir/lt-$name"
9578
if test "X$noexename" != "X$name" ; then
9579
func_append rmfiles " $odir/lt-${noexename}.c"
9585
func_show_eval "$RM $rmfiles" 'exit_status=1'
9588
# Try to remove the ${objdir}s in the directories where we deleted files
9589
for dir in $rmdirs; do
9590
if test -d "$dir"; then
9591
func_show_eval "rmdir $dir >/dev/null 2>&1"
9598
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9599
func_mode_uninstall ${1+"$@"}
9601
test -z "$opt_mode" && {
9602
help="$generic_help"
9603
func_fatal_help "you must specify a MODE"
9606
test -z "$exec_cmd" && \
9607
func_fatal_help "invalid operation mode \`$opt_mode'"
9609
if test -n "$exec_cmd"; then
9610
eval exec "$exec_cmd"
9617
# The TAGs below are defined such that we never get into a situation
9618
# in which we disable both kinds of libraries. Given conflicting
9619
# choices, we go for a static library, that is the most portable,
9620
# since we can't tell whether shared libraries were disabled because
9621
# the user asked for that or because the platform doesn't support
9622
# them. This is particularly important on AIX, because we don't
9623
# support having both static and shared libraries enabled at the same
9624
# time on that platform, so we default to a shared-only configuration.
9625
# If a disable-shared tag is given, we'll fallback to a static-only
9626
# configuration. But we'll never go from static-only to shared-only.
9628
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9629
build_libtool_libs=no
9631
# ### END LIBTOOL TAG CONFIG: disable-shared
9633
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
9634
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9635
# ### END LIBTOOL TAG CONFIG: disable-static