1
# Generated from ltmain.m4sh.
3
# ltmain.sh (GNU libtool) 2.2.6b
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.6b
69
# automake: $automake_version
70
# autoconf: $autoconf_version
72
# Report bugs to <bug-libtool@gnu.org>.
78
package_revision=1.3017
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="/bin/grep -E"}
120
: ${FGREP="/bin/grep -F"}
121
: ${GREP="/bin/grep"}
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* | *cegcc*)
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.
897
$SED -e 4q "$1" 2>/dev/null \
898
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
901
# func_lalib_unsafe_p file
902
# True iff FILE is a libtool `.la' library or `.lo' object file.
903
# This function implements the same check as func_lalib_p without
904
# resorting to external programs. To this end, it redirects stdin and
905
# closes it afterwards, without saving the original file descriptor.
906
# As a safety measure, use it only where a negative result would be
907
# fatal anyway. Works if `file' does not exist.
908
func_lalib_unsafe_p ()
911
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
912
for lalib_p_l in 1 2 3 4
915
case "$lalib_p_line" in
916
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
921
test "$lalib_p" = yes
924
# func_ltwrapper_script_p file
925
# True iff FILE is a libtool wrapper script
926
# This function is only a basic sanity check; it will hardly flush out
927
# determined imposters.
928
func_ltwrapper_script_p ()
933
# func_ltwrapper_executable_p file
934
# True iff FILE is a libtool wrapper executable
935
# This function is only a basic sanity check; it will hardly flush out
936
# determined imposters.
937
func_ltwrapper_executable_p ()
939
func_ltwrapper_exec_suffix=
942
*) func_ltwrapper_exec_suffix=.exe ;;
944
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
947
# func_ltwrapper_scriptname file
948
# Assumes file is an ltwrapper_executable
949
# uses $file to determine the appropriate filename for a
950
# temporary ltwrapper_script.
951
func_ltwrapper_scriptname ()
953
func_ltwrapper_scriptname_result=""
954
if func_ltwrapper_executable_p "$1"; then
955
func_dirname_and_basename "$1" "" "."
956
func_stripname '' '.exe' "$func_basename_result"
957
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
961
# func_ltwrapper_p file
962
# True iff FILE is a libtool wrapper script or wrapper executable
963
# This function is only a basic sanity check; it will hardly flush out
964
# determined imposters.
967
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
971
# func_execute_cmds commands fail_cmd
972
# Execute tilde-delimited COMMANDS.
973
# If FAIL_CMD is given, eval that upon failure.
974
# FAIL_CMD may read-access the current command in variable CMD!
978
save_ifs=$IFS; IFS='~'
982
func_show_eval "$cmd" "${2-:}"
989
# Source FILE, adding directory component if necessary.
990
# Note that it is not necessary on cygwin/mingw to append a dot to
991
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
992
# behavior happens only for exec(3), not for open(2)! Also, sourcing
993
# `FILE.' does not work on cygwin managed mounts.
998
*/* | *\\*) . "$1" ;;
1004
# func_infer_tag arg
1005
# Infer tagged configuration to use if any are available and
1006
# if one wasn't chosen via the "--tag" command line option.
1007
# Only attempt this if the compiler in the base compile
1008
# command doesn't match the default compiler.
1009
# arg is usually of the form 'gcc ...'
1013
if test -n "$available_tags" && test -z "$tagname"; then
1016
func_quote_for_eval "$arg"
1017
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1020
# Blanks in the command may have been stripped by the calling shell,
1021
# but not from the CC environment variable when configure was run.
1022
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1023
# Blanks at the start of $base_compile will cause this to fail
1024
# if we don't check for them as well.
1026
for z in $available_tags; do
1027
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1028
# Evaluate the configuration.
1029
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1032
# Double-quote args containing other shell metacharacters.
1033
func_quote_for_eval "$arg"
1034
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1037
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1038
# The compiler in the base compile command matches
1039
# the one in the tagged configuration.
1040
# Assume this is the tagged configuration we want.
1047
# If $tagname still isn't set, then no tagged configuration
1048
# was found and let the user know that the "--tag" command
1049
# line option must be used.
1050
if test -z "$tagname"; then
1051
func_echo "unable to infer tagged configuration"
1052
func_fatal_error "specify a tag with \`--tag'"
1054
# func_verbose "using $tagname tagged configuration"
1063
# func_write_libtool_object output_name pic_name nonpic_name
1064
# Create a libtool object file (analogous to a ".la" file),
1065
# but don't create it if we're doing a dry run.
1066
func_write_libtool_object ()
1069
if test "$build_libtool_libs" = yes; then
1075
if test "$build_old_libs" = yes; then
1076
write_oldobj=\'${3}\'
1082
cat >${write_libobj}T <<EOF
1083
# $write_libobj - a libtool object file
1084
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1086
# Please DO NOT delete this file!
1087
# It is necessary for linking the library.
1089
# Name of the PIC object.
1090
pic_object=$write_lobj
1092
# Name of the non-PIC object
1093
non_pic_object=$write_oldobj
1096
$MV "${write_libobj}T" "${write_libobj}"
1100
# func_mode_compile arg...
1101
func_mode_compile ()
1104
# Get the compilation command and the source file.
1106
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1118
# do not "continue". Instead, add this to base_compile
1130
# Accept any command-line options.
1133
test -n "$libobj" && \
1134
func_fatal_error "you cannot specify \`-o' more than once"
1139
-pie | -fpie | -fPIE)
1140
pie_flag="$pie_flag $arg"
1144
-shared | -static | -prefer-pic | -prefer-non-pic)
1155
arg_mode=arg # the next one goes into the "base_compile" arg list
1156
continue # The current "srcfile" will either be retained or
1157
;; # replaced later. I would guess that would be a bug.
1160
func_stripname '-Wc,' '' "$arg"
1161
args=$func_stripname_result
1163
save_ifs="$IFS"; IFS=','
1164
for arg in $args; do
1166
func_quote_for_eval "$arg"
1167
lastarg="$lastarg $func_quote_for_eval_result"
1170
func_stripname ' ' '' "$lastarg"
1171
lastarg=$func_stripname_result
1173
# Add the arguments to base_compile.
1174
base_compile="$base_compile $lastarg"
1179
# Accept the current argument as the source file.
1180
# The previous "srcfile" becomes the current argument.
1187
esac # case $arg_mode
1189
# Aesthetically quote the previous argument.
1190
func_quote_for_eval "$lastarg"
1191
base_compile="$base_compile $func_quote_for_eval_result"
1196
func_fatal_error "you must specify an argument for -Xcompile"
1199
func_fatal_error "you must specify a target with \`-o'"
1202
# Get the name of the library object.
1203
test -z "$libobj" && {
1204
func_basename "$srcfile"
1205
libobj="$func_basename_result"
1210
# Recognize several different file suffixes.
1211
# If the user specifies -o file.o, it is replaced with file.lo
1214
*.ada | *.adb | *.ads | *.asm | \
1215
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1216
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
1217
func_xform "$libobj"
1218
libobj=$func_xform_result
1223
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1225
func_fatal_error "cannot determine name of library object from \`$libobj'"
1229
func_infer_tag $base_compile
1231
for arg in $later; do
1234
test "$build_libtool_libs" != yes && \
1235
func_fatal_configuration "can not build a shared library"
1241
build_libtool_libs=no
1258
func_quote_for_eval "$libobj"
1259
test "X$libobj" != "X$func_quote_for_eval_result" \
1260
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1261
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1262
func_dirname_and_basename "$obj" "/" ""
1263
objname="$func_basename_result"
1264
xdir="$func_dirname_result"
1265
lobj=${xdir}$objdir/$objname
1267
test -z "$base_compile" && \
1268
func_fatal_help "you must specify a compilation command"
1270
# Delete any leftover library objects.
1271
if test "$build_old_libs" = yes; then
1272
removelist="$obj $lobj $libobj ${libobj}T"
1274
removelist="$lobj $libobj ${libobj}T"
1277
# On Cygwin there's no "real" PIC flag so we must build both object types
1279
cygwin* | mingw* | pw32* | os2* | cegcc*)
1283
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1284
# non-PIC code in shared libraries is not supported
1288
# Calculate the filename of the output object if compiler does
1289
# not support -o with -c
1290
if test "$compiler_c_o" = no; then
1291
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1292
lockfile="$output_obj.lock"
1299
# Lock this critical section if it is needed
1300
# We use this script file to make the link, it avoids creating a new file
1301
if test "$need_locks" = yes; then
1302
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1303
func_echo "Waiting for $lockfile to be removed"
1306
elif test "$need_locks" = warn; then
1307
if test -f "$lockfile"; then
1309
*** ERROR, $lockfile exists and contains:
1310
`cat $lockfile 2>/dev/null`
1312
This indicates that another process is trying to use the same
1313
temporary object file, and libtool could not work around it because
1314
your compiler does not support \`-c' and \`-o' together. If you
1315
repeat this compilation, it may succeed, by chance, but you had better
1316
avoid parallel builds (make -j) in this platform, or get a better
1319
$opt_dry_run || $RM $removelist
1322
removelist="$removelist $output_obj"
1323
$ECHO "$srcfile" > "$lockfile"
1326
$opt_dry_run || $RM $removelist
1327
removelist="$removelist $lockfile"
1328
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1330
if test -n "$fix_srcfile_path"; then
1331
eval srcfile=\"$fix_srcfile_path\"
1333
func_quote_for_eval "$srcfile"
1334
qsrcfile=$func_quote_for_eval_result
1336
# Only build a PIC object if we are building libtool libraries.
1337
if test "$build_libtool_libs" = yes; then
1338
# Without this assignment, base_compile gets emptied.
1339
fbsd_hideous_sh_bug=$base_compile
1341
if test "$pic_mode" != no; then
1342
command="$base_compile $qsrcfile $pic_flag"
1344
# Don't build PIC code
1345
command="$base_compile $qsrcfile"
1348
func_mkdir_p "$xdir$objdir"
1350
if test -z "$output_obj"; then
1351
# Place PIC objects in $objdir
1352
command="$command -o $lobj"
1355
func_show_eval_locale "$command" \
1356
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1358
if test "$need_locks" = warn &&
1359
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1361
*** ERROR, $lockfile contains:
1362
`cat $lockfile 2>/dev/null`
1364
but it should contain:
1367
This indicates that another process is trying to use the same
1368
temporary object file, and libtool could not work around it because
1369
your compiler does not support \`-c' and \`-o' together. If you
1370
repeat this compilation, it may succeed, by chance, but you had better
1371
avoid parallel builds (make -j) in this platform, or get a better
1374
$opt_dry_run || $RM $removelist
1378
# Just move the object if needed, then go on to compile the next one
1379
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1380
func_show_eval '$MV "$output_obj" "$lobj"' \
1381
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1384
# Allow error messages only from the first compilation.
1385
if test "$suppress_opt" = yes; then
1386
suppress_output=' >/dev/null 2>&1'
1390
# Only build a position-dependent object if we build old libraries.
1391
if test "$build_old_libs" = yes; then
1392
if test "$pic_mode" != yes; then
1393
# Don't build PIC code
1394
command="$base_compile $qsrcfile$pie_flag"
1396
command="$base_compile $qsrcfile $pic_flag"
1398
if test "$compiler_c_o" = yes; then
1399
command="$command -o $obj"
1402
# Suppress compiler output if we already did a PIC compilation.
1403
command="$command$suppress_output"
1404
func_show_eval_locale "$command" \
1405
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1407
if test "$need_locks" = warn &&
1408
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1410
*** ERROR, $lockfile contains:
1411
`cat $lockfile 2>/dev/null`
1413
but it should contain:
1416
This indicates that another process is trying to use the same
1417
temporary object file, and libtool could not work around it because
1418
your compiler does not support \`-c' and \`-o' together. If you
1419
repeat this compilation, it may succeed, by chance, but you had better
1420
avoid parallel builds (make -j) in this platform, or get a better
1423
$opt_dry_run || $RM $removelist
1427
# Just move the object if needed
1428
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1429
func_show_eval '$MV "$output_obj" "$obj"' \
1430
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1435
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1437
# Unlock the critical section if it was locked
1438
if test "$need_locks" != no; then
1439
removelist=$lockfile
1448
test "$mode" = compile && func_mode_compile ${1+"$@"}
1453
# We need to display help for each of the modes.
1456
# Generic help is extracted from the usage comments
1457
# at the start of this file.
1463
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1465
Remove files from the build directory.
1467
RM is the name of the program to use to delete files associated with each FILE
1468
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1471
If FILE is a libtool library, object or program, all the files associated
1472
with it are deleted. Otherwise, only FILE itself is deleted using RM."
1477
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1479
Compile a source file into a libtool library object.
1481
This mode accepts the following additional options:
1483
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1484
-no-suppress do not suppress compiler output for multiple passes
1485
-prefer-pic try to building PIC objects only
1486
-prefer-non-pic try to building non-PIC objects only
1487
-shared do not build a \`.o' file suitable for static linking
1488
-static only build a \`.o' file suitable for static linking
1490
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1491
from the given SOURCEFILE.
1493
The output file name is determined by removing the directory component from
1494
SOURCEFILE, then substituting the C source code suffix \`.c' with the
1495
library object suffix, \`.lo'."
1500
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1502
Automatically set library path, then run a program.
1504
This mode accepts the following additional options:
1506
-dlopen FILE add the directory containing FILE to the library path
1508
This mode sets the library path environment variable according to \`-dlopen'
1511
If any of the ARGS are libtool executable wrappers, then they are translated
1512
into their corresponding uninstalled binary, and any of their required library
1513
directories are added to the library path.
1515
Then, COMMAND is executed, with ARGS as arguments."
1520
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1522
Complete the installation of libtool libraries.
1524
Each LIBDIR is a directory that contains libtool libraries.
1526
The commands that this mode executes may require superuser privileges. Use
1527
the \`--dry-run' option if you just want to see what would be executed."
1532
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1534
Install executables or libraries.
1536
INSTALL-COMMAND is the installation command. The first component should be
1537
either the \`install' or \`cp' program.
1539
The following components of INSTALL-COMMAND are treated specially:
1541
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1543
The rest of the components are interpreted as arguments to that command (only
1544
BSD-compatible install options are recognized)."
1549
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1551
Link object files or libraries together to form another library, or to
1552
create an executable program.
1554
LINK-COMMAND is a command using the C compiler that you would use to create
1555
a program from several object files.
1557
The following components of LINK-COMMAND are treated specially:
1559
-all-static do not do any dynamic linking at all
1560
-avoid-version do not add a version suffix if possible
1561
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1562
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1563
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1564
-export-symbols SYMFILE
1565
try to export only the symbols listed in SYMFILE
1566
-export-symbols-regex REGEX
1567
try to export only the symbols matching REGEX
1568
-LLIBDIR search LIBDIR for required installed libraries
1569
-lNAME OUTPUT-FILE requires the installed library libNAME
1570
-module build a library that can dlopened
1571
-no-fast-install disable the fast-install mode
1572
-no-install link a not-installable executable
1573
-no-undefined declare that a library does not refer to external symbols
1574
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1575
-objectlist FILE Use a list of object files found in FILE to specify objects
1576
-precious-files-regex REGEX
1577
don't remove output files matching REGEX
1578
-release RELEASE specify package release information
1579
-rpath LIBDIR the created library will eventually be installed in LIBDIR
1580
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1581
-shared only do dynamic linking of libtool libraries
1582
-shrext SUFFIX override the standard shared library file extension
1583
-static do not do any dynamic linking of uninstalled libtool libraries
1584
-static-libtool-libs
1585
do not do any dynamic linking of libtool libraries
1586
-version-info CURRENT[:REVISION[:AGE]]
1587
specify library version info [each variable defaults to 0]
1588
-weak LIBNAME declare that the target provides the LIBNAME interface
1590
All other options (arguments beginning with \`-') are ignored.
1592
Every other argument is treated as a filename. Files ending in \`.la' are
1593
treated as uninstalled libtool libraries, other files are standard or library
1596
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1597
only library objects (\`.lo' files) may be specified, and \`-rpath' is
1598
required, except when creating a convenience library.
1600
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1601
using \`ar' and \`ranlib', or on Windows using \`lib'.
1603
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1604
is created, otherwise an executable program is created."
1609
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1611
Remove libraries from an installation directory.
1613
RM is the name of the program to use to delete files associated with each FILE
1614
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1617
If FILE is a libtool library, all the files associated with it are deleted.
1618
Otherwise, only FILE itself is deleted using RM."
1622
func_fatal_help "invalid operation mode \`$mode'"
1627
$ECHO "Try \`$progname --help' for more information about other modes."
1632
# Now that we've collected a possible --mode arg, show help if necessary
1633
$opt_help && func_mode_help
1636
# func_mode_execute arg...
1637
func_mode_execute ()
1640
# The first argument is the command name.
1643
func_fatal_help "you must specify a COMMAND"
1645
# Handle -dlopen flags immediately.
1646
for file in $execute_dlfiles; do
1648
|| func_fatal_help "\`$file' is not a file"
1653
# Check to see that this really is a libtool archive.
1654
func_lalib_unsafe_p "$file" \
1655
|| func_fatal_help "\`$lib' is not a valid libtool archive"
1657
# Read the libtool library.
1662
# Skip this library if it cannot be dlopened.
1663
if test -z "$dlname"; then
1664
# Warn if it was a shared library.
1665
test -n "$library_names" && \
1666
func_warning "\`$file' was not linked with \`-export-dynamic'"
1670
func_dirname "$file" "" "."
1671
dir="$func_dirname_result"
1673
if test -f "$dir/$objdir/$dlname"; then
1676
if test ! -f "$dir/$dlname"; then
1677
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1683
# Just add the directory containing the .lo file.
1684
func_dirname "$file" "" "."
1685
dir="$func_dirname_result"
1689
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1694
# Get the absolute pathname.
1695
absdir=`cd "$dir" && pwd`
1696
test -n "$absdir" && dir="$absdir"
1698
# Now add the directory to shlibpath_var.
1699
if eval "test -z \"\$$shlibpath_var\""; then
1700
eval "$shlibpath_var=\"\$dir\""
1702
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
1706
# This variable tells wrapper scripts just to set shlibpath_var
1707
# rather than running their programs.
1708
libtool_execute_magic="$magic"
1710
# Check if any of the arguments is a wrapper script.
1717
# Do a test to see if this is really a libtool program.
1718
if func_ltwrapper_script_p "$file"; then
1720
# Transform arg to wrapped name.
1721
file="$progdir/$program"
1722
elif func_ltwrapper_executable_p "$file"; then
1723
func_ltwrapper_scriptname "$file"
1724
func_source "$func_ltwrapper_scriptname_result"
1725
# Transform arg to wrapped name.
1726
file="$progdir/$program"
1730
# Quote arguments (to preserve shell metacharacters).
1731
func_quote_for_eval "$file"
1732
args="$args $func_quote_for_eval_result"
1735
if test "X$opt_dry_run" = Xfalse; then
1736
if test -n "$shlibpath_var"; then
1737
# Export the shlibpath_var.
1738
eval "export $shlibpath_var"
1741
# Restore saved environment variables
1742
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1744
eval "if test \"\${save_$lt_var+set}\" = set; then
1745
$lt_var=\$save_$lt_var; export $lt_var
1751
# Now prepare to actually exec the command.
1752
exec_cmd="\$cmd$args"
1754
# Display what would be done.
1755
if test -n "$shlibpath_var"; then
1756
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1757
$ECHO "export $shlibpath_var"
1764
test "$mode" = execute && func_mode_execute ${1+"$@"}
1767
# func_mode_finish arg...
1774
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1777
libdirs="$libdirs $dir"
1780
for libdir in $libdirs; do
1781
if test -n "$finish_cmds"; then
1782
# Do each command in the finish commands.
1783
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1786
if test -n "$finish_eval"; then
1787
# Do the single finish_eval.
1788
eval cmds=\"$finish_eval\"
1789
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
1795
# Exit here if they wanted silent mode.
1796
$opt_silent && exit $EXIT_SUCCESS
1798
$ECHO "X----------------------------------------------------------------------" | $Xsed
1799
$ECHO "Libraries have been installed in:"
1800
for libdir in $libdirs; do
1804
$ECHO "If you ever happen to want to link against installed libraries"
1805
$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
1806
$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
1807
$ECHO "flag during linking and do at least one of the following:"
1808
if test -n "$shlibpath_var"; then
1809
$ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
1810
$ECHO " during execution"
1812
if test -n "$runpath_var"; then
1813
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
1814
$ECHO " during linking"
1816
if test -n "$hardcode_libdir_flag_spec"; then
1818
eval flag=\"$hardcode_libdir_flag_spec\"
1820
$ECHO " - use the \`$flag' linker flag"
1822
if test -n "$admincmds"; then
1823
$ECHO " - have your system administrator run these commands:$admincmds"
1825
if test -f /etc/ld.so.conf; then
1826
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
1830
$ECHO "See any operating system documentation about shared libraries for"
1832
solaris2.[6789]|solaris2.1[0-9])
1833
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
1837
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
1840
$ECHO "X----------------------------------------------------------------------" | $Xsed
1844
test "$mode" = finish && func_mode_finish ${1+"$@"}
1847
# func_mode_install arg...
1848
func_mode_install ()
1851
# There may be an optional sh(1) argument at the beginning of
1852
# install_prog (especially on Windows NT).
1853
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
1854
# Allow the use of GNU shtool's install command.
1855
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
1856
# Aesthetically quote it.
1857
func_quote_for_eval "$nonopt"
1858
install_prog="$func_quote_for_eval_result "
1866
# The real first argument should be the name of the installation program.
1867
# Aesthetically quote it.
1868
func_quote_for_eval "$arg"
1869
install_prog="$install_prog$func_quote_for_eval_result"
1871
# We need to accept at least all the BSD install flags.
1881
if test -n "$dest"; then
1882
files="$files $dest"
1890
case " $install_prog " in
1905
# If the previous option needed an argument, then skip it.
1906
if test -n "$prev"; then
1915
# Aesthetically quote the argument.
1916
func_quote_for_eval "$arg"
1917
install_prog="$install_prog $func_quote_for_eval_result"
1920
test -z "$install_prog" && \
1921
func_fatal_help "you must specify an install program"
1923
test -n "$prev" && \
1924
func_fatal_help "the \`$prev' option requires an argument"
1926
if test -z "$files"; then
1927
if test -z "$dest"; then
1928
func_fatal_help "no file or destination specified"
1930
func_fatal_help "you must specify a destination"
1934
# Strip any trailing slash from the destination.
1935
func_stripname '' '/' "$dest"
1936
dest=$func_stripname_result
1938
# Check to see that the destination is a directory.
1939
test -d "$dest" && isdir=yes
1940
if test "$isdir" = yes; then
1944
func_dirname_and_basename "$dest" "" "."
1945
destdir="$func_dirname_result"
1946
destname="$func_basename_result"
1948
# Not a directory, so check to see that there is only one file specified.
1949
set dummy $files; shift
1950
test "$#" -gt 1 && \
1951
func_fatal_help "\`$dest' is not a directory"
1954
[\\/]* | [A-Za-z]:[\\/]*) ;;
1956
for file in $files; do
1960
func_fatal_help "\`$destdir' must be an absolute directory name"
1967
# This variable tells wrapper scripts just to set variables rather
1968
# than running their programs.
1969
libtool_install_magic="$magic"
1974
for file in $files; do
1976
# Do each installation.
1979
# Do the static libraries later.
1980
staticlibs="$staticlibs $file"
1984
# Check to see that this really is a libtool archive.
1985
func_lalib_unsafe_p "$file" \
1986
|| func_fatal_help "\`$file' is not a valid libtool archive"
1993
# Add the libdir to current_libdirs if it is the destination.
1994
if test "X$destdir" = "X$libdir"; then
1995
case "$current_libdirs " in
1997
*) current_libdirs="$current_libdirs $libdir" ;;
2000
# Note the libdir as a future libdir.
2001
case "$future_libdirs " in
2003
*) future_libdirs="$future_libdirs $libdir" ;;
2007
func_dirname "$file" "/" ""
2008
dir="$func_dirname_result"
2011
if test -n "$relink_command"; then
2012
# Determine the prefix the user has applied to our future dir.
2013
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2015
# Don't allow the user to place us outside of our expected
2016
# location b/c this prevents finding dependent libraries that
2017
# are installed to the same prefix.
2018
# At present, this check doesn't affect windows .dll's that
2019
# are installed into $libdir/../bin (currently, that works fine)
2020
# but it's something to keep an eye on.
2021
test "$inst_prefix_dir" = "$destdir" && \
2022
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2024
if test -n "$inst_prefix_dir"; then
2025
# Stick the inst_prefix_dir data into the link command.
2026
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2028
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2031
func_warning "relinking \`$file'"
2032
func_show_eval "$relink_command" \
2033
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2036
# See the names of the shared library.
2037
set dummy $library_names; shift
2038
if test -n "$1"; then
2043
test -n "$relink_command" && srcname="$realname"T
2045
# Install the shared library and build the symlinks.
2046
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2050
cygwin* | mingw* | pw32* | cegcc*)
2058
if test -n "$tstripme" && test -n "$striplib"; then
2059
func_show_eval "$striplib $destdir/$realname" 'exit $?'
2062
if test "$#" -gt 0; then
2063
# Delete the old symlinks, and create new ones.
2064
# Try `ln -sf' first, because the `ln' binary might depend on
2065
# the symlink we replace! Solaris /bin/ln does not understand -f,
2066
# so we also need to try rm && ln -s.
2069
test "$linkname" != "$realname" \
2070
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2074
# Do each command in the postinstall commands.
2075
lib="$destdir/$realname"
2076
func_execute_cmds "$postinstall_cmds" 'exit $?'
2079
# Install the pseudo-library for information purposes.
2080
func_basename "$file"
2081
name="$func_basename_result"
2082
instname="$dir/$name"i
2083
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2085
# Maybe install the static library, too.
2086
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2090
# Install (i.e. copy) a libtool object.
2092
# Figure out destination file name, if it wasn't already specified.
2093
if test -n "$destname"; then
2094
destfile="$destdir/$destname"
2096
func_basename "$file"
2097
destfile="$func_basename_result"
2098
destfile="$destdir/$destfile"
2101
# Deduce the name of the destination old-style object file.
2104
func_lo2o "$destfile"
2105
staticdest=$func_lo2o_result
2108
staticdest="$destfile"
2112
func_fatal_help "cannot copy a libtool object to \`$destfile'"
2116
# Install the libtool object if requested.
2117
test -n "$destfile" && \
2118
func_show_eval "$install_prog $file $destfile" 'exit $?'
2120
# Install the old object if enabled.
2121
if test "$build_old_libs" = yes; then
2122
# Deduce the name of the old-style object file.
2124
staticobj=$func_lo2o_result
2125
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2131
# Figure out destination file name, if it wasn't already specified.
2132
if test -n "$destname"; then
2133
destfile="$destdir/$destname"
2135
func_basename "$file"
2136
destfile="$func_basename_result"
2137
destfile="$destdir/$destfile"
2140
# If the file is missing, and there is a .exe on the end, strip it
2141
# because it is most likely a libtool script we actually want to
2146
if test ! -f "$file"; then
2147
func_stripname '' '.exe' "$file"
2148
file=$func_stripname_result
2154
# Do a test to see if this is really a libtool program.
2157
if func_ltwrapper_executable_p "$file"; then
2158
func_ltwrapper_scriptname "$file"
2159
wrapper=$func_ltwrapper_scriptname_result
2161
func_stripname '' '.exe' "$file"
2162
wrapper=$func_stripname_result
2169
if func_ltwrapper_script_p "$wrapper"; then
2173
func_source "$wrapper"
2175
# Check the variables that should have been set.
2176
test -z "$generated_by_libtool_version" && \
2177
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2180
for lib in $notinst_deplibs; do
2181
# Check to see that each library is installed.
2183
if test -f "$lib"; then
2186
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2187
if test -n "$libdir" && test ! -f "$libfile"; then
2188
func_warning "\`$lib' has not been installed in \`$libdir'"
2194
func_source "$wrapper"
2197
if test "$fast_install" = no && test -n "$relink_command"; then
2199
if test "$finalize" = yes; then
2200
tmpdir=`func_mktempdir`
2201
func_basename "$file$stripped_ext"
2202
file="$func_basename_result"
2203
outputname="$tmpdir/$file"
2204
# Replace the output file specification.
2205
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2208
func_quote_for_expand "$relink_command"
2209
eval "func_echo $func_quote_for_expand_result"
2211
if eval "$relink_command"; then :
2213
func_error "error: relink \`$file' with the above command before installing it"
2214
$opt_dry_run || ${RM}r "$tmpdir"
2219
func_warning "cannot relink \`$file'"
2223
# Install the binary that we compiled earlier.
2224
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2228
# remove .exe since cygwin /usr/bin/install will append another
2230
case $install_prog,$host in
2231
*/usr/bin/install*,*cygwin*)
2232
case $file:$destfile in
2237
destfile=$destfile.exe
2240
func_stripname '' '.exe' "$destfile"
2241
destfile=$func_stripname_result
2246
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2247
$opt_dry_run || if test -n "$outputname"; then
2254
for file in $staticlibs; do
2255
func_basename "$file"
2256
name="$func_basename_result"
2258
# Set up the ranlib parameters.
2259
oldlib="$destdir/$name"
2261
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2263
if test -n "$stripme" && test -n "$old_striplib"; then
2264
func_show_eval "$old_striplib $oldlib" 'exit $?'
2267
# Do each command in the postinstall commands.
2268
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2271
test -n "$future_libdirs" && \
2272
func_warning "remember to run \`$progname --finish$future_libdirs'"
2274
if test -n "$current_libdirs"; then
2275
# Maybe just do a dry run.
2276
$opt_dry_run && current_libdirs=" -n$current_libdirs"
2277
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2283
test "$mode" = install && func_mode_install ${1+"$@"}
2286
# func_generate_dlsyms outputname originator pic_p
2287
# Extract symbols from dlprefiles and create ${outputname}S.o with
2288
# a dlpreopen symbol table.
2289
func_generate_dlsyms ()
2295
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2298
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2299
if test -n "$NM" && test -n "$global_symbol_pipe"; then
2300
my_dlsyms="${my_outputname}S.c"
2302
func_error "not configured to extract global symbols from dlpreopened files"
2306
if test -n "$my_dlsyms"; then
2310
# Discover the nlist of each of the dlfiles.
2311
nlist="$output_objdir/${my_outputname}.nm"
2313
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2315
# Parse the name list into a source file.
2316
func_verbose "creating $output_objdir/$my_dlsyms"
2318
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2319
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2320
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2326
/* External symbol declarations for the compiler. */\
2329
if test "$dlself" = yes; then
2330
func_verbose "generating symbol list for \`$output'"
2332
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2334
# Add our own program objects to the symbol list.
2335
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2336
for progfile in $progfiles; do
2337
func_verbose "extracting global C symbols from \`$progfile'"
2338
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2341
if test -n "$exclude_expsyms"; then
2343
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2344
eval '$MV "$nlist"T "$nlist"'
2348
if test -n "$export_symbols_regex"; then
2350
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2351
eval '$MV "$nlist"T "$nlist"'
2355
# Prepare the list of exported symbols
2356
if test -z "$export_symbols"; then
2357
export_symbols="$output_objdir/$outputname.exp"
2360
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2362
*cygwin* | *mingw* | *cegcc* )
2363
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2364
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2370
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2371
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2372
eval '$MV "$nlist"T "$nlist"'
2374
*cygwin | *mingw* | *cegcc* )
2375
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2376
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2383
for dlprefile in $dlprefiles; do
2384
func_verbose "extracting global C symbols from \`$dlprefile'"
2385
func_basename "$dlprefile"
2386
name="$func_basename_result"
2388
eval '$ECHO ": $name " >> "$nlist"'
2389
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2394
# Make sure we have at least an empty file.
2395
test -f "$nlist" || : > "$nlist"
2397
if test -n "$exclude_expsyms"; then
2398
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2399
$MV "$nlist"T "$nlist"
2402
# Try sorting and uniquifying the output.
2403
if $GREP -v "^: " < "$nlist" |
2404
if sort -k 3 </dev/null >/dev/null 2>&1; then
2409
uniq > "$nlist"S; then
2412
$GREP -v "^: " < "$nlist" > "$nlist"S
2415
if test -f "$nlist"S; then
2416
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2418
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2421
$ECHO >> "$output_objdir/$my_dlsyms" "\
2423
/* The mapping between symbol names and symbols. */
2430
*cygwin* | *mingw* | *cegcc* )
2431
$ECHO >> "$output_objdir/$my_dlsyms" "\
2432
/* DATA imports from DLLs on WIN32 con't be const, because
2433
runtime relocations are performed -- see ld's documentation
2434
on pseudo-relocs. */"
2437
echo >> "$output_objdir/$my_dlsyms" "\
2438
/* This system does not cope well with relocations in const data */"
2441
lt_dlsym_const=const ;;
2444
$ECHO >> "$output_objdir/$my_dlsyms" "\
2445
extern $lt_dlsym_const lt_dlsymlist
2446
lt_${my_prefix}_LTX_preloaded_symbols[];
2447
$lt_dlsym_const lt_dlsymlist
2448
lt_${my_prefix}_LTX_preloaded_symbols[] =
2450
{ \"$my_originator\", (void *) 0 },"
2452
case $need_lib_prefix in
2454
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2457
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2460
$ECHO >> "$output_objdir/$my_dlsyms" "\
2464
/* This works around a problem in FreeBSD linker */
2465
#ifdef FREEBSD_WORKAROUND
2466
static const void *lt_preloaded_setup() {
2467
return lt_${my_prefix}_LTX_preloaded_symbols;
2477
pic_flag_for_symtable=
2478
case "$compile_command " in
2482
# compiling the symbol table file with pic_flag works around
2483
# a FreeBSD bug that causes programs to crash when -lm is
2484
# linked before any other PIC object. But we must not use
2485
# pic_flag when linking with -static. The problem exists in
2486
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2487
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2488
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2490
pic_flag_for_symtable=" $pic_flag" ;;
2492
if test "X$my_pic_p" != Xno; then
2493
pic_flag_for_symtable=" $pic_flag"
2500
for arg in $LTCFLAGS; do
2502
-pie | -fpie | -fPIE) ;;
2503
*) symtab_cflags="$symtab_cflags $arg" ;;
2507
# Now compile the dynamic symbol file.
2508
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2510
# Clean up the generated files.
2511
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2513
# Transform the symbol file into the correct name.
2514
symfileobj="$output_objdir/${my_outputname}S.$objext"
2516
*cygwin* | *mingw* | *cegcc* )
2517
if test -f "$output_objdir/$my_outputname.def"; then
2518
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2519
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2521
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2522
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2526
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2527
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
2532
func_fatal_error "unknown suffix for \`$my_dlsyms'"
2536
# We keep going just in case the user didn't refer to
2537
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2538
# really was required.
2540
# Nullify the symbol file.
2541
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
2542
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
2546
# func_win32_libid arg
2547
# return the library type of file 'arg'
2549
# Need a lot of goo to handle *both* DLLs and import libs
2550
# Has to be a shell function in order to 'eat' the argument
2551
# that is supplied when $file_magic_command is called.
2555
win32_libid_type="unknown"
2556
win32_fileres=`file -L $1 2>/dev/null`
2557
case $win32_fileres in
2558
*ar\ archive\ import\ library*) # definitely import
2559
win32_libid_type="x86 archive import"
2561
*ar\ archive*) # could be an import, or static
2562
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
2563
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
2564
win32_nmres=`eval $NM -f posix -A $1 |
2573
case $win32_nmres in
2574
import*) win32_libid_type="x86 archive import";;
2575
*) win32_libid_type="x86 archive static";;
2580
win32_libid_type="x86 DLL"
2582
*executable*) # but shell scripts are "executable" too...
2583
case $win32_fileres in
2584
*MS\ Windows\ PE\ Intel*)
2585
win32_libid_type="x86 DLL"
2590
$ECHO "$win32_libid_type"
2595
# func_extract_an_archive dir oldlib
2596
func_extract_an_archive ()
2599
f_ex_an_ar_dir="$1"; shift
2600
f_ex_an_ar_oldlib="$1"
2601
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
2602
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2605
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2610
# func_extract_archives gentop oldlib ...
2611
func_extract_archives ()
2614
my_gentop="$1"; shift
2615
my_oldlibs=${1+"$@"}
2621
for my_xlib in $my_oldlibs; do
2622
# Extract the objects.
2624
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2625
*) my_xabs=`pwd`"/$my_xlib" ;;
2627
func_basename "$my_xlib"
2628
my_xlib="$func_basename_result"
2631
case " $extracted_archives " in
2633
func_arith $extracted_serial + 1
2634
extracted_serial=$func_arith_result
2635
my_xlib_u=lt$extracted_serial-$my_xlib ;;
2639
extracted_archives="$extracted_archives $my_xlib_u"
2640
my_xdir="$my_gentop/$my_xlib_u"
2642
func_mkdir_p "$my_xdir"
2646
func_verbose "Extracting $my_xabs"
2647
# Do not bother doing anything if just a dry run
2649
darwin_orig_dir=`pwd`
2650
cd $my_xdir || exit $?
2651
darwin_archive=$my_xabs
2653
darwin_base_archive=`basename "$darwin_archive"`
2654
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2655
if test -n "$darwin_arches"; then
2656
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2658
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2659
for darwin_arch in $darwin_arches ; do
2660
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2661
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2662
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2663
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2665
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2666
done # $darwin_arches
2667
## Okay now we've a bunch of thin objects, gotta fatten them up :)
2668
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2671
for darwin_file in $darwin_filelist; do
2672
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2673
$LIPO -create -output "$darwin_file" $darwin_files
2674
done # $darwin_filelist
2676
cd "$darwin_orig_dir"
2679
func_extract_an_archive "$my_xdir" "$my_xabs"
2684
func_extract_an_archive "$my_xdir" "$my_xabs"
2687
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2690
func_extract_archives_result="$my_oldobjs"
2695
# func_emit_wrapper_part1 [arg=no]
2697
# Emit the first part of a libtool wrapper script on stdout.
2698
# For more information, see the description associated with
2699
# func_emit_wrapper(), below.
2700
func_emit_wrapper_part1 ()
2702
func_emit_wrapper_part1_arg1=no
2703
if test -n "$1" ; then
2704
func_emit_wrapper_part1_arg1=$1
2710
# $output - temporary wrapper script for $objdir/$outputname
2711
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2713
# The $output program cannot be directly executed until all the libtool
2714
# libraries that it depends on are installed.
2716
# This wrapper script should never be moved out of the build directory.
2717
# If it is, it will not operate correctly.
2719
# Sed substitution that helps us do robust quoting. It backslashifies
2720
# metacharacters that are still active within double-quoted strings.
2721
Xsed='${SED} -e 1s/^X//'
2722
sed_quote_subst='$sed_quote_subst'
2724
# Be Bourne compatible
2725
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2728
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2729
# is contrary to our usage. Disable this feature.
2730
alias -g '\${1+\"\$@\"}'='\"\$@\"'
2731
setopt NO_GLOB_SUBST
2733
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2735
BIN_SH=xpg4; export BIN_SH # for Tru64
2736
DUALCASE=1; export DUALCASE # for MKS sh
2738
# The HP-UX ksh and POSIX shell print the target directory to stdout
2740
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2742
relink_command=\"$relink_command\"
2744
# This environment variable determines our operation mode.
2745
if test \"\$libtool_install_magic\" = \"$magic\"; then
2746
# install mode needs the following variables:
2747
generated_by_libtool_version='$macro_version'
2748
notinst_deplibs='$notinst_deplibs'
2750
# When we are sourced in execute mode, \$file and \$ECHO are already set.
2751
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2754
# Make sure echo works.
2755
if test \"X\$1\" = X--no-reexec; then
2756
# Discard the --no-reexec flag, and continue.
2758
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
2759
# Yippee, \$ECHO works!
2762
# Restart under the correct shell, and then maybe \$ECHO will work.
2763
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
2769
# Find the directory that this script lives in.
2770
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
2771
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
2773
# Follow symbolic links until we get to the real thisdir.
2774
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
2775
while test -n \"\$file\"; do
2776
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
2778
# If there was a directory component, then change thisdir.
2779
if test \"x\$destdir\" != \"x\$file\"; then
2780
case \"\$destdir\" in
2781
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
2782
*) thisdir=\"\$thisdir/\$destdir\" ;;
2786
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
2787
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
2791
# end: func_emit_wrapper_part1
2793
# func_emit_wrapper_part2 [arg=no]
2795
# Emit the second part of a libtool wrapper script on stdout.
2796
# For more information, see the description associated with
2797
# func_emit_wrapper(), below.
2798
func_emit_wrapper_part2 ()
2800
func_emit_wrapper_part2_arg1=no
2801
if test -n "$1" ; then
2802
func_emit_wrapper_part2_arg1=$1
2807
# Usually 'no', except on cygwin/mingw when embedded into
2809
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
2810
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
2811
# special case for '.'
2812
if test \"\$thisdir\" = \".\"; then
2815
# remove .libs from thisdir
2816
case \"\$thisdir\" in
2817
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
2818
$objdir ) thisdir=. ;;
2822
# Try to get the absolute directory name.
2823
absdir=\`cd \"\$thisdir\" && pwd\`
2824
test -n \"\$absdir\" && thisdir=\"\$absdir\"
2827
if test "$fast_install" = yes; then
2829
program=lt-'$outputname'$exeext
2830
progdir=\"\$thisdir/$objdir\"
2832
if test ! -f \"\$progdir/\$program\" ||
2833
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
2834
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
2836
file=\"\$\$-\$program\"
2838
if test ! -d \"\$progdir\"; then
2839
$MKDIR \"\$progdir\"
2841
$RM \"\$progdir/\$file\"
2846
# relink executable if necessary
2847
if test -n \"\$relink_command\"; then
2848
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
2850
$ECHO \"\$relink_command_output\" >&2
2851
$RM \"\$progdir/\$file\"
2856
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
2857
{ $RM \"\$progdir/\$program\";
2858
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
2859
$RM \"\$progdir/\$file\"
2863
program='$outputname'
2864
progdir=\"\$thisdir/$objdir\"
2870
if test -f \"\$progdir/\$program\"; then"
2872
# Export our shlibpath_var if we have one.
2873
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
2875
# Add our own library path to $shlibpath_var
2876
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
2878
# Some systems cannot cope with colon-terminated $shlibpath_var
2879
# The second colon is a workaround for a bug in BeOS R4 sed
2880
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
2882
export $shlibpath_var
2886
# fixup the dll searchpath if we need to.
2887
if test -n "$dllsearchpath"; then
2889
# Add the dll search path components to the executable PATH
2890
PATH=$dllsearchpath:\$PATH
2895
if test \"\$libtool_execute_magic\" != \"$magic\"; then
2896
# Run the actual program with our arguments.
2899
# Backslashes separate directories on plain windows
2900
*-*-mingw | *-*-os2* | *-cegcc*)
2902
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
2908
exec \"\$progdir/\$program\" \${1+\"\$@\"}
2913
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
2917
# The program doesn't exist.
2918
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
2919
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
2920
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
2926
# end: func_emit_wrapper_part2
2929
# func_emit_wrapper [arg=no]
2931
# Emit a libtool wrapper script on stdout.
2932
# Don't directly open a file because we may want to
2933
# incorporate the script contents within a cygwin/mingw
2934
# wrapper executable. Must ONLY be called from within
2935
# func_mode_link because it depends on a number of variables
2938
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2939
# variable will take. If 'yes', then the emitted script
2940
# will assume that the directory in which it is stored is
2941
# the $objdir directory. This is a cygwin/mingw-specific
2943
func_emit_wrapper ()
2945
func_emit_wrapper_arg1=no
2946
if test -n "$1" ; then
2947
func_emit_wrapper_arg1=$1
2950
# split this up so that func_emit_cwrapperexe_src
2951
# can call each part independently.
2952
func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
2953
func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
2957
# func_to_host_path arg
2959
# Convert paths to host format when used with build tools.
2960
# Intended for use with "native" mingw (where libtool itself
2961
# is running under the msys shell), or in the following cross-
2962
# build environments:
2964
# mingw (msys) mingw [e.g. native]
2967
# where wine is equipped with the `winepath' executable.
2968
# In the native mingw case, the (msys) shell automatically
2969
# converts paths for any non-msys applications it launches,
2970
# but that facility isn't available from inside the cwrapper.
2971
# Similar accommodations are necessary for $host mingw and
2972
# $build cygwin. Calling this function does no harm for other
2973
# $host/$build combinations not listed above.
2975
# ARG is the path (on $build) that should be converted to
2976
# the proper representation for $host. The result is stored
2977
# in $func_to_host_path_result.
2978
func_to_host_path ()
2980
func_to_host_path_result="$1"
2981
if test -n "$1" ; then
2984
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
2986
*mingw* ) # actually, msys
2987
# awkward: cmd appends spaces to result
2988
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
2989
func_to_host_path_tmp1=`( cmd //c echo "$1" |\
2990
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
2991
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2992
$SED -e "$lt_sed_naive_backslashify"`
2995
func_to_host_path_tmp1=`cygpath -w "$1"`
2996
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
2997
$SED -e "$lt_sed_naive_backslashify"`
3000
# Unfortunately, winepath does not exit with a non-zero
3001
# error code, so we are forced to check the contents of
3002
# stdout. On the other hand, if the command is not
3003
# found, the shell will set an exit code of 127 and print
3004
# *an error message* to stdout. So we must check for both
3005
# error code of zero AND non-empty stdout, which explains
3006
# the odd construction:
3007
func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3008
if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3009
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3010
$SED -e "$lt_sed_naive_backslashify"`
3012
# Allow warning below.
3013
func_to_host_path_result=""
3017
if test -z "$func_to_host_path_result" ; then
3018
func_error "Could not determine host path corresponding to"
3020
func_error "Continuing, but uninstalled executables may not work."
3022
func_to_host_path_result="$1"
3028
# end: func_to_host_path
3030
# func_to_host_pathlist arg
3032
# Convert pathlists to host format when used with build tools.
3033
# See func_to_host_path(), above. This function supports the
3034
# following $build/$host combinations (but does no harm for
3035
# combinations not listed here):
3037
# mingw (msys) mingw [e.g. native]
3041
# Path separators are also converted from $build format to
3042
# $host format. If ARG begins or ends with a path separator
3043
# character, it is preserved (but converted to $host format)
3046
# ARG is a pathlist (on $build) that should be converted to
3047
# the proper representation on $host. The result is stored
3048
# in $func_to_host_pathlist_result.
3049
func_to_host_pathlist ()
3051
func_to_host_pathlist_result="$1"
3052
if test -n "$1" ; then
3055
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3056
# Remove leading and trailing path separator characters from
3057
# ARG. msys behavior is inconsistent here, cygpath turns them
3058
# into '.;' and ';.', and winepath ignores them completely.
3059
func_to_host_pathlist_tmp2="$1"
3060
# Once set for this call, this variable should not be
3061
# reassigned. It is used in tha fallback case.
3062
func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3063
$SED -e 's|^:*||' -e 's|:*$||'`
3065
*mingw* ) # Actually, msys.
3066
# Awkward: cmd appends spaces to result.
3067
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3068
func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3069
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3070
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3071
$SED -e "$lt_sed_naive_backslashify"`
3074
func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3075
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3076
$SED -e "$lt_sed_naive_backslashify"`
3079
# unfortunately, winepath doesn't convert pathlists
3080
func_to_host_pathlist_result=""
3081
func_to_host_pathlist_oldIFS=$IFS
3083
for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3084
IFS=$func_to_host_pathlist_oldIFS
3085
if test -n "$func_to_host_pathlist_f" ; then
3086
func_to_host_path "$func_to_host_pathlist_f"
3087
if test -n "$func_to_host_path_result" ; then
3088
if test -z "$func_to_host_pathlist_result" ; then
3089
func_to_host_pathlist_result="$func_to_host_path_result"
3091
func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3097
IFS=$func_to_host_pathlist_oldIFS
3100
if test -z "$func_to_host_pathlist_result" ; then
3101
func_error "Could not determine the host path(s) corresponding to"
3103
func_error "Continuing, but uninstalled executables may not work."
3104
# Fallback. This may break if $1 contains DOS-style drive
3105
# specifications. The fix is not to complicate the expression
3106
# below, but for the user to provide a working wine installation
3107
# with winepath so that path translation in the cross-to-mingw
3108
# case works properly.
3109
lt_replace_pathsep_nix_to_dos="s|:|;|g"
3110
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3111
$SED -e "$lt_replace_pathsep_nix_to_dos"`
3113
# Now, add the leading and trailing path separators back
3115
:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3119
*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3126
# end: func_to_host_pathlist
3128
# func_emit_cwrapperexe_src
3129
# emit the source code for a wrapper executable on stdout
3130
# Must ONLY be called from within func_mode_link because
3131
# it depends on a number of variable set therein.
3132
func_emit_cwrapperexe_src ()
3136
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3137
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3139
The $output program cannot be directly executed until all the libtool
3140
libraries that it depends on are installed.
3142
This wrapper executable should never be moved out of the build directory.
3143
If it is, it will not operate correctly.
3145
Currently, it simply execs the wrapper *script* "$SHELL $output",
3146
but could eventually absorb all of the scripts functionality and
3147
exec $objdir/$outputname directly.
3154
# include <direct.h>
3155
# include <process.h>
3157
# define setmode _setmode
3159
# include <unistd.h>
3160
# include <stdint.h>
3163
# define HAVE_SETENV
3164
# ifdef __STRICT_ANSI__
3165
char *realpath (const char *, char *);
3166
int putenv (char *);
3167
int setenv (const char *, const char *, int);
3178
#include <sys/stat.h>
3180
#if defined(PATH_MAX)
3181
# define LT_PATHMAX PATH_MAX
3182
#elif defined(MAXPATHLEN)
3183
# define LT_PATHMAX MAXPATHLEN
3185
# define LT_PATHMAX 1024
3196
# define S_IXUSR _S_IEXEC
3198
# ifndef _INTPTR_T_DEFINED
3199
# define intptr_t int
3203
#ifndef DIR_SEPARATOR
3204
# define DIR_SEPARATOR '/'
3205
# define PATH_SEPARATOR ':'
3208
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3210
# define HAVE_DOS_BASED_FILE_SYSTEM
3211
# define FOPEN_WB "wb"
3212
# ifndef DIR_SEPARATOR_2
3213
# define DIR_SEPARATOR_2 '\\'
3215
# ifndef PATH_SEPARATOR_2
3216
# define PATH_SEPARATOR_2 ';'
3220
#ifndef DIR_SEPARATOR_2
3221
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3222
#else /* DIR_SEPARATOR_2 */
3223
# define IS_DIR_SEPARATOR(ch) \
3224
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3225
#endif /* DIR_SEPARATOR_2 */
3227
#ifndef PATH_SEPARATOR_2
3228
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3229
#else /* PATH_SEPARATOR_2 */
3230
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3231
#endif /* PATH_SEPARATOR_2 */
3234
# define FOPEN_WB "wb"
3238
# define FOPEN_WB "w"
3241
# define _O_BINARY 0
3244
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3245
#define XFREE(stale) do { \
3246
if (stale) { free ((void *) stale); stale = 0; } \
3249
#undef LTWRAPPER_DEBUGPRINTF
3250
#if defined DEBUGWRAPPER
3251
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3253
ltwrapper_debugprintf (const char *fmt, ...)
3256
va_start (args, fmt);
3257
(void) vfprintf (stderr, fmt, args);
3261
# define LTWRAPPER_DEBUGPRINTF(args)
3264
const char *program_name = NULL;
3266
void *xmalloc (size_t num);
3267
char *xstrdup (const char *string);
3268
const char *base_name (const char *name);
3269
char *find_executable (const char *wrapper);
3270
char *chase_symlinks (const char *pathspec);
3271
int make_executable (const char *path);
3272
int check_executable (const char *path);
3273
char *strendzap (char *str, const char *pat);
3274
void lt_fatal (const char *message, ...);
3275
void lt_setenv (const char *name, const char *value);
3276
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3277
void lt_opt_process_env_set (const char *arg);
3278
void lt_opt_process_env_prepend (const char *arg);
3279
void lt_opt_process_env_append (const char *arg);
3280
int lt_split_name_value (const char *arg, char** name, char** value);
3281
void lt_update_exe_path (const char *name, const char *value);
3282
void lt_update_lib_path (const char *name, const char *value);
3284
static const char *script_text_part1 =
3287
func_emit_wrapper_part1 yes |
3288
$SED -e 's/\([\\"]\)/\\\1/g' \
3289
-e 's/^/ "/' -e 's/$/\\n"/'
3293
static const char *script_text_part2 =
3295
func_emit_wrapper_part2 yes |
3296
$SED -e 's/\([\\"]\)/\\\1/g' \
3297
-e 's/^/ "/' -e 's/$/\\n"/'
3301
const char * MAGIC_EXE = "$magic_exe";
3302
const char * LIB_PATH_VARNAME = "$shlibpath_var";
3305
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3306
func_to_host_pathlist "$temp_rpath"
3308
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3312
const char * LIB_PATH_VALUE = "";
3316
if test -n "$dllsearchpath"; then
3317
func_to_host_pathlist "$dllsearchpath:"
3319
const char * EXE_PATH_VARNAME = "PATH";
3320
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3324
const char * EXE_PATH_VARNAME = "";
3325
const char * EXE_PATH_VALUE = "";
3329
if test "$fast_install" = yes; then
3331
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3335
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3342
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3343
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3345
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3348
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3350
static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3351
static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";
3352
/* argument is putenv-style "foo=bar", value of foo is set to bar */
3354
static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3355
static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";
3356
/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3358
static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3359
static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";
3360
/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3363
main (int argc, char *argv[])
3368
char *actual_cwrapper_path;
3369
char *actual_cwrapper_name;
3372
intptr_t rval = 127;
3376
program_name = (char *) xstrdup (base_name (argv[0]));
3377
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3378
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3380
/* very simple arg parsing; don't want to rely on getopt */
3381
for (i = 1; i < argc; i++)
3383
if (strcmp (argv[i], dumpscript_opt) == 0)
3387
*mingw* | *cygwin* )
3388
# make stdout use "unix" line endings
3389
echo " setmode(1,_O_BINARY);"
3394
printf ("%s", script_text_part1);
3395
printf ("%s", script_text_part2);
3400
newargz = XMALLOC (char *, argc + 1);
3401
tmp_pathspec = find_executable (argv[0]);
3402
if (tmp_pathspec == NULL)
3403
lt_fatal ("Couldn't find %s", argv[0]);
3404
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3407
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3408
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3409
actual_cwrapper_path));
3410
XFREE (tmp_pathspec);
3412
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3413
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3415
/* wrapper name transforms */
3416
strendzap (actual_cwrapper_name, ".exe");
3417
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3418
XFREE (actual_cwrapper_name);
3419
actual_cwrapper_name = tmp_pathspec;
3422
/* target_name transforms -- use actual target program name; might have lt- prefix */
3423
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3424
strendzap (target_name, ".exe");
3425
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3426
XFREE (target_name);
3427
target_name = tmp_pathspec;
3430
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3436
XMALLOC (char, (strlen (actual_cwrapper_path) +
3437
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3438
strcpy (newargz[0], actual_cwrapper_path);
3439
strcat (newargz[0], "$objdir");
3440
strcat (newargz[0], "/");
3444
/* stop here, and copy so we don't have to do this twice */
3445
tmp_pathspec = xstrdup (newargz[0]);
3447
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3448
strcat (newargz[0], actual_cwrapper_name);
3450
/* DO want the lt- prefix here if it exists, so use target_name */
3451
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3452
XFREE (tmp_pathspec);
3453
tmp_pathspec = NULL;
3461
while ((p = strchr (newargz[0], '\\')) != NULL)
3465
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3475
XFREE (target_name);
3476
XFREE (actual_cwrapper_path);
3477
XFREE (actual_cwrapper_name);
3479
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3480
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3481
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3482
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3485
for (i = 1; i < argc; i++)
3487
if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3489
if (argv[i][env_set_opt_len] == '=')
3491
const char *p = argv[i] + env_set_opt_len + 1;
3492
lt_opt_process_env_set (p);
3494
else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3496
lt_opt_process_env_set (argv[++i]); /* don't copy */
3499
lt_fatal ("%s missing required argument", env_set_opt);
3502
if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3504
if (argv[i][env_prepend_opt_len] == '=')
3506
const char *p = argv[i] + env_prepend_opt_len + 1;
3507
lt_opt_process_env_prepend (p);
3509
else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3511
lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3514
lt_fatal ("%s missing required argument", env_prepend_opt);
3517
if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3519
if (argv[i][env_append_opt_len] == '=')
3521
const char *p = argv[i] + env_append_opt_len + 1;
3522
lt_opt_process_env_append (p);
3524
else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3526
lt_opt_process_env_append (argv[++i]); /* don't copy */
3529
lt_fatal ("%s missing required argument", env_append_opt);
3532
if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3534
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3535
namespace, but it is not one of the ones we know about and
3536
have already dealt with, above (inluding dump-script), then
3537
report an error. Otherwise, targets might begin to believe
3538
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3539
namespace. The first time any user complains about this, we'll
3540
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3541
or a configure.ac-settable value.
3543
lt_fatal ("Unrecognized option in %s namespace: '%s'",
3544
ltwrapper_option_prefix, argv[i]);
3547
newargz[++newargc] = xstrdup (argv[i]);
3549
newargz[++newargc] = NULL;
3551
LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3552
for (i = 0; i < newargc; i++)
3554
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3562
/* execv doesn't actually work on mingw as expected on unix */
3563
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3566
/* failed to start process */
3567
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3575
execv (lt_argv_zero, newargz);
3576
return rval; /* =127, but avoids unused variable warning */
3585
xmalloc (size_t num)
3587
void *p = (void *) malloc (num);
3589
lt_fatal ("Memory exhausted");
3595
xstrdup (const char *string)
3597
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3602
base_name (const char *name)
3606
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3607
/* Skip over the disk name in MSDOS pathnames. */
3608
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3612
for (base = name; *name; name++)
3613
if (IS_DIR_SEPARATOR (*name))
3619
check_executable (const char *path)
3623
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3624
path ? (*path ? path : "EMPTY!") : "NULL!"));
3625
if ((!path) || (!*path))
3628
if ((stat (path, &st) >= 0)
3629
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3636
make_executable (const char *path)
3641
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3642
path ? (*path ? path : "EMPTY!") : "NULL!"));
3643
if ((!path) || (!*path))
3646
if (stat (path, &st) >= 0)
3648
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3653
/* Searches for the full path of the wrapper. Returns
3654
newly allocated full path name if found, NULL otherwise
3655
Does not chase symlinks, even on platforms that support them.
3658
find_executable (const char *wrapper)
3663
/* static buffer for getcwd */
3664
char tmp[LT_PATHMAX + 1];
3668
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3669
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3671
if ((wrapper == NULL) || (*wrapper == '\0'))
3674
/* Absolute path? */
3675
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3676
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3678
concat_name = xstrdup (wrapper);
3679
if (check_executable (concat_name))
3681
XFREE (concat_name);
3686
if (IS_DIR_SEPARATOR (wrapper[0]))
3688
concat_name = xstrdup (wrapper);
3689
if (check_executable (concat_name))
3691
XFREE (concat_name);
3693
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3697
for (p = wrapper; *p; p++)
3705
/* no slashes; search PATH */
3706
const char *path = getenv ("PATH");
3709
for (p = path; *p; p = p_next)
3713
for (q = p; *q; q++)
3714
if (IS_PATH_SEPARATOR (*q))
3717
p_next = (*q == '\0' ? q : q + 1);
3720
/* empty path: current directory */
3721
if (getcwd (tmp, LT_PATHMAX) == NULL)
3722
lt_fatal ("getcwd failed");
3723
tmp_len = strlen (tmp);
3725
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3726
memcpy (concat_name, tmp, tmp_len);
3727
concat_name[tmp_len] = '/';
3728
strcpy (concat_name + tmp_len + 1, wrapper);
3733
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3734
memcpy (concat_name, p, p_len);
3735
concat_name[p_len] = '/';
3736
strcpy (concat_name + p_len + 1, wrapper);
3738
if (check_executable (concat_name))
3740
XFREE (concat_name);
3743
/* not found in PATH; assume curdir */
3745
/* Relative path | not found in path: prepend cwd */
3746
if (getcwd (tmp, LT_PATHMAX) == NULL)
3747
lt_fatal ("getcwd failed");
3748
tmp_len = strlen (tmp);
3749
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3750
memcpy (concat_name, tmp, tmp_len);
3751
concat_name[tmp_len] = '/';
3752
strcpy (concat_name + tmp_len + 1, wrapper);
3754
if (check_executable (concat_name))
3756
XFREE (concat_name);
3761
chase_symlinks (const char *pathspec)
3764
return xstrdup (pathspec);
3766
char buf[LT_PATHMAX];
3768
char *tmp_pathspec = xstrdup (pathspec);
3770
int has_symlinks = 0;
3771
while (strlen (tmp_pathspec) && !has_symlinks)
3773
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3775
if (lstat (tmp_pathspec, &s) == 0)
3777
if (S_ISLNK (s.st_mode) != 0)
3783
/* search backwards for last DIR_SEPARATOR */
3784
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3785
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3787
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3789
/* no more DIR_SEPARATORS left */
3796
char *errstr = strerror (errno);
3797
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3800
XFREE (tmp_pathspec);
3804
return xstrdup (pathspec);
3807
tmp_pathspec = realpath (pathspec, buf);
3808
if (tmp_pathspec == 0)
3810
lt_fatal ("Could not follow symlinks for %s", pathspec);
3812
return xstrdup (tmp_pathspec);
3817
strendzap (char *str, const char *pat)
3821
assert (str != NULL);
3822
assert (pat != NULL);
3825
patlen = strlen (pat);
3829
str += len - patlen;
3830
if (strcmp (str, pat) == 0)
3837
lt_error_core (int exit_status, const char *mode,
3838
const char *message, va_list ap)
3840
fprintf (stderr, "%s: %s: ", program_name, mode);
3841
vfprintf (stderr, message, ap);
3842
fprintf (stderr, ".\n");
3844
if (exit_status >= 0)
3849
lt_fatal (const char *message, ...)
3852
va_start (ap, message);
3853
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3858
lt_setenv (const char *name, const char *value)
3860
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3861
(name ? name : "<NULL>"),
3862
(value ? value : "<NULL>")));
3865
/* always make a copy, for consistency with !HAVE_SETENV */
3866
char *str = xstrdup (value);
3867
setenv (name, str, 1);
3869
int len = strlen (name) + 1 + strlen (value) + 1;
3870
char *str = XMALLOC (char, len);
3871
sprintf (str, "%s=%s", name, value);
3872
if (putenv (str) != EXIT_SUCCESS)
3881
lt_extend_str (const char *orig_value, const char *add, int to_end)
3884
if (orig_value && *orig_value)
3886
int orig_value_len = strlen (orig_value);
3887
int add_len = strlen (add);
3888
new_value = XMALLOC (char, add_len + orig_value_len + 1);
3891
strcpy (new_value, orig_value);
3892
strcpy (new_value + orig_value_len, add);
3896
strcpy (new_value, add);
3897
strcpy (new_value + add_len, orig_value);
3902
new_value = xstrdup (add);
3908
lt_split_name_value (const char *arg, char** name, char** value)
3915
p = strchr (arg, (int)'=');
3920
*value = xstrdup (++p);
3922
len = strlen (arg) - strlen (*value);
3923
*name = XMALLOC (char, len);
3924
strncpy (*name, arg, len-1);
3925
(*name)[len - 1] = '\0';
3931
lt_opt_process_env_set (const char *arg)
3936
if (lt_split_name_value (arg, &name, &value) != 0)
3940
lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3943
lt_setenv (name, value);
3949
lt_opt_process_env_prepend (const char *arg)
3953
char *new_value = NULL;
3955
if (lt_split_name_value (arg, &name, &value) != 0)
3959
lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3962
new_value = lt_extend_str (getenv (name), value, 0);
3963
lt_setenv (name, new_value);
3970
lt_opt_process_env_append (const char *arg)
3974
char *new_value = NULL;
3976
if (lt_split_name_value (arg, &name, &value) != 0)
3980
lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3983
new_value = lt_extend_str (getenv (name), value, 1);
3984
lt_setenv (name, new_value);
3991
lt_update_exe_path (const char *name, const char *value)
3993
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3994
(name ? name : "<NULL>"),
3995
(value ? value : "<NULL>")));
3997
if (name && *name && value && *value)
3999
char *new_value = lt_extend_str (getenv (name), value, 0);
4000
/* some systems can't cope with a ':'-terminated path #' */
4001
int len = strlen (new_value);
4002
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4004
new_value[len-1] = '\0';
4006
lt_setenv (name, new_value);
4012
lt_update_lib_path (const char *name, const char *value)
4014
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4015
(name ? name : "<NULL>"),
4016
(value ? value : "<NULL>")));
4018
if (name && *name && value && *value)
4020
char *new_value = lt_extend_str (getenv (name), value, 0);
4021
lt_setenv (name, new_value);
4029
# end: func_emit_cwrapperexe_src
4031
# func_mode_link arg...
4036
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4037
# It is impossible to link a dll without this setting, and
4038
# we shouldn't force the makefile maintainer to figure out
4039
# which system we are compiling for in order to pass an extra
4040
# flag for every libtool invocation.
4041
# allow_undefined=no
4043
# FIXME: Unfortunately, there are problems with the above when trying
4044
# to make a dll which has undefined symbols, in which case not
4045
# even a static library is built. For now, we need to specify
4046
# -no-undefined on the libtool link line when we can be certain
4047
# that all symbols are satisfied, otherwise we get a static library.
4054
libtool_args=$nonopt
4055
base_compile="$nonopt $@"
4056
compile_command=$nonopt
4057
finalize_command=$nonopt
4070
lib_search_path=`pwd`
4072
new_inherited_linker_flags=
4080
export_symbols_regex=
4088
precious_files_regex=
4089
prefer_static_libs=no
4102
single_module="${wl}-single_module"
4103
func_infer_tag $base_compile
4105
# We need to know -static, to get the right output filenames.
4110
test "$build_libtool_libs" != yes && \
4111
func_fatal_configuration "can not build a shared library"
4115
-all-static | -static | -static-libtool-libs)
4118
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4119
func_warning "complete static linking is impossible in this configuration"
4121
if test -n "$link_static_flag"; then
4122
dlopen_self=$dlopen_self_static
4124
prefer_static_libs=yes
4127
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4128
dlopen_self=$dlopen_self_static
4130
prefer_static_libs=built
4132
-static-libtool-libs)
4133
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4134
dlopen_self=$dlopen_self_static
4136
prefer_static_libs=yes
4139
build_libtool_libs=no
4146
# See if our shared archives depend on static archives.
4147
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4149
# Go through the arguments, transforming them on the way.
4150
while test "$#" -gt 0; do
4153
func_quote_for_eval "$arg"
4154
qarg=$func_quote_for_eval_unquoted_result
4155
func_append libtool_args " $func_quote_for_eval_result"
4157
# If the previous option needs an argument, assign it.
4158
if test -n "$prev"; then
4161
func_append compile_command " @OUTPUT@"
4162
func_append finalize_command " @OUTPUT@"
4168
if test "$preload" = no; then
4169
# Add the symbol object into the linking commands.
4170
func_append compile_command " @SYMFILE@"
4171
func_append finalize_command " @SYMFILE@"
4175
*.la | *.lo) ;; # We handle these cases below.
4177
if test "$dlself" = no; then
4185
if test "$prev" = dlprefiles; then
4187
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4197
if test "$prev" = dlfiles; then
4198
dlfiles="$dlfiles $arg"
4200
dlprefiles="$dlprefiles $arg"
4208
export_symbols="$arg"
4210
|| func_fatal_error "symbol file \`$arg' does not exist"
4215
export_symbols_regex="$arg"
4223
*" $qarg.ltframework "*) ;;
4224
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4233
inst_prefix_dir="$arg"
4238
if test -f "$arg"; then
4241
for fil in `cat "$save_arg"`
4243
# moreargs="$moreargs $fil"
4245
# A libtool-controlled object.
4247
# Check to see that this really is a libtool object.
4248
if func_lalib_unsafe_p "$arg"; then
4255
if test -z "$pic_object" ||
4256
test -z "$non_pic_object" ||
4257
test "$pic_object" = none &&
4258
test "$non_pic_object" = none; then
4259
func_fatal_error "cannot find name of object for \`$arg'"
4262
# Extract subdirectory from the argument.
4263
func_dirname "$arg" "/" ""
4264
xdir="$func_dirname_result"
4266
if test "$pic_object" != none; then
4267
# Prepend the subdirectory the object is found in.
4268
pic_object="$xdir$pic_object"
4270
if test "$prev" = dlfiles; then
4271
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4272
dlfiles="$dlfiles $pic_object"
4276
# If libtool objects are unsupported, then we need to preload.
4281
# CHECK ME: I think I busted this. -Ossama
4282
if test "$prev" = dlprefiles; then
4283
# Preload the old-style object.
4284
dlprefiles="$dlprefiles $pic_object"
4289
func_append libobjs " $pic_object"
4294
if test "$non_pic_object" != none; then
4295
# Prepend the subdirectory the object is found in.
4296
non_pic_object="$xdir$non_pic_object"
4298
# A standard non-PIC object
4299
func_append non_pic_objects " $non_pic_object"
4300
if test -z "$pic_object" || test "$pic_object" = none ; then
4301
arg="$non_pic_object"
4304
# If the PIC object exists, use it instead.
4305
# $xdir was prepended to $pic_object above.
4306
non_pic_object="$pic_object"
4307
func_append non_pic_objects " $non_pic_object"
4310
# Only an error if not doing a dry-run.
4311
if $opt_dry_run; then
4312
# Extract subdirectory from the argument.
4313
func_dirname "$arg" "/" ""
4314
xdir="$func_dirname_result"
4317
pic_object=$xdir$objdir/$func_lo2o_result
4318
non_pic_object=$xdir$func_lo2o_result
4319
func_append libobjs " $pic_object"
4320
func_append non_pic_objects " $non_pic_object"
4322
func_fatal_error "\`$arg' is not a valid libtool object"
4327
func_fatal_error "link input file \`$arg' does not exist"
4334
precious_files_regex="$arg"
4344
# We need an absolute path.
4346
[\\/]* | [A-Za-z]:[\\/]*) ;;
4348
func_fatal_error "only absolute run-paths are allowed"
4351
if test "$prev" = rpath; then
4354
*) rpath="$rpath $arg" ;;
4359
*) xrpath="$xrpath $arg" ;;
4371
weak_libs="$weak_libs $arg"
4376
linker_flags="$linker_flags $qarg"
4377
compiler_flags="$compiler_flags $qarg"
4379
func_append compile_command " $qarg"
4380
func_append finalize_command " $qarg"
4384
compiler_flags="$compiler_flags $qarg"
4386
func_append compile_command " $qarg"
4387
func_append finalize_command " $qarg"
4391
linker_flags="$linker_flags $qarg"
4392
compiler_flags="$compiler_flags $wl$qarg"
4394
func_append compile_command " $wl$qarg"
4395
func_append finalize_command " $wl$qarg"
4399
eval "$prev=\"\$arg\""
4404
fi # test -n "$prev"
4410
if test -n "$link_static_flag"; then
4411
# See comment for -static flag below, for more details.
4412
func_append compile_command " $link_static_flag"
4413
func_append finalize_command " $link_static_flag"
4419
# FIXME: remove this flag sometime in the future.
4420
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4443
-export-symbols | -export-symbols-regex)
4444
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4445
func_fatal_error "more than one -exported-symbols argument is not allowed"
4447
if test "X$arg" = "X-export-symbols"; then
4465
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4466
# so, if we see these flags be careful not to treat them like -L
4468
case $with_gcc/$host in
4469
no/*-*-irix* | /*-*-irix*)
4470
func_append compile_command " $arg"
4471
func_append finalize_command " $arg"
4478
func_stripname '-L' '' "$arg"
4479
dir=$func_stripname_result
4480
if test -z "$dir"; then
4481
if test "$#" -gt 0; then
4482
func_fatal_error "require no space between \`-L' and \`$1'"
4484
func_fatal_error "need path for \`-L' option"
4487
# We need an absolute path.
4489
[\\/]* | [A-Za-z]:[\\/]*) ;;
4491
absdir=`cd "$dir" && pwd`
4492
test -z "$absdir" && \
4493
func_fatal_error "cannot determine absolute directory name of \`$dir'"
4500
deplibs="$deplibs -L$dir"
4501
lib_search_path="$lib_search_path $dir"
4505
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4506
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4507
case :$dllsearchpath: in
4509
::) dllsearchpath=$dir;;
4510
*) dllsearchpath="$dllsearchpath:$dir";;
4512
case :$dllsearchpath: in
4513
*":$testbindir:"*) ;;
4514
::) dllsearchpath=$testbindir;;
4515
*) dllsearchpath="$dllsearchpath:$testbindir";;
4523
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4525
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4526
# These systems don't actually have a C or math library (as such)
4530
# These systems don't actually have a C library (as such)
4531
test "X$arg" = "X-lc" && continue
4533
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4534
# Do not include libc due to us having libc/libc_r.
4535
test "X$arg" = "X-lc" && continue
4537
*-*-rhapsody* | *-*-darwin1.[012])
4538
# Rhapsody C and math libraries are in the System framework
4539
deplibs="$deplibs System.ltframework"
4542
*-*-sco3.2v5* | *-*-sco5v6*)
4543
# Causes problems with __ctype
4544
test "X$arg" = "X-lc" && continue
4546
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4547
# Compiler inserts libc in the correct place for threads to work
4548
test "X$arg" = "X-lc" && continue
4551
elif test "X$arg" = "X-lc_r"; then
4553
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4554
# Do not include libc_r directly, use -pthread flag.
4559
deplibs="$deplibs $arg"
4568
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4569
# classes, name mangling, and exception handling.
4570
# Darwin uses the -arch flag to determine output architecture.
4571
-model|-arch|-isysroot)
4572
compiler_flags="$compiler_flags $arg"
4573
func_append compile_command " $arg"
4574
func_append finalize_command " $arg"
4579
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4580
compiler_flags="$compiler_flags $arg"
4581
func_append compile_command " $arg"
4582
func_append finalize_command " $arg"
4583
case "$new_inherited_linker_flags " in
4585
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4591
single_module="${wl}-multi_module"
4602
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4603
# The PATH hackery in wrapper scripts is required on Windows
4604
# and Darwin in order for the loader to find any dlls it needs.
4605
func_warning "\`-no-install' is ignored for $host"
4606
func_warning "assuming \`-no-fast-install' instead"
4609
*) no_install=yes ;;
4626
-precious-files-regex)
4647
func_stripname '-R' '' "$arg"
4648
dir=$func_stripname_result
4649
# We need an absolute path.
4651
[\\/]* | [A-Za-z]:[\\/]*) ;;
4653
func_fatal_error "only absolute run-paths are allowed"
4658
*) xrpath="$xrpath $dir" ;;
4664
# The effects of -shared are defined in a previous loop.
4673
-static | -static-libtool-libs)
4674
# The effects of -static are defined in a previous loop.
4675
# We used to do the same as -all-static on platforms that
4676
# didn't have a PIC flag, but the assumption that the effects
4677
# would be equivalent was wrong. It would break on at least
4678
# Digital Unix and AIX.
4704
func_stripname '-Wc,' '' "$arg"
4705
args=$func_stripname_result
4707
save_ifs="$IFS"; IFS=','
4708
for flag in $args; do
4710
func_quote_for_eval "$flag"
4711
arg="$arg $wl$func_quote_for_eval_result"
4712
compiler_flags="$compiler_flags $func_quote_for_eval_result"
4715
func_stripname ' ' '' "$arg"
4716
arg=$func_stripname_result
4720
func_stripname '-Wl,' '' "$arg"
4721
args=$func_stripname_result
4723
save_ifs="$IFS"; IFS=','
4724
for flag in $args; do
4726
func_quote_for_eval "$flag"
4727
arg="$arg $wl$func_quote_for_eval_result"
4728
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4729
linker_flags="$linker_flags $func_quote_for_eval_result"
4732
func_stripname ' ' '' "$arg"
4733
arg=$func_stripname_result
4753
func_quote_for_eval "$arg"
4754
arg="$func_quote_for_eval_result"
4757
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4758
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4759
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4760
# +DA*, +DD* enable 64-bit mode on the HP compiler
4761
# -q* pass through compiler args for the IBM compiler
4762
# -m*, -t[45]*, -txscale* pass through architecture-specific
4763
# compiler args for GCC
4764
# -F/path gives path to uninstalled frameworks, gcc on darwin
4765
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4766
# @file GCC response files
4767
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4768
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4769
func_quote_for_eval "$arg"
4770
arg="$func_quote_for_eval_result"
4771
func_append compile_command " $arg"
4772
func_append finalize_command " $arg"
4773
compiler_flags="$compiler_flags $arg"
4777
# Some other compiler flag.
4779
func_quote_for_eval "$arg"
4780
arg="$func_quote_for_eval_result"
4784
# A standard object.
4789
# A libtool-controlled object.
4791
# Check to see that this really is a libtool object.
4792
if func_lalib_unsafe_p "$arg"; then
4799
if test -z "$pic_object" ||
4800
test -z "$non_pic_object" ||
4801
test "$pic_object" = none &&
4802
test "$non_pic_object" = none; then
4803
func_fatal_error "cannot find name of object for \`$arg'"
4806
# Extract subdirectory from the argument.
4807
func_dirname "$arg" "/" ""
4808
xdir="$func_dirname_result"
4810
if test "$pic_object" != none; then
4811
# Prepend the subdirectory the object is found in.
4812
pic_object="$xdir$pic_object"
4814
if test "$prev" = dlfiles; then
4815
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4816
dlfiles="$dlfiles $pic_object"
4820
# If libtool objects are unsupported, then we need to preload.
4825
# CHECK ME: I think I busted this. -Ossama
4826
if test "$prev" = dlprefiles; then
4827
# Preload the old-style object.
4828
dlprefiles="$dlprefiles $pic_object"
4833
func_append libobjs " $pic_object"
4838
if test "$non_pic_object" != none; then
4839
# Prepend the subdirectory the object is found in.
4840
non_pic_object="$xdir$non_pic_object"
4842
# A standard non-PIC object
4843
func_append non_pic_objects " $non_pic_object"
4844
if test -z "$pic_object" || test "$pic_object" = none ; then
4845
arg="$non_pic_object"
4848
# If the PIC object exists, use it instead.
4849
# $xdir was prepended to $pic_object above.
4850
non_pic_object="$pic_object"
4851
func_append non_pic_objects " $non_pic_object"
4854
# Only an error if not doing a dry-run.
4855
if $opt_dry_run; then
4856
# Extract subdirectory from the argument.
4857
func_dirname "$arg" "/" ""
4858
xdir="$func_dirname_result"
4861
pic_object=$xdir$objdir/$func_lo2o_result
4862
non_pic_object=$xdir$func_lo2o_result
4863
func_append libobjs " $pic_object"
4864
func_append non_pic_objects " $non_pic_object"
4866
func_fatal_error "\`$arg' is not a valid libtool object"
4873
deplibs="$deplibs $arg"
4874
old_deplibs="$old_deplibs $arg"
4879
# A libtool-controlled library.
4881
if test "$prev" = dlfiles; then
4882
# This library was specified with -dlopen.
4883
dlfiles="$dlfiles $arg"
4885
elif test "$prev" = dlprefiles; then
4886
# The library was specified with -dlpreopen.
4887
dlprefiles="$dlprefiles $arg"
4890
deplibs="$deplibs $arg"
4895
# Some other compiler argument.
4897
# Unknown arguments in both finalize_command and compile_command need
4898
# to be aesthetically quoted because they are evaled later.
4899
func_quote_for_eval "$arg"
4900
arg="$func_quote_for_eval_result"
4904
# Now actually substitute the argument into the commands.
4905
if test -n "$arg"; then
4906
func_append compile_command " $arg"
4907
func_append finalize_command " $arg"
4909
done # argument parsing loop
4911
test -n "$prev" && \
4912
func_fatal_help "the \`$prevarg' option requires an argument"
4914
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4915
eval arg=\"$export_dynamic_flag_spec\"
4916
func_append compile_command " $arg"
4917
func_append finalize_command " $arg"
4921
# calculate the name of the file, without its directory
4922
func_basename "$output"
4923
outputname="$func_basename_result"
4924
libobjs_save="$libobjs"
4926
if test -n "$shlibpath_var"; then
4927
# get the directories listed in $shlibpath_var
4928
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4932
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4933
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4935
func_dirname "$output" "/" ""
4936
output_objdir="$func_dirname_result$objdir"
4937
# Create the object directory.
4938
func_mkdir_p "$output_objdir"
4940
# Determine the type of output
4943
func_fatal_help "you must specify an output file"
4945
*.$libext) linkmode=oldlib ;;
4946
*.lo | *.$objext) linkmode=obj ;;
4947
*.la) linkmode=lib ;;
4948
*) linkmode=prog ;; # Anything else should be a program.
4954
# Find all interdependent deplibs by searching for libraries
4955
# that are linked more than once (e.g. -la -lb -la)
4956
for deplib in $deplibs; do
4957
if $opt_duplicate_deps ; then
4959
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4962
libs="$libs $deplib"
4965
if test "$linkmode" = lib; then
4966
libs="$predeps $libs $compiler_lib_search_path $postdeps"
4968
# Compute libraries that are listed more than once in $predeps
4969
# $postdeps and mark them as special (i.e., whose duplicates are
4970
# not to be eliminated).
4972
if $opt_duplicate_compiler_generated_deps; then
4973
for pre_post_dep in $predeps $postdeps; do
4974
case "$pre_post_deps " in
4975
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4977
pre_post_deps="$pre_post_deps $pre_post_dep"
4986
need_relink=no # whether we're linking any uninstalled libtool libraries
4987
notinst_deplibs= # not-installed libtool libraries
4988
notinst_path= # paths that contain not-installed libtool libraries
4992
passes="conv dlpreopen link"
4993
for file in $dlfiles $dlprefiles; do
4997
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5008
passes="conv scan dlopen dlpreopen link"
5014
for pass in $passes; do
5015
# The preopen pass in lib mode reverses $deplibs; put it back here
5016
# so that -L comes before libs that need it for instance...
5017
if test "$linkmode,$pass" = "lib,link"; then
5018
## FIXME: Find the place where the list is rebuilt in the wrong
5019
## order, and fix it there properly
5021
for deplib in $deplibs; do
5022
tmp_deplibs="$deplib $tmp_deplibs"
5024
deplibs="$tmp_deplibs"
5027
if test "$linkmode,$pass" = "lib,link" ||
5028
test "$linkmode,$pass" = "prog,scan"; then
5032
if test "$linkmode" = prog; then
5034
dlopen) libs="$dlfiles" ;;
5035
dlpreopen) libs="$dlprefiles" ;;
5036
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5039
if test "$linkmode,$pass" = "lib,dlpreopen"; then
5040
# Collect and forward deplibs of preopened libtool libs
5041
for lib in $dlprefiles; do
5042
# Ignore non-libtool-libs
5045
*.la) func_source "$lib" ;;
5048
# Collect preopened libtool deplibs, except any this library
5049
# has declared as weak libs
5050
for deplib in $dependency_libs; do
5051
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5052
case " $weak_libs " in
5053
*" $deplib_base "*) ;;
5054
*) deplibs="$deplibs $deplib" ;;
5060
if test "$pass" = dlopen; then
5061
# Collect dlpreopened libraries
5062
save_deplibs="$deplibs"
5066
for deplib in $libs; do
5070
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5071
if test "$linkmode,$pass" = "prog,link"; then
5072
compile_deplibs="$deplib $compile_deplibs"
5073
finalize_deplibs="$deplib $finalize_deplibs"
5075
compiler_flags="$compiler_flags $deplib"
5076
if test "$linkmode" = lib ; then
5077
case "$new_inherited_linker_flags " in
5079
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5086
if test "$linkmode" != lib && test "$linkmode" != prog; then
5087
func_warning "\`-l' is ignored for archives/objects"
5090
func_stripname '-l' '' "$deplib"
5091
name=$func_stripname_result
5092
if test "$linkmode" = lib; then
5093
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5095
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5097
for searchdir in $searchdirs; do
5098
for search_ext in .la $std_shrext .so .a; do
5099
# Search the libtool library
5100
lib="$searchdir/lib${name}${search_ext}"
5101
if test -f "$lib"; then
5102
if test "$search_ext" = ".la"; then
5111
if test "$found" != yes; then
5112
# deplib doesn't seem to be a libtool library
5113
if test "$linkmode,$pass" = "prog,link"; then
5114
compile_deplibs="$deplib $compile_deplibs"
5115
finalize_deplibs="$deplib $finalize_deplibs"
5117
deplibs="$deplib $deplibs"
5118
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5121
else # deplib is a libtool library
5122
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5123
# We need to do some special things here, and not later.
5124
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5125
case " $predeps $postdeps " in
5127
if func_lalib_p "$lib"; then
5131
for l in $old_library $library_names; do
5134
if test "X$ll" = "X$old_library" ; then # only static version available
5136
func_dirname "$lib" "" "."
5137
ladir="$func_dirname_result"
5138
lib=$ladir/$old_library
5139
if test "$linkmode,$pass" = "prog,link"; then
5140
compile_deplibs="$deplib $compile_deplibs"
5141
finalize_deplibs="$deplib $finalize_deplibs"
5143
deplibs="$deplib $deplibs"
5144
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5156
if test "$linkmode,$pass" = "prog,link"; then
5157
compile_deplibs="$deplib $compile_deplibs"
5158
finalize_deplibs="$deplib $finalize_deplibs"
5160
deplibs="$deplib $deplibs"
5161
if test "$linkmode" = lib ; then
5162
case "$new_inherited_linker_flags " in
5164
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5173
deplibs="$deplib $deplibs"
5174
test "$pass" = conv && continue
5175
newdependency_libs="$deplib $newdependency_libs"
5176
func_stripname '-L' '' "$deplib"
5177
newlib_search_path="$newlib_search_path $func_stripname_result"
5180
if test "$pass" = conv; then
5181
deplibs="$deplib $deplibs"
5184
if test "$pass" = scan; then
5185
deplibs="$deplib $deplibs"
5187
compile_deplibs="$deplib $compile_deplibs"
5188
finalize_deplibs="$deplib $finalize_deplibs"
5190
func_stripname '-L' '' "$deplib"
5191
newlib_search_path="$newlib_search_path $func_stripname_result"
5194
func_warning "\`-L' is ignored for archives/objects"
5200
if test "$pass" = link; then
5201
func_stripname '-R' '' "$deplib"
5202
dir=$func_stripname_result
5203
# Make sure the xrpath contains only unique directories.
5206
*) xrpath="$xrpath $dir" ;;
5209
deplibs="$deplib $deplibs"
5212
*.la) lib="$deplib" ;;
5214
if test "$pass" = conv; then
5215
deplibs="$deplib $deplibs"
5220
# Linking convenience modules into shared libraries is allowed,
5221
# but linking other static libraries is non-portable.
5222
case " $dlpreconveniencelibs " in
5226
case $deplibs_check_method in
5228
set dummy $deplibs_check_method; shift
5229
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5230
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5231
| $EGREP "$match_pattern_regex" > /dev/null; then
5239
if test "$valid_a_lib" != yes; then
5241
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5242
$ECHO "*** I have the capability to make that library automatically link in when"
5243
$ECHO "*** you link to this library. But I can only do this if you have a"
5244
$ECHO "*** shared version of the library, which you do not appear to have"
5245
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5246
$ECHO "*** that it is just a static archive that I should not use here."
5249
$ECHO "*** Warning: Linking the shared library $output against the"
5250
$ECHO "*** static library $deplib is not portable!"
5251
deplibs="$deplib $deplibs"
5258
if test "$pass" != link; then
5259
deplibs="$deplib $deplibs"
5261
compile_deplibs="$deplib $compile_deplibs"
5262
finalize_deplibs="$deplib $finalize_deplibs"
5269
if test "$pass" = conv; then
5270
deplibs="$deplib $deplibs"
5271
elif test "$linkmode" = prog; then
5272
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5273
# If there is no dlopen support or we're linking statically,
5274
# we need to preload.
5275
newdlprefiles="$newdlprefiles $deplib"
5276
compile_deplibs="$deplib $compile_deplibs"
5277
finalize_deplibs="$deplib $finalize_deplibs"
5279
newdlfiles="$newdlfiles $deplib"
5290
if test "$found" = yes || test -f "$lib"; then :
5292
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5295
# Check to see that this really is a libtool archive.
5296
func_lalib_unsafe_p "$lib" \
5297
|| func_fatal_error "\`$lib' is not a valid libtool archive"
5299
func_dirname "$lib" "" "."
5300
ladir="$func_dirname_result"
5308
inherited_linker_flags=
5309
# If the library was installed with an old release of libtool,
5310
# it will not redefine variables installed, or shouldnotlink
5319
# Convert "-framework foo" to "foo.ltframework"
5320
if test -n "$inherited_linker_flags"; then
5321
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5322
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5323
case " $new_inherited_linker_flags " in
5324
*" $tmp_inherited_linker_flag "*) ;;
5325
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5329
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5330
if test "$linkmode,$pass" = "lib,link" ||
5331
test "$linkmode,$pass" = "prog,scan" ||
5332
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5333
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5334
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5337
if test "$pass" = conv; then
5338
# Only check for convenience libraries
5339
deplibs="$lib $deplibs"
5340
if test -z "$libdir"; then
5341
if test -z "$old_library"; then
5342
func_fatal_error "cannot find name of link library for \`$lib'"
5344
# It is a libtool convenience library, so add in its objects.
5345
convenience="$convenience $ladir/$objdir/$old_library"
5346
old_convenience="$old_convenience $ladir/$objdir/$old_library"
5347
elif test "$linkmode" != prog && test "$linkmode" != lib; then
5348
func_fatal_error "\`$lib' is not a convenience library"
5351
for deplib in $dependency_libs; do
5352
deplibs="$deplib $deplibs"
5353
if $opt_duplicate_deps ; then
5354
case "$tmp_libs " in
5355
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5358
tmp_libs="$tmp_libs $deplib"
5364
# Get the name of the library we link against.
5366
for l in $old_library $library_names; do
5369
if test -z "$linklib"; then
5370
func_fatal_error "cannot find name of link library for \`$lib'"
5373
# This library was specified with -dlopen.
5374
if test "$pass" = dlopen; then
5375
if test -z "$libdir"; then
5376
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5378
if test -z "$dlname" ||
5379
test "$dlopen_support" != yes ||
5380
test "$build_libtool_libs" = no; then
5381
# If there is no dlname, no dlopen support or we're linking
5382
# statically, we need to preload. We also need to preload any
5383
# dependent libraries so libltdl's deplib preloader doesn't
5384
# bomb out in the load deplibs phase.
5385
dlprefiles="$dlprefiles $lib $dependency_libs"
5387
newdlfiles="$newdlfiles $lib"
5392
# We need an absolute path.
5394
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5396
abs_ladir=`cd "$ladir" && pwd`
5397
if test -z "$abs_ladir"; then
5398
func_warning "cannot determine absolute directory name of \`$ladir'"
5399
func_warning "passing it literally to the linker, although it might fail"
5404
func_basename "$lib"
5405
laname="$func_basename_result"
5407
# Find the relevant object directory and library name.
5408
if test "X$installed" = Xyes; then
5409
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5410
func_warning "library \`$lib' was moved."
5418
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5420
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5423
# Remove this search path later
5424
notinst_path="$notinst_path $abs_ladir"
5426
dir="$ladir/$objdir"
5427
absdir="$abs_ladir/$objdir"
5428
# Remove this search path later
5429
notinst_path="$notinst_path $abs_ladir"
5431
fi # $installed = yes
5432
func_stripname 'lib' '.la' "$laname"
5433
name=$func_stripname_result
5435
# This library was specified with -dlpreopen.
5436
if test "$pass" = dlpreopen; then
5437
if test -z "$libdir" && test "$linkmode" = prog; then
5438
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5440
# Prefer using a static library (so that no silly _DYNAMIC symbols
5441
# are required to link).
5442
if test -n "$old_library"; then
5443
newdlprefiles="$newdlprefiles $dir/$old_library"
5444
# Keep a list of preopened convenience libraries to check
5445
# that they are being used correctly in the link pass.
5446
test -z "$libdir" && \
5447
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5448
# Otherwise, use the dlname, so that lt_dlopen finds it.
5449
elif test -n "$dlname"; then
5450
newdlprefiles="$newdlprefiles $dir/$dlname"
5452
newdlprefiles="$newdlprefiles $dir/$linklib"
5454
fi # $pass = dlpreopen
5456
if test -z "$libdir"; then
5457
# Link the convenience library
5458
if test "$linkmode" = lib; then
5459
deplibs="$dir/$old_library $deplibs"
5460
elif test "$linkmode,$pass" = "prog,link"; then
5461
compile_deplibs="$dir/$old_library $compile_deplibs"
5462
finalize_deplibs="$dir/$old_library $finalize_deplibs"
5464
deplibs="$lib $deplibs" # used for prog,scan pass
5470
if test "$linkmode" = prog && test "$pass" != link; then
5471
newlib_search_path="$newlib_search_path $ladir"
5472
deplibs="$lib $deplibs"
5475
if test "$link_all_deplibs" != no || test -z "$library_names" ||
5476
test "$build_libtool_libs" = no; then
5481
for deplib in $dependency_libs; do
5483
-L*) func_stripname '-L' '' "$deplib"
5484
newlib_search_path="$newlib_search_path $func_stripname_result"
5487
# Need to link against all dependency_libs?
5488
if test "$linkalldeplibs" = yes; then
5489
deplibs="$deplib $deplibs"
5491
# Need to hardcode shared library paths
5492
# or/and link against static libraries
5493
newdependency_libs="$deplib $newdependency_libs"
5495
if $opt_duplicate_deps ; then
5496
case "$tmp_libs " in
5497
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5500
tmp_libs="$tmp_libs $deplib"
5503
fi # $linkmode = prog...
5505
if test "$linkmode,$pass" = "prog,link"; then
5506
if test -n "$library_names" &&
5507
{ { test "$prefer_static_libs" = no ||
5508
test "$prefer_static_libs,$installed" = "built,yes"; } ||
5509
test -z "$old_library"; }; then
5510
# We need to hardcode the library path
5511
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5512
# Make sure the rpath contains only unique directories.
5513
case "$temp_rpath:" in
5515
*) temp_rpath="$temp_rpath$absdir:" ;;
5519
# Hardcode the library path.
5520
# Skip directories that are in the system default run-time
5522
case " $sys_lib_dlsearch_path " in
5525
case "$compile_rpath " in
5527
*) compile_rpath="$compile_rpath $absdir"
5531
case " $sys_lib_dlsearch_path " in
5534
case "$finalize_rpath " in
5536
*) finalize_rpath="$finalize_rpath $libdir"
5540
fi # $linkmode,$pass = prog,link...
5542
if test "$alldeplibs" = yes &&
5543
{ test "$deplibs_check_method" = pass_all ||
5544
{ test "$build_libtool_libs" = yes &&
5545
test -n "$library_names"; }; }; then
5546
# We only need to search for static libraries
5551
link_static=no # Whether the deplib will be linked statically
5552
use_static_libs=$prefer_static_libs
5553
if test "$use_static_libs" = built && test "$installed" = yes; then
5556
if test -n "$library_names" &&
5557
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
5559
*cygwin* | *mingw* | *cegcc*)
5560
# No point in relinking DLLs because paths are not encoded
5561
notinst_deplibs="$notinst_deplibs $lib"
5565
if test "$installed" = no; then
5566
notinst_deplibs="$notinst_deplibs $lib"
5571
# This is a shared library
5573
# Warn about portability, can't link against -module's on some
5574
# systems (darwin). Don't bleat about dlopened modules though!
5576
for dlpremoduletest in $dlprefiles; do
5577
if test "X$dlpremoduletest" = "X$lib"; then
5578
dlopenmodule="$dlpremoduletest"
5582
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5584
if test "$linkmode" = prog; then
5585
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5587
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5589
$ECHO "*** $linklib is not portable!"
5591
if test "$linkmode" = lib &&
5592
test "$hardcode_into_libs" = yes; then
5593
# Hardcode the library path.
5594
# Skip directories that are in the system default run-time
5596
case " $sys_lib_dlsearch_path " in
5599
case "$compile_rpath " in
5601
*) compile_rpath="$compile_rpath $absdir"
5605
case " $sys_lib_dlsearch_path " in
5608
case "$finalize_rpath " in
5610
*) finalize_rpath="$finalize_rpath $libdir"
5616
if test -n "$old_archive_from_expsyms_cmds"; then
5617
# figure out the soname
5618
set dummy $library_names
5622
libname=`eval "\\$ECHO \"$libname_spec\""`
5623
# use dlname if we got it. it's perfectly good, no?
5624
if test -n "$dlname"; then
5626
elif test -n "$soname_spec"; then
5629
*cygwin* | mingw* | *cegcc*)
5630
func_arith $current - $age
5631
major=$func_arith_result
5635
eval soname=\"$soname_spec\"
5640
# Make a new name for the extract_expsyms_cmds to use
5642
func_basename "$soroot"
5643
soname="$func_basename_result"
5644
func_stripname 'lib' '.dll' "$soname"
5645
newlib=libimp-$func_stripname_result.a
5647
# If the library has no export list, then create one now
5648
if test -f "$output_objdir/$soname-def"; then :
5650
func_verbose "extracting exported symbol list from \`$soname'"
5651
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5655
if test -f "$output_objdir/$newlib"; then :; else
5656
func_verbose "generating import library for \`$soname'"
5657
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5659
# make sure the library variables are pointing to the new library
5662
fi # test -n "$old_archive_from_expsyms_cmds"
5664
if test "$linkmode" = prog || test "$mode" != relink; then
5669
case $hardcode_action in
5670
immediate | unsupported)
5671
if test "$hardcode_direct" = no; then
5674
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5675
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
5676
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5677
*-*-unixware7*) add_dir="-L$dir" ;;
5679
# if the lib is a (non-dlopened) module then we can not
5680
# link against it, someone is ignoring the earlier warnings
5681
if /usr/bin/file -L $add 2> /dev/null |
5682
$GREP ": [^:]* bundle" >/dev/null ; then
5683
if test "X$dlopenmodule" != "X$lib"; then
5684
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5685
if test -z "$old_library" ; then
5687
$ECHO "*** And there doesn't seem to be a static archive available"
5688
$ECHO "*** The link will probably fail, sorry"
5690
add="$dir/$old_library"
5692
elif test -n "$old_library"; then
5693
add="$dir/$old_library"
5697
elif test "$hardcode_minus_L" = no; then
5699
*-*-sunos*) add_shlibpath="$dir" ;;
5703
elif test "$hardcode_shlibpath_var" = no; then
5704
add_shlibpath="$dir"
5711
if test "$hardcode_direct" = yes &&
5712
test "$hardcode_direct_absolute" = no; then
5714
elif test "$hardcode_minus_L" = yes; then
5716
# Try looking first in the location we're being installed to.
5717
if test -n "$inst_prefix_dir"; then
5720
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5725
elif test "$hardcode_shlibpath_var" = yes; then
5726
add_shlibpath="$dir"
5735
if test "$lib_linked" != yes; then
5736
func_fatal_configuration "unsupported hardcode properties"
5739
if test -n "$add_shlibpath"; then
5740
case :$compile_shlibpath: in
5741
*":$add_shlibpath:"*) ;;
5742
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5745
if test "$linkmode" = prog; then
5746
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5747
test -n "$add" && compile_deplibs="$add $compile_deplibs"
5749
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5750
test -n "$add" && deplibs="$add $deplibs"
5751
if test "$hardcode_direct" != yes &&
5752
test "$hardcode_minus_L" != yes &&
5753
test "$hardcode_shlibpath_var" = yes; then
5754
case :$finalize_shlibpath: in
5756
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5762
if test "$linkmode" = prog || test "$mode" = relink; then
5766
# Finalize command for both is simple: just hardcode it.
5767
if test "$hardcode_direct" = yes &&
5768
test "$hardcode_direct_absolute" = no; then
5769
add="$libdir/$linklib"
5770
elif test "$hardcode_minus_L" = yes; then
5773
elif test "$hardcode_shlibpath_var" = yes; then
5774
case :$finalize_shlibpath: in
5776
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5779
elif test "$hardcode_automatic" = yes; then
5780
if test -n "$inst_prefix_dir" &&
5781
test -f "$inst_prefix_dir$libdir/$linklib" ; then
5782
add="$inst_prefix_dir$libdir/$linklib"
5784
add="$libdir/$linklib"
5787
# We cannot seem to hardcode it, guess we'll fake it.
5789
# Try looking first in the location we're being installed to.
5790
if test -n "$inst_prefix_dir"; then
5793
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5800
if test "$linkmode" = prog; then
5801
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5802
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5804
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5805
test -n "$add" && deplibs="$add $deplibs"
5808
elif test "$linkmode" = prog; then
5809
# Here we assume that one of hardcode_direct or hardcode_minus_L
5810
# is not unsupported. This is valid on all known static and
5812
if test "$hardcode_direct" != unsupported; then
5813
test -n "$old_library" && linklib="$old_library"
5814
compile_deplibs="$dir/$linklib $compile_deplibs"
5815
finalize_deplibs="$dir/$linklib $finalize_deplibs"
5817
compile_deplibs="-l$name -L$dir $compile_deplibs"
5818
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5820
elif test "$build_libtool_libs" = yes; then
5821
# Not a shared library
5822
if test "$deplibs_check_method" != pass_all; then
5823
# We're trying link a shared library against a static one
5824
# but the system doesn't support it.
5826
# Just print a warning and add the library to dependency_libs so
5827
# that the program can be linked against the static library.
5829
$ECHO "*** Warning: This system can not link to static lib archive $lib."
5830
$ECHO "*** I have the capability to make that library automatically link in when"
5831
$ECHO "*** you link to this library. But I can only do this if you have a"
5832
$ECHO "*** shared version of the library, which you do not appear to have."
5833
if test "$module" = yes; then
5834
$ECHO "*** But as you try to build a module library, libtool will still create "
5835
$ECHO "*** a static module, that should work as long as the dlopening application"
5836
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5837
if test -z "$global_symbol_pipe"; then
5839
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5840
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5841
$ECHO "*** not find such a program. So, this module is probably useless."
5842
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5844
if test "$build_old_libs" = no; then
5845
build_libtool_libs=module
5848
build_libtool_libs=no
5852
deplibs="$dir/$old_library $deplibs"
5855
fi # link shared/static library?
5857
if test "$linkmode" = lib; then
5858
if test -n "$dependency_libs" &&
5859
{ test "$hardcode_into_libs" != yes ||
5860
test "$build_old_libs" = yes ||
5861
test "$link_static" = yes; }; then
5862
# Extract -R from dependency_libs
5864
for libdir in $dependency_libs; do
5866
-R*) func_stripname '-R' '' "$libdir"
5867
temp_xrpath=$func_stripname_result
5869
*" $temp_xrpath "*) ;;
5870
*) xrpath="$xrpath $temp_xrpath";;
5872
*) temp_deplibs="$temp_deplibs $libdir";;
5875
dependency_libs="$temp_deplibs"
5878
newlib_search_path="$newlib_search_path $absdir"
5879
# Link against this library
5880
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5881
# ... and its dependency_libs
5883
for deplib in $dependency_libs; do
5884
newdependency_libs="$deplib $newdependency_libs"
5885
if $opt_duplicate_deps ; then
5886
case "$tmp_libs " in
5887
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5890
tmp_libs="$tmp_libs $deplib"
5893
if test "$link_all_deplibs" != no; then
5894
# Add the search paths of all dependency libraries
5895
for deplib in $dependency_libs; do
5897
-L*) path="$deplib" ;;
5899
func_dirname "$deplib" "" "."
5900
dir="$func_dirname_result"
5901
# We need an absolute path.
5903
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5905
absdir=`cd "$dir" && pwd`
5906
if test -z "$absdir"; then
5907
func_warning "cannot determine absolute directory name of \`$dir'"
5912
if $GREP "^installed=no" $deplib > /dev/null; then
5916
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5917
if test -n "$deplibrary_names" ; then
5918
for tmp in $deplibrary_names ; do
5921
if test -f "$absdir/$objdir/$depdepl" ; then
5922
depdepl="$absdir/$objdir/$depdepl"
5923
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5924
if test -z "$darwin_install_name"; then
5925
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5927
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5928
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5934
path="-L$absdir/$objdir"
5938
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5939
test -z "$libdir" && \
5940
func_fatal_error "\`$deplib' is not a valid libtool archive"
5941
test "$absdir" != "$libdir" && \
5942
func_warning "\`$deplib' seems to be moved"
5948
case " $deplibs " in
5950
*) deplibs="$path $deplibs" ;;
5953
fi # link_all_deplibs != no
5955
done # for deplib in $libs
5956
if test "$pass" = link; then
5957
if test "$linkmode" = "prog"; then
5958
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5959
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5961
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5964
dependency_libs="$newdependency_libs"
5965
if test "$pass" = dlpreopen; then
5966
# Link the dlpreopened libraries before other libraries
5967
for deplib in $save_deplibs; do
5968
deplibs="$deplib $deplibs"
5971
if test "$pass" != dlopen; then
5972
if test "$pass" != conv; then
5973
# Make sure lib_search_path contains only unique directories.
5975
for dir in $newlib_search_path; do
5976
case "$lib_search_path " in
5978
*) lib_search_path="$lib_search_path $dir" ;;
5984
if test "$linkmode,$pass" != "prog,link"; then
5987
vars="compile_deplibs finalize_deplibs"
5989
for var in $vars dependency_libs; do
5990
# Add libraries to $var in reverse order
5991
eval tmp_libs=\"\$$var\"
5993
for deplib in $tmp_libs; do
5994
# FIXME: Pedantically, this is the right thing to do, so
5995
# that some nasty dependency loop isn't accidentally
5997
#new_libs="$deplib $new_libs"
5998
# Pragmatically, this seems to cause very few problems in
6001
-L*) new_libs="$deplib $new_libs" ;;
6004
# And here is the reason: when a library appears more
6005
# than once as an explicit dependence of a library, or
6006
# is implicitly linked in more than once by the
6007
# compiler, it is considered special, and multiple
6008
# occurrences thereof are not removed. Compare this
6009
# with having the same library being listed as a
6010
# dependency of multiple other libraries: in this case,
6011
# we know (pedantically, we assume) the library does not
6012
# need to be listed more than once, so we keep only the
6013
# last copy. This is not always right, but it is rare
6014
# enough that we require users that really mean to play
6015
# such unportable linking tricks to link the library
6016
# using -Wl,-lname, so that libtool does not consider it
6017
# for duplicate removal.
6018
case " $specialdeplibs " in
6019
*" $deplib "*) new_libs="$deplib $new_libs" ;;
6021
case " $new_libs " in
6023
*) new_libs="$deplib $new_libs" ;;
6031
for deplib in $new_libs; do
6034
case " $tmp_libs " in
6036
*) tmp_libs="$tmp_libs $deplib" ;;
6039
*) tmp_libs="$tmp_libs $deplib" ;;
6042
eval $var=\"$tmp_libs\"
6045
# Last step: remove runtime libs from dependency_libs
6046
# (they stay in deplibs)
6048
for i in $dependency_libs ; do
6049
case " $predeps $postdeps $compiler_lib_search_path " in
6054
if test -n "$i" ; then
6055
tmp_libs="$tmp_libs $i"
6058
dependency_libs=$tmp_libs
6060
if test "$linkmode" = prog; then
6061
dlfiles="$newdlfiles"
6063
if test "$linkmode" = prog || test "$linkmode" = lib; then
6064
dlprefiles="$newdlprefiles"
6069
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6070
func_warning "\`-dlopen' is ignored for archives"
6075
func_warning "\`-l' and \`-L' are ignored for archives" ;;
6078
test -n "$rpath" && \
6079
func_warning "\`-rpath' is ignored for archives"
6081
test -n "$xrpath" && \
6082
func_warning "\`-R' is ignored for archives"
6084
test -n "$vinfo" && \
6085
func_warning "\`-version-info/-version-number' is ignored for archives"
6087
test -n "$release" && \
6088
func_warning "\`-release' is ignored for archives"
6090
test -n "$export_symbols$export_symbols_regex" && \
6091
func_warning "\`-export-symbols' is ignored for archives"
6093
# Now set the variables for building old libraries.
6094
build_libtool_libs=no
6096
objs="$objs$old_deplibs"
6100
# Make sure we only generate libraries of the form `libNAME.la'.
6103
func_stripname 'lib' '.la' "$outputname"
6104
name=$func_stripname_result
6105
eval shared_ext=\"$shrext_cmds\"
6106
eval libname=\"$libname_spec\"
6109
test "$module" = no && \
6110
func_fatal_help "libtool library \`$output' must begin with \`lib'"
6112
if test "$need_lib_prefix" != no; then
6113
# Add the "lib" prefix for modules if required
6114
func_stripname '' '.la' "$outputname"
6115
name=$func_stripname_result
6116
eval shared_ext=\"$shrext_cmds\"
6117
eval libname=\"$libname_spec\"
6119
func_stripname '' '.la' "$outputname"
6120
libname=$func_stripname_result
6125
if test -n "$objs"; then
6126
if test "$deplibs_check_method" != pass_all; then
6127
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6130
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6131
$ECHO "*** objects $objs is not portable!"
6132
libobjs="$libobjs $objs"
6136
test "$dlself" != no && \
6137
func_warning "\`-dlopen self' is ignored for libtool libraries"
6141
test "$#" -gt 1 && \
6142
func_warning "ignoring multiple \`-rpath's for a libtool library"
6147
if test -z "$rpath"; then
6148
if test "$build_libtool_libs" = yes; then
6149
# Building a libtool convenience library.
6150
# Some compilers have problems with a `.al' extension so
6151
# convenience libraries should have the same extension an
6152
# archive normally would.
6153
oldlibs="$output_objdir/$libname.$libext $oldlibs"
6154
build_libtool_libs=convenience
6158
test -n "$vinfo" && \
6159
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6161
test -n "$release" && \
6162
func_warning "\`-release' is ignored for convenience libraries"
6165
# Parse the version information argument.
6166
save_ifs="$IFS"; IFS=':'
6167
set dummy $vinfo 0 0 0
6172
func_fatal_help "too many parameters to \`-version-info'"
6174
# convert absolute version numbers to libtool ages
6175
# this retains compatibility with .la files and attempts
6176
# to make the code below a bit more comprehensible
6178
case $vinfo_number in
6182
number_revision="$3"
6184
# There are really only two kinds -- those that
6185
# use the current revision as the major version
6186
# and those that subtract age and use age as
6187
# a minor version. But, then there is irix
6188
# which has an extra 1 added just for fun
6190
case $version_type in
6191
darwin|linux|osf|windows|none)
6192
func_arith $number_major + $number_minor
6193
current=$func_arith_result
6195
revision="$number_revision"
6197
freebsd-aout|freebsd-elf|sunos)
6198
current="$number_major"
6199
revision="$number_minor"
6203
func_arith $number_major + $number_minor
6204
current=$func_arith_result
6206
revision="$number_minor"
6207
lt_irix_increment=no
6218
# Check that each of the things are valid numbers.
6220
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]) ;;
6222
func_error "CURRENT \`$current' must be a nonnegative integer"
6223
func_fatal_error "\`$vinfo' is not valid version information"
6228
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]) ;;
6230
func_error "REVISION \`$revision' must be a nonnegative integer"
6231
func_fatal_error "\`$vinfo' is not valid version information"
6236
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]) ;;
6238
func_error "AGE \`$age' must be a nonnegative integer"
6239
func_fatal_error "\`$vinfo' is not valid version information"
6243
if test "$age" -gt "$current"; then
6244
func_error "AGE \`$age' is greater than the current interface number \`$current'"
6245
func_fatal_error "\`$vinfo' is not valid version information"
6248
# Calculate the version variables.
6252
case $version_type in
6256
# Like Linux, but with the current version available in
6257
# verstring for coding it into the library header
6258
func_arith $current - $age
6259
major=.$func_arith_result
6260
versuffix="$major.$age.$revision"
6261
# Darwin ld doesn't like 0 for these options...
6262
func_arith $current + 1
6263
minor_current=$func_arith_result
6264
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6265
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6270
versuffix=".$current.$revision";
6275
versuffix=".$current"
6279
if test "X$lt_irix_increment" = "Xno"; then
6280
func_arith $current - $age
6282
func_arith $current - $age + 1
6284
major=$func_arith_result
6286
case $version_type in
6287
nonstopux) verstring_prefix=nonstopux ;;
6288
*) verstring_prefix=sgi ;;
6290
verstring="$verstring_prefix$major.$revision"
6292
# Add in all the interfaces that we are compatible with.
6294
while test "$loop" -ne 0; do
6295
func_arith $revision - $loop
6296
iface=$func_arith_result
6297
func_arith $loop - 1
6298
loop=$func_arith_result
6299
verstring="$verstring_prefix$major.$iface:$verstring"
6302
# Before this point, $major must not contain `.'.
6304
versuffix="$major.$revision"
6308
func_arith $current - $age
6309
major=.$func_arith_result
6310
versuffix="$major.$age.$revision"
6314
func_arith $current - $age
6315
major=.$func_arith_result
6316
versuffix=".$current.$age.$revision"
6317
verstring="$current.$age.$revision"
6319
# Add in all the interfaces that we are compatible with.
6321
while test "$loop" -ne 0; do
6322
func_arith $current - $loop
6323
iface=$func_arith_result
6324
func_arith $loop - 1
6325
loop=$func_arith_result
6326
verstring="$verstring:${iface}.0"
6329
# Make executables depend on our current version.
6330
verstring="$verstring:${current}.0"
6335
versuffix=".$current"
6340
versuffix=".$current.$revision"
6344
# Use '-' rather than '.', since we only want one
6345
# extension on DOS 8.3 filesystems.
6346
func_arith $current - $age
6347
major=$func_arith_result
6352
func_fatal_configuration "unknown library version type \`$version_type'"
6356
# Clear the version info if we defaulted, and they specified a release.
6357
if test -z "$vinfo" && test -n "$release"; then
6359
case $version_type in
6361
# we can't check for "0.0" in archive_cmds due to quoting
6362
# problems, so we reset it completely
6369
if test "$need_version" = no; then
6376
# Remove version info from name if versioning should be avoided
6377
if test "$avoid_version" = yes && test "$need_version" = no; then
6383
# Check to see if the archive will have undefined symbols.
6384
if test "$allow_undefined" = yes; then
6385
if test "$allow_undefined_flag" = unsupported; then
6386
func_warning "undefined symbols not allowed in $host shared libraries"
6387
build_libtool_libs=no
6391
# Don't allow undefined symbols.
6392
allow_undefined_flag="$no_undefined_flag"
6397
func_generate_dlsyms "$libname" "$libname" "yes"
6398
libobjs="$libobjs $symfileobj"
6399
test "X$libobjs" = "X " && libobjs=
6401
if test "$mode" != relink; then
6402
# Remove our outputs, but don't remove object files since they
6403
# may have been created when compiling PIC objects.
6405
tempremovelist=`$ECHO "$output_objdir/*"`
6406
for p in $tempremovelist; do
6410
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6411
if test "X$precious_files_regex" != "X"; then
6412
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6417
removelist="$removelist $p"
6422
test -n "$removelist" && \
6423
func_show_eval "${RM}r \$removelist"
6426
# Now set the variables for building old libraries.
6427
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6428
oldlibs="$oldlibs $output_objdir/$libname.$libext"
6430
# Transform .lo files to .o files.
6431
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6434
# Eliminate all temporary directories.
6435
#for path in $notinst_path; do
6436
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6437
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6438
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6441
if test -n "$xrpath"; then
6442
# If the user specified any rpath flags, then add them.
6444
for libdir in $xrpath; do
6445
temp_xrpath="$temp_xrpath -R$libdir"
6446
case "$finalize_rpath " in
6448
*) finalize_rpath="$finalize_rpath $libdir" ;;
6451
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6452
dependency_libs="$temp_xrpath $dependency_libs"
6456
# Make sure dlfiles contains only unique files that won't be dlpreopened
6457
old_dlfiles="$dlfiles"
6459
for lib in $old_dlfiles; do
6460
case " $dlprefiles $dlfiles " in
6462
*) dlfiles="$dlfiles $lib" ;;
6466
# Make sure dlprefiles contains only unique files
6467
old_dlprefiles="$dlprefiles"
6469
for lib in $old_dlprefiles; do
6470
case "$dlprefiles " in
6472
*) dlprefiles="$dlprefiles $lib" ;;
6476
if test "$build_libtool_libs" = yes; then
6477
if test -n "$rpath"; then
6479
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6480
# these systems don't actually have a c library (as such)!
6482
*-*-rhapsody* | *-*-darwin1.[012])
6483
# Rhapsody C library is in the System framework
6484
deplibs="$deplibs System.ltframework"
6487
# Don't link with libc until the a.out ld.so is fixed.
6489
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6490
# Do not include libc due to us having libc/libc_r.
6492
*-*-sco3.2v5* | *-*-sco5v6*)
6493
# Causes problems with __ctype
6495
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6496
# Compiler inserts libc in the correct place for threads to work
6499
# Add libc to deplibs on all other systems if necessary.
6500
if test "$build_libtool_need_lc" = "yes"; then
6501
deplibs="$deplibs -lc"
6507
# Transform deplibs into only deplibs that can be linked in shared.
6509
libname_save=$libname
6510
release_save=$release
6511
versuffix_save=$versuffix
6513
# I'm not sure if I'm treating the release correctly. I think
6514
# release should show up in the -l (ie -lgmp5) so we don't want to
6515
# add it in twice. Is that correct?
6521
case $deplibs_check_method in
6523
# Don't check for shared/static. Everything works.
6524
# This might be a little naive. We might want to check
6525
# whether the library exists or not. But this is on
6526
# osf3 & osf4 and I'm not really sure... Just
6527
# implementing what was already the behavior.
6531
# This code stresses the "libraries are programs" paradigm to its
6532
# limits. Maybe even breaks it. We compile a program, linking it
6533
# against the deplibs as a proxy for the library. Then we can check
6534
# whether they linked in statically or dynamically with ldd.
6535
$opt_dry_run || $RM conftest.c
6536
cat > conftest.c <<EOF
6537
int main() { return 0; }
6539
$opt_dry_run || $RM conftest
6540
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6541
ldd_output=`ldd conftest`
6542
for i in $deplibs; do
6545
func_stripname -l '' "$i"
6546
name=$func_stripname_result
6547
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6548
case " $predeps $postdeps " in
6550
newdeplibs="$newdeplibs $i"
6555
if test -n "$i" ; then
6556
libname=`eval "\\$ECHO \"$libname_spec\""`
6557
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6558
set dummy $deplib_matches; shift
6560
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6561
newdeplibs="$newdeplibs $i"
6565
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6566
$ECHO "*** I have the capability to make that library automatically link in when"
6567
$ECHO "*** you link to this library. But I can only do this if you have a"
6568
$ECHO "*** shared version of the library, which I believe you do not have"
6569
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6570
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6575
newdeplibs="$newdeplibs $i"
6580
# Error occurred in the first compile. Let's try to salvage
6581
# the situation: Compile a separate program for each library.
6582
for i in $deplibs; do
6585
func_stripname -l '' "$i"
6586
name=$func_stripname_result
6587
$opt_dry_run || $RM conftest
6588
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6589
ldd_output=`ldd conftest`
6590
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6591
case " $predeps $postdeps " in
6593
newdeplibs="$newdeplibs $i"
6598
if test -n "$i" ; then
6599
libname=`eval "\\$ECHO \"$libname_spec\""`
6600
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6601
set dummy $deplib_matches; shift
6603
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6604
newdeplibs="$newdeplibs $i"
6608
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6609
$ECHO "*** I have the capability to make that library automatically link in when"
6610
$ECHO "*** you link to this library. But I can only do this if you have a"
6611
$ECHO "*** shared version of the library, which you do not appear to have"
6612
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6613
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6619
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6620
$ECHO "*** make it link in! You will probably need to install it or some"
6621
$ECHO "*** library that it depends on before this library will be fully"
6622
$ECHO "*** functional. Installing it before continuing would be even better."
6626
newdeplibs="$newdeplibs $i"
6633
set dummy $deplibs_check_method; shift
6634
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6635
for a_deplib in $deplibs; do
6638
func_stripname -l '' "$a_deplib"
6639
name=$func_stripname_result
6640
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6641
case " $predeps $postdeps " in
6643
newdeplibs="$newdeplibs $a_deplib"
6648
if test -n "$a_deplib" ; then
6649
libname=`eval "\\$ECHO \"$libname_spec\""`
6650
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6651
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6652
for potent_lib in $potential_libs; do
6653
# Follow soft links.
6654
if ls -lLd "$potent_lib" 2>/dev/null |
6655
$GREP " -> " >/dev/null; then
6658
# The statement above tries to avoid entering an
6659
# endless loop below, in case of cyclic links.
6660
# We might still enter an endless loop, since a link
6661
# loop can be closed while we follow links,
6663
potlib="$potent_lib"
6664
while test -h "$potlib" 2>/dev/null; do
6665
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6667
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6668
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6671
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6673
$EGREP "$file_magic_regex" > /dev/null; then
6674
newdeplibs="$newdeplibs $a_deplib"
6681
if test -n "$a_deplib" ; then
6684
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6685
$ECHO "*** I have the capability to make that library automatically link in when"
6686
$ECHO "*** you link to this library. But I can only do this if you have a"
6687
$ECHO "*** shared version of the library, which you do not appear to have"
6688
$ECHO "*** because I did check the linker path looking for a file starting"
6689
if test -z "$potlib" ; then
6690
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6692
$ECHO "*** with $libname and none of the candidates passed a file format test"
6693
$ECHO "*** using a file magic. Last file checked: $potlib"
6698
# Add a -L argument.
6699
newdeplibs="$newdeplibs $a_deplib"
6702
done # Gone through all deplibs.
6705
set dummy $deplibs_check_method; shift
6706
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6707
for a_deplib in $deplibs; do
6710
func_stripname -l '' "$a_deplib"
6711
name=$func_stripname_result
6712
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6713
case " $predeps $postdeps " in
6715
newdeplibs="$newdeplibs $a_deplib"
6720
if test -n "$a_deplib" ; then
6721
libname=`eval "\\$ECHO \"$libname_spec\""`
6722
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6723
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6724
for potent_lib in $potential_libs; do
6725
potlib="$potent_lib" # see symlink-check above in file_magic test
6726
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6727
$EGREP "$match_pattern_regex" > /dev/null; then
6728
newdeplibs="$newdeplibs $a_deplib"
6735
if test -n "$a_deplib" ; then
6738
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6739
$ECHO "*** I have the capability to make that library automatically link in when"
6740
$ECHO "*** you link to this library. But I can only do this if you have a"
6741
$ECHO "*** shared version of the library, which you do not appear to have"
6742
$ECHO "*** because I did check the linker path looking for a file starting"
6743
if test -z "$potlib" ; then
6744
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6746
$ECHO "*** with $libname and none of the candidates passed a file format test"
6747
$ECHO "*** using a regex pattern. Last file checked: $potlib"
6752
# Add a -L argument.
6753
newdeplibs="$newdeplibs $a_deplib"
6756
done # Gone through all deplibs.
6760
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6761
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6762
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6763
for i in $predeps $postdeps ; do
6764
# can't use Xsed below, because $i might contain '/'
6765
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6768
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6769
$GREP . >/dev/null; then
6771
if test "X$deplibs_check_method" = "Xnone"; then
6772
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6774
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
6776
$ECHO "*** All declared inter-library dependencies are being dropped."
6781
versuffix=$versuffix_save
6783
release=$release_save
6784
libname=$libname_save
6788
*-*-rhapsody* | *-*-darwin1.[012])
6789
# On Rhapsody replace the C library with the System framework
6790
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6794
if test "$droppeddeps" = yes; then
6795
if test "$module" = yes; then
6797
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6798
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6799
$ECHO "*** a static module, that should work as long as the dlopening"
6800
$ECHO "*** application is linked with the -dlopen flag."
6801
if test -z "$global_symbol_pipe"; then
6803
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6804
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6805
$ECHO "*** not find such a program. So, this module is probably useless."
6806
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6808
if test "$build_old_libs" = no; then
6809
oldlibs="$output_objdir/$libname.$libext"
6810
build_libtool_libs=module
6813
build_libtool_libs=no
6816
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6817
$ECHO "*** automatically added whenever a program is linked with this library"
6818
$ECHO "*** or is declared to -dlopen it."
6820
if test "$allow_undefined" = no; then
6822
$ECHO "*** Since this library must not contain undefined symbols,"
6823
$ECHO "*** because either the platform does not support them or"
6824
$ECHO "*** it was explicitly requested with -no-undefined,"
6825
$ECHO "*** libtool will only create a static version of it."
6826
if test "$build_old_libs" = no; then
6827
oldlibs="$output_objdir/$libname.$libext"
6828
build_libtool_libs=module
6831
build_libtool_libs=no
6836
# Done checking deplibs!
6839
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6842
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6843
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6844
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6848
# move library search paths that coincide with paths to not yet
6849
# installed libraries to the beginning of the library search list
6851
for path in $notinst_path; do
6852
case " $new_libs " in
6853
*" -L$path/$objdir "*) ;;
6855
case " $deplibs " in
6856
*" -L$path/$objdir "*)
6857
new_libs="$new_libs -L$path/$objdir" ;;
6862
for deplib in $deplibs; do
6865
case " $new_libs " in
6867
*) new_libs="$new_libs $deplib" ;;
6870
*) new_libs="$new_libs $deplib" ;;
6875
# All the library-specific variables (install_libdir is set above).
6880
# Test again, we may have decided not to build it any more
6881
if test "$build_libtool_libs" = yes; then
6882
if test "$hardcode_into_libs" = yes; then
6883
# Hardcode the library paths
6886
rpath="$finalize_rpath"
6887
test "$mode" != relink && rpath="$compile_rpath$rpath"
6888
for libdir in $rpath; do
6889
if test -n "$hardcode_libdir_flag_spec"; then
6890
if test -n "$hardcode_libdir_separator"; then
6891
if test -z "$hardcode_libdirs"; then
6892
hardcode_libdirs="$libdir"
6894
# Just accumulate the unique libdirs.
6895
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6896
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6899
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6904
eval flag=\"$hardcode_libdir_flag_spec\"
6905
dep_rpath="$dep_rpath $flag"
6907
elif test -n "$runpath_var"; then
6908
case "$perm_rpath " in
6910
*) perm_rpath="$perm_rpath $libdir" ;;
6914
# Substitute the hardcoded libdirs into the rpath.
6915
if test -n "$hardcode_libdir_separator" &&
6916
test -n "$hardcode_libdirs"; then
6917
libdir="$hardcode_libdirs"
6918
if test -n "$hardcode_libdir_flag_spec_ld"; then
6919
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6921
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6924
if test -n "$runpath_var" && test -n "$perm_rpath"; then
6925
# We should set the runpath_var.
6927
for dir in $perm_rpath; do
6930
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6932
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6935
shlibpath="$finalize_shlibpath"
6936
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6937
if test -n "$shlibpath"; then
6938
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6941
# Get the real and link names of the library.
6942
eval shared_ext=\"$shrext_cmds\"
6943
eval library_names=\"$library_names_spec\"
6944
set dummy $library_names
6949
if test -n "$soname_spec"; then
6950
eval soname=\"$soname_spec\"
6954
if test -z "$dlname"; then
6958
lib="$output_objdir/$realname"
6962
linknames="$linknames $link"
6965
# Use standard objects if they are pic
6966
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6967
test "X$libobjs" = "X " && libobjs=
6970
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6971
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6972
export_symbols="$output_objdir/$libname.uexp"
6973
delfiles="$delfiles $export_symbols"
6976
orig_export_symbols=
6978
cygwin* | mingw* | cegcc*)
6979
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6980
# exporting using user supplied symfile
6981
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6982
# and it's NOT already a .def file. Must figure out
6983
# which of the given symbols are data symbols and tag
6984
# them as such. So, trigger use of export_symbols_cmds.
6985
# export_symbols gets reassigned inside the "prepare
6986
# the list of exported symbols" if statement, so the
6987
# include_expsyms logic still works.
6988
orig_export_symbols="$export_symbols"
6990
always_export_symbols=yes
6996
# Prepare the list of exported symbols
6997
if test -z "$export_symbols"; then
6998
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
6999
func_verbose "generating symbol list for \`$libname.la'"
7000
export_symbols="$output_objdir/$libname.exp"
7001
$opt_dry_run || $RM $export_symbols
7002
cmds=$export_symbols_cmds
7003
save_ifs="$IFS"; IFS='~'
7004
for cmd in $cmds; do
7008
len=$func_len_result
7009
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7010
func_show_eval "$cmd" 'exit $?'
7011
skipped_export=false
7013
# The command line is too long to execute in one step.
7014
func_verbose "using reloadable object file for export list..."
7016
# Break out early, otherwise skipped_export may be
7017
# set to false by a later but shorter cmd.
7022
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7023
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7024
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7029
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7030
tmp_export_symbols="$export_symbols"
7031
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7032
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7035
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7036
# The given exports_symbols file has to be filtered, so filter it.
7037
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7038
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7039
# 's' commands which not all seds can handle. GNU sed should be fine
7040
# though. Also, the filter scales superlinearly with the number of
7041
# global variables. join(1) would be nice here, but unfortunately
7042
# isn't a blessed tool.
7043
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7044
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7045
export_symbols=$output_objdir/$libname.def
7046
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7050
for test_deplib in $deplibs; do
7051
case " $convenience " in
7052
*" $test_deplib "*) ;;
7054
tmp_deplibs="$tmp_deplibs $test_deplib"
7058
deplibs="$tmp_deplibs"
7060
if test -n "$convenience"; then
7061
if test -n "$whole_archive_flag_spec" &&
7062
test "$compiler_needs_object" = yes &&
7063
test -z "$libobjs"; then
7064
# extract the archives, so we have objects to list.
7065
# TODO: could optimize this to just extract one archive.
7066
whole_archive_flag_spec=
7068
if test -n "$whole_archive_flag_spec"; then
7069
save_libobjs=$libobjs
7070
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7071
test "X$libobjs" = "X " && libobjs=
7073
gentop="$output_objdir/${outputname}x"
7074
generated="$generated $gentop"
7076
func_extract_archives $gentop $convenience
7077
libobjs="$libobjs $func_extract_archives_result"
7078
test "X$libobjs" = "X " && libobjs=
7082
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7083
eval flag=\"$thread_safe_flag_spec\"
7084
linker_flags="$linker_flags $flag"
7087
# Make a backup of the uninstalled library when relinking
7088
if test "$mode" = relink; then
7089
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7092
# Do each of the archive commands.
7093
if test "$module" = yes && test -n "$module_cmds" ; then
7094
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7095
eval test_cmds=\"$module_expsym_cmds\"
7096
cmds=$module_expsym_cmds
7098
eval test_cmds=\"$module_cmds\"
7102
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7103
eval test_cmds=\"$archive_expsym_cmds\"
7104
cmds=$archive_expsym_cmds
7106
eval test_cmds=\"$archive_cmds\"
7111
if test "X$skipped_export" != "X:" &&
7112
func_len " $test_cmds" &&
7113
len=$func_len_result &&
7114
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7117
# The command line is too long to link in one step, link piecewise
7118
# or, if using GNU ld and skipped_export is not :, use a linker
7121
# Save the value of $output and $libobjs because we want to
7122
# use them later. If we have whole_archive_flag_spec, we
7123
# want to use save_libobjs as it was before
7124
# whole_archive_flag_spec was expanded, because we can't
7125
# assume the linker understands whole_archive_flag_spec.
7126
# This may have to be revisited, in case too many
7127
# convenience libraries get linked in and end up exceeding
7129
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7130
save_libobjs=$libobjs
7133
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7135
# Clear the reloadable object creation command queue and
7136
# initialize k to one.
7143
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7144
output=${output_objdir}/${output_la}.lnkscript
7145
func_verbose "creating GNU ld script: $output"
7146
$ECHO 'INPUT (' > $output
7147
for obj in $save_libobjs
7149
$ECHO "$obj" >> $output
7151
$ECHO ')' >> $output
7152
delfiles="$delfiles $output"
7153
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7154
output=${output_objdir}/${output_la}.lnk
7155
func_verbose "creating linker input file list: $output"
7160
if test "$compiler_needs_object" = yes; then
7166
$ECHO "$obj" >> $output
7168
delfiles="$delfiles $output"
7169
output=$firstobj\"$file_list_spec$output\"
7171
if test -n "$save_libobjs"; then
7172
func_verbose "creating reloadable object files..."
7173
output=$output_objdir/$output_la-${k}.$objext
7174
eval test_cmds=\"$reload_cmds\"
7175
func_len " $test_cmds"
7176
len0=$func_len_result
7179
# Loop over the list of objects to be linked.
7180
for obj in $save_libobjs
7183
func_arith $len + $func_len_result
7184
len=$func_arith_result
7185
if test "X$objlist" = X ||
7186
test "$len" -lt "$max_cmd_len"; then
7187
func_append objlist " $obj"
7189
# The command $test_cmds is almost too long, add a
7190
# command to the queue.
7191
if test "$k" -eq 1 ; then
7192
# The first file doesn't have a previous command to add.
7193
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7195
# All subsequent reloadable object files will link in
7196
# the last one created.
7197
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7199
last_robj=$output_objdir/$output_la-${k}.$objext
7201
k=$func_arith_result
7202
output=$output_objdir/$output_la-${k}.$objext
7204
func_len " $last_robj"
7205
func_arith $len0 + $func_len_result
7206
len=$func_arith_result
7209
# Handle the remaining objects by creating one last
7210
# reloadable object file. All subsequent reloadable object
7211
# files will link in the last one created.
7212
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7213
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7214
if test -n "$last_robj"; then
7215
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7217
delfiles="$delfiles $output"
7223
if ${skipped_export-false}; then
7224
func_verbose "generating symbol list for \`$libname.la'"
7225
export_symbols="$output_objdir/$libname.exp"
7226
$opt_dry_run || $RM $export_symbols
7228
# Append the command to create the export file.
7229
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7230
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7231
if test -n "$last_robj"; then
7232
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7236
test -n "$save_libobjs" &&
7237
func_verbose "creating a temporary reloadable object file: $output"
7239
# Loop through the commands generated above and execute them.
7240
save_ifs="$IFS"; IFS='~'
7241
for cmd in $concat_cmds; do
7244
func_quote_for_expand "$cmd"
7245
eval "func_echo $func_quote_for_expand_result"
7247
$opt_dry_run || eval "$cmd" || {
7250
# Restore the uninstalled library and exit
7251
if test "$mode" = relink; then
7252
( cd "$output_objdir" && \
7253
$RM "${realname}T" && \
7254
$MV "${realname}U" "$realname" )
7262
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7263
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7264
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7268
if ${skipped_export-false}; then
7269
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7270
tmp_export_symbols="$export_symbols"
7271
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7272
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7275
if test -n "$orig_export_symbols"; then
7276
# The given exports_symbols file has to be filtered, so filter it.
7277
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7278
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7279
# 's' commands which not all seds can handle. GNU sed should be fine
7280
# though. Also, the filter scales superlinearly with the number of
7281
# global variables. join(1) would be nice here, but unfortunately
7282
# isn't a blessed tool.
7283
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7284
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7285
export_symbols=$output_objdir/$libname.def
7286
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7291
# Restore the value of output.
7294
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7295
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7296
test "X$libobjs" = "X " && libobjs=
7298
# Expand the library linking commands again to reset the
7299
# value of $libobjs for piecewise linking.
7301
# Do each of the archive commands.
7302
if test "$module" = yes && test -n "$module_cmds" ; then
7303
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7304
cmds=$module_expsym_cmds
7309
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7310
cmds=$archive_expsym_cmds
7317
if test -n "$delfiles"; then
7318
# Append the command to remove temporary files to $cmds.
7319
eval cmds=\"\$cmds~\$RM $delfiles\"
7322
# Add any objects from preloaded convenience libraries
7323
if test -n "$dlprefiles"; then
7324
gentop="$output_objdir/${outputname}x"
7325
generated="$generated $gentop"
7327
func_extract_archives $gentop $dlprefiles
7328
libobjs="$libobjs $func_extract_archives_result"
7329
test "X$libobjs" = "X " && libobjs=
7332
save_ifs="$IFS"; IFS='~'
7333
for cmd in $cmds; do
7337
func_quote_for_expand "$cmd"
7338
eval "func_echo $func_quote_for_expand_result"
7340
$opt_dry_run || eval "$cmd" || {
7343
# Restore the uninstalled library and exit
7344
if test "$mode" = relink; then
7345
( cd "$output_objdir" && \
7346
$RM "${realname}T" && \
7347
$MV "${realname}U" "$realname" )
7355
# Restore the uninstalled library and exit
7356
if test "$mode" = relink; then
7357
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7359
if test -n "$convenience"; then
7360
if test -z "$whole_archive_flag_spec"; then
7361
func_show_eval '${RM}r "$gentop"'
7368
# Create links to the real library.
7369
for linkname in $linknames; do
7370
if test "$realname" != "$linkname"; then
7371
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7375
# If -module or -export-dynamic was specified, set the dlname.
7376
if test "$module" = yes || test "$export_dynamic" = yes; then
7377
# On all known operating systems, these are identical.
7384
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7385
func_warning "\`-dlopen' is ignored for objects"
7390
func_warning "\`-l' and \`-L' are ignored for objects" ;;
7393
test -n "$rpath" && \
7394
func_warning "\`-rpath' is ignored for objects"
7396
test -n "$xrpath" && \
7397
func_warning "\`-R' is ignored for objects"
7399
test -n "$vinfo" && \
7400
func_warning "\`-version-info' is ignored for objects"
7402
test -n "$release" && \
7403
func_warning "\`-release' is ignored for objects"
7407
test -n "$objs$old_deplibs" && \
7408
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7412
obj=$func_lo2o_result
7420
# Delete the old objects.
7421
$opt_dry_run || $RM $obj $libobj
7423
# Objects from convenience libraries. This assumes
7424
# single-version convenience libraries. Whenever we create
7425
# different ones for PIC/non-PIC, this we'll have to duplicate
7429
# reload_cmds runs $LD directly, so let us get rid of
7430
# -Wl from whole_archive_flag_spec and hope we can get by with
7431
# turning comma into space..
7434
if test -n "$convenience"; then
7435
if test -n "$whole_archive_flag_spec"; then
7436
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7437
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7439
gentop="$output_objdir/${obj}x"
7440
generated="$generated $gentop"
7442
func_extract_archives $gentop $convenience
7443
reload_conv_objs="$reload_objs $func_extract_archives_result"
7447
# Create the old-style object.
7448
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
7451
func_execute_cmds "$reload_cmds" 'exit $?'
7453
# Exit if we aren't doing a library object file.
7454
if test -z "$libobj"; then
7455
if test -n "$gentop"; then
7456
func_show_eval '${RM}r "$gentop"'
7462
if test "$build_libtool_libs" != yes; then
7463
if test -n "$gentop"; then
7464
func_show_eval '${RM}r "$gentop"'
7467
# Create an invalid libtool object if no PIC, so that we don't
7468
# accidentally link it into a program.
7469
# $show "echo timestamp > $libobj"
7470
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7474
if test -n "$pic_flag" || test "$pic_mode" != default; then
7475
# Only do commands if we really have different PIC objects.
7476
reload_objs="$libobjs $reload_conv_objs"
7478
func_execute_cmds "$reload_cmds" 'exit $?'
7481
if test -n "$gentop"; then
7482
func_show_eval '${RM}r "$gentop"'
7490
*cygwin*) func_stripname '' '.exe' "$output"
7491
output=$func_stripname_result.exe;;
7493
test -n "$vinfo" && \
7494
func_warning "\`-version-info' is ignored for programs"
7496
test -n "$release" && \
7497
func_warning "\`-release' is ignored for programs"
7499
test "$preload" = yes \
7500
&& test "$dlopen_support" = unknown \
7501
&& test "$dlopen_self" = unknown \
7502
&& test "$dlopen_self_static" = unknown && \
7503
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7506
*-*-rhapsody* | *-*-darwin1.[012])
7507
# On Rhapsody replace the C library is the System framework
7508
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7509
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7515
# Don't allow lazy linking, it breaks C++ global constructors
7516
# But is supposedly fixed on 10.4 or later (yay!).
7517
if test "$tagname" = CXX ; then
7518
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7520
compile_command="$compile_command ${wl}-bind_at_load"
7521
finalize_command="$finalize_command ${wl}-bind_at_load"
7525
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7526
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7527
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7532
# move library search paths that coincide with paths to not yet
7533
# installed libraries to the beginning of the library search list
7535
for path in $notinst_path; do
7536
case " $new_libs " in
7537
*" -L$path/$objdir "*) ;;
7539
case " $compile_deplibs " in
7540
*" -L$path/$objdir "*)
7541
new_libs="$new_libs -L$path/$objdir" ;;
7546
for deplib in $compile_deplibs; do
7549
case " $new_libs " in
7551
*) new_libs="$new_libs $deplib" ;;
7554
*) new_libs="$new_libs $deplib" ;;
7557
compile_deplibs="$new_libs"
7560
compile_command="$compile_command $compile_deplibs"
7561
finalize_command="$finalize_command $finalize_deplibs"
7563
if test -n "$rpath$xrpath"; then
7564
# If the user specified any rpath flags, then add them.
7565
for libdir in $rpath $xrpath; do
7566
# This is the magic to use -rpath.
7567
case "$finalize_rpath " in
7569
*) finalize_rpath="$finalize_rpath $libdir" ;;
7574
# Now hardcode the library paths
7577
for libdir in $compile_rpath $finalize_rpath; do
7578
if test -n "$hardcode_libdir_flag_spec"; then
7579
if test -n "$hardcode_libdir_separator"; then
7580
if test -z "$hardcode_libdirs"; then
7581
hardcode_libdirs="$libdir"
7583
# Just accumulate the unique libdirs.
7584
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7585
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7588
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7593
eval flag=\"$hardcode_libdir_flag_spec\"
7594
rpath="$rpath $flag"
7596
elif test -n "$runpath_var"; then
7597
case "$perm_rpath " in
7599
*) perm_rpath="$perm_rpath $libdir" ;;
7603
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7604
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7605
case :$dllsearchpath: in
7607
::) dllsearchpath=$libdir;;
7608
*) dllsearchpath="$dllsearchpath:$libdir";;
7610
case :$dllsearchpath: in
7611
*":$testbindir:"*) ;;
7612
::) dllsearchpath=$testbindir;;
7613
*) dllsearchpath="$dllsearchpath:$testbindir";;
7618
# Substitute the hardcoded libdirs into the rpath.
7619
if test -n "$hardcode_libdir_separator" &&
7620
test -n "$hardcode_libdirs"; then
7621
libdir="$hardcode_libdirs"
7622
eval rpath=\" $hardcode_libdir_flag_spec\"
7624
compile_rpath="$rpath"
7628
for libdir in $finalize_rpath; do
7629
if test -n "$hardcode_libdir_flag_spec"; then
7630
if test -n "$hardcode_libdir_separator"; then
7631
if test -z "$hardcode_libdirs"; then
7632
hardcode_libdirs="$libdir"
7634
# Just accumulate the unique libdirs.
7635
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7636
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7639
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7644
eval flag=\"$hardcode_libdir_flag_spec\"
7645
rpath="$rpath $flag"
7647
elif test -n "$runpath_var"; then
7648
case "$finalize_perm_rpath " in
7650
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7654
# Substitute the hardcoded libdirs into the rpath.
7655
if test -n "$hardcode_libdir_separator" &&
7656
test -n "$hardcode_libdirs"; then
7657
libdir="$hardcode_libdirs"
7658
eval rpath=\" $hardcode_libdir_flag_spec\"
7660
finalize_rpath="$rpath"
7662
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7663
# Transform all the library objects into standard objects.
7664
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7665
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7668
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7670
# template prelinking step
7671
if test -n "$prelink_cmds"; then
7672
func_execute_cmds "$prelink_cmds" 'exit $?'
7675
wrappers_required=yes
7677
*cygwin* | *mingw* )
7678
if test "$build_libtool_libs" != yes; then
7679
wrappers_required=no
7683
# Disable wrappers for cegcc, we are cross compiling anyway.
7684
wrappers_required=no
7687
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7688
wrappers_required=no
7692
if test "$wrappers_required" = no; then
7693
# Replace the output file specification.
7694
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7695
link_command="$compile_command$compile_rpath"
7697
# We have no uninstalled library dependencies, so finalize right now.
7699
func_show_eval "$link_command" 'exit_status=$?'
7701
# Delete the generated files.
7702
if test -f "$output_objdir/${outputname}S.${objext}"; then
7703
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7709
if test -n "$compile_shlibpath$finalize_shlibpath"; then
7710
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7712
if test -n "$finalize_shlibpath"; then
7713
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7718
if test -n "$runpath_var"; then
7719
if test -n "$perm_rpath"; then
7720
# We should set the runpath_var.
7722
for dir in $perm_rpath; do
7725
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7727
if test -n "$finalize_perm_rpath"; then
7728
# We should set the runpath_var.
7730
for dir in $finalize_perm_rpath; do
7733
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7737
if test "$no_install" = yes; then
7738
# We don't need to create a wrapper script.
7739
link_command="$compile_var$compile_command$compile_rpath"
7740
# Replace the output file specification.
7741
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7742
# Delete the old output file.
7743
$opt_dry_run || $RM $output
7744
# Link the executable and exit
7745
func_show_eval "$link_command" 'exit $?'
7749
if test "$hardcode_action" = relink; then
7750
# Fast installation is not supported
7751
link_command="$compile_var$compile_command$compile_rpath"
7752
relink_command="$finalize_var$finalize_command$finalize_rpath"
7754
func_warning "this platform does not like uninstalled shared libraries"
7755
func_warning "\`$output' will be relinked during installation"
7757
if test "$fast_install" != no; then
7758
link_command="$finalize_var$compile_command$finalize_rpath"
7759
if test "$fast_install" = yes; then
7760
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7762
# fast_install is set to needless
7766
link_command="$compile_var$compile_command$compile_rpath"
7767
relink_command="$finalize_var$finalize_command$finalize_rpath"
7771
# Replace the output file specification.
7772
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7774
# Delete the old output files.
7775
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7777
func_show_eval "$link_command" 'exit $?'
7779
# Now create the wrapper script.
7780
func_verbose "creating $output"
7782
# Quote the relink command for shipping.
7783
if test -n "$relink_command"; then
7784
# Preserve any variables that may affect compiler behavior
7785
for var in $variables_saved_for_relink; do
7786
if eval test -z \"\${$var+set}\"; then
7787
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7788
elif eval var_value=\$$var; test -z "$var_value"; then
7789
relink_command="$var=; export $var; $relink_command"
7791
func_quote_for_eval "$var_value"
7792
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7795
relink_command="(cd `pwd`; $relink_command)"
7796
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7799
# Quote $ECHO for shipping.
7800
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7802
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7803
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7805
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7807
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7810
# Only actually do things if not in dry run mode.
7812
# win32 will think the script is a binary if it has
7813
# a .exe suffix, so we strip it off here.
7815
*.exe) func_stripname '' '.exe' "$output"
7816
output=$func_stripname_result ;;
7818
# test for cygwin because mv fails w/o .exe extensions
7822
func_stripname '' '.exe' "$outputname"
7823
outputname=$func_stripname_result ;;
7827
*cygwin* | *mingw* )
7828
func_dirname_and_basename "$output" "" "."
7829
output_name=$func_basename_result
7830
output_path=$func_dirname_result
7831
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7832
cwrapper="$output_path/$output_name.exe"
7833
$RM $cwrappersource $cwrapper
7834
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7836
func_emit_cwrapperexe_src > $cwrappersource
7838
# The wrapper executable is built using the $host compiler,
7839
# because it contains $host paths and files. If cross-
7840
# compiling, it, like the target executable, must be
7841
# executed on the $host or under an emulation environment.
7843
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7847
# Now, create the wrapper script for func_source use:
7848
func_ltwrapper_scriptname $cwrapper
7849
$RM $func_ltwrapper_scriptname_result
7850
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7852
# note: this script will not be executed, so do not chmod.
7853
if test "x$build" = "x$host" ; then
7854
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7856
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7862
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7864
func_emit_wrapper no > $output
7873
# See if we need to build an old-fashioned archive.
7874
for oldlib in $oldlibs; do
7876
if test "$build_libtool_libs" = convenience; then
7877
oldobjs="$libobjs_save $symfileobj"
7878
addlibs="$convenience"
7879
build_libtool_libs=no
7881
if test "$build_libtool_libs" = module; then
7882
oldobjs="$libobjs_save"
7883
build_libtool_libs=no
7885
oldobjs="$old_deplibs $non_pic_objects"
7886
if test "$preload" = yes && test -f "$symfileobj"; then
7887
oldobjs="$oldobjs $symfileobj"
7890
addlibs="$old_convenience"
7893
if test -n "$addlibs"; then
7894
gentop="$output_objdir/${outputname}x"
7895
generated="$generated $gentop"
7897
func_extract_archives $gentop $addlibs
7898
oldobjs="$oldobjs $func_extract_archives_result"
7901
# Do each command in the archive commands.
7902
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7903
cmds=$old_archive_from_new_cmds
7906
# Add any objects from preloaded convenience libraries
7907
if test -n "$dlprefiles"; then
7908
gentop="$output_objdir/${outputname}x"
7909
generated="$generated $gentop"
7911
func_extract_archives $gentop $dlprefiles
7912
oldobjs="$oldobjs $func_extract_archives_result"
7915
# POSIX demands no paths to be encoded in archives. We have
7916
# to avoid creating archives with duplicate basenames if we
7917
# might have to extract them afterwards, e.g., when creating a
7918
# static archive out of a convenience library, or when linking
7919
# the entirety of a libtool archive into another (currently
7920
# not supported by libtool).
7921
if (for obj in $oldobjs
7923
func_basename "$obj"
7924
$ECHO "$func_basename_result"
7925
done | sort | sort -uc >/dev/null 2>&1); then
7928
$ECHO "copying selected object files to avoid basename conflicts..."
7929
gentop="$output_objdir/${outputname}x"
7930
generated="$generated $gentop"
7931
func_mkdir_p "$gentop"
7932
save_oldobjs=$oldobjs
7935
for obj in $save_oldobjs
7937
func_basename "$obj"
7938
objbase="$func_basename_result"
7939
case " $oldobjs " in
7940
" ") oldobjs=$obj ;;
7943
# Make sure we don't pick an alternate name that also
7945
newobj=lt$counter-$objbase
7946
func_arith $counter + 1
7947
counter=$func_arith_result
7948
case " $oldobjs " in
7949
*[\ /]"$newobj "*) ;;
7950
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
7953
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7954
oldobjs="$oldobjs $gentop/$newobj"
7956
*) oldobjs="$oldobjs $obj" ;;
7960
eval cmds=\"$old_archive_cmds\"
7963
len=$func_len_result
7964
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7965
cmds=$old_archive_cmds
7967
# the command line is too long to link in one step, link in parts
7968
func_verbose "using piecewise archive linking..."
7973
save_oldobjs=$oldobjs
7975
# Is there a better way of finding the last object in the list?
7976
for obj in $save_oldobjs
7980
eval test_cmds=\"$old_archive_cmds\"
7981
func_len " $test_cmds"
7982
len0=$func_len_result
7984
for obj in $save_oldobjs
7987
func_arith $len + $func_len_result
7988
len=$func_arith_result
7989
func_append objlist " $obj"
7990
if test "$len" -lt "$max_cmd_len"; then
7993
# the above command should be used before it gets too long
7995
if test "$obj" = "$last_oldobj" ; then
7998
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7999
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8006
if test "X$oldobjs" = "X" ; then
8007
eval cmds=\"\$concat_cmds\"
8009
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8013
func_execute_cmds "$cmds" 'exit $?'
8016
test -n "$generated" && \
8017
func_show_eval "${RM}r$generated"
8019
# Now create the libtool archive.
8023
test "$build_old_libs" = yes && old_library="$libname.$libext"
8024
func_verbose "creating $output"
8026
# Preserve any variables that may affect compiler behavior
8027
for var in $variables_saved_for_relink; do
8028
if eval test -z \"\${$var+set}\"; then
8029
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8030
elif eval var_value=\$$var; test -z "$var_value"; then
8031
relink_command="$var=; export $var; $relink_command"
8033
func_quote_for_eval "$var_value"
8034
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8037
# Quote the link command for shipping.
8038
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8039
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8040
if test "$hardcode_automatic" = yes ; then
8044
# Only create the output if not a dry run.
8046
for installed in no yes; do
8047
if test "$installed" = yes; then
8048
if test -z "$install_libdir"; then
8051
output="$output_objdir/$outputname"i
8052
# Replace all uninstalled libtool libraries with the installed ones
8054
for deplib in $dependency_libs; do
8057
func_basename "$deplib"
8058
name="$func_basename_result"
8059
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8060
test -z "$libdir" && \
8061
func_fatal_error "\`$deplib' is not a valid libtool archive"
8062
newdependency_libs="$newdependency_libs $libdir/$name"
8064
*) newdependency_libs="$newdependency_libs $deplib" ;;
8067
dependency_libs="$newdependency_libs"
8070
for lib in $dlfiles; do
8073
func_basename "$lib"
8074
name="$func_basename_result"
8075
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8076
test -z "$libdir" && \
8077
func_fatal_error "\`$lib' is not a valid libtool archive"
8078
newdlfiles="$newdlfiles $libdir/$name"
8080
*) newdlfiles="$newdlfiles $lib" ;;
8083
dlfiles="$newdlfiles"
8085
for lib in $dlprefiles; do
8088
# Only pass preopened files to the pseudo-archive (for
8089
# eventual linking with the app. that links it) if we
8090
# didn't already link the preopened objects directly into
8092
func_basename "$lib"
8093
name="$func_basename_result"
8094
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8095
test -z "$libdir" && \
8096
func_fatal_error "\`$lib' is not a valid libtool archive"
8097
newdlprefiles="$newdlprefiles $libdir/$name"
8101
dlprefiles="$newdlprefiles"
8104
for lib in $dlfiles; do
8106
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8107
*) abs=`pwd`"/$lib" ;;
8109
newdlfiles="$newdlfiles $abs"
8111
dlfiles="$newdlfiles"
8113
for lib in $dlprefiles; do
8115
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8116
*) abs=`pwd`"/$lib" ;;
8118
newdlprefiles="$newdlprefiles $abs"
8120
dlprefiles="$newdlprefiles"
8123
# place dlname in correct position for cygwin
8125
case $host,$output,$installed,$module,$dlname in
8126
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8129
# $outputname - a libtool library file
8130
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8132
# Please DO NOT delete this file!
8133
# It is necessary for linking the library.
8135
# The name that we can dlopen(3).
8138
# Names of this library.
8139
library_names='$library_names'
8141
# The name of the static archive.
8142
old_library='$old_library'
8144
# Linker flags that can not go in dependency_libs.
8145
inherited_linker_flags='$new_inherited_linker_flags'
8147
# Libraries that this one depends upon.
8148
dependency_libs='$dependency_libs'
8150
# Names of additional weak libraries provided by this library
8151
weak_library_names='$weak_libs'
8153
# Version information for $libname.
8158
# Is this an already installed library?
8159
installed=$installed
8161
# Should we warn about portability when linking against -modules?
8162
shouldnotlink=$module
8164
# Files to dlopen/dlpreopen
8166
dlpreopen='$dlprefiles'
8168
# Directory that this library needs to be installed in:
8169
libdir='$install_libdir'"
8170
if test "$installed" = no && test "$need_relink" = yes; then
8172
relink_command=\"$relink_command\""
8177
# Do a symbolic link so that the libtool archive can be found in
8178
# LD_LIBRARY_PATH before the program is installed.
8179
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8185
{ test "$mode" = link || test "$mode" = relink; } &&
8186
func_mode_link ${1+"$@"}
8189
# func_mode_uninstall arg...
8190
func_mode_uninstall ()
8198
# This variable tells wrapper scripts just to set variables rather
8199
# than running their programs.
8200
libtool_install_magic="$magic"
8205
-f) RM="$RM $arg"; rmforce=yes ;;
8206
-*) RM="$RM $arg" ;;
8207
*) files="$files $arg" ;;
8212
func_fatal_help "you must specify an RM program"
8216
origobjdir="$objdir"
8217
for file in $files; do
8218
func_dirname "$file" "" "."
8219
dir="$func_dirname_result"
8220
if test "X$dir" = X.; then
8221
objdir="$origobjdir"
8223
objdir="$dir/$origobjdir"
8225
func_basename "$file"
8226
name="$func_basename_result"
8227
test "$mode" = uninstall && objdir="$dir"
8229
# Remember objdir for removal later, being careful to avoid duplicates
8230
if test "$mode" = clean; then
8233
*) rmdirs="$rmdirs $objdir" ;;
8237
# Don't error if the file doesn't exist and rm -f was used.
8238
if { test -L "$file"; } >/dev/null 2>&1 ||
8239
{ test -h "$file"; } >/dev/null 2>&1 ||
8240
test -f "$file"; then
8242
elif test -d "$file"; then
8245
elif test "$rmforce" = yes; then
8253
# Possibly a libtool archive, so verify it.
8254
if func_lalib_p "$file"; then
8255
func_source $dir/$name
8257
# Delete the libtool libraries and symlinks.
8258
for n in $library_names; do
8259
rmfiles="$rmfiles $objdir/$n"
8261
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8265
case " $library_names " in
8266
# " " in the beginning catches empty $dlname
8268
*) rmfiles="$rmfiles $objdir/$dlname" ;;
8270
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8273
if test -n "$library_names"; then
8274
# Do each command in the postuninstall commands.
8275
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8278
if test -n "$old_library"; then
8279
# Do each command in the old_postuninstall commands.
8280
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8282
# FIXME: should reinstall the best remaining shared library.
8289
# Possibly a libtool object, so verify it.
8290
if func_lalib_p "$file"; then
8293
func_source $dir/$name
8295
# Add PIC object to the list of files to remove.
8296
if test -n "$pic_object" &&
8297
test "$pic_object" != none; then
8298
rmfiles="$rmfiles $dir/$pic_object"
8301
# Add non-PIC object to the list of files to remove.
8302
if test -n "$non_pic_object" &&
8303
test "$non_pic_object" != none; then
8304
rmfiles="$rmfiles $dir/$non_pic_object"
8310
if test "$mode" = clean ; then
8314
func_stripname '' '.exe' "$file"
8315
file=$func_stripname_result
8316
func_stripname '' '.exe' "$name"
8317
noexename=$func_stripname_result
8318
# $file with .exe has already been added to rmfiles,
8319
# add $file without .exe
8320
rmfiles="$rmfiles $file"
8323
# Do a test to see if this is a libtool program.
8324
if func_ltwrapper_p "$file"; then
8325
if func_ltwrapper_executable_p "$file"; then
8326
func_ltwrapper_scriptname "$file"
8328
func_source $func_ltwrapper_scriptname_result
8329
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8332
func_source $dir/$noexename
8335
# note $name still contains .exe if it was in $file originally
8336
# as does the version of $file that was added into $rmfiles
8337
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8338
if test "$fast_install" = yes && test -n "$relink_command"; then
8339
rmfiles="$rmfiles $objdir/lt-$name"
8341
if test "X$noexename" != "X$name" ; then
8342
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8348
func_show_eval "$RM $rmfiles" 'exit_status=1'
8350
objdir="$origobjdir"
8352
# Try to remove the ${objdir}s in the directories where we deleted files
8353
for dir in $rmdirs; do
8354
if test -d "$dir"; then
8355
func_show_eval "rmdir $dir >/dev/null 2>&1"
8362
{ test "$mode" = uninstall || test "$mode" = clean; } &&
8363
func_mode_uninstall ${1+"$@"}
8365
test -z "$mode" && {
8366
help="$generic_help"
8367
func_fatal_help "you must specify a MODE"
8370
test -z "$exec_cmd" && \
8371
func_fatal_help "invalid operation mode \`$mode'"
8373
if test -n "$exec_cmd"; then
8374
eval exec "$exec_cmd"
8381
# The TAGs below are defined such that we never get into a situation
8382
# in which we disable both kinds of libraries. Given conflicting
8383
# choices, we go for a static library, that is the most portable,
8384
# since we can't tell whether shared libraries were disabled because
8385
# the user asked for that or because the platform doesn't support
8386
# them. This is particularly important on AIX, because we don't
8387
# support having both static and shared libraries enabled at the same
8388
# time on that platform, so we default to a shared-only configuration.
8389
# If a disable-shared tag is given, we'll fallback to a static-only
8390
# configuration. But we'll never go from static-only to shared-only.
8392
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8393
build_libtool_libs=no
8395
# ### END LIBTOOL TAG CONFIG: disable-shared
8397
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8398
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8399
# ### END LIBTOOL TAG CONFIG: disable-static