2
# libtool (GNU libtool) 2.4.2
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, 2011 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
# --no-warn don't display warning messages
45
# --tag=TAG use configuration variables from tag TAG
46
# -v, --verbose print more informational messages than default
47
# --no-verbose don't print the extra informational messages
48
# --version print version information
49
# -h, --help, --help-all print short, long, or detailed help message
51
# MODE must be one of the following:
53
# clean remove files from the build directory
54
# compile compile a source file into a libtool object
55
# execute automatically set library path, then run a program
56
# finish complete the installation of libtool libraries
57
# install install libraries or executables
58
# link create a library or an executable
59
# uninstall remove libraries from an installed directory
61
# MODE-ARGS vary depending on the MODE. When passed as first option,
62
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
63
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
65
# When reporting a bug, please describe a test case to reproduce it and
66
# include the following information:
71
# compiler flags: $LTCFLAGS
72
# linker: $LD (gnu? $with_gnu_ld)
73
# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1ubuntu1
74
# automake: $automake_version
75
# autoconf: $autoconf_version
77
# Report bugs to <bug-libtool@gnu.org>.
78
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79
# General help using GNU software: <http://www.gnu.org/gethelp/>.
83
VERSION="2.4.2 Debian-2.4.2-1ubuntu1"
85
package_revision=1.3337
87
# Be Bourne compatible
88
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
91
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92
# is contrary to our usage. Disable this feature.
93
alias -g '${1+"$@"}'='"$@"'
96
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
98
BIN_SH=xpg4; export BIN_SH # for Tru64
99
DUALCASE=1; export DUALCASE # for MKS sh
101
# A function that is used when there is no print builtin or printf.
102
func_fallback_echo ()
104
eval 'cat <<_LTECHO_EOF
109
# NLS nuisances: We save the old values to restore during execute mode.
112
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
114
eval "if test \"\${$lt_var+set}\" = set; then
115
save_$lt_var=\$$lt_var
118
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
124
export LANGUAGE LC_ALL
129
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130
# is ksh but when the shell is invoked as "sh" and the current value of
131
# the _XPG environment variable is not equal to 1 (one), the special
132
# positional parameter $0, within a function call, is the name of the
139
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
144
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145
: ${Xsed="$SED -e 1s/^X//"}
150
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
151
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
153
exit_status=$EXIT_SUCCESS
155
# Make sure IFS has a sensible default
160
dirname="s,/[^/]*$,,"
163
# func_dirname file append nondir_replacement
164
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
165
# otherwise set result to NONDIR_REPLACEMENT.
168
func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
169
if test "X$func_dirname_result" = "X${1}"; then
170
func_dirname_result="${3}"
172
func_dirname_result="$func_dirname_result${2}"
174
} # func_dirname may be replaced by extended shell implementation
180
func_basename_result=`$ECHO "${1}" | $SED "$basename"`
181
} # func_basename may be replaced by extended shell implementation
184
# func_dirname_and_basename file append nondir_replacement
185
# perform func_basename and func_dirname in a single function
187
# dirname: Compute the dirname of FILE. If nonempty,
188
# add APPEND to the result, otherwise set result
189
# to NONDIR_REPLACEMENT.
190
# value returned in "$func_dirname_result"
191
# basename: Compute filename of FILE.
192
# value retuned in "$func_basename_result"
193
# Implementation must be kept synchronized with func_dirname
194
# and func_basename. For efficiency, we do not delegate to
195
# those functions but instead duplicate the functionality here.
196
func_dirname_and_basename ()
198
# Extract subdirectory from the argument.
199
func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
200
if test "X$func_dirname_result" = "X${1}"; then
201
func_dirname_result="${3}"
203
func_dirname_result="$func_dirname_result${2}"
205
func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
206
} # func_dirname_and_basename may be replaced by extended shell implementation
209
# func_stripname prefix suffix name
210
# strip PREFIX and SUFFIX off of NAME.
211
# PREFIX and SUFFIX must not contain globbing or regex special
212
# characters, hashes, percent signs, but SUFFIX may contain a leading
213
# dot (in which case that matches only a dot).
214
# func_strip_suffix prefix name
218
.*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219
*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
221
} # func_stripname may be replaced by extended shell implementation
224
# These SED scripts presuppose an absolute path with a trailing slash.
225
pathcar='s,^/\([^/]*\).*$,\1,'
226
pathcdr='s,^/[^/]*,,'
227
removedotparts=':dotsl
231
collapseslashes='s@/\{1,\}@/@g'
232
finalslash='s,/*$,/,'
234
# func_normal_abspath PATH
235
# Remove doubled-up and trailing slashes, "." path components,
236
# and cancel out any ".." path components in PATH after making
237
# it an absolute path.
238
# value returned in "$func_normal_abspath_result"
239
func_normal_abspath ()
241
# Start from root dir and reassemble the path.
242
func_normal_abspath_result=
243
func_normal_abspath_tpath=$1
244
func_normal_abspath_altnamespace=
245
case $func_normal_abspath_tpath in
247
# Empty path, that just means $cwd.
248
func_stripname '' '/' "`pwd`"
249
func_normal_abspath_result=$func_stripname_result
252
# The next three entries are used to spot a run of precisely
253
# two leading slashes without using negated character classes;
254
# we take advantage of case's first-match behaviour.
256
# Unusual form of absolute path, do nothing.
259
# Not necessarily an ordinary path; POSIX reserves leading '//'
260
# and for example Cygwin uses it to access remote file shares
261
# over CIFS/SMB, so we conserve a leading double slash if found.
262
func_normal_abspath_altnamespace=/
265
# Absolute path, do nothing.
268
# Relative path, prepend $cwd.
269
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
272
# Cancel out all the simple stuff to save iterations. We also want
273
# the path to end with a slash for ease of parsing, so make sure
274
# there is one (and only one) here.
275
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
276
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
278
# Processed it all yet?
279
if test "$func_normal_abspath_tpath" = / ; then
280
# If we ascended to the root using ".." the result may be empty now.
281
if test -z "$func_normal_abspath_result" ; then
282
func_normal_abspath_result=/
286
func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
288
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
290
# Figure out what to do with it
291
case $func_normal_abspath_tcomponent in
293
# Trailing empty path component, ignore it.
296
# Parent dir; strip last assembled component from result.
297
func_dirname "$func_normal_abspath_result"
298
func_normal_abspath_result=$func_dirname_result
301
# Actual path component, append it.
302
func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
306
# Restore leading double-slash if one was found on entry.
307
func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
310
# func_relative_path SRCDIR DSTDIR
311
# generates a relative path from SRCDIR to DSTDIR, with a trailing
312
# slash if non-empty, suitable for immediately appending a filename
313
# without needing to append a separator.
314
# value returned in "$func_relative_path_result"
315
func_relative_path ()
317
func_relative_path_result=
318
func_normal_abspath "$1"
319
func_relative_path_tlibdir=$func_normal_abspath_result
320
func_normal_abspath "$2"
321
func_relative_path_tbindir=$func_normal_abspath_result
323
# Ascend the tree starting from libdir
325
# check if we have found a prefix of bindir
326
case $func_relative_path_tbindir in
327
$func_relative_path_tlibdir)
328
# found an exact match
329
func_relative_path_tcancelled=
332
$func_relative_path_tlibdir*)
333
# found a matching prefix
334
func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335
func_relative_path_tcancelled=$func_stripname_result
336
if test -z "$func_relative_path_result"; then
337
func_relative_path_result=.
342
func_dirname $func_relative_path_tlibdir
343
func_relative_path_tlibdir=${func_dirname_result}
344
if test "x$func_relative_path_tlibdir" = x ; then
345
# Have to descend all the way to the root!
346
func_relative_path_result=../$func_relative_path_result
347
func_relative_path_tcancelled=$func_relative_path_tbindir
350
func_relative_path_result=../$func_relative_path_result
355
# Now calculate path; take care to avoid doubling-up slashes.
356
func_stripname '' '/' "$func_relative_path_result"
357
func_relative_path_result=$func_stripname_result
358
func_stripname '/' '/' "$func_relative_path_tcancelled"
359
if test "x$func_stripname_result" != x ; then
360
func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
363
# Normalisation. If bindir is libdir, return empty string,
364
# else relative path ending with a slash; either way, target
365
# file name can be directly appended.
366
if test ! -z "$func_relative_path_result"; then
367
func_stripname './' '' "$func_relative_path_result/"
368
func_relative_path_result=$func_stripname_result
372
# The name of this program:
373
func_dirname_and_basename "$progpath"
374
progname=$func_basename_result
376
# Make sure we have an absolute path for reexecution:
378
[\\/]*|[A-Za-z]:\\*) ;;
380
progdir=$func_dirname_result
381
progdir=`cd "$progdir" && pwd`
382
progpath="$progdir/$progname"
386
IFS=${PATH_SEPARATOR-:}
387
for progdir in $PATH; do
389
test -x "$progdir/$progname" && break
392
test -n "$progdir" || progdir=`pwd`
393
progpath="$progdir/$progname"
397
# Sed substitution that helps us do robust quoting. It backslashifies
398
# metacharacters that are still active within double-quoted strings.
399
Xsed="${SED}"' -e 1s/^X//'
400
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
402
# Same as above, but do not quote variable references.
403
double_quote_subst='s/\(["`\\]\)/\\\1/g'
405
# Sed substitution that turns a string into a regex matching for the
407
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
409
# Sed substitution that converts a w32 file name or path
410
# which contains forward slashes, into one that contains
411
# (escaped) backslashes. A very naive implementation.
412
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
414
# Re-`\' parameter expansions in output of double_quote_subst that were
415
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
416
# in input to double_quote_subst, that '$' was protected from expansion.
417
# Since each input `\' is now two `\'s, look for any number of runs of
418
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
423
sed_double_backslash="\
427
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
438
# Echo program name prefixed message, along with the current mode
439
# name if it has been set yet.
442
$ECHO "$progname: ${opt_mode+$opt_mode: }$*"
445
# func_verbose arg...
446
# Echo program name prefixed message in verbose mode only.
449
$opt_verbose && func_echo ${1+"$@"}
451
# A bug in bash halts the script if the last line of a function
452
# fails when set -e is in force, so we need another command to
457
# func_echo_all arg...
458
# Invoke $ECHO with all args, space-separated.
465
# Echo program name prefixed message to standard error.
468
$ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
471
# func_warning arg...
472
# Echo program name prefixed warning message to standard error.
475
$opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
481
# func_fatal_error arg...
482
# Echo program name prefixed message to standard error, and exit.
489
# func_fatal_help arg...
490
# Echo program name prefixed message to standard error, followed by
491
# a help hint, and exit.
495
func_fatal_error "$help"
497
help="Try \`$progname --help' for more information." ## default
500
# func_grep expression filename
501
# Check whether EXPRESSION matches any line of FILENAME, without output.
504
$GREP "$1" "$2" >/dev/null 2>&1
508
# func_mkdir_p directory-path
509
# Make sure the entire path to DIRECTORY-PATH is available.
512
my_directory_path="$1"
515
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
517
# Protect directory names starting with `-'
518
case $my_directory_path in
519
-*) my_directory_path="./$my_directory_path" ;;
522
# While some portion of DIR does not yet exist...
523
while test ! -d "$my_directory_path"; do
524
# ...make a list in topmost first order. Use a colon delimited
525
# list incase some portion of path contains whitespace.
526
my_dir_list="$my_directory_path:$my_dir_list"
528
# If the last portion added has no slash in it, the list is done
529
case $my_directory_path in */*) ;; *) break ;; esac
531
# ...otherwise throw away the child directory and loop
532
my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
534
my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
536
save_mkdir_p_IFS="$IFS"; IFS=':'
537
for my_dir in $my_dir_list; do
538
IFS="$save_mkdir_p_IFS"
539
# mkdir can fail with a `File exist' error if two processes
540
# try to create one of the directories concurrently. Don't
542
$MKDIR "$my_dir" 2>/dev/null || :
544
IFS="$save_mkdir_p_IFS"
546
# Bail out if we (or some other process) failed to create a directory.
547
test -d "$my_directory_path" || \
548
func_fatal_error "Failed to create \`$1'"
553
# func_mktempdir [string]
554
# Make a temporary directory that won't clash with other running
555
# libtool processes, and avoids race conditions if possible. If
556
# given, STRING is the basename for that directory.
559
my_template="${TMPDIR-/tmp}/${1-$progname}"
561
if test "$opt_dry_run" = ":"; then
562
# Return a directory name, but don't create it in dry-run mode
563
my_tmpdir="${my_template}-$$"
566
# If mktemp works, use that first and foremost
567
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
569
if test ! -d "$my_tmpdir"; then
570
# Failing that, at least try and use $RANDOM to avoid a race
571
my_tmpdir="${my_template}-${RANDOM-0}$$"
573
save_mktempdir_umask=`umask`
576
umask $save_mktempdir_umask
579
# If we're not in dry-run mode, bomb out on failure
580
test -d "$my_tmpdir" || \
581
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
588
# func_quote_for_eval arg
589
# Aesthetically quote ARG to be evaled later.
590
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591
# is double-quoted, suitable for a subsequent eval, whereas
592
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593
# which are still active within double quotes backslashified.
594
func_quote_for_eval ()
598
func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
600
func_quote_for_eval_unquoted_result="$1" ;;
603
case $func_quote_for_eval_unquoted_result in
604
# Double-quote args containing shell metacharacters to delay
605
# word splitting, command substitution and and variable
606
# expansion for a subsequent eval.
607
# Many Bourne shells cannot handle close brackets correctly
608
# in scan sets, so we specify it separately.
609
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
610
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
613
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
618
# func_quote_for_expand arg
619
# Aesthetically quote ARG to be evaled later; same as above,
620
# but do not quote variable references.
621
func_quote_for_expand ()
625
my_arg=`$ECHO "$1" | $SED \
626
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
632
# Double-quote args containing shell metacharacters to delay
633
# word splitting and command substitution for a subsequent eval.
634
# Many Bourne shells cannot handle close brackets correctly
635
# in scan sets, so we specify it separately.
636
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
641
func_quote_for_expand_result="$my_arg"
645
# func_show_eval cmd [fail_exp]
646
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
647
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
648
# is given, then evaluate it.
654
${opt_silent-false} || {
655
func_quote_for_expand "$my_cmd"
656
eval "func_echo $func_quote_for_expand_result"
659
if ${opt_dry_run-false}; then :; else
662
if test "$my_status" -eq 0; then :; else
663
eval "(exit $my_status); $my_fail_exp"
669
# func_show_eval_locale cmd [fail_exp]
670
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
671
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
672
# is given, then evaluate it. Use the saved locale for evaluation.
673
func_show_eval_locale ()
678
${opt_silent-false} || {
679
func_quote_for_expand "$my_cmd"
680
eval "func_echo $func_quote_for_expand_result"
683
if ${opt_dry_run-false}; then :; else
684
eval "$lt_user_locale
687
eval "$lt_safe_locale"
688
if test "$my_status" -eq 0; then :; else
689
eval "(exit $my_status); $my_fail_exp"
695
# Turn $1 into a string suitable for a shell variable name.
696
# Result is stored in $func_tr_sh_result. All characters
697
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698
# if $1 begins with a digit, a '_' is prepended as well.
702
[0-9]* | *[!a-zA-Z0-9_]*)
703
func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
713
# Echo version message to standard output and exit.
726
/^# '$PROGRAM' (GNU /,/# warranty; / {
729
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
736
# Echo short help message to standard output and exit.
741
$SED -n '/^# Usage:/,/^# *.*--help/ {
744
s/\$progname/'$progname'/
748
$ECHO "run \`$progname --help | more' for full usage"
753
# Echo long help message to standard output and exit,
754
# unless 'noexit' is passed as argument.
759
$SED -n '/^# Usage:/,/# Report bugs to/ {
763
s*\$progname*'$progname'*
765
s*\$SHELL*'"$SHELL"'*
767
s*\$LTCFLAGS*'"$LTCFLAGS"'*
769
s/\$with_gnu_ld/'"$with_gnu_ld"'/
770
s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771
s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
775
/^# .* home page:/b print
776
/^# General help using/b print
779
if test -z "$1"; then
784
# func_missing_arg argname
785
# Echo program name prefixed message to standard error and set global
791
func_error "missing argument for $1."
796
# func_split_short_opt shortopt
797
# Set func_split_short_opt_name and func_split_short_opt_arg shell
798
# variables after splitting SHORTOPT after the 2nd character.
799
func_split_short_opt ()
801
my_sed_short_opt='1s/^\(..\).*$/\1/;q'
802
my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
804
func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805
func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806
} # func_split_short_opt may be replaced by extended shell implementation
809
# func_split_long_opt longopt
810
# Set func_split_long_opt_name and func_split_long_opt_arg shell
811
# variables after splitting LONGOPT at the `=' sign.
812
func_split_long_opt ()
814
my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
815
my_sed_long_arg='1s/^--[^=]*=//'
817
func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818
func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819
} # func_split_long_opt may be replaced by extended shell implementation
827
magic="%%%MAGIC variable%%%"
828
magic_exe="%%%MAGIC EXE variable%%%"
833
lo2o="s/\\.lo\$/.${objext}/"
834
o2lo="s/\\.${objext}\$/.lo/"
838
# If this variable is set in any of the actions, the command in it
839
# will be execed at the end. This prevents here-documents from being
840
# left over by shells.
843
# func_append var value
844
# Append VALUE to the end of shell variable VAR.
847
eval "${1}=\$${1}\${2}"
848
} # func_append may be replaced by extended shell implementation
850
# func_append_quoted var value
851
# Quote VALUE and append to the end of shell variable VAR, separated
853
func_append_quoted ()
855
func_quote_for_eval "${2}"
856
eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857
} # func_append_quoted may be replaced by extended shell implementation
860
# func_arith arithmetic-term...
863
func_arith_result=`expr "${@}"`
864
} # func_arith may be replaced by extended shell implementation
868
# STRING may not start with a hyphen.
871
func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872
} # func_len may be replaced by extended shell implementation
878
func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
879
} # func_lo2o may be replaced by extended shell implementation
882
# func_xform libobj-or-source
885
func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886
} # func_xform may be replaced by extended shell implementation
889
# func_fatal_configuration arg...
890
# Echo program name prefixed message to standard error, followed by
891
# a configuration failure hint, and exit.
892
func_fatal_configuration ()
895
func_error "See the $PACKAGE documentation for more information."
896
func_fatal_error "Fatal configuration error."
901
# Display the configuration for all the tags in this script.
904
re_begincf='^# ### BEGIN LIBTOOL'
905
re_endcf='^# ### END LIBTOOL'
907
# Default configuration.
908
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
910
# Now print the configurations for the tags.
911
for tagname in $taglist; do
912
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
919
# Display the features supported by this script.
923
if test "$build_libtool_libs" = yes; then
924
echo "enable shared libraries"
926
echo "disable shared libraries"
928
if test "$build_old_libs" = yes; then
929
echo "enable static libraries"
931
echo "disable static libraries"
937
# func_enable_tag tagname
938
# Verify that TAGNAME is valid, and either flag an error and exit, or
939
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
946
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948
sed_extractcf="/$re_begincf/,/$re_endcf/p"
953
func_fatal_error "invalid tag name: $tagname"
957
# Don't test for the "default" C tag, as we know it's
958
# there but not specially marked.
962
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
963
taglist="$taglist $tagname"
965
# Evaluate the configuration. Be careful to quote the path
966
# and the sed script, to avoid splitting on whitespace, but
967
# also don't use non-portable quotes within backquotes within
968
# quotes we have to do it in 2 steps:
969
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
972
func_error "ignoring unknown tag $tagname"
978
# func_check_version_match
979
# Ensure that we are using m4 macros, and libtool script from the same
980
# release of libtool.
981
func_check_version_match ()
983
if test "$package_revision" != "$macro_revision"; then
984
if test "$VERSION" != "$macro_version"; then
985
if test -z "$macro_version"; then
987
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
988
$progname: definition of this LT_INIT comes from an older release.
989
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990
$progname: and run autoconf again.
994
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
995
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997
$progname: and run autoconf again.
1002
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1003
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005
$progname: of $PACKAGE $VERSION and run autoconf again.
1014
# Shorthand for --mode=foo, only valid as the first argument
1017
shift; set dummy --mode clean ${1+"$@"}; shift
1019
compile|compil|compi|comp|com|co|c)
1020
shift; set dummy --mode compile ${1+"$@"}; shift
1022
execute|execut|execu|exec|exe|ex|e)
1023
shift; set dummy --mode execute ${1+"$@"}; shift
1025
finish|finis|fini|fin|fi|f)
1026
shift; set dummy --mode finish ${1+"$@"}; shift
1028
install|instal|insta|inst|ins|in|i)
1029
shift; set dummy --mode install ${1+"$@"}; shift
1032
shift; set dummy --mode link ${1+"$@"}; shift
1034
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1035
shift; set dummy --mode uninstall ${1+"$@"}; shift
1045
opt_preserve_dup_deps=false
1057
# Parse options once, thoroughly. This comes as soon as possible in the
1058
# script to make things like `--version' happen as quickly as we can.
1060
# this just eases exit handling
1061
while test $# -gt 0; do
1065
--debug|-x) opt_debug='set -x'
1066
func_echo "enabling shell trace mode"
1069
--dry-run|--dryrun|-n)
1078
opt_dlopen="${opt_dlopen+$opt_dlopen
1082
--preserve-dup-deps)
1083
opt_preserve_dup_deps=:
1091
set dummy --mode finish ${1+"$@"}; shift
1098
opt_help=': help-all'
1101
test $# = 0 && func_missing_arg $opt && break
1105
# Valid mode arguments:
1106
clean|compile|execute|finish|install|link|relink|uninstall) ;;
1108
# Catch anything else as an error
1109
*) func_error "invalid argument for $opt"
1116
--no-silent|--no-quiet)
1118
func_append preserve_args " $opt"
1120
--no-warning|--no-warn)
1122
func_append preserve_args " $opt"
1126
func_append preserve_args " $opt"
1130
func_append preserve_args " $opt"
1135
func_append preserve_args " $opt"
1139
test $# = 0 && func_missing_arg $opt && break
1142
func_append preserve_args " $opt $optarg"
1143
func_enable_tag "$optarg"
1147
-\?|-h) func_usage ;;
1148
--help) func_help ;;
1149
--version) func_version ;;
1151
# Separate optargs to long options:
1153
func_split_long_opt "$opt"
1154
set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1158
# Separate non-argument short options:
1160
func_split_short_opt "$opt"
1161
set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1166
-*) func_fatal_help "unrecognized option \`$opt'" ;;
1167
*) set dummy "$opt" ${1+"$@"}; shift; break ;;
1173
# save first non-option argument
1174
if test "$#" -gt 0; then
1180
test "$opt_debug" = : || func_append preserve_args " --debug"
1183
*cygwin* | *mingw* | *pw32* | *cegcc*)
1184
# don't eliminate duplications in $postdeps and $predeps
1185
opt_duplicate_compiler_generated_deps=:
1188
opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1193
# Sanity checks first:
1194
func_check_version_match
1196
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197
func_fatal_configuration "not configured to build any kind of library"
1201
eval std_shrext=\"$shrext_cmds\"
1203
# Only execute mode is allowed to have -dlopen flags.
1204
if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1205
func_error "unrecognized option \`-dlopen'"
1210
# Change the help message to a mode-specific one.
1211
generic_help="$help"
1212
help="Try \`$progname --help --mode=$opt_mode' for more information."
1216
# Bail if the options were screwed
1217
$exit_cmd $EXIT_FAILURE
1228
# True iff FILE is a libtool `.la' library or `.lo' object file.
1229
# This function is only a basic sanity check; it will hardly flush out
1230
# determined imposters.
1234
$SED -e 4q "$1" 2>/dev/null \
1235
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1238
# func_lalib_unsafe_p file
1239
# True iff FILE is a libtool `.la' library or `.lo' object file.
1240
# This function implements the same check as func_lalib_p without
1241
# resorting to external programs. To this end, it redirects stdin and
1242
# closes it afterwards, without saving the original file descriptor.
1243
# As a safety measure, use it only where a negative result would be
1244
# fatal anyway. Works if `file' does not exist.
1245
func_lalib_unsafe_p ()
1248
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249
for lalib_p_l in 1 2 3 4
1252
case "$lalib_p_line" in
1253
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1258
test "$lalib_p" = yes
1261
# func_ltwrapper_script_p file
1262
# True iff FILE is a libtool wrapper script
1263
# This function is only a basic sanity check; it will hardly flush out
1264
# determined imposters.
1265
func_ltwrapper_script_p ()
1270
# func_ltwrapper_executable_p file
1271
# True iff FILE is a libtool wrapper executable
1272
# This function is only a basic sanity check; it will hardly flush out
1273
# determined imposters.
1274
func_ltwrapper_executable_p ()
1276
func_ltwrapper_exec_suffix=
1279
*) func_ltwrapper_exec_suffix=.exe ;;
1281
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1284
# func_ltwrapper_scriptname file
1285
# Assumes file is an ltwrapper_executable
1286
# uses $file to determine the appropriate filename for a
1287
# temporary ltwrapper_script.
1288
func_ltwrapper_scriptname ()
1290
func_dirname_and_basename "$1" "" "."
1291
func_stripname '' '.exe' "$func_basename_result"
1292
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1295
# func_ltwrapper_p file
1296
# True iff FILE is a libtool wrapper script or wrapper executable
1297
# This function is only a basic sanity check; it will hardly flush out
1298
# determined imposters.
1301
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1305
# func_execute_cmds commands fail_cmd
1306
# Execute tilde-delimited COMMANDS.
1307
# If FAIL_CMD is given, eval that upon failure.
1308
# FAIL_CMD may read-access the current command in variable CMD!
1309
func_execute_cmds ()
1312
save_ifs=$IFS; IFS='~'
1316
func_show_eval "$cmd" "${2-:}"
1323
# Source FILE, adding directory component if necessary.
1324
# Note that it is not necessary on cygwin/mingw to append a dot to
1325
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326
# behavior happens only for exec(3), not for open(2)! Also, sourcing
1327
# `FILE.' does not work on cygwin managed mounts.
1332
*/* | *\\*) . "$1" ;;
1338
# func_resolve_sysroot PATH
1339
# Replace a leading = in PATH with a sysroot. Store the result into
1340
# func_resolve_sysroot_result
1341
func_resolve_sysroot ()
1343
func_resolve_sysroot_result=$1
1344
case $func_resolve_sysroot_result in
1346
func_stripname '=' '' "$func_resolve_sysroot_result"
1347
func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1352
# func_replace_sysroot PATH
1353
# If PATH begins with the sysroot, replace it with = and
1354
# store the result into func_replace_sysroot_result.
1355
func_replace_sysroot ()
1357
case "$lt_sysroot:$1" in
1359
func_stripname "$lt_sysroot" '' "$1"
1360
func_replace_sysroot_result="=$func_stripname_result"
1363
# Including no sysroot.
1364
func_replace_sysroot_result=$1
1369
# func_infer_tag arg
1370
# Infer tagged configuration to use if any are available and
1371
# if one wasn't chosen via the "--tag" command line option.
1372
# Only attempt this if the compiler in the base compile
1373
# command doesn't match the default compiler.
1374
# arg is usually of the form 'gcc ...'
1378
if test -n "$available_tags" && test -z "$tagname"; then
1381
func_append_quoted CC_quoted "$arg"
1383
CC_expanded=`func_echo_all $CC`
1384
CC_quoted_expanded=`func_echo_all $CC_quoted`
1386
# Blanks in the command may have been stripped by the calling shell,
1387
# but not from the CC environment variable when configure was run.
1388
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1389
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1390
# Blanks at the start of $base_compile will cause this to fail
1391
# if we don't check for them as well.
1393
for z in $available_tags; do
1394
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1395
# Evaluate the configuration.
1396
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1399
# Double-quote args containing other shell metacharacters.
1400
func_append_quoted CC_quoted "$arg"
1402
CC_expanded=`func_echo_all $CC`
1403
CC_quoted_expanded=`func_echo_all $CC_quoted`
1405
" $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1406
" $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1407
# The compiler in the base compile command matches
1408
# the one in the tagged configuration.
1409
# Assume this is the tagged configuration we want.
1416
# If $tagname still isn't set, then no tagged configuration
1417
# was found and let the user know that the "--tag" command
1418
# line option must be used.
1419
if test -z "$tagname"; then
1420
func_echo "unable to infer tagged configuration"
1421
func_fatal_error "specify a tag with \`--tag'"
1423
# func_verbose "using $tagname tagged configuration"
1432
# func_write_libtool_object output_name pic_name nonpic_name
1433
# Create a libtool object file (analogous to a ".la" file),
1434
# but don't create it if we're doing a dry run.
1435
func_write_libtool_object ()
1438
if test "$build_libtool_libs" = yes; then
1444
if test "$build_old_libs" = yes; then
1445
write_oldobj=\'${3}\'
1451
cat >${write_libobj}T <<EOF
1452
# $write_libobj - a libtool object file
1453
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1455
# Please DO NOT delete this file!
1456
# It is necessary for linking the library.
1458
# Name of the PIC object.
1459
pic_object=$write_lobj
1461
# Name of the non-PIC object
1462
non_pic_object=$write_oldobj
1465
$MV "${write_libobj}T" "${write_libobj}"
1470
##################################################
1471
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472
##################################################
1474
# func_convert_core_file_wine_to_w32 ARG
1475
# Helper function used by file name conversion functions when $build is *nix,
1476
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477
# correctly configured wine environment available, with the winepath program
1478
# in $build's $PATH.
1480
# ARG is the $build file name to be converted to w32 format.
1481
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482
# be empty on error (or when ARG is empty)
1483
func_convert_core_file_wine_to_w32 ()
1486
func_convert_core_file_wine_to_w32_result="$1"
1487
if test -n "$1"; then
1488
# Unfortunately, winepath does not exit with a non-zero error code, so we
1489
# are forced to check the contents of stdout. On the other hand, if the
1490
# command is not found, the shell will set an exit code of 127 and print
1491
# *an error message* to stdout. So we must check for both error code of
1492
# zero AND non-empty stdout, which explains the odd construction:
1493
func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1494
if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495
func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496
$SED -e "$lt_sed_naive_backslashify"`
1498
func_convert_core_file_wine_to_w32_result=
1502
# end: func_convert_core_file_wine_to_w32
1505
# func_convert_core_path_wine_to_w32 ARG
1506
# Helper function used by path conversion functions when $build is *nix, and
1507
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508
# configured wine environment available, with the winepath program in $build's
1509
# $PATH. Assumes ARG has no leading or trailing path separator characters.
1511
# ARG is path to be converted from $build format to win32.
1512
# Result is available in $func_convert_core_path_wine_to_w32_result.
1513
# Unconvertible file (directory) names in ARG are skipped; if no directory names
1514
# are convertible, then the result may be empty.
1515
func_convert_core_path_wine_to_w32 ()
1518
# unfortunately, winepath doesn't convert paths, only file names
1519
func_convert_core_path_wine_to_w32_result=""
1520
if test -n "$1"; then
1523
for func_convert_core_path_wine_to_w32_f in $1; do
1525
func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1526
if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527
if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528
func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1530
func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1537
# end: func_convert_core_path_wine_to_w32
1540
# func_cygpath ARGS...
1541
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544
# (2), returns the Cygwin file name or path in func_cygpath_result (input
1545
# file name or path is assumed to be in w32 format, as previously converted
1546
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547
# or path in func_cygpath_result (input file name or path is assumed to be in
1548
# Cygwin format). Returns an empty string on error.
1550
# ARGS are passed to cygpath, with the last one being the file name or path to
1553
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554
# environment variable; do not put it in $PATH.
1558
if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559
func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1560
if test "$?" -ne 0; then
1561
# on failure, ensure result is empty
1562
func_cygpath_result=
1565
func_cygpath_result=
1566
func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1572
# func_convert_core_msys_to_w32 ARG
1573
# Convert file name or path ARG from MSYS format to w32 format. Return
1574
# result in func_convert_core_msys_to_w32_result.
1575
func_convert_core_msys_to_w32 ()
1578
# awkward: cmd appends spaces to result
1579
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1580
$SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1582
#end: func_convert_core_msys_to_w32
1585
# func_convert_file_check ARG1 ARG2
1586
# Verify that ARG1 (a file name in $build format) was converted to $host
1587
# format in ARG2. Otherwise, emit an error message, but continue (resetting
1588
# func_to_host_file_result to ARG1).
1589
func_convert_file_check ()
1592
if test -z "$2" && test -n "$1" ; then
1593
func_error "Could not determine host file name corresponding to"
1595
func_error "Continuing, but uninstalled executables may not work."
1597
func_to_host_file_result="$1"
1600
# end func_convert_file_check
1603
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604
# Verify that FROM_PATH (a path in $build format) was converted to $host
1605
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606
# func_to_host_file_result to a simplistic fallback value (see below).
1607
func_convert_path_check ()
1610
if test -z "$4" && test -n "$3"; then
1611
func_error "Could not determine the host path corresponding to"
1613
func_error "Continuing, but uninstalled executables may not work."
1614
# Fallback. This is a deliberately simplistic "conversion" and
1615
# should not be "improved". See libtool.info.
1616
if test "x$1" != "x$2"; then
1617
lt_replace_pathsep_chars="s|$1|$2|g"
1618
func_to_host_path_result=`echo "$3" |
1619
$SED -e "$lt_replace_pathsep_chars"`
1621
func_to_host_path_result="$3"
1625
# end func_convert_path_check
1628
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630
# and appending REPL if ORIG matches BACKPAT.
1631
func_convert_path_front_back_pathsep ()
1635
$1 ) func_to_host_path_result="$3$func_to_host_path_result"
1639
$2 ) func_append func_to_host_path_result "$3"
1643
# end func_convert_path_front_back_pathsep
1646
##################################################
1647
# $build to $host FILE NAME CONVERSION FUNCTIONS #
1648
##################################################
1649
# invoked via `$to_host_file_cmd ARG'
1651
# In each case, ARG is the path to be converted from $build to $host format.
1652
# Result will be available in $func_to_host_file_result.
1655
# func_to_host_file ARG
1656
# Converts the file name ARG from $build format to $host format. Return result
1657
# in func_to_host_file_result.
1658
func_to_host_file ()
1661
$to_host_file_cmd "$1"
1663
# end func_to_host_file
1666
# func_to_tool_file ARG LAZY
1667
# converts the file name ARG from $build format to toolchain format. Return
1668
# result in func_to_tool_file_result. If the conversion in use is listed
1669
# in (the comma separated) LAZY, no conversion takes place.
1670
func_to_tool_file ()
1674
*,"$to_tool_file_cmd",*)
1675
func_to_tool_file_result=$1
1678
$to_tool_file_cmd "$1"
1679
func_to_tool_file_result=$func_to_host_file_result
1683
# end func_to_tool_file
1686
# func_convert_file_noop ARG
1687
# Copy ARG to func_to_host_file_result.
1688
func_convert_file_noop ()
1690
func_to_host_file_result="$1"
1692
# end func_convert_file_noop
1695
# func_convert_file_msys_to_w32 ARG
1696
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697
# conversion to w32 is not available inside the cwrapper. Returns result in
1698
# func_to_host_file_result.
1699
func_convert_file_msys_to_w32 ()
1702
func_to_host_file_result="$1"
1703
if test -n "$1"; then
1704
func_convert_core_msys_to_w32 "$1"
1705
func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1707
func_convert_file_check "$1" "$func_to_host_file_result"
1709
# end func_convert_file_msys_to_w32
1712
# func_convert_file_cygwin_to_w32 ARG
1713
# Convert file name ARG from Cygwin to w32 format. Returns result in
1714
# func_to_host_file_result.
1715
func_convert_file_cygwin_to_w32 ()
1718
func_to_host_file_result="$1"
1719
if test -n "$1"; then
1720
# because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721
# LT_CYGPATH in this case.
1722
func_to_host_file_result=`cygpath -m "$1"`
1724
func_convert_file_check "$1" "$func_to_host_file_result"
1726
# end func_convert_file_cygwin_to_w32
1729
# func_convert_file_nix_to_w32 ARG
1730
# Convert file name ARG from *nix to w32 format. Requires a wine environment
1731
# and a working winepath. Returns result in func_to_host_file_result.
1732
func_convert_file_nix_to_w32 ()
1735
func_to_host_file_result="$1"
1736
if test -n "$1"; then
1737
func_convert_core_file_wine_to_w32 "$1"
1738
func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1740
func_convert_file_check "$1" "$func_to_host_file_result"
1742
# end func_convert_file_nix_to_w32
1745
# func_convert_file_msys_to_cygwin ARG
1746
# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1747
# Returns result in func_to_host_file_result.
1748
func_convert_file_msys_to_cygwin ()
1751
func_to_host_file_result="$1"
1752
if test -n "$1"; then
1753
func_convert_core_msys_to_w32 "$1"
1754
func_cygpath -u "$func_convert_core_msys_to_w32_result"
1755
func_to_host_file_result="$func_cygpath_result"
1757
func_convert_file_check "$1" "$func_to_host_file_result"
1759
# end func_convert_file_msys_to_cygwin
1762
# func_convert_file_nix_to_cygwin ARG
1763
# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1764
# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1765
# in func_to_host_file_result.
1766
func_convert_file_nix_to_cygwin ()
1769
func_to_host_file_result="$1"
1770
if test -n "$1"; then
1771
# convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772
func_convert_core_file_wine_to_w32 "$1"
1773
func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1774
func_to_host_file_result="$func_cygpath_result"
1776
func_convert_file_check "$1" "$func_to_host_file_result"
1778
# end func_convert_file_nix_to_cygwin
1781
#############################################
1782
# $build to $host PATH CONVERSION FUNCTIONS #
1783
#############################################
1784
# invoked via `$to_host_path_cmd ARG'
1786
# In each case, ARG is the path to be converted from $build to $host format.
1787
# The result will be available in $func_to_host_path_result.
1789
# Path separators are also converted from $build format to $host format. If
1790
# ARG begins or ends with a path separator character, it is preserved (but
1791
# converted to $host format) on output.
1793
# All path conversion functions are named using the following convention:
1794
# file name conversion function : func_convert_file_X_to_Y ()
1795
# path conversion function : func_convert_path_X_to_Y ()
1796
# where, for any given $build/$host combination the 'X_to_Y' value is the
1797
# same. If conversion functions are added for new $build/$host combinations,
1798
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
1802
# func_init_to_host_path_cmd
1803
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804
# appropriate value, based on the value of $to_host_file_cmd.
1806
func_init_to_host_path_cmd ()
1809
if test -z "$to_host_path_cmd"; then
1810
func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1811
to_host_path_cmd="func_convert_path_${func_stripname_result}"
1816
# func_to_host_path ARG
1817
# Converts the path ARG from $build format to $host format. Return result
1818
# in func_to_host_path_result.
1819
func_to_host_path ()
1822
func_init_to_host_path_cmd
1823
$to_host_path_cmd "$1"
1825
# end func_to_host_path
1828
# func_convert_path_noop ARG
1829
# Copy ARG to func_to_host_path_result.
1830
func_convert_path_noop ()
1832
func_to_host_path_result="$1"
1834
# end func_convert_path_noop
1837
# func_convert_path_msys_to_w32 ARG
1838
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839
# conversion to w32 is not available inside the cwrapper. Returns result in
1840
# func_to_host_path_result.
1841
func_convert_path_msys_to_w32 ()
1844
func_to_host_path_result="$1"
1845
if test -n "$1"; then
1846
# Remove leading and trailing path separator characters from ARG. MSYS
1847
# behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848
# and winepath ignores them completely.
1849
func_stripname : : "$1"
1850
func_to_host_path_tmp1=$func_stripname_result
1851
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1852
func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1853
func_convert_path_check : ";" \
1854
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1855
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1858
# end func_convert_path_msys_to_w32
1861
# func_convert_path_cygwin_to_w32 ARG
1862
# Convert path ARG from Cygwin to w32 format. Returns result in
1863
# func_to_host_file_result.
1864
func_convert_path_cygwin_to_w32 ()
1867
func_to_host_path_result="$1"
1868
if test -n "$1"; then
1869
# See func_convert_path_msys_to_w32:
1870
func_stripname : : "$1"
1871
func_to_host_path_tmp1=$func_stripname_result
1872
func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1873
func_convert_path_check : ";" \
1874
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1875
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1878
# end func_convert_path_cygwin_to_w32
1881
# func_convert_path_nix_to_w32 ARG
1882
# Convert path ARG from *nix to w32 format. Requires a wine environment and
1883
# a working winepath. Returns result in func_to_host_file_result.
1884
func_convert_path_nix_to_w32 ()
1887
func_to_host_path_result="$1"
1888
if test -n "$1"; then
1889
# See func_convert_path_msys_to_w32:
1890
func_stripname : : "$1"
1891
func_to_host_path_tmp1=$func_stripname_result
1892
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1893
func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1894
func_convert_path_check : ";" \
1895
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1896
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1899
# end func_convert_path_nix_to_w32
1902
# func_convert_path_msys_to_cygwin ARG
1903
# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1904
# Returns result in func_to_host_file_result.
1905
func_convert_path_msys_to_cygwin ()
1908
func_to_host_path_result="$1"
1909
if test -n "$1"; then
1910
# See func_convert_path_msys_to_w32:
1911
func_stripname : : "$1"
1912
func_to_host_path_tmp1=$func_stripname_result
1913
func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1914
func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1915
func_to_host_path_result="$func_cygpath_result"
1916
func_convert_path_check : : \
1917
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1918
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1921
# end func_convert_path_msys_to_cygwin
1924
# func_convert_path_nix_to_cygwin ARG
1925
# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1926
# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1927
# func_to_host_file_result.
1928
func_convert_path_nix_to_cygwin ()
1931
func_to_host_path_result="$1"
1932
if test -n "$1"; then
1933
# Remove leading and trailing path separator characters from
1934
# ARG. msys behavior is inconsistent here, cygpath turns them
1935
# into '.;' and ';.', and winepath ignores them completely.
1936
func_stripname : : "$1"
1937
func_to_host_path_tmp1=$func_stripname_result
1938
func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1939
func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1940
func_to_host_path_result="$func_cygpath_result"
1941
func_convert_path_check : : \
1942
"$func_to_host_path_tmp1" "$func_to_host_path_result"
1943
func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1946
# end func_convert_path_nix_to_cygwin
1949
# func_mode_compile arg...
1950
func_mode_compile ()
1953
# Get the compilation command and the source file.
1955
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1967
# do not "continue". Instead, add this to base_compile
1979
# Accept any command-line options.
1982
test -n "$libobj" && \
1983
func_fatal_error "you cannot specify \`-o' more than once"
1988
-pie | -fpie | -fPIE)
1989
func_append pie_flag " $arg"
1993
-shared | -static | -prefer-pic | -prefer-non-pic)
1994
func_append later " $arg"
2004
arg_mode=arg # the next one goes into the "base_compile" arg list
2005
continue # The current "srcfile" will either be retained or
2006
;; # replaced later. I would guess that would be a bug.
2009
func_stripname '-Wc,' '' "$arg"
2010
args=$func_stripname_result
2012
save_ifs="$IFS"; IFS=','
2013
for arg in $args; do
2015
func_append_quoted lastarg "$arg"
2018
func_stripname ' ' '' "$lastarg"
2019
lastarg=$func_stripname_result
2021
# Add the arguments to base_compile.
2022
func_append base_compile " $lastarg"
2027
# Accept the current argument as the source file.
2028
# The previous "srcfile" becomes the current argument.
2035
esac # case $arg_mode
2037
# Aesthetically quote the previous argument.
2038
func_append_quoted base_compile "$lastarg"
2043
func_fatal_error "you must specify an argument for -Xcompile"
2046
func_fatal_error "you must specify a target with \`-o'"
2049
# Get the name of the library object.
2050
test -z "$libobj" && {
2051
func_basename "$srcfile"
2052
libobj="$func_basename_result"
2057
# Recognize several different file suffixes.
2058
# If the user specifies -o file.o, it is replaced with file.lo
2061
*.ada | *.adb | *.ads | *.asm | \
2062
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2063
*.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
2064
func_xform "$libobj"
2065
libobj=$func_xform_result
2070
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2072
func_fatal_error "cannot determine name of library object from \`$libobj'"
2076
func_infer_tag $base_compile
2078
for arg in $later; do
2081
test "$build_libtool_libs" != yes && \
2082
func_fatal_configuration "can not build a shared library"
2088
build_libtool_libs=no
2105
func_quote_for_eval "$libobj"
2106
test "X$libobj" != "X$func_quote_for_eval_result" \
2107
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2108
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
2109
func_dirname_and_basename "$obj" "/" ""
2110
objname="$func_basename_result"
2111
xdir="$func_dirname_result"
2112
lobj=${xdir}$objdir/$objname
2114
test -z "$base_compile" && \
2115
func_fatal_help "you must specify a compilation command"
2117
# Delete any leftover library objects.
2118
if test "$build_old_libs" = yes; then
2119
removelist="$obj $lobj $libobj ${libobj}T"
2121
removelist="$lobj $libobj ${libobj}T"
2124
# On Cygwin there's no "real" PIC flag so we must build both object types
2126
cygwin* | mingw* | pw32* | os2* | cegcc*)
2130
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2131
# non-PIC code in shared libraries is not supported
2135
# Calculate the filename of the output object if compiler does
2136
# not support -o with -c
2137
if test "$compiler_c_o" = no; then
2138
output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2139
lockfile="$output_obj.lock"
2146
# Lock this critical section if it is needed
2147
# We use this script file to make the link, it avoids creating a new file
2148
if test "$need_locks" = yes; then
2149
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2150
func_echo "Waiting for $lockfile to be removed"
2153
elif test "$need_locks" = warn; then
2154
if test -f "$lockfile"; then
2156
*** ERROR, $lockfile exists and contains:
2157
`cat $lockfile 2>/dev/null`
2159
This indicates that another process is trying to use the same
2160
temporary object file, and libtool could not work around it because
2161
your compiler does not support \`-c' and \`-o' together. If you
2162
repeat this compilation, it may succeed, by chance, but you had better
2163
avoid parallel builds (make -j) in this platform, or get a better
2166
$opt_dry_run || $RM $removelist
2169
func_append removelist " $output_obj"
2170
$ECHO "$srcfile" > "$lockfile"
2173
$opt_dry_run || $RM $removelist
2174
func_append removelist " $lockfile"
2175
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2177
func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2178
srcfile=$func_to_tool_file_result
2179
func_quote_for_eval "$srcfile"
2180
qsrcfile=$func_quote_for_eval_result
2182
# Only build a PIC object if we are building libtool libraries.
2183
if test "$build_libtool_libs" = yes; then
2184
# Without this assignment, base_compile gets emptied.
2185
fbsd_hideous_sh_bug=$base_compile
2187
if test "$pic_mode" != no; then
2188
command="$base_compile $qsrcfile $pic_flag"
2190
# Don't build PIC code
2191
command="$base_compile $qsrcfile"
2194
func_mkdir_p "$xdir$objdir"
2196
if test -z "$output_obj"; then
2197
# Place PIC objects in $objdir
2198
func_append command " -o $lobj"
2201
func_show_eval_locale "$command" \
2202
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2204
if test "$need_locks" = warn &&
2205
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2207
*** ERROR, $lockfile contains:
2208
`cat $lockfile 2>/dev/null`
2210
but it should contain:
2213
This indicates that another process is trying to use the same
2214
temporary object file, and libtool could not work around it because
2215
your compiler does not support \`-c' and \`-o' together. If you
2216
repeat this compilation, it may succeed, by chance, but you had better
2217
avoid parallel builds (make -j) in this platform, or get a better
2220
$opt_dry_run || $RM $removelist
2224
# Just move the object if needed, then go on to compile the next one
2225
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226
func_show_eval '$MV "$output_obj" "$lobj"' \
2227
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2230
# Allow error messages only from the first compilation.
2231
if test "$suppress_opt" = yes; then
2232
suppress_output=' >/dev/null 2>&1'
2236
# Only build a position-dependent object if we build old libraries.
2237
if test "$build_old_libs" = yes; then
2238
if test "$pic_mode" != yes; then
2239
# Don't build PIC code
2240
command="$base_compile $qsrcfile$pie_flag"
2242
command="$base_compile $qsrcfile $pic_flag"
2244
if test "$compiler_c_o" = yes; then
2245
func_append command " -o $obj"
2248
# Suppress compiler output if we already did a PIC compilation.
2249
func_append command "$suppress_output"
2250
func_show_eval_locale "$command" \
2251
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2253
if test "$need_locks" = warn &&
2254
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2256
*** ERROR, $lockfile contains:
2257
`cat $lockfile 2>/dev/null`
2259
but it should contain:
2262
This indicates that another process is trying to use the same
2263
temporary object file, and libtool could not work around it because
2264
your compiler does not support \`-c' and \`-o' together. If you
2265
repeat this compilation, it may succeed, by chance, but you had better
2266
avoid parallel builds (make -j) in this platform, or get a better
2269
$opt_dry_run || $RM $removelist
2273
# Just move the object if needed
2274
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275
func_show_eval '$MV "$output_obj" "$obj"' \
2276
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2281
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2283
# Unlock the critical section if it was locked
2284
if test "$need_locks" != no; then
2285
removelist=$lockfile
2294
test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2299
# We need to display help for each of the modes.
2302
# Generic help is extracted from the usage comments
2303
# at the start of this file.
2309
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2311
Remove files from the build directory.
2313
RM is the name of the program to use to delete files associated with each FILE
2314
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2317
If FILE is a libtool library, object or program, all the files associated
2318
with it are deleted. Otherwise, only FILE itself is deleted using RM."
2323
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2325
Compile a source file into a libtool library object.
2327
This mode accepts the following additional options:
2329
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
2330
-no-suppress do not suppress compiler output for multiple passes
2331
-prefer-pic try to build PIC objects only
2332
-prefer-non-pic try to build non-PIC objects only
2333
-shared do not build a \`.o' file suitable for static linking
2334
-static only build a \`.o' file suitable for static linking
2335
-Wc,FLAG pass FLAG directly to the compiler
2337
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338
from the given SOURCEFILE.
2340
The output file name is determined by removing the directory component from
2341
SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342
library object suffix, \`.lo'."
2347
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2349
Automatically set library path, then run a program.
2351
This mode accepts the following additional options:
2353
-dlopen FILE add the directory containing FILE to the library path
2355
This mode sets the library path environment variable according to \`-dlopen'
2358
If any of the ARGS are libtool executable wrappers, then they are translated
2359
into their corresponding uninstalled binary, and any of their required library
2360
directories are added to the library path.
2362
Then, COMMAND is executed, with ARGS as arguments."
2367
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2369
Complete the installation of libtool libraries.
2371
Each LIBDIR is a directory that contains libtool libraries.
2373
The commands that this mode executes may require superuser privileges. Use
2374
the \`--dry-run' option if you just want to see what would be executed."
2379
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2381
Install executables or libraries.
2383
INSTALL-COMMAND is the installation command. The first component should be
2384
either the \`install' or \`cp' program.
2386
The following components of INSTALL-COMMAND are treated specially:
2388
-inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2390
The rest of the components are interpreted as arguments to that command (only
2391
BSD-compatible install options are recognized)."
2396
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2398
Link object files or libraries together to form another library, or to
2399
create an executable program.
2401
LINK-COMMAND is a command using the C compiler that you would use to create
2402
a program from several object files.
2404
The following components of LINK-COMMAND are treated specially:
2406
-all-static do not do any dynamic linking at all
2407
-avoid-version do not add a version suffix if possible
2408
-bindir BINDIR specify path to binaries directory (for systems where
2409
libraries must be found in the PATH setting at runtime)
2410
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2412
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413
-export-symbols SYMFILE
2414
try to export only the symbols listed in SYMFILE
2415
-export-symbols-regex REGEX
2416
try to export only the symbols matching REGEX
2417
-LLIBDIR search LIBDIR for required installed libraries
2418
-lNAME OUTPUT-FILE requires the installed library libNAME
2419
-module build a library that can dlopened
2420
-no-fast-install disable the fast-install mode
2421
-no-install link a not-installable executable
2422
-no-undefined declare that a library does not refer to external symbols
2423
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2424
-objectlist FILE Use a list of object files found in FILE to specify objects
2425
-precious-files-regex REGEX
2426
don't remove output files matching REGEX
2427
-release RELEASE specify package release information
2428
-rpath LIBDIR the created library will eventually be installed in LIBDIR
2429
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2430
-shared only do dynamic linking of libtool libraries
2431
-shrext SUFFIX override the standard shared library file extension
2432
-static do not do any dynamic linking of uninstalled libtool libraries
2433
-static-libtool-libs
2434
do not do any dynamic linking of libtool libraries
2435
-version-info CURRENT[:REVISION[:AGE]]
2436
specify library version info [each variable defaults to 0]
2437
-weak LIBNAME declare that the target provides the LIBNAME interface
2439
-Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2441
-Xlinker FLAG pass linker-specific FLAG directly to the linker
2442
-XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2444
All other options (arguments beginning with \`-') are ignored.
2446
Every other argument is treated as a filename. Files ending in \`.la' are
2447
treated as uninstalled libtool libraries, other files are standard or library
2450
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451
only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452
required, except when creating a convenience library.
2454
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455
using \`ar' and \`ranlib', or on Windows using \`lib'.
2457
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458
is created, otherwise an executable program is created."
2463
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2465
Remove libraries from an installation directory.
2467
RM is the name of the program to use to delete files associated with each FILE
2468
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2471
If FILE is a libtool library, all the files associated with it are deleted.
2472
Otherwise, only FILE itself is deleted using RM."
2476
func_fatal_help "invalid operation mode \`$opt_mode'"
2481
$ECHO "Try \`$progname --help' for more information about other modes."
2484
# Now that we've collected a possible --mode arg, show help if necessary
2486
if test "$opt_help" = :; then
2491
for opt_mode in compile link execute install finish uninstall clean; do
2494
} | sed -n '1p; 2,$s/^Usage:/ or: /p'
2497
for opt_mode in compile link execute install finish uninstall clean; do
2503
/^When reporting/,/^Report/{
2508
/information about other modes/d
2509
/more detailed .*MODE/d
2510
s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2516
# func_mode_execute arg...
2517
func_mode_execute ()
2520
# The first argument is the command name.
2523
func_fatal_help "you must specify a COMMAND"
2525
# Handle -dlopen flags immediately.
2526
for file in $opt_dlopen; do
2528
|| func_fatal_help "\`$file' is not a file"
2533
func_resolve_sysroot "$file"
2534
file=$func_resolve_sysroot_result
2536
# Check to see that this really is a libtool archive.
2537
func_lalib_unsafe_p "$file" \
2538
|| func_fatal_help "\`$lib' is not a valid libtool archive"
2540
# Read the libtool library.
2545
# Skip this library if it cannot be dlopened.
2546
if test -z "$dlname"; then
2547
# Warn if it was a shared library.
2548
test -n "$library_names" && \
2549
func_warning "\`$file' was not linked with \`-export-dynamic'"
2553
func_dirname "$file" "" "."
2554
dir="$func_dirname_result"
2556
if test -f "$dir/$objdir/$dlname"; then
2557
func_append dir "/$objdir"
2559
if test ! -f "$dir/$dlname"; then
2560
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2566
# Just add the directory containing the .lo file.
2567
func_dirname "$file" "" "."
2568
dir="$func_dirname_result"
2572
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2577
# Get the absolute pathname.
2578
absdir=`cd "$dir" && pwd`
2579
test -n "$absdir" && dir="$absdir"
2581
# Now add the directory to shlibpath_var.
2582
if eval "test -z \"\$$shlibpath_var\""; then
2583
eval "$shlibpath_var=\"\$dir\""
2585
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2589
# This variable tells wrapper scripts just to set shlibpath_var
2590
# rather than running their programs.
2591
libtool_execute_magic="$magic"
2593
# Check if any of the arguments is a wrapper script.
2598
-* | *.la | *.lo ) ;;
2600
# Do a test to see if this is really a libtool program.
2601
if func_ltwrapper_script_p "$file"; then
2603
# Transform arg to wrapped name.
2604
file="$progdir/$program"
2605
elif func_ltwrapper_executable_p "$file"; then
2606
func_ltwrapper_scriptname "$file"
2607
func_source "$func_ltwrapper_scriptname_result"
2608
# Transform arg to wrapped name.
2609
file="$progdir/$program"
2613
# Quote arguments (to preserve shell metacharacters).
2614
func_append_quoted args "$file"
2617
if test "X$opt_dry_run" = Xfalse; then
2618
if test -n "$shlibpath_var"; then
2619
# Export the shlibpath_var.
2620
eval "export $shlibpath_var"
2623
# Restore saved environment variables
2624
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2626
eval "if test \"\${save_$lt_var+set}\" = set; then
2627
$lt_var=\$save_$lt_var; export $lt_var
2633
# Now prepare to actually exec the command.
2634
exec_cmd="\$cmd$args"
2636
# Display what would be done.
2637
if test -n "$shlibpath_var"; then
2638
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639
echo "export $shlibpath_var"
2646
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2649
# func_mode_finish arg...
2657
for opt in "$nonopt" ${1+"$@"}
2659
if test -d "$opt"; then
2660
func_append libdirs " $opt"
2662
elif test -f "$opt"; then
2663
if func_lalib_unsafe_p "$opt"; then
2664
func_append libs " $opt"
2666
func_warning "\`$opt' is not a valid libtool archive"
2670
func_fatal_error "invalid argument \`$opt'"
2674
if test -n "$libs"; then
2675
if test -n "$lt_sysroot"; then
2676
sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677
sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2682
# Remove sysroot references
2683
if $opt_dry_run; then
2684
for lib in $libs; do
2685
echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2688
tmpdir=`func_mktempdir`
2689
for lib in $libs; do
2690
sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2692
mv -f $tmpdir/tmp-la $lib
2698
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699
for libdir in $libdirs; do
2700
if test -n "$finish_cmds"; then
2701
# Do each command in the finish commands.
2702
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2705
if test -n "$finish_eval"; then
2706
# Do the single finish_eval.
2707
eval cmds=\"$finish_eval\"
2708
$opt_dry_run || eval "$cmds" || func_append admincmds "
2714
# Exit here if they wanted silent mode.
2715
$opt_silent && exit $EXIT_SUCCESS
2717
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718
echo "----------------------------------------------------------------------"
2719
echo "Libraries have been installed in:"
2720
for libdir in $libdirs; do
2724
echo "If you ever happen to want to link against installed libraries"
2725
echo "in a given directory, LIBDIR, you must either use libtool, and"
2726
echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727
echo "flag during linking and do at least one of the following:"
2728
if test -n "$shlibpath_var"; then
2729
echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2730
echo " during execution"
2732
if test -n "$runpath_var"; then
2733
echo " - add LIBDIR to the \`$runpath_var' environment variable"
2734
echo " during linking"
2736
if test -n "$hardcode_libdir_flag_spec"; then
2738
eval flag=\"$hardcode_libdir_flag_spec\"
2740
$ECHO " - use the \`$flag' linker flag"
2742
if test -n "$admincmds"; then
2743
$ECHO " - have your system administrator run these commands:$admincmds"
2745
if test -f /etc/ld.so.conf; then
2746
echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2750
echo "See any operating system documentation about shared libraries for"
2752
solaris2.[6789]|solaris2.1[0-9])
2753
echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2757
echo "more information, such as the ld(1) and ld.so(8) manual pages."
2760
echo "----------------------------------------------------------------------"
2765
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2768
# func_mode_install arg...
2769
func_mode_install ()
2772
# There may be an optional sh(1) argument at the beginning of
2773
# install_prog (especially on Windows NT).
2774
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775
# Allow the use of GNU shtool's install command.
2776
case $nonopt in *shtool*) :;; *) false;; esac; then
2777
# Aesthetically quote it.
2778
func_quote_for_eval "$nonopt"
2779
install_prog="$func_quote_for_eval_result "
2787
# The real first argument should be the name of the installation program.
2788
# Aesthetically quote it.
2789
func_quote_for_eval "$arg"
2790
func_append install_prog "$func_quote_for_eval_result"
2791
install_shared_prog=$install_prog
2792
case " $install_prog " in
2793
*[\\\ /]cp\ *) install_cp=: ;;
2794
*) install_cp=false ;;
2797
# We need to accept at least all the BSD install flags.
2809
if test -n "$dest"; then
2810
func_append files " $dest"
2818
if $install_cp; then :; else
2832
# If the previous option needed an argument, then skip it.
2833
if test -n "$prev"; then
2834
if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835
arg2=$install_override_mode
2846
# Aesthetically quote the argument.
2847
func_quote_for_eval "$arg"
2848
func_append install_prog " $func_quote_for_eval_result"
2849
if test -n "$arg2"; then
2850
func_quote_for_eval "$arg2"
2852
func_append install_shared_prog " $func_quote_for_eval_result"
2855
test -z "$install_prog" && \
2856
func_fatal_help "you must specify an install program"
2858
test -n "$prev" && \
2859
func_fatal_help "the \`$prev' option requires an argument"
2861
if test -n "$install_override_mode" && $no_mode; then
2862
if $install_cp; then :; else
2863
func_quote_for_eval "$install_override_mode"
2864
func_append install_shared_prog " -m $func_quote_for_eval_result"
2868
if test -z "$files"; then
2869
if test -z "$dest"; then
2870
func_fatal_help "no file or destination specified"
2872
func_fatal_help "you must specify a destination"
2876
# Strip any trailing slash from the destination.
2877
func_stripname '' '/' "$dest"
2878
dest=$func_stripname_result
2880
# Check to see that the destination is a directory.
2881
test -d "$dest" && isdir=yes
2882
if test "$isdir" = yes; then
2886
func_dirname_and_basename "$dest" "" "."
2887
destdir="$func_dirname_result"
2888
destname="$func_basename_result"
2890
# Not a directory, so check to see that there is only one file specified.
2891
set dummy $files; shift
2892
test "$#" -gt 1 && \
2893
func_fatal_help "\`$dest' is not a directory"
2896
[\\/]* | [A-Za-z]:[\\/]*) ;;
2898
for file in $files; do
2902
func_fatal_help "\`$destdir' must be an absolute directory name"
2909
# This variable tells wrapper scripts just to set variables rather
2910
# than running their programs.
2911
libtool_install_magic="$magic"
2916
for file in $files; do
2918
# Do each installation.
2921
# Do the static libraries later.
2922
func_append staticlibs " $file"
2926
func_resolve_sysroot "$file"
2927
file=$func_resolve_sysroot_result
2929
# Check to see that this really is a libtool archive.
2930
func_lalib_unsafe_p "$file" \
2931
|| func_fatal_help "\`$file' is not a valid libtool archive"
2938
# Add the libdir to current_libdirs if it is the destination.
2939
if test "X$destdir" = "X$libdir"; then
2940
case "$current_libdirs " in
2942
*) func_append current_libdirs " $libdir" ;;
2945
# Note the libdir as a future libdir.
2946
case "$future_libdirs " in
2948
*) func_append future_libdirs " $libdir" ;;
2952
func_dirname "$file" "/" ""
2953
dir="$func_dirname_result"
2954
func_append dir "$objdir"
2956
if test -n "$relink_command"; then
2957
# Determine the prefix the user has applied to our future dir.
2958
inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2960
# Don't allow the user to place us outside of our expected
2961
# location b/c this prevents finding dependent libraries that
2962
# are installed to the same prefix.
2963
# At present, this check doesn't affect windows .dll's that
2964
# are installed into $libdir/../bin (currently, that works fine)
2965
# but it's something to keep an eye on.
2966
test "$inst_prefix_dir" = "$destdir" && \
2967
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2969
if test -n "$inst_prefix_dir"; then
2970
# Stick the inst_prefix_dir data into the link command.
2971
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2973
relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2976
func_warning "relinking \`$file'"
2977
func_show_eval "$relink_command" \
2978
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2981
# See the names of the shared library.
2982
set dummy $library_names; shift
2983
if test -n "$1"; then
2988
test -n "$relink_command" && srcname="$realname"T
2990
# Install the shared library and build the symlinks.
2991
func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2995
cygwin* | mingw* | pw32* | cegcc*)
3003
if test -n "$tstripme" && test -n "$striplib"; then
3004
func_show_eval "$striplib $destdir/$realname" 'exit $?'
3007
if test "$#" -gt 0; then
3008
# Delete the old symlinks, and create new ones.
3009
# Try `ln -sf' first, because the `ln' binary might depend on
3010
# the symlink we replace! Solaris /bin/ln does not understand -f,
3011
# so we also need to try rm && ln -s.
3014
test "$linkname" != "$realname" \
3015
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3019
# Do each command in the postinstall commands.
3020
lib="$destdir/$realname"
3021
func_execute_cmds "$postinstall_cmds" 'exit $?'
3024
# Install the pseudo-library for information purposes.
3025
func_basename "$file"
3026
name="$func_basename_result"
3027
instname="$dir/$name"i
3028
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3030
# Maybe install the static library, too.
3031
test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3035
# Install (i.e. copy) a libtool object.
3037
# Figure out destination file name, if it wasn't already specified.
3038
if test -n "$destname"; then
3039
destfile="$destdir/$destname"
3041
func_basename "$file"
3042
destfile="$func_basename_result"
3043
destfile="$destdir/$destfile"
3046
# Deduce the name of the destination old-style object file.
3049
func_lo2o "$destfile"
3050
staticdest=$func_lo2o_result
3053
staticdest="$destfile"
3057
func_fatal_help "cannot copy a libtool object to \`$destfile'"
3061
# Install the libtool object if requested.
3062
test -n "$destfile" && \
3063
func_show_eval "$install_prog $file $destfile" 'exit $?'
3065
# Install the old object if enabled.
3066
if test "$build_old_libs" = yes; then
3067
# Deduce the name of the old-style object file.
3069
staticobj=$func_lo2o_result
3070
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3076
# Figure out destination file name, if it wasn't already specified.
3077
if test -n "$destname"; then
3078
destfile="$destdir/$destname"
3080
func_basename "$file"
3081
destfile="$func_basename_result"
3082
destfile="$destdir/$destfile"
3085
# If the file is missing, and there is a .exe on the end, strip it
3086
# because it is most likely a libtool script we actually want to
3091
if test ! -f "$file"; then
3092
func_stripname '' '.exe' "$file"
3093
file=$func_stripname_result
3099
# Do a test to see if this is really a libtool program.
3102
if func_ltwrapper_executable_p "$file"; then
3103
func_ltwrapper_scriptname "$file"
3104
wrapper=$func_ltwrapper_scriptname_result
3106
func_stripname '' '.exe' "$file"
3107
wrapper=$func_stripname_result
3114
if func_ltwrapper_script_p "$wrapper"; then
3118
func_source "$wrapper"
3120
# Check the variables that should have been set.
3121
test -z "$generated_by_libtool_version" && \
3122
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3125
for lib in $notinst_deplibs; do
3126
# Check to see that each library is installed.
3128
if test -f "$lib"; then
3131
libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132
if test -n "$libdir" && test ! -f "$libfile"; then
3133
func_warning "\`$lib' has not been installed in \`$libdir'"
3139
func_source "$wrapper"
3142
if test "$fast_install" = no && test -n "$relink_command"; then
3144
if test "$finalize" = yes; then
3145
tmpdir=`func_mktempdir`
3146
func_basename "$file$stripped_ext"
3147
file="$func_basename_result"
3148
outputname="$tmpdir/$file"
3149
# Replace the output file specification.
3150
relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3153
func_quote_for_expand "$relink_command"
3154
eval "func_echo $func_quote_for_expand_result"
3156
if eval "$relink_command"; then :
3158
func_error "error: relink \`$file' with the above command before installing it"
3159
$opt_dry_run || ${RM}r "$tmpdir"
3164
func_warning "cannot relink \`$file'"
3168
# Install the binary that we compiled earlier.
3169
file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3173
# remove .exe since cygwin /usr/bin/install will append another
3175
case $install_prog,$host in
3176
*/usr/bin/install*,*cygwin*)
3177
case $file:$destfile in
3182
destfile=$destfile.exe
3185
func_stripname '' '.exe' "$destfile"
3186
destfile=$func_stripname_result
3191
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192
$opt_dry_run || if test -n "$outputname"; then
3199
for file in $staticlibs; do
3200
func_basename "$file"
3201
name="$func_basename_result"
3203
# Set up the ranlib parameters.
3204
oldlib="$destdir/$name"
3205
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
3206
tool_oldlib=$func_to_tool_file_result
3208
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3210
if test -n "$stripme" && test -n "$old_striplib"; then
3211
func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
3214
# Do each command in the postinstall commands.
3215
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3218
test -n "$future_libdirs" && \
3219
func_warning "remember to run \`$progname --finish$future_libdirs'"
3221
if test -n "$current_libdirs"; then
3222
# Maybe just do a dry run.
3223
$opt_dry_run && current_libdirs=" -n$current_libdirs"
3224
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3230
test "$opt_mode" = install && func_mode_install ${1+"$@"}
3233
# func_generate_dlsyms outputname originator pic_p
3234
# Extract symbols from dlprefiles and create ${outputname}S.o with
3235
# a dlpreopen symbol table.
3236
func_generate_dlsyms ()
3242
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3245
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3246
if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247
my_dlsyms="${my_outputname}S.c"
3249
func_error "not configured to extract global symbols from dlpreopened files"
3253
if test -n "$my_dlsyms"; then
3257
# Discover the nlist of each of the dlfiles.
3258
nlist="$output_objdir/${my_outputname}.nm"
3260
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3262
# Parse the name list into a source file.
3263
func_verbose "creating $output_objdir/$my_dlsyms"
3265
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3266
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3273
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3277
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3278
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279
/* DATA imports from DLLs on WIN32 con't be const, because runtime
3280
relocations are performed -- see ld's documentation on pseudo-relocs. */
3281
# define LT_DLSYM_CONST
3282
#elif defined(__osf__)
3283
/* This system does not cope well with relocations in const data. */
3284
# define LT_DLSYM_CONST
3286
# define LT_DLSYM_CONST const
3289
/* External symbol declarations for the compiler. */\
3292
if test "$dlself" = yes; then
3293
func_verbose "generating symbol list for \`$output'"
3295
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3297
# Add our own program objects to the symbol list.
3298
progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299
for progfile in $progfiles; do
3300
func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3301
func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3302
$opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3305
if test -n "$exclude_expsyms"; then
3307
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308
eval '$MV "$nlist"T "$nlist"'
3312
if test -n "$export_symbols_regex"; then
3314
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315
eval '$MV "$nlist"T "$nlist"'
3319
# Prepare the list of exported symbols
3320
if test -z "$export_symbols"; then
3321
export_symbols="$output_objdir/$outputname.exp"
3324
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3326
*cygwin* | *mingw* | *cegcc* )
3327
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3334
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336
eval '$MV "$nlist"T "$nlist"'
3338
*cygwin* | *mingw* | *cegcc* )
3339
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3347
for dlprefile in $dlprefiles; do
3348
func_verbose "extracting global C symbols from \`$dlprefile'"
3349
func_basename "$dlprefile"
3350
name="$func_basename_result"
3352
*cygwin* | *mingw* | *cegcc* )
3353
# if an import library, we need to obtain dlname
3354
if func_win32_import_lib_p "$dlprefile"; then
3355
func_tr_sh "$dlprefile"
3356
eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357
dlprefile_dlbasename=""
3358
if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3359
# Use subshell, to avoid clobbering current variable values
3360
dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3361
if test -n "$dlprefile_dlname" ; then
3362
func_basename "$dlprefile_dlname"
3363
dlprefile_dlbasename="$func_basename_result"
3365
# no lafile. user explicitly requested -dlpreopen <import library>.
3366
$sharedlib_from_linklib_cmd "$dlprefile"
3367
dlprefile_dlbasename=$sharedlib_from_linklib_result
3371
if test -n "$dlprefile_dlbasename" ; then
3372
eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3374
func_warning "Could not compute DLL name from $name"
3375
eval '$ECHO ": $name " >> "$nlist"'
3377
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3378
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379
$SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3381
else # not an import lib
3383
eval '$ECHO ": $name " >> "$nlist"'
3384
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3385
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3391
eval '$ECHO ": $name " >> "$nlist"'
3392
func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3393
eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3400
# Make sure we have at least an empty file.
3401
test -f "$nlist" || : > "$nlist"
3403
if test -n "$exclude_expsyms"; then
3404
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405
$MV "$nlist"T "$nlist"
3408
# Try sorting and uniquifying the output.
3409
if $GREP -v "^: " < "$nlist" |
3410
if sort -k 3 </dev/null >/dev/null 2>&1; then
3415
uniq > "$nlist"S; then
3418
$GREP -v "^: " < "$nlist" > "$nlist"S
3421
if test -f "$nlist"S; then
3422
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3424
echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3427
echo >> "$output_objdir/$my_dlsyms" "\
3429
/* The mapping between symbol names and symbols. */
3434
extern LT_DLSYM_CONST lt_dlsymlist
3435
lt_${my_prefix}_LTX_preloaded_symbols[];
3436
LT_DLSYM_CONST lt_dlsymlist
3437
lt_${my_prefix}_LTX_preloaded_symbols[] =
3439
{ \"$my_originator\", (void *) 0 },"
3441
case $need_lib_prefix in
3443
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3446
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3449
echo >> "$output_objdir/$my_dlsyms" "\
3453
/* This works around a problem in FreeBSD linker */
3454
#ifdef FREEBSD_WORKAROUND
3455
static const void *lt_preloaded_setup() {
3456
return lt_${my_prefix}_LTX_preloaded_symbols;
3466
pic_flag_for_symtable=
3467
case "$compile_command " in
3471
# compiling the symbol table file with pic_flag works around
3472
# a FreeBSD bug that causes programs to crash when -lm is
3473
# linked before any other PIC object. But we must not use
3474
# pic_flag when linking with -static. The problem exists in
3475
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476
*-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3477
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3479
pic_flag_for_symtable=" $pic_flag" ;;
3481
if test "X$my_pic_p" != Xno; then
3482
pic_flag_for_symtable=" $pic_flag"
3489
for arg in $LTCFLAGS; do
3491
-pie | -fpie | -fPIE) ;;
3492
*) func_append symtab_cflags " $arg" ;;
3496
# Now compile the dynamic symbol file.
3497
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3499
# Clean up the generated files.
3500
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3502
# Transform the symbol file into the correct name.
3503
symfileobj="$output_objdir/${my_outputname}S.$objext"
3505
*cygwin* | *mingw* | *cegcc* )
3506
if test -f "$output_objdir/$my_outputname.def"; then
3507
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3510
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3515
compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516
finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3521
func_fatal_error "unknown suffix for \`$my_dlsyms'"
3525
# We keep going just in case the user didn't refer to
3526
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3527
# really was required.
3529
# Nullify the symbol file.
3530
compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531
finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3535
# func_win32_libid arg
3536
# return the library type of file 'arg'
3538
# Need a lot of goo to handle *both* DLLs and import libs
3539
# Has to be a shell function in order to 'eat' the argument
3540
# that is supplied when $file_magic_command is called.
3541
# Despite the name, also deal with 64 bit binaries.
3545
win32_libid_type="unknown"
3546
win32_fileres=`file -L $1 2>/dev/null`
3547
case $win32_fileres in
3548
*ar\ archive\ import\ library*) # definitely import
3549
win32_libid_type="x86 archive import"
3551
*ar\ archive*) # could be an import, or static
3552
# Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3554
$EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3555
func_to_tool_file "$1" func_convert_file_msys_to_w32
3556
win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3565
case $win32_nmres in
3566
import*) win32_libid_type="x86 archive import";;
3567
*) win32_libid_type="x86 archive static";;
3572
win32_libid_type="x86 DLL"
3574
*executable*) # but shell scripts are "executable" too...
3575
case $win32_fileres in
3576
*MS\ Windows\ PE\ Intel*)
3577
win32_libid_type="x86 DLL"
3582
$ECHO "$win32_libid_type"
3585
# func_cygming_dll_for_implib ARG
3587
# Platform-specific function to extract the
3588
# name of the DLL associated with the specified
3589
# import library ARG.
3590
# Invoked by eval'ing the libtool variable
3591
# $sharedlib_from_linklib_cmd
3592
# Result is available in the variable
3593
# $sharedlib_from_linklib_result
3594
func_cygming_dll_for_implib ()
3597
sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3600
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3602
# The is the core of a fallback implementation of a
3603
# platform-specific function to extract the name of the
3604
# DLL associated with the specified import library LIBNAME.
3606
# SECTION_NAME is either .idata$6 or .idata$7, depending
3607
# on the platform and compiler that created the implib.
3609
# Echos the name of the DLL associated with the
3610
# specified import library.
3611
func_cygming_dll_for_implib_fallback_core ()
3614
match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615
$OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3616
$SED '/^Contents of section '"$match_literal"':/{
3617
# Place marker at beginning of archive member dllname section
3622
# These lines can sometimes be longer than 43 characters, but
3623
# are always uninteresting
3624
/:[ ]*file format pe[i]\{,1\}-/d
3625
/^In archive [^:]*:/d
3626
# Ensure marker is printed
3628
# Remove all lines with less than 43 characters
3630
# From remaining lines, remove first 43 characters
3633
# Join marker and all lines until next marker into a single line
3634
/^====MARK====/ b para
3643
# Remove trailing dots and whitespace
3647
# we now have a list, one entry per line, of the stringified
3648
# contents of the appropriate section of all members of the
3649
# archive which possess that section. Heuristic: eliminate
3650
# all those which have a first or second character that is
3651
# a '.' (that is, objdump's representation of an unprintable
3652
# character.) This should work for all archives with less than
3653
# 0x302f exports -- but will fail for DLLs whose name actually
3654
# begins with a literal '.' or a single character followed by
3657
# Of those that remain, print the first one.
3658
$SED -e '/^\./d;/^.\./d;q'
3661
# func_cygming_gnu_implib_p ARG
3662
# This predicate returns with zero status (TRUE) if
3663
# ARG is a GNU/binutils-style import library. Returns
3664
# with nonzero status (FALSE) otherwise.
3665
func_cygming_gnu_implib_p ()
3668
func_to_tool_file "$1" func_convert_file_msys_to_w32
3669
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)$'`
3670
test -n "$func_cygming_gnu_implib_tmp"
3673
# func_cygming_ms_implib_p ARG
3674
# This predicate returns with zero status (TRUE) if
3675
# ARG is an MS-style import library. Returns
3676
# with nonzero status (FALSE) otherwise.
3677
func_cygming_ms_implib_p ()
3680
func_to_tool_file "$1" func_convert_file_msys_to_w32
3681
func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682
test -n "$func_cygming_ms_implib_tmp"
3685
# func_cygming_dll_for_implib_fallback ARG
3686
# Platform-specific function to extract the
3687
# name of the DLL associated with the specified
3688
# import library ARG.
3690
# This fallback implementation is for use when $DLLTOOL
3691
# does not support the --identify-strict option.
3692
# Invoked by eval'ing the libtool variable
3693
# $sharedlib_from_linklib_cmd
3694
# Result is available in the variable
3695
# $sharedlib_from_linklib_result
3696
func_cygming_dll_for_implib_fallback ()
3699
if func_cygming_gnu_implib_p "$1" ; then
3700
# binutils import library
3701
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702
elif func_cygming_ms_implib_p "$1" ; then
3703
# ms-generated import library
3704
sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3707
sharedlib_from_linklib_result=""
3712
# func_extract_an_archive dir oldlib
3713
func_extract_an_archive ()
3716
f_ex_an_ar_dir="$1"; shift
3717
f_ex_an_ar_oldlib="$1"
3718
if test "$lock_old_archive_extraction" = yes; then
3719
lockfile=$f_ex_an_ar_oldlib.lock
3720
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3721
func_echo "Waiting for $lockfile to be removed"
3725
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726
'stat=$?; rm -f "$lockfile"; exit $stat'
3727
if test "$lock_old_archive_extraction" = yes; then
3728
$opt_dry_run || rm -f "$lockfile"
3730
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3733
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3738
# func_extract_archives gentop oldlib ...
3739
func_extract_archives ()
3742
my_gentop="$1"; shift
3743
my_oldlibs=${1+"$@"}
3749
for my_xlib in $my_oldlibs; do
3750
# Extract the objects.
3752
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3753
*) my_xabs=`pwd`"/$my_xlib" ;;
3755
func_basename "$my_xlib"
3756
my_xlib="$func_basename_result"
3759
case " $extracted_archives " in
3761
func_arith $extracted_serial + 1
3762
extracted_serial=$func_arith_result
3763
my_xlib_u=lt$extracted_serial-$my_xlib ;;
3767
extracted_archives="$extracted_archives $my_xlib_u"
3768
my_xdir="$my_gentop/$my_xlib_u"
3770
func_mkdir_p "$my_xdir"
3774
func_verbose "Extracting $my_xabs"
3775
# Do not bother doing anything if just a dry run
3777
darwin_orig_dir=`pwd`
3778
cd $my_xdir || exit $?
3779
darwin_archive=$my_xabs
3781
darwin_base_archive=`basename "$darwin_archive"`
3782
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783
if test -n "$darwin_arches"; then
3784
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3786
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3787
for darwin_arch in $darwin_arches ; do
3788
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3793
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794
done # $darwin_arches
3795
## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3799
for darwin_file in $darwin_filelist; do
3800
darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801
$LIPO -create -output "$darwin_file" $darwin_files
3802
done # $darwin_filelist
3804
cd "$darwin_orig_dir"
3807
func_extract_an_archive "$my_xdir" "$my_xabs"
3812
func_extract_an_archive "$my_xdir" "$my_xabs"
3815
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3818
func_extract_archives_result="$my_oldobjs"
3822
# func_emit_wrapper [arg=no]
3824
# Emit a libtool wrapper script on stdout.
3825
# Don't directly open a file because we may want to
3826
# incorporate the script contents within a cygwin/mingw
3827
# wrapper executable. Must ONLY be called from within
3828
# func_mode_link because it depends on a number of variables
3831
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832
# variable will take. If 'yes', then the emitted script
3833
# will assume that the directory in which it is stored is
3834
# the $objdir directory. This is a cygwin/mingw-specific
3836
func_emit_wrapper ()
3838
func_emit_wrapper_arg1=${1-no}
3843
# $output - temporary wrapper script for $objdir/$outputname
3844
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3846
# The $output program cannot be directly executed until all the libtool
3847
# libraries that it depends on are installed.
3849
# This wrapper script should never be moved out of the build directory.
3850
# If it is, it will not operate correctly.
3852
# Sed substitution that helps us do robust quoting. It backslashifies
3853
# metacharacters that are still active within double-quoted strings.
3854
sed_quote_subst='$sed_quote_subst'
3856
# Be Bourne compatible
3857
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3860
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861
# is contrary to our usage. Disable this feature.
3862
alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863
setopt NO_GLOB_SUBST
3865
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3867
BIN_SH=xpg4; export BIN_SH # for Tru64
3868
DUALCASE=1; export DUALCASE # for MKS sh
3870
# The HP-UX ksh and POSIX shell print the target directory to stdout
3872
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3874
relink_command=\"$relink_command\"
3876
# This environment variable determines our operation mode.
3877
if test \"\$libtool_install_magic\" = \"$magic\"; then
3878
# install mode needs the following variables:
3879
generated_by_libtool_version='$macro_version'
3880
notinst_deplibs='$notinst_deplibs'
3882
# When we are sourced in execute mode, \$file and \$ECHO are already set.
3883
if test \"\$libtool_execute_magic\" != \"$magic\"; then
3886
qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3889
# A function that is used when there is no print builtin or printf.
3890
func_fallback_echo ()
3892
eval 'cat <<_LTECHO_EOF
3899
# Very basic option parsing. These options are (a) specific to
3900
# the libtool wrapper, (b) are identical between the wrapper
3901
# /script/ and the wrapper /executable/ which is used only on
3902
# windows platforms, and (c) all begin with the string "--lt-"
3903
# (application programs are unlikely to have options which match
3906
# There are only two supported options: --lt-debug and
3907
# --lt-dump-script. There is, deliberately, no --lt-help.
3909
# The first argument to this parsing function should be the
3910
# script's $0 value, followed by "$@".
3912
func_parse_lt_options ()
3918
case \"\$lt_opt\" in
3919
--lt-debug) lt_option_debug=1 ;;
3921
lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922
test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923
lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924
cat \"\$lt_dump_D/\$lt_dump_F\"
3928
\$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3934
# Print the debug banner immediately:
3935
if test -n \"\$lt_option_debug\"; then
3936
echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3940
# Used when --lt-debug. Prints its arguments to stdout
3941
# (redirection is the responsibility of the caller)
3942
func_lt_dump_args ()
3947
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948
lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3952
# Core function for launching the target application
3953
func_exec_program_core ()
3957
# Backslashes separate directories on plain windows
3958
*-*-mingw | *-*-os2* | *-cegcc*)
3960
if test -n \"\$lt_option_debug\"; then
3961
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962
func_lt_dump_args \${1+\"\$@\"} 1>&2
3964
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3970
if test -n \"\$lt_option_debug\"; then
3971
\$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3972
func_lt_dump_args \${1+\"\$@\"} 1>&2
3974
exec \"\$progdir/\$program\" \${1+\"\$@\"}
3979
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3983
# A function to encapsulate launching the target application
3984
# Strips options in the --lt-* namespace from \$@ and
3985
# launches target application with the remaining arguments.
3986
func_exec_program ()
3994
*) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3999
func_exec_program_core \${1+\"\$@\"}
4003
func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4005
# Find the directory that this script lives in.
4006
thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4007
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4009
# Follow symbolic links until we get to the real thisdir.
4010
file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4011
while test -n \"\$file\"; do
4012
destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4014
# If there was a directory component, then change thisdir.
4015
if test \"x\$destdir\" != \"x\$file\"; then
4016
case \"\$destdir\" in
4017
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4018
*) thisdir=\"\$thisdir/\$destdir\" ;;
4022
file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023
file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4026
# Usually 'no', except on cygwin/mingw when embedded into
4028
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4029
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4030
# special case for '.'
4031
if test \"\$thisdir\" = \".\"; then
4034
# remove .libs from thisdir
4035
case \"\$thisdir\" in
4036
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4037
$objdir ) thisdir=. ;;
4041
# Try to get the absolute directory name.
4042
absdir=\`cd \"\$thisdir\" && pwd\`
4043
test -n \"\$absdir\" && thisdir=\"\$absdir\"
4046
if test "$fast_install" = yes; then
4048
program=lt-'$outputname'$exeext
4049
progdir=\"\$thisdir/$objdir\"
4051
if test ! -f \"\$progdir/\$program\" ||
4052
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4053
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4055
file=\"\$\$-\$program\"
4057
if test ! -d \"\$progdir\"; then
4058
$MKDIR \"\$progdir\"
4060
$RM \"\$progdir/\$file\"
4065
# relink executable if necessary
4066
if test -n \"\$relink_command\"; then
4067
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4069
$ECHO \"\$relink_command_output\" >&2
4070
$RM \"\$progdir/\$file\"
4075
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4076
{ $RM \"\$progdir/\$program\";
4077
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4078
$RM \"\$progdir/\$file\"
4082
program='$outputname'
4083
progdir=\"\$thisdir/$objdir\"
4089
if test -f \"\$progdir/\$program\"; then"
4091
# fixup the dll searchpath if we need to.
4093
# Fix the DLL searchpath if we need to. Do this before prepending
4094
# to shlibpath, because on Windows, both are PATH and uninstalled
4095
# libraries must come first.
4096
if test -n "$dllsearchpath"; then
4098
# Add the dll search path components to the executable PATH
4099
PATH=$dllsearchpath:\$PATH
4103
# Export our shlibpath_var if we have one.
4104
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4106
# Add our own library path to $shlibpath_var
4107
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4109
# Some systems cannot cope with colon-terminated $shlibpath_var
4110
# The second colon is a workaround for a bug in BeOS R4 sed
4111
$shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4113
export $shlibpath_var
4118
if test \"\$libtool_execute_magic\" != \"$magic\"; then
4119
# Run the actual program with our arguments.
4120
func_exec_program \${1+\"\$@\"}
4123
# The program doesn't exist.
4124
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4125
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4126
\$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4134
# func_emit_cwrapperexe_src
4135
# emit the source code for a wrapper executable on stdout
4136
# Must ONLY be called from within func_mode_link because
4137
# it depends on a number of variable set therein.
4138
func_emit_cwrapperexe_src ()
4142
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4143
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4145
The $output program cannot be directly executed until all the libtool
4146
libraries that it depends on are installed.
4148
This wrapper executable should never be moved out of the build directory.
4149
If it is, it will not operate correctly.
4154
# define _CRT_SECURE_NO_DEPRECATE 1
4159
# include <direct.h>
4160
# include <process.h>
4163
# include <unistd.h>
4164
# include <stdint.h>
4176
#include <sys/stat.h>
4178
/* declarations of non-ANSI functions */
4179
#if defined(__MINGW32__)
4180
# ifdef __STRICT_ANSI__
4181
int _putenv (const char *);
4183
#elif defined(__CYGWIN__)
4184
# ifdef __STRICT_ANSI__
4185
char *realpath (const char *, char *);
4186
int putenv (char *);
4187
int setenv (const char *, const char *, int);
4189
/* #elif defined (other platforms) ... */
4192
/* portability defines, excluding path handling macros */
4193
#if defined(_MSC_VER)
4194
# define setmode _setmode
4196
# define chmod _chmod
4197
# define getcwd _getcwd
4198
# define putenv _putenv
4199
# define S_IXUSR _S_IEXEC
4200
# ifndef _INTPTR_T_DEFINED
4201
# define _INTPTR_T_DEFINED
4202
# define intptr_t int
4204
#elif defined(__MINGW32__)
4205
# define setmode _setmode
4207
# define chmod _chmod
4208
# define getcwd _getcwd
4209
# define putenv _putenv
4210
#elif defined(__CYGWIN__)
4211
# define HAVE_SETENV
4212
# define FOPEN_WB "wb"
4213
/* #elif defined (other platforms) ... */
4216
#if defined(PATH_MAX)
4217
# define LT_PATHMAX PATH_MAX
4218
#elif defined(MAXPATHLEN)
4219
# define LT_PATHMAX MAXPATHLEN
4221
# define LT_PATHMAX 1024
4231
/* path handling portability macros */
4232
#ifndef DIR_SEPARATOR
4233
# define DIR_SEPARATOR '/'
4234
# define PATH_SEPARATOR ':'
4237
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4239
# define HAVE_DOS_BASED_FILE_SYSTEM
4240
# define FOPEN_WB "wb"
4241
# ifndef DIR_SEPARATOR_2
4242
# define DIR_SEPARATOR_2 '\\'
4244
# ifndef PATH_SEPARATOR_2
4245
# define PATH_SEPARATOR_2 ';'
4249
#ifndef DIR_SEPARATOR_2
4250
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4251
#else /* DIR_SEPARATOR_2 */
4252
# define IS_DIR_SEPARATOR(ch) \
4253
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4254
#endif /* DIR_SEPARATOR_2 */
4256
#ifndef PATH_SEPARATOR_2
4257
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4258
#else /* PATH_SEPARATOR_2 */
4259
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4260
#endif /* PATH_SEPARATOR_2 */
4263
# define FOPEN_WB "w"
4266
# define _O_BINARY 0
4269
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4270
#define XFREE(stale) do { \
4271
if (stale) { free ((void *) stale); stale = 0; } \
4274
#if defined(LT_DEBUGWRAPPER)
4275
static int lt_debug = 1;
4277
static int lt_debug = 0;
4280
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4282
void *xmalloc (size_t num);
4283
char *xstrdup (const char *string);
4284
const char *base_name (const char *name);
4285
char *find_executable (const char *wrapper);
4286
char *chase_symlinks (const char *pathspec);
4287
int make_executable (const char *path);
4288
int check_executable (const char *path);
4289
char *strendzap (char *str, const char *pat);
4290
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4291
void lt_fatal (const char *file, int line, const char *message, ...);
4292
static const char *nonnull (const char *s);
4293
static const char *nonempty (const char *s);
4294
void lt_setenv (const char *name, const char *value);
4295
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4296
void lt_update_exe_path (const char *name, const char *value);
4297
void lt_update_lib_path (const char *name, const char *value);
4298
char **prepare_spawn (char **argv);
4299
void lt_dump_script (FILE *f);
4303
volatile const char * MAGIC_EXE = "$magic_exe";
4304
const char * LIB_PATH_VARNAME = "$shlibpath_var";
4307
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4308
func_to_host_path "$temp_rpath"
4310
const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4314
const char * LIB_PATH_VALUE = "";
4318
if test -n "$dllsearchpath"; then
4319
func_to_host_path "$dllsearchpath:"
4321
const char * EXE_PATH_VARNAME = "PATH";
4322
const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4326
const char * EXE_PATH_VARNAME = "";
4327
const char * EXE_PATH_VALUE = "";
4331
if test "$fast_install" = yes; then
4333
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4337
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4344
#define LTWRAPPER_OPTION_PREFIX "--lt-"
4346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4347
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4348
static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
4351
main (int argc, char *argv[])
4356
char *actual_cwrapper_path;
4357
char *actual_cwrapper_name;
4360
intptr_t rval = 127;
4364
program_name = (char *) xstrdup (base_name (argv[0]));
4365
newargz = XMALLOC (char *, argc + 1);
4367
/* very simple arg parsing; don't want to rely on getopt
4368
* also, copy all non cwrapper options to newargz, except
4369
* argz[0], which is handled differently
4372
for (i = 1; i < argc; i++)
4374
if (strcmp (argv[i], dumpscript_opt) == 0)
4378
*mingw* | *cygwin* )
4379
# make stdout use "unix" line endings
4380
echo " setmode(1,_O_BINARY);"
4385
lt_dump_script (stdout);
4388
if (strcmp (argv[i], debug_opt) == 0)
4393
if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4395
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4396
namespace, but it is not one of the ones we know about and
4397
have already dealt with, above (inluding dump-script), then
4398
report an error. Otherwise, targets might begin to believe
4399
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4400
namespace. The first time any user complains about this, we'll
4401
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4402
or a configure.ac-settable value.
4404
lt_fatal (__FILE__, __LINE__,
4405
"unrecognized %s option: '%s'",
4406
ltwrapper_option_prefix, argv[i]);
4409
newargz[++newargc] = xstrdup (argv[i]);
4411
newargz[++newargc] = NULL;
4415
/* The GNU banner must be the first non-error debug message */
4416
lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4419
lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4420
lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4422
tmp_pathspec = find_executable (argv[0]);
4423
if (tmp_pathspec == NULL)
4424
lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4425
lt_debugprintf (__FILE__, __LINE__,
4426
"(main) found exe (before symlink chase) at: %s\n",
4429
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4430
lt_debugprintf (__FILE__, __LINE__,
4431
"(main) found exe (after symlink chase) at: %s\n",
4432
actual_cwrapper_path);
4433
XFREE (tmp_pathspec);
4435
actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4436
strendzap (actual_cwrapper_path, actual_cwrapper_name);
4438
/* wrapper name transforms */
4439
strendzap (actual_cwrapper_name, ".exe");
4440
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4441
XFREE (actual_cwrapper_name);
4442
actual_cwrapper_name = tmp_pathspec;
4445
/* target_name transforms -- use actual target program name; might have lt- prefix */
4446
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4447
strendzap (target_name, ".exe");
4448
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4449
XFREE (target_name);
4450
target_name = tmp_pathspec;
4453
lt_debugprintf (__FILE__, __LINE__,
4454
"(main) libtool target name: %s\n",
4460
XMALLOC (char, (strlen (actual_cwrapper_path) +
4461
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4462
strcpy (newargz[0], actual_cwrapper_path);
4463
strcat (newargz[0], "$objdir");
4464
strcat (newargz[0], "/");
4468
/* stop here, and copy so we don't have to do this twice */
4469
tmp_pathspec = xstrdup (newargz[0]);
4471
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4472
strcat (newargz[0], actual_cwrapper_name);
4474
/* DO want the lt- prefix here if it exists, so use target_name */
4475
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4476
XFREE (tmp_pathspec);
4477
tmp_pathspec = NULL;
4485
while ((p = strchr (newargz[0], '\\')) != NULL)
4489
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4499
XFREE (target_name);
4500
XFREE (actual_cwrapper_path);
4501
XFREE (actual_cwrapper_name);
4503
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4504
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4505
/* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4506
be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4507
because on Windows, both *_VARNAMEs are PATH but uninstalled
4508
libraries must come first. */
4509
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4510
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4512
lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513
nonnull (lt_argv_zero));
4514
for (i = 0; i < newargc; i++)
4516
lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517
i, nonnull (newargz[i]));
4525
/* execv doesn't actually work on mingw as expected on unix */
4526
newargz = prepare_spawn (newargz);
4527
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4530
/* failed to start process */
4531
lt_debugprintf (__FILE__, __LINE__,
4532
"(main) failed to launch target \"%s\": %s\n",
4533
lt_argv_zero, nonnull (strerror (errno)));
4541
execv (lt_argv_zero, newargz);
4542
return rval; /* =127, but avoids unused variable warning */
4551
xmalloc (size_t num)
4553
void *p = (void *) malloc (num);
4555
lt_fatal (__FILE__, __LINE__, "memory exhausted");
4561
xstrdup (const char *string)
4563
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4568
base_name (const char *name)
4572
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4573
/* Skip over the disk name in MSDOS pathnames. */
4574
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4578
for (base = name; *name; name++)
4579
if (IS_DIR_SEPARATOR (*name))
4585
check_executable (const char *path)
4589
lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4591
if ((!path) || (!*path))
4594
if ((stat (path, &st) >= 0)
4595
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4602
make_executable (const char *path)
4607
lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4609
if ((!path) || (!*path))
4612
if (stat (path, &st) >= 0)
4614
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4619
/* Searches for the full path of the wrapper. Returns
4620
newly allocated full path name if found, NULL otherwise
4621
Does not chase symlinks, even on platforms that support them.
4624
find_executable (const char *wrapper)
4629
/* static buffer for getcwd */
4630
char tmp[LT_PATHMAX + 1];
4634
lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4635
nonempty (wrapper));
4637
if ((wrapper == NULL) || (*wrapper == '\0'))
4640
/* Absolute path? */
4641
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4642
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4644
concat_name = xstrdup (wrapper);
4645
if (check_executable (concat_name))
4647
XFREE (concat_name);
4652
if (IS_DIR_SEPARATOR (wrapper[0]))
4654
concat_name = xstrdup (wrapper);
4655
if (check_executable (concat_name))
4657
XFREE (concat_name);
4659
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4663
for (p = wrapper; *p; p++)
4671
/* no slashes; search PATH */
4672
const char *path = getenv ("PATH");
4675
for (p = path; *p; p = p_next)
4679
for (q = p; *q; q++)
4680
if (IS_PATH_SEPARATOR (*q))
4683
p_next = (*q == '\0' ? q : q + 1);
4686
/* empty path: current directory */
4687
if (getcwd (tmp, LT_PATHMAX) == NULL)
4688
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4689
nonnull (strerror (errno)));
4690
tmp_len = strlen (tmp);
4692
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4693
memcpy (concat_name, tmp, tmp_len);
4694
concat_name[tmp_len] = '/';
4695
strcpy (concat_name + tmp_len + 1, wrapper);
4700
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4701
memcpy (concat_name, p, p_len);
4702
concat_name[p_len] = '/';
4703
strcpy (concat_name + p_len + 1, wrapper);
4705
if (check_executable (concat_name))
4707
XFREE (concat_name);
4710
/* not found in PATH; assume curdir */
4712
/* Relative path | not found in path: prepend cwd */
4713
if (getcwd (tmp, LT_PATHMAX) == NULL)
4714
lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4715
nonnull (strerror (errno)));
4716
tmp_len = strlen (tmp);
4717
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4718
memcpy (concat_name, tmp, tmp_len);
4719
concat_name[tmp_len] = '/';
4720
strcpy (concat_name + tmp_len + 1, wrapper);
4722
if (check_executable (concat_name))
4724
XFREE (concat_name);
4729
chase_symlinks (const char *pathspec)
4732
return xstrdup (pathspec);
4734
char buf[LT_PATHMAX];
4736
char *tmp_pathspec = xstrdup (pathspec);
4738
int has_symlinks = 0;
4739
while (strlen (tmp_pathspec) && !has_symlinks)
4741
lt_debugprintf (__FILE__, __LINE__,
4742
"checking path component for symlinks: %s\n",
4744
if (lstat (tmp_pathspec, &s) == 0)
4746
if (S_ISLNK (s.st_mode) != 0)
4752
/* search backwards for last DIR_SEPARATOR */
4753
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4754
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4756
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4758
/* no more DIR_SEPARATORS left */
4765
lt_fatal (__FILE__, __LINE__,
4766
"error accessing file \"%s\": %s",
4767
tmp_pathspec, nonnull (strerror (errno)));
4770
XFREE (tmp_pathspec);
4774
return xstrdup (pathspec);
4777
tmp_pathspec = realpath (pathspec, buf);
4778
if (tmp_pathspec == 0)
4780
lt_fatal (__FILE__, __LINE__,
4781
"could not follow symlinks for %s", pathspec);
4783
return xstrdup (tmp_pathspec);
4788
strendzap (char *str, const char *pat)
4792
assert (str != NULL);
4793
assert (pat != NULL);
4796
patlen = strlen (pat);
4800
str += len - patlen;
4801
if (strcmp (str, pat) == 0)
4808
lt_debugprintf (const char *file, int line, const char *fmt, ...)
4813
(void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4814
va_start (args, fmt);
4815
(void) vfprintf (stderr, fmt, args);
4821
lt_error_core (int exit_status, const char *file,
4822
int line, const char *mode,
4823
const char *message, va_list ap)
4825
fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4826
vfprintf (stderr, message, ap);
4827
fprintf (stderr, ".\n");
4829
if (exit_status >= 0)
4834
lt_fatal (const char *file, int line, const char *message, ...)
4837
va_start (ap, message);
4838
lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4843
nonnull (const char *s)
4845
return s ? s : "(null)";
4849
nonempty (const char *s)
4851
return (s && !*s) ? "(empty)" : nonnull (s);
4855
lt_setenv (const char *name, const char *value)
4857
lt_debugprintf (__FILE__, __LINE__,
4858
"(lt_setenv) setting '%s' to '%s'\n",
4859
nonnull (name), nonnull (value));
4862
/* always make a copy, for consistency with !HAVE_SETENV */
4863
char *str = xstrdup (value);
4864
setenv (name, str, 1);
4866
int len = strlen (name) + 1 + strlen (value) + 1;
4867
char *str = XMALLOC (char, len);
4868
sprintf (str, "%s=%s", name, value);
4869
if (putenv (str) != EXIT_SUCCESS)
4878
lt_extend_str (const char *orig_value, const char *add, int to_end)
4881
if (orig_value && *orig_value)
4883
int orig_value_len = strlen (orig_value);
4884
int add_len = strlen (add);
4885
new_value = XMALLOC (char, add_len + orig_value_len + 1);
4888
strcpy (new_value, orig_value);
4889
strcpy (new_value + orig_value_len, add);
4893
strcpy (new_value, add);
4894
strcpy (new_value + add_len, orig_value);
4899
new_value = xstrdup (add);
4905
lt_update_exe_path (const char *name, const char *value)
4907
lt_debugprintf (__FILE__, __LINE__,
4908
"(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909
nonnull (name), nonnull (value));
4911
if (name && *name && value && *value)
4913
char *new_value = lt_extend_str (getenv (name), value, 0);
4914
/* some systems can't cope with a ':'-terminated path #' */
4915
int len = strlen (new_value);
4916
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4918
new_value[len-1] = '\0';
4920
lt_setenv (name, new_value);
4926
lt_update_lib_path (const char *name, const char *value)
4928
lt_debugprintf (__FILE__, __LINE__,
4929
"(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930
nonnull (name), nonnull (value));
4932
if (name && *name && value && *value)
4934
char *new_value = lt_extend_str (getenv (name), value, 0);
4935
lt_setenv (name, new_value);
4945
/* Prepares an argument vector before calling spawn().
4946
Note that spawn() does not by itself call the command interpreter
4947
(getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4948
({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4950
v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4951
}) ? "cmd.exe" : "command.com").
4952
Instead it simply concatenates the arguments, separated by ' ', and calls
4953
CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4954
interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4956
- Space and tab are interpreted as delimiters. They are not treated as
4957
delimiters if they are surrounded by double quotes: "...".
4958
- Unescaped double quotes are removed from the input. Their only effect is
4959
that within double quotes, space and tab are treated like normal
4961
- Backslashes not followed by double quotes are not special.
4962
- But 2*n+1 backslashes followed by a double quote become
4963
n backslashes followed by a double quote (n >= 0):
4968
#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"
4969
#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"
4971
prepare_spawn (char **argv)
4977
/* Count number of arguments. */
4978
for (argc = 0; argv[argc] != NULL; argc++)
4981
/* Allocate new argument vector. */
4982
new_argv = XMALLOC (char *, argc + 1);
4984
/* Put quoted arguments into the new argument vector. */
4985
for (i = 0; i < argc; i++)
4987
const char *string = argv[i];
4989
if (string[0] == '\0')
4990
new_argv[i] = xstrdup ("\"\"");
4991
else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4993
int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4995
unsigned int backslashes;
4997
char *quoted_string;
5004
for (s = string; *s != '\0'; s++)
5008
length += backslashes + 1;
5016
length += backslashes + 1;
5018
quoted_string = XMALLOC (char, length + 1);
5024
for (s = string; *s != '\0'; s++)
5030
for (j = backslashes + 1; j > 0; j--)
5042
for (j = backslashes; j > 0; j--)
5048
new_argv[i] = quoted_string;
5051
new_argv[i] = (char *) string;
5053
new_argv[argc] = NULL;
5062
void lt_dump_script (FILE* f)
5065
func_emit_wrapper yes |
5067
s/^\(.\{79\}\)\(..*\)/\1\
5072
s/\([^\n]*\).*/ fputs ("\1", f);/p
5079
# end: func_emit_cwrapperexe_src
5081
# func_win32_import_lib_p ARG
5082
# True if ARG is an import lib, as indicated by $file_magic_cmd
5083
func_win32_import_lib_p ()
5086
case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5092
# func_mode_link arg...
5097
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5098
# It is impossible to link a dll without this setting, and
5099
# we shouldn't force the makefile maintainer to figure out
5100
# which system we are compiling for in order to pass an extra
5101
# flag for every libtool invocation.
5102
# allow_undefined=no
5104
# FIXME: Unfortunately, there are problems with the above when trying
5105
# to make a dll which has undefined symbols, in which case not
5106
# even a static library is built. For now, we need to specify
5107
# -no-undefined on the libtool link line when we can be certain
5108
# that all symbols are satisfied, otherwise we get a static library.
5115
libtool_args=$nonopt
5116
base_compile="$nonopt $@"
5117
compile_command=$nonopt
5118
finalize_command=$nonopt
5131
lib_search_path=`pwd`
5133
new_inherited_linker_flags=
5142
export_symbols_regex=
5150
precious_files_regex=
5151
prefer_static_libs=no
5164
single_module="${wl}-single_module"
5165
func_infer_tag $base_compile
5167
# We need to know -static, to get the right output filenames.
5172
test "$build_libtool_libs" != yes && \
5173
func_fatal_configuration "can not build a shared library"
5177
-all-static | -static | -static-libtool-libs)
5180
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5181
func_warning "complete static linking is impossible in this configuration"
5183
if test -n "$link_static_flag"; then
5184
dlopen_self=$dlopen_self_static
5186
prefer_static_libs=yes
5189
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5190
dlopen_self=$dlopen_self_static
5192
prefer_static_libs=built
5194
-static-libtool-libs)
5195
if test -z "$pic_flag" && test -n "$link_static_flag"; then
5196
dlopen_self=$dlopen_self_static
5198
prefer_static_libs=yes
5201
build_libtool_libs=no
5208
# See if our shared archives depend on static archives.
5209
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5211
# Go through the arguments, transforming them on the way.
5212
while test "$#" -gt 0; do
5215
func_quote_for_eval "$arg"
5216
qarg=$func_quote_for_eval_unquoted_result
5217
func_append libtool_args " $func_quote_for_eval_result"
5219
# If the previous option needs an argument, assign it.
5220
if test -n "$prev"; then
5223
func_append compile_command " @OUTPUT@"
5224
func_append finalize_command " @OUTPUT@"
5235
if test "$preload" = no; then
5236
# Add the symbol object into the linking commands.
5237
func_append compile_command " @SYMFILE@"
5238
func_append finalize_command " @SYMFILE@"
5242
*.la | *.lo) ;; # We handle these cases below.
5244
if test "$dlself" = no; then
5252
if test "$prev" = dlprefiles; then
5254
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5264
if test "$prev" = dlfiles; then
5265
func_append dlfiles " $arg"
5267
func_append dlprefiles " $arg"
5275
export_symbols="$arg"
5277
|| func_fatal_error "symbol file \`$arg' does not exist"
5282
export_symbols_regex="$arg"
5290
*" $qarg.ltframework "*) ;;
5291
*) func_append deplibs " $qarg.ltframework" # this is fixed later
5300
inst_prefix_dir="$arg"
5305
if test -f "$arg"; then
5308
for fil in `cat "$save_arg"`
5310
# func_append moreargs " $fil"
5312
# A libtool-controlled object.
5314
# Check to see that this really is a libtool object.
5315
if func_lalib_unsafe_p "$arg"; then
5322
if test -z "$pic_object" ||
5323
test -z "$non_pic_object" ||
5324
test "$pic_object" = none &&
5325
test "$non_pic_object" = none; then
5326
func_fatal_error "cannot find name of object for \`$arg'"
5329
# Extract subdirectory from the argument.
5330
func_dirname "$arg" "/" ""
5331
xdir="$func_dirname_result"
5333
if test "$pic_object" != none; then
5334
# Prepend the subdirectory the object is found in.
5335
pic_object="$xdir$pic_object"
5337
if test "$prev" = dlfiles; then
5338
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5339
func_append dlfiles " $pic_object"
5343
# If libtool objects are unsupported, then we need to preload.
5348
# CHECK ME: I think I busted this. -Ossama
5349
if test "$prev" = dlprefiles; then
5350
# Preload the old-style object.
5351
func_append dlprefiles " $pic_object"
5356
func_append libobjs " $pic_object"
5361
if test "$non_pic_object" != none; then
5362
# Prepend the subdirectory the object is found in.
5363
non_pic_object="$xdir$non_pic_object"
5365
# A standard non-PIC object
5366
func_append non_pic_objects " $non_pic_object"
5367
if test -z "$pic_object" || test "$pic_object" = none ; then
5368
arg="$non_pic_object"
5371
# If the PIC object exists, use it instead.
5372
# $xdir was prepended to $pic_object above.
5373
non_pic_object="$pic_object"
5374
func_append non_pic_objects " $non_pic_object"
5377
# Only an error if not doing a dry-run.
5378
if $opt_dry_run; then
5379
# Extract subdirectory from the argument.
5380
func_dirname "$arg" "/" ""
5381
xdir="$func_dirname_result"
5384
pic_object=$xdir$objdir/$func_lo2o_result
5385
non_pic_object=$xdir$func_lo2o_result
5386
func_append libobjs " $pic_object"
5387
func_append non_pic_objects " $non_pic_object"
5389
func_fatal_error "\`$arg' is not a valid libtool object"
5394
func_fatal_error "link input file \`$arg' does not exist"
5401
precious_files_regex="$arg"
5411
# We need an absolute path.
5413
[\\/]* | [A-Za-z]:[\\/]*) ;;
5415
func_fatal_error "only absolute run-paths are allowed"
5418
if test "$prev" = rpath; then
5421
*) func_append rpath " $arg" ;;
5426
*) func_append xrpath " $arg" ;;
5438
func_append weak_libs " $arg"
5443
func_append linker_flags " $qarg"
5444
func_append compiler_flags " $qarg"
5446
func_append compile_command " $qarg"
5447
func_append finalize_command " $qarg"
5451
func_append compiler_flags " $qarg"
5453
func_append compile_command " $qarg"
5454
func_append finalize_command " $qarg"
5458
func_append linker_flags " $qarg"
5459
func_append compiler_flags " $wl$qarg"
5461
func_append compile_command " $wl$qarg"
5462
func_append finalize_command " $wl$qarg"
5466
eval "$prev=\"\$arg\""
5471
fi # test -n "$prev"
5477
if test -n "$link_static_flag"; then
5478
# See comment for -static flag below, for more details.
5479
func_append compile_command " $link_static_flag"
5480
func_append finalize_command " $link_static_flag"
5486
# FIXME: remove this flag sometime in the future.
5487
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5515
-export-symbols | -export-symbols-regex)
5516
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5517
func_fatal_error "more than one -exported-symbols argument is not allowed"
5519
if test "X$arg" = "X-export-symbols"; then
5537
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5538
# so, if we see these flags be careful not to treat them like -L
5540
case $with_gcc/$host in
5541
no/*-*-irix* | /*-*-irix*)
5542
func_append compile_command " $arg"
5543
func_append finalize_command " $arg"
5550
func_stripname "-L" '' "$arg"
5551
if test -z "$func_stripname_result"; then
5552
if test "$#" -gt 0; then
5553
func_fatal_error "require no space between \`-L' and \`$1'"
5555
func_fatal_error "need path for \`-L' option"
5558
func_resolve_sysroot "$func_stripname_result"
5559
dir=$func_resolve_sysroot_result
5560
# We need an absolute path.
5562
[\\/]* | [A-Za-z]:[\\/]*) ;;
5564
absdir=`cd "$dir" && pwd`
5565
test -z "$absdir" && \
5566
func_fatal_error "cannot determine absolute directory name of \`$dir'"
5571
*" -L$dir "* | *" $arg "*)
5572
# Will only happen for absolute or sysroot arguments
5575
# Preserve sysroot, but never include relative directories
5577
[\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5578
*) func_append deplibs " -L$dir" ;;
5580
func_append lib_search_path " $dir"
5584
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5585
testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5586
case :$dllsearchpath: in
5588
::) dllsearchpath=$dir;;
5589
*) func_append dllsearchpath ":$dir";;
5591
case :$dllsearchpath: in
5592
*":$testbindir:"*) ;;
5593
::) dllsearchpath=$testbindir;;
5594
*) func_append dllsearchpath ":$testbindir";;
5602
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5604
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5605
# These systems don't actually have a C or math library (as such)
5609
# These systems don't actually have a C library (as such)
5610
test "X$arg" = "X-lc" && continue
5612
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5613
# Do not include libc due to us having libc/libc_r.
5614
test "X$arg" = "X-lc" && continue
5616
*-*-rhapsody* | *-*-darwin1.[012])
5617
# Rhapsody C and math libraries are in the System framework
5618
func_append deplibs " System.ltframework"
5621
*-*-sco3.2v5* | *-*-sco5v6*)
5622
# Causes problems with __ctype
5623
test "X$arg" = "X-lc" && continue
5625
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5626
# Compiler inserts libc in the correct place for threads to work
5627
test "X$arg" = "X-lc" && continue
5630
elif test "X$arg" = "X-lc_r"; then
5632
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5633
# Do not include libc_r directly, use -pthread flag.
5638
func_append deplibs " $arg"
5647
# Tru64 UNIX uses -model [arg] to determine the layout of C++
5648
# classes, name mangling, and exception handling.
5649
# Darwin uses the -arch flag to determine output architecture.
5650
-model|-arch|-isysroot|--sysroot)
5651
func_append compiler_flags " $arg"
5652
func_append compile_command " $arg"
5653
func_append finalize_command " $arg"
5658
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660
func_append compiler_flags " $arg"
5661
func_append compile_command " $arg"
5662
func_append finalize_command " $arg"
5663
case "$new_inherited_linker_flags " in
5665
* ) func_append new_inherited_linker_flags " $arg" ;;
5671
single_module="${wl}-multi_module"
5682
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5683
# The PATH hackery in wrapper scripts is required on Windows
5684
# and Darwin in order for the loader to find any dlls it needs.
5685
func_warning "\`-no-install' is ignored for $host"
5686
func_warning "assuming \`-no-fast-install' instead"
5689
*) no_install=yes ;;
5706
-precious-files-regex)
5727
func_stripname '-R' '' "$arg"
5728
dir=$func_stripname_result
5729
# We need an absolute path.
5731
[\\/]* | [A-Za-z]:[\\/]*) ;;
5733
func_stripname '=' '' "$dir"
5734
dir=$lt_sysroot$func_stripname_result
5737
func_fatal_error "only absolute run-paths are allowed"
5742
*) func_append xrpath " $dir" ;;
5748
# The effects of -shared are defined in a previous loop.
5757
-static | -static-libtool-libs)
5758
# The effects of -static are defined in a previous loop.
5759
# We used to do the same as -all-static on platforms that
5760
# didn't have a PIC flag, but the assumption that the effects
5761
# would be equivalent was wrong. It would break on at least
5762
# Digital Unix and AIX.
5788
func_stripname '-Wc,' '' "$arg"
5789
args=$func_stripname_result
5791
save_ifs="$IFS"; IFS=','
5792
for flag in $args; do
5794
func_quote_for_eval "$flag"
5795
func_append arg " $func_quote_for_eval_result"
5796
func_append compiler_flags " $func_quote_for_eval_result"
5799
func_stripname ' ' '' "$arg"
5800
arg=$func_stripname_result
5804
func_stripname '-Wl,' '' "$arg"
5805
args=$func_stripname_result
5807
save_ifs="$IFS"; IFS=','
5808
for flag in $args; do
5810
func_quote_for_eval "$flag"
5811
func_append arg " $wl$func_quote_for_eval_result"
5812
func_append compiler_flags " $wl$func_quote_for_eval_result"
5813
func_append linker_flags " $func_quote_for_eval_result"
5816
func_stripname ' ' '' "$arg"
5817
arg=$func_stripname_result
5837
func_quote_for_eval "$arg"
5838
arg="$func_quote_for_eval_result"
5841
# Flags to be passed through unchanged, with rationale:
5842
# -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5843
# -r[0-9][0-9]* specify processor for the SGI compiler
5844
# -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5845
# +DA*, +DD* enable 64-bit mode for the HP compiler
5846
# -q* compiler args for the IBM compiler
5847
# -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5848
# -F/path path to uninstalled frameworks, gcc on darwin
5849
# -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5850
# @file GCC response files
5851
# -tp=* Portland pgcc target processor selection
5852
# --sysroot=* for sysroot support
5853
# -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5854
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5855
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856
-O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5857
func_quote_for_eval "$arg"
5858
arg="$func_quote_for_eval_result"
5859
func_append compile_command " $arg"
5860
func_append finalize_command " $arg"
5861
func_append compiler_flags " $arg"
5865
# Some other compiler flag.
5867
func_quote_for_eval "$arg"
5868
arg="$func_quote_for_eval_result"
5872
# A standard object.
5873
func_append objs " $arg"
5877
# A libtool-controlled object.
5879
# Check to see that this really is a libtool object.
5880
if func_lalib_unsafe_p "$arg"; then
5887
if test -z "$pic_object" ||
5888
test -z "$non_pic_object" ||
5889
test "$pic_object" = none &&
5890
test "$non_pic_object" = none; then
5891
func_fatal_error "cannot find name of object for \`$arg'"
5894
# Extract subdirectory from the argument.
5895
func_dirname "$arg" "/" ""
5896
xdir="$func_dirname_result"
5898
if test "$pic_object" != none; then
5899
# Prepend the subdirectory the object is found in.
5900
pic_object="$xdir$pic_object"
5902
if test "$prev" = dlfiles; then
5903
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5904
func_append dlfiles " $pic_object"
5908
# If libtool objects are unsupported, then we need to preload.
5913
# CHECK ME: I think I busted this. -Ossama
5914
if test "$prev" = dlprefiles; then
5915
# Preload the old-style object.
5916
func_append dlprefiles " $pic_object"
5921
func_append libobjs " $pic_object"
5926
if test "$non_pic_object" != none; then
5927
# Prepend the subdirectory the object is found in.
5928
non_pic_object="$xdir$non_pic_object"
5930
# A standard non-PIC object
5931
func_append non_pic_objects " $non_pic_object"
5932
if test -z "$pic_object" || test "$pic_object" = none ; then
5933
arg="$non_pic_object"
5936
# If the PIC object exists, use it instead.
5937
# $xdir was prepended to $pic_object above.
5938
non_pic_object="$pic_object"
5939
func_append non_pic_objects " $non_pic_object"
5942
# Only an error if not doing a dry-run.
5943
if $opt_dry_run; then
5944
# Extract subdirectory from the argument.
5945
func_dirname "$arg" "/" ""
5946
xdir="$func_dirname_result"
5949
pic_object=$xdir$objdir/$func_lo2o_result
5950
non_pic_object=$xdir$func_lo2o_result
5951
func_append libobjs " $pic_object"
5952
func_append non_pic_objects " $non_pic_object"
5954
func_fatal_error "\`$arg' is not a valid libtool object"
5961
func_append deplibs " $arg"
5962
func_append old_deplibs " $arg"
5967
# A libtool-controlled library.
5969
func_resolve_sysroot "$arg"
5970
if test "$prev" = dlfiles; then
5971
# This library was specified with -dlopen.
5972
func_append dlfiles " $func_resolve_sysroot_result"
5974
elif test "$prev" = dlprefiles; then
5975
# The library was specified with -dlpreopen.
5976
func_append dlprefiles " $func_resolve_sysroot_result"
5979
func_append deplibs " $func_resolve_sysroot_result"
5984
# Some other compiler argument.
5986
# Unknown arguments in both finalize_command and compile_command need
5987
# to be aesthetically quoted because they are evaled later.
5988
func_quote_for_eval "$arg"
5989
arg="$func_quote_for_eval_result"
5993
# Now actually substitute the argument into the commands.
5994
if test -n "$arg"; then
5995
func_append compile_command " $arg"
5996
func_append finalize_command " $arg"
5998
done # argument parsing loop
6000
test -n "$prev" && \
6001
func_fatal_help "the \`$prevarg' option requires an argument"
6003
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6004
eval arg=\"$export_dynamic_flag_spec\"
6005
func_append compile_command " $arg"
6006
func_append finalize_command " $arg"
6010
# calculate the name of the file, without its directory
6011
func_basename "$output"
6012
outputname="$func_basename_result"
6013
libobjs_save="$libobjs"
6015
if test -n "$shlibpath_var"; then
6016
# get the directories listed in $shlibpath_var
6017
eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6021
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6022
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6024
func_dirname "$output" "/" ""
6025
output_objdir="$func_dirname_result$objdir"
6026
func_to_tool_file "$output_objdir/"
6027
tool_output_objdir=$func_to_tool_file_result
6028
# Create the object directory.
6029
func_mkdir_p "$output_objdir"
6031
# Determine the type of output
6034
func_fatal_help "you must specify an output file"
6036
*.$libext) linkmode=oldlib ;;
6037
*.lo | *.$objext) linkmode=obj ;;
6038
*.la) linkmode=lib ;;
6039
*) linkmode=prog ;; # Anything else should be a program.
6045
# Find all interdependent deplibs by searching for libraries
6046
# that are linked more than once (e.g. -la -lb -la)
6047
for deplib in $deplibs; do
6048
if $opt_preserve_dup_deps ; then
6050
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6053
func_append libs " $deplib"
6056
if test "$linkmode" = lib; then
6057
libs="$predeps $libs $compiler_lib_search_path $postdeps"
6059
# Compute libraries that are listed more than once in $predeps
6060
# $postdeps and mark them as special (i.e., whose duplicates are
6061
# not to be eliminated).
6063
if $opt_duplicate_compiler_generated_deps; then
6064
for pre_post_dep in $predeps $postdeps; do
6065
case "$pre_post_deps " in
6066
*" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6068
func_append pre_post_deps " $pre_post_dep"
6077
need_relink=no # whether we're linking any uninstalled libtool libraries
6078
notinst_deplibs= # not-installed libtool libraries
6079
notinst_path= # paths that contain not-installed libtool libraries
6083
passes="conv dlpreopen link"
6084
for file in $dlfiles $dlprefiles; do
6088
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6099
passes="conv scan dlopen dlpreopen link"
6105
for pass in $passes; do
6106
# The preopen pass in lib mode reverses $deplibs; put it back here
6107
# so that -L comes before libs that need it for instance...
6108
if test "$linkmode,$pass" = "lib,link"; then
6109
## FIXME: Find the place where the list is rebuilt in the wrong
6110
## order, and fix it there properly
6112
for deplib in $deplibs; do
6113
tmp_deplibs="$deplib $tmp_deplibs"
6115
deplibs="$tmp_deplibs"
6118
if test "$linkmode,$pass" = "lib,link" ||
6119
test "$linkmode,$pass" = "prog,scan"; then
6123
if test "$linkmode" = prog; then
6125
dlopen) libs="$dlfiles" ;;
6126
dlpreopen) libs="$dlprefiles" ;;
6128
libs="$deplibs %DEPLIBS%"
6129
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
6133
if test "$linkmode,$pass" = "lib,dlpreopen"; then
6134
# Collect and forward deplibs of preopened libtool libs
6135
for lib in $dlprefiles; do
6136
# Ignore non-libtool-libs
6138
func_resolve_sysroot "$lib"
6140
*.la) func_source "$func_resolve_sysroot_result" ;;
6143
# Collect preopened libtool deplibs, except any this library
6144
# has declared as weak libs
6145
for deplib in $dependency_libs; do
6146
func_basename "$deplib"
6147
deplib_base=$func_basename_result
6148
case " $weak_libs " in
6149
*" $deplib_base "*) ;;
6150
*) func_append deplibs " $deplib" ;;
6156
if test "$pass" = dlopen; then
6157
# Collect dlpreopened libraries
6158
save_deplibs="$deplibs"
6162
for deplib in $libs; do
6166
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6167
|-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6168
if test "$linkmode,$pass" = "prog,link"; then
6169
compile_deplibs="$deplib $compile_deplibs"
6170
finalize_deplibs="$deplib $finalize_deplibs"
6172
func_append compiler_flags " $deplib"
6173
if test "$linkmode" = lib ; then
6174
case "$new_inherited_linker_flags " in
6176
* ) func_append new_inherited_linker_flags " $deplib" ;;
6183
if test "$linkmode" != lib && test "$linkmode" != prog; then
6184
func_warning "\`-l' is ignored for archives/objects"
6187
func_stripname '-l' '' "$deplib"
6188
name=$func_stripname_result
6189
if test "$linkmode" = lib; then
6190
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6192
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6194
for searchdir in $searchdirs; do
6195
for search_ext in .la $std_shrext .so .a; do
6196
# Search the libtool library
6197
lib="$searchdir/lib${name}${search_ext}"
6198
if test -f "$lib"; then
6199
if test "$search_ext" = ".la"; then
6208
if test "$found" != yes; then
6209
# deplib doesn't seem to be a libtool library
6210
if test "$linkmode,$pass" = "prog,link"; then
6211
compile_deplibs="$deplib $compile_deplibs"
6212
finalize_deplibs="$deplib $finalize_deplibs"
6214
deplibs="$deplib $deplibs"
6215
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6218
else # deplib is a libtool library
6219
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6220
# We need to do some special things here, and not later.
6221
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6222
case " $predeps $postdeps " in
6224
if func_lalib_p "$lib"; then
6228
for l in $old_library $library_names; do
6231
if test "X$ll" = "X$old_library" ; then # only static version available
6233
func_dirname "$lib" "" "."
6234
ladir="$func_dirname_result"
6235
lib=$ladir/$old_library
6236
if test "$linkmode,$pass" = "prog,link"; then
6237
compile_deplibs="$deplib $compile_deplibs"
6238
finalize_deplibs="$deplib $finalize_deplibs"
6240
deplibs="$deplib $deplibs"
6241
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6253
if test "$linkmode,$pass" = "prog,link"; then
6254
compile_deplibs="$deplib $compile_deplibs"
6255
finalize_deplibs="$deplib $finalize_deplibs"
6257
deplibs="$deplib $deplibs"
6258
if test "$linkmode" = lib ; then
6259
case "$new_inherited_linker_flags " in
6261
* ) func_append new_inherited_linker_flags " $deplib" ;;
6270
deplibs="$deplib $deplibs"
6271
test "$pass" = conv && continue
6272
newdependency_libs="$deplib $newdependency_libs"
6273
func_stripname '-L' '' "$deplib"
6274
func_resolve_sysroot "$func_stripname_result"
6275
func_append newlib_search_path " $func_resolve_sysroot_result"
6278
if test "$pass" = conv; then
6279
deplibs="$deplib $deplibs"
6282
if test "$pass" = scan; then
6283
deplibs="$deplib $deplibs"
6285
compile_deplibs="$deplib $compile_deplibs"
6286
finalize_deplibs="$deplib $finalize_deplibs"
6288
func_stripname '-L' '' "$deplib"
6289
func_resolve_sysroot "$func_stripname_result"
6290
func_append newlib_search_path " $func_resolve_sysroot_result"
6293
func_warning "\`-L' is ignored for archives/objects"
6299
if test "$pass" = link; then
6300
func_stripname '-R' '' "$deplib"
6301
func_resolve_sysroot "$func_stripname_result"
6302
dir=$func_resolve_sysroot_result
6303
# Make sure the xrpath contains only unique directories.
6306
*) func_append xrpath " $dir" ;;
6309
deplibs="$deplib $deplibs"
6313
func_resolve_sysroot "$deplib"
6314
lib=$func_resolve_sysroot_result
6317
if test "$pass" = conv; then
6318
deplibs="$deplib $deplibs"
6323
# Linking convenience modules into shared libraries is allowed,
6324
# but linking other static libraries is non-portable.
6325
case " $dlpreconveniencelibs " in
6329
case $deplibs_check_method in
6331
set dummy $deplibs_check_method; shift
6332
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6333
if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6334
| $EGREP "$match_pattern_regex" > /dev/null; then
6342
if test "$valid_a_lib" != yes; then
6344
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
6345
echo "*** I have the capability to make that library automatically link in when"
6346
echo "*** you link to this library. But I can only do this if you have a"
6347
echo "*** shared version of the library, which you do not appear to have"
6348
echo "*** because the file extensions .$libext of this argument makes me believe"
6349
echo "*** that it is just a static archive that I should not use here."
6352
$ECHO "*** Warning: Linking the shared library $output against the"
6353
$ECHO "*** static library $deplib is not portable!"
6354
deplibs="$deplib $deplibs"
6361
if test "$pass" != link; then
6362
deplibs="$deplib $deplibs"
6364
compile_deplibs="$deplib $compile_deplibs"
6365
finalize_deplibs="$deplib $finalize_deplibs"
6372
if test "$pass" = conv; then
6373
deplibs="$deplib $deplibs"
6374
elif test "$linkmode" = prog; then
6375
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6376
# If there is no dlopen support or we're linking statically,
6377
# we need to preload.
6378
func_append newdlprefiles " $deplib"
6379
compile_deplibs="$deplib $compile_deplibs"
6380
finalize_deplibs="$deplib $finalize_deplibs"
6382
func_append newdlfiles " $deplib"
6393
if test "$found" = yes || test -f "$lib"; then :
6395
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6398
# Check to see that this really is a libtool archive.
6399
func_lalib_unsafe_p "$lib" \
6400
|| func_fatal_error "\`$lib' is not a valid libtool archive"
6402
func_dirname "$lib" "" "."
6403
ladir="$func_dirname_result"
6411
inherited_linker_flags=
6412
# If the library was installed with an old release of libtool,
6413
# it will not redefine variables installed, or shouldnotlink
6422
# Convert "-framework foo" to "foo.ltframework"
6423
if test -n "$inherited_linker_flags"; then
6424
tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6425
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6426
case " $new_inherited_linker_flags " in
6427
*" $tmp_inherited_linker_flag "*) ;;
6428
*) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6432
dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6433
if test "$linkmode,$pass" = "lib,link" ||
6434
test "$linkmode,$pass" = "prog,scan" ||
6435
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
6436
test -n "$dlopen" && func_append dlfiles " $dlopen"
6437
test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6440
if test "$pass" = conv; then
6441
# Only check for convenience libraries
6442
deplibs="$lib $deplibs"
6443
if test -z "$libdir"; then
6444
if test -z "$old_library"; then
6445
func_fatal_error "cannot find name of link library for \`$lib'"
6447
# It is a libtool convenience library, so add in its objects.
6448
func_append convenience " $ladir/$objdir/$old_library"
6449
func_append old_convenience " $ladir/$objdir/$old_library"
6451
for deplib in $dependency_libs; do
6452
deplibs="$deplib $deplibs"
6453
if $opt_preserve_dup_deps ; then
6454
case "$tmp_libs " in
6455
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6458
func_append tmp_libs " $deplib"
6460
elif test "$linkmode" != prog && test "$linkmode" != lib; then
6461
func_fatal_error "\`$lib' is not a convenience library"
6467
# Get the name of the library we link against.
6469
if test -n "$old_library" &&
6470
{ test "$prefer_static_libs" = yes ||
6471
test "$prefer_static_libs,$installed" = "built,no"; }; then
6472
linklib=$old_library
6474
for l in $old_library $library_names; do
6478
if test -z "$linklib"; then
6479
func_fatal_error "cannot find name of link library for \`$lib'"
6482
# This library was specified with -dlopen.
6483
if test "$pass" = dlopen; then
6484
if test -z "$libdir"; then
6485
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6487
if test -z "$dlname" ||
6488
test "$dlopen_support" != yes ||
6489
test "$build_libtool_libs" = no; then
6490
# If there is no dlname, no dlopen support or we're linking
6491
# statically, we need to preload. We also need to preload any
6492
# dependent libraries so libltdl's deplib preloader doesn't
6493
# bomb out in the load deplibs phase.
6494
func_append dlprefiles " $lib $dependency_libs"
6496
func_append newdlfiles " $lib"
6501
# We need an absolute path.
6503
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6505
abs_ladir=`cd "$ladir" && pwd`
6506
if test -z "$abs_ladir"; then
6507
func_warning "cannot determine absolute directory name of \`$ladir'"
6508
func_warning "passing it literally to the linker, although it might fail"
6513
func_basename "$lib"
6514
laname="$func_basename_result"
6516
# Find the relevant object directory and library name.
6517
if test "X$installed" = Xyes; then
6518
if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6519
func_warning "library \`$lib' was moved."
6524
dir="$lt_sysroot$libdir"
6525
absdir="$lt_sysroot$libdir"
6527
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6529
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6532
# Remove this search path later
6533
func_append notinst_path " $abs_ladir"
6535
dir="$ladir/$objdir"
6536
absdir="$abs_ladir/$objdir"
6537
# Remove this search path later
6538
func_append notinst_path " $abs_ladir"
6540
fi # $installed = yes
6541
func_stripname 'lib' '.la' "$laname"
6542
name=$func_stripname_result
6544
# This library was specified with -dlpreopen.
6545
if test "$pass" = dlpreopen; then
6546
if test -z "$libdir" && test "$linkmode" = prog; then
6547
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6550
# special handling for platforms with PE-DLLs.
6551
*cygwin* | *mingw* | *cegcc* )
6552
# Linker will automatically link against shared library if both
6553
# static and shared are present. Therefore, ensure we extract
6554
# symbols from the import library if a shared library is present
6555
# (otherwise, the dlopen module name will be incorrect). We do
6556
# this by putting the import library name into $newdlprefiles.
6557
# We recover the dlopen module name by 'saving' the la file
6558
# name in a special purpose variable, and (later) extracting the
6559
# dlname from the la file.
6560
if test -n "$dlname"; then
6561
func_tr_sh "$dir/$linklib"
6562
eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6563
func_append newdlprefiles " $dir/$linklib"
6565
func_append newdlprefiles " $dir/$old_library"
6566
# Keep a list of preopened convenience libraries to check
6567
# that they are being used correctly in the link pass.
6568
test -z "$libdir" && \
6569
func_append dlpreconveniencelibs " $dir/$old_library"
6573
# Prefer using a static library (so that no silly _DYNAMIC symbols
6574
# are required to link).
6575
if test -n "$old_library"; then
6576
func_append newdlprefiles " $dir/$old_library"
6577
# Keep a list of preopened convenience libraries to check
6578
# that they are being used correctly in the link pass.
6579
test -z "$libdir" && \
6580
func_append dlpreconveniencelibs " $dir/$old_library"
6581
# Otherwise, use the dlname, so that lt_dlopen finds it.
6582
elif test -n "$dlname"; then
6583
func_append newdlprefiles " $dir/$dlname"
6585
func_append newdlprefiles " $dir/$linklib"
6589
fi # $pass = dlpreopen
6591
if test -z "$libdir"; then
6592
# Link the convenience library
6593
if test "$linkmode" = lib; then
6594
deplibs="$dir/$old_library $deplibs"
6595
elif test "$linkmode,$pass" = "prog,link"; then
6596
compile_deplibs="$dir/$old_library $compile_deplibs"
6597
finalize_deplibs="$dir/$old_library $finalize_deplibs"
6599
deplibs="$lib $deplibs" # used for prog,scan pass
6605
if test "$linkmode" = prog && test "$pass" != link; then
6606
func_append newlib_search_path " $ladir"
6607
deplibs="$lib $deplibs"
6610
if test "$link_all_deplibs" != no || test -z "$library_names" ||
6611
test "$build_libtool_libs" = no; then
6616
for deplib in $dependency_libs; do
6618
-L*) func_stripname '-L' '' "$deplib"
6619
func_resolve_sysroot "$func_stripname_result"
6620
func_append newlib_search_path " $func_resolve_sysroot_result"
6623
# Need to link against all dependency_libs?
6624
if test "$linkalldeplibs" = yes; then
6625
deplibs="$deplib $deplibs"
6627
# Need to hardcode shared library paths
6628
# or/and link against static libraries
6629
newdependency_libs="$deplib $newdependency_libs"
6631
if $opt_preserve_dup_deps ; then
6632
case "$tmp_libs " in
6633
*" $deplib "*) func_append specialdeplibs " $deplib" ;;
6636
func_append tmp_libs " $deplib"
6639
fi # $linkmode = prog...
6641
if test "$linkmode,$pass" = "prog,link"; then
6642
if test -n "$library_names" &&
6643
{ { test "$prefer_static_libs" = no ||
6644
test "$prefer_static_libs,$installed" = "built,yes"; } ||
6645
test -z "$old_library"; }; then
6646
# We need to hardcode the library path
6647
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6648
# Make sure the rpath contains only unique directories.
6649
case "$temp_rpath:" in
6651
*) func_append temp_rpath "$absdir:" ;;
6655
# Hardcode the library path.
6656
# Skip directories that are in the system default run-time
6658
case " $sys_lib_dlsearch_path " in
6661
case "$compile_rpath " in
6663
*) func_append compile_rpath " $absdir" ;;
6667
case " $sys_lib_dlsearch_path " in
6670
case "$finalize_rpath " in
6672
*) func_append finalize_rpath " $libdir" ;;
6676
fi # $linkmode,$pass = prog,link...
6678
if test "$alldeplibs" = yes &&
6679
{ test "$deplibs_check_method" = pass_all ||
6680
{ test "$build_libtool_libs" = yes &&
6681
test -n "$library_names"; }; }; then
6682
# We only need to search for static libraries
6687
link_static=no # Whether the deplib will be linked statically
6688
use_static_libs=$prefer_static_libs
6689
if test "$use_static_libs" = built && test "$installed" = yes; then
6692
if test -n "$library_names" &&
6693
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
6695
*cygwin* | *mingw* | *cegcc*)
6696
# No point in relinking DLLs because paths are not encoded
6697
func_append notinst_deplibs " $lib"
6701
if test "$installed" = no; then
6702
func_append notinst_deplibs " $lib"
6707
# This is a shared library
6709
# Warn about portability, can't link against -module's on some
6710
# systems (darwin). Don't bleat about dlopened modules though!
6712
for dlpremoduletest in $dlprefiles; do
6713
if test "X$dlpremoduletest" = "X$lib"; then
6714
dlopenmodule="$dlpremoduletest"
6718
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6720
if test "$linkmode" = prog; then
6721
$ECHO "*** Warning: Linking the executable $output against the loadable module"
6723
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
6725
$ECHO "*** $linklib is not portable!"
6727
if test "$linkmode" = lib &&
6728
test "$hardcode_into_libs" = yes; then
6729
# Hardcode the library path.
6730
# Skip directories that are in the system default run-time
6732
case " $sys_lib_dlsearch_path " in
6735
case "$compile_rpath " in
6737
*) func_append compile_rpath " $absdir" ;;
6741
case " $sys_lib_dlsearch_path " in
6744
case "$finalize_rpath " in
6746
*) func_append finalize_rpath " $libdir" ;;
6752
if test -n "$old_archive_from_expsyms_cmds"; then
6753
# figure out the soname
6754
set dummy $library_names
6758
libname=`eval "\\$ECHO \"$libname_spec\""`
6759
# use dlname if we got it. it's perfectly good, no?
6760
if test -n "$dlname"; then
6762
elif test -n "$soname_spec"; then
6765
*cygwin* | mingw* | *cegcc*)
6766
func_arith $current - $age
6767
major=$func_arith_result
6771
eval soname=\"$soname_spec\"
6776
# Make a new name for the extract_expsyms_cmds to use
6778
func_basename "$soroot"
6779
soname="$func_basename_result"
6780
func_stripname 'lib' '.dll' "$soname"
6781
newlib=libimp-$func_stripname_result.a
6783
# If the library has no export list, then create one now
6784
if test -f "$output_objdir/$soname-def"; then :
6786
func_verbose "extracting exported symbol list from \`$soname'"
6787
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6791
if test -f "$output_objdir/$newlib"; then :; else
6792
func_verbose "generating import library for \`$soname'"
6793
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6795
# make sure the library variables are pointing to the new library
6798
fi # test -n "$old_archive_from_expsyms_cmds"
6800
if test "$linkmode" = prog || test "$opt_mode" != relink; then
6805
case $hardcode_action in
6806
immediate | unsupported)
6807
if test "$hardcode_direct" = no; then
6810
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6811
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
6812
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6813
*-*-unixware7*) add_dir="-L$dir" ;;
6815
# if the lib is a (non-dlopened) module then we can not
6816
# link against it, someone is ignoring the earlier warnings
6817
if /usr/bin/file -L $add 2> /dev/null |
6818
$GREP ": [^:]* bundle" >/dev/null ; then
6819
if test "X$dlopenmodule" != "X$lib"; then
6820
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6821
if test -z "$old_library" ; then
6823
echo "*** And there doesn't seem to be a static archive available"
6824
echo "*** The link will probably fail, sorry"
6826
add="$dir/$old_library"
6828
elif test -n "$old_library"; then
6829
add="$dir/$old_library"
6833
elif test "$hardcode_minus_L" = no; then
6835
*-*-sunos*) add_shlibpath="$dir" ;;
6839
elif test "$hardcode_shlibpath_var" = no; then
6840
add_shlibpath="$dir"
6847
if test "$hardcode_direct" = yes &&
6848
test "$hardcode_direct_absolute" = no; then
6850
elif test "$hardcode_minus_L" = yes; then
6852
# Try looking first in the location we're being installed to.
6853
if test -n "$inst_prefix_dir"; then
6856
func_append add_dir " -L$inst_prefix_dir$libdir"
6861
elif test "$hardcode_shlibpath_var" = yes; then
6862
add_shlibpath="$dir"
6871
if test "$lib_linked" != yes; then
6872
func_fatal_configuration "unsupported hardcode properties"
6875
if test -n "$add_shlibpath"; then
6876
case :$compile_shlibpath: in
6877
*":$add_shlibpath:"*) ;;
6878
*) func_append compile_shlibpath "$add_shlibpath:" ;;
6881
if test "$linkmode" = prog; then
6882
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6883
test -n "$add" && compile_deplibs="$add $compile_deplibs"
6885
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6886
test -n "$add" && deplibs="$add $deplibs"
6887
if test "$hardcode_direct" != yes &&
6888
test "$hardcode_minus_L" != yes &&
6889
test "$hardcode_shlibpath_var" = yes; then
6890
case :$finalize_shlibpath: in
6892
*) func_append finalize_shlibpath "$libdir:" ;;
6898
if test "$linkmode" = prog || test "$opt_mode" = relink; then
6902
# Finalize command for both is simple: just hardcode it.
6903
if test "$hardcode_direct" = yes &&
6904
test "$hardcode_direct_absolute" = no; then
6905
add="$libdir/$linklib"
6906
elif test "$hardcode_minus_L" = yes; then
6909
elif test "$hardcode_shlibpath_var" = yes; then
6910
case :$finalize_shlibpath: in
6912
*) func_append finalize_shlibpath "$libdir:" ;;
6915
elif test "$hardcode_automatic" = yes; then
6916
if test -n "$inst_prefix_dir" &&
6917
test -f "$inst_prefix_dir$libdir/$linklib" ; then
6918
add="$inst_prefix_dir$libdir/$linklib"
6920
add="$libdir/$linklib"
6923
# We cannot seem to hardcode it, guess we'll fake it.
6925
# Try looking first in the location we're being installed to.
6926
if test -n "$inst_prefix_dir"; then
6929
func_append add_dir " -L$inst_prefix_dir$libdir"
6936
if test "$linkmode" = prog; then
6937
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6938
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6940
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6941
test -n "$add" && deplibs="$add $deplibs"
6944
elif test "$linkmode" = prog; then
6945
# Here we assume that one of hardcode_direct or hardcode_minus_L
6946
# is not unsupported. This is valid on all known static and
6948
if test "$hardcode_direct" != unsupported; then
6949
test -n "$old_library" && linklib="$old_library"
6950
compile_deplibs="$dir/$linklib $compile_deplibs"
6951
finalize_deplibs="$dir/$linklib $finalize_deplibs"
6953
compile_deplibs="-l$name -L$dir $compile_deplibs"
6954
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6956
elif test "$build_libtool_libs" = yes; then
6957
# Not a shared library
6958
if test "$deplibs_check_method" != pass_all; then
6959
# We're trying link a shared library against a static one
6960
# but the system doesn't support it.
6962
# Just print a warning and add the library to dependency_libs so
6963
# that the program can be linked against the static library.
6965
$ECHO "*** Warning: This system can not link to static lib archive $lib."
6966
echo "*** I have the capability to make that library automatically link in when"
6967
echo "*** you link to this library. But I can only do this if you have a"
6968
echo "*** shared version of the library, which you do not appear to have."
6969
if test "$module" = yes; then
6970
echo "*** But as you try to build a module library, libtool will still create "
6971
echo "*** a static module, that should work as long as the dlopening application"
6972
echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6973
if test -z "$global_symbol_pipe"; then
6975
echo "*** However, this would only work if libtool was able to extract symbol"
6976
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6977
echo "*** not find such a program. So, this module is probably useless."
6978
echo "*** \`nm' from GNU binutils and a full rebuild may help."
6980
if test "$build_old_libs" = no; then
6981
build_libtool_libs=module
6984
build_libtool_libs=no
6988
deplibs="$dir/$old_library $deplibs"
6991
fi # link shared/static library?
6993
if test "$linkmode" = lib; then
6994
if test -n "$dependency_libs" &&
6995
{ test "$hardcode_into_libs" != yes ||
6996
test "$build_old_libs" = yes ||
6997
test "$link_static" = yes; }; then
6998
# Extract -R from dependency_libs
7000
for libdir in $dependency_libs; do
7002
-R*) func_stripname '-R' '' "$libdir"
7003
temp_xrpath=$func_stripname_result
7005
*" $temp_xrpath "*) ;;
7006
*) func_append xrpath " $temp_xrpath";;
7008
*) func_append temp_deplibs " $libdir";;
7011
dependency_libs="$temp_deplibs"
7014
func_append newlib_search_path " $absdir"
7015
# Link against this library
7016
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7017
# ... and its dependency_libs
7019
for deplib in $dependency_libs; do
7020
newdependency_libs="$deplib $newdependency_libs"
7022
-L*) func_stripname '-L' '' "$deplib"
7023
func_resolve_sysroot "$func_stripname_result";;
7024
*) func_resolve_sysroot "$deplib" ;;
7026
if $opt_preserve_dup_deps ; then
7027
case "$tmp_libs " in
7028
*" $func_resolve_sysroot_result "*)
7029
func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7032
func_append tmp_libs " $func_resolve_sysroot_result"
7035
if test "$link_all_deplibs" != no; then
7036
# Add the search paths of all dependency libraries
7037
for deplib in $dependency_libs; do
7040
-L*) path="$deplib" ;;
7042
func_resolve_sysroot "$deplib"
7043
deplib=$func_resolve_sysroot_result
7044
func_dirname "$deplib" "" "."
7045
dir=$func_dirname_result
7046
# We need an absolute path.
7048
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7050
absdir=`cd "$dir" && pwd`
7051
if test -z "$absdir"; then
7052
func_warning "cannot determine absolute directory name of \`$dir'"
7057
if $GREP "^installed=no" $deplib > /dev/null; then
7061
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7062
if test -n "$deplibrary_names" ; then
7063
for tmp in $deplibrary_names ; do
7066
if test -f "$absdir/$objdir/$depdepl" ; then
7067
depdepl="$absdir/$objdir/$depdepl"
7068
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7069
if test -z "$darwin_install_name"; then
7070
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7072
func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7073
func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7079
path="-L$absdir/$objdir"
7083
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7084
test -z "$libdir" && \
7085
func_fatal_error "\`$deplib' is not a valid libtool archive"
7086
test "$absdir" != "$libdir" && \
7087
func_warning "\`$deplib' seems to be moved"
7093
case " $deplibs " in
7095
*) deplibs="$path $deplibs" ;;
7098
fi # link_all_deplibs != no
7100
done # for deplib in $libs
7101
if test "$pass" = link; then
7102
if test "$linkmode" = "prog"; then
7103
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7104
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7106
compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7109
dependency_libs="$newdependency_libs"
7110
if test "$pass" = dlpreopen; then
7111
# Link the dlpreopened libraries before other libraries
7112
for deplib in $save_deplibs; do
7113
deplibs="$deplib $deplibs"
7116
if test "$pass" != dlopen; then
7117
if test "$pass" != conv; then
7118
# Make sure lib_search_path contains only unique directories.
7120
for dir in $newlib_search_path; do
7121
case "$lib_search_path " in
7123
*) func_append lib_search_path " $dir" ;;
7129
if test "$linkmode,$pass" != "prog,link"; then
7132
vars="compile_deplibs finalize_deplibs"
7134
for var in $vars dependency_libs; do
7135
# Add libraries to $var in reverse order
7136
eval tmp_libs=\"\$$var\"
7138
for deplib in $tmp_libs; do
7139
# FIXME: Pedantically, this is the right thing to do, so
7140
# that some nasty dependency loop isn't accidentally
7142
#new_libs="$deplib $new_libs"
7143
# Pragmatically, this seems to cause very few problems in
7146
-L*) new_libs="$deplib $new_libs" ;;
7149
# And here is the reason: when a library appears more
7150
# than once as an explicit dependence of a library, or
7151
# is implicitly linked in more than once by the
7152
# compiler, it is considered special, and multiple
7153
# occurrences thereof are not removed. Compare this
7154
# with having the same library being listed as a
7155
# dependency of multiple other libraries: in this case,
7156
# we know (pedantically, we assume) the library does not
7157
# need to be listed more than once, so we keep only the
7158
# last copy. This is not always right, but it is rare
7159
# enough that we require users that really mean to play
7160
# such unportable linking tricks to link the library
7161
# using -Wl,-lname, so that libtool does not consider it
7162
# for duplicate removal.
7163
case " $specialdeplibs " in
7164
*" $deplib "*) new_libs="$deplib $new_libs" ;;
7166
case " $new_libs " in
7168
*) new_libs="$deplib $new_libs" ;;
7176
for deplib in $new_libs; do
7179
case " $tmp_libs " in
7181
*) func_append tmp_libs " $deplib" ;;
7184
*) func_append tmp_libs " $deplib" ;;
7187
eval $var=\"$tmp_libs\"
7190
# Last step: remove runtime libs from dependency_libs
7191
# (they stay in deplibs)
7193
for i in $dependency_libs ; do
7194
case " $predeps $postdeps $compiler_lib_search_path " in
7199
if test -n "$i" ; then
7200
func_append tmp_libs " $i"
7203
dependency_libs=$tmp_libs
7205
if test "$linkmode" = prog; then
7206
dlfiles="$newdlfiles"
7208
if test "$linkmode" = prog || test "$linkmode" = lib; then
7209
dlprefiles="$newdlprefiles"
7214
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7215
func_warning "\`-dlopen' is ignored for archives"
7220
func_warning "\`-l' and \`-L' are ignored for archives" ;;
7223
test -n "$rpath" && \
7224
func_warning "\`-rpath' is ignored for archives"
7226
test -n "$xrpath" && \
7227
func_warning "\`-R' is ignored for archives"
7229
test -n "$vinfo" && \
7230
func_warning "\`-version-info/-version-number' is ignored for archives"
7232
test -n "$release" && \
7233
func_warning "\`-release' is ignored for archives"
7235
test -n "$export_symbols$export_symbols_regex" && \
7236
func_warning "\`-export-symbols' is ignored for archives"
7238
# Now set the variables for building old libraries.
7239
build_libtool_libs=no
7241
func_append objs "$old_deplibs"
7245
# Make sure we only generate libraries of the form `libNAME.la'.
7248
func_stripname 'lib' '.la' "$outputname"
7249
name=$func_stripname_result
7250
eval shared_ext=\"$shrext_cmds\"
7251
eval libname=\"$libname_spec\"
7254
test "$module" = no && \
7255
func_fatal_help "libtool library \`$output' must begin with \`lib'"
7257
if test "$need_lib_prefix" != no; then
7258
# Add the "lib" prefix for modules if required
7259
func_stripname '' '.la' "$outputname"
7260
name=$func_stripname_result
7261
eval shared_ext=\"$shrext_cmds\"
7262
eval libname=\"$libname_spec\"
7264
func_stripname '' '.la' "$outputname"
7265
libname=$func_stripname_result
7270
if test -n "$objs"; then
7271
if test "$deplibs_check_method" != pass_all; then
7272
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7275
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7276
$ECHO "*** objects $objs is not portable!"
7277
func_append libobjs " $objs"
7281
test "$dlself" != no && \
7282
func_warning "\`-dlopen self' is ignored for libtool libraries"
7286
test "$#" -gt 1 && \
7287
func_warning "ignoring multiple \`-rpath's for a libtool library"
7292
if test -z "$rpath"; then
7293
if test "$build_libtool_libs" = yes; then
7294
# Building a libtool convenience library.
7295
# Some compilers have problems with a `.al' extension so
7296
# convenience libraries should have the same extension an
7297
# archive normally would.
7298
oldlibs="$output_objdir/$libname.$libext $oldlibs"
7299
build_libtool_libs=convenience
7303
test -n "$vinfo" && \
7304
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7306
test -n "$release" && \
7307
func_warning "\`-release' is ignored for convenience libraries"
7310
# Parse the version information argument.
7311
save_ifs="$IFS"; IFS=':'
7312
set dummy $vinfo 0 0 0
7317
func_fatal_help "too many parameters to \`-version-info'"
7319
# convert absolute version numbers to libtool ages
7320
# this retains compatibility with .la files and attempts
7321
# to make the code below a bit more comprehensible
7323
case $vinfo_number in
7327
number_revision="$3"
7329
# There are really only two kinds -- those that
7330
# use the current revision as the major version
7331
# and those that subtract age and use age as
7332
# a minor version. But, then there is irix
7333
# which has an extra 1 added just for fun
7335
case $version_type in
7336
# correct linux to gnu/linux during the next big refactor
7337
darwin|linux|osf|windows|none)
7338
func_arith $number_major + $number_minor
7339
current=$func_arith_result
7341
revision="$number_revision"
7343
freebsd-aout|freebsd-elf|qnx|sunos)
7344
current="$number_major"
7345
revision="$number_minor"
7349
func_arith $number_major + $number_minor
7350
current=$func_arith_result
7352
revision="$number_minor"
7353
lt_irix_increment=no
7356
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
7367
# Check that each of the things are valid numbers.
7369
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]) ;;
7371
func_error "CURRENT \`$current' must be a nonnegative integer"
7372
func_fatal_error "\`$vinfo' is not valid version information"
7377
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]) ;;
7379
func_error "REVISION \`$revision' must be a nonnegative integer"
7380
func_fatal_error "\`$vinfo' is not valid version information"
7385
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]) ;;
7387
func_error "AGE \`$age' must be a nonnegative integer"
7388
func_fatal_error "\`$vinfo' is not valid version information"
7392
if test "$age" -gt "$current"; then
7393
func_error "AGE \`$age' is greater than the current interface number \`$current'"
7394
func_fatal_error "\`$vinfo' is not valid version information"
7397
# Calculate the version variables.
7401
case $version_type in
7405
# Like Linux, but with the current version available in
7406
# verstring for coding it into the library header
7407
func_arith $current - $age
7408
major=.$func_arith_result
7409
versuffix="$major.$age.$revision"
7410
# Darwin ld doesn't like 0 for these options...
7411
func_arith $current + 1
7412
minor_current=$func_arith_result
7413
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7414
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7419
versuffix=".$current.$revision";
7424
versuffix=".$current"
7428
if test "X$lt_irix_increment" = "Xno"; then
7429
func_arith $current - $age
7431
func_arith $current - $age + 1
7433
major=$func_arith_result
7435
case $version_type in
7436
nonstopux) verstring_prefix=nonstopux ;;
7437
*) verstring_prefix=sgi ;;
7439
verstring="$verstring_prefix$major.$revision"
7441
# Add in all the interfaces that we are compatible with.
7443
while test "$loop" -ne 0; do
7444
func_arith $revision - $loop
7445
iface=$func_arith_result
7446
func_arith $loop - 1
7447
loop=$func_arith_result
7448
verstring="$verstring_prefix$major.$iface:$verstring"
7451
# Before this point, $major must not contain `.'.
7453
versuffix="$major.$revision"
7456
linux) # correct to gnu/linux during the next big refactor
7457
func_arith $current - $age
7458
major=.$func_arith_result
7459
versuffix="$major.$age.$revision"
7463
func_arith $current - $age
7464
major=.$func_arith_result
7465
versuffix=".$current.$age.$revision"
7466
verstring="$current.$age.$revision"
7468
# Add in all the interfaces that we are compatible with.
7470
while test "$loop" -ne 0; do
7471
func_arith $current - $loop
7472
iface=$func_arith_result
7473
func_arith $loop - 1
7474
loop=$func_arith_result
7475
verstring="$verstring:${iface}.0"
7478
# Make executables depend on our current version.
7479
func_append verstring ":${current}.0"
7484
versuffix=".$current"
7489
versuffix=".$current.$revision"
7493
# Use '-' rather than '.', since we only want one
7494
# extension on DOS 8.3 filesystems.
7495
func_arith $current - $age
7496
major=$func_arith_result
7501
func_fatal_configuration "unknown library version type \`$version_type'"
7505
# Clear the version info if we defaulted, and they specified a release.
7506
if test -z "$vinfo" && test -n "$release"; then
7508
case $version_type in
7510
# we can't check for "0.0" in archive_cmds due to quoting
7511
# problems, so we reset it completely
7518
if test "$need_version" = no; then
7525
# Remove version info from name if versioning should be avoided
7526
if test "$avoid_version" = yes && test "$need_version" = no; then
7532
# Check to see if the archive will have undefined symbols.
7533
if test "$allow_undefined" = yes; then
7534
if test "$allow_undefined_flag" = unsupported; then
7535
func_warning "undefined symbols not allowed in $host shared libraries"
7536
build_libtool_libs=no
7540
# Don't allow undefined symbols.
7541
allow_undefined_flag="$no_undefined_flag"
7546
func_generate_dlsyms "$libname" "$libname" "yes"
7547
func_append libobjs " $symfileobj"
7548
test "X$libobjs" = "X " && libobjs=
7550
if test "$opt_mode" != relink; then
7551
# Remove our outputs, but don't remove object files since they
7552
# may have been created when compiling PIC objects.
7554
tempremovelist=`$ECHO "$output_objdir/*"`
7555
for p in $tempremovelist; do
7559
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7560
if test "X$precious_files_regex" != "X"; then
7561
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7566
func_append removelist " $p"
7571
test -n "$removelist" && \
7572
func_show_eval "${RM}r \$removelist"
7575
# Now set the variables for building old libraries.
7576
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7577
func_append oldlibs " $output_objdir/$libname.$libext"
7579
# Transform .lo files to .o files.
7580
oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7583
# Eliminate all temporary directories.
7584
#for path in $notinst_path; do
7585
# lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7586
# deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7587
# dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7590
if test -n "$xrpath"; then
7591
# If the user specified any rpath flags, then add them.
7593
for libdir in $xrpath; do
7594
func_replace_sysroot "$libdir"
7595
func_append temp_xrpath " -R$func_replace_sysroot_result"
7596
case "$finalize_rpath " in
7598
*) func_append finalize_rpath " $libdir" ;;
7601
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7602
dependency_libs="$temp_xrpath $dependency_libs"
7606
# Make sure dlfiles contains only unique files that won't be dlpreopened
7607
old_dlfiles="$dlfiles"
7609
for lib in $old_dlfiles; do
7610
case " $dlprefiles $dlfiles " in
7612
*) func_append dlfiles " $lib" ;;
7616
# Make sure dlprefiles contains only unique files
7617
old_dlprefiles="$dlprefiles"
7619
for lib in $old_dlprefiles; do
7620
case "$dlprefiles " in
7622
*) func_append dlprefiles " $lib" ;;
7626
if test "$build_libtool_libs" = yes; then
7627
if test -n "$rpath"; then
7629
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7630
# these systems don't actually have a c library (as such)!
7632
*-*-rhapsody* | *-*-darwin1.[012])
7633
# Rhapsody C library is in the System framework
7634
func_append deplibs " System.ltframework"
7637
# Don't link with libc until the a.out ld.so is fixed.
7639
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7640
# Do not include libc due to us having libc/libc_r.
7642
*-*-sco3.2v5* | *-*-sco5v6*)
7643
# Causes problems with __ctype
7645
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7646
# Compiler inserts libc in the correct place for threads to work
7649
# Add libc to deplibs on all other systems if necessary.
7650
if test "$build_libtool_need_lc" = "yes"; then
7651
func_append deplibs " -lc"
7657
# Transform deplibs into only deplibs that can be linked in shared.
7659
libname_save=$libname
7660
release_save=$release
7661
versuffix_save=$versuffix
7663
# I'm not sure if I'm treating the release correctly. I think
7664
# release should show up in the -l (ie -lgmp5) so we don't want to
7665
# add it in twice. Is that correct?
7671
case $deplibs_check_method in
7673
# Don't check for shared/static. Everything works.
7674
# This might be a little naive. We might want to check
7675
# whether the library exists or not. But this is on
7676
# osf3 & osf4 and I'm not really sure... Just
7677
# implementing what was already the behavior.
7681
# This code stresses the "libraries are programs" paradigm to its
7682
# limits. Maybe even breaks it. We compile a program, linking it
7683
# against the deplibs as a proxy for the library. Then we can check
7684
# whether they linked in statically or dynamically with ldd.
7685
$opt_dry_run || $RM conftest.c
7686
cat > conftest.c <<EOF
7687
int main() { return 0; }
7689
$opt_dry_run || $RM conftest
7690
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7691
ldd_output=`ldd conftest`
7692
for i in $deplibs; do
7695
func_stripname -l '' "$i"
7696
name=$func_stripname_result
7697
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7698
case " $predeps $postdeps " in
7700
func_append newdeplibs " $i"
7705
if test -n "$i" ; then
7706
libname=`eval "\\$ECHO \"$libname_spec\""`
7707
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7708
set dummy $deplib_matches; shift
7710
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7711
func_append newdeplibs " $i"
7715
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7716
echo "*** I have the capability to make that library automatically link in when"
7717
echo "*** you link to this library. But I can only do this if you have a"
7718
echo "*** shared version of the library, which I believe you do not have"
7719
echo "*** because a test_compile did reveal that the linker did not use it for"
7720
echo "*** its dynamic dependency list that programs get resolved with at runtime."
7725
func_append newdeplibs " $i"
7730
# Error occurred in the first compile. Let's try to salvage
7731
# the situation: Compile a separate program for each library.
7732
for i in $deplibs; do
7735
func_stripname -l '' "$i"
7736
name=$func_stripname_result
7737
$opt_dry_run || $RM conftest
7738
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7739
ldd_output=`ldd conftest`
7740
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7741
case " $predeps $postdeps " in
7743
func_append newdeplibs " $i"
7748
if test -n "$i" ; then
7749
libname=`eval "\\$ECHO \"$libname_spec\""`
7750
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7751
set dummy $deplib_matches; shift
7753
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7754
func_append newdeplibs " $i"
7758
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7759
echo "*** I have the capability to make that library automatically link in when"
7760
echo "*** you link to this library. But I can only do this if you have a"
7761
echo "*** shared version of the library, which you do not appear to have"
7762
echo "*** because a test_compile did reveal that the linker did not use this one"
7763
echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7769
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7770
echo "*** make it link in! You will probably need to install it or some"
7771
echo "*** library that it depends on before this library will be fully"
7772
echo "*** functional. Installing it before continuing would be even better."
7776
func_append newdeplibs " $i"
7783
set dummy $deplibs_check_method; shift
7784
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7785
for a_deplib in $deplibs; do
7788
func_stripname -l '' "$a_deplib"
7789
name=$func_stripname_result
7790
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7791
case " $predeps $postdeps " in
7793
func_append newdeplibs " $a_deplib"
7798
if test -n "$a_deplib" ; then
7799
libname=`eval "\\$ECHO \"$libname_spec\""`
7800
if test -n "$file_magic_glob"; then
7801
libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7803
libnameglob=$libname
7805
test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7806
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7807
if test "$want_nocaseglob" = yes; then
7809
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7812
potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7814
for potent_lib in $potential_libs; do
7815
# Follow soft links.
7816
if ls -lLd "$potent_lib" 2>/dev/null |
7817
$GREP " -> " >/dev/null; then
7820
# The statement above tries to avoid entering an
7821
# endless loop below, in case of cyclic links.
7822
# We might still enter an endless loop, since a link
7823
# loop can be closed while we follow links,
7825
potlib="$potent_lib"
7826
while test -h "$potlib" 2>/dev/null; do
7827
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7829
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7830
*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7833
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7835
$EGREP "$file_magic_regex" > /dev/null; then
7836
func_append newdeplibs " $a_deplib"
7843
if test -n "$a_deplib" ; then
7846
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7847
echo "*** I have the capability to make that library automatically link in when"
7848
echo "*** you link to this library. But I can only do this if you have a"
7849
echo "*** shared version of the library, which you do not appear to have"
7850
echo "*** because I did check the linker path looking for a file starting"
7851
if test -z "$potlib" ; then
7852
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7854
$ECHO "*** with $libname and none of the candidates passed a file format test"
7855
$ECHO "*** using a file magic. Last file checked: $potlib"
7860
# Add a -L argument.
7861
func_append newdeplibs " $a_deplib"
7864
done # Gone through all deplibs.
7867
set dummy $deplibs_check_method; shift
7868
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7869
for a_deplib in $deplibs; do
7872
func_stripname -l '' "$a_deplib"
7873
name=$func_stripname_result
7874
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7875
case " $predeps $postdeps " in
7877
func_append newdeplibs " $a_deplib"
7882
if test -n "$a_deplib" ; then
7883
libname=`eval "\\$ECHO \"$libname_spec\""`
7884
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7885
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7886
for potent_lib in $potential_libs; do
7887
potlib="$potent_lib" # see symlink-check above in file_magic test
7888
if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7889
$EGREP "$match_pattern_regex" > /dev/null; then
7890
func_append newdeplibs " $a_deplib"
7897
if test -n "$a_deplib" ; then
7900
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7901
echo "*** I have the capability to make that library automatically link in when"
7902
echo "*** you link to this library. But I can only do this if you have a"
7903
echo "*** shared version of the library, which you do not appear to have"
7904
echo "*** because I did check the linker path looking for a file starting"
7905
if test -z "$potlib" ; then
7906
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7908
$ECHO "*** with $libname and none of the candidates passed a file format test"
7909
$ECHO "*** using a regex pattern. Last file checked: $potlib"
7914
# Add a -L argument.
7915
func_append newdeplibs " $a_deplib"
7918
done # Gone through all deplibs.
7922
tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7923
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7924
for i in $predeps $postdeps ; do
7925
# can't use Xsed below, because $i might contain '/'
7926
tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7929
case $tmp_deplibs in
7932
if test "X$deplibs_check_method" = "Xnone"; then
7933
echo "*** Warning: inter-library dependencies are not supported in this platform."
7935
echo "*** Warning: inter-library dependencies are not known to be supported."
7937
echo "*** All declared inter-library dependencies are being dropped."
7943
versuffix=$versuffix_save
7945
release=$release_save
7946
libname=$libname_save
7950
*-*-rhapsody* | *-*-darwin1.[012])
7951
# On Rhapsody replace the C library with the System framework
7952
newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7956
if test "$droppeddeps" = yes; then
7957
if test "$module" = yes; then
7959
echo "*** Warning: libtool could not satisfy all declared inter-library"
7960
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7961
echo "*** a static module, that should work as long as the dlopening"
7962
echo "*** application is linked with the -dlopen flag."
7963
if test -z "$global_symbol_pipe"; then
7965
echo "*** However, this would only work if libtool was able to extract symbol"
7966
echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7967
echo "*** not find such a program. So, this module is probably useless."
7968
echo "*** \`nm' from GNU binutils and a full rebuild may help."
7970
if test "$build_old_libs" = no; then
7971
oldlibs="$output_objdir/$libname.$libext"
7972
build_libtool_libs=module
7975
build_libtool_libs=no
7978
echo "*** The inter-library dependencies that have been dropped here will be"
7979
echo "*** automatically added whenever a program is linked with this library"
7980
echo "*** or is declared to -dlopen it."
7982
if test "$allow_undefined" = no; then
7984
echo "*** Since this library must not contain undefined symbols,"
7985
echo "*** because either the platform does not support them or"
7986
echo "*** it was explicitly requested with -no-undefined,"
7987
echo "*** libtool will only create a static version of it."
7988
if test "$build_old_libs" = no; then
7989
oldlibs="$output_objdir/$libname.$libext"
7990
build_libtool_libs=module
7993
build_libtool_libs=no
7998
# Done checking deplibs!
8001
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8004
newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8005
new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8006
deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8010
# move library search paths that coincide with paths to not yet
8011
# installed libraries to the beginning of the library search list
8013
for path in $notinst_path; do
8014
case " $new_libs " in
8015
*" -L$path/$objdir "*) ;;
8017
case " $deplibs " in
8018
*" -L$path/$objdir "*)
8019
func_append new_libs " -L$path/$objdir" ;;
8024
for deplib in $deplibs; do
8027
case " $new_libs " in
8029
*) func_append new_libs " $deplib" ;;
8032
*) func_append new_libs " $deplib" ;;
8037
# All the library-specific variables (install_libdir is set above).
8042
# Test again, we may have decided not to build it any more
8043
if test "$build_libtool_libs" = yes; then
8044
# Remove ${wl} instances when linking with ld.
8045
# FIXME: should test the right _cmds variable.
8046
case $archive_cmds in
8049
if test "$hardcode_into_libs" = yes; then
8050
# Hardcode the library paths
8053
rpath="$finalize_rpath"
8054
test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8055
for libdir in $rpath; do
8056
if test -n "$hardcode_libdir_flag_spec"; then
8057
if test -n "$hardcode_libdir_separator"; then
8058
func_replace_sysroot "$libdir"
8059
libdir=$func_replace_sysroot_result
8060
if test -z "$hardcode_libdirs"; then
8061
hardcode_libdirs="$libdir"
8063
# Just accumulate the unique libdirs.
8064
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8065
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8068
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8073
eval flag=\"$hardcode_libdir_flag_spec\"
8074
func_append dep_rpath " $flag"
8076
elif test -n "$runpath_var"; then
8077
case "$perm_rpath " in
8079
*) func_append perm_rpath " $libdir" ;;
8083
# Substitute the hardcoded libdirs into the rpath.
8084
if test -n "$hardcode_libdir_separator" &&
8085
test -n "$hardcode_libdirs"; then
8086
libdir="$hardcode_libdirs"
8087
eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8089
if test -n "$runpath_var" && test -n "$perm_rpath"; then
8090
# We should set the runpath_var.
8092
for dir in $perm_rpath; do
8093
func_append rpath "$dir:"
8095
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8097
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8100
shlibpath="$finalize_shlibpath"
8101
test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8102
if test -n "$shlibpath"; then
8103
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8106
# Get the real and link names of the library.
8107
eval shared_ext=\"$shrext_cmds\"
8108
eval library_names=\"$library_names_spec\"
8109
set dummy $library_names
8114
if test -n "$soname_spec"; then
8115
eval soname=\"$soname_spec\"
8119
if test -z "$dlname"; then
8123
lib="$output_objdir/$realname"
8127
func_append linknames " $link"
8130
# Use standard objects if they are pic
8131
test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8132
test "X$libobjs" = "X " && libobjs=
8135
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8136
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8137
export_symbols="$output_objdir/$libname.uexp"
8138
func_append delfiles " $export_symbols"
8141
orig_export_symbols=
8143
cygwin* | mingw* | cegcc*)
8144
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8145
# exporting using user supplied symfile
8146
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8147
# and it's NOT already a .def file. Must figure out
8148
# which of the given symbols are data symbols and tag
8149
# them as such. So, trigger use of export_symbols_cmds.
8150
# export_symbols gets reassigned inside the "prepare
8151
# the list of exported symbols" if statement, so the
8152
# include_expsyms logic still works.
8153
orig_export_symbols="$export_symbols"
8155
always_export_symbols=yes
8161
# Prepare the list of exported symbols
8162
if test -z "$export_symbols"; then
8163
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8164
func_verbose "generating symbol list for \`$libname.la'"
8165
export_symbols="$output_objdir/$libname.exp"
8166
$opt_dry_run || $RM $export_symbols
8167
cmds=$export_symbols_cmds
8168
save_ifs="$IFS"; IFS='~'
8169
for cmd1 in $cmds; do
8171
# Take the normal branch if the nm_file_list_spec branch
8172
# doesn't work or if tool conversion is not needed.
8173
case $nm_file_list_spec~$to_tool_file_cmd in
8174
*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8175
try_normal_branch=yes
8178
len=$func_len_result
8181
try_normal_branch=no
8184
if test "$try_normal_branch" = yes \
8185
&& { test "$len" -lt "$max_cmd_len" \
8186
|| test "$max_cmd_len" -le -1; }
8188
func_show_eval "$cmd" 'exit $?'
8189
skipped_export=false
8190
elif test -n "$nm_file_list_spec"; then
8191
func_basename "$output"
8192
output_la=$func_basename_result
8193
save_libobjs=$libobjs
8195
output=${output_objdir}/${output_la}.nm
8196
func_to_tool_file "$output"
8197
libobjs=$nm_file_list_spec$func_to_tool_file_result
8198
func_append delfiles " $output"
8199
func_verbose "creating $NM input file list: $output"
8200
for obj in $save_libobjs; do
8201
func_to_tool_file "$obj"
8202
$ECHO "$func_to_tool_file_result"
8205
func_show_eval "$cmd" 'exit $?'
8207
libobjs=$save_libobjs
8208
skipped_export=false
8210
# The command line is too long to execute in one step.
8211
func_verbose "using reloadable object file for export list..."
8213
# Break out early, otherwise skipped_export may be
8214
# set to false by a later but shorter cmd.
8219
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8220
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8221
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8226
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8227
tmp_export_symbols="$export_symbols"
8228
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8229
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8232
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8233
# The given exports_symbols file has to be filtered, so filter it.
8234
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8235
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8236
# 's' commands which not all seds can handle. GNU sed should be fine
8237
# though. Also, the filter scales superlinearly with the number of
8238
# global variables. join(1) would be nice here, but unfortunately
8239
# isn't a blessed tool.
8240
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8241
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8242
export_symbols=$output_objdir/$libname.def
8243
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8247
for test_deplib in $deplibs; do
8248
case " $convenience " in
8249
*" $test_deplib "*) ;;
8251
func_append tmp_deplibs " $test_deplib"
8255
deplibs="$tmp_deplibs"
8257
if test -n "$convenience"; then
8258
if test -n "$whole_archive_flag_spec" &&
8259
test "$compiler_needs_object" = yes &&
8260
test -z "$libobjs"; then
8261
# extract the archives, so we have objects to list.
8262
# TODO: could optimize this to just extract one archive.
8263
whole_archive_flag_spec=
8265
if test -n "$whole_archive_flag_spec"; then
8266
save_libobjs=$libobjs
8267
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8268
test "X$libobjs" = "X " && libobjs=
8270
gentop="$output_objdir/${outputname}x"
8271
func_append generated " $gentop"
8273
func_extract_archives $gentop $convenience
8274
func_append libobjs " $func_extract_archives_result"
8275
test "X$libobjs" = "X " && libobjs=
8279
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8280
eval flag=\"$thread_safe_flag_spec\"
8281
func_append linker_flags " $flag"
8284
# Make a backup of the uninstalled library when relinking
8285
if test "$opt_mode" = relink; then
8286
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8289
# Do each of the archive commands.
8290
if test "$module" = yes && test -n "$module_cmds" ; then
8291
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8292
eval test_cmds=\"$module_expsym_cmds\"
8293
cmds=$module_expsym_cmds
8295
eval test_cmds=\"$module_cmds\"
8299
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8300
eval test_cmds=\"$archive_expsym_cmds\"
8301
cmds=$archive_expsym_cmds
8303
eval test_cmds=\"$archive_cmds\"
8308
if test "X$skipped_export" != "X:" &&
8309
func_len " $test_cmds" &&
8310
len=$func_len_result &&
8311
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8314
# The command line is too long to link in one step, link piecewise
8315
# or, if using GNU ld and skipped_export is not :, use a linker
8318
# Save the value of $output and $libobjs because we want to
8319
# use them later. If we have whole_archive_flag_spec, we
8320
# want to use save_libobjs as it was before
8321
# whole_archive_flag_spec was expanded, because we can't
8322
# assume the linker understands whole_archive_flag_spec.
8323
# This may have to be revisited, in case too many
8324
# convenience libraries get linked in and end up exceeding
8326
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8327
save_libobjs=$libobjs
8330
func_basename "$output"
8331
output_la=$func_basename_result
8333
# Clear the reloadable object creation command queue and
8334
# initialize k to one.
8341
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8342
output=${output_objdir}/${output_la}.lnkscript
8343
func_verbose "creating GNU ld script: $output"
8344
echo 'INPUT (' > $output
8345
for obj in $save_libobjs
8347
func_to_tool_file "$obj"
8348
$ECHO "$func_to_tool_file_result" >> $output
8351
func_append delfiles " $output"
8352
func_to_tool_file "$output"
8353
output=$func_to_tool_file_result
8354
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8355
output=${output_objdir}/${output_la}.lnk
8356
func_verbose "creating linker input file list: $output"
8361
if test "$compiler_needs_object" = yes; then
8367
func_to_tool_file "$obj"
8368
$ECHO "$func_to_tool_file_result" >> $output
8370
func_append delfiles " $output"
8371
func_to_tool_file "$output"
8372
output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8374
if test -n "$save_libobjs"; then
8375
func_verbose "creating reloadable object files..."
8376
output=$output_objdir/$output_la-${k}.$objext
8377
eval test_cmds=\"$reload_cmds\"
8378
func_len " $test_cmds"
8379
len0=$func_len_result
8382
# Loop over the list of objects to be linked.
8383
for obj in $save_libobjs
8386
func_arith $len + $func_len_result
8387
len=$func_arith_result
8388
if test "X$objlist" = X ||
8389
test "$len" -lt "$max_cmd_len"; then
8390
func_append objlist " $obj"
8392
# The command $test_cmds is almost too long, add a
8393
# command to the queue.
8394
if test "$k" -eq 1 ; then
8395
# The first file doesn't have a previous command to add.
8396
reload_objs=$objlist
8397
eval concat_cmds=\"$reload_cmds\"
8399
# All subsequent reloadable object files will link in
8400
# the last one created.
8401
reload_objs="$objlist $last_robj"
8402
eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8404
last_robj=$output_objdir/$output_la-${k}.$objext
8406
k=$func_arith_result
8407
output=$output_objdir/$output_la-${k}.$objext
8409
func_len " $last_robj"
8410
func_arith $len0 + $func_len_result
8411
len=$func_arith_result
8414
# Handle the remaining objects by creating one last
8415
# reloadable object file. All subsequent reloadable object
8416
# files will link in the last one created.
8417
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8418
reload_objs="$objlist $last_robj"
8419
eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8420
if test -n "$last_robj"; then
8421
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8423
func_append delfiles " $output"
8429
if ${skipped_export-false}; then
8430
func_verbose "generating symbol list for \`$libname.la'"
8431
export_symbols="$output_objdir/$libname.exp"
8432
$opt_dry_run || $RM $export_symbols
8434
# Append the command to create the export file.
8435
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8436
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8437
if test -n "$last_robj"; then
8438
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8442
test -n "$save_libobjs" &&
8443
func_verbose "creating a temporary reloadable object file: $output"
8445
# Loop through the commands generated above and execute them.
8446
save_ifs="$IFS"; IFS='~'
8447
for cmd in $concat_cmds; do
8450
func_quote_for_expand "$cmd"
8451
eval "func_echo $func_quote_for_expand_result"
8453
$opt_dry_run || eval "$cmd" || {
8456
# Restore the uninstalled library and exit
8457
if test "$opt_mode" = relink; then
8458
( cd "$output_objdir" && \
8459
$RM "${realname}T" && \
8460
$MV "${realname}U" "$realname" )
8468
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8469
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8470
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8474
if ${skipped_export-false}; then
8475
if test -n "$export_symbols" && test -n "$include_expsyms"; then
8476
tmp_export_symbols="$export_symbols"
8477
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8478
$opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8481
if test -n "$orig_export_symbols"; then
8482
# The given exports_symbols file has to be filtered, so filter it.
8483
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8484
# FIXME: $output_objdir/$libname.filter potentially contains lots of
8485
# 's' commands which not all seds can handle. GNU sed should be fine
8486
# though. Also, the filter scales superlinearly with the number of
8487
# global variables. join(1) would be nice here, but unfortunately
8488
# isn't a blessed tool.
8489
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8490
func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8491
export_symbols=$output_objdir/$libname.def
8492
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8497
# Restore the value of output.
8500
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8501
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8502
test "X$libobjs" = "X " && libobjs=
8504
# Expand the library linking commands again to reset the
8505
# value of $libobjs for piecewise linking.
8507
# Do each of the archive commands.
8508
if test "$module" = yes && test -n "$module_cmds" ; then
8509
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8510
cmds=$module_expsym_cmds
8515
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8516
cmds=$archive_expsym_cmds
8523
if test -n "$delfiles"; then
8524
# Append the command to remove temporary files to $cmds.
8525
eval cmds=\"\$cmds~\$RM $delfiles\"
8528
# Add any objects from preloaded convenience libraries
8529
if test -n "$dlprefiles"; then
8530
gentop="$output_objdir/${outputname}x"
8531
func_append generated " $gentop"
8533
func_extract_archives $gentop $dlprefiles
8534
func_append libobjs " $func_extract_archives_result"
8535
test "X$libobjs" = "X " && libobjs=
8538
save_ifs="$IFS"; IFS='~'
8539
for cmd in $cmds; do
8543
func_quote_for_expand "$cmd"
8544
eval "func_echo $func_quote_for_expand_result"
8546
$opt_dry_run || eval "$cmd" || {
8549
# Restore the uninstalled library and exit
8550
if test "$opt_mode" = relink; then
8551
( cd "$output_objdir" && \
8552
$RM "${realname}T" && \
8553
$MV "${realname}U" "$realname" )
8561
# Restore the uninstalled library and exit
8562
if test "$opt_mode" = relink; then
8563
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8565
if test -n "$convenience"; then
8566
if test -z "$whole_archive_flag_spec"; then
8567
func_show_eval '${RM}r "$gentop"'
8574
# Create links to the real library.
8575
for linkname in $linknames; do
8576
if test "$realname" != "$linkname"; then
8577
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8581
# If -module or -export-dynamic was specified, set the dlname.
8582
if test "$module" = yes || test "$export_dynamic" = yes; then
8583
# On all known operating systems, these are identical.
8590
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8591
func_warning "\`-dlopen' is ignored for objects"
8596
func_warning "\`-l' and \`-L' are ignored for objects" ;;
8599
test -n "$rpath" && \
8600
func_warning "\`-rpath' is ignored for objects"
8602
test -n "$xrpath" && \
8603
func_warning "\`-R' is ignored for objects"
8605
test -n "$vinfo" && \
8606
func_warning "\`-version-info' is ignored for objects"
8608
test -n "$release" && \
8609
func_warning "\`-release' is ignored for objects"
8613
test -n "$objs$old_deplibs" && \
8614
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8618
obj=$func_lo2o_result
8626
# Delete the old objects.
8627
$opt_dry_run || $RM $obj $libobj
8629
# Objects from convenience libraries. This assumes
8630
# single-version convenience libraries. Whenever we create
8631
# different ones for PIC/non-PIC, this we'll have to duplicate
8635
# reload_cmds runs $LD directly, so let us get rid of
8636
# -Wl from whole_archive_flag_spec and hope we can get by with
8637
# turning comma into space..
8640
if test -n "$convenience"; then
8641
if test -n "$whole_archive_flag_spec"; then
8642
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8643
reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8645
gentop="$output_objdir/${obj}x"
8646
func_append generated " $gentop"
8648
func_extract_archives $gentop $convenience
8649
reload_conv_objs="$reload_objs $func_extract_archives_result"
8653
# If we're not building shared, we need to use non_pic_objs
8654
test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8656
# Create the old-style object.
8657
reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8660
func_execute_cmds "$reload_cmds" 'exit $?'
8662
# Exit if we aren't doing a library object file.
8663
if test -z "$libobj"; then
8664
if test -n "$gentop"; then
8665
func_show_eval '${RM}r "$gentop"'
8671
if test "$build_libtool_libs" != yes; then
8672
if test -n "$gentop"; then
8673
func_show_eval '${RM}r "$gentop"'
8676
# Create an invalid libtool object if no PIC, so that we don't
8677
# accidentally link it into a program.
8678
# $show "echo timestamp > $libobj"
8679
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8683
if test -n "$pic_flag" || test "$pic_mode" != default; then
8684
# Only do commands if we really have different PIC objects.
8685
reload_objs="$libobjs $reload_conv_objs"
8687
func_execute_cmds "$reload_cmds" 'exit $?'
8690
if test -n "$gentop"; then
8691
func_show_eval '${RM}r "$gentop"'
8699
*cygwin*) func_stripname '' '.exe' "$output"
8700
output=$func_stripname_result.exe;;
8702
test -n "$vinfo" && \
8703
func_warning "\`-version-info' is ignored for programs"
8705
test -n "$release" && \
8706
func_warning "\`-release' is ignored for programs"
8708
test "$preload" = yes \
8709
&& test "$dlopen_support" = unknown \
8710
&& test "$dlopen_self" = unknown \
8711
&& test "$dlopen_self_static" = unknown && \
8712
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8715
*-*-rhapsody* | *-*-darwin1.[012])
8716
# On Rhapsody replace the C library is the System framework
8717
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8718
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8724
# Don't allow lazy linking, it breaks C++ global constructors
8725
# But is supposedly fixed on 10.4 or later (yay!).
8726
if test "$tagname" = CXX ; then
8727
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8729
func_append compile_command " ${wl}-bind_at_load"
8730
func_append finalize_command " ${wl}-bind_at_load"
8734
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8735
compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8736
finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8741
# move library search paths that coincide with paths to not yet
8742
# installed libraries to the beginning of the library search list
8744
for path in $notinst_path; do
8745
case " $new_libs " in
8746
*" -L$path/$objdir "*) ;;
8748
case " $compile_deplibs " in
8749
*" -L$path/$objdir "*)
8750
func_append new_libs " -L$path/$objdir" ;;
8755
for deplib in $compile_deplibs; do
8758
case " $new_libs " in
8760
*) func_append new_libs " $deplib" ;;
8763
*) func_append new_libs " $deplib" ;;
8766
compile_deplibs="$new_libs"
8769
func_append compile_command " $compile_deplibs"
8770
func_append finalize_command " $finalize_deplibs"
8772
if test -n "$rpath$xrpath"; then
8773
# If the user specified any rpath flags, then add them.
8774
for libdir in $rpath $xrpath; do
8775
# This is the magic to use -rpath.
8776
case "$finalize_rpath " in
8778
*) func_append finalize_rpath " $libdir" ;;
8783
# Now hardcode the library paths
8786
for libdir in $compile_rpath $finalize_rpath; do
8787
if test -n "$hardcode_libdir_flag_spec"; then
8788
if test -n "$hardcode_libdir_separator"; then
8789
if test -z "$hardcode_libdirs"; then
8790
hardcode_libdirs="$libdir"
8792
# Just accumulate the unique libdirs.
8793
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8794
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8797
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8802
eval flag=\"$hardcode_libdir_flag_spec\"
8803
func_append rpath " $flag"
8805
elif test -n "$runpath_var"; then
8806
case "$perm_rpath " in
8808
*) func_append perm_rpath " $libdir" ;;
8812
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8813
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8814
case :$dllsearchpath: in
8816
::) dllsearchpath=$libdir;;
8817
*) func_append dllsearchpath ":$libdir";;
8819
case :$dllsearchpath: in
8820
*":$testbindir:"*) ;;
8821
::) dllsearchpath=$testbindir;;
8822
*) func_append dllsearchpath ":$testbindir";;
8827
# Substitute the hardcoded libdirs into the rpath.
8828
if test -n "$hardcode_libdir_separator" &&
8829
test -n "$hardcode_libdirs"; then
8830
libdir="$hardcode_libdirs"
8831
eval rpath=\" $hardcode_libdir_flag_spec\"
8833
compile_rpath="$rpath"
8837
for libdir in $finalize_rpath; do
8838
if test -n "$hardcode_libdir_flag_spec"; then
8839
if test -n "$hardcode_libdir_separator"; then
8840
if test -z "$hardcode_libdirs"; then
8841
hardcode_libdirs="$libdir"
8843
# Just accumulate the unique libdirs.
8844
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8845
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8848
func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8853
eval flag=\"$hardcode_libdir_flag_spec\"
8854
func_append rpath " $flag"
8856
elif test -n "$runpath_var"; then
8857
case "$finalize_perm_rpath " in
8859
*) func_append finalize_perm_rpath " $libdir" ;;
8863
# Substitute the hardcoded libdirs into the rpath.
8864
if test -n "$hardcode_libdir_separator" &&
8865
test -n "$hardcode_libdirs"; then
8866
libdir="$hardcode_libdirs"
8867
eval rpath=\" $hardcode_libdir_flag_spec\"
8869
finalize_rpath="$rpath"
8871
if test -n "$libobjs" && test "$build_old_libs" = yes; then
8872
# Transform all the library objects into standard objects.
8873
compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8874
finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8877
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8879
# template prelinking step
8880
if test -n "$prelink_cmds"; then
8881
func_execute_cmds "$prelink_cmds" 'exit $?'
8884
wrappers_required=yes
8886
*cegcc* | *mingw32ce*)
8887
# Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8888
wrappers_required=no
8890
*cygwin* | *mingw* )
8891
if test "$build_libtool_libs" != yes; then
8892
wrappers_required=no
8896
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8897
wrappers_required=no
8901
if test "$wrappers_required" = no; then
8902
# Replace the output file specification.
8903
compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8904
link_command="$compile_command$compile_rpath"
8906
# We have no uninstalled library dependencies, so finalize right now.
8908
func_show_eval "$link_command" 'exit_status=$?'
8910
if test -n "$postlink_cmds"; then
8911
func_to_tool_file "$output"
8912
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8913
func_execute_cmds "$postlink_cmds" 'exit $?'
8916
# Delete the generated files.
8917
if test -f "$output_objdir/${outputname}S.${objext}"; then
8918
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8924
if test -n "$compile_shlibpath$finalize_shlibpath"; then
8925
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8927
if test -n "$finalize_shlibpath"; then
8928
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8933
if test -n "$runpath_var"; then
8934
if test -n "$perm_rpath"; then
8935
# We should set the runpath_var.
8937
for dir in $perm_rpath; do
8938
func_append rpath "$dir:"
8940
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8942
if test -n "$finalize_perm_rpath"; then
8943
# We should set the runpath_var.
8945
for dir in $finalize_perm_rpath; do
8946
func_append rpath "$dir:"
8948
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8952
if test "$no_install" = yes; then
8953
# We don't need to create a wrapper script.
8954
link_command="$compile_var$compile_command$compile_rpath"
8955
# Replace the output file specification.
8956
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8957
# Delete the old output file.
8958
$opt_dry_run || $RM $output
8959
# Link the executable and exit
8960
func_show_eval "$link_command" 'exit $?'
8962
if test -n "$postlink_cmds"; then
8963
func_to_tool_file "$output"
8964
postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8965
func_execute_cmds "$postlink_cmds" 'exit $?'
8971
if test "$hardcode_action" = relink; then
8972
# Fast installation is not supported
8973
link_command="$compile_var$compile_command$compile_rpath"
8974
relink_command="$finalize_var$finalize_command$finalize_rpath"
8976
func_warning "this platform does not like uninstalled shared libraries"
8977
func_warning "\`$output' will be relinked during installation"
8979
if test "$fast_install" != no; then
8980
link_command="$finalize_var$compile_command$finalize_rpath"
8981
if test "$fast_install" = yes; then
8982
relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8984
# fast_install is set to needless
8988
link_command="$compile_var$compile_command$compile_rpath"
8989
relink_command="$finalize_var$finalize_command$finalize_rpath"
8993
# Replace the output file specification.
8994
link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8996
# Delete the old output files.
8997
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8999
func_show_eval "$link_command" 'exit $?'
9001
if test -n "$postlink_cmds"; then
9002
func_to_tool_file "$output_objdir/$outputname"
9003
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'`
9004
func_execute_cmds "$postlink_cmds" 'exit $?'
9007
# Now create the wrapper script.
9008
func_verbose "creating $output"
9010
# Quote the relink command for shipping.
9011
if test -n "$relink_command"; then
9012
# Preserve any variables that may affect compiler behavior
9013
for var in $variables_saved_for_relink; do
9014
if eval test -z \"\${$var+set}\"; then
9015
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9016
elif eval var_value=\$$var; test -z "$var_value"; then
9017
relink_command="$var=; export $var; $relink_command"
9019
func_quote_for_eval "$var_value"
9020
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9023
relink_command="(cd `pwd`; $relink_command)"
9024
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9027
# Only actually do things if not in dry run mode.
9029
# win32 will think the script is a binary if it has
9030
# a .exe suffix, so we strip it off here.
9032
*.exe) func_stripname '' '.exe' "$output"
9033
output=$func_stripname_result ;;
9035
# test for cygwin because mv fails w/o .exe extensions
9039
func_stripname '' '.exe' "$outputname"
9040
outputname=$func_stripname_result ;;
9044
*cygwin* | *mingw* )
9045
func_dirname_and_basename "$output" "" "."
9046
output_name=$func_basename_result
9047
output_path=$func_dirname_result
9048
cwrappersource="$output_path/$objdir/lt-$output_name.c"
9049
cwrapper="$output_path/$output_name.exe"
9050
$RM $cwrappersource $cwrapper
9051
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9053
func_emit_cwrapperexe_src > $cwrappersource
9055
# The wrapper executable is built using the $host compiler,
9056
# because it contains $host paths and files. If cross-
9057
# compiling, it, like the target executable, must be
9058
# executed on the $host or under an emulation environment.
9060
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9064
# Now, create the wrapper script for func_source use:
9065
func_ltwrapper_scriptname $cwrapper
9066
$RM $func_ltwrapper_scriptname_result
9067
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9069
# note: this script will not be executed, so do not chmod.
9070
if test "x$build" = "x$host" ; then
9071
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9073
func_emit_wrapper no > $func_ltwrapper_scriptname_result
9079
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9081
func_emit_wrapper no > $output
9090
# See if we need to build an old-fashioned archive.
9091
for oldlib in $oldlibs; do
9093
if test "$build_libtool_libs" = convenience; then
9094
oldobjs="$libobjs_save $symfileobj"
9095
addlibs="$convenience"
9096
build_libtool_libs=no
9098
if test "$build_libtool_libs" = module; then
9099
oldobjs="$libobjs_save"
9100
build_libtool_libs=no
9102
oldobjs="$old_deplibs $non_pic_objects"
9103
if test "$preload" = yes && test -f "$symfileobj"; then
9104
func_append oldobjs " $symfileobj"
9107
addlibs="$old_convenience"
9110
if test -n "$addlibs"; then
9111
gentop="$output_objdir/${outputname}x"
9112
func_append generated " $gentop"
9114
func_extract_archives $gentop $addlibs
9115
func_append oldobjs " $func_extract_archives_result"
9118
# Do each command in the archive commands.
9119
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9120
cmds=$old_archive_from_new_cmds
9123
# Add any objects from preloaded convenience libraries
9124
if test -n "$dlprefiles"; then
9125
gentop="$output_objdir/${outputname}x"
9126
func_append generated " $gentop"
9128
func_extract_archives $gentop $dlprefiles
9129
func_append oldobjs " $func_extract_archives_result"
9132
# POSIX demands no paths to be encoded in archives. We have
9133
# to avoid creating archives with duplicate basenames if we
9134
# might have to extract them afterwards, e.g., when creating a
9135
# static archive out of a convenience library, or when linking
9136
# the entirety of a libtool archive into another (currently
9137
# not supported by libtool).
9138
if (for obj in $oldobjs
9140
func_basename "$obj"
9141
$ECHO "$func_basename_result"
9142
done | sort | sort -uc >/dev/null 2>&1); then
9145
echo "copying selected object files to avoid basename conflicts..."
9146
gentop="$output_objdir/${outputname}x"
9147
func_append generated " $gentop"
9148
func_mkdir_p "$gentop"
9149
save_oldobjs=$oldobjs
9152
for obj in $save_oldobjs
9154
func_basename "$obj"
9155
objbase="$func_basename_result"
9156
case " $oldobjs " in
9157
" ") oldobjs=$obj ;;
9160
# Make sure we don't pick an alternate name that also
9162
newobj=lt$counter-$objbase
9163
func_arith $counter + 1
9164
counter=$func_arith_result
9165
case " $oldobjs " in
9166
*[\ /]"$newobj "*) ;;
9167
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
9170
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9171
func_append oldobjs " $gentop/$newobj"
9173
*) func_append oldobjs " $obj" ;;
9177
func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9178
tool_oldlib=$func_to_tool_file_result
9179
eval cmds=\"$old_archive_cmds\"
9182
len=$func_len_result
9183
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9184
cmds=$old_archive_cmds
9185
elif test -n "$archiver_list_spec"; then
9186
func_verbose "using command file archive linking..."
9189
func_to_tool_file "$obj"
9190
$ECHO "$func_to_tool_file_result"
9191
done > $output_objdir/$libname.libcmd
9192
func_to_tool_file "$output_objdir/$libname.libcmd"
9193
oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9194
cmds=$old_archive_cmds
9196
# the command line is too long to link in one step, link in parts
9197
func_verbose "using piecewise archive linking..."
9202
save_oldobjs=$oldobjs
9204
# Is there a better way of finding the last object in the list?
9205
for obj in $save_oldobjs
9209
eval test_cmds=\"$old_archive_cmds\"
9210
func_len " $test_cmds"
9211
len0=$func_len_result
9213
for obj in $save_oldobjs
9216
func_arith $len + $func_len_result
9217
len=$func_arith_result
9218
func_append objlist " $obj"
9219
if test "$len" -lt "$max_cmd_len"; then
9222
# the above command should be used before it gets too long
9224
if test "$obj" = "$last_oldobj" ; then
9227
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9228
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9235
if test "X$oldobjs" = "X" ; then
9236
eval cmds=\"\$concat_cmds\"
9238
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9242
func_execute_cmds "$cmds" 'exit $?'
9245
test -n "$generated" && \
9246
func_show_eval "${RM}r$generated"
9248
# Now create the libtool archive.
9252
test "$build_old_libs" = yes && old_library="$libname.$libext"
9253
func_verbose "creating $output"
9255
# Preserve any variables that may affect compiler behavior
9256
for var in $variables_saved_for_relink; do
9257
if eval test -z \"\${$var+set}\"; then
9258
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9259
elif eval var_value=\$$var; test -z "$var_value"; then
9260
relink_command="$var=; export $var; $relink_command"
9262
func_quote_for_eval "$var_value"
9263
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9266
# Quote the link command for shipping.
9267
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9268
relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9269
if test "$hardcode_automatic" = yes ; then
9273
# Only create the output if not a dry run.
9275
for installed in no yes; do
9276
if test "$installed" = yes; then
9277
if test -z "$install_libdir"; then
9280
output="$output_objdir/$outputname"i
9281
# Replace all uninstalled libtool libraries with the installed ones
9283
for deplib in $dependency_libs; do
9286
func_basename "$deplib"
9287
name="$func_basename_result"
9288
func_resolve_sysroot "$deplib"
9289
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9290
test -z "$libdir" && \
9291
func_fatal_error "\`$deplib' is not a valid libtool archive"
9292
func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9295
func_stripname -L '' "$deplib"
9296
func_replace_sysroot "$func_stripname_result"
9297
func_append newdependency_libs " -L$func_replace_sysroot_result"
9300
func_stripname -R '' "$deplib"
9301
func_replace_sysroot "$func_stripname_result"
9302
func_append newdependency_libs " -R$func_replace_sysroot_result"
9304
*) func_append newdependency_libs " $deplib" ;;
9307
dependency_libs="$newdependency_libs"
9310
for lib in $dlfiles; do
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 newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9320
*) func_append newdlfiles " $lib" ;;
9323
dlfiles="$newdlfiles"
9325
for lib in $dlprefiles; do
9328
# Only pass preopened files to the pseudo-archive (for
9329
# eventual linking with the app. that links it) if we
9330
# didn't already link the preopened objects directly into
9332
func_basename "$lib"
9333
name="$func_basename_result"
9334
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9335
test -z "$libdir" && \
9336
func_fatal_error "\`$lib' is not a valid libtool archive"
9337
func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9341
dlprefiles="$newdlprefiles"
9344
for lib in $dlfiles; do
9346
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9347
*) abs=`pwd`"/$lib" ;;
9349
func_append newdlfiles " $abs"
9351
dlfiles="$newdlfiles"
9353
for lib in $dlprefiles; do
9355
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9356
*) abs=`pwd`"/$lib" ;;
9358
func_append newdlprefiles " $abs"
9360
dlprefiles="$newdlprefiles"
9363
# place dlname in correct position for cygwin
9364
# In fact, it would be nice if we could use this code for all target
9365
# systems that can't hard-code library paths into their executables
9366
# and that have no shared library path variable independent of PATH,
9367
# but it turns out we can't easily determine that from inspecting
9368
# libtool variables, so we have to hard-code the OSs to which it
9369
# applies here; at the moment, that means platforms that use the PE
9370
# object format with DLL files. See the long comment at the top of
9371
# tests/bindir.at for full details.
9373
case $host,$output,$installed,$module,$dlname in
9374
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9375
# If a -bindir argument was supplied, place the dll there.
9376
if test "x$bindir" != x ;
9378
func_relative_path "$install_libdir" "$bindir"
9379
tdlname=$func_relative_path_result$dlname
9381
# Otherwise fall back on heuristic.
9382
tdlname=../bin/$dlname
9387
# $outputname - a libtool library file
9388
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9390
# Please DO NOT delete this file!
9391
# It is necessary for linking the library.
9393
# The name that we can dlopen(3).
9396
# Names of this library.
9397
library_names='$library_names'
9399
# The name of the static archive.
9400
old_library='$old_library'
9402
# Linker flags that can not go in dependency_libs.
9403
inherited_linker_flags='$new_inherited_linker_flags'
9405
# Libraries that this one depends upon.
9406
dependency_libs='$dependency_libs'
9408
# Names of additional weak libraries provided by this library
9409
weak_library_names='$weak_libs'
9411
# Version information for $libname.
9416
# Is this an already installed library?
9417
installed=$installed
9419
# Should we warn about portability when linking against -modules?
9420
shouldnotlink=$module
9422
# Files to dlopen/dlpreopen
9424
dlpreopen='$dlprefiles'
9426
# Directory that this library needs to be installed in:
9427
libdir='$install_libdir'"
9428
if test "$installed" = no && test "$need_relink" = yes; then
9430
relink_command=\"$relink_command\""
9435
# Do a symbolic link so that the libtool archive can be found in
9436
# LD_LIBRARY_PATH before the program is installed.
9437
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9443
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9444
func_mode_link ${1+"$@"}
9447
# func_mode_uninstall arg...
9448
func_mode_uninstall ()
9456
# This variable tells wrapper scripts just to set variables rather
9457
# than running their programs.
9458
libtool_install_magic="$magic"
9463
-f) func_append RM " $arg"; rmforce=yes ;;
9464
-*) func_append RM " $arg" ;;
9465
*) func_append files " $arg" ;;
9470
func_fatal_help "you must specify an RM program"
9474
for file in $files; do
9475
func_dirname "$file" "" "."
9476
dir="$func_dirname_result"
9477
if test "X$dir" = X.; then
9482
func_basename "$file"
9483
name="$func_basename_result"
9484
test "$opt_mode" = uninstall && odir="$dir"
9486
# Remember odir for removal later, being careful to avoid duplicates
9487
if test "$opt_mode" = clean; then
9490
*) func_append rmdirs " $odir" ;;
9494
# Don't error if the file doesn't exist and rm -f was used.
9495
if { test -L "$file"; } >/dev/null 2>&1 ||
9496
{ test -h "$file"; } >/dev/null 2>&1 ||
9497
test -f "$file"; then
9499
elif test -d "$file"; then
9502
elif test "$rmforce" = yes; then
9510
# Possibly a libtool archive, so verify it.
9511
if func_lalib_p "$file"; then
9512
func_source $dir/$name
9514
# Delete the libtool libraries and symlinks.
9515
for n in $library_names; do
9516
func_append rmfiles " $odir/$n"
9518
test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9522
case " $library_names " in
9524
*) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9526
test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9529
if test -n "$library_names"; then
9530
# Do each command in the postuninstall commands.
9531
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9534
if test -n "$old_library"; then
9535
# Do each command in the old_postuninstall commands.
9536
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9538
# FIXME: should reinstall the best remaining shared library.
9545
# Possibly a libtool object, so verify it.
9546
if func_lalib_p "$file"; then
9549
func_source $dir/$name
9551
# Add PIC object to the list of files to remove.
9552
if test -n "$pic_object" &&
9553
test "$pic_object" != none; then
9554
func_append rmfiles " $dir/$pic_object"
9557
# Add non-PIC object to the list of files to remove.
9558
if test -n "$non_pic_object" &&
9559
test "$non_pic_object" != none; then
9560
func_append rmfiles " $dir/$non_pic_object"
9566
if test "$opt_mode" = clean ; then
9570
func_stripname '' '.exe' "$file"
9571
file=$func_stripname_result
9572
func_stripname '' '.exe' "$name"
9573
noexename=$func_stripname_result
9574
# $file with .exe has already been added to rmfiles,
9575
# add $file without .exe
9576
func_append rmfiles " $file"
9579
# Do a test to see if this is a libtool program.
9580
if func_ltwrapper_p "$file"; then
9581
if func_ltwrapper_executable_p "$file"; then
9582
func_ltwrapper_scriptname "$file"
9584
func_source $func_ltwrapper_scriptname_result
9585
func_append rmfiles " $func_ltwrapper_scriptname_result"
9588
func_source $dir/$noexename
9591
# note $name still contains .exe if it was in $file originally
9592
# as does the version of $file that was added into $rmfiles
9593
func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9594
if test "$fast_install" = yes && test -n "$relink_command"; then
9595
func_append rmfiles " $odir/lt-$name"
9597
if test "X$noexename" != "X$name" ; then
9598
func_append rmfiles " $odir/lt-${noexename}.c"
9604
func_show_eval "$RM $rmfiles" 'exit_status=1'
9607
# Try to remove the ${objdir}s in the directories where we deleted files
9608
for dir in $rmdirs; do
9609
if test -d "$dir"; then
9610
func_show_eval "rmdir $dir >/dev/null 2>&1"
9617
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9618
func_mode_uninstall ${1+"$@"}
9620
test -z "$opt_mode" && {
9621
help="$generic_help"
9622
func_fatal_help "you must specify a MODE"
9625
test -z "$exec_cmd" && \
9626
func_fatal_help "invalid operation mode \`$opt_mode'"
9628
if test -n "$exec_cmd"; then
9629
eval exec "$exec_cmd"
9636
# The TAGs below are defined such that we never get into a situation
9637
# in which we disable both kinds of libraries. Given conflicting
9638
# choices, we go for a static library, that is the most portable,
9639
# since we can't tell whether shared libraries were disabled because
9640
# the user asked for that or because the platform doesn't support
9641
# them. This is particularly important on AIX, because we don't
9642
# support having both static and shared libraries enabled at the same
9643
# time on that platform, so we default to a shared-only configuration.
9644
# If a disable-shared tag is given, we'll fallback to a static-only
9645
# configuration. But we'll never go from static-only to shared-only.
9647
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9648
build_libtool_libs=no
9650
# ### END LIBTOOL TAG CONFIG: disable-shared
9652
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
9653
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9654
# ### END LIBTOOL TAG CONFIG: disable-static
added
removed
gnome/ltmain.sh
