1
# Generated from ltmain.m4sh.
3
# ltmain.sh (GNU libtool) 2.2.4
4
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
6
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 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
# --tag=TAG use configuration variables from tag TAG
43
# -v, --verbose print informational messages (default)
44
# --version print version information
45
# -h, --help print short or long help message
47
# MODE must be one of the following:
49
# clean remove files from the build directory
50
# compile compile a source file into a libtool object
51
# execute automatically set library path, then run a program
52
# finish complete the installation of libtool libraries
53
# install install libraries or executables
54
# link create a library or an executable
55
# uninstall remove libraries from an installed directory
57
# MODE-ARGS vary depending on the MODE.
58
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
60
# When reporting a bug, please describe a test case to reproduce it and
61
# include the following information:
66
# compiler flags: $LTCFLAGS
67
# linker: $LD (gnu? $with_gnu_ld)
68
# $progname: (GNU libtool) 2.2.4
69
# automake: $automake_version
70
# autoconf: $autoconf_version
72
# Report bugs to <bug-libtool@gnu.org>.
78
package_revision=1.2976
80
# Be Bourne compatible
81
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
84
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
85
# is contrary to our usage. Disable this feature.
86
alias -g '${1+"$@"}'='"$@"'
89
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
91
BIN_SH=xpg4; export BIN_SH # for Tru64
92
DUALCASE=1; export DUALCASE # for MKS sh
94
# NLS nuisances: We save the old values to restore during execute mode.
95
# Only set LANG and LC_ALL to C if already set.
96
# These must not be set unconditionally because not all systems understand
97
# e.g. LANG=C (notably SCO).
100
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
102
eval "if test \"\${$lt_var+set}\" = set; then
103
save_$lt_var=\$$lt_var
106
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
107
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
119
: ${EGREP="/usr/bin/grep -E"}
120
: ${FGREP="/usr/bin/grep -F"}
121
: ${GREP="/usr/bin/grep"}
127
: ${SED="/opt/local/bin/gsed"}
128
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
129
: ${Xsed="$SED -e 1s/^X//"}
134
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
135
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
137
exit_status=$EXIT_SUCCESS
139
# Make sure IFS has a sensible default
144
dirname="s,/[^/]*$,,"
147
# func_dirname_and_basename file append nondir_replacement
148
# perform func_basename and func_dirname in a single function
150
# dirname: Compute the dirname of FILE. If nonempty,
151
# add APPEND to the result, otherwise set result
152
# to NONDIR_REPLACEMENT.
153
# value returned in "$func_dirname_result"
154
# basename: Compute filename of FILE.
155
# value retuned in "$func_basename_result"
156
# Implementation must be kept synchronized with func_dirname
157
# and func_basename. For efficiency, we do not delegate to
158
# those functions but instead duplicate the functionality here.
159
func_dirname_and_basename ()
161
# Extract subdirectory from the argument.
162
func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
163
if test "X$func_dirname_result" = "X${1}"; then
164
func_dirname_result="${3}"
166
func_dirname_result="$func_dirname_result${2}"
168
func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
171
# Generated shell functions inserted here.
173
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
174
# is ksh but when the shell is invoked as "sh" and the current value of
175
# the _XPG environment variable is not equal to 1 (one), the special
176
# positional parameter $0, within a function call, is the name of the
180
# The name of this program:
181
# In the unlikely event $progname began with a '-', it would play havoc with
182
# func_echo (imagine progname=-n), so we prepend ./ in that case:
183
func_dirname_and_basename "$progpath"
184
progname=$func_basename_result
186
-*) progname=./$progname ;;
189
# Make sure we have an absolute path for reexecution:
191
[\\/]*|[A-Za-z]:\\*) ;;
193
progdir=$func_dirname_result
194
progdir=`cd "$progdir" && pwd`
195
progpath="$progdir/$progname"
200
for progdir in $PATH; do
202
test -x "$progdir/$progname" && break
205
test -n "$progdir" || progdir=`pwd`
206
progpath="$progdir/$progname"
210
# Sed substitution that helps us do robust quoting. It backslashifies
211
# metacharacters that are still active within double-quoted strings.
212
Xsed="${SED}"' -e 1s/^X//'
213
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
215
# Same as above, but do not quote variable references.
216
double_quote_subst='s/\(["`\\]\)/\\\1/g'
218
# Re-`\' parameter expansions in output of double_quote_subst that were
219
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
220
# in input to double_quote_subst, that '$' was protected from expansion.
221
# Since each input `\' is now two `\'s, look for any number of runs of
222
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
227
sed_double_backslash="\
231
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
242
# Echo program name prefixed message, along with the current mode
243
# name if it has been set yet.
246
$ECHO "$progname${mode+: }$mode: $*"
249
# func_verbose arg...
250
# Echo program name prefixed message in verbose mode only.
253
$opt_verbose && func_echo ${1+"$@"}
255
# A bug in bash halts the script if the last line of a function
256
# fails when set -e is in force, so we need another command to
262
# Echo program name prefixed message to standard error.
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
268
# func_warning arg...
269
# Echo program name prefixed warning message to standard error.
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
278
# func_fatal_error arg...
279
# Echo program name prefixed message to standard error, and exit.
286
# func_fatal_help arg...
287
# Echo program name prefixed message to standard error, followed by
288
# a help hint, and exit.
292
func_fatal_error "$help"
294
help="Try \`$progname --help' for more information." ## default
297
# func_grep expression filename
298
# Check whether EXPRESSION matches any line of FILENAME, without output.
301
$GREP "$1" "$2" >/dev/null 2>&1
305
# func_mkdir_p directory-path
306
# Make sure the entire path to DIRECTORY-PATH is available.
309
my_directory_path="$1"
312
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
314
# Protect directory names starting with `-'
315
case $my_directory_path in
316
-*) my_directory_path="./$my_directory_path" ;;
319
# While some portion of DIR does not yet exist...
320
while test ! -d "$my_directory_path"; do
321
# ...make a list in topmost first order. Use a colon delimited
322
# list incase some portion of path contains whitespace.
323
my_dir_list="$my_directory_path:$my_dir_list"
325
# If the last portion added has no slash in it, the list is done
326
case $my_directory_path in */*) ;; *) break ;; esac
328
# ...otherwise throw away the child directory and loop
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
333
save_mkdir_p_IFS="$IFS"; IFS=':'
334
for my_dir in $my_dir_list; do
335
IFS="$save_mkdir_p_IFS"
336
# mkdir can fail with a `File exist' error if two processes
337
# try to create one of the directories concurrently. Don't
339
$MKDIR "$my_dir" 2>/dev/null || :
341
IFS="$save_mkdir_p_IFS"
343
# Bail out if we (or some other process) failed to create a directory.
344
test -d "$my_directory_path" || \
345
func_fatal_error "Failed to create \`$1'"
350
# func_mktempdir [string]
351
# Make a temporary directory that won't clash with other running
352
# libtool processes, and avoids race conditions if possible. If
353
# given, STRING is the basename for that directory.
356
my_template="${TMPDIR-/tmp}/${1-$progname}"
358
if test "$opt_dry_run" = ":"; then
359
# Return a directory name, but don't create it in dry-run mode
360
my_tmpdir="${my_template}-$$"
363
# If mktemp works, use that first and foremost
364
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
366
if test ! -d "$my_tmpdir"; then
367
# Failing that, at least try and use $RANDOM to avoid a race
368
my_tmpdir="${my_template}-${RANDOM-0}$$"
370
save_mktempdir_umask=`umask`
373
umask $save_mktempdir_umask
376
# If we're not in dry-run mode, bomb out on failure
377
test -d "$my_tmpdir" || \
378
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
381
$ECHO "X$my_tmpdir" | $Xsed
385
# func_quote_for_eval arg
386
# Aesthetically quote ARG to be evaled later.
387
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
388
# is double-quoted, suitable for a subsequent eval, whereas
389
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
390
# which are still active within double quotes backslashified.
391
func_quote_for_eval ()
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
397
func_quote_for_eval_unquoted_result="$1" ;;
400
case $func_quote_for_eval_unquoted_result in
401
# Double-quote args containing shell metacharacters to delay
402
# word splitting, command substitution and and variable
403
# expansion for a subsequent eval.
404
# Many Bourne shells cannot handle close brackets correctly
405
# in scan sets, so we specify it separately.
406
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
407
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
410
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
415
# func_quote_for_expand arg
416
# Aesthetically quote ARG to be evaled later; same as above,
417
# but do not quote variable references.
418
func_quote_for_expand ()
422
my_arg=`$ECHO "X$1" | $Xsed \
423
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
429
# Double-quote args containing shell metacharacters to delay
430
# word splitting and command substitution for a subsequent eval.
431
# Many Bourne shells cannot handle close brackets correctly
432
# in scan sets, so we specify it separately.
433
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
438
func_quote_for_expand_result="$my_arg"
442
# func_show_eval cmd [fail_exp]
443
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
444
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
445
# is given, then evaluate it.
451
${opt_silent-false} || {
452
func_quote_for_expand "$my_cmd"
453
eval "func_echo $func_quote_for_expand_result"
456
if ${opt_dry_run-false}; then :; else
459
if test "$my_status" -eq 0; then :; else
460
eval "(exit $my_status); $my_fail_exp"
466
# func_show_eval_locale cmd [fail_exp]
467
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
468
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
469
# is given, then evaluate it. Use the saved locale for evaluation.
470
func_show_eval_locale ()
475
${opt_silent-false} || {
476
func_quote_for_expand "$my_cmd"
477
eval "func_echo $func_quote_for_expand_result"
480
if ${opt_dry_run-false}; then :; else
481
eval "$lt_user_locale
484
eval "$lt_safe_locale"
485
if test "$my_status" -eq 0; then :; else
486
eval "(exit $my_status); $my_fail_exp"
496
# Echo version message to standard output and exit.
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
502
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
509
# Echo short help message to standard output and exit.
512
$SED -n '/^# Usage:/,/# -h/ {
515
s/\$progname/'$progname'/
519
$ECHO "run \`$progname --help | more' for full usage"
524
# Echo long help message to standard output and exit.
527
$SED -n '/^# Usage:/,/# Report bugs to/ {
530
s*\$progname*'$progname'*
532
s*\$SHELL*'"$SHELL"'*
534
s*\$LTCFLAGS*'"$LTCFLAGS"'*
536
s/\$with_gnu_ld/'"$with_gnu_ld"'/
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
544
# func_missing_arg argname
545
# Echo program name prefixed message to standard error and set global
549
func_error "missing argument for $1"
559
# Check that we have a working $ECHO.
560
if test "X$1" = X--no-reexec; then
561
# Discard the --no-reexec flag, and continue.
563
elif test "X$1" = X--fallback-echo; then
564
# Avoid inline document here, it may be left over
566
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567
# Yippee, $ECHO works!
570
# Restart under the correct shell, and then maybe $ECHO will work.
571
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
574
if test "X$1" = X--fallback-echo; then
575
# used as fallback echo
583
magic="%%%MAGIC variable%%%"
584
magic_exe="%%%MAGIC EXE variable%%%"
591
lo2o="s/\\.lo\$/.${objext}/"
592
o2lo="s/\\.${objext}\$/.lo/"
597
opt_duplicate_deps=false
601
# If this variable is set in any of the actions, the command in it
602
# will be execed at the end. This prevents here-documents from being
603
# left over by shells.
606
# func_fatal_configuration arg...
607
# Echo program name prefixed message to standard error, followed by
608
# a configuration failure hint, and exit.
609
func_fatal_configuration ()
612
func_error "See the $PACKAGE documentation for more information."
613
func_fatal_error "Fatal configuration error."
618
# Display the configuration for all the tags in this script.
621
re_begincf='^# ### BEGIN LIBTOOL'
622
re_endcf='^# ### END LIBTOOL'
624
# Default configuration.
625
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
627
# Now print the configurations for the tags.
628
for tagname in $taglist; do
629
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
636
# Display the features supported by this script.
640
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
643
$ECHO "disable shared libraries"
645
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
648
$ECHO "disable static libraries"
654
# func_enable_tag tagname
655
# Verify that TAGNAME is valid, and either flag an error and exit, or
656
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
663
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
664
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
665
sed_extractcf="/$re_begincf/,/$re_endcf/p"
670
func_fatal_error "invalid tag name: $tagname"
674
# Don't test for the "default" C tag, as we know it's
675
# there but not specially marked.
679
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
680
taglist="$taglist $tagname"
682
# Evaluate the configuration. Be careful to quote the path
683
# and the sed script, to avoid splitting on whitespace, but
684
# also don't use non-portable quotes within backquotes within
685
# quotes we have to do it in 2 steps:
686
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
689
func_error "ignoring unknown tag $tagname"
695
# Parse options once, thoroughly. This comes as soon as possible in
696
# the script to make things like `libtool --version' happen quickly.
699
# Shorthand for --mode=foo, only valid as the first argument
702
shift; set dummy --mode clean ${1+"$@"}; shift
704
compile|compil|compi|comp|com|co|c)
705
shift; set dummy --mode compile ${1+"$@"}; shift
707
execute|execut|execu|exec|exe|ex|e)
708
shift; set dummy --mode execute ${1+"$@"}; shift
710
finish|finis|fini|fin|fi|f)
711
shift; set dummy --mode finish ${1+"$@"}; shift
713
install|instal|insta|inst|ins|in|i)
714
shift; set dummy --mode install ${1+"$@"}; shift
717
shift; set dummy --mode link ${1+"$@"}; shift
719
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720
shift; set dummy --mode uninstall ${1+"$@"}; shift
724
# Parse non-mode specific arguments:
725
while test "$#" -gt 0; do
730
--config) func_config ;;
732
--debug) preserve_args="$preserve_args $opt"
733
func_echo "enabling shell trace mode"
738
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
739
execute_dlfiles="$execute_dlfiles $1"
743
--dry-run | -n) opt_dry_run=: ;;
744
--features) func_features ;;
745
--finish) mode="finish" ;;
747
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
749
# Valid mode arguments:
759
# Catch anything else as an error
760
*) func_error "invalid argument for $opt"
771
opt_duplicate_deps=: ;;
773
--quiet|--silent) preserve_args="$preserve_args $opt"
777
--verbose| -v) preserve_args="$preserve_args $opt"
781
--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
782
preserve_args="$preserve_args $opt $1"
783
func_enable_tag "$1" # tagname is set here
787
# Separate optargs to long options:
788
-dlopen=*|--mode=*|--tag=*)
789
func_opt_split "$opt"
790
set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
794
-\?|-h) func_usage ;;
795
--help) opt_help=: ;;
796
--version) func_version ;;
798
-*) func_fatal_help "unrecognized option \`$opt'" ;;
808
*cygwin* | *mingw* | *pw32*)
809
# don't eliminate duplications in $postdeps and $predeps
810
opt_duplicate_compiler_generated_deps=:
813
opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
817
# Having warned about all mis-specified options, bail out if
818
# anything was wrong.
819
$exit_cmd $EXIT_FAILURE
822
# func_check_version_match
823
# Ensure that we are using m4 macros, and libtool script from the same
824
# release of libtool.
825
func_check_version_match ()
827
if test "$package_revision" != "$macro_revision"; then
828
if test "$VERSION" != "$macro_version"; then
829
if test -z "$macro_version"; then
831
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
832
$progname: definition of this LT_INIT comes from an older release.
833
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
834
$progname: and run autoconf again.
838
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
839
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
840
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
841
$progname: and run autoconf again.
846
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
847
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
848
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
849
$progname: of $PACKAGE $VERSION and run autoconf again.
863
# Sanity checks first:
864
func_check_version_match
866
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
867
func_fatal_configuration "not configured to build any kind of library"
870
test -z "$mode" && func_fatal_error "error: you must specify a MODE."
874
eval std_shrext=\"$shrext_cmds\"
877
# Only execute mode is allowed to have -dlopen flags.
878
if test -n "$execute_dlfiles" && test "$mode" != execute; then
879
func_error "unrecognized option \`-dlopen'"
884
# Change the help message to a mode-specific one.
886
help="Try \`$progname --help --mode=$mode' for more information."
891
# True iff FILE is a libtool `.la' library or `.lo' object file.
892
# This function is only a basic sanity check; it will hardly flush out
893
# determined imposters.
896
$SED -e 4q "$1" 2>/dev/null \
897
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
900
# func_lalib_unsafe_p file
901
# True iff FILE is a libtool `.la' library or `.lo' object file.
902
# This function implements the same check as func_lalib_p without
903
# resorting to external programs. To this end, it redirects stdin and
904
# closes it afterwards, without saving the original file descriptor.
905
# As a safety measure, use it only where a negative result would be
906
# fatal anyway. Works if `file' does not exist.
907
func_lalib_unsafe_p ()
910
if test -r "$1" && exec 5<&0 <"$1"; then
911
for lalib_p_l in 1 2 3 4
914
case "$lalib_p_line" in
915
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
920
test "$lalib_p" = yes
923
# func_ltwrapper_script_p file
924
# True iff FILE is a libtool wrapper script
925
# This function is only a basic sanity check; it will hardly flush out
926
# determined imposters.
927
func_ltwrapper_script_p ()
932
# func_ltwrapper_executable_p file
933
# True iff FILE is a libtool wrapper executable
934
# This function is only a basic sanity check; it will hardly flush out
935
# determined imposters.
936
func_ltwrapper_executable_p ()
938
func_ltwrapper_exec_suffix=
941
*) func_ltwrapper_exec_suffix=.exe ;;
943
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
946
# func_ltwrapper_scriptname file
947
# Assumes file is an ltwrapper_executable
948
# uses $file to determine the appropriate filename for a
949
# temporary ltwrapper_script.
950
func_ltwrapper_scriptname ()
952
func_ltwrapper_scriptname_result=""
953
if func_ltwrapper_executable_p "$1"; then
954
func_dirname_and_basename "$1" "" "."
955
func_stripname '' '.exe' "$func_basename_result"
956
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
960
# func_ltwrapper_p file
961
# True iff FILE is a libtool wrapper script or wrapper executable
962
# This function is only a basic sanity check; it will hardly flush out
963
# determined imposters.
966
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
970
# func_execute_cmds commands fail_cmd
971
# Execute tilde-delimited COMMANDS.
972
# If FAIL_CMD is given, eval that upon failure.
973
# FAIL_CMD may read-access the current command in variable CMD!
977
save_ifs=$IFS; IFS='~'
981
func_show_eval "$cmd" "${2-:}"
988
# Source FILE, adding directory component if necessary.
989
# Note that it is not necessary on cygwin/mingw to append a dot to
990
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
991
# behavior happens only for exec(3), not for open(2)! Also, sourcing
992
# `FILE.' does not work on cygwin managed mounts.
997
*/* | *\\*) . "$1" ;;
1003
# func_infer_tag arg
1004
# Infer tagged configuration to use if any are available and
1005
# if one wasn't chosen via the "--tag" command line option.
1006
# Only attempt this if the compiler in the base compile
1007
# command doesn't match the default compiler.
1008
# arg is usually of the form 'gcc ...'
1012
if test -n "$available_tags" && test -z "$tagname"; then
1015
func_quote_for_eval "$arg"
1016
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1019
# Blanks in the command may have been stripped by the calling shell,
1020
# but not from the CC environment variable when configure was run.
1021
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1022
# Blanks at the start of $base_compile will cause this to fail
1023
# if we don't check for them as well.
1025
for z in $available_tags; do
1026
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1027
# Evaluate the configuration.
1028
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1031
# Double-quote args containing other shell metacharacters.
1032
func_quote_for_eval "$arg"
1033
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1036
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1037
# The compiler in the base compile command matches
1038
# the one in the tagged configuration.
1039
# Assume this is the tagged configuration we want.
1046
# If $tagname still isn't set, then no tagged configuration
1047
# was found and let the user know that the "--tag" command
1048
# line option must be used.
1049
if test -z "$tagname"; then
1050
func_echo "unable to infer tagged configuration"
1051
func_fatal_error "specify a tag with \`--tag'"
1053
# func_verbose "using $tagname tagged configuration"
1062
# func_write_libtool_object output_name pic_name nonpic_name
1063
# Create a libtool object file (analogous to a ".la" file),
1064
# but don't create it if we're doing a dry run.
1065
func_write_libtool_object ()
1068
if test "$build_libtool_libs" = yes; then
1074
if test "$build_old_libs" = yes; then
1075
write_oldobj=\'${3}\'
1081
cat >${write_libobj}T <<EOF
1082
# $write_libobj - a libtool object file
1083
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1085
# Please DO NOT delete this file!
1086
# It is necessary for linking the library.
1088
# Name of the PIC object.
1089
pic_object=$write_lobj
1091
# Name of the non-PIC object
1092
non_pic_object=$write_oldobj
1095
$MV "${write_libobj}T" "${write_libobj}"
1099
# func_mode_compile arg...
1100
func_mode_compile ()
1103
# Get the compilation command and the source file.
1105
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1117
# do not "continue". Instead, add this to base_compile
1129
# Accept any command-line options.
1132
test -n "$libobj" && \
1133
func_fatal_error "you cannot specify \`-o' more than once"
1138
-pie | -fpie | -fPIE)
1139
pie_flag="$pie_flag $arg"
1143
-shared | -static | -prefer-pic | -prefer-non-pic)
1154
arg_mode=arg # the next one goes into the "base_compile" arg list
1155
continue # The current "srcfile" will either be retained or
1156
;; # replaced later. I would guess that would be a bug.
1159
func_stripname '-Wc,' '' "$arg"
1160
args=$func_stripname_result
1162
save_ifs="$IFS"; IFS=','
1163
for arg in $args; do
1165
func_quote_for_eval "$arg"
1166
lastarg="$lastarg $func_quote_for_eval_result"
1169
func_stripname ' ' '' "$lastarg"
1170
lastarg=$func_stripname_result
1172
# Add the arguments to base_compile.
1173
base_compile="$base_compile $lastarg"
1178
# Accept the current argument as the source file.
1179
# The previous "srcfile" becomes the current argument.
1186
esac # case $arg_mode
1188
# Aesthetically quote the previous argument.
1189
func_quote_for_eval "$lastarg"
1190
base_compile="$base_compile $func_quote_for_eval_result"
1195
func_fatal_error "you must specify an argument for -Xcompile"
1198
func_fatal_error "you must specify a target with \`-o'"
1201
# Get the name of the library object.
1202
test -z "$libobj" && {
1203
func_basename "$srcfile"
1204
libobj="$func_basename_result"
1209
# Recognize several different file suffixes.
1210
# If the user specifies -o file.o, it is replaced with file.lo
1213
*.ada | *.adb | *.ads | *.asm | \
1214
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1215
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
1216
func_xform "$libobj"
1217
libobj=$func_xform_result
1222
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1224
func_fatal_error "cannot determine name of library object from \`$libobj'"
1228
func_infer_tag $base_compile
1230
for arg in $later; do
1233
test "$build_libtool_libs" != yes && \
1234
func_fatal_configuration "can not build a shared library"
1240
build_libtool_libs=no
1257
func_quote_for_eval "$libobj"
1258
test "X$libobj" != "X$func_quote_for_eval_result" \
1259
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1260
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1261
func_dirname_and_basename "$obj" "/" ""
1262
objname="$func_basename_result"
1263
xdir="$func_dirname_result"
1264
lobj=${xdir}$objdir/$objname
1266
test -z "$base_compile" && \
1267
func_fatal_help "you must specify a compilation command"
1269
# Delete any leftover library objects.
1270
if test "$build_old_libs" = yes; then
1271
removelist="$obj $lobj $libobj ${libobj}T"
1273
removelist="$lobj $libobj ${libobj}T"
1276
# On Cygwin there's no "real" PIC flag so we must build both object types
1278
cygwin* | mingw* | pw32* | os2*)
1282
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1283
# non-PIC code in shared libraries is not supported
1287
# Calculate the filename of the output object if compiler does
1288
# not support -o with -c
1289
if test "$compiler_c_o" = no; then
1290
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1291
lockfile="$output_obj.lock"
1298
# Lock this critical section if it is needed
1299
# We use this script file to make the link, it avoids creating a new file
1300
if test "$need_locks" = yes; then
1301
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1302
func_echo "Waiting for $lockfile to be removed"
1305
elif test "$need_locks" = warn; then
1306
if test -f "$lockfile"; then
1308
*** ERROR, $lockfile exists and contains:
1309
`cat $lockfile 2>/dev/null`
1311
This indicates that another process is trying to use the same
1312
temporary object file, and libtool could not work around it because
1313
your compiler does not support \`-c' and \`-o' together. If you
1314
repeat this compilation, it may succeed, by chance, but you had better
1315
avoid parallel builds (make -j) in this platform, or get a better
1318
$opt_dry_run || $RM $removelist
1321
removelist="$removelist $output_obj"
1322
$ECHO "$srcfile" > "$lockfile"
1325
$opt_dry_run || $RM $removelist
1326
removelist="$removelist $lockfile"
1327
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1329
if test -n "$fix_srcfile_path"; then
1330
eval srcfile=\"$fix_srcfile_path\"
1332
func_quote_for_eval "$srcfile"
1333
qsrcfile=$func_quote_for_eval_result
1335
# Only build a PIC object if we are building libtool libraries.
1336
if test "$build_libtool_libs" = yes; then
1337
# Without this assignment, base_compile gets emptied.
1338
fbsd_hideous_sh_bug=$base_compile
1340
if test "$pic_mode" != no; then
1341
command="$base_compile $qsrcfile $pic_flag"
1343
# Don't build PIC code
1344
command="$base_compile $qsrcfile"
1347
func_mkdir_p "$xdir$objdir"
1349
if test -z "$output_obj"; then
1350
# Place PIC objects in $objdir
1351
command="$command -o $lobj"
1354
func_show_eval_locale "$command" \
1355
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1357
if test "$need_locks" = warn &&
1358
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1360
*** ERROR, $lockfile contains:
1361
`cat $lockfile 2>/dev/null`
1363
but it should contain:
1366
This indicates that another process is trying to use the same
1367
temporary object file, and libtool could not work around it because
1368
your compiler does not support \`-c' and \`-o' together. If you
1369
repeat this compilation, it may succeed, by chance, but you had better
1370
avoid parallel builds (make -j) in this platform, or get a better
1373
$opt_dry_run || $RM $removelist
1377
# Just move the object if needed, then go on to compile the next one
1378
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1379
func_show_eval '$MV "$output_obj" "$lobj"' \
1380
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1383
# Allow error messages only from the first compilation.
1384
if test "$suppress_opt" = yes; then
1385
suppress_output=' >/dev/null 2>&1'
1389
# Only build a position-dependent object if we build old libraries.
1390
if test "$build_old_libs" = yes; then
1391
if test "$pic_mode" != yes; then
1392
# Don't build PIC code
1393
command="$base_compile $qsrcfile$pie_flag"
1395
command="$base_compile $qsrcfile $pic_flag"
1397
if test "$compiler_c_o" = yes; then
1398
command="$command -o $obj"
1401
# Suppress compiler output if we already did a PIC compilation.
1402
command="$command$suppress_output"
1403
func_show_eval_locale "$command" \
1404
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1406
if test "$need_locks" = warn &&
1407
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1409
*** ERROR, $lockfile contains:
1410
`cat $lockfile 2>/dev/null`
1412
but it should contain:
1415
This indicates that another process is trying to use the same
1416
temporary object file, and libtool could not work around it because
1417
your compiler does not support \`-c' and \`-o' together. If you
1418
repeat this compilation, it may succeed, by chance, but you had better
1419
avoid parallel builds (make -j) in this platform, or get a better
1422
$opt_dry_run || $RM $removelist
1426
# Just move the object if needed
1427
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1428
func_show_eval '$MV "$output_obj" "$obj"' \
1429
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1434
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1436
# Unlock the critical section if it was locked
1437
if test "$need_locks" != no; then
1438
removelist=$lockfile
1447
test "$mode" = compile && func_mode_compile ${1+"$@"}
1452
# We need to display help for each of the modes.
1455
# Generic help is extracted from the usage comments
1456
# at the start of this file.
1462
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1464
Remove files from the build directory.
1466
RM is the name of the program to use to delete files associated with each FILE
1467
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1470
If FILE is a libtool library, object or program, all the files associated
1471
with it are deleted. Otherwise, only FILE itself is deleted using RM."
1476
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1478
Compile a source file into a libtool library object.
1480
This mode accepts the following additional options:
1482
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1483
-no-suppress do not suppress compiler output for multiple passes
1484
-prefer-pic try to building PIC objects only
1485
-prefer-non-pic try to building non-PIC objects only
1486
-shared do not build a \`.o' file suitable for static linking
1487
-static only build a \`.o' file suitable for static linking
1489
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1490
from the given SOURCEFILE.
1492
The output file name is determined by removing the directory component from
1493
SOURCEFILE, then substituting the C source code suffix \`.c' with the
1494
library object suffix, \`.lo'."
1499
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1501
Automatically set library path, then run a program.
1503
This mode accepts the following additional options:
1505
-dlopen FILE add the directory containing FILE to the library path
1507
This mode sets the library path environment variable according to \`-dlopen'
1510
If any of the ARGS are libtool executable wrappers, then they are translated
1511
into their corresponding uninstalled binary, and any of their required library
1512
directories are added to the library path.
1514
Then, COMMAND is executed, with ARGS as arguments."
1519
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1521
Complete the installation of libtool libraries.
1523
Each LIBDIR is a directory that contains libtool libraries.
1525
The commands that this mode executes may require superuser privileges. Use
1526
the \`--dry-run' option if you just want to see what would be executed."
1531
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1533
Install executables or libraries.
1535
INSTALL-COMMAND is the installation command. The first component should be
1536
either the \`install' or \`cp' program.
1538
The following components of INSTALL-COMMAND are treated specially:
1540
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1542
The rest of the components are interpreted as arguments to that command (only
1543
BSD-compatible install options are recognized)."
1548
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1550
Link object files or libraries together to form another library, or to
1551
create an executable program.
1553
LINK-COMMAND is a command using the C compiler that you would use to create
1554
a program from several object files.
1556
The following components of LINK-COMMAND are treated specially:
1558
-all-static do not do any dynamic linking at all
1559
-avoid-version do not add a version suffix if possible
1560
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1561
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1562
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1563
-export-symbols SYMFILE
1564
try to export only the symbols listed in SYMFILE
1565
-export-symbols-regex REGEX
1566
try to export only the symbols matching REGEX
1567
-LLIBDIR search LIBDIR for required installed libraries
1568
-lNAME OUTPUT-FILE requires the installed library libNAME
1569
-module build a library that can dlopened
1570
-no-fast-install disable the fast-install mode
1571
-no-install link a not-installable executable
1572
-no-undefined declare that a library does not refer to external symbols
1573
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1574
-objectlist FILE Use a list of object files found in FILE to specify objects
1575
-precious-files-regex REGEX
1576
don't remove output files matching REGEX
1577
-release RELEASE specify package release information
1578
-rpath LIBDIR the created library will eventually be installed in LIBDIR
1579
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1580
-shared only do dynamic linking of libtool libraries
1581
-shrext SUFFIX override the standard shared library file extension
1582
-static do not do any dynamic linking of uninstalled libtool libraries
1583
-static-libtool-libs
1584
do not do any dynamic linking of libtool libraries
1585
-version-info CURRENT[:REVISION[:AGE]]
1586
specify library version info [each variable defaults to 0]
1587
-weak LIBNAME declare that the target provides the LIBNAME interface
1589
All other options (arguments beginning with \`-') are ignored.
1591
Every other argument is treated as a filename. Files ending in \`.la' are
1592
treated as uninstalled libtool libraries, other files are standard or library
1595
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1596
only library objects (\`.lo' files) may be specified, and \`-rpath' is
1597
required, except when creating a convenience library.
1599
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1600
using \`ar' and \`ranlib', or on Windows using \`lib'.
1602
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1603
is created, otherwise an executable program is created."
1608
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1610
Remove libraries from an installation directory.
1612
RM is the name of the program to use to delete files associated with each FILE
1613
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1616
If FILE is a libtool library, all the files associated with it are deleted.
1617
Otherwise, only FILE itself is deleted using RM."
1621
func_fatal_help "invalid operation mode \`$mode'"
1626
$ECHO "Try \`$progname --help' for more information about other modes."
1631
# Now that we've collected a possible --mode arg, show help if necessary
1632
$opt_help && func_mode_help
1635
# func_mode_execute arg...
1636
func_mode_execute ()
1639
# The first argument is the command name.
1642
func_fatal_help "you must specify a COMMAND"
1644
# Handle -dlopen flags immediately.
1645
for file in $execute_dlfiles; do
1647
|| func_fatal_help "\`$file' is not a file"
1652
# Check to see that this really is a libtool archive.
1653
func_lalib_unsafe_p "$file" \
1654
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1656
# Read the libtool library.
1661
# Skip this library if it cannot be dlopened.
1662
if test -z "$dlname"; then
1663
# Warn if it was a shared library.
1664
test -n "$library_names" && \
1665
func_warning "\`$file' was not linked with \`-export-dynamic'"
1669
func_dirname "$file" "" "."
1670
dir="$func_dirname_result"
1672
if test -f "$dir/$objdir/$dlname"; then
1675
if test ! -f "$dir/$dlname"; then
1676
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1682
# Just add the directory containing the .lo file.
1683
func_dirname "$file" "" "."
1684
dir="$func_dirname_result"
1688
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1693
# Get the absolute pathname.
1694
absdir=`cd "$dir" && pwd`
1695
test -n "$absdir" && dir="$absdir"
1697
# Now add the directory to shlibpath_var.
1698
if eval "test -z \"\$$shlibpath_var\""; then
1699
eval "$shlibpath_var=\"\$dir\""
1701
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1705
# This variable tells wrapper scripts just to set shlibpath_var
1706
# rather than running their programs.
1707
libtool_execute_magic="$magic"
1709
# Check if any of the arguments is a wrapper script.
1716
# Do a test to see if this is really a libtool program.
1717
if func_ltwrapper_script_p "$file"; then
1719
# Transform arg to wrapped name.
1720
file="$progdir/$program"
1721
elif func_ltwrapper_executable_p "$file"; then
1722
func_ltwrapper_scriptname "$file"
1723
func_source "$func_ltwrapper_scriptname_result"
1724
# Transform arg to wrapped name.
1725
file="$progdir/$program"
1729
# Quote arguments (to preserve shell metacharacters).
1730
func_quote_for_eval "$file"
1731
args="$args $func_quote_for_eval_result"
1734
if test "X$opt_dry_run" = Xfalse; then
1735
if test -n "$shlibpath_var"; then
1736
# Export the shlibpath_var.
1737
eval "export $shlibpath_var"
1740
# Restore saved environment variables
1741
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1743
eval "if test \"\${save_$lt_var+set}\" = set; then
1744
$lt_var=\$save_$lt_var; export $lt_var
1750
# Now prepare to actually exec the command.
1751
exec_cmd="\$cmd$args"
1753
# Display what would be done.
1754
if test -n "$shlibpath_var"; then
1755
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1756
$ECHO "export $shlibpath_var"
1763
test "$mode" = execute && func_mode_execute ${1+"$@"}
1766
# func_mode_finish arg...
1773
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1776
libdirs="$libdirs $dir"
1779
for libdir in $libdirs; do
1780
if test -n "$finish_cmds"; then
1781
# Do each command in the finish commands.
1782
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1785
if test -n "$finish_eval"; then
1786
# Do the single finish_eval.
1787
eval cmds=\"$finish_eval\"
1788
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
1794
# Exit here if they wanted silent mode.
1795
$opt_silent && exit $EXIT_SUCCESS
1797
$ECHO "X----------------------------------------------------------------------" | $Xsed
1798
$ECHO "Libraries have been installed in:"
1799
for libdir in $libdirs; do
1803
$ECHO "If you ever happen to want to link against installed libraries"
1804
$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1805
$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1806
$ECHO "flag during linking and do at least one of the following:"
1807
if test -n "$shlibpath_var"; then
1808
$ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
1809
$ECHO " during execution"
1811
if test -n "$runpath_var"; then
1812
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1813
$ECHO " during linking"
1815
if test -n "$hardcode_libdir_flag_spec"; then
1817
eval flag=\"$hardcode_libdir_flag_spec\"
1819
$ECHO " - use the \`$flag' linker flag"
1821
if test -n "$admincmds"; then
1822
$ECHO " - have your system administrator run these commands:$admincmds"
1824
if test -f /etc/ld.so.conf; then
1825
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1829
$ECHO "See any operating system documentation about shared libraries for"
1831
solaris2.[6789]|solaris2.1[0-9])
1832
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1836
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1839
$ECHO "X----------------------------------------------------------------------" | $Xsed
1843
test "$mode" = finish && func_mode_finish ${1+"$@"}
1846
# func_mode_install arg...
1847
func_mode_install ()
1850
# There may be an optional sh(1) argument at the beginning of
1851
# install_prog (especially on Windows NT).
1852
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1853
# Allow the use of GNU shtool's install command.
1854
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1855
# Aesthetically quote it.
1856
func_quote_for_eval "$nonopt"
1857
install_prog="$func_quote_for_eval_result "
1865
# The real first argument should be the name of the installation program.
1866
# Aesthetically quote it.
1867
func_quote_for_eval "$arg"
1868
install_prog="$install_prog$func_quote_for_eval_result"
1870
# We need to accept at least all the BSD install flags.
1880
if test -n "$dest"; then
1881
files="$files $dest"
1889
case " $install_prog " in
1904
# If the previous option needed an argument, then skip it.
1905
if test -n "$prev"; then
1914
# Aesthetically quote the argument.
1915
func_quote_for_eval "$arg"
1916
install_prog="$install_prog $func_quote_for_eval_result"
1919
test -z "$install_prog" && \
1920
func_fatal_help "you must specify an install program"
1922
test -n "$prev" && \
1923
func_fatal_help "the \`$prev' option requires an argument"
1925
if test -z "$files"; then
1926
if test -z "$dest"; then
1927
func_fatal_help "no file or destination specified"
1929
func_fatal_help "you must specify a destination"
1933
# Strip any trailing slash from the destination.
1934
func_stripname '' '/' "$dest"
1935
dest=$func_stripname_result
1937
# Check to see that the destination is a directory.
1938
test -d "$dest" && isdir=yes
1939
if test "$isdir" = yes; then
1943
func_dirname_and_basename "$dest" "" "."
1944
destdir="$func_dirname_result"
1945
destname="$func_basename_result"
1947
# Not a directory, so check to see that there is only one file specified.
1948
set dummy $files; shift
1949
test "$#" -gt 1 && \
1950
func_fatal_help "\`$dest' is not a directory"
1953
[\\/]* | [A-Za-z]:[\\/]*) ;;
1955
for file in $files; do
1959
func_fatal_help "\`$destdir' must be an absolute directory name"
1966
# This variable tells wrapper scripts just to set variables rather
1967
# than running their programs.
1968
libtool_install_magic="$magic"
1973
for file in $files; do
1975
# Do each installation.
1978
# Do the static libraries later.
1979
staticlibs="$staticlibs $file"
1983
# Check to see that this really is a libtool archive.
1984
func_lalib_unsafe_p "$file" \
1985
|| func_fatal_help "\`$file' is not a valid libtool archive"
1992
# Add the libdir to current_libdirs if it is the destination.
1993
if test "X$destdir" = "X$libdir"; then
1994
case "$current_libdirs " in
1996
*) current_libdirs="$current_libdirs $libdir" ;;
1999
# Note the libdir as a future libdir.
2000
case "$future_libdirs " in
2002
*) future_libdirs="$future_libdirs $libdir" ;;
2006
func_dirname "$file" "/" ""
2007
dir="$func_dirname_result"
2010
if test -n "$relink_command"; then
2011
# Determine the prefix the user has applied to our future dir.
2012
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2014
# Don't allow the user to place us outside of our expected
2015
# location b/c this prevents finding dependent libraries that
2016
# are installed to the same prefix.
2017
# At present, this check doesn't affect windows .dll's that
2018
# are installed into $libdir/../bin (currently, that works fine)
2019
# but it's something to keep an eye on.
2020
test "$inst_prefix_dir" = "$destdir" && \
2021
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2023
if test -n "$inst_prefix_dir"; then
2024
# Stick the inst_prefix_dir data into the link command.
2025
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2027
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2030
func_warning "relinking \`$file'"
2031
func_show_eval "$relink_command" \
2032
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2035
# See the names of the shared library.
2036
set dummy $library_names; shift
2037
if test -n "$1"; then
2042
test -n "$relink_command" && srcname="$realname"T
2044
# Install the shared library and build the symlinks.
2045
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2049
cygwin* | mingw* | pw32*)
2057
if test -n "$tstripme" && test -n "$striplib"; then
2058
func_show_eval "$striplib $destdir/$realname" 'exit $?'
2061
if test "$#" -gt 0; then
2062
# Delete the old symlinks, and create new ones.
2063
# Try `ln -sf' first, because the `ln' binary might depend on
2064
# the symlink we replace! Solaris /bin/ln does not understand -f,
2065
# so we also need to try rm && ln -s.
2068
test "$linkname" != "$realname" \
2069
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2073
# Do each command in the postinstall commands.
2074
lib="$destdir/$realname"
2075
func_execute_cmds "$postinstall_cmds" 'exit $?'
2078
# Install the pseudo-library for information purposes.
2079
func_basename "$file"
2080
name="$func_basename_result"
2081
instname="$dir/$name"i
2082
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2084
# Maybe install the static library, too.
2085
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2089
# Install (i.e. copy) a libtool object.
2091
# Figure out destination file name, if it wasn't already specified.
2092
if test -n "$destname"; then
2093
destfile="$destdir/$destname"
2095
func_basename "$file"
2096
destfile="$func_basename_result"
2097
destfile="$destdir/$destfile"
2100
# Deduce the name of the destination old-style object file.
2103
func_lo2o "$destfile"
2104
staticdest=$func_lo2o_result
2107
staticdest="$destfile"
2111
func_fatal_help "cannot copy a libtool object to \`$destfile'"
2115
# Install the libtool object if requested.
2116
test -n "$destfile" && \
2117
func_show_eval "$install_prog $file $destfile" 'exit $?'
2119
# Install the old object if enabled.
2120
if test "$build_old_libs" = yes; then
2121
# Deduce the name of the old-style object file.
2123
staticobj=$func_lo2o_result
2124
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2130
# Figure out destination file name, if it wasn't already specified.
2131
if test -n "$destname"; then
2132
destfile="$destdir/$destname"
2134
func_basename "$file"
2135
destfile="$func_basename_result"
2136
destfile="$destdir/$destfile"
2139
# If the file is missing, and there is a .exe on the end, strip it
2140
# because it is most likely a libtool script we actually want to
2145
if test ! -f "$file"; then
2146
func_stripname '' '.exe' "$file"
2147
file=$func_stripname_result
2153
# Do a test to see if this is really a libtool program.
2156
if func_ltwrapper_executable_p "$file"; then
2157
func_ltwrapper_scriptname "$file"
2158
wrapper=$func_ltwrapper_scriptname_result
2160
func_stripname '' '.exe' "$file"
2161
wrapper=$func_stripname_result
2168
if func_ltwrapper_script_p "$wrapper"; then
2172
func_source "$wrapper"
2174
# Check the variables that should have been set.
2175
test -z "$generated_by_libtool_version" && \
2176
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2179
for lib in $notinst_deplibs; do
2180
# Check to see that each library is installed.
2182
if test -f "$lib"; then
2185
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2186
if test -n "$libdir" && test ! -f "$libfile"; then
2187
func_warning "\`$lib' has not been installed in \`$libdir'"
2193
func_source "$wrapper"
2196
if test "$fast_install" = no && test -n "$relink_command"; then
2198
if test "$finalize" = yes; then
2199
tmpdir=`func_mktempdir`
2200
func_basename "$file$stripped_ext"
2201
file="$func_basename_result"
2202
outputname="$tmpdir/$file"
2203
# Replace the output file specification.
2204
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2207
func_quote_for_expand "$relink_command"
2208
eval "func_echo $func_quote_for_expand_result"
2210
if eval "$relink_command"; then :
2212
func_error "error: relink \`$file' with the above command before installing it"
2213
$opt_dry_run || ${RM}r "$tmpdir"
2218
func_warning "cannot relink \`$file'"
2222
# Install the binary that we compiled earlier.
2223
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2227
# remove .exe since cygwin /usr/bin/install will append another
2229
case $install_prog,$host in
2230
*/usr/bin/install*,*cygwin*)
2231
case $file:$destfile in
2236
destfile=$destfile.exe
2239
func_stripname '' '.exe' "$destfile"
2240
destfile=$func_stripname_result
2245
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2246
$opt_dry_run || if test -n "$outputname"; then
2253
for file in $staticlibs; do
2254
func_basename "$file"
2255
name="$func_basename_result"
2257
# Set up the ranlib parameters.
2258
oldlib="$destdir/$name"
2260
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2262
if test -n "$stripme" && test -n "$old_striplib"; then
2263
func_show_eval "$old_striplib $oldlib" 'exit $?'
2266
# Do each command in the postinstall commands.
2267
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2270
test -n "$future_libdirs" && \
2271
func_warning "remember to run \`$progname --finish$future_libdirs'"
2273
if test -n "$current_libdirs"; then
2274
# Maybe just do a dry run.
2275
$opt_dry_run && current_libdirs=" -n$current_libdirs"
2276
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2282
test "$mode" = install && func_mode_install ${1+"$@"}
2285
# func_generate_dlsyms outputname originator pic_p
2286
# Extract symbols from dlprefiles and create ${outputname}S.o with
2287
# a dlpreopen symbol table.
2288
func_generate_dlsyms ()
2294
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2297
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2298
if test -n "$NM" && test -n "$global_symbol_pipe"; then
2299
my_dlsyms="${my_outputname}S.c"
2301
func_error "not configured to extract global symbols from dlpreopened files"
2305
if test -n "$my_dlsyms"; then
2309
# Discover the nlist of each of the dlfiles.
2310
nlist="$output_objdir/${my_outputname}.nm"
2312
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2314
# Parse the name list into a source file.
2315
func_verbose "creating $output_objdir/$my_dlsyms"
2317
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2318
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2319
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2325
/* External symbol declarations for the compiler. */\
2328
if test "$dlself" = yes; then
2329
func_verbose "generating symbol list for \`$output'"
2331
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2333
# Add our own program objects to the symbol list.
2334
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2335
for progfile in $progfiles; do
2336
func_verbose "extracting global C symbols from \`$progfile'"
2337
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2340
if test -n "$exclude_expsyms"; then
2342
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2343
eval '$MV "$nlist"T "$nlist"'
2347
if test -n "$export_symbols_regex"; then
2349
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2350
eval '$MV "$nlist"T "$nlist"'
2354
# Prepare the list of exported symbols
2355
if test -z "$export_symbols"; then
2356
export_symbols="$output_objdir/$outputname.exp"
2359
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2361
*cygwin* | *mingw* )
2362
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2363
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2369
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2370
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2371
eval '$MV "$nlist"T "$nlist"'
2374
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2375
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2382
for dlprefile in $dlprefiles; do
2383
func_verbose "extracting global C symbols from \`$dlprefile'"
2384
func_basename "$dlprefile"
2385
name="$func_basename_result"
2387
eval '$ECHO ": $name " >> "$nlist"'
2388
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2393
# Make sure we have at least an empty file.
2394
test -f "$nlist" || : > "$nlist"
2396
if test -n "$exclude_expsyms"; then
2397
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2398
$MV "$nlist"T "$nlist"
2401
# Try sorting and uniquifying the output.
2402
if $GREP -v "^: " < "$nlist" |
2403
if sort -k 3 </dev/null >/dev/null 2>&1; then
2408
uniq > "$nlist"S; then
2411
$GREP -v "^: " < "$nlist" > "$nlist"S
2414
if test -f "$nlist"S; then
2415
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2417
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2420
$ECHO >> "$output_objdir/$my_dlsyms" "\
2422
/* The mapping between symbol names and symbols. */
2429
*cygwin* | *mingw* )
2430
$ECHO >> "$output_objdir/$my_dlsyms" "\
2431
/* DATA imports from DLLs on WIN32 con't be const, because
2432
runtime relocations are performed -- see ld's documentation
2433
on pseudo-relocs. */"
2436
echo >> "$output_objdir/$my_dlsyms" "\
2437
/* This system does not cope well with relocations in const data */"
2440
lt_dlsym_const=const ;;
2443
$ECHO >> "$output_objdir/$my_dlsyms" "\
2444
extern $lt_dlsym_const lt_dlsymlist
2445
lt_${my_prefix}_LTX_preloaded_symbols[];
2446
$lt_dlsym_const lt_dlsymlist
2447
lt_${my_prefix}_LTX_preloaded_symbols[] =
2449
{ \"$my_originator\", (void *) 0 },"
2451
case $need_lib_prefix in
2453
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2456
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2459
$ECHO >> "$output_objdir/$my_dlsyms" "\
2463
/* This works around a problem in FreeBSD linker */
2464
#ifdef FREEBSD_WORKAROUND
2465
static const void *lt_preloaded_setup() {
2466
return lt_${my_prefix}_LTX_preloaded_symbols;
2476
pic_flag_for_symtable=
2477
case "$compile_command " in
2481
# compiling the symbol table file with pic_flag works around
2482
# a FreeBSD bug that causes programs to crash when -lm is
2483
# linked before any other PIC object. But we must not use
2484
# pic_flag when linking with -static. The problem exists in
2485
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2486
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2487
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2489
pic_flag_for_symtable=" $pic_flag" ;;
2491
if test "X$my_pic_p" != Xno; then
2492
pic_flag_for_symtable=" $pic_flag"
2499
for arg in $LTCFLAGS; do
2501
-pie | -fpie | -fPIE) ;;
2502
*) symtab_cflags="$symtab_cflags $arg" ;;
2506
# Now compile the dynamic symbol file.
2507
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2509
# Clean up the generated files.
2510
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2512
# Transform the symbol file into the correct name.
2513
symfileobj="$output_objdir/${my_outputname}S.$objext"
2515
*cygwin* | *mingw* )
2516
if test -f "$output_objdir/$my_outputname.def"; then
2517
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2518
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2520
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2521
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2525
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2526
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2531
func_fatal_error "unknown suffix for \`$my_dlsyms'"
2535
# We keep going just in case the user didn't refer to
2536
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2537
# really was required.
2539
# Nullify the symbol file.
2540
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2541
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2545
# func_win32_libid arg
2546
# return the library type of file 'arg'
2548
# Need a lot of goo to handle *both* DLLs and import libs
2549
# Has to be a shell function in order to 'eat' the argument
2550
# that is supplied when $file_magic_command is called.
2554
win32_libid_type="unknown"
2555
win32_fileres=`file -L $1 2>/dev/null`
2556
case $win32_fileres in
2557
*ar\ archive\ import\ library*) # definitely import
2558
win32_libid_type="x86 archive import"
2560
*ar\ archive*) # could be an import, or static
2561
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2562
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2563
win32_nmres=`eval $NM -f posix -A $1 |
2572
case $win32_nmres in
2573
import*) win32_libid_type="x86 archive import";;
2574
*) win32_libid_type="x86 archive static";;
2579
win32_libid_type="x86 DLL"
2581
*executable*) # but shell scripts are "executable" too...
2582
case $win32_fileres in
2583
*MS\ Windows\ PE\ Intel*)
2584
win32_libid_type="x86 DLL"
2589
$ECHO "$win32_libid_type"
2594
# func_extract_an_archive dir oldlib
2595
func_extract_an_archive ()
2598
f_ex_an_ar_dir="$1"; shift
2599
f_ex_an_ar_oldlib="$1"
2600
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2601
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2604
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2609
# func_extract_archives gentop oldlib ...
2610
func_extract_archives ()
2613
my_gentop="$1"; shift
2614
my_oldlibs=${1+"$@"}
2620
for my_xlib in $my_oldlibs; do
2621
# Extract the objects.
2623
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2624
*) my_xabs=`pwd`"/$my_xlib" ;;
2626
func_basename "$my_xlib"
2627
my_xlib="$func_basename_result"
2630
case " $extracted_archives " in
2632
func_arith $extracted_serial + 1
2633
extracted_serial=$func_arith_result
2634
my_xlib_u=lt$extracted_serial-$my_xlib ;;
2638
extracted_archives="$extracted_archives $my_xlib_u"
2639
my_xdir="$my_gentop/$my_xlib_u"
2641
func_mkdir_p "$my_xdir"
2645
func_verbose "Extracting $my_xabs"
2646
# Do not bother doing anything if just a dry run
2648
darwin_orig_dir=`pwd`
2649
cd $my_xdir || exit $?
2650
darwin_archive=$my_xabs
2652
darwin_base_archive=`basename "$darwin_archive"`
2653
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2654
if test -n "$darwin_arches"; then
2655
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2657
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2658
for darwin_arch in $darwin_arches ; do
2659
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2660
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2661
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2662
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2664
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2665
done # $darwin_arches
2666
## Okay now we've a bunch of thin objects, gotta fatten them up :)
2667
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2670
for darwin_file in $darwin_filelist; do
2671
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2672
$LIPO -create -output "$darwin_file" $darwin_files
2673
done # $darwin_filelist
2675
cd "$darwin_orig_dir"
2678
func_extract_an_archive "$my_xdir" "$my_xabs"
2683
func_extract_an_archive "$my_xdir" "$my_xabs"
2686
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2689
func_extract_archives_result="$my_oldobjs"
2694
# func_emit_wrapper arg
2696
# emit a libtool wrapper script on stdout
2697
# don't directly open a file because we may want to
2698
# incorporate the script contents within a cygwin/mingw
2699
# wrapper executable. Must ONLY be called from within
2700
# func_mode_link because it depends on a number of variable
2703
# arg is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2704
# variable will take. If 'yes', then the emitted script
2705
# will assume that the directory in which it is stored is
2706
# the '.lib' directory. This is a cygwin/mingw-specific
2708
func_emit_wrapper ()
2710
func_emit_wrapper_arg1=no
2711
if test -n "$1" ; then
2712
func_emit_wrapper_arg1=$1
2718
# $output - temporary wrapper script for $objdir/$outputname
2719
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2721
# The $output program cannot be directly executed until all the libtool
2722
# libraries that it depends on are installed.
2724
# This wrapper script should never be moved out of the build directory.
2725
# If it is, it will not operate correctly.
2727
# Sed substitution that helps us do robust quoting. It backslashifies
2728
# metacharacters that are still active within double-quoted strings.
2729
Xsed='${SED} -e 1s/^X//'
2730
sed_quote_subst='$sed_quote_subst'
2732
# Be Bourne compatible
2733
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2736
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2737
# is contrary to our usage. Disable this feature.
2738
alias -g '\${1+\"\$@\"}'='\"\$@\"'
2739
setopt NO_GLOB_SUBST
2741
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2743
BIN_SH=xpg4; export BIN_SH # for Tru64
2744
DUALCASE=1; export DUALCASE # for MKS sh
2746
# The HP-UX ksh and POSIX shell print the target directory to stdout
2748
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2750
relink_command=\"$relink_command\"
2752
# This environment variable determines our operation mode.
2753
if test \"\$libtool_install_magic\" = \"$magic\"; then
2754
# install mode needs the following variables:
2755
generated_by_libtool_version='$macro_version'
2756
notinst_deplibs='$notinst_deplibs'
2758
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2759
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2762
# Make sure echo works.
2763
if test \"X\$1\" = X--no-reexec; then
2764
# Discard the --no-reexec flag, and continue.
2766
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2767
# Yippee, \$ECHO works!
2770
# Restart under the correct shell, and then maybe \$ECHO will work.
2771
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2777
# Find the directory that this script lives in.
2778
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2779
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2781
# Follow symbolic links until we get to the real thisdir.
2782
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2783
while test -n \"\$file\"; do
2784
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2786
# If there was a directory component, then change thisdir.
2787
if test \"x\$destdir\" != \"x\$file\"; then
2788
case \"\$destdir\" in
2789
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2790
*) thisdir=\"\$thisdir/\$destdir\" ;;
2794
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2795
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2798
# Usually 'no', except on cygwin/mingw when embedded into
2800
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
2801
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2802
# special case for '.'
2803
if test \"\$thisdir\" = \".\"; then
2806
# remove .libs from thisdir
2807
case \"\$thisdir\" in
2808
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2809
$objdir ) thisdir=. ;;
2813
# Try to get the absolute directory name.
2814
absdir=\`cd \"\$thisdir\" && pwd\`
2815
test -n \"\$absdir\" && thisdir=\"\$absdir\"
2818
if test "$fast_install" = yes; then
2820
program=lt-'$outputname'$exeext
2821
progdir=\"\$thisdir/$objdir\"
2823
if test ! -f \"\$progdir/\$program\" ||
2824
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2825
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2827
file=\"\$\$-\$program\"
2829
if test ! -d \"\$progdir\"; then
2830
$MKDIR \"\$progdir\"
2832
$RM \"\$progdir/\$file\"
2837
# relink executable if necessary
2838
if test -n \"\$relink_command\"; then
2839
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2841
$ECHO \"\$relink_command_output\" >&2
2842
$RM \"\$progdir/\$file\"
2847
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2848
{ $RM \"\$progdir/\$program\";
2849
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2850
$RM \"\$progdir/\$file\"
2854
program='$outputname'
2855
progdir=\"\$thisdir/$objdir\"
2861
if test -f \"\$progdir/\$program\"; then"
2863
# Export our shlibpath_var if we have one.
2864
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2866
# Add our own library path to $shlibpath_var
2867
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2869
# Some systems cannot cope with colon-terminated $shlibpath_var
2870
# The second colon is a workaround for a bug in BeOS R4 sed
2871
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2873
export $shlibpath_var
2877
# fixup the dll searchpath if we need to.
2878
if test -n "$dllsearchpath"; then
2880
# Add the dll search path components to the executable PATH
2881
PATH=$dllsearchpath:\$PATH
2886
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2887
# Run the actual program with our arguments.
2890
# Backslashes separate directories on plain windows
2891
*-*-mingw | *-*-os2*)
2893
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2899
exec \"\$progdir/\$program\" \${1+\"\$@\"}
2904
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2908
# The program doesn't exist.
2909
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2910
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2911
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2917
# end: func_emit_wrapper
2919
# func_emit_cwrapperexe_src
2920
# emit the source code for a wrapper executable on stdout
2921
# Must ONLY be called from within func_mode_link because
2922
# it depends on a number of variable set therein.
2923
func_emit_cwrapperexe_src ()
2927
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
2928
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2930
The $output program cannot be directly executed until all the libtool
2931
libraries that it depends on are installed.
2933
This wrapper executable should never be moved out of the build directory.
2934
If it is, it will not operate correctly.
2936
Currently, it simply execs the wrapper *script* "$SHELL $output",
2937
but could eventually absorb all of the scripts functionality and
2938
exec $objdir/$outputname directly.
2945
# include <direct.h>
2946
# include <process.h>
2948
# define setmode _setmode
2950
# include <unistd.h>
2951
# include <stdint.h>
2963
#include <sys/stat.h>
2965
#if defined(PATH_MAX)
2966
# define LT_PATHMAX PATH_MAX
2967
#elif defined(MAXPATHLEN)
2968
# define LT_PATHMAX MAXPATHLEN
2970
# define LT_PATHMAX 1024
2981
# define S_IXUSR _S_IEXEC
2983
# ifndef _INTPTR_T_DEFINED
2984
# define intptr_t int
2988
#ifndef DIR_SEPARATOR
2989
# define DIR_SEPARATOR '/'
2990
# define PATH_SEPARATOR ':'
2993
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
2995
# define HAVE_DOS_BASED_FILE_SYSTEM
2996
# define FOPEN_WB "wb"
2997
# ifndef DIR_SEPARATOR_2
2998
# define DIR_SEPARATOR_2 '\\'
3000
# ifndef PATH_SEPARATOR_2
3001
# define PATH_SEPARATOR_2 ';'
3005
#ifndef DIR_SEPARATOR_2
3006
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3007
#else /* DIR_SEPARATOR_2 */
3008
# define IS_DIR_SEPARATOR(ch) \
3009
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3010
#endif /* DIR_SEPARATOR_2 */
3012
#ifndef PATH_SEPARATOR_2
3013
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3014
#else /* PATH_SEPARATOR_2 */
3015
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3016
#endif /* PATH_SEPARATOR_2 */
3019
# define FOPEN_WB "wb"
3023
# define FOPEN_WB "w"
3026
# define _O_BINARY 0
3029
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3030
#define XFREE(stale) do { \
3031
if (stale) { free ((void *) stale); stale = 0; } \
3034
#undef LTWRAPPER_DEBUGPRINTF
3035
#if defined DEBUGWRAPPER
3036
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3038
ltwrapper_debugprintf (const char *fmt, ...)
3041
va_start (args, fmt);
3042
(void) vfprintf (stderr, fmt, args);
3046
# define LTWRAPPER_DEBUGPRINTF(args)
3049
const char *program_name = NULL;
3051
void *xmalloc (size_t num);
3052
char *xstrdup (const char *string);
3053
const char *base_name (const char *name);
3054
char *find_executable (const char *wrapper);
3055
char *chase_symlinks (const char *pathspec);
3056
int make_executable (const char *path);
3057
int check_executable (const char *path);
3058
char *strendzap (char *str, const char *pat);
3059
void lt_fatal (const char *message, ...);
3061
static const char *script_text =
3064
func_emit_wrapper yes |
3065
$SED -e 's/\([\\"]\)/\\\1/g' \
3066
-e 's/^/ "/' -e 's/$/\\n"/'
3070
const char * MAGIC_EXE = "$magic_exe";
3073
main (int argc, char *argv[])
3077
char *actual_cwrapper_path;
3078
char *shwrapper_name;
3079
intptr_t rval = 127;
3082
const char *dumpscript_opt = "--lt-dump-script";
3085
program_name = (char *) xstrdup (base_name (argv[0]));
3086
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3087
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3089
/* very simple arg parsing; don't want to rely on getopt */
3090
for (i = 1; i < argc; i++)
3092
if (strcmp (argv[i], dumpscript_opt) == 0)
3096
*mingw* | *cygwin* )
3097
# make stdout use "unix" line endings
3098
echo " setmode(1,_O_BINARY);"
3103
printf ("%s", script_text);
3108
newargz = XMALLOC (char *, argc + 2);
3111
if test -n "$TARGETSHELL" ; then
3112
# no path translation at all
3113
lt_newargv0=$TARGETSHELL
3117
# awkward: cmd appends spaces to result
3118
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3119
lt_newargv0=`( cmd //c echo $SHELL | $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo $SHELL`
3120
case $lt_newargv0 in
3122
*) lt_newargv0=$lt_newargv0.exe ;;
3125
* ) lt_newargv0=$SHELL ;;
3130
newargz[0] = (char *) xstrdup ("$lt_newargv0");
3134
tmp_pathspec = find_executable (argv[0]);
3135
if (tmp_pathspec == NULL)
3136
lt_fatal ("Couldn't find %s", argv[0]);
3137
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3140
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3141
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3142
actual_cwrapper_path));
3143
XFREE (tmp_pathspec);
3145
shwrapper_name = (char *) xstrdup (base_name (actual_cwrapper_path));
3146
strendzap (actual_cwrapper_path, shwrapper_name);
3148
/* shwrapper_name transforms */
3149
strendzap (shwrapper_name, ".exe");
3150
tmp_pathspec = XMALLOC (char, (strlen (shwrapper_name) +
3151
strlen ("_ltshwrapperTMP") + 1));
3152
strcpy (tmp_pathspec, shwrapper_name);
3153
strcat (tmp_pathspec, "_ltshwrapperTMP");
3154
XFREE (shwrapper_name);
3155
shwrapper_name = tmp_pathspec;
3157
LTWRAPPER_DEBUGPRINTF (("(main) libtool shell wrapper name: %s\n",
3163
XMALLOC (char, (strlen (actual_cwrapper_path) +
3164
strlen ("$objdir") + 1 + strlen (shwrapper_name) + 1));
3165
strcpy (newargz[1], actual_cwrapper_path);
3166
strcat (newargz[1], "$objdir");
3167
strcat (newargz[1], "/");
3168
strcat (newargz[1], shwrapper_name);
3177
while ((p = strchr (newargz[1], '\\')) != NULL)
3187
XFREE (shwrapper_name);
3188
XFREE (actual_cwrapper_path);
3190
/* always write in binary mode */
3191
if ((shwrapper = fopen (newargz[1], FOPEN_WB)) == 0)
3193
lt_fatal ("Could not open %s for writing", newargz[1]);
3195
fprintf (shwrapper, "%s", script_text);
3198
make_executable (newargz[1]);
3200
for (i = 1; i < argc; i++)
3201
newargz[i + 1] = xstrdup (argv[i]);
3202
newargz[argc + 1] = NULL;
3204
for (i = 0; i < argc + 1; i++)
3206
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, newargz[i]));
3214
/* execv doesn't actually work on mingw as expected on unix */
3215
rval = _spawnv (_P_WAIT, "$lt_newargv0", (const char * const *) newargz);
3218
/* failed to start process */
3219
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"$lt_newargv0\": errno = %d\n", errno));
3228
execv ("$lt_newargv0", newargz);
3229
return rval; /* =127, but avoids unused variable warning */
3238
xmalloc (size_t num)
3240
void *p = (void *) malloc (num);
3242
lt_fatal ("Memory exhausted");
3248
xstrdup (const char *string)
3250
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3255
base_name (const char *name)
3259
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3260
/* Skip over the disk name in MSDOS pathnames. */
3261
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3265
for (base = name; *name; name++)
3266
if (IS_DIR_SEPARATOR (*name))
3272
check_executable (const char *path)
3276
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3277
path ? (*path ? path : "EMPTY!") : "NULL!"));
3278
if ((!path) || (!*path))
3281
if ((stat (path, &st) >= 0)
3282
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3289
make_executable (const char *path)
3294
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3295
path ? (*path ? path : "EMPTY!") : "NULL!"));
3296
if ((!path) || (!*path))
3299
if (stat (path, &st) >= 0)
3301
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3306
/* Searches for the full path of the wrapper. Returns
3307
newly allocated full path name if found, NULL otherwise
3308
Does not chase symlinks, even on platforms that support them.
3311
find_executable (const char *wrapper)
3316
/* static buffer for getcwd */
3317
char tmp[LT_PATHMAX + 1];
3321
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3322
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3324
if ((wrapper == NULL) || (*wrapper == '\0'))
3327
/* Absolute path? */
3328
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3329
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3331
concat_name = xstrdup (wrapper);
3332
if (check_executable (concat_name))
3334
XFREE (concat_name);
3339
if (IS_DIR_SEPARATOR (wrapper[0]))
3341
concat_name = xstrdup (wrapper);
3342
if (check_executable (concat_name))
3344
XFREE (concat_name);
3346
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3350
for (p = wrapper; *p; p++)
3358
/* no slashes; search PATH */
3359
const char *path = getenv ("PATH");
3362
for (p = path; *p; p = p_next)
3366
for (q = p; *q; q++)
3367
if (IS_PATH_SEPARATOR (*q))
3370
p_next = (*q == '\0' ? q : q + 1);
3373
/* empty path: current directory */
3374
if (getcwd (tmp, LT_PATHMAX) == NULL)
3375
lt_fatal ("getcwd failed");
3376
tmp_len = strlen (tmp);
3378
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3379
memcpy (concat_name, tmp, tmp_len);
3380
concat_name[tmp_len] = '/';
3381
strcpy (concat_name + tmp_len + 1, wrapper);
3386
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3387
memcpy (concat_name, p, p_len);
3388
concat_name[p_len] = '/';
3389
strcpy (concat_name + p_len + 1, wrapper);
3391
if (check_executable (concat_name))
3393
XFREE (concat_name);
3396
/* not found in PATH; assume curdir */
3398
/* Relative path | not found in path: prepend cwd */
3399
if (getcwd (tmp, LT_PATHMAX) == NULL)
3400
lt_fatal ("getcwd failed");
3401
tmp_len = strlen (tmp);
3402
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3403
memcpy (concat_name, tmp, tmp_len);
3404
concat_name[tmp_len] = '/';
3405
strcpy (concat_name + tmp_len + 1, wrapper);
3407
if (check_executable (concat_name))
3409
XFREE (concat_name);
3414
chase_symlinks (const char *pathspec)
3417
return xstrdup (pathspec);
3419
char buf[LT_PATHMAX];
3421
char *tmp_pathspec = xstrdup (pathspec);
3423
int has_symlinks = 0;
3424
while (strlen (tmp_pathspec) && !has_symlinks)
3426
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3428
if (lstat (tmp_pathspec, &s) == 0)
3430
if (S_ISLNK (s.st_mode) != 0)
3436
/* search backwards for last DIR_SEPARATOR */
3437
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3438
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3440
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3442
/* no more DIR_SEPARATORS left */
3449
char *errstr = strerror (errno);
3450
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3453
XFREE (tmp_pathspec);
3457
return xstrdup (pathspec);
3460
tmp_pathspec = realpath (pathspec, buf);
3461
if (tmp_pathspec == 0)
3463
lt_fatal ("Could not follow symlinks for %s", pathspec);
3465
return xstrdup (tmp_pathspec);
3470
strendzap (char *str, const char *pat)
3474
assert (str != NULL);
3475
assert (pat != NULL);
3478
patlen = strlen (pat);
3482
str += len - patlen;
3483
if (strcmp (str, pat) == 0)
3490
lt_error_core (int exit_status, const char *mode,
3491
const char *message, va_list ap)
3493
fprintf (stderr, "%s: %s: ", program_name, mode);
3494
vfprintf (stderr, message, ap);
3495
fprintf (stderr, ".\n");
3497
if (exit_status >= 0)
3502
lt_fatal (const char *message, ...)
3505
va_start (ap, message);
3506
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3511
# end: func_emit_cwrapperexe_src
3513
# func_mode_link arg...
3518
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3519
# It is impossible to link a dll without this setting, and
3520
# we shouldn't force the makefile maintainer to figure out
3521
# which system we are compiling for in order to pass an extra
3522
# flag for every libtool invocation.
3523
# allow_undefined=no
3525
# FIXME: Unfortunately, there are problems with the above when trying
3526
# to make a dll which has undefined symbols, in which case not
3527
# even a static library is built. For now, we need to specify
3528
# -no-undefined on the libtool link line when we can be certain
3529
# that all symbols are satisfied, otherwise we get a static library.
3536
libtool_args=$nonopt
3537
base_compile="$nonopt $@"
3538
compile_command=$nonopt
3539
finalize_command=$nonopt
3552
lib_search_path=`pwd`
3554
new_inherited_linker_flags=
3562
export_symbols_regex=
3570
precious_files_regex=
3571
prefer_static_libs=no
3584
single_module="${wl}-single_module"
3585
func_infer_tag $base_compile
3587
# We need to know -static, to get the right output filenames.
3592
test "$build_libtool_libs" != yes && \
3593
func_fatal_configuration "can not build a shared library"
3597
-all-static | -static | -static-libtool-libs)
3600
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
3601
func_warning "complete static linking is impossible in this configuration"
3603
if test -n "$link_static_flag"; then
3604
dlopen_self=$dlopen_self_static
3606
prefer_static_libs=yes
3609
if test -z "$pic_flag" && test -n "$link_static_flag"; then
3610
dlopen_self=$dlopen_self_static
3612
prefer_static_libs=built
3614
-static-libtool-libs)
3615
if test -z "$pic_flag" && test -n "$link_static_flag"; then
3616
dlopen_self=$dlopen_self_static
3618
prefer_static_libs=yes
3621
build_libtool_libs=no
3628
# See if our shared archives depend on static archives.
3629
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
3631
# Go through the arguments, transforming them on the way.
3632
while test "$#" -gt 0; do
3635
func_quote_for_eval "$arg"
3636
qarg=$func_quote_for_eval_unquoted_result
3637
func_append libtool_args " $func_quote_for_eval_result"
3639
# If the previous option needs an argument, assign it.
3640
if test -n "$prev"; then
3643
func_append compile_command " @OUTPUT@"
3644
func_append finalize_command " @OUTPUT@"
3650
if test "$preload" = no; then
3651
# Add the symbol object into the linking commands.
3652
func_append compile_command " @SYMFILE@"
3653
func_append finalize_command " @SYMFILE@"
3657
*.la | *.lo) ;; # We handle these cases below.
3659
if test "$dlself" = no; then
3667
if test "$prev" = dlprefiles; then
3669
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
3679
if test "$prev" = dlfiles; then
3680
dlfiles="$dlfiles $arg"
3682
dlprefiles="$dlprefiles $arg"
3690
export_symbols="$arg"
3692
|| func_fatal_error "symbol file \`$arg' does not exist"
3697
export_symbols_regex="$arg"
3705
*" $qarg.ltframework "*) ;;
3706
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
3715
inst_prefix_dir="$arg"
3720
if test -f "$arg"; then
3723
for fil in `cat "$save_arg"`
3725
# moreargs="$moreargs $fil"
3727
# A libtool-controlled object.
3729
# Check to see that this really is a libtool object.
3730
if func_lalib_unsafe_p "$arg"; then
3737
if test -z "$pic_object" ||
3738
test -z "$non_pic_object" ||
3739
test "$pic_object" = none &&
3740
test "$non_pic_object" = none; then
3741
func_fatal_error "cannot find name of object for \`$arg'"
3744
# Extract subdirectory from the argument.
3745
func_dirname "$arg" "/" ""
3746
xdir="$func_dirname_result"
3748
if test "$pic_object" != none; then
3749
# Prepend the subdirectory the object is found in.
3750
pic_object="$xdir$pic_object"
3752
if test "$prev" = dlfiles; then
3753
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
3754
dlfiles="$dlfiles $pic_object"
3758
# If libtool objects are unsupported, then we need to preload.
3763
# CHECK ME: I think I busted this. -Ossama
3764
if test "$prev" = dlprefiles; then
3765
# Preload the old-style object.
3766
dlprefiles="$dlprefiles $pic_object"
3771
func_append libobjs " $pic_object"
3776
if test "$non_pic_object" != none; then
3777
# Prepend the subdirectory the object is found in.
3778
non_pic_object="$xdir$non_pic_object"
3780
# A standard non-PIC object
3781
func_append non_pic_objects " $non_pic_object"
3782
if test -z "$pic_object" || test "$pic_object" = none ; then
3783
arg="$non_pic_object"
3786
# If the PIC object exists, use it instead.
3787
# $xdir was prepended to $pic_object above.
3788
non_pic_object="$pic_object"
3789
func_append non_pic_objects " $non_pic_object"
3792
# Only an error if not doing a dry-run.
3793
if $opt_dry_run; then
3794
# Extract subdirectory from the argument.
3795
func_dirname "$arg" "/" ""
3796
xdir="$func_dirname_result"
3799
pic_object=$xdir$objdir/$func_lo2o_result
3800
non_pic_object=$xdir$func_lo2o_result
3801
func_append libobjs " $pic_object"
3802
func_append non_pic_objects " $non_pic_object"
3804
func_fatal_error "\`$arg' is not a valid libtool object"
3809
func_fatal_error "link input file \`$arg' does not exist"
3816
precious_files_regex="$arg"
3826
# We need an absolute path.
3828
[\\/]* | [A-Za-z]:[\\/]*) ;;
3830
func_fatal_error "only absolute run-paths are allowed"
3833
if test "$prev" = rpath; then
3836
*) rpath="$rpath $arg" ;;
3841
*) xrpath="$xrpath $arg" ;;
3853
weak_libs="$weak_libs $arg"
3858
linker_flags="$linker_flags $qarg"
3859
compiler_flags="$compiler_flags $qarg"
3861
func_append compile_command " $qarg"
3862
func_append finalize_command " $qarg"
3866
compiler_flags="$compiler_flags $qarg"
3868
func_append compile_command " $qarg"
3869
func_append finalize_command " $qarg"
3873
linker_flags="$linker_flags $qarg"
3874
compiler_flags="$compiler_flags $wl$qarg"
3876
func_append compile_command " $wl$qarg"
3877
func_append finalize_command " $wl$qarg"
3881
eval "$prev=\"\$arg\""
3886
fi # test -n "$prev"
3892
if test -n "$link_static_flag"; then
3893
# See comment for -static flag below, for more details.
3894
func_append compile_command " $link_static_flag"
3895
func_append finalize_command " $link_static_flag"
3901
# FIXME: remove this flag sometime in the future.
3902
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
3925
-export-symbols | -export-symbols-regex)
3926
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3927
func_fatal_error "more than one -exported-symbols argument is not allowed"
3929
if test "X$arg" = "X-export-symbols"; then
3947
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
3948
# so, if we see these flags be careful not to treat them like -L
3950
case $with_gcc/$host in
3951
no/*-*-irix* | /*-*-irix*)
3952
func_append compile_command " $arg"
3953
func_append finalize_command " $arg"
3960
func_stripname '-L' '' "$arg"
3961
dir=$func_stripname_result
3962
# We need an absolute path.
3964
[\\/]* | [A-Za-z]:[\\/]*) ;;
3966
absdir=`cd "$dir" && pwd`
3967
test -z "$absdir" && \
3968
func_fatal_error "cannot determine absolute directory name of \`$dir'"
3975
deplibs="$deplibs -L$dir"
3976
lib_search_path="$lib_search_path $dir"
3980
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3981
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
3982
case :$dllsearchpath: in
3984
*) dllsearchpath="$dllsearchpath:$dir";;
3986
case :$dllsearchpath: in
3987
*":$testbindir:"*) ;;
3988
*) dllsearchpath="$dllsearchpath:$testbindir";;
3996
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
3998
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
3999
# These systems don't actually have a C or math library (as such)
4003
# These systems don't actually have a C library (as such)
4004
test "X$arg" = "X-lc" && continue
4006
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4007
# Do not include libc due to us having libc/libc_r.
4008
test "X$arg" = "X-lc" && continue
4010
*-*-rhapsody* | *-*-darwin1.[012])
4011
# Rhapsody C and math libraries are in the System framework
4012
deplibs="$deplibs System.ltframework"
4015
*-*-sco3.2v5* | *-*-sco5v6*)
4016
# Causes problems with __ctype
4017
test "X$arg" = "X-lc" && continue
4019
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4020
# Compiler inserts libc in the correct place for threads to work
4021
test "X$arg" = "X-lc" && continue
4024
elif test "X$arg" = "X-lc_r"; then
4026
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4027
# Do not include libc_r directly, use -pthread flag.
4032
deplibs="$deplibs $arg"
4041
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4042
# classes, name mangling, and exception handling.
4043
# Darwin uses the -arch flag to determine output architecture.
4044
-model|-arch|-isysroot)
4045
compiler_flags="$compiler_flags $arg"
4046
func_append compile_command " $arg"
4047
func_append finalize_command " $arg"
4052
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4053
compiler_flags="$compiler_flags $arg"
4054
func_append compile_command " $arg"
4055
func_append finalize_command " $arg"
4056
case "$new_inherited_linker_flags " in
4058
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4064
single_module="${wl}-multi_module"
4075
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
4076
# The PATH hackery in wrapper scripts is required on Windows
4077
# and Darwin in order for the loader to find any dlls it needs.
4078
func_warning "\`-no-install' is ignored for $host"
4079
func_warning "assuming \`-no-fast-install' instead"
4082
*) no_install=yes ;;
4099
-precious-files-regex)
4120
func_stripname '-R' '' "$arg"
4121
dir=$func_stripname_result
4122
# We need an absolute path.
4124
[\\/]* | [A-Za-z]:[\\/]*) ;;
4126
func_fatal_error "only absolute run-paths are allowed"
4131
*) xrpath="$xrpath $dir" ;;
4137
# The effects of -shared are defined in a previous loop.
4146
-static | -static-libtool-libs)
4147
# The effects of -static are defined in a previous loop.
4148
# We used to do the same as -all-static on platforms that
4149
# didn't have a PIC flag, but the assumption that the effects
4150
# would be equivalent was wrong. It would break on at least
4151
# Digital Unix and AIX.
4177
func_stripname '-Wc,' '' "$arg"
4178
args=$func_stripname_result
4180
save_ifs="$IFS"; IFS=','
4181
for flag in $args; do
4183
func_quote_for_eval "$flag"
4184
arg="$arg $wl$func_quote_for_eval_result"
4185
compiler_flags="$compiler_flags $func_quote_for_eval_result"
4188
func_stripname ' ' '' "$arg"
4189
arg=$func_stripname_result
4193
func_stripname '-Wl,' '' "$arg"
4194
args=$func_stripname_result
4196
save_ifs="$IFS"; IFS=','
4197
for flag in $args; do
4199
func_quote_for_eval "$flag"
4200
arg="$arg $wl$func_quote_for_eval_result"
4201
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4202
linker_flags="$linker_flags $func_quote_for_eval_result"
4205
func_stripname ' ' '' "$arg"
4206
arg=$func_stripname_result
4226
func_quote_for_eval "$arg"
4227
arg="$func_quote_for_eval_result"
4230
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4231
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4232
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4233
# +DA*, +DD* enable 64-bit mode on the HP compiler
4234
# -q* pass through compiler args for the IBM compiler
4235
# -m*, -t[45]*, -txscale* pass through architecture-specific
4236
# compiler args for GCC
4237
# -F/path gives path to uninstalled frameworks, gcc on darwin
4238
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4239
# @file GCC response files
4240
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4241
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4242
func_quote_for_eval "$arg"
4243
arg="$func_quote_for_eval_result"
4244
func_append compile_command " $arg"
4245
func_append finalize_command " $arg"
4246
compiler_flags="$compiler_flags $arg"
4250
# Some other compiler flag.
4252
func_quote_for_eval "$arg"
4253
arg="$func_quote_for_eval_result"
4257
# A standard object.
4262
# A libtool-controlled object.
4264
# Check to see that this really is a libtool object.
4265
if func_lalib_unsafe_p "$arg"; then
4272
if test -z "$pic_object" ||
4273
test -z "$non_pic_object" ||
4274
test "$pic_object" = none &&
4275
test "$non_pic_object" = none; then
4276
func_fatal_error "cannot find name of object for \`$arg'"
4279
# Extract subdirectory from the argument.
4280
func_dirname "$arg" "/" ""
4281
xdir="$func_dirname_result"
4283
if test "$pic_object" != none; then
4284
# Prepend the subdirectory the object is found in.
4285
pic_object="$xdir$pic_object"
4287
if test "$prev" = dlfiles; then
4288
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4289
dlfiles="$dlfiles $pic_object"
4293
# If libtool objects are unsupported, then we need to preload.
4298
# CHECK ME: I think I busted this. -Ossama
4299
if test "$prev" = dlprefiles; then
4300
# Preload the old-style object.
4301
dlprefiles="$dlprefiles $pic_object"
4306
func_append libobjs " $pic_object"
4311
if test "$non_pic_object" != none; then
4312
# Prepend the subdirectory the object is found in.
4313
non_pic_object="$xdir$non_pic_object"
4315
# A standard non-PIC object
4316
func_append non_pic_objects " $non_pic_object"
4317
if test -z "$pic_object" || test "$pic_object" = none ; then
4318
arg="$non_pic_object"
4321
# If the PIC object exists, use it instead.
4322
# $xdir was prepended to $pic_object above.
4323
non_pic_object="$pic_object"
4324
func_append non_pic_objects " $non_pic_object"
4327
# Only an error if not doing a dry-run.
4328
if $opt_dry_run; then
4329
# Extract subdirectory from the argument.
4330
func_dirname "$arg" "/" ""
4331
xdir="$func_dirname_result"
4334
pic_object=$xdir$objdir/$func_lo2o_result
4335
non_pic_object=$xdir$func_lo2o_result
4336
func_append libobjs " $pic_object"
4337
func_append non_pic_objects " $non_pic_object"
4339
func_fatal_error "\`$arg' is not a valid libtool object"
4346
deplibs="$deplibs $arg"
4347
old_deplibs="$old_deplibs $arg"
4352
# A libtool-controlled library.
4354
if test "$prev" = dlfiles; then
4355
# This library was specified with -dlopen.
4356
dlfiles="$dlfiles $arg"
4358
elif test "$prev" = dlprefiles; then
4359
# The library was specified with -dlpreopen.
4360
dlprefiles="$dlprefiles $arg"
4363
deplibs="$deplibs $arg"
4368
# Some other compiler argument.
4370
# Unknown arguments in both finalize_command and compile_command need
4371
# to be aesthetically quoted because they are evaled later.
4372
func_quote_for_eval "$arg"
4373
arg="$func_quote_for_eval_result"
4377
# Now actually substitute the argument into the commands.
4378
if test -n "$arg"; then
4379
func_append compile_command " $arg"
4380
func_append finalize_command " $arg"
4382
done # argument parsing loop
4384
test -n "$prev" && \
4385
func_fatal_help "the \`$prevarg' option requires an argument"
4387
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4388
eval arg=\"$export_dynamic_flag_spec\"
4389
func_append compile_command " $arg"
4390
func_append finalize_command " $arg"
4394
# calculate the name of the file, without its directory
4395
func_basename "$output"
4396
outputname="$func_basename_result"
4397
libobjs_save="$libobjs"
4399
if test -n "$shlibpath_var"; then
4400
# get the directories listed in $shlibpath_var
4401
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4405
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4406
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4408
func_dirname "$output" "/" ""
4409
output_objdir="$func_dirname_result$objdir"
4410
# Create the object directory.
4411
func_mkdir_p "$output_objdir"
4413
# Determine the type of output
4416
func_fatal_help "you must specify an output file"
4418
*.$libext) linkmode=oldlib ;;
4419
*.lo | *.$objext) linkmode=obj ;;
4420
*.la) linkmode=lib ;;
4421
*) linkmode=prog ;; # Anything else should be a program.
4427
# Find all interdependent deplibs by searching for libraries
4428
# that are linked more than once (e.g. -la -lb -la)
4429
for deplib in $deplibs; do
4430
if $opt_duplicate_deps ; then
4432
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4435
libs="$libs $deplib"
4438
if test "$linkmode" = lib; then
4439
libs="$predeps $libs $compiler_lib_search_path $postdeps"
4441
# Compute libraries that are listed more than once in $predeps
4442
# $postdeps and mark them as special (i.e., whose duplicates are
4443
# not to be eliminated).
4445
if $opt_duplicate_compiler_generated_deps; then
4446
for pre_post_dep in $predeps $postdeps; do
4447
case "$pre_post_deps " in
4448
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4450
pre_post_deps="$pre_post_deps $pre_post_dep"
4459
need_relink=no # whether we're linking any uninstalled libtool libraries
4460
notinst_deplibs= # not-installed libtool libraries
4461
notinst_path= # paths that contain not-installed libtool libraries
4465
passes="conv dlpreopen link"
4466
for file in $dlfiles $dlprefiles; do
4470
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
4481
passes="conv scan dlopen dlpreopen link"
4487
for pass in $passes; do
4488
# The preopen pass in lib mode reverses $deplibs; put it back here
4489
# so that -L comes before libs that need it for instance...
4490
if test "$linkmode,$pass" = "lib,link"; then
4491
## FIXME: Find the place where the list is rebuilt in the wrong
4492
## order, and fix it there properly
4494
for deplib in $deplibs; do
4495
tmp_deplibs="$deplib $tmp_deplibs"
4497
deplibs="$tmp_deplibs"
4500
if test "$linkmode,$pass" = "lib,link" ||
4501
test "$linkmode,$pass" = "prog,scan"; then
4505
if test "$linkmode" = prog; then
4507
dlopen) libs="$dlfiles" ;;
4508
dlpreopen) libs="$dlprefiles" ;;
4509
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
4512
if test "$linkmode,$pass" = "lib,dlpreopen"; then
4513
# Collect and forward deplibs of preopened libtool libs
4514
for lib in $dlprefiles; do
4515
# Ignore non-libtool-libs
4518
*.la) func_source "$lib" ;;
4521
# Collect preopened libtool deplibs, except any this library
4522
# has declared as weak libs
4523
for deplib in $dependency_libs; do
4524
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
4525
case " $weak_libs " in
4526
*" $deplib_base "*) ;;
4527
*) deplibs="$deplibs $deplib" ;;
4533
if test "$pass" = dlopen; then
4534
# Collect dlpreopened libraries
4535
save_deplibs="$deplibs"
4539
for deplib in $libs; do
4543
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4544
if test "$linkmode,$pass" = "prog,link"; then
4545
compile_deplibs="$deplib $compile_deplibs"
4546
finalize_deplibs="$deplib $finalize_deplibs"
4548
compiler_flags="$compiler_flags $deplib"
4549
if test "$linkmode" = lib ; then
4550
case "$new_inherited_linker_flags " in
4552
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4559
if test "$linkmode" != lib && test "$linkmode" != prog; then
4560
func_warning "\`-l' is ignored for archives/objects"
4563
func_stripname '-l' '' "$deplib"
4564
name=$func_stripname_result
4565
if test "$linkmode" = lib; then
4566
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
4568
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
4570
for searchdir in $searchdirs; do
4571
for search_ext in .la $std_shrext .so .a; do
4572
# Search the libtool library
4573
lib="$searchdir/lib${name}${search_ext}"
4574
if test -f "$lib"; then
4575
if test "$search_ext" = ".la"; then
4584
if test "$found" != yes; then
4585
# deplib doesn't seem to be a libtool library
4586
if test "$linkmode,$pass" = "prog,link"; then
4587
compile_deplibs="$deplib $compile_deplibs"
4588
finalize_deplibs="$deplib $finalize_deplibs"
4590
deplibs="$deplib $deplibs"
4591
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4594
else # deplib is a libtool library
4595
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
4596
# We need to do some special things here, and not later.
4597
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
4598
case " $predeps $postdeps " in
4600
if func_lalib_p "$lib"; then
4604
for l in $old_library $library_names; do
4607
if test "X$ll" = "X$old_library" ; then # only static version available
4609
func_dirname "$lib" "" "."
4610
ladir="$func_dirname_result"
4611
lib=$ladir/$old_library
4612
if test "$linkmode,$pass" = "prog,link"; then
4613
compile_deplibs="$deplib $compile_deplibs"
4614
finalize_deplibs="$deplib $finalize_deplibs"
4616
deplibs="$deplib $deplibs"
4617
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
4629
if test "$linkmode,$pass" = "prog,link"; then
4630
compile_deplibs="$deplib $compile_deplibs"
4631
finalize_deplibs="$deplib $finalize_deplibs"
4633
deplibs="$deplib $deplibs"
4634
if test "$linkmode" = lib ; then
4635
case "$new_inherited_linker_flags " in
4637
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
4646
deplibs="$deplib $deplibs"
4647
test "$pass" = conv && continue
4648
newdependency_libs="$deplib $newdependency_libs"
4649
func_stripname '-L' '' "$deplib"
4650
newlib_search_path="$newlib_search_path $func_stripname_result"
4653
if test "$pass" = conv; then
4654
deplibs="$deplib $deplibs"
4657
if test "$pass" = scan; then
4658
deplibs="$deplib $deplibs"
4660
compile_deplibs="$deplib $compile_deplibs"
4661
finalize_deplibs="$deplib $finalize_deplibs"
4663
func_stripname '-L' '' "$deplib"
4664
newlib_search_path="$newlib_search_path $func_stripname_result"
4667
func_warning "\`-L' is ignored for archives/objects"
4673
if test "$pass" = link; then
4674
func_stripname '-R' '' "$deplib"
4675
dir=$func_stripname_result
4676
# Make sure the xrpath contains only unique directories.
4679
*) xrpath="$xrpath $dir" ;;
4682
deplibs="$deplib $deplibs"
4685
*.la) lib="$deplib" ;;
4687
if test "$pass" = conv; then
4688
deplibs="$deplib $deplibs"
4693
# Linking convenience modules into shared libraries is allowed,
4694
# but linking other static libraries is non-portable.
4695
case " $dlpreconveniencelibs " in
4699
case $deplibs_check_method in
4701
set dummy $deplibs_check_method; shift
4702
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
4703
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
4704
| $EGREP "$match_pattern_regex" > /dev/null; then
4712
if test "$valid_a_lib" != yes; then
4714
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
4715
$ECHO "*** I have the capability to make that library automatically link in when"
4716
$ECHO "*** you link to this library. But I can only do this if you have a"
4717
$ECHO "*** shared version of the library, which you do not appear to have"
4718
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
4719
$ECHO "*** that it is just a static archive that I should not use here."
4722
$ECHO "*** Warning: Linking the shared library $output against the"
4723
$ECHO "*** static library $deplib is not portable!"
4724
deplibs="$deplib $deplibs"
4731
if test "$pass" != link; then
4732
deplibs="$deplib $deplibs"
4734
compile_deplibs="$deplib $compile_deplibs"
4735
finalize_deplibs="$deplib $finalize_deplibs"
4742
if test "$pass" = conv; then
4743
deplibs="$deplib $deplibs"
4744
elif test "$linkmode" = prog; then
4745
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
4746
# If there is no dlopen support or we're linking statically,
4747
# we need to preload.
4748
newdlprefiles="$newdlprefiles $deplib"
4749
compile_deplibs="$deplib $compile_deplibs"
4750
finalize_deplibs="$deplib $finalize_deplibs"
4752
newdlfiles="$newdlfiles $deplib"
4763
if test "$found" = yes || test -f "$lib"; then :
4765
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
4768
# Check to see that this really is a libtool archive.
4769
func_lalib_unsafe_p "$lib" \
4770
|| func_fatal_error "\`$lib' is not a valid libtool archive"
4772
func_dirname "$lib" "" "."
4773
ladir="$func_dirname_result"
4781
inherited_linker_flags=
4782
# If the library was installed with an old release of libtool,
4783
# it will not redefine variables installed, or shouldnotlink
4792
# Convert "-framework foo" to "foo.ltframework"
4793
if test -n "$inherited_linker_flags"; then
4794
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
4795
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
4796
case " $new_inherited_linker_flags " in
4797
*" $tmp_inherited_linker_flag "*) ;;
4798
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
4802
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
4803
if test "$linkmode,$pass" = "lib,link" ||
4804
test "$linkmode,$pass" = "prog,scan" ||
4805
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
4806
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
4807
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
4810
if test "$pass" = conv; then
4811
# Only check for convenience libraries
4812
deplibs="$lib $deplibs"
4813
if test -z "$libdir"; then
4814
if test -z "$old_library"; then
4815
func_fatal_error "cannot find name of link library for \`$lib'"
4817
# It is a libtool convenience library, so add in its objects.
4818
convenience="$convenience $ladir/$objdir/$old_library"
4819
old_convenience="$old_convenience $ladir/$objdir/$old_library"
4820
elif test "$linkmode" != prog && test "$linkmode" != lib; then
4821
func_fatal_error "\`$lib' is not a convenience library"
4824
for deplib in $dependency_libs; do
4825
deplibs="$deplib $deplibs"
4826
if $opt_duplicate_deps ; then
4827
case "$tmp_libs " in
4828
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4831
tmp_libs="$tmp_libs $deplib"
4837
# Get the name of the library we link against.
4839
for l in $old_library $library_names; do
4842
if test -z "$linklib"; then
4843
func_fatal_error "cannot find name of link library for \`$lib'"
4846
# This library was specified with -dlopen.
4847
if test "$pass" = dlopen; then
4848
if test -z "$libdir"; then
4849
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
4851
if test -z "$dlname" ||
4852
test "$dlopen_support" != yes ||
4853
test "$build_libtool_libs" = no; then
4854
# If there is no dlname, no dlopen support or we're linking
4855
# statically, we need to preload. We also need to preload any
4856
# dependent libraries so libltdl's deplib preloader doesn't
4857
# bomb out in the load deplibs phase.
4858
dlprefiles="$dlprefiles $lib $dependency_libs"
4860
newdlfiles="$newdlfiles $lib"
4865
# We need an absolute path.
4867
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
4869
abs_ladir=`cd "$ladir" && pwd`
4870
if test -z "$abs_ladir"; then
4871
func_warning "cannot determine absolute directory name of \`$ladir'"
4872
func_warning "passing it literally to the linker, although it might fail"
4877
func_basename "$lib"
4878
laname="$func_basename_result"
4880
# Find the relevant object directory and library name.
4881
if test "X$installed" = Xyes; then
4882
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4883
func_warning "library \`$lib' was moved."
4891
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
4893
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
4896
# Remove this search path later
4897
notinst_path="$notinst_path $abs_ladir"
4899
dir="$ladir/$objdir"
4900
absdir="$abs_ladir/$objdir"
4901
# Remove this search path later
4902
notinst_path="$notinst_path $abs_ladir"
4904
fi # $installed = yes
4905
func_stripname 'lib' '.la' "$laname"
4906
name=$func_stripname_result
4908
# This library was specified with -dlpreopen.
4909
if test "$pass" = dlpreopen; then
4910
if test -z "$libdir" && test "$linkmode" = prog; then
4911
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
4913
# Prefer using a static library (so that no silly _DYNAMIC symbols
4914
# are required to link).
4915
if test -n "$old_library"; then
4916
newdlprefiles="$newdlprefiles $dir/$old_library"
4917
# Keep a list of preopened convenience libraries to check
4918
# that they are being used correctly in the link pass.
4919
test -z "$libdir" && \
4920
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
4921
# Otherwise, use the dlname, so that lt_dlopen finds it.
4922
elif test -n "$dlname"; then
4923
newdlprefiles="$newdlprefiles $dir/$dlname"
4925
newdlprefiles="$newdlprefiles $dir/$linklib"
4927
fi # $pass = dlpreopen
4929
if test -z "$libdir"; then
4930
# Link the convenience library
4931
if test "$linkmode" = lib; then
4932
deplibs="$dir/$old_library $deplibs"
4933
elif test "$linkmode,$pass" = "prog,link"; then
4934
compile_deplibs="$dir/$old_library $compile_deplibs"
4935
finalize_deplibs="$dir/$old_library $finalize_deplibs"
4937
deplibs="$lib $deplibs" # used for prog,scan pass
4943
if test "$linkmode" = prog && test "$pass" != link; then
4944
newlib_search_path="$newlib_search_path $ladir"
4945
deplibs="$lib $deplibs"
4948
if test "$link_all_deplibs" != no || test -z "$library_names" ||
4949
test "$build_libtool_libs" = no; then
4954
for deplib in $dependency_libs; do
4956
-L*) func_stripname '-L' '' "$deplib"
4957
newlib_search_path="$newlib_search_path $func_stripname_result"
4960
# Need to link against all dependency_libs?
4961
if test "$linkalldeplibs" = yes; then
4962
deplibs="$deplib $deplibs"
4964
# Need to hardcode shared library paths
4965
# or/and link against static libraries
4966
newdependency_libs="$deplib $newdependency_libs"
4968
if $opt_duplicate_deps ; then
4969
case "$tmp_libs " in
4970
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4973
tmp_libs="$tmp_libs $deplib"
4976
fi # $linkmode = prog...
4978
if test "$linkmode,$pass" = "prog,link"; then
4979
if test -n "$library_names" &&
4980
{ { test "$prefer_static_libs" = no ||
4981
test "$prefer_static_libs,$installed" = "built,yes"; } ||
4982
test -z "$old_library"; }; then
4983
# We need to hardcode the library path
4984
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
4985
# Make sure the rpath contains only unique directories.
4986
case "$temp_rpath:" in
4988
*) temp_rpath="$temp_rpath$absdir:" ;;
4992
# Hardcode the library path.
4993
# Skip directories that are in the system default run-time
4995
case " $sys_lib_dlsearch_path " in
4998
case "$compile_rpath " in
5000
*) compile_rpath="$compile_rpath $absdir"
5004
case " $sys_lib_dlsearch_path " in
5007
case "$finalize_rpath " in
5009
*) finalize_rpath="$finalize_rpath $libdir"
5013
fi # $linkmode,$pass = prog,link...
5015
if test "$alldeplibs" = yes &&
5016
{ test "$deplibs_check_method" = pass_all ||
5017
{ test "$build_libtool_libs" = yes &&
5018
test -n "$library_names"; }; }; then
5019
# We only need to search for static libraries
5024
link_static=no # Whether the deplib will be linked statically
5025
use_static_libs=$prefer_static_libs
5026
if test "$use_static_libs" = built && test "$installed" = yes; then
5029
if test -n "$library_names" &&
5030
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
5033
# No point in relinking DLLs because paths are not encoded
5034
notinst_deplibs="$notinst_deplibs $lib"
5038
if test "$installed" = no; then
5039
notinst_deplibs="$notinst_deplibs $lib"
5044
# This is a shared library
5046
# Warn about portability, can't link against -module's on some
5047
# systems (darwin). Don't bleat about dlopened modules though!
5049
for dlpremoduletest in $dlprefiles; do
5050
if test "X$dlpremoduletest" = "X$lib"; then
5051
dlopenmodule="$dlpremoduletest"
5055
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5057
if test "$linkmode" = prog; then
5058
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5060
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5062
$ECHO "*** $linklib is not portable!"
5064
if test "$linkmode" = lib &&
5065
test "$hardcode_into_libs" = yes; then
5066
# Hardcode the library path.
5067
# Skip directories that are in the system default run-time
5069
case " $sys_lib_dlsearch_path " in
5072
case "$compile_rpath " in
5074
*) compile_rpath="$compile_rpath $absdir"
5078
case " $sys_lib_dlsearch_path " in
5081
case "$finalize_rpath " in
5083
*) finalize_rpath="$finalize_rpath $libdir"
5089
if test -n "$old_archive_from_expsyms_cmds"; then
5090
# figure out the soname
5091
set dummy $library_names
5095
libname=`eval "\\$ECHO \"$libname_spec\""`
5096
# use dlname if we got it. it's perfectly good, no?
5097
if test -n "$dlname"; then
5099
elif test -n "$soname_spec"; then
5103
func_arith $current - $age
5104
major=$func_arith_result
5108
eval soname=\"$soname_spec\"
5113
# Make a new name for the extract_expsyms_cmds to use
5115
func_basename "$soroot"
5116
soname="$func_basename_result"
5117
func_stripname 'lib' '.dll' "$soname"
5118
newlib=libimp-$func_stripname_result.a
5120
# If the library has no export list, then create one now
5121
if test -f "$output_objdir/$soname-def"; then :
5123
func_verbose "extracting exported symbol list from \`$soname'"
5124
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5128
if test -f "$output_objdir/$newlib"; then :; else
5129
func_verbose "generating import library for \`$soname'"
5130
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5132
# make sure the library variables are pointing to the new library
5135
fi # test -n "$old_archive_from_expsyms_cmds"
5137
if test "$linkmode" = prog || test "$mode" != relink; then
5142
case $hardcode_action in
5143
immediate | unsupported)
5144
if test "$hardcode_direct" = no; then
5147
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5148
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
5149
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5150
*-*-unixware7*) add_dir="-L$dir" ;;
5152
# if the lib is a (non-dlopened) module then we can not
5153
# link against it, someone is ignoring the earlier warnings
5154
if /usr/bin/file -L $add 2> /dev/null |
5155
$GREP ": [^:]* bundle" >/dev/null ; then
5156
if test "X$dlopenmodule" != "X$lib"; then
5157
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5158
if test -z "$old_library" ; then
5160
$ECHO "*** And there doesn't seem to be a static archive available"
5161
$ECHO "*** The link will probably fail, sorry"
5163
add="$dir/$old_library"
5165
elif test -n "$old_library"; then
5166
add="$dir/$old_library"
5170
elif test "$hardcode_minus_L" = no; then
5172
*-*-sunos*) add_shlibpath="$dir" ;;
5176
elif test "$hardcode_shlibpath_var" = no; then
5177
add_shlibpath="$dir"
5184
if test "$hardcode_direct" = yes &&
5185
test "$hardcode_direct_absolute" = no; then
5187
elif test "$hardcode_minus_L" = yes; then
5189
# Try looking first in the location we're being installed to.
5190
if test -n "$inst_prefix_dir"; then
5193
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5198
elif test "$hardcode_shlibpath_var" = yes; then
5199
add_shlibpath="$dir"
5208
if test "$lib_linked" != yes; then
5209
func_fatal_configuration "unsupported hardcode properties"
5212
if test -n "$add_shlibpath"; then
5213
case :$compile_shlibpath: in
5214
*":$add_shlibpath:"*) ;;
5215
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5218
if test "$linkmode" = prog; then
5219
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5220
test -n "$add" && compile_deplibs="$add $compile_deplibs"
5222
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5223
test -n "$add" && deplibs="$add $deplibs"
5224
if test "$hardcode_direct" != yes &&
5225
test "$hardcode_minus_L" != yes &&
5226
test "$hardcode_shlibpath_var" = yes; then
5227
case :$finalize_shlibpath: in
5229
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5235
if test "$linkmode" = prog || test "$mode" = relink; then
5239
# Finalize command for both is simple: just hardcode it.
5240
if test "$hardcode_direct" = yes &&
5241
test "$hardcode_direct_absolute" = no; then
5242
add="$libdir/$linklib"
5243
elif test "$hardcode_minus_L" = yes; then
5246
elif test "$hardcode_shlibpath_var" = yes; then
5247
case :$finalize_shlibpath: in
5249
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5252
elif test "$hardcode_automatic" = yes; then
5253
if test -n "$inst_prefix_dir" &&
5254
test -f "$inst_prefix_dir$libdir/$linklib" ; then
5255
add="$inst_prefix_dir$libdir/$linklib"
5257
add="$libdir/$linklib"
5260
# We cannot seem to hardcode it, guess we'll fake it.
5262
# Try looking first in the location we're being installed to.
5263
if test -n "$inst_prefix_dir"; then
5266
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5273
if test "$linkmode" = prog; then
5274
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5275
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5277
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5278
test -n "$add" && deplibs="$add $deplibs"
5281
elif test "$linkmode" = prog; then
5282
# Here we assume that one of hardcode_direct or hardcode_minus_L
5283
# is not unsupported. This is valid on all known static and
5285
if test "$hardcode_direct" != unsupported; then
5286
test -n "$old_library" && linklib="$old_library"
5287
compile_deplibs="$dir/$linklib $compile_deplibs"
5288
finalize_deplibs="$dir/$linklib $finalize_deplibs"
5290
compile_deplibs="-l$name -L$dir $compile_deplibs"
5291
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5293
elif test "$build_libtool_libs" = yes; then
5294
# Not a shared library
5295
if test "$deplibs_check_method" != pass_all; then
5296
# We're trying link a shared library against a static one
5297
# but the system doesn't support it.
5299
# Just print a warning and add the library to dependency_libs so
5300
# that the program can be linked against the static library.
5302
$ECHO "*** Warning: This system can not link to static lib archive $lib."
5303
$ECHO "*** I have the capability to make that library automatically link in when"
5304
$ECHO "*** you link to this library. But I can only do this if you have a"
5305
$ECHO "*** shared version of the library, which you do not appear to have."
5306
if test "$module" = yes; then
5307
$ECHO "*** But as you try to build a module library, libtool will still create "
5308
$ECHO "*** a static module, that should work as long as the dlopening application"
5309
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5310
if test -z "$global_symbol_pipe"; then
5312
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5313
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5314
$ECHO "*** not find such a program. So, this module is probably useless."
5315
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5317
if test "$build_old_libs" = no; then
5318
build_libtool_libs=module
5321
build_libtool_libs=no
5325
deplibs="$dir/$old_library $deplibs"
5328
fi # link shared/static library?
5330
if test "$linkmode" = lib; then
5331
if test -n "$dependency_libs" &&
5332
{ test "$hardcode_into_libs" != yes ||
5333
test "$build_old_libs" = yes ||
5334
test "$link_static" = yes; }; then
5335
# Extract -R from dependency_libs
5337
for libdir in $dependency_libs; do
5339
-R*) func_stripname '-R' '' "$libdir"
5340
temp_xrpath=$func_stripname_result
5342
*" $temp_xrpath "*) ;;
5343
*) xrpath="$xrpath $temp_xrpath";;
5345
*) temp_deplibs="$temp_deplibs $libdir";;
5348
dependency_libs="$temp_deplibs"
5351
newlib_search_path="$newlib_search_path $absdir"
5352
# Link against this library
5353
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5354
# ... and its dependency_libs
5356
for deplib in $dependency_libs; do
5357
newdependency_libs="$deplib $newdependency_libs"
5358
if $opt_duplicate_deps ; then
5359
case "$tmp_libs " in
5360
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5363
tmp_libs="$tmp_libs $deplib"
5366
if test "$link_all_deplibs" != no; then
5367
# Add the search paths of all dependency libraries
5368
for deplib in $dependency_libs; do
5370
-L*) path="$deplib" ;;
5372
func_dirname "$deplib" "" "."
5373
dir="$func_dirname_result"
5374
# We need an absolute path.
5376
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5378
absdir=`cd "$dir" && pwd`
5379
if test -z "$absdir"; then
5380
func_warning "cannot determine absolute directory name of \`$dir'"
5385
if $GREP "^installed=no" $deplib > /dev/null; then
5389
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5390
if test -n "$deplibrary_names" ; then
5391
for tmp in $deplibrary_names ; do
5394
if test -f "$absdir/$objdir/$depdepl" ; then
5395
depdepl="$absdir/$objdir/$depdepl"
5396
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5397
if test -z "$darwin_install_name"; then
5398
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5400
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5401
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5407
path="-L$absdir/$objdir"
5411
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5412
test -z "$libdir" && \
5413
func_fatal_error "\`$deplib' is not a valid libtool archive"
5414
test "$absdir" != "$libdir" && \
5415
func_warning "\`$deplib' seems to be moved"
5421
case " $deplibs " in
5423
*) deplibs="$path $deplibs" ;;
5426
fi # link_all_deplibs != no
5428
done # for deplib in $libs
5429
if test "$pass" = link; then
5430
if test "$linkmode" = "prog"; then
5431
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5432
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5434
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5437
dependency_libs="$newdependency_libs"
5438
if test "$pass" = dlpreopen; then
5439
# Link the dlpreopened libraries before other libraries
5440
for deplib in $save_deplibs; do
5441
deplibs="$deplib $deplibs"
5444
if test "$pass" != dlopen; then
5445
if test "$pass" != conv; then
5446
# Make sure lib_search_path contains only unique directories.
5448
for dir in $newlib_search_path; do
5449
case "$lib_search_path " in
5451
*) lib_search_path="$lib_search_path $dir" ;;
5457
if test "$linkmode,$pass" != "prog,link"; then
5460
vars="compile_deplibs finalize_deplibs"
5462
for var in $vars dependency_libs; do
5463
# Add libraries to $var in reverse order
5464
eval tmp_libs=\"\$$var\"
5466
for deplib in $tmp_libs; do
5467
# FIXME: Pedantically, this is the right thing to do, so
5468
# that some nasty dependency loop isn't accidentally
5470
#new_libs="$deplib $new_libs"
5471
# Pragmatically, this seems to cause very few problems in
5474
-L*) new_libs="$deplib $new_libs" ;;
5477
# And here is the reason: when a library appears more
5478
# than once as an explicit dependence of a library, or
5479
# is implicitly linked in more than once by the
5480
# compiler, it is considered special, and multiple
5481
# occurrences thereof are not removed. Compare this
5482
# with having the same library being listed as a
5483
# dependency of multiple other libraries: in this case,
5484
# we know (pedantically, we assume) the library does not
5485
# need to be listed more than once, so we keep only the
5486
# last copy. This is not always right, but it is rare
5487
# enough that we require users that really mean to play
5488
# such unportable linking tricks to link the library
5489
# using -Wl,-lname, so that libtool does not consider it
5490
# for duplicate removal.
5491
case " $specialdeplibs " in
5492
*" $deplib "*) new_libs="$deplib $new_libs" ;;
5494
case " $new_libs " in
5496
*) new_libs="$deplib $new_libs" ;;
5504
for deplib in $new_libs; do
5507
case " $tmp_libs " in
5509
*) tmp_libs="$tmp_libs $deplib" ;;
5512
*) tmp_libs="$tmp_libs $deplib" ;;
5515
eval $var=\"$tmp_libs\"
5518
# Last step: remove runtime libs from dependency_libs
5519
# (they stay in deplibs)
5521
for i in $dependency_libs ; do
5522
case " $predeps $postdeps $compiler_lib_search_path " in
5527
if test -n "$i" ; then
5528
tmp_libs="$tmp_libs $i"
5531
dependency_libs=$tmp_libs
5533
if test "$linkmode" = prog; then
5534
dlfiles="$newdlfiles"
5536
if test "$linkmode" = prog || test "$linkmode" = lib; then
5537
dlprefiles="$newdlprefiles"
5542
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
5543
func_warning "\`-dlopen' is ignored for archives"
5548
func_warning "\`-l' and \`-L' are ignored for archives" ;;
5551
test -n "$rpath" && \
5552
func_warning "\`-rpath' is ignored for archives"
5554
test -n "$xrpath" && \
5555
func_warning "\`-R' is ignored for archives"
5557
test -n "$vinfo" && \
5558
func_warning "\`-version-info/-version-number' is ignored for archives"
5560
test -n "$release" && \
5561
func_warning "\`-release' is ignored for archives"
5563
test -n "$export_symbols$export_symbols_regex" && \
5564
func_warning "\`-export-symbols' is ignored for archives"
5566
# Now set the variables for building old libraries.
5567
build_libtool_libs=no
5569
objs="$objs$old_deplibs"
5573
# Make sure we only generate libraries of the form `libNAME.la'.
5576
func_stripname 'lib' '.la' "$outputname"
5577
name=$func_stripname_result
5578
eval shared_ext=\"$shrext_cmds\"
5579
eval libname=\"$libname_spec\"
5582
test "$module" = no && \
5583
func_fatal_help "libtool library \`$output' must begin with \`lib'"
5585
if test "$need_lib_prefix" != no; then
5586
# Add the "lib" prefix for modules if required
5587
func_stripname '' '.la' "$outputname"
5588
name=$func_stripname_result
5589
eval shared_ext=\"$shrext_cmds\"
5590
eval libname=\"$libname_spec\"
5592
func_stripname '' '.la' "$outputname"
5593
libname=$func_stripname_result
5598
if test -n "$objs"; then
5599
if test "$deplibs_check_method" != pass_all; then
5600
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
5603
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
5604
$ECHO "*** objects $objs is not portable!"
5605
libobjs="$libobjs $objs"
5609
test "$dlself" != no && \
5610
func_warning "\`-dlopen self' is ignored for libtool libraries"
5614
test "$#" -gt 1 && \
5615
func_warning "ignoring multiple \`-rpath's for a libtool library"
5620
if test -z "$rpath"; then
5621
if test "$build_libtool_libs" = yes; then
5622
# Building a libtool convenience library.
5623
# Some compilers have problems with a `.al' extension so
5624
# convenience libraries should have the same extension an
5625
# archive normally would.
5626
oldlibs="$output_objdir/$libname.$libext $oldlibs"
5627
build_libtool_libs=convenience
5631
test -n "$vinfo" && \
5632
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
5634
test -n "$release" && \
5635
func_warning "\`-release' is ignored for convenience libraries"
5638
# Parse the version information argument.
5639
save_ifs="$IFS"; IFS=':'
5640
set dummy $vinfo 0 0 0
5645
func_fatal_help "too many parameters to \`-version-info'"
5647
# convert absolute version numbers to libtool ages
5648
# this retains compatibility with .la files and attempts
5649
# to make the code below a bit more comprehensible
5651
case $vinfo_number in
5655
number_revision="$3"
5657
# There are really only two kinds -- those that
5658
# use the current revision as the major version
5659
# and those that subtract age and use age as
5660
# a minor version. But, then there is irix
5661
# which has an extra 1 added just for fun
5663
case $version_type in
5664
darwin|linux|osf|windows|none)
5665
func_arith $number_major + $number_minor
5666
current=$func_arith_result
5668
revision="$number_revision"
5670
freebsd-aout|freebsd-elf|sunos)
5671
current="$number_major"
5672
revision="$number_minor"
5676
func_arith $number_major + $number_minor
5677
current=$func_arith_result
5679
revision="$number_minor"
5680
lt_irix_increment=no
5691
# Check that each of the things are valid numbers.
5693
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]) ;;
5695
func_error "CURRENT \`$current' must be a nonnegative integer"
5696
func_fatal_error "\`$vinfo' is not valid version information"
5701
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]) ;;
5703
func_error "REVISION \`$revision' must be a nonnegative integer"
5704
func_fatal_error "\`$vinfo' is not valid version information"
5709
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]) ;;
5711
func_error "AGE \`$age' must be a nonnegative integer"
5712
func_fatal_error "\`$vinfo' is not valid version information"
5716
if test "$age" -gt "$current"; then
5717
func_error "AGE \`$age' is greater than the current interface number \`$current'"
5718
func_fatal_error "\`$vinfo' is not valid version information"
5721
# Calculate the version variables.
5725
case $version_type in
5729
# Like Linux, but with the current version available in
5730
# verstring for coding it into the library header
5731
func_arith $current - $age
5732
major=.$func_arith_result
5733
versuffix="$major.$age.$revision"
5734
# Darwin ld doesn't like 0 for these options...
5735
func_arith $current + 1
5736
minor_current=$func_arith_result
5737
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
5738
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
5743
versuffix=".$current.$revision";
5748
versuffix=".$current"
5752
if test "X$lt_irix_increment" = "Xno"; then
5753
func_arith $current - $age
5755
func_arith $current - $age + 1
5757
major=$func_arith_result
5759
case $version_type in
5760
nonstopux) verstring_prefix=nonstopux ;;
5761
*) verstring_prefix=sgi ;;
5763
verstring="$verstring_prefix$major.$revision"
5765
# Add in all the interfaces that we are compatible with.
5767
while test "$loop" -ne 0; do
5768
func_arith $revision - $loop
5769
iface=$func_arith_result
5770
func_arith $loop - 1
5771
loop=$func_arith_result
5772
verstring="$verstring_prefix$major.$iface:$verstring"
5775
# Before this point, $major must not contain `.'.
5777
versuffix="$major.$revision"
5781
func_arith $current - $age
5782
major=.$func_arith_result
5783
versuffix="$major.$age.$revision"
5787
func_arith $current - $age
5788
major=.$func_arith_result
5789
versuffix=".$current.$age.$revision"
5790
verstring="$current.$age.$revision"
5792
# Add in all the interfaces that we are compatible with.
5794
while test "$loop" -ne 0; do
5795
func_arith $current - $loop
5796
iface=$func_arith_result
5797
func_arith $loop - 1
5798
loop=$func_arith_result
5799
verstring="$verstring:${iface}.0"
5802
# Make executables depend on our current version.
5803
verstring="$verstring:${current}.0"
5808
versuffix=".$current"
5813
versuffix=".$current.$revision"
5817
# Use '-' rather than '.', since we only want one
5818
# extension on DOS 8.3 filesystems.
5819
func_arith $current - $age
5820
major=$func_arith_result
5825
func_fatal_configuration "unknown library version type \`$version_type'"
5829
# Clear the version info if we defaulted, and they specified a release.
5830
if test -z "$vinfo" && test -n "$release"; then
5832
case $version_type in
5834
# we can't check for "0.0" in archive_cmds due to quoting
5835
# problems, so we reset it completely
5842
if test "$need_version" = no; then
5849
# Remove version info from name if versioning should be avoided
5850
if test "$avoid_version" = yes && test "$need_version" = no; then
5856
# Check to see if the archive will have undefined symbols.
5857
if test "$allow_undefined" = yes; then
5858
if test "$allow_undefined_flag" = unsupported; then
5859
func_warning "undefined symbols not allowed in $host shared libraries"
5860
build_libtool_libs=no
5864
# Don't allow undefined symbols.
5865
allow_undefined_flag="$no_undefined_flag"
5870
func_generate_dlsyms "$libname" "$libname" "yes"
5871
libobjs="$libobjs $symfileobj"
5872
test "X$libobjs" = "X " && libobjs=
5874
if test "$mode" != relink; then
5875
# Remove our outputs, but don't remove object files since they
5876
# may have been created when compiling PIC objects.
5878
tempremovelist=`$ECHO "$output_objdir/*"`
5879
for p in $tempremovelist; do
5883
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
5884
if test "X$precious_files_regex" != "X"; then
5885
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
5890
removelist="$removelist $p"
5895
test -n "$removelist" && \
5896
func_show_eval "${RM}r \$removelist"
5899
# Now set the variables for building old libraries.
5900
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
5901
oldlibs="$oldlibs $output_objdir/$libname.$libext"
5903
# Transform .lo files to .o files.
5904
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
5907
# Eliminate all temporary directories.
5908
#for path in $notinst_path; do
5909
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
5910
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
5911
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
5914
if test -n "$xrpath"; then
5915
# If the user specified any rpath flags, then add them.
5917
for libdir in $xrpath; do
5918
temp_xrpath="$temp_xrpath -R$libdir"
5919
case "$finalize_rpath " in
5921
*) finalize_rpath="$finalize_rpath $libdir" ;;
5924
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
5925
dependency_libs="$temp_xrpath $dependency_libs"
5929
# Make sure dlfiles contains only unique files that won't be dlpreopened
5930
old_dlfiles="$dlfiles"
5932
for lib in $old_dlfiles; do
5933
case " $dlprefiles $dlfiles " in
5935
*) dlfiles="$dlfiles $lib" ;;
5939
# Make sure dlprefiles contains only unique files
5940
old_dlprefiles="$dlprefiles"
5942
for lib in $old_dlprefiles; do
5943
case "$dlprefiles " in
5945
*) dlprefiles="$dlprefiles $lib" ;;
5949
if test "$build_libtool_libs" = yes; then
5950
if test -n "$rpath"; then
5952
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
5953
# these systems don't actually have a c library (as such)!
5955
*-*-rhapsody* | *-*-darwin1.[012])
5956
# Rhapsody C library is in the System framework
5957
deplibs="$deplibs System.ltframework"
5960
# Don't link with libc until the a.out ld.so is fixed.
5962
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5963
# Do not include libc due to us having libc/libc_r.
5965
*-*-sco3.2v5* | *-*-sco5v6*)
5966
# Causes problems with __ctype
5968
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5969
# Compiler inserts libc in the correct place for threads to work
5972
# Add libc to deplibs on all other systems if necessary.
5973
if test "$build_libtool_need_lc" = "yes"; then
5974
deplibs="$deplibs -lc"
5980
# Transform deplibs into only deplibs that can be linked in shared.
5982
libname_save=$libname
5983
release_save=$release
5984
versuffix_save=$versuffix
5986
# I'm not sure if I'm treating the release correctly. I think
5987
# release should show up in the -l (ie -lgmp5) so we don't want to
5988
# add it in twice. Is that correct?
5994
case $deplibs_check_method in
5996
# Don't check for shared/static. Everything works.
5997
# This might be a little naive. We might want to check
5998
# whether the library exists or not. But this is on
5999
# osf3 & osf4 and I'm not really sure... Just
6000
# implementing what was already the behavior.
6004
# This code stresses the "libraries are programs" paradigm to its
6005
# limits. Maybe even breaks it. We compile a program, linking it
6006
# against the deplibs as a proxy for the library. Then we can check
6007
# whether they linked in statically or dynamically with ldd.
6008
$opt_dry_run || $RM conftest.c
6009
cat > conftest.c <<EOF
6010
int main() { return 0; }
6012
$opt_dry_run || $RM conftest
6013
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6014
ldd_output=`ldd conftest`
6015
for i in $deplibs; do
6018
func_stripname -l '' "$i"
6019
name=$func_stripname_result
6020
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6021
case " $predeps $postdeps " in
6023
newdeplibs="$newdeplibs $i"
6028
if test -n "$i" ; then
6029
libname=`eval "\\$ECHO \"$libname_spec\""`
6030
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6031
set dummy $deplib_matches; shift
6033
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6034
newdeplibs="$newdeplibs $i"
6038
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6039
$ECHO "*** I have the capability to make that library automatically link in when"
6040
$ECHO "*** you link to this library. But I can only do this if you have a"
6041
$ECHO "*** shared version of the library, which I believe you do not have"
6042
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6043
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6048
newdeplibs="$newdeplibs $i"
6053
# Error occurred in the first compile. Let's try to salvage
6054
# the situation: Compile a separate program for each library.
6055
for i in $deplibs; do
6058
func_stripname -l '' "$i"
6059
name=$func_stripname_result
6060
$opt_dry_run || $RM conftest
6061
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6062
ldd_output=`ldd conftest`
6063
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6064
case " $predeps $postdeps " in
6066
newdeplibs="$newdeplibs $i"
6071
if test -n "$i" ; then
6072
libname=`eval "\\$ECHO \"$libname_spec\""`
6073
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6074
set dummy $deplib_matches; shift
6076
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6077
newdeplibs="$newdeplibs $i"
6081
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6082
$ECHO "*** I have the capability to make that library automatically link in when"
6083
$ECHO "*** you link to this library. But I can only do this if you have a"
6084
$ECHO "*** shared version of the library, which you do not appear to have"
6085
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6086
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6092
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6093
$ECHO "*** make it link in! You will probably need to install it or some"
6094
$ECHO "*** library that it depends on before this library will be fully"
6095
$ECHO "*** functional. Installing it before continuing would be even better."
6099
newdeplibs="$newdeplibs $i"
6106
set dummy $deplibs_check_method; shift
6107
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6108
for a_deplib in $deplibs; do
6111
func_stripname -l '' "$a_deplib"
6112
name=$func_stripname_result
6113
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6114
case " $predeps $postdeps " in
6116
newdeplibs="$newdeplibs $a_deplib"
6121
if test -n "$a_deplib" ; then
6122
libname=`eval "\\$ECHO \"$libname_spec\""`
6123
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6124
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6125
for potent_lib in $potential_libs; do
6126
# Follow soft links.
6127
if ls -lLd "$potent_lib" 2>/dev/null |
6128
$GREP " -> " >/dev/null; then
6131
# The statement above tries to avoid entering an
6132
# endless loop below, in case of cyclic links.
6133
# We might still enter an endless loop, since a link
6134
# loop can be closed while we follow links,
6136
potlib="$potent_lib"
6137
while test -h "$potlib" 2>/dev/null; do
6138
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6140
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6141
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6144
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6146
$EGREP "$file_magic_regex" > /dev/null; then
6147
newdeplibs="$newdeplibs $a_deplib"
6154
if test -n "$a_deplib" ; then
6157
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6158
$ECHO "*** I have the capability to make that library automatically link in when"
6159
$ECHO "*** you link to this library. But I can only do this if you have a"
6160
$ECHO "*** shared version of the library, which you do not appear to have"
6161
$ECHO "*** because I did check the linker path looking for a file starting"
6162
if test -z "$potlib" ; then
6163
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6165
$ECHO "*** with $libname and none of the candidates passed a file format test"
6166
$ECHO "*** using a file magic. Last file checked: $potlib"
6171
# Add a -L argument.
6172
newdeplibs="$newdeplibs $a_deplib"
6175
done # Gone through all deplibs.
6178
set dummy $deplibs_check_method; shift
6179
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6180
for a_deplib in $deplibs; do
6183
func_stripname -l '' "$a_deplib"
6184
name=$func_stripname_result
6185
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6186
case " $predeps $postdeps " in
6188
newdeplibs="$newdeplibs $a_deplib"
6193
if test -n "$a_deplib" ; then
6194
libname=`eval "\\$ECHO \"$libname_spec\""`
6195
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6196
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6197
for potent_lib in $potential_libs; do
6198
potlib="$potent_lib" # see symlink-check above in file_magic test
6199
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6200
$EGREP "$match_pattern_regex" > /dev/null; then
6201
newdeplibs="$newdeplibs $a_deplib"
6208
if test -n "$a_deplib" ; then
6211
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6212
$ECHO "*** I have the capability to make that library automatically link in when"
6213
$ECHO "*** you link to this library. But I can only do this if you have a"
6214
$ECHO "*** shared version of the library, which you do not appear to have"
6215
$ECHO "*** because I did check the linker path looking for a file starting"
6216
if test -z "$potlib" ; then
6217
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6219
$ECHO "*** with $libname and none of the candidates passed a file format test"
6220
$ECHO "*** using a regex pattern. Last file checked: $potlib"
6225
# Add a -L argument.
6226
newdeplibs="$newdeplibs $a_deplib"
6229
done # Gone through all deplibs.
6233
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6234
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6235
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6236
for i in $predeps $postdeps ; do
6237
# can't use Xsed below, because $i might contain '/'
6238
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6241
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6242
$GREP . >/dev/null; then
6244
if test "X$deplibs_check_method" = "Xnone"; then
6245
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6247
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
6249
$ECHO "*** All declared inter-library dependencies are being dropped."
6254
versuffix=$versuffix_save
6256
release=$release_save
6257
libname=$libname_save
6261
*-*-rhapsody* | *-*-darwin1.[012])
6262
# On Rhapsody replace the C library with the System framework
6263
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6267
if test "$droppeddeps" = yes; then
6268
if test "$module" = yes; then
6270
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6271
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6272
$ECHO "*** a static module, that should work as long as the dlopening"
6273
$ECHO "*** application is linked with the -dlopen flag."
6274
if test -z "$global_symbol_pipe"; then
6276
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6277
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6278
$ECHO "*** not find such a program. So, this module is probably useless."
6279
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6281
if test "$build_old_libs" = no; then
6282
oldlibs="$output_objdir/$libname.$libext"
6283
build_libtool_libs=module
6286
build_libtool_libs=no
6289
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6290
$ECHO "*** automatically added whenever a program is linked with this library"
6291
$ECHO "*** or is declared to -dlopen it."
6293
if test "$allow_undefined" = no; then
6295
$ECHO "*** Since this library must not contain undefined symbols,"
6296
$ECHO "*** because either the platform does not support them or"
6297
$ECHO "*** it was explicitly requested with -no-undefined,"
6298
$ECHO "*** libtool will only create a static version of it."
6299
if test "$build_old_libs" = no; then
6300
oldlibs="$output_objdir/$libname.$libext"
6301
build_libtool_libs=module
6304
build_libtool_libs=no
6309
# Done checking deplibs!
6312
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6315
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6316
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6317
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6321
# move library search paths that coincide with paths to not yet
6322
# installed libraries to the beginning of the library search list
6324
for path in $notinst_path; do
6325
case " $new_libs " in
6326
*" -L$path/$objdir "*) ;;
6328
case " $deplibs " in
6329
*" -L$path/$objdir "*)
6330
new_libs="$new_libs -L$path/$objdir" ;;
6335
for deplib in $deplibs; do
6338
case " $new_libs " in
6340
*) new_libs="$new_libs $deplib" ;;
6343
*) new_libs="$new_libs $deplib" ;;
6348
# All the library-specific variables (install_libdir is set above).
6353
# Test again, we may have decided not to build it any more
6354
if test "$build_libtool_libs" = yes; then
6355
if test "$hardcode_into_libs" = yes; then
6356
# Hardcode the library paths
6359
rpath="$finalize_rpath"
6360
test "$mode" != relink && rpath="$compile_rpath$rpath"
6361
for libdir in $rpath; do
6362
if test -n "$hardcode_libdir_flag_spec"; then
6363
if test -n "$hardcode_libdir_separator"; then
6364
if test -z "$hardcode_libdirs"; then
6365
hardcode_libdirs="$libdir"
6367
# Just accumulate the unique libdirs.
6368
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6369
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6372
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6377
eval flag=\"$hardcode_libdir_flag_spec\"
6378
dep_rpath="$dep_rpath $flag"
6380
elif test -n "$runpath_var"; then
6381
case "$perm_rpath " in
6383
*) perm_rpath="$perm_rpath $libdir" ;;
6387
# Substitute the hardcoded libdirs into the rpath.
6388
if test -n "$hardcode_libdir_separator" &&
6389
test -n "$hardcode_libdirs"; then
6390
libdir="$hardcode_libdirs"
6391
if test -n "$hardcode_libdir_flag_spec_ld"; then
6392
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6394
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6397
if test -n "$runpath_var" && test -n "$perm_rpath"; then
6398
# We should set the runpath_var.
6400
for dir in $perm_rpath; do
6403
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6405
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6408
shlibpath="$finalize_shlibpath"
6409
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6410
if test -n "$shlibpath"; then
6411
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6414
# Get the real and link names of the library.
6415
eval shared_ext=\"$shrext_cmds\"
6416
eval library_names=\"$library_names_spec\"
6417
set dummy $library_names
6422
if test -n "$soname_spec"; then
6423
eval soname=\"$soname_spec\"
6427
if test -z "$dlname"; then
6431
lib="$output_objdir/$realname"
6435
linknames="$linknames $link"
6438
# Use standard objects if they are pic
6439
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6440
test "X$libobjs" = "X " && libobjs=
6443
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6444
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6445
export_symbols="$output_objdir/$libname.uexp"
6446
delfiles="$delfiles $export_symbols"
6449
orig_export_symbols=
6452
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6453
# exporting using user supplied symfile
6454
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6455
# and it's NOT already a .def file. Must figure out
6456
# which of the given symbols are data symbols and tag
6457
# them as such. So, trigger use of export_symbols_cmds.
6458
# export_symbols gets reassigned inside the "prepare
6459
# the list of exported symbols" if statement, so the
6460
# include_expsyms logic still works.
6461
orig_export_symbols="$export_symbols"
6463
always_export_symbols=yes
6469
# Prepare the list of exported symbols
6470
if test -z "$export_symbols"; then
6471
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6472
func_verbose "generating symbol list for \`$libname.la'"
6473
export_symbols="$output_objdir/$libname.exp"
6474
$opt_dry_run || $RM $export_symbols
6475
cmds=$export_symbols_cmds
6476
save_ifs="$IFS"; IFS='~'
6477
for cmd in $cmds; do
6481
len=$func_len_result
6482
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6483
func_show_eval "$cmd" 'exit $?'
6484
skipped_export=false
6486
# The command line is too long to execute in one step.
6487
func_verbose "using reloadable object file for export list..."
6489
# Break out early, otherwise skipped_export may be
6490
# set to false by a later but shorter cmd.
6495
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
6496
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6497
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6502
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6503
tmp_export_symbols="$export_symbols"
6504
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6505
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6508
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
6509
# The given exports_symbols file has to be filtered, so filter it.
6510
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6511
# FIXME: $output_objdir/$libname.filter potentially contains lots of
6512
# 's' commands which not all seds can handle. GNU sed should be fine
6513
# though. Also, the filter scales superlinearly with the number of
6514
# global variables. join(1) would be nice here, but unfortunately
6515
# isn't a blessed tool.
6516
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6517
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6518
export_symbols=$output_objdir/$libname.def
6519
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6523
for test_deplib in $deplibs; do
6524
case " $convenience " in
6525
*" $test_deplib "*) ;;
6527
tmp_deplibs="$tmp_deplibs $test_deplib"
6531
deplibs="$tmp_deplibs"
6533
if test -n "$convenience"; then
6534
if test -n "$whole_archive_flag_spec" &&
6535
test "$compiler_needs_object" = yes &&
6536
test -z "$libobjs"; then
6537
# extract the archives, so we have objects to list.
6538
# TODO: could optimize this to just extract one archive.
6539
whole_archive_flag_spec=
6541
if test -n "$whole_archive_flag_spec"; then
6542
save_libobjs=$libobjs
6543
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6544
test "X$libobjs" = "X " && libobjs=
6546
gentop="$output_objdir/${outputname}x"
6547
generated="$generated $gentop"
6549
func_extract_archives $gentop $convenience
6550
libobjs="$libobjs $func_extract_archives_result"
6551
test "X$libobjs" = "X " && libobjs=
6555
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
6556
eval flag=\"$thread_safe_flag_spec\"
6557
linker_flags="$linker_flags $flag"
6560
# Make a backup of the uninstalled library when relinking
6561
if test "$mode" = relink; then
6562
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
6565
# Do each of the archive commands.
6566
if test "$module" = yes && test -n "$module_cmds" ; then
6567
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6568
eval test_cmds=\"$module_expsym_cmds\"
6569
cmds=$module_expsym_cmds
6571
eval test_cmds=\"$module_cmds\"
6575
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6576
eval test_cmds=\"$archive_expsym_cmds\"
6577
cmds=$archive_expsym_cmds
6579
eval test_cmds=\"$archive_cmds\"
6584
if test "X$skipped_export" != "X:" &&
6585
func_len " $test_cmds" &&
6586
len=$func_len_result &&
6587
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
6590
# The command line is too long to link in one step, link piecewise
6591
# or, if using GNU ld and skipped_export is not :, use a linker
6594
# Save the value of $output and $libobjs because we want to
6595
# use them later. If we have whole_archive_flag_spec, we
6596
# want to use save_libobjs as it was before
6597
# whole_archive_flag_spec was expanded, because we can't
6598
# assume the linker understands whole_archive_flag_spec.
6599
# This may have to be revisited, in case too many
6600
# convenience libraries get linked in and end up exceeding
6602
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
6603
save_libobjs=$libobjs
6606
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
6608
# Clear the reloadable object creation command queue and
6609
# initialize k to one.
6616
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
6617
output=${output_objdir}/${output_la}.lnkscript
6618
func_verbose "creating GNU ld script: $output"
6619
$ECHO 'INPUT (' > $output
6620
for obj in $save_libobjs
6622
$ECHO "$obj" >> $output
6624
$ECHO ')' >> $output
6625
delfiles="$delfiles $output"
6626
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
6627
output=${output_objdir}/${output_la}.lnk
6628
func_verbose "creating linker input file list: $output"
6633
if test "$compiler_needs_object" = yes; then
6639
$ECHO "$obj" >> $output
6641
delfiles="$delfiles $output"
6642
output=$firstobj\"$file_list_spec$output\"
6644
if test -n "$save_libobjs"; then
6645
func_verbose "creating reloadable object files..."
6646
output=$output_objdir/$output_la-${k}.$objext
6647
eval test_cmds=\"$reload_cmds\"
6648
func_len " $test_cmds"
6649
len0=$func_len_result
6652
# Loop over the list of objects to be linked.
6653
for obj in $save_libobjs
6656
func_arith $len + $func_len_result
6657
len=$func_arith_result
6658
if test "X$objlist" = X ||
6659
test "$len" -lt "$max_cmd_len"; then
6660
func_append objlist " $obj"
6662
# The command $test_cmds is almost too long, add a
6663
# command to the queue.
6664
if test "$k" -eq 1 ; then
6665
# The first file doesn't have a previous command to add.
6666
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
6668
# All subsequent reloadable object files will link in
6669
# the last one created.
6670
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
6672
last_robj=$output_objdir/$output_la-${k}.$objext
6674
k=$func_arith_result
6675
output=$output_objdir/$output_la-${k}.$objext
6677
func_len " $last_robj"
6678
func_arith $len0 + $func_len_result
6679
len=$func_arith_result
6682
# Handle the remaining objects by creating one last
6683
# reloadable object file. All subsequent reloadable object
6684
# files will link in the last one created.
6685
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6686
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
6687
if test -n "$last_robj"; then
6688
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
6690
delfiles="$delfiles $output"
6696
if ${skipped_export-false}; then
6697
func_verbose "generating symbol list for \`$libname.la'"
6698
export_symbols="$output_objdir/$libname.exp"
6699
$opt_dry_run || $RM $export_symbols
6701
# Append the command to create the export file.
6702
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
6703
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
6704
if test -n "$last_robj"; then
6705
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
6709
test -n "$save_libobjs" &&
6710
func_verbose "creating a temporary reloadable object file: $output"
6712
# Loop through the commands generated above and execute them.
6713
save_ifs="$IFS"; IFS='~'
6714
for cmd in $concat_cmds; do
6717
func_quote_for_expand "$cmd"
6718
eval "func_echo $func_quote_for_expand_result"
6720
$opt_dry_run || eval "$cmd" || {
6723
# Restore the uninstalled library and exit
6724
if test "$mode" = relink; then
6725
( cd "$output_objdir" && \
6726
$RM "${realname}T" && \
6727
$MV "${realname}U" "$realname" )
6735
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
6736
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
6737
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
6741
if ${skipped_export-false}; then
6742
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6743
tmp_export_symbols="$export_symbols"
6744
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
6745
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
6748
if test -n "$orig_export_symbols"; then
6749
# The given exports_symbols file has to be filtered, so filter it.
6750
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
6751
# FIXME: $output_objdir/$libname.filter potentially contains lots of
6752
# 's' commands which not all seds can handle. GNU sed should be fine
6753
# though. Also, the filter scales superlinearly with the number of
6754
# global variables. join(1) would be nice here, but unfortunately
6755
# isn't a blessed tool.
6756
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
6757
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
6758
export_symbols=$output_objdir/$libname.def
6759
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
6764
# Restore the value of output.
6767
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
6768
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
6769
test "X$libobjs" = "X " && libobjs=
6771
# Expand the library linking commands again to reset the
6772
# value of $libobjs for piecewise linking.
6774
# Do each of the archive commands.
6775
if test "$module" = yes && test -n "$module_cmds" ; then
6776
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
6777
cmds=$module_expsym_cmds
6782
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
6783
cmds=$archive_expsym_cmds
6790
if test -n "$delfiles"; then
6791
# Append the command to remove temporary files to $cmds.
6792
eval cmds=\"\$cmds~\$RM $delfiles\"
6795
# Add any objects from preloaded convenience libraries
6796
if test -n "$dlprefiles"; then
6797
gentop="$output_objdir/${outputname}x"
6798
generated="$generated $gentop"
6800
func_extract_archives $gentop $dlprefiles
6801
libobjs="$libobjs $func_extract_archives_result"
6802
test "X$libobjs" = "X " && libobjs=
6805
save_ifs="$IFS"; IFS='~'
6806
for cmd in $cmds; do
6810
func_quote_for_expand "$cmd"
6811
eval "func_echo $func_quote_for_expand_result"
6813
$opt_dry_run || eval "$cmd" || {
6816
# Restore the uninstalled library and exit
6817
if test "$mode" = relink; then
6818
( cd "$output_objdir" && \
6819
$RM "${realname}T" && \
6820
$MV "${realname}U" "$realname" )
6828
# Restore the uninstalled library and exit
6829
if test "$mode" = relink; then
6830
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
6832
if test -n "$convenience"; then
6833
if test -z "$whole_archive_flag_spec"; then
6834
func_show_eval '${RM}r "$gentop"'
6841
# Create links to the real library.
6842
for linkname in $linknames; do
6843
if test "$realname" != "$linkname"; then
6844
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
6848
# If -module or -export-dynamic was specified, set the dlname.
6849
if test "$module" = yes || test "$export_dynamic" = yes; then
6850
# On all known operating systems, these are identical.
6857
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6858
func_warning "\`-dlopen' is ignored for objects"
6863
func_warning "\`-l' and \`-L' are ignored for objects" ;;
6866
test -n "$rpath" && \
6867
func_warning "\`-rpath' is ignored for objects"
6869
test -n "$xrpath" && \
6870
func_warning "\`-R' is ignored for objects"
6872
test -n "$vinfo" && \
6873
func_warning "\`-version-info' is ignored for objects"
6875
test -n "$release" && \
6876
func_warning "\`-release' is ignored for objects"
6880
test -n "$objs$old_deplibs" && \
6881
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
6885
obj=$func_lo2o_result
6893
# Delete the old objects.
6894
$opt_dry_run || $RM $obj $libobj
6896
# Objects from convenience libraries. This assumes
6897
# single-version convenience libraries. Whenever we create
6898
# different ones for PIC/non-PIC, this we'll have to duplicate
6902
# reload_cmds runs $LD directly, so let us get rid of
6903
# -Wl from whole_archive_flag_spec and hope we can get by with
6904
# turning comma into space..
6907
if test -n "$convenience"; then
6908
if test -n "$whole_archive_flag_spec"; then
6909
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
6910
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
6912
gentop="$output_objdir/${obj}x"
6913
generated="$generated $gentop"
6915
func_extract_archives $gentop $convenience
6916
reload_conv_objs="$reload_objs $func_extract_archives_result"
6920
# Create the old-style object.
6921
reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
6924
func_execute_cmds "$reload_cmds" 'exit $?'
6926
# Exit if we aren't doing a library object file.
6927
if test -z "$libobj"; then
6928
if test -n "$gentop"; then
6929
func_show_eval '${RM}r "$gentop"'
6935
if test "$build_libtool_libs" != yes; then
6936
if test -n "$gentop"; then
6937
func_show_eval '${RM}r "$gentop"'
6940
# Create an invalid libtool object if no PIC, so that we don't
6941
# accidentally link it into a program.
6942
# $show "echo timestamp > $libobj"
6943
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
6947
if test -n "$pic_flag" || test "$pic_mode" != default; then
6948
# Only do commands if we really have different PIC objects.
6949
reload_objs="$libobjs $reload_conv_objs"
6951
func_execute_cmds "$reload_cmds" 'exit $?'
6954
if test -n "$gentop"; then
6955
func_show_eval '${RM}r "$gentop"'
6963
*cygwin*) func_stripname '' '.exe' "$output"
6964
output=$func_stripname_result.exe;;
6966
test -n "$vinfo" && \
6967
func_warning "\`-version-info' is ignored for programs"
6969
test -n "$release" && \
6970
func_warning "\`-release' is ignored for programs"
6972
test "$preload" = yes \
6973
&& test "$dlopen_support" = unknown \
6974
&& test "$dlopen_self" = unknown \
6975
&& test "$dlopen_self_static" = unknown && \
6976
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
6979
*-*-rhapsody* | *-*-darwin1.[012])
6980
# On Rhapsody replace the C library is the System framework
6981
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6982
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6988
# Don't allow lazy linking, it breaks C++ global constructors
6989
# But is supposedly fixed on 10.4 or later (yay!).
6990
if test "$tagname" = CXX ; then
6991
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
6993
compile_command="$compile_command ${wl}-bind_at_load"
6994
finalize_command="$finalize_command ${wl}-bind_at_load"
6998
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6999
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7000
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7005
# move library search paths that coincide with paths to not yet
7006
# installed libraries to the beginning of the library search list
7008
for path in $notinst_path; do
7009
case " $new_libs " in
7010
*" -L$path/$objdir "*) ;;
7012
case " $compile_deplibs " in
7013
*" -L$path/$objdir "*)
7014
new_libs="$new_libs -L$path/$objdir" ;;
7019
for deplib in $compile_deplibs; do
7022
case " $new_libs " in
7024
*) new_libs="$new_libs $deplib" ;;
7027
*) new_libs="$new_libs $deplib" ;;
7030
compile_deplibs="$new_libs"
7033
compile_command="$compile_command $compile_deplibs"
7034
finalize_command="$finalize_command $finalize_deplibs"
7036
if test -n "$rpath$xrpath"; then
7037
# If the user specified any rpath flags, then add them.
7038
for libdir in $rpath $xrpath; do
7039
# This is the magic to use -rpath.
7040
case "$finalize_rpath " in
7042
*) finalize_rpath="$finalize_rpath $libdir" ;;
7047
# Now hardcode the library paths
7050
for libdir in $compile_rpath $finalize_rpath; do
7051
if test -n "$hardcode_libdir_flag_spec"; then
7052
if test -n "$hardcode_libdir_separator"; then
7053
if test -z "$hardcode_libdirs"; then
7054
hardcode_libdirs="$libdir"
7056
# Just accumulate the unique libdirs.
7057
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7058
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7061
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7066
eval flag=\"$hardcode_libdir_flag_spec\"
7067
rpath="$rpath $flag"
7069
elif test -n "$runpath_var"; then
7070
case "$perm_rpath " in
7072
*) perm_rpath="$perm_rpath $libdir" ;;
7076
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
7077
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7078
case :$dllsearchpath: in
7080
*) dllsearchpath="$dllsearchpath:$libdir";;
7082
case :$dllsearchpath: in
7083
*":$testbindir:"*) ;;
7084
*) dllsearchpath="$dllsearchpath:$testbindir";;
7089
# Substitute the hardcoded libdirs into the rpath.
7090
if test -n "$hardcode_libdir_separator" &&
7091
test -n "$hardcode_libdirs"; then
7092
libdir="$hardcode_libdirs"
7093
eval rpath=\" $hardcode_libdir_flag_spec\"
7095
compile_rpath="$rpath"
7099
for libdir in $finalize_rpath; do
7100
if test -n "$hardcode_libdir_flag_spec"; then
7101
if test -n "$hardcode_libdir_separator"; then
7102
if test -z "$hardcode_libdirs"; then
7103
hardcode_libdirs="$libdir"
7105
# Just accumulate the unique libdirs.
7106
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7107
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7110
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7115
eval flag=\"$hardcode_libdir_flag_spec\"
7116
rpath="$rpath $flag"
7118
elif test -n "$runpath_var"; then
7119
case "$finalize_perm_rpath " in
7121
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7125
# Substitute the hardcoded libdirs into the rpath.
7126
if test -n "$hardcode_libdir_separator" &&
7127
test -n "$hardcode_libdirs"; then
7128
libdir="$hardcode_libdirs"
7129
eval rpath=\" $hardcode_libdir_flag_spec\"
7131
finalize_rpath="$rpath"
7133
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7134
# Transform all the library objects into standard objects.
7135
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7136
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7139
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7141
# template prelinking step
7142
if test -n "$prelink_cmds"; then
7143
func_execute_cmds "$prelink_cmds" 'exit $?'
7146
wrappers_required=yes
7148
*cygwin* | *mingw* )
7149
if test "$build_libtool_libs" != yes; then
7150
wrappers_required=no
7154
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7155
wrappers_required=no
7159
if test "$wrappers_required" = no; then
7160
# Replace the output file specification.
7161
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7162
link_command="$compile_command$compile_rpath"
7164
# We have no uninstalled library dependencies, so finalize right now.
7166
func_show_eval "$link_command" 'exit_status=$?'
7168
# Delete the generated files.
7169
if test -f "$output_objdir/${outputname}S.${objext}"; then
7170
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7176
if test -n "$compile_shlibpath$finalize_shlibpath"; then
7177
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7179
if test -n "$finalize_shlibpath"; then
7180
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7185
if test -n "$runpath_var"; then
7186
if test -n "$perm_rpath"; then
7187
# We should set the runpath_var.
7189
for dir in $perm_rpath; do
7192
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7194
if test -n "$finalize_perm_rpath"; then
7195
# We should set the runpath_var.
7197
for dir in $finalize_perm_rpath; do
7200
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7204
if test "$no_install" = yes; then
7205
# We don't need to create a wrapper script.
7206
link_command="$compile_var$compile_command$compile_rpath"
7207
# Replace the output file specification.
7208
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7209
# Delete the old output file.
7210
$opt_dry_run || $RM $output
7211
# Link the executable and exit
7212
func_show_eval "$link_command" 'exit $?'
7216
if test "$hardcode_action" = relink; then
7217
# Fast installation is not supported
7218
link_command="$compile_var$compile_command$compile_rpath"
7219
relink_command="$finalize_var$finalize_command$finalize_rpath"
7221
func_warning "this platform does not like uninstalled shared libraries"
7222
func_warning "\`$output' will be relinked during installation"
7224
if test "$fast_install" != no; then
7225
link_command="$finalize_var$compile_command$finalize_rpath"
7226
if test "$fast_install" = yes; then
7227
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7229
# fast_install is set to needless
7233
link_command="$compile_var$compile_command$compile_rpath"
7234
relink_command="$finalize_var$finalize_command$finalize_rpath"
7238
# Replace the output file specification.
7239
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7241
# Delete the old output files.
7242
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7244
func_show_eval "$link_command" 'exit $?'
7246
# Now create the wrapper script.
7247
func_verbose "creating $output"
7249
# Quote the relink command for shipping.
7250
if test -n "$relink_command"; then
7251
# Preserve any variables that may affect compiler behavior
7252
for var in $variables_saved_for_relink; do
7253
if eval test -z \"\${$var+set}\"; then
7254
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7255
elif eval var_value=\$$var; test -z "$var_value"; then
7256
relink_command="$var=; export $var; $relink_command"
7258
func_quote_for_eval "$var_value"
7259
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7262
relink_command="(cd `pwd`; $relink_command)"
7263
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7266
# Quote $ECHO for shipping.
7267
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7269
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7270
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7272
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7274
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7277
# Only actually do things if not in dry run mode.
7279
# win32 will think the script is a binary if it has
7280
# a .exe suffix, so we strip it off here.
7282
*.exe) func_stripname '' '.exe' "$output"
7283
output=$func_stripname_result ;;
7285
# test for cygwin because mv fails w/o .exe extensions
7289
func_stripname '' '.exe' "$outputname"
7290
outputname=$func_stripname_result ;;
7294
*cygwin* | *mingw* )
7295
func_dirname_and_basename "$output" "" "."
7296
output_name=$func_basename_result
7297
output_path=$func_dirname_result
7298
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7299
cwrapper="$output_path/$output_name.exe"
7300
$RM $cwrappersource $cwrapper
7301
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7303
func_emit_cwrapperexe_src > $cwrappersource
7305
# we should really use a build-platform specific compiler
7306
# here, but OTOH, the wrappers (shell script and this C one)
7307
# are only useful if you want to execute the "real" binary.
7308
# Since the "real" binary is built for $host, then this
7309
# wrapper might as well be built for $host, too.
7311
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7315
# Now, create the wrapper script for func_source use:
7316
func_ltwrapper_scriptname $cwrapper
7317
$RM $func_ltwrapper_scriptname_result
7318
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7320
# note: this script will not be executed, so do not chmod.
7321
if test "x$build" = "x$host" ; then
7322
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7324
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7330
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7332
func_emit_wrapper no > $output
7341
# See if we need to build an old-fashioned archive.
7342
for oldlib in $oldlibs; do
7344
if test "$build_libtool_libs" = convenience; then
7345
oldobjs="$libobjs_save $symfileobj"
7346
addlibs="$convenience"
7347
build_libtool_libs=no
7349
if test "$build_libtool_libs" = module; then
7350
oldobjs="$libobjs_save"
7351
build_libtool_libs=no
7353
oldobjs="$old_deplibs $non_pic_objects"
7354
if test "$preload" = yes && test -f "$symfileobj"; then
7355
oldobjs="$oldobjs $symfileobj"
7358
addlibs="$old_convenience"
7361
if test -n "$addlibs"; then
7362
gentop="$output_objdir/${outputname}x"
7363
generated="$generated $gentop"
7365
func_extract_archives $gentop $addlibs
7366
oldobjs="$oldobjs $func_extract_archives_result"
7369
# Do each command in the archive commands.
7370
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7371
cmds=$old_archive_from_new_cmds
7374
# Add any objects from preloaded convenience libraries
7375
if test -n "$dlprefiles"; then
7376
gentop="$output_objdir/${outputname}x"
7377
generated="$generated $gentop"
7379
func_extract_archives $gentop $dlprefiles
7380
oldobjs="$oldobjs $func_extract_archives_result"
7383
# POSIX demands no paths to be encoded in archives. We have
7384
# to avoid creating archives with duplicate basenames if we
7385
# might have to extract them afterwards, e.g., when creating a
7386
# static archive out of a convenience library, or when linking
7387
# the entirety of a libtool archive into another (currently
7388
# not supported by libtool).
7389
if (for obj in $oldobjs
7391
func_basename "$obj"
7392
$ECHO "$func_basename_result"
7393
done | sort | sort -uc >/dev/null 2>&1); then
7396
$ECHO "copying selected object files to avoid basename conflicts..."
7397
gentop="$output_objdir/${outputname}x"
7398
generated="$generated $gentop"
7399
func_mkdir_p "$gentop"
7400
save_oldobjs=$oldobjs
7403
for obj in $save_oldobjs
7405
func_basename "$obj"
7406
objbase="$func_basename_result"
7407
case " $oldobjs " in
7408
" ") oldobjs=$obj ;;
7411
# Make sure we don't pick an alternate name that also
7413
newobj=lt$counter-$objbase
7414
func_arith $counter + 1
7415
counter=$func_arith_result
7416
case " $oldobjs " in
7417
*[\ /]"$newobj "*) ;;
7418
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
7421
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7422
oldobjs="$oldobjs $gentop/$newobj"
7424
*) oldobjs="$oldobjs $obj" ;;
7428
eval cmds=\"$old_archive_cmds\"
7431
len=$func_len_result
7432
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7433
cmds=$old_archive_cmds
7435
# the command line is too long to link in one step, link in parts
7436
func_verbose "using piecewise archive linking..."
7441
save_oldobjs=$oldobjs
7443
# Is there a better way of finding the last object in the list?
7444
for obj in $save_oldobjs
7448
eval test_cmds=\"$old_archive_cmds\"
7449
func_len " $test_cmds"
7450
len0=$func_len_result
7452
for obj in $save_oldobjs
7455
func_arith $len + $func_len_result
7456
len=$func_arith_result
7457
func_append objlist " $obj"
7458
if test "$len" -lt "$max_cmd_len"; then
7461
# the above command should be used before it gets too long
7463
if test "$obj" = "$last_oldobj" ; then
7466
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7467
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
7474
if test "X$oldobjs" = "X" ; then
7475
eval cmds=\"\$concat_cmds\"
7477
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
7481
func_execute_cmds "$cmds" 'exit $?'
7484
test -n "$generated" && \
7485
func_show_eval "${RM}r$generated"
7487
# Now create the libtool archive.
7491
test "$build_old_libs" = yes && old_library="$libname.$libext"
7492
func_verbose "creating $output"
7494
# Preserve any variables that may affect compiler behavior
7495
for var in $variables_saved_for_relink; do
7496
if eval test -z \"\${$var+set}\"; then
7497
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7498
elif eval var_value=\$$var; test -z "$var_value"; then
7499
relink_command="$var=; export $var; $relink_command"
7501
func_quote_for_eval "$var_value"
7502
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7505
# Quote the link command for shipping.
7506
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
7507
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7508
if test "$hardcode_automatic" = yes ; then
7512
# Only create the output if not a dry run.
7514
for installed in no yes; do
7515
if test "$installed" = yes; then
7516
if test -z "$install_libdir"; then
7519
output="$output_objdir/$outputname"i
7520
# Replace all uninstalled libtool libraries with the installed ones
7522
for deplib in $dependency_libs; do
7525
func_basename "$deplib"
7526
name="$func_basename_result"
7527
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7528
test -z "$libdir" && \
7529
func_fatal_error "\`$deplib' is not a valid libtool archive"
7530
newdependency_libs="$newdependency_libs $libdir/$name"
7532
*) newdependency_libs="$newdependency_libs $deplib" ;;
7535
dependency_libs="$newdependency_libs"
7538
for lib in $dlfiles; do
7541
func_basename "$lib"
7542
name="$func_basename_result"
7543
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7544
test -z "$libdir" && \
7545
func_fatal_error "\`$lib' is not a valid libtool archive"
7546
newdlfiles="$newdlfiles $libdir/$name"
7548
*) newdlfiles="$newdlfiles $lib" ;;
7551
dlfiles="$newdlfiles"
7553
for lib in $dlprefiles; do
7556
# Only pass preopened files to the pseudo-archive (for
7557
# eventual linking with the app. that links it) if we
7558
# didn't already link the preopened objects directly into
7560
func_basename "$lib"
7561
name="$func_basename_result"
7562
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
7563
test -z "$libdir" && \
7564
func_fatal_error "\`$lib' is not a valid libtool archive"
7565
newdlprefiles="$newdlprefiles $libdir/$name"
7569
dlprefiles="$newdlprefiles"
7572
for lib in $dlfiles; do
7574
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7575
*) abs=`pwd`"/$lib" ;;
7577
newdlfiles="$newdlfiles $abs"
7579
dlfiles="$newdlfiles"
7581
for lib in $dlprefiles; do
7583
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
7584
*) abs=`pwd`"/$lib" ;;
7586
newdlprefiles="$newdlprefiles $abs"
7588
dlprefiles="$newdlprefiles"
7591
# place dlname in correct position for cygwin
7593
case $host,$output,$installed,$module,$dlname in
7594
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
7597
# $outputname - a libtool library file
7598
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
7600
# Please DO NOT delete this file!
7601
# It is necessary for linking the library.
7603
# The name that we can dlopen(3).
7606
# Names of this library.
7607
library_names='$library_names'
7609
# The name of the static archive.
7610
old_library='$old_library'
7612
# Linker flags that can not go in dependency_libs.
7613
inherited_linker_flags='$new_inherited_linker_flags'
7615
# Libraries that this one depends upon.
7616
dependency_libs='$dependency_libs'
7618
# Names of additional weak libraries provided by this library
7619
weak_library_names='$weak_libs'
7621
# Version information for $libname.
7626
# Is this an already installed library?
7627
installed=$installed
7629
# Should we warn about portability when linking against -modules?
7630
shouldnotlink=$module
7632
# Files to dlopen/dlpreopen
7634
dlpreopen='$dlprefiles'
7636
# Directory that this library needs to be installed in:
7637
libdir='$install_libdir'"
7638
if test "$installed" = no && test "$need_relink" = yes; then
7640
relink_command=\"$relink_command\""
7645
# Do a symbolic link so that the libtool archive can be found in
7646
# LD_LIBRARY_PATH before the program is installed.
7647
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
7653
{ test "$mode" = link || test "$mode" = relink; } &&
7654
func_mode_link ${1+"$@"}
7657
# func_mode_uninstall arg...
7658
func_mode_uninstall ()
7666
# This variable tells wrapper scripts just to set variables rather
7667
# than running their programs.
7668
libtool_install_magic="$magic"
7673
-f) RM="$RM $arg"; rmforce=yes ;;
7674
-*) RM="$RM $arg" ;;
7675
*) files="$files $arg" ;;
7680
func_fatal_help "you must specify an RM program"
7684
origobjdir="$objdir"
7685
for file in $files; do
7686
func_dirname "$file" "" "."
7687
dir="$func_dirname_result"
7688
if test "X$dir" = X.; then
7689
objdir="$origobjdir"
7691
objdir="$dir/$origobjdir"
7693
func_basename "$file"
7694
name="$func_basename_result"
7695
test "$mode" = uninstall && objdir="$dir"
7697
# Remember objdir for removal later, being careful to avoid duplicates
7698
if test "$mode" = clean; then
7701
*) rmdirs="$rmdirs $objdir" ;;
7705
# Don't error if the file doesn't exist and rm -f was used.
7706
if { test -L "$file"; } >/dev/null 2>&1 ||
7707
{ test -h "$file"; } >/dev/null 2>&1 ||
7708
test -f "$file"; then
7710
elif test -d "$file"; then
7713
elif test "$rmforce" = yes; then
7721
# Possibly a libtool archive, so verify it.
7722
if func_lalib_p "$file"; then
7723
func_source $dir/$name
7725
# Delete the libtool libraries and symlinks.
7726
for n in $library_names; do
7727
rmfiles="$rmfiles $objdir/$n"
7729
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
7733
case " $library_names " in
7734
# " " in the beginning catches empty $dlname
7736
*) rmfiles="$rmfiles $objdir/$dlname" ;;
7738
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
7741
if test -n "$library_names"; then
7742
# Do each command in the postuninstall commands.
7743
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7746
if test -n "$old_library"; then
7747
# Do each command in the old_postuninstall commands.
7748
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
7750
# FIXME: should reinstall the best remaining shared library.
7757
# Possibly a libtool object, so verify it.
7758
if func_lalib_p "$file"; then
7761
func_source $dir/$name
7763
# Add PIC object to the list of files to remove.
7764
if test -n "$pic_object" &&
7765
test "$pic_object" != none; then
7766
rmfiles="$rmfiles $dir/$pic_object"
7769
# Add non-PIC object to the list of files to remove.
7770
if test -n "$non_pic_object" &&
7771
test "$non_pic_object" != none; then
7772
rmfiles="$rmfiles $dir/$non_pic_object"
7778
if test "$mode" = clean ; then
7782
func_stripname '' '.exe' "$file"
7783
file=$func_stripname_result
7784
func_stripname '' '.exe' "$name"
7785
noexename=$func_stripname_result
7786
# $file with .exe has already been added to rmfiles,
7787
# add $file without .exe
7788
rmfiles="$rmfiles $file"
7791
# Do a test to see if this is a libtool program.
7792
if func_ltwrapper_p "$file"; then
7793
if func_ltwrapper_executable_p "$file"; then
7794
func_ltwrapper_scriptname "$file"
7796
func_source $func_ltwrapper_scriptname_result
7797
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
7800
func_source $dir/$noexename
7803
# note $name still contains .exe if it was in $file originally
7804
# as does the version of $file that was added into $rmfiles
7805
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
7806
if test "$fast_install" = yes && test -n "$relink_command"; then
7807
rmfiles="$rmfiles $objdir/lt-$name"
7809
if test "X$noexename" != "X$name" ; then
7810
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
7816
func_show_eval "$RM $rmfiles" 'exit_status=1'
7818
objdir="$origobjdir"
7820
# Try to remove the ${objdir}s in the directories where we deleted files
7821
for dir in $rmdirs; do
7822
if test -d "$dir"; then
7823
func_show_eval "rmdir $dir >/dev/null 2>&1"
7830
{ test "$mode" = uninstall || test "$mode" = clean; } &&
7831
func_mode_uninstall ${1+"$@"}
7833
test -z "$mode" && {
7834
help="$generic_help"
7835
func_fatal_help "you must specify a MODE"
7838
test -z "$exec_cmd" && \
7839
func_fatal_help "invalid operation mode \`$mode'"
7841
if test -n "$exec_cmd"; then
7842
eval exec "$exec_cmd"
7849
# The TAGs below are defined such that we never get into a situation
7850
# in which we disable both kinds of libraries. Given conflicting
7851
# choices, we go for a static library, that is the most portable,
7852
# since we can't tell whether shared libraries were disabled because
7853
# the user asked for that or because the platform doesn't support
7854
# them. This is particularly important on AIX, because we don't
7855
# support having both static and shared libraries enabled at the same
7856
# time on that platform, so we default to a shared-only configuration.
7857
# If a disable-shared tag is given, we'll fallback to a static-only
7858
# configuration. But we'll never go from static-only to shared-only.
7860
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
7861
build_libtool_libs=no
7863
# ### END LIBTOOL TAG CONFIG: disable-shared
7865
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
7866
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
7867
# ### END LIBTOOL TAG CONFIG: disable-static
added
removed
tests/bullet/ltmain.sh
