1
# Generated from ltmain.m4sh.
3
# ltmain.sh (GNU libtool) 2.2.6
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.6
69
# automake: $automake_version
70
# autoconf: $autoconf_version
72
# Report bugs to <bug-libtool@gnu.org>.
78
package_revision=1.3012
80
# Be Bourne compatible
81
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
84
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
85
# is contrary to our usage. Disable this feature.
86
alias -g '${1+"$@"}'='"$@"'
89
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
91
BIN_SH=xpg4; export BIN_SH # for Tru64
92
DUALCASE=1; export DUALCASE # for MKS sh
94
# NLS nuisances: We save the old values to restore during execute mode.
95
# Only set LANG and LC_ALL to C if already set.
96
# These must not be set unconditionally because not all systems understand
97
# e.g. LANG=C (notably SCO).
100
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
102
eval "if test \"\${$lt_var+set}\" = set; then
103
save_$lt_var=\$$lt_var
106
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
107
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
119
: ${EGREP="/usr/bin/grep -E"}
120
: ${FGREP="/usr/bin/grep -F"}
121
: ${GREP="/usr/bin/grep"}
127
: ${SED="/opt/local/bin/gsed"}
128
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
129
: ${Xsed="$SED -e 1s/^X//"}
134
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
135
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
137
exit_status=$EXIT_SUCCESS
139
# Make sure IFS has a sensible default
144
dirname="s,/[^/]*$,,"
147
# func_dirname_and_basename file append nondir_replacement
148
# perform func_basename and func_dirname in a single function
150
# dirname: Compute the dirname of FILE. If nonempty,
151
# add APPEND to the result, otherwise set result
152
# to NONDIR_REPLACEMENT.
153
# value returned in "$func_dirname_result"
154
# basename: Compute filename of FILE.
155
# value retuned in "$func_basename_result"
156
# Implementation must be kept synchronized with func_dirname
157
# and func_basename. For efficiency, we do not delegate to
158
# those functions but instead duplicate the functionality here.
159
func_dirname_and_basename ()
161
# Extract subdirectory from the argument.
162
func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
163
if test "X$func_dirname_result" = "X${1}"; then
164
func_dirname_result="${3}"
166
func_dirname_result="$func_dirname_result${2}"
168
func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
171
# Generated shell functions inserted here.
173
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
174
# is ksh but when the shell is invoked as "sh" and the current value of
175
# the _XPG environment variable is not equal to 1 (one), the special
176
# positional parameter $0, within a function call, is the name of the
180
# The name of this program:
181
# In the unlikely event $progname began with a '-', it would play havoc with
182
# func_echo (imagine progname=-n), so we prepend ./ in that case:
183
func_dirname_and_basename "$progpath"
184
progname=$func_basename_result
186
-*) progname=./$progname ;;
189
# Make sure we have an absolute path for reexecution:
191
[\\/]*|[A-Za-z]:\\*) ;;
193
progdir=$func_dirname_result
194
progdir=`cd "$progdir" && pwd`
195
progpath="$progdir/$progname"
200
for progdir in $PATH; do
202
test -x "$progdir/$progname" && break
205
test -n "$progdir" || progdir=`pwd`
206
progpath="$progdir/$progname"
210
# Sed substitution that helps us do robust quoting. It backslashifies
211
# metacharacters that are still active within double-quoted strings.
212
Xsed="${SED}"' -e 1s/^X//'
213
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
215
# Same as above, but do not quote variable references.
216
double_quote_subst='s/\(["`\\]\)/\\\1/g'
218
# Re-`\' parameter expansions in output of double_quote_subst that were
219
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
220
# in input to double_quote_subst, that '$' was protected from expansion.
221
# Since each input `\' is now two `\'s, look for any number of runs of
222
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
227
sed_double_backslash="\
231
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
242
# Echo program name prefixed message, along with the current mode
243
# name if it has been set yet.
246
$ECHO "$progname${mode+: }$mode: $*"
249
# func_verbose arg...
250
# Echo program name prefixed message in verbose mode only.
253
$opt_verbose && func_echo ${1+"$@"}
255
# A bug in bash halts the script if the last line of a function
256
# fails when set -e is in force, so we need another command to
262
# Echo program name prefixed message to standard error.
265
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
268
# func_warning arg...
269
# Echo program name prefixed warning message to standard error.
272
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
278
# func_fatal_error arg...
279
# Echo program name prefixed message to standard error, and exit.
286
# func_fatal_help arg...
287
# Echo program name prefixed message to standard error, followed by
288
# a help hint, and exit.
292
func_fatal_error "$help"
294
help="Try \`$progname --help' for more information." ## default
297
# func_grep expression filename
298
# Check whether EXPRESSION matches any line of FILENAME, without output.
301
$GREP "$1" "$2" >/dev/null 2>&1
305
# func_mkdir_p directory-path
306
# Make sure the entire path to DIRECTORY-PATH is available.
309
my_directory_path="$1"
312
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
314
# Protect directory names starting with `-'
315
case $my_directory_path in
316
-*) my_directory_path="./$my_directory_path" ;;
319
# While some portion of DIR does not yet exist...
320
while test ! -d "$my_directory_path"; do
321
# ...make a list in topmost first order. Use a colon delimited
322
# list incase some portion of path contains whitespace.
323
my_dir_list="$my_directory_path:$my_dir_list"
325
# If the last portion added has no slash in it, the list is done
326
case $my_directory_path in */*) ;; *) break ;; esac
328
# ...otherwise throw away the child directory and loop
329
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
331
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
333
save_mkdir_p_IFS="$IFS"; IFS=':'
334
for my_dir in $my_dir_list; do
335
IFS="$save_mkdir_p_IFS"
336
# mkdir can fail with a `File exist' error if two processes
337
# try to create one of the directories concurrently. Don't
339
$MKDIR "$my_dir" 2>/dev/null || :
341
IFS="$save_mkdir_p_IFS"
343
# Bail out if we (or some other process) failed to create a directory.
344
test -d "$my_directory_path" || \
345
func_fatal_error "Failed to create \`$1'"
350
# func_mktempdir [string]
351
# Make a temporary directory that won't clash with other running
352
# libtool processes, and avoids race conditions if possible. If
353
# given, STRING is the basename for that directory.
356
my_template="${TMPDIR-/tmp}/${1-$progname}"
358
if test "$opt_dry_run" = ":"; then
359
# Return a directory name, but don't create it in dry-run mode
360
my_tmpdir="${my_template}-$$"
363
# If mktemp works, use that first and foremost
364
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
366
if test ! -d "$my_tmpdir"; then
367
# Failing that, at least try and use $RANDOM to avoid a race
368
my_tmpdir="${my_template}-${RANDOM-0}$$"
370
save_mktempdir_umask=`umask`
373
umask $save_mktempdir_umask
376
# If we're not in dry-run mode, bomb out on failure
377
test -d "$my_tmpdir" || \
378
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
381
$ECHO "X$my_tmpdir" | $Xsed
385
# func_quote_for_eval arg
386
# Aesthetically quote ARG to be evaled later.
387
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
388
# is double-quoted, suitable for a subsequent eval, whereas
389
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
390
# which are still active within double quotes backslashified.
391
func_quote_for_eval ()
395
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
397
func_quote_for_eval_unquoted_result="$1" ;;
400
case $func_quote_for_eval_unquoted_result in
401
# Double-quote args containing shell metacharacters to delay
402
# word splitting, command substitution and and variable
403
# expansion for a subsequent eval.
404
# Many Bourne shells cannot handle close brackets correctly
405
# in scan sets, so we specify it separately.
406
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
407
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
410
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
415
# func_quote_for_expand arg
416
# Aesthetically quote ARG to be evaled later; same as above,
417
# but do not quote variable references.
418
func_quote_for_expand ()
422
my_arg=`$ECHO "X$1" | $Xsed \
423
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
429
# Double-quote args containing shell metacharacters to delay
430
# word splitting and command substitution for a subsequent eval.
431
# Many Bourne shells cannot handle close brackets correctly
432
# in scan sets, so we specify it separately.
433
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
438
func_quote_for_expand_result="$my_arg"
442
# func_show_eval cmd [fail_exp]
443
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
444
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
445
# is given, then evaluate it.
451
${opt_silent-false} || {
452
func_quote_for_expand "$my_cmd"
453
eval "func_echo $func_quote_for_expand_result"
456
if ${opt_dry_run-false}; then :; else
459
if test "$my_status" -eq 0; then :; else
460
eval "(exit $my_status); $my_fail_exp"
466
# func_show_eval_locale cmd [fail_exp]
467
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
468
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
469
# is given, then evaluate it. Use the saved locale for evaluation.
470
func_show_eval_locale ()
475
${opt_silent-false} || {
476
func_quote_for_expand "$my_cmd"
477
eval "func_echo $func_quote_for_expand_result"
480
if ${opt_dry_run-false}; then :; else
481
eval "$lt_user_locale
484
eval "$lt_safe_locale"
485
if test "$my_status" -eq 0; then :; else
486
eval "(exit $my_status); $my_fail_exp"
496
# Echo version message to standard output and exit.
499
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
502
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
509
# Echo short help message to standard output and exit.
512
$SED -n '/^# Usage:/,/# -h/ {
515
s/\$progname/'$progname'/
519
$ECHO "run \`$progname --help | more' for full usage"
524
# Echo long help message to standard output and exit.
527
$SED -n '/^# Usage:/,/# Report bugs to/ {
530
s*\$progname*'$progname'*
532
s*\$SHELL*'"$SHELL"'*
534
s*\$LTCFLAGS*'"$LTCFLAGS"'*
536
s/\$with_gnu_ld/'"$with_gnu_ld"'/
537
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
538
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
544
# func_missing_arg argname
545
# Echo program name prefixed message to standard error and set global
549
func_error "missing argument for $1"
559
# Check that we have a working $ECHO.
560
if test "X$1" = X--no-reexec; then
561
# Discard the --no-reexec flag, and continue.
563
elif test "X$1" = X--fallback-echo; then
564
# Avoid inline document here, it may be left over
566
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
567
# Yippee, $ECHO works!
570
# Restart under the correct shell, and then maybe $ECHO will work.
571
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
574
if test "X$1" = X--fallback-echo; then
575
# used as fallback echo
583
magic="%%%MAGIC variable%%%"
584
magic_exe="%%%MAGIC EXE variable%%%"
591
lo2o="s/\\.lo\$/.${objext}/"
592
o2lo="s/\\.${objext}\$/.lo/"
597
opt_duplicate_deps=false
601
# If this variable is set in any of the actions, the command in it
602
# will be execed at the end. This prevents here-documents from being
603
# left over by shells.
606
# func_fatal_configuration arg...
607
# Echo program name prefixed message to standard error, followed by
608
# a configuration failure hint, and exit.
609
func_fatal_configuration ()
612
func_error "See the $PACKAGE documentation for more information."
613
func_fatal_error "Fatal configuration error."
618
# Display the configuration for all the tags in this script.
621
re_begincf='^# ### BEGIN LIBTOOL'
622
re_endcf='^# ### END LIBTOOL'
624
# Default configuration.
625
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
627
# Now print the configurations for the tags.
628
for tagname in $taglist; do
629
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
636
# Display the features supported by this script.
640
if test "$build_libtool_libs" = yes; then
641
$ECHO "enable shared libraries"
643
$ECHO "disable shared libraries"
645
if test "$build_old_libs" = yes; then
646
$ECHO "enable static libraries"
648
$ECHO "disable static libraries"
654
# func_enable_tag tagname
655
# Verify that TAGNAME is valid, and either flag an error and exit, or
656
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
663
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
664
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
665
sed_extractcf="/$re_begincf/,/$re_endcf/p"
670
func_fatal_error "invalid tag name: $tagname"
674
# Don't test for the "default" C tag, as we know it's
675
# there but not specially marked.
679
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
680
taglist="$taglist $tagname"
682
# Evaluate the configuration. Be careful to quote the path
683
# and the sed script, to avoid splitting on whitespace, but
684
# also don't use non-portable quotes within backquotes within
685
# quotes we have to do it in 2 steps:
686
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
689
func_error "ignoring unknown tag $tagname"
695
# Parse options once, thoroughly. This comes as soon as possible in
696
# the script to make things like `libtool --version' happen quickly.
699
# Shorthand for --mode=foo, only valid as the first argument
702
shift; set dummy --mode clean ${1+"$@"}; shift
704
compile|compil|compi|comp|com|co|c)
705
shift; set dummy --mode compile ${1+"$@"}; shift
707
execute|execut|execu|exec|exe|ex|e)
708
shift; set dummy --mode execute ${1+"$@"}; shift
710
finish|finis|fini|fin|fi|f)
711
shift; set dummy --mode finish ${1+"$@"}; shift
713
install|instal|insta|inst|ins|in|i)
714
shift; set dummy --mode install ${1+"$@"}; shift
717
shift; set dummy --mode link ${1+"$@"}; shift
719
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
720
shift; set dummy --mode uninstall ${1+"$@"}; shift
724
# Parse non-mode specific arguments:
725
while test "$#" -gt 0; do
730
--config) func_config ;;
732
--debug) preserve_args="$preserve_args $opt"
733
func_echo "enabling shell trace mode"
738
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
739
execute_dlfiles="$execute_dlfiles $1"
743
--dry-run | -n) opt_dry_run=: ;;
744
--features) func_features ;;
745
--finish) mode="finish" ;;
747
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
749
# Valid mode arguments:
759
# Catch anything else as an error
760
*) func_error "invalid argument for $opt"
771
opt_duplicate_deps=: ;;
773
--quiet|--silent) preserve_args="$preserve_args $opt"
777
--verbose| -v) preserve_args="$preserve_args $opt"
781
--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
782
preserve_args="$preserve_args $opt $1"
783
func_enable_tag "$1" # tagname is set here
787
# Separate optargs to long options:
788
-dlopen=*|--mode=*|--tag=*)
789
func_opt_split "$opt"
790
set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
794
-\?|-h) func_usage ;;
795
--help) opt_help=: ;;
796
--version) func_version ;;
798
-*) func_fatal_help "unrecognized option \`$opt'" ;;
808
*cygwin* | *mingw* | *pw32* | *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 */
3364
main (int argc, char *argv[])
3369
char *actual_cwrapper_path;
3370
char *actual_cwrapper_name;
3373
intptr_t rval = 127;
3377
program_name = (char *) xstrdup (base_name (argv[0]));
3378
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3379
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3381
/* very simple arg parsing; don't want to rely on getopt */
3382
for (i = 1; i < argc; i++)
3384
if (strcmp (argv[i], dumpscript_opt) == 0)
3388
*mingw* | *cygwin* )
3389
# make stdout use "unix" line endings
3390
echo " setmode(1,_O_BINARY);"
3395
printf ("%s", script_text_part1);
3396
printf ("%s", script_text_part2);
3401
newargz = XMALLOC (char *, argc + 1);
3402
tmp_pathspec = find_executable (argv[0]);
3403
if (tmp_pathspec == NULL)
3404
lt_fatal ("Couldn't find %s", argv[0]);
3405
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3408
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3409
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3410
actual_cwrapper_path));
3411
XFREE (tmp_pathspec);
3413
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3414
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3416
/* wrapper name transforms */
3417
strendzap (actual_cwrapper_name, ".exe");
3418
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3419
XFREE (actual_cwrapper_name);
3420
actual_cwrapper_name = tmp_pathspec;
3423
/* target_name transforms -- use actual target program name; might have lt- prefix */
3424
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3425
strendzap (target_name, ".exe");
3426
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3427
XFREE (target_name);
3428
target_name = tmp_pathspec;
3431
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3437
XMALLOC (char, (strlen (actual_cwrapper_path) +
3438
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3439
strcpy (newargz[0], actual_cwrapper_path);
3440
strcat (newargz[0], "$objdir");
3441
strcat (newargz[0], "/");
3445
/* stop here, and copy so we don't have to do this twice */
3446
tmp_pathspec = xstrdup (newargz[0]);
3448
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3449
strcat (newargz[0], actual_cwrapper_name);
3451
/* DO want the lt- prefix here if it exists, so use target_name */
3452
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3453
XFREE (tmp_pathspec);
3454
tmp_pathspec = NULL;
3462
while ((p = strchr (newargz[0], '\\')) != NULL)
3466
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3476
XFREE (target_name);
3477
XFREE (actual_cwrapper_path);
3478
XFREE (actual_cwrapper_name);
3480
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3481
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3482
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3483
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3486
for (i = 1; i < argc; i++)
3488
if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3490
if (argv[i][env_set_opt_len] == '=')
3492
const char *p = argv[i] + env_set_opt_len + 1;
3493
lt_opt_process_env_set (p);
3495
else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3497
lt_opt_process_env_set (argv[++i]); /* don't copy */
3500
lt_fatal ("%s missing required argument", env_set_opt);
3503
if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3505
if (argv[i][env_prepend_opt_len] == '=')
3507
const char *p = argv[i] + env_prepend_opt_len + 1;
3508
lt_opt_process_env_prepend (p);
3510
else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3512
lt_opt_process_env_prepend (argv[++i]); /* don't copy */
3515
lt_fatal ("%s missing required argument", env_prepend_opt);
3518
if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
3520
if (argv[i][env_append_opt_len] == '=')
3522
const char *p = argv[i] + env_append_opt_len + 1;
3523
lt_opt_process_env_append (p);
3525
else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
3527
lt_opt_process_env_append (argv[++i]); /* don't copy */
3530
lt_fatal ("%s missing required argument", env_append_opt);
3533
if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3535
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3536
namespace, but it is not one of the ones we know about and
3537
have already dealt with, above (inluding dump-script), then
3538
report an error. Otherwise, targets might begin to believe
3539
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3540
namespace. The first time any user complains about this, we'll
3541
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3542
or a configure.ac-settable value.
3544
lt_fatal ("Unrecognized option in %s namespace: '%s'",
3545
ltwrapper_option_prefix, argv[i]);
3548
newargz[++newargc] = xstrdup (argv[i]);
3550
newargz[++newargc] = NULL;
3552
LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3553
for (i = 0; i < newargc; i++)
3555
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3563
/* execv doesn't actually work on mingw as expected on unix */
3564
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3567
/* failed to start process */
3568
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3576
execv (lt_argv_zero, newargz);
3577
return rval; /* =127, but avoids unused variable warning */
3586
xmalloc (size_t num)
3588
void *p = (void *) malloc (num);
3590
lt_fatal ("Memory exhausted");
3596
xstrdup (const char *string)
3598
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3603
base_name (const char *name)
3607
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3608
/* Skip over the disk name in MSDOS pathnames. */
3609
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3613
for (base = name; *name; name++)
3614
if (IS_DIR_SEPARATOR (*name))
3620
check_executable (const char *path)
3624
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3625
path ? (*path ? path : "EMPTY!") : "NULL!"));
3626
if ((!path) || (!*path))
3629
if ((stat (path, &st) >= 0)
3630
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3637
make_executable (const char *path)
3642
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3643
path ? (*path ? path : "EMPTY!") : "NULL!"));
3644
if ((!path) || (!*path))
3647
if (stat (path, &st) >= 0)
3649
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3654
/* Searches for the full path of the wrapper. Returns
3655
newly allocated full path name if found, NULL otherwise
3656
Does not chase symlinks, even on platforms that support them.
3659
find_executable (const char *wrapper)
3664
/* static buffer for getcwd */
3665
char tmp[LT_PATHMAX + 1];
3669
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3670
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3672
if ((wrapper == NULL) || (*wrapper == '\0'))
3675
/* Absolute path? */
3676
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3677
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3679
concat_name = xstrdup (wrapper);
3680
if (check_executable (concat_name))
3682
XFREE (concat_name);
3687
if (IS_DIR_SEPARATOR (wrapper[0]))
3689
concat_name = xstrdup (wrapper);
3690
if (check_executable (concat_name))
3692
XFREE (concat_name);
3694
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3698
for (p = wrapper; *p; p++)
3706
/* no slashes; search PATH */
3707
const char *path = getenv ("PATH");
3710
for (p = path; *p; p = p_next)
3714
for (q = p; *q; q++)
3715
if (IS_PATH_SEPARATOR (*q))
3718
p_next = (*q == '\0' ? q : q + 1);
3721
/* empty path: current directory */
3722
if (getcwd (tmp, LT_PATHMAX) == NULL)
3723
lt_fatal ("getcwd failed");
3724
tmp_len = strlen (tmp);
3726
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3727
memcpy (concat_name, tmp, tmp_len);
3728
concat_name[tmp_len] = '/';
3729
strcpy (concat_name + tmp_len + 1, wrapper);
3734
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3735
memcpy (concat_name, p, p_len);
3736
concat_name[p_len] = '/';
3737
strcpy (concat_name + p_len + 1, wrapper);
3739
if (check_executable (concat_name))
3741
XFREE (concat_name);
3744
/* not found in PATH; assume curdir */
3746
/* Relative path | not found in path: prepend cwd */
3747
if (getcwd (tmp, LT_PATHMAX) == NULL)
3748
lt_fatal ("getcwd failed");
3749
tmp_len = strlen (tmp);
3750
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3751
memcpy (concat_name, tmp, tmp_len);
3752
concat_name[tmp_len] = '/';
3753
strcpy (concat_name + tmp_len + 1, wrapper);
3755
if (check_executable (concat_name))
3757
XFREE (concat_name);
3762
chase_symlinks (const char *pathspec)
3765
return xstrdup (pathspec);
3767
char buf[LT_PATHMAX];
3769
char *tmp_pathspec = xstrdup (pathspec);
3771
int has_symlinks = 0;
3772
while (strlen (tmp_pathspec) && !has_symlinks)
3774
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3776
if (lstat (tmp_pathspec, &s) == 0)
3778
if (S_ISLNK (s.st_mode) != 0)
3784
/* search backwards for last DIR_SEPARATOR */
3785
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3786
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3788
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3790
/* no more DIR_SEPARATORS left */
3797
char *errstr = strerror (errno);
3798
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3801
XFREE (tmp_pathspec);
3805
return xstrdup (pathspec);
3808
tmp_pathspec = realpath (pathspec, buf);
3809
if (tmp_pathspec == 0)
3811
lt_fatal ("Could not follow symlinks for %s", pathspec);
3813
return xstrdup (tmp_pathspec);
3818
strendzap (char *str, const char *pat)
3822
assert (str != NULL);
3823
assert (pat != NULL);
3826
patlen = strlen (pat);
3830
str += len - patlen;
3831
if (strcmp (str, pat) == 0)
3838
lt_error_core (int exit_status, const char *mode,
3839
const char *message, va_list ap)
3841
fprintf (stderr, "%s: %s: ", program_name, mode);
3842
vfprintf (stderr, message, ap);
3843
fprintf (stderr, ".\n");
3845
if (exit_status >= 0)
3850
lt_fatal (const char *message, ...)
3853
va_start (ap, message);
3854
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
3859
lt_setenv (const char *name, const char *value)
3861
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
3862
(name ? name : "<NULL>"),
3863
(value ? value : "<NULL>")));
3866
/* always make a copy, for consistency with !HAVE_SETENV */
3867
char *str = xstrdup (value);
3868
setenv (name, str, 1);
3870
int len = strlen (name) + 1 + strlen (value) + 1;
3871
char *str = XMALLOC (char, len);
3872
sprintf (str, "%s=%s", name, value);
3873
if (putenv (str) != EXIT_SUCCESS)
3882
lt_extend_str (const char *orig_value, const char *add, int to_end)
3885
if (orig_value && *orig_value)
3887
int orig_value_len = strlen (orig_value);
3888
int add_len = strlen (add);
3889
new_value = XMALLOC (char, add_len + orig_value_len + 1);
3892
strcpy (new_value, orig_value);
3893
strcpy (new_value + orig_value_len, add);
3897
strcpy (new_value, add);
3898
strcpy (new_value + add_len, orig_value);
3903
new_value = xstrdup (add);
3909
lt_split_name_value (const char *arg, char** name, char** value)
3916
p = strchr (arg, (int)'=');
3921
*value = xstrdup (++p);
3923
len = strlen (arg) - strlen (*value);
3924
*name = XMALLOC (char, len);
3925
strncpy (*name, arg, len-1);
3926
(*name)[len - 1] = '\0';
3932
lt_opt_process_env_set (const char *arg)
3937
if (lt_split_name_value (arg, &name, &value) != 0)
3941
lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
3944
lt_setenv (name, value);
3950
lt_opt_process_env_prepend (const char *arg)
3954
char *new_value = NULL;
3956
if (lt_split_name_value (arg, &name, &value) != 0)
3960
lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
3963
new_value = lt_extend_str (getenv (name), value, 0);
3964
lt_setenv (name, new_value);
3971
lt_opt_process_env_append (const char *arg)
3975
char *new_value = NULL;
3977
if (lt_split_name_value (arg, &name, &value) != 0)
3981
lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
3984
new_value = lt_extend_str (getenv (name), value, 1);
3985
lt_setenv (name, new_value);
3992
lt_update_exe_path (const char *name, const char *value)
3994
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
3995
(name ? name : "<NULL>"),
3996
(value ? value : "<NULL>")));
3998
if (name && *name && value && *value)
4000
char *new_value = lt_extend_str (getenv (name), value, 0);
4001
/* some systems can't cope with a ':'-terminated path #' */
4002
int len = strlen (new_value);
4003
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4005
new_value[len-1] = '\0';
4007
lt_setenv (name, new_value);
4013
lt_update_lib_path (const char *name, const char *value)
4015
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4016
(name ? name : "<NULL>"),
4017
(value ? value : "<NULL>")));
4019
if (name && *name && value && *value)
4021
char *new_value = lt_extend_str (getenv (name), value, 0);
4022
lt_setenv (name, new_value);
4030
# end: func_emit_cwrapperexe_src
4032
# func_mode_link arg...
4037
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4038
# It is impossible to link a dll without this setting, and
4039
# we shouldn't force the makefile maintainer to figure out
4040
# which system we are compiling for in order to pass an extra
4041
# flag for every libtool invocation.
4042
# allow_undefined=no
4044
# FIXME: Unfortunately, there are problems with the above when trying
4045
# to make a dll which has undefined symbols, in which case not
4046
# even a static library is built. For now, we need to specify
4047
# -no-undefined on the libtool link line when we can be certain
4048
# that all symbols are satisfied, otherwise we get a static library.
4055
libtool_args=$nonopt
4056
base_compile="$nonopt $@"
4057
compile_command=$nonopt
4058
finalize_command=$nonopt
4071
lib_search_path=`pwd`
4073
new_inherited_linker_flags=
4081
export_symbols_regex=
4089
precious_files_regex=
4090
prefer_static_libs=no
4103
single_module="${wl}-single_module"
4104
func_infer_tag $base_compile
4106
# We need to know -static, to get the right output filenames.
4111
test "$build_libtool_libs" != yes && \
4112
func_fatal_configuration "can not build a shared library"
4116
-all-static | -static | -static-libtool-libs)
4119
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4120
func_warning "complete static linking is impossible in this configuration"
4122
if test -n "$link_static_flag"; then
4123
dlopen_self=$dlopen_self_static
4125
prefer_static_libs=yes
4128
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4129
dlopen_self=$dlopen_self_static
4131
prefer_static_libs=built
4133
-static-libtool-libs)
4134
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4135
dlopen_self=$dlopen_self_static
4137
prefer_static_libs=yes
4140
build_libtool_libs=no
4147
# See if our shared archives depend on static archives.
4148
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4150
# Go through the arguments, transforming them on the way.
4151
while test "$#" -gt 0; do
4154
func_quote_for_eval "$arg"
4155
qarg=$func_quote_for_eval_unquoted_result
4156
func_append libtool_args " $func_quote_for_eval_result"
4158
# If the previous option needs an argument, assign it.
4159
if test -n "$prev"; then
4162
func_append compile_command " @OUTPUT@"
4163
func_append finalize_command " @OUTPUT@"
4169
if test "$preload" = no; then
4170
# Add the symbol object into the linking commands.
4171
func_append compile_command " @SYMFILE@"
4172
func_append finalize_command " @SYMFILE@"
4176
*.la | *.lo) ;; # We handle these cases below.
4178
if test "$dlself" = no; then
4186
if test "$prev" = dlprefiles; then
4188
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4198
if test "$prev" = dlfiles; then
4199
dlfiles="$dlfiles $arg"
4201
dlprefiles="$dlprefiles $arg"
4209
export_symbols="$arg"
4211
|| func_fatal_error "symbol file \`$arg' does not exist"
4216
export_symbols_regex="$arg"
4224
*" $qarg.ltframework "*) ;;
4225
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4234
inst_prefix_dir="$arg"
4239
if test -f "$arg"; then
4242
for fil in `cat "$save_arg"`
4244
# moreargs="$moreargs $fil"
4246
# A libtool-controlled object.
4248
# Check to see that this really is a libtool object.
4249
if func_lalib_unsafe_p "$arg"; then
4256
if test -z "$pic_object" ||
4257
test -z "$non_pic_object" ||
4258
test "$pic_object" = none &&
4259
test "$non_pic_object" = none; then
4260
func_fatal_error "cannot find name of object for \`$arg'"
4263
# Extract subdirectory from the argument.
4264
func_dirname "$arg" "/" ""
4265
xdir="$func_dirname_result"
4267
if test "$pic_object" != none; then
4268
# Prepend the subdirectory the object is found in.
4269
pic_object="$xdir$pic_object"
4271
if test "$prev" = dlfiles; then
4272
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4273
dlfiles="$dlfiles $pic_object"
4277
# If libtool objects are unsupported, then we need to preload.
4282
# CHECK ME: I think I busted this. -Ossama
4283
if test "$prev" = dlprefiles; then
4284
# Preload the old-style object.
4285
dlprefiles="$dlprefiles $pic_object"
4290
func_append libobjs " $pic_object"
4295
if test "$non_pic_object" != none; then
4296
# Prepend the subdirectory the object is found in.
4297
non_pic_object="$xdir$non_pic_object"
4299
# A standard non-PIC object
4300
func_append non_pic_objects " $non_pic_object"
4301
if test -z "$pic_object" || test "$pic_object" = none ; then
4302
arg="$non_pic_object"
4305
# If the PIC object exists, use it instead.
4306
# $xdir was prepended to $pic_object above.
4307
non_pic_object="$pic_object"
4308
func_append non_pic_objects " $non_pic_object"
4311
# Only an error if not doing a dry-run.
4312
if $opt_dry_run; then
4313
# Extract subdirectory from the argument.
4314
func_dirname "$arg" "/" ""
4315
xdir="$func_dirname_result"
4318
pic_object=$xdir$objdir/$func_lo2o_result
4319
non_pic_object=$xdir$func_lo2o_result
4320
func_append libobjs " $pic_object"
4321
func_append non_pic_objects " $non_pic_object"
4323
func_fatal_error "\`$arg' is not a valid libtool object"
4328
func_fatal_error "link input file \`$arg' does not exist"
4335
precious_files_regex="$arg"
4345
# We need an absolute path.
4347
[\\/]* | [A-Za-z]:[\\/]*) ;;
4349
func_fatal_error "only absolute run-paths are allowed"
4352
if test "$prev" = rpath; then
4355
*) rpath="$rpath $arg" ;;
4360
*) xrpath="$xrpath $arg" ;;
4372
weak_libs="$weak_libs $arg"
4377
linker_flags="$linker_flags $qarg"
4378
compiler_flags="$compiler_flags $qarg"
4380
func_append compile_command " $qarg"
4381
func_append finalize_command " $qarg"
4385
compiler_flags="$compiler_flags $qarg"
4387
func_append compile_command " $qarg"
4388
func_append finalize_command " $qarg"
4392
linker_flags="$linker_flags $qarg"
4393
compiler_flags="$compiler_flags $wl$qarg"
4395
func_append compile_command " $wl$qarg"
4396
func_append finalize_command " $wl$qarg"
4400
eval "$prev=\"\$arg\""
4405
fi # test -n "$prev"
4411
if test -n "$link_static_flag"; then
4412
# See comment for -static flag below, for more details.
4413
func_append compile_command " $link_static_flag"
4414
func_append finalize_command " $link_static_flag"
4420
# FIXME: remove this flag sometime in the future.
4421
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4444
-export-symbols | -export-symbols-regex)
4445
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4446
func_fatal_error "more than one -exported-symbols argument is not allowed"
4448
if test "X$arg" = "X-export-symbols"; then
4466
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4467
# so, if we see these flags be careful not to treat them like -L
4469
case $with_gcc/$host in
4470
no/*-*-irix* | /*-*-irix*)
4471
func_append compile_command " $arg"
4472
func_append finalize_command " $arg"
4479
func_stripname '-L' '' "$arg"
4480
dir=$func_stripname_result
4481
if test -z "$dir"; then
4482
if test "$#" -gt 0; then
4483
func_fatal_error "require no space between \`-L' and \`$1'"
4485
func_fatal_error "need path for \`-L' option"
4488
# We need an absolute path.
4490
[\\/]* | [A-Za-z]:[\\/]*) ;;
4492
absdir=`cd "$dir" && pwd`
4493
test -z "$absdir" && \
4494
func_fatal_error "cannot determine absolute directory name of \`$dir'"
4501
deplibs="$deplibs -L$dir"
4502
lib_search_path="$lib_search_path $dir"
4506
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4507
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4508
case :$dllsearchpath: in
4510
::) dllsearchpath=$dir;;
4511
*) dllsearchpath="$dllsearchpath:$dir";;
4513
case :$dllsearchpath: in
4514
*":$testbindir:"*) ;;
4515
::) dllsearchpath=$testbindir;;
4516
*) dllsearchpath="$dllsearchpath:$testbindir";;
4524
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4526
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
4527
# These systems don't actually have a C or math library (as such)
4531
# These systems don't actually have a C library (as such)
4532
test "X$arg" = "X-lc" && continue
4534
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4535
# Do not include libc due to us having libc/libc_r.
4536
test "X$arg" = "X-lc" && continue
4538
*-*-rhapsody* | *-*-darwin1.[012])
4539
# Rhapsody C and math libraries are in the System framework
4540
deplibs="$deplibs System.ltframework"
4543
*-*-sco3.2v5* | *-*-sco5v6*)
4544
# Causes problems with __ctype
4545
test "X$arg" = "X-lc" && continue
4547
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4548
# Compiler inserts libc in the correct place for threads to work
4549
test "X$arg" = "X-lc" && continue
4552
elif test "X$arg" = "X-lc_r"; then
4554
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4555
# Do not include libc_r directly, use -pthread flag.
4560
deplibs="$deplibs $arg"
4569
# Tru64 UNIX uses -model [arg] to determine the layout of C++
4570
# classes, name mangling, and exception handling.
4571
# Darwin uses the -arch flag to determine output architecture.
4572
-model|-arch|-isysroot)
4573
compiler_flags="$compiler_flags $arg"
4574
func_append compile_command " $arg"
4575
func_append finalize_command " $arg"
4580
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4581
compiler_flags="$compiler_flags $arg"
4582
func_append compile_command " $arg"
4583
func_append finalize_command " $arg"
4584
case "$new_inherited_linker_flags " in
4586
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4592
single_module="${wl}-multi_module"
4603
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4604
# The PATH hackery in wrapper scripts is required on Windows
4605
# and Darwin in order for the loader to find any dlls it needs.
4606
func_warning "\`-no-install' is ignored for $host"
4607
func_warning "assuming \`-no-fast-install' instead"
4610
*) no_install=yes ;;
4627
-precious-files-regex)
4648
func_stripname '-R' '' "$arg"
4649
dir=$func_stripname_result
4650
# We need an absolute path.
4652
[\\/]* | [A-Za-z]:[\\/]*) ;;
4654
func_fatal_error "only absolute run-paths are allowed"
4659
*) xrpath="$xrpath $dir" ;;
4665
# The effects of -shared are defined in a previous loop.
4674
-static | -static-libtool-libs)
4675
# The effects of -static are defined in a previous loop.
4676
# We used to do the same as -all-static on platforms that
4677
# didn't have a PIC flag, but the assumption that the effects
4678
# would be equivalent was wrong. It would break on at least
4679
# Digital Unix and AIX.
4705
func_stripname '-Wc,' '' "$arg"
4706
args=$func_stripname_result
4708
save_ifs="$IFS"; IFS=','
4709
for flag in $args; do
4711
func_quote_for_eval "$flag"
4712
arg="$arg $wl$func_quote_for_eval_result"
4713
compiler_flags="$compiler_flags $func_quote_for_eval_result"
4716
func_stripname ' ' '' "$arg"
4717
arg=$func_stripname_result
4721
func_stripname '-Wl,' '' "$arg"
4722
args=$func_stripname_result
4724
save_ifs="$IFS"; IFS=','
4725
for flag in $args; do
4727
func_quote_for_eval "$flag"
4728
arg="$arg $wl$func_quote_for_eval_result"
4729
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4730
linker_flags="$linker_flags $func_quote_for_eval_result"
4733
func_stripname ' ' '' "$arg"
4734
arg=$func_stripname_result
4754
func_quote_for_eval "$arg"
4755
arg="$func_quote_for_eval_result"
4758
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4759
# -r[0-9][0-9]* specifies the processor on the SGI compiler
4760
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4761
# +DA*, +DD* enable 64-bit mode on the HP compiler
4762
# -q* pass through compiler args for the IBM compiler
4763
# -m*, -t[45]*, -txscale* pass through architecture-specific
4764
# compiler args for GCC
4765
# -F/path gives path to uninstalled frameworks, gcc on darwin
4766
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4767
# @file GCC response files
4768
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4769
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
4770
func_quote_for_eval "$arg"
4771
arg="$func_quote_for_eval_result"
4772
func_append compile_command " $arg"
4773
func_append finalize_command " $arg"
4774
compiler_flags="$compiler_flags $arg"
4778
# Some other compiler flag.
4780
func_quote_for_eval "$arg"
4781
arg="$func_quote_for_eval_result"
4785
# A standard object.
4790
# A libtool-controlled object.
4792
# Check to see that this really is a libtool object.
4793
if func_lalib_unsafe_p "$arg"; then
4800
if test -z "$pic_object" ||
4801
test -z "$non_pic_object" ||
4802
test "$pic_object" = none &&
4803
test "$non_pic_object" = none; then
4804
func_fatal_error "cannot find name of object for \`$arg'"
4807
# Extract subdirectory from the argument.
4808
func_dirname "$arg" "/" ""
4809
xdir="$func_dirname_result"
4811
if test "$pic_object" != none; then
4812
# Prepend the subdirectory the object is found in.
4813
pic_object="$xdir$pic_object"
4815
if test "$prev" = dlfiles; then
4816
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4817
dlfiles="$dlfiles $pic_object"
4821
# If libtool objects are unsupported, then we need to preload.
4826
# CHECK ME: I think I busted this. -Ossama
4827
if test "$prev" = dlprefiles; then
4828
# Preload the old-style object.
4829
dlprefiles="$dlprefiles $pic_object"
4834
func_append libobjs " $pic_object"
4839
if test "$non_pic_object" != none; then
4840
# Prepend the subdirectory the object is found in.
4841
non_pic_object="$xdir$non_pic_object"
4843
# A standard non-PIC object
4844
func_append non_pic_objects " $non_pic_object"
4845
if test -z "$pic_object" || test "$pic_object" = none ; then
4846
arg="$non_pic_object"
4849
# If the PIC object exists, use it instead.
4850
# $xdir was prepended to $pic_object above.
4851
non_pic_object="$pic_object"
4852
func_append non_pic_objects " $non_pic_object"
4855
# Only an error if not doing a dry-run.
4856
if $opt_dry_run; then
4857
# Extract subdirectory from the argument.
4858
func_dirname "$arg" "/" ""
4859
xdir="$func_dirname_result"
4862
pic_object=$xdir$objdir/$func_lo2o_result
4863
non_pic_object=$xdir$func_lo2o_result
4864
func_append libobjs " $pic_object"
4865
func_append non_pic_objects " $non_pic_object"
4867
func_fatal_error "\`$arg' is not a valid libtool object"
4874
deplibs="$deplibs $arg"
4875
old_deplibs="$old_deplibs $arg"
4880
# A libtool-controlled library.
4882
if test "$prev" = dlfiles; then
4883
# This library was specified with -dlopen.
4884
dlfiles="$dlfiles $arg"
4886
elif test "$prev" = dlprefiles; then
4887
# The library was specified with -dlpreopen.
4888
dlprefiles="$dlprefiles $arg"
4891
deplibs="$deplibs $arg"
4896
# Some other compiler argument.
4898
# Unknown arguments in both finalize_command and compile_command need
4899
# to be aesthetically quoted because they are evaled later.
4900
func_quote_for_eval "$arg"
4901
arg="$func_quote_for_eval_result"
4905
# Now actually substitute the argument into the commands.
4906
if test -n "$arg"; then
4907
func_append compile_command " $arg"
4908
func_append finalize_command " $arg"
4910
done # argument parsing loop
4912
test -n "$prev" && \
4913
func_fatal_help "the \`$prevarg' option requires an argument"
4915
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
4916
eval arg=\"$export_dynamic_flag_spec\"
4917
func_append compile_command " $arg"
4918
func_append finalize_command " $arg"
4922
# calculate the name of the file, without its directory
4923
func_basename "$output"
4924
outputname="$func_basename_result"
4925
libobjs_save="$libobjs"
4927
if test -n "$shlibpath_var"; then
4928
# get the directories listed in $shlibpath_var
4929
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
4933
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
4934
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
4936
func_dirname "$output" "/" ""
4937
output_objdir="$func_dirname_result$objdir"
4938
# Create the object directory.
4939
func_mkdir_p "$output_objdir"
4941
# Determine the type of output
4944
func_fatal_help "you must specify an output file"
4946
*.$libext) linkmode=oldlib ;;
4947
*.lo | *.$objext) linkmode=obj ;;
4948
*.la) linkmode=lib ;;
4949
*) linkmode=prog ;; # Anything else should be a program.
4955
# Find all interdependent deplibs by searching for libraries
4956
# that are linked more than once (e.g. -la -lb -la)
4957
for deplib in $deplibs; do
4958
if $opt_duplicate_deps ; then
4960
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
4963
libs="$libs $deplib"
4966
if test "$linkmode" = lib; then
4967
libs="$predeps $libs $compiler_lib_search_path $postdeps"
4969
# Compute libraries that are listed more than once in $predeps
4970
# $postdeps and mark them as special (i.e., whose duplicates are
4971
# not to be eliminated).
4973
if $opt_duplicate_compiler_generated_deps; then
4974
for pre_post_dep in $predeps $postdeps; do
4975
case "$pre_post_deps " in
4976
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
4978
pre_post_deps="$pre_post_deps $pre_post_dep"
4987
need_relink=no # whether we're linking any uninstalled libtool libraries
4988
notinst_deplibs= # not-installed libtool libraries
4989
notinst_path= # paths that contain not-installed libtool libraries
4993
passes="conv dlpreopen link"
4994
for file in $dlfiles $dlprefiles; do
4998
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5009
passes="conv scan dlopen dlpreopen link"
5015
for pass in $passes; do
5016
# The preopen pass in lib mode reverses $deplibs; put it back here
5017
# so that -L comes before libs that need it for instance...
5018
if test "$linkmode,$pass" = "lib,link"; then
5019
## FIXME: Find the place where the list is rebuilt in the wrong
5020
## order, and fix it there properly
5022
for deplib in $deplibs; do
5023
tmp_deplibs="$deplib $tmp_deplibs"
5025
deplibs="$tmp_deplibs"
5028
if test "$linkmode,$pass" = "lib,link" ||
5029
test "$linkmode,$pass" = "prog,scan"; then
5033
if test "$linkmode" = prog; then
5035
dlopen) libs="$dlfiles" ;;
5036
dlpreopen) libs="$dlprefiles" ;;
5037
link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5040
if test "$linkmode,$pass" = "lib,dlpreopen"; then
5041
# Collect and forward deplibs of preopened libtool libs
5042
for lib in $dlprefiles; do
5043
# Ignore non-libtool-libs
5046
*.la) func_source "$lib" ;;
5049
# Collect preopened libtool deplibs, except any this library
5050
# has declared as weak libs
5051
for deplib in $dependency_libs; do
5052
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5053
case " $weak_libs " in
5054
*" $deplib_base "*) ;;
5055
*) deplibs="$deplibs $deplib" ;;
5061
if test "$pass" = dlopen; then
5062
# Collect dlpreopened libraries
5063
save_deplibs="$deplibs"
5067
for deplib in $libs; do
5071
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5072
if test "$linkmode,$pass" = "prog,link"; then
5073
compile_deplibs="$deplib $compile_deplibs"
5074
finalize_deplibs="$deplib $finalize_deplibs"
5076
compiler_flags="$compiler_flags $deplib"
5077
if test "$linkmode" = lib ; then
5078
case "$new_inherited_linker_flags " in
5080
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5087
if test "$linkmode" != lib && test "$linkmode" != prog; then
5088
func_warning "\`-l' is ignored for archives/objects"
5091
func_stripname '-l' '' "$deplib"
5092
name=$func_stripname_result
5093
if test "$linkmode" = lib; then
5094
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5096
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5098
for searchdir in $searchdirs; do
5099
for search_ext in .la $std_shrext .so .a; do
5100
# Search the libtool library
5101
lib="$searchdir/lib${name}${search_ext}"
5102
if test -f "$lib"; then
5103
if test "$search_ext" = ".la"; then
5112
if test "$found" != yes; then
5113
# deplib doesn't seem to be a libtool library
5114
if test "$linkmode,$pass" = "prog,link"; then
5115
compile_deplibs="$deplib $compile_deplibs"
5116
finalize_deplibs="$deplib $finalize_deplibs"
5118
deplibs="$deplib $deplibs"
5119
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5122
else # deplib is a libtool library
5123
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5124
# We need to do some special things here, and not later.
5125
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5126
case " $predeps $postdeps " in
5128
if func_lalib_p "$lib"; then
5132
for l in $old_library $library_names; do
5135
if test "X$ll" = "X$old_library" ; then # only static version available
5137
func_dirname "$lib" "" "."
5138
ladir="$func_dirname_result"
5139
lib=$ladir/$old_library
5140
if test "$linkmode,$pass" = "prog,link"; then
5141
compile_deplibs="$deplib $compile_deplibs"
5142
finalize_deplibs="$deplib $finalize_deplibs"
5144
deplibs="$deplib $deplibs"
5145
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5157
if test "$linkmode,$pass" = "prog,link"; then
5158
compile_deplibs="$deplib $compile_deplibs"
5159
finalize_deplibs="$deplib $finalize_deplibs"
5161
deplibs="$deplib $deplibs"
5162
if test "$linkmode" = lib ; then
5163
case "$new_inherited_linker_flags " in
5165
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5174
deplibs="$deplib $deplibs"
5175
test "$pass" = conv && continue
5176
newdependency_libs="$deplib $newdependency_libs"
5177
func_stripname '-L' '' "$deplib"
5178
newlib_search_path="$newlib_search_path $func_stripname_result"
5181
if test "$pass" = conv; then
5182
deplibs="$deplib $deplibs"
5185
if test "$pass" = scan; then
5186
deplibs="$deplib $deplibs"
5188
compile_deplibs="$deplib $compile_deplibs"
5189
finalize_deplibs="$deplib $finalize_deplibs"
5191
func_stripname '-L' '' "$deplib"
5192
newlib_search_path="$newlib_search_path $func_stripname_result"
5195
func_warning "\`-L' is ignored for archives/objects"
5201
if test "$pass" = link; then
5202
func_stripname '-R' '' "$deplib"
5203
dir=$func_stripname_result
5204
# Make sure the xrpath contains only unique directories.
5207
*) xrpath="$xrpath $dir" ;;
5210
deplibs="$deplib $deplibs"
5213
*.la) lib="$deplib" ;;
5215
if test "$pass" = conv; then
5216
deplibs="$deplib $deplibs"
5221
# Linking convenience modules into shared libraries is allowed,
5222
# but linking other static libraries is non-portable.
5223
case " $dlpreconveniencelibs " in
5227
case $deplibs_check_method in
5229
set dummy $deplibs_check_method; shift
5230
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5231
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5232
| $EGREP "$match_pattern_regex" > /dev/null; then
5240
if test "$valid_a_lib" != yes; then
5242
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5243
$ECHO "*** I have the capability to make that library automatically link in when"
5244
$ECHO "*** you link to this library. But I can only do this if you have a"
5245
$ECHO "*** shared version of the library, which you do not appear to have"
5246
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5247
$ECHO "*** that it is just a static archive that I should not use here."
5250
$ECHO "*** Warning: Linking the shared library $output against the"
5251
$ECHO "*** static library $deplib is not portable!"
5252
deplibs="$deplib $deplibs"
5259
if test "$pass" != link; then
5260
deplibs="$deplib $deplibs"
5262
compile_deplibs="$deplib $compile_deplibs"
5263
finalize_deplibs="$deplib $finalize_deplibs"
5270
if test "$pass" = conv; then
5271
deplibs="$deplib $deplibs"
5272
elif test "$linkmode" = prog; then
5273
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5274
# If there is no dlopen support or we're linking statically,
5275
# we need to preload.
5276
newdlprefiles="$newdlprefiles $deplib"
5277
compile_deplibs="$deplib $compile_deplibs"
5278
finalize_deplibs="$deplib $finalize_deplibs"
5280
newdlfiles="$newdlfiles $deplib"
5291
if test "$found" = yes || test -f "$lib"; then :
5293
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5296
# Check to see that this really is a libtool archive.
5297
func_lalib_unsafe_p "$lib" \
5298
|| func_fatal_error "\`$lib' is not a valid libtool archive"
5300
func_dirname "$lib" "" "."
5301
ladir="$func_dirname_result"
5309
inherited_linker_flags=
5310
# If the library was installed with an old release of libtool,
5311
# it will not redefine variables installed, or shouldnotlink
5320
# Convert "-framework foo" to "foo.ltframework"
5321
if test -n "$inherited_linker_flags"; then
5322
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5323
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5324
case " $new_inherited_linker_flags " in
5325
*" $tmp_inherited_linker_flag "*) ;;
5326
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5330
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5331
if test "$linkmode,$pass" = "lib,link" ||
5332
test "$linkmode,$pass" = "prog,scan" ||
5333
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5334
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5335
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5338
if test "$pass" = conv; then
5339
# Only check for convenience libraries
5340
deplibs="$lib $deplibs"
5341
if test -z "$libdir"; then
5342
if test -z "$old_library"; then
5343
func_fatal_error "cannot find name of link library for \`$lib'"
5345
# It is a libtool convenience library, so add in its objects.
5346
convenience="$convenience $ladir/$objdir/$old_library"
5347
old_convenience="$old_convenience $ladir/$objdir/$old_library"
5348
elif test "$linkmode" != prog && test "$linkmode" != lib; then
5349
func_fatal_error "\`$lib' is not a convenience library"
5352
for deplib in $dependency_libs; do
5353
deplibs="$deplib $deplibs"
5354
if $opt_duplicate_deps ; then
5355
case "$tmp_libs " in
5356
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5359
tmp_libs="$tmp_libs $deplib"
5365
# Get the name of the library we link against.
5367
for l in $old_library $library_names; do
5370
if test -z "$linklib"; then
5371
func_fatal_error "cannot find name of link library for \`$lib'"
5374
# This library was specified with -dlopen.
5375
if test "$pass" = dlopen; then
5376
if test -z "$libdir"; then
5377
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5379
if test -z "$dlname" ||
5380
test "$dlopen_support" != yes ||
5381
test "$build_libtool_libs" = no; then
5382
# If there is no dlname, no dlopen support or we're linking
5383
# statically, we need to preload. We also need to preload any
5384
# dependent libraries so libltdl's deplib preloader doesn't
5385
# bomb out in the load deplibs phase.
5386
dlprefiles="$dlprefiles $lib $dependency_libs"
5388
newdlfiles="$newdlfiles $lib"
5393
# We need an absolute path.
5395
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5397
abs_ladir=`cd "$ladir" && pwd`
5398
if test -z "$abs_ladir"; then
5399
func_warning "cannot determine absolute directory name of \`$ladir'"
5400
func_warning "passing it literally to the linker, although it might fail"
5405
func_basename "$lib"
5406
laname="$func_basename_result"
5408
# Find the relevant object directory and library name.
5409
if test "X$installed" = Xyes; then
5410
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5411
func_warning "library \`$lib' was moved."
5419
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5421
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5424
# Remove this search path later
5425
notinst_path="$notinst_path $abs_ladir"
5427
dir="$ladir/$objdir"
5428
absdir="$abs_ladir/$objdir"
5429
# Remove this search path later
5430
notinst_path="$notinst_path $abs_ladir"
5432
fi # $installed = yes
5433
func_stripname 'lib' '.la' "$laname"
5434
name=$func_stripname_result
5436
# This library was specified with -dlpreopen.
5437
if test "$pass" = dlpreopen; then
5438
if test -z "$libdir" && test "$linkmode" = prog; then
5439
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5441
# Prefer using a static library (so that no silly _DYNAMIC symbols
5442
# are required to link).
5443
if test -n "$old_library"; then
5444
newdlprefiles="$newdlprefiles $dir/$old_library"
5445
# Keep a list of preopened convenience libraries to check
5446
# that they are being used correctly in the link pass.
5447
test -z "$libdir" && \
5448
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5449
# Otherwise, use the dlname, so that lt_dlopen finds it.
5450
elif test -n "$dlname"; then
5451
newdlprefiles="$newdlprefiles $dir/$dlname"
5453
newdlprefiles="$newdlprefiles $dir/$linklib"
5455
fi # $pass = dlpreopen
5457
if test -z "$libdir"; then
5458
# Link the convenience library
5459
if test "$linkmode" = lib; then
5460
deplibs="$dir/$old_library $deplibs"
5461
elif test "$linkmode,$pass" = "prog,link"; then
5462
compile_deplibs="$dir/$old_library $compile_deplibs"
5463
finalize_deplibs="$dir/$old_library $finalize_deplibs"
5465
deplibs="$lib $deplibs" # used for prog,scan pass
5471
if test "$linkmode" = prog && test "$pass" != link; then
5472
newlib_search_path="$newlib_search_path $ladir"
5473
deplibs="$lib $deplibs"
5476
if test "$link_all_deplibs" != no || test -z "$library_names" ||
5477
test "$build_libtool_libs" = no; then
5482
for deplib in $dependency_libs; do
5484
-L*) func_stripname '-L' '' "$deplib"
5485
newlib_search_path="$newlib_search_path $func_stripname_result"
5488
# Need to link against all dependency_libs?
5489
if test "$linkalldeplibs" = yes; then
5490
deplibs="$deplib $deplibs"
5492
# Need to hardcode shared library paths
5493
# or/and link against static libraries
5494
newdependency_libs="$deplib $newdependency_libs"
5496
if $opt_duplicate_deps ; then
5497
case "$tmp_libs " in
5498
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5501
tmp_libs="$tmp_libs $deplib"
5504
fi # $linkmode = prog...
5506
if test "$linkmode,$pass" = "prog,link"; then
5507
if test -n "$library_names" &&
5508
{ { test "$prefer_static_libs" = no ||
5509
test "$prefer_static_libs,$installed" = "built,yes"; } ||
5510
test -z "$old_library"; }; then
5511
# We need to hardcode the library path
5512
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5513
# Make sure the rpath contains only unique directories.
5514
case "$temp_rpath:" in
5516
*) temp_rpath="$temp_rpath$absdir:" ;;
5520
# Hardcode the library path.
5521
# Skip directories that are in the system default run-time
5523
case " $sys_lib_dlsearch_path " in
5526
case "$compile_rpath " in
5528
*) compile_rpath="$compile_rpath $absdir"
5532
case " $sys_lib_dlsearch_path " in
5535
case "$finalize_rpath " in
5537
*) finalize_rpath="$finalize_rpath $libdir"
5541
fi # $linkmode,$pass = prog,link...
5543
if test "$alldeplibs" = yes &&
5544
{ test "$deplibs_check_method" = pass_all ||
5545
{ test "$build_libtool_libs" = yes &&
5546
test -n "$library_names"; }; }; then
5547
# We only need to search for static libraries
5552
link_static=no # Whether the deplib will be linked statically
5553
use_static_libs=$prefer_static_libs
5554
if test "$use_static_libs" = built && test "$installed" = yes; then
5557
if test -n "$library_names" &&
5558
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
5560
*cygwin* | *mingw* | *cegcc*)
5561
# No point in relinking DLLs because paths are not encoded
5562
notinst_deplibs="$notinst_deplibs $lib"
5566
if test "$installed" = no; then
5567
notinst_deplibs="$notinst_deplibs $lib"
5572
# This is a shared library
5574
# Warn about portability, can't link against -module's on some
5575
# systems (darwin). Don't bleat about dlopened modules though!
5577
for dlpremoduletest in $dlprefiles; do
5578
if test "X$dlpremoduletest" = "X$lib"; then
5579
dlopenmodule="$dlpremoduletest"
5583
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5585
if test "$linkmode" = prog; then
5586
$ECHO "*** Warning: Linking the executable $output against the loadable module"
5588
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
5590
$ECHO "*** $linklib is not portable!"
5592
if test "$linkmode" = lib &&
5593
test "$hardcode_into_libs" = yes; then
5594
# Hardcode the library path.
5595
# Skip directories that are in the system default run-time
5597
case " $sys_lib_dlsearch_path " in
5600
case "$compile_rpath " in
5602
*) compile_rpath="$compile_rpath $absdir"
5606
case " $sys_lib_dlsearch_path " in
5609
case "$finalize_rpath " in
5611
*) finalize_rpath="$finalize_rpath $libdir"
5617
if test -n "$old_archive_from_expsyms_cmds"; then
5618
# figure out the soname
5619
set dummy $library_names
5623
libname=`eval "\\$ECHO \"$libname_spec\""`
5624
# use dlname if we got it. it's perfectly good, no?
5625
if test -n "$dlname"; then
5627
elif test -n "$soname_spec"; then
5630
*cygwin* | mingw* | *cegcc*)
5631
func_arith $current - $age
5632
major=$func_arith_result
5636
eval soname=\"$soname_spec\"
5641
# Make a new name for the extract_expsyms_cmds to use
5643
func_basename "$soroot"
5644
soname="$func_basename_result"
5645
func_stripname 'lib' '.dll' "$soname"
5646
newlib=libimp-$func_stripname_result.a
5648
# If the library has no export list, then create one now
5649
if test -f "$output_objdir/$soname-def"; then :
5651
func_verbose "extracting exported symbol list from \`$soname'"
5652
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5656
if test -f "$output_objdir/$newlib"; then :; else
5657
func_verbose "generating import library for \`$soname'"
5658
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5660
# make sure the library variables are pointing to the new library
5663
fi # test -n "$old_archive_from_expsyms_cmds"
5665
if test "$linkmode" = prog || test "$mode" != relink; then
5670
case $hardcode_action in
5671
immediate | unsupported)
5672
if test "$hardcode_direct" = no; then
5675
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5676
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
5677
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5678
*-*-unixware7*) add_dir="-L$dir" ;;
5680
# if the lib is a (non-dlopened) module then we can not
5681
# link against it, someone is ignoring the earlier warnings
5682
if /usr/bin/file -L $add 2> /dev/null |
5683
$GREP ": [^:]* bundle" >/dev/null ; then
5684
if test "X$dlopenmodule" != "X$lib"; then
5685
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
5686
if test -z "$old_library" ; then
5688
$ECHO "*** And there doesn't seem to be a static archive available"
5689
$ECHO "*** The link will probably fail, sorry"
5691
add="$dir/$old_library"
5693
elif test -n "$old_library"; then
5694
add="$dir/$old_library"
5698
elif test "$hardcode_minus_L" = no; then
5700
*-*-sunos*) add_shlibpath="$dir" ;;
5704
elif test "$hardcode_shlibpath_var" = no; then
5705
add_shlibpath="$dir"
5712
if test "$hardcode_direct" = yes &&
5713
test "$hardcode_direct_absolute" = no; then
5715
elif test "$hardcode_minus_L" = yes; then
5717
# Try looking first in the location we're being installed to.
5718
if test -n "$inst_prefix_dir"; then
5721
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5726
elif test "$hardcode_shlibpath_var" = yes; then
5727
add_shlibpath="$dir"
5736
if test "$lib_linked" != yes; then
5737
func_fatal_configuration "unsupported hardcode properties"
5740
if test -n "$add_shlibpath"; then
5741
case :$compile_shlibpath: in
5742
*":$add_shlibpath:"*) ;;
5743
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5746
if test "$linkmode" = prog; then
5747
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5748
test -n "$add" && compile_deplibs="$add $compile_deplibs"
5750
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5751
test -n "$add" && deplibs="$add $deplibs"
5752
if test "$hardcode_direct" != yes &&
5753
test "$hardcode_minus_L" != yes &&
5754
test "$hardcode_shlibpath_var" = yes; then
5755
case :$finalize_shlibpath: in
5757
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5763
if test "$linkmode" = prog || test "$mode" = relink; then
5767
# Finalize command for both is simple: just hardcode it.
5768
if test "$hardcode_direct" = yes &&
5769
test "$hardcode_direct_absolute" = no; then
5770
add="$libdir/$linklib"
5771
elif test "$hardcode_minus_L" = yes; then
5774
elif test "$hardcode_shlibpath_var" = yes; then
5775
case :$finalize_shlibpath: in
5777
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5780
elif test "$hardcode_automatic" = yes; then
5781
if test -n "$inst_prefix_dir" &&
5782
test -f "$inst_prefix_dir$libdir/$linklib" ; then
5783
add="$inst_prefix_dir$libdir/$linklib"
5785
add="$libdir/$linklib"
5788
# We cannot seem to hardcode it, guess we'll fake it.
5790
# Try looking first in the location we're being installed to.
5791
if test -n "$inst_prefix_dir"; then
5794
add_dir="$add_dir -L$inst_prefix_dir$libdir"
5801
if test "$linkmode" = prog; then
5802
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
5803
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
5805
test -n "$add_dir" && deplibs="$add_dir $deplibs"
5806
test -n "$add" && deplibs="$add $deplibs"
5809
elif test "$linkmode" = prog; then
5810
# Here we assume that one of hardcode_direct or hardcode_minus_L
5811
# is not unsupported. This is valid on all known static and
5813
if test "$hardcode_direct" != unsupported; then
5814
test -n "$old_library" && linklib="$old_library"
5815
compile_deplibs="$dir/$linklib $compile_deplibs"
5816
finalize_deplibs="$dir/$linklib $finalize_deplibs"
5818
compile_deplibs="-l$name -L$dir $compile_deplibs"
5819
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
5821
elif test "$build_libtool_libs" = yes; then
5822
# Not a shared library
5823
if test "$deplibs_check_method" != pass_all; then
5824
# We're trying link a shared library against a static one
5825
# but the system doesn't support it.
5827
# Just print a warning and add the library to dependency_libs so
5828
# that the program can be linked against the static library.
5830
$ECHO "*** Warning: This system can not link to static lib archive $lib."
5831
$ECHO "*** I have the capability to make that library automatically link in when"
5832
$ECHO "*** you link to this library. But I can only do this if you have a"
5833
$ECHO "*** shared version of the library, which you do not appear to have."
5834
if test "$module" = yes; then
5835
$ECHO "*** But as you try to build a module library, libtool will still create "
5836
$ECHO "*** a static module, that should work as long as the dlopening application"
5837
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
5838
if test -z "$global_symbol_pipe"; then
5840
$ECHO "*** However, this would only work if libtool was able to extract symbol"
5841
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
5842
$ECHO "*** not find such a program. So, this module is probably useless."
5843
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
5845
if test "$build_old_libs" = no; then
5846
build_libtool_libs=module
5849
build_libtool_libs=no
5853
deplibs="$dir/$old_library $deplibs"
5856
fi # link shared/static library?
5858
if test "$linkmode" = lib; then
5859
if test -n "$dependency_libs" &&
5860
{ test "$hardcode_into_libs" != yes ||
5861
test "$build_old_libs" = yes ||
5862
test "$link_static" = yes; }; then
5863
# Extract -R from dependency_libs
5865
for libdir in $dependency_libs; do
5867
-R*) func_stripname '-R' '' "$libdir"
5868
temp_xrpath=$func_stripname_result
5870
*" $temp_xrpath "*) ;;
5871
*) xrpath="$xrpath $temp_xrpath";;
5873
*) temp_deplibs="$temp_deplibs $libdir";;
5876
dependency_libs="$temp_deplibs"
5879
newlib_search_path="$newlib_search_path $absdir"
5880
# Link against this library
5881
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
5882
# ... and its dependency_libs
5884
for deplib in $dependency_libs; do
5885
newdependency_libs="$deplib $newdependency_libs"
5886
if $opt_duplicate_deps ; then
5887
case "$tmp_libs " in
5888
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5891
tmp_libs="$tmp_libs $deplib"
5894
if test "$link_all_deplibs" != no; then
5895
# Add the search paths of all dependency libraries
5896
for deplib in $dependency_libs; do
5898
-L*) path="$deplib" ;;
5900
func_dirname "$deplib" "" "."
5901
dir="$func_dirname_result"
5902
# We need an absolute path.
5904
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
5906
absdir=`cd "$dir" && pwd`
5907
if test -z "$absdir"; then
5908
func_warning "cannot determine absolute directory name of \`$dir'"
5913
if $GREP "^installed=no" $deplib > /dev/null; then
5917
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
5918
if test -n "$deplibrary_names" ; then
5919
for tmp in $deplibrary_names ; do
5922
if test -f "$absdir/$objdir/$depdepl" ; then
5923
depdepl="$absdir/$objdir/$depdepl"
5924
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5925
if test -z "$darwin_install_name"; then
5926
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
5928
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
5929
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
5935
path="-L$absdir/$objdir"
5939
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5940
test -z "$libdir" && \
5941
func_fatal_error "\`$deplib' is not a valid libtool archive"
5942
test "$absdir" != "$libdir" && \
5943
func_warning "\`$deplib' seems to be moved"
5949
case " $deplibs " in
5951
*) deplibs="$path $deplibs" ;;
5954
fi # link_all_deplibs != no
5956
done # for deplib in $libs
5957
if test "$pass" = link; then
5958
if test "$linkmode" = "prog"; then
5959
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
5960
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
5962
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5965
dependency_libs="$newdependency_libs"
5966
if test "$pass" = dlpreopen; then
5967
# Link the dlpreopened libraries before other libraries
5968
for deplib in $save_deplibs; do
5969
deplibs="$deplib $deplibs"
5972
if test "$pass" != dlopen; then
5973
if test "$pass" != conv; then
5974
# Make sure lib_search_path contains only unique directories.
5976
for dir in $newlib_search_path; do
5977
case "$lib_search_path " in
5979
*) lib_search_path="$lib_search_path $dir" ;;
5985
if test "$linkmode,$pass" != "prog,link"; then
5988
vars="compile_deplibs finalize_deplibs"
5990
for var in $vars dependency_libs; do
5991
# Add libraries to $var in reverse order
5992
eval tmp_libs=\"\$$var\"
5994
for deplib in $tmp_libs; do
5995
# FIXME: Pedantically, this is the right thing to do, so
5996
# that some nasty dependency loop isn't accidentally
5998
#new_libs="$deplib $new_libs"
5999
# Pragmatically, this seems to cause very few problems in
6002
-L*) new_libs="$deplib $new_libs" ;;
6005
# And here is the reason: when a library appears more
6006
# than once as an explicit dependence of a library, or
6007
# is implicitly linked in more than once by the
6008
# compiler, it is considered special, and multiple
6009
# occurrences thereof are not removed. Compare this
6010
# with having the same library being listed as a
6011
# dependency of multiple other libraries: in this case,
6012
# we know (pedantically, we assume) the library does not
6013
# need to be listed more than once, so we keep only the
6014
# last copy. This is not always right, but it is rare
6015
# enough that we require users that really mean to play
6016
# such unportable linking tricks to link the library
6017
# using -Wl,-lname, so that libtool does not consider it
6018
# for duplicate removal.
6019
case " $specialdeplibs " in
6020
*" $deplib "*) new_libs="$deplib $new_libs" ;;
6022
case " $new_libs " in
6024
*) new_libs="$deplib $new_libs" ;;
6032
for deplib in $new_libs; do
6035
case " $tmp_libs " in
6037
*) tmp_libs="$tmp_libs $deplib" ;;
6040
*) tmp_libs="$tmp_libs $deplib" ;;
6043
eval $var=\"$tmp_libs\"
6046
# Last step: remove runtime libs from dependency_libs
6047
# (they stay in deplibs)
6049
for i in $dependency_libs ; do
6050
case " $predeps $postdeps $compiler_lib_search_path " in
6055
if test -n "$i" ; then
6056
tmp_libs="$tmp_libs $i"
6059
dependency_libs=$tmp_libs
6061
if test "$linkmode" = prog; then
6062
dlfiles="$newdlfiles"
6064
if test "$linkmode" = prog || test "$linkmode" = lib; then
6065
dlprefiles="$newdlprefiles"
6070
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6071
func_warning "\`-dlopen' is ignored for archives"
6076
func_warning "\`-l' and \`-L' are ignored for archives" ;;
6079
test -n "$rpath" && \
6080
func_warning "\`-rpath' is ignored for archives"
6082
test -n "$xrpath" && \
6083
func_warning "\`-R' is ignored for archives"
6085
test -n "$vinfo" && \
6086
func_warning "\`-version-info/-version-number' is ignored for archives"
6088
test -n "$release" && \
6089
func_warning "\`-release' is ignored for archives"
6091
test -n "$export_symbols$export_symbols_regex" && \
6092
func_warning "\`-export-symbols' is ignored for archives"
6094
# Now set the variables for building old libraries.
6095
build_libtool_libs=no
6097
objs="$objs$old_deplibs"
6101
# Make sure we only generate libraries of the form `libNAME.la'.
6104
func_stripname 'lib' '.la' "$outputname"
6105
name=$func_stripname_result
6106
eval shared_ext=\"$shrext_cmds\"
6107
eval libname=\"$libname_spec\"
6110
test "$module" = no && \
6111
func_fatal_help "libtool library \`$output' must begin with \`lib'"
6113
if test "$need_lib_prefix" != no; then
6114
# Add the "lib" prefix for modules if required
6115
func_stripname '' '.la' "$outputname"
6116
name=$func_stripname_result
6117
eval shared_ext=\"$shrext_cmds\"
6118
eval libname=\"$libname_spec\"
6120
func_stripname '' '.la' "$outputname"
6121
libname=$func_stripname_result
6126
if test -n "$objs"; then
6127
if test "$deplibs_check_method" != pass_all; then
6128
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6131
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6132
$ECHO "*** objects $objs is not portable!"
6133
libobjs="$libobjs $objs"
6137
test "$dlself" != no && \
6138
func_warning "\`-dlopen self' is ignored for libtool libraries"
6142
test "$#" -gt 1 && \
6143
func_warning "ignoring multiple \`-rpath's for a libtool library"
6148
if test -z "$rpath"; then
6149
if test "$build_libtool_libs" = yes; then
6150
# Building a libtool convenience library.
6151
# Some compilers have problems with a `.al' extension so
6152
# convenience libraries should have the same extension an
6153
# archive normally would.
6154
oldlibs="$output_objdir/$libname.$libext $oldlibs"
6155
build_libtool_libs=convenience
6159
test -n "$vinfo" && \
6160
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6162
test -n "$release" && \
6163
func_warning "\`-release' is ignored for convenience libraries"
6166
# Parse the version information argument.
6167
save_ifs="$IFS"; IFS=':'
6168
set dummy $vinfo 0 0 0
6173
func_fatal_help "too many parameters to \`-version-info'"
6175
# convert absolute version numbers to libtool ages
6176
# this retains compatibility with .la files and attempts
6177
# to make the code below a bit more comprehensible
6179
case $vinfo_number in
6183
number_revision="$3"
6185
# There are really only two kinds -- those that
6186
# use the current revision as the major version
6187
# and those that subtract age and use age as
6188
# a minor version. But, then there is irix
6189
# which has an extra 1 added just for fun
6191
case $version_type in
6192
darwin|linux|osf|windows|none)
6193
func_arith $number_major + $number_minor
6194
current=$func_arith_result
6196
revision="$number_revision"
6198
freebsd-aout|freebsd-elf|sunos)
6199
current="$number_major"
6200
revision="$number_minor"
6204
func_arith $number_major + $number_minor
6205
current=$func_arith_result
6207
revision="$number_minor"
6208
lt_irix_increment=no
6219
# Check that each of the things are valid numbers.
6221
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]) ;;
6223
func_error "CURRENT \`$current' must be a nonnegative integer"
6224
func_fatal_error "\`$vinfo' is not valid version information"
6229
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]) ;;
6231
func_error "REVISION \`$revision' must be a nonnegative integer"
6232
func_fatal_error "\`$vinfo' is not valid version information"
6237
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]) ;;
6239
func_error "AGE \`$age' must be a nonnegative integer"
6240
func_fatal_error "\`$vinfo' is not valid version information"
6244
if test "$age" -gt "$current"; then
6245
func_error "AGE \`$age' is greater than the current interface number \`$current'"
6246
func_fatal_error "\`$vinfo' is not valid version information"
6249
# Calculate the version variables.
6253
case $version_type in
6257
# Like Linux, but with the current version available in
6258
# verstring for coding it into the library header
6259
func_arith $current - $age
6260
major=.$func_arith_result
6261
versuffix="$major.$age.$revision"
6262
# Darwin ld doesn't like 0 for these options...
6263
func_arith $current + 1
6264
minor_current=$func_arith_result
6265
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6266
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6271
versuffix=".$current.$revision";
6276
versuffix=".$current"
6280
if test "X$lt_irix_increment" = "Xno"; then
6281
func_arith $current - $age
6283
func_arith $current - $age + 1
6285
major=$func_arith_result
6287
case $version_type in
6288
nonstopux) verstring_prefix=nonstopux ;;
6289
*) verstring_prefix=sgi ;;
6291
verstring="$verstring_prefix$major.$revision"
6293
# Add in all the interfaces that we are compatible with.
6295
while test "$loop" -ne 0; do
6296
func_arith $revision - $loop
6297
iface=$func_arith_result
6298
func_arith $loop - 1
6299
loop=$func_arith_result
6300
verstring="$verstring_prefix$major.$iface:$verstring"
6303
# Before this point, $major must not contain `.'.
6305
versuffix="$major.$revision"
6309
func_arith $current - $age
6310
major=.$func_arith_result
6311
versuffix="$major.$age.$revision"
6315
func_arith $current - $age
6316
major=.$func_arith_result
6317
versuffix=".$current.$age.$revision"
6318
verstring="$current.$age.$revision"
6320
# Add in all the interfaces that we are compatible with.
6322
while test "$loop" -ne 0; do
6323
func_arith $current - $loop
6324
iface=$func_arith_result
6325
func_arith $loop - 1
6326
loop=$func_arith_result
6327
verstring="$verstring:${iface}.0"
6330
# Make executables depend on our current version.
6331
verstring="$verstring:${current}.0"
6336
versuffix=".$current"
6341
versuffix=".$current.$revision"
6345
# Use '-' rather than '.', since we only want one
6346
# extension on DOS 8.3 filesystems.
6347
func_arith $current - $age
6348
major=$func_arith_result
6353
func_fatal_configuration "unknown library version type \`$version_type'"
6357
# Clear the version info if we defaulted, and they specified a release.
6358
if test -z "$vinfo" && test -n "$release"; then
6360
case $version_type in
6362
# we can't check for "0.0" in archive_cmds due to quoting
6363
# problems, so we reset it completely
6370
if test "$need_version" = no; then
6377
# Remove version info from name if versioning should be avoided
6378
if test "$avoid_version" = yes && test "$need_version" = no; then
6384
# Check to see if the archive will have undefined symbols.
6385
if test "$allow_undefined" = yes; then
6386
if test "$allow_undefined_flag" = unsupported; then
6387
func_warning "undefined symbols not allowed in $host shared libraries"
6388
build_libtool_libs=no
6392
# Don't allow undefined symbols.
6393
allow_undefined_flag="$no_undefined_flag"
6398
func_generate_dlsyms "$libname" "$libname" "yes"
6399
libobjs="$libobjs $symfileobj"
6400
test "X$libobjs" = "X " && libobjs=
6402
if test "$mode" != relink; then
6403
# Remove our outputs, but don't remove object files since they
6404
# may have been created when compiling PIC objects.
6406
tempremovelist=`$ECHO "$output_objdir/*"`
6407
for p in $tempremovelist; do
6411
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6412
if test "X$precious_files_regex" != "X"; then
6413
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6418
removelist="$removelist $p"
6423
test -n "$removelist" && \
6424
func_show_eval "${RM}r \$removelist"
6427
# Now set the variables for building old libraries.
6428
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6429
oldlibs="$oldlibs $output_objdir/$libname.$libext"
6431
# Transform .lo files to .o files.
6432
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6435
# Eliminate all temporary directories.
6436
#for path in $notinst_path; do
6437
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6438
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6439
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6442
if test -n "$xrpath"; then
6443
# If the user specified any rpath flags, then add them.
6445
for libdir in $xrpath; do
6446
temp_xrpath="$temp_xrpath -R$libdir"
6447
case "$finalize_rpath " in
6449
*) finalize_rpath="$finalize_rpath $libdir" ;;
6452
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6453
dependency_libs="$temp_xrpath $dependency_libs"
6457
# Make sure dlfiles contains only unique files that won't be dlpreopened
6458
old_dlfiles="$dlfiles"
6460
for lib in $old_dlfiles; do
6461
case " $dlprefiles $dlfiles " in
6463
*) dlfiles="$dlfiles $lib" ;;
6467
# Make sure dlprefiles contains only unique files
6468
old_dlprefiles="$dlprefiles"
6470
for lib in $old_dlprefiles; do
6471
case "$dlprefiles " in
6473
*) dlprefiles="$dlprefiles $lib" ;;
6477
if test "$build_libtool_libs" = yes; then
6478
if test -n "$rpath"; then
6480
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6481
# these systems don't actually have a c library (as such)!
6483
*-*-rhapsody* | *-*-darwin1.[012])
6484
# Rhapsody C library is in the System framework
6485
deplibs="$deplibs System.ltframework"
6488
# Don't link with libc until the a.out ld.so is fixed.
6490
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6491
# Do not include libc due to us having libc/libc_r.
6493
*-*-sco3.2v5* | *-*-sco5v6*)
6494
# Causes problems with __ctype
6496
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6497
# Compiler inserts libc in the correct place for threads to work
6500
# Add libc to deplibs on all other systems if necessary.
6501
if test "$build_libtool_need_lc" = "yes"; then
6502
deplibs="$deplibs -lc"
6508
# Transform deplibs into only deplibs that can be linked in shared.
6510
libname_save=$libname
6511
release_save=$release
6512
versuffix_save=$versuffix
6514
# I'm not sure if I'm treating the release correctly. I think
6515
# release should show up in the -l (ie -lgmp5) so we don't want to
6516
# add it in twice. Is that correct?
6522
case $deplibs_check_method in
6524
# Don't check for shared/static. Everything works.
6525
# This might be a little naive. We might want to check
6526
# whether the library exists or not. But this is on
6527
# osf3 & osf4 and I'm not really sure... Just
6528
# implementing what was already the behavior.
6532
# This code stresses the "libraries are programs" paradigm to its
6533
# limits. Maybe even breaks it. We compile a program, linking it
6534
# against the deplibs as a proxy for the library. Then we can check
6535
# whether they linked in statically or dynamically with ldd.
6536
$opt_dry_run || $RM conftest.c
6537
cat > conftest.c <<EOF
6538
int main() { return 0; }
6540
$opt_dry_run || $RM conftest
6541
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6542
ldd_output=`ldd conftest`
6543
for i in $deplibs; do
6546
func_stripname -l '' "$i"
6547
name=$func_stripname_result
6548
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6549
case " $predeps $postdeps " in
6551
newdeplibs="$newdeplibs $i"
6556
if test -n "$i" ; then
6557
libname=`eval "\\$ECHO \"$libname_spec\""`
6558
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6559
set dummy $deplib_matches; shift
6561
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6562
newdeplibs="$newdeplibs $i"
6566
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6567
$ECHO "*** I have the capability to make that library automatically link in when"
6568
$ECHO "*** you link to this library. But I can only do this if you have a"
6569
$ECHO "*** shared version of the library, which I believe you do not have"
6570
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
6571
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
6576
newdeplibs="$newdeplibs $i"
6581
# Error occurred in the first compile. Let's try to salvage
6582
# the situation: Compile a separate program for each library.
6583
for i in $deplibs; do
6586
func_stripname -l '' "$i"
6587
name=$func_stripname_result
6588
$opt_dry_run || $RM conftest
6589
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6590
ldd_output=`ldd conftest`
6591
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6592
case " $predeps $postdeps " in
6594
newdeplibs="$newdeplibs $i"
6599
if test -n "$i" ; then
6600
libname=`eval "\\$ECHO \"$libname_spec\""`
6601
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
6602
set dummy $deplib_matches; shift
6604
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6605
newdeplibs="$newdeplibs $i"
6609
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
6610
$ECHO "*** I have the capability to make that library automatically link in when"
6611
$ECHO "*** you link to this library. But I can only do this if you have a"
6612
$ECHO "*** shared version of the library, which you do not appear to have"
6613
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
6614
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
6620
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6621
$ECHO "*** make it link in! You will probably need to install it or some"
6622
$ECHO "*** library that it depends on before this library will be fully"
6623
$ECHO "*** functional. Installing it before continuing would be even better."
6627
newdeplibs="$newdeplibs $i"
6634
set dummy $deplibs_check_method; shift
6635
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6636
for a_deplib in $deplibs; do
6639
func_stripname -l '' "$a_deplib"
6640
name=$func_stripname_result
6641
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6642
case " $predeps $postdeps " in
6644
newdeplibs="$newdeplibs $a_deplib"
6649
if test -n "$a_deplib" ; then
6650
libname=`eval "\\$ECHO \"$libname_spec\""`
6651
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6652
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6653
for potent_lib in $potential_libs; do
6654
# Follow soft links.
6655
if ls -lLd "$potent_lib" 2>/dev/null |
6656
$GREP " -> " >/dev/null; then
6659
# The statement above tries to avoid entering an
6660
# endless loop below, in case of cyclic links.
6661
# We might still enter an endless loop, since a link
6662
# loop can be closed while we follow links,
6664
potlib="$potent_lib"
6665
while test -h "$potlib" 2>/dev/null; do
6666
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6668
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6669
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
6672
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
6674
$EGREP "$file_magic_regex" > /dev/null; then
6675
newdeplibs="$newdeplibs $a_deplib"
6682
if test -n "$a_deplib" ; then
6685
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6686
$ECHO "*** I have the capability to make that library automatically link in when"
6687
$ECHO "*** you link to this library. But I can only do this if you have a"
6688
$ECHO "*** shared version of the library, which you do not appear to have"
6689
$ECHO "*** because I did check the linker path looking for a file starting"
6690
if test -z "$potlib" ; then
6691
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6693
$ECHO "*** with $libname and none of the candidates passed a file format test"
6694
$ECHO "*** using a file magic. Last file checked: $potlib"
6699
# Add a -L argument.
6700
newdeplibs="$newdeplibs $a_deplib"
6703
done # Gone through all deplibs.
6706
set dummy $deplibs_check_method; shift
6707
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6708
for a_deplib in $deplibs; do
6711
func_stripname -l '' "$a_deplib"
6712
name=$func_stripname_result
6713
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6714
case " $predeps $postdeps " in
6716
newdeplibs="$newdeplibs $a_deplib"
6721
if test -n "$a_deplib" ; then
6722
libname=`eval "\\$ECHO \"$libname_spec\""`
6723
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6724
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6725
for potent_lib in $potential_libs; do
6726
potlib="$potent_lib" # see symlink-check above in file_magic test
6727
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
6728
$EGREP "$match_pattern_regex" > /dev/null; then
6729
newdeplibs="$newdeplibs $a_deplib"
6736
if test -n "$a_deplib" ; then
6739
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6740
$ECHO "*** I have the capability to make that library automatically link in when"
6741
$ECHO "*** you link to this library. But I can only do this if you have a"
6742
$ECHO "*** shared version of the library, which you do not appear to have"
6743
$ECHO "*** because I did check the linker path looking for a file starting"
6744
if test -z "$potlib" ; then
6745
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6747
$ECHO "*** with $libname and none of the candidates passed a file format test"
6748
$ECHO "*** using a regex pattern. Last file checked: $potlib"
6753
# Add a -L argument.
6754
newdeplibs="$newdeplibs $a_deplib"
6757
done # Gone through all deplibs.
6761
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
6762
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
6763
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6764
for i in $predeps $postdeps ; do
6765
# can't use Xsed below, because $i might contain '/'
6766
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
6769
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
6770
$GREP . >/dev/null; then
6772
if test "X$deplibs_check_method" = "Xnone"; then
6773
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
6775
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
6777
$ECHO "*** All declared inter-library dependencies are being dropped."
6782
versuffix=$versuffix_save
6784
release=$release_save
6785
libname=$libname_save
6789
*-*-rhapsody* | *-*-darwin1.[012])
6790
# On Rhapsody replace the C library with the System framework
6791
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
6795
if test "$droppeddeps" = yes; then
6796
if test "$module" = yes; then
6798
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
6799
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
6800
$ECHO "*** a static module, that should work as long as the dlopening"
6801
$ECHO "*** application is linked with the -dlopen flag."
6802
if test -z "$global_symbol_pipe"; then
6804
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6805
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6806
$ECHO "*** not find such a program. So, this module is probably useless."
6807
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6809
if test "$build_old_libs" = no; then
6810
oldlibs="$output_objdir/$libname.$libext"
6811
build_libtool_libs=module
6814
build_libtool_libs=no
6817
$ECHO "*** The inter-library dependencies that have been dropped here will be"
6818
$ECHO "*** automatically added whenever a program is linked with this library"
6819
$ECHO "*** or is declared to -dlopen it."
6821
if test "$allow_undefined" = no; then
6823
$ECHO "*** Since this library must not contain undefined symbols,"
6824
$ECHO "*** because either the platform does not support them or"
6825
$ECHO "*** it was explicitly requested with -no-undefined,"
6826
$ECHO "*** libtool will only create a static version of it."
6827
if test "$build_old_libs" = no; then
6828
oldlibs="$output_objdir/$libname.$libext"
6829
build_libtool_libs=module
6832
build_libtool_libs=no
6837
# Done checking deplibs!
6840
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
6843
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6844
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6845
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6849
# move library search paths that coincide with paths to not yet
6850
# installed libraries to the beginning of the library search list
6852
for path in $notinst_path; do
6853
case " $new_libs " in
6854
*" -L$path/$objdir "*) ;;
6856
case " $deplibs " in
6857
*" -L$path/$objdir "*)
6858
new_libs="$new_libs -L$path/$objdir" ;;
6863
for deplib in $deplibs; do
6866
case " $new_libs " in
6868
*) new_libs="$new_libs $deplib" ;;
6871
*) new_libs="$new_libs $deplib" ;;
6876
# All the library-specific variables (install_libdir is set above).
6881
# Test again, we may have decided not to build it any more
6882
if test "$build_libtool_libs" = yes; then
6883
if test "$hardcode_into_libs" = yes; then
6884
# Hardcode the library paths
6887
rpath="$finalize_rpath"
6888
test "$mode" != relink && rpath="$compile_rpath$rpath"
6889
for libdir in $rpath; do
6890
if test -n "$hardcode_libdir_flag_spec"; then
6891
if test -n "$hardcode_libdir_separator"; then
6892
if test -z "$hardcode_libdirs"; then
6893
hardcode_libdirs="$libdir"
6895
# Just accumulate the unique libdirs.
6896
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
6897
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
6900
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
6905
eval flag=\"$hardcode_libdir_flag_spec\"
6906
dep_rpath="$dep_rpath $flag"
6908
elif test -n "$runpath_var"; then
6909
case "$perm_rpath " in
6911
*) perm_rpath="$perm_rpath $libdir" ;;
6915
# Substitute the hardcoded libdirs into the rpath.
6916
if test -n "$hardcode_libdir_separator" &&
6917
test -n "$hardcode_libdirs"; then
6918
libdir="$hardcode_libdirs"
6919
if test -n "$hardcode_libdir_flag_spec_ld"; then
6920
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
6922
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
6925
if test -n "$runpath_var" && test -n "$perm_rpath"; then
6926
# We should set the runpath_var.
6928
for dir in $perm_rpath; do
6931
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
6933
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
6936
shlibpath="$finalize_shlibpath"
6937
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
6938
if test -n "$shlibpath"; then
6939
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
6942
# Get the real and link names of the library.
6943
eval shared_ext=\"$shrext_cmds\"
6944
eval library_names=\"$library_names_spec\"
6945
set dummy $library_names
6950
if test -n "$soname_spec"; then
6951
eval soname=\"$soname_spec\"
6955
if test -z "$dlname"; then
6959
lib="$output_objdir/$realname"
6963
linknames="$linknames $link"
6966
# Use standard objects if they are pic
6967
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
6968
test "X$libobjs" = "X " && libobjs=
6971
if test -n "$export_symbols" && test -n "$include_expsyms"; then
6972
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
6973
export_symbols="$output_objdir/$libname.uexp"
6974
delfiles="$delfiles $export_symbols"
6977
orig_export_symbols=
6979
cygwin* | mingw* | cegcc*)
6980
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
6981
# exporting using user supplied symfile
6982
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
6983
# and it's NOT already a .def file. Must figure out
6984
# which of the given symbols are data symbols and tag
6985
# them as such. So, trigger use of export_symbols_cmds.
6986
# export_symbols gets reassigned inside the "prepare
6987
# the list of exported symbols" if statement, so the
6988
# include_expsyms logic still works.
6989
orig_export_symbols="$export_symbols"
6991
always_export_symbols=yes
6997
# Prepare the list of exported symbols
6998
if test -z "$export_symbols"; then
6999
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7000
func_verbose "generating symbol list for \`$libname.la'"
7001
export_symbols="$output_objdir/$libname.exp"
7002
$opt_dry_run || $RM $export_symbols
7003
cmds=$export_symbols_cmds
7004
save_ifs="$IFS"; IFS='~'
7005
for cmd in $cmds; do
7009
len=$func_len_result
7010
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7011
func_show_eval "$cmd" 'exit $?'
7012
skipped_export=false
7014
# The command line is too long to execute in one step.
7015
func_verbose "using reloadable object file for export list..."
7017
# Break out early, otherwise skipped_export may be
7018
# set to false by a later but shorter cmd.
7023
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7024
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7025
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7030
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7031
tmp_export_symbols="$export_symbols"
7032
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7033
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7036
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7037
# The given exports_symbols file has to be filtered, so filter it.
7038
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7039
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7040
# 's' commands which not all seds can handle. GNU sed should be fine
7041
# though. Also, the filter scales superlinearly with the number of
7042
# global variables. join(1) would be nice here, but unfortunately
7043
# isn't a blessed tool.
7044
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7045
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7046
export_symbols=$output_objdir/$libname.def
7047
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7051
for test_deplib in $deplibs; do
7052
case " $convenience " in
7053
*" $test_deplib "*) ;;
7055
tmp_deplibs="$tmp_deplibs $test_deplib"
7059
deplibs="$tmp_deplibs"
7061
if test -n "$convenience"; then
7062
if test -n "$whole_archive_flag_spec" &&
7063
test "$compiler_needs_object" = yes &&
7064
test -z "$libobjs"; then
7065
# extract the archives, so we have objects to list.
7066
# TODO: could optimize this to just extract one archive.
7067
whole_archive_flag_spec=
7069
if test -n "$whole_archive_flag_spec"; then
7070
save_libobjs=$libobjs
7071
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7072
test "X$libobjs" = "X " && libobjs=
7074
gentop="$output_objdir/${outputname}x"
7075
generated="$generated $gentop"
7077
func_extract_archives $gentop $convenience
7078
libobjs="$libobjs $func_extract_archives_result"
7079
test "X$libobjs" = "X " && libobjs=
7083
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7084
eval flag=\"$thread_safe_flag_spec\"
7085
linker_flags="$linker_flags $flag"
7088
# Make a backup of the uninstalled library when relinking
7089
if test "$mode" = relink; then
7090
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7093
# Do each of the archive commands.
7094
if test "$module" = yes && test -n "$module_cmds" ; then
7095
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7096
eval test_cmds=\"$module_expsym_cmds\"
7097
cmds=$module_expsym_cmds
7099
eval test_cmds=\"$module_cmds\"
7103
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7104
eval test_cmds=\"$archive_expsym_cmds\"
7105
cmds=$archive_expsym_cmds
7107
eval test_cmds=\"$archive_cmds\"
7112
if test "X$skipped_export" != "X:" &&
7113
func_len " $test_cmds" &&
7114
len=$func_len_result &&
7115
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7118
# The command line is too long to link in one step, link piecewise
7119
# or, if using GNU ld and skipped_export is not :, use a linker
7122
# Save the value of $output and $libobjs because we want to
7123
# use them later. If we have whole_archive_flag_spec, we
7124
# want to use save_libobjs as it was before
7125
# whole_archive_flag_spec was expanded, because we can't
7126
# assume the linker understands whole_archive_flag_spec.
7127
# This may have to be revisited, in case too many
7128
# convenience libraries get linked in and end up exceeding
7130
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7131
save_libobjs=$libobjs
7134
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7136
# Clear the reloadable object creation command queue and
7137
# initialize k to one.
7144
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7145
output=${output_objdir}/${output_la}.lnkscript
7146
func_verbose "creating GNU ld script: $output"
7147
$ECHO 'INPUT (' > $output
7148
for obj in $save_libobjs
7150
$ECHO "$obj" >> $output
7152
$ECHO ')' >> $output
7153
delfiles="$delfiles $output"
7154
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7155
output=${output_objdir}/${output_la}.lnk
7156
func_verbose "creating linker input file list: $output"
7161
if test "$compiler_needs_object" = yes; then
7167
$ECHO "$obj" >> $output
7169
delfiles="$delfiles $output"
7170
output=$firstobj\"$file_list_spec$output\"
7172
if test -n "$save_libobjs"; then
7173
func_verbose "creating reloadable object files..."
7174
output=$output_objdir/$output_la-${k}.$objext
7175
eval test_cmds=\"$reload_cmds\"
7176
func_len " $test_cmds"
7177
len0=$func_len_result
7180
# Loop over the list of objects to be linked.
7181
for obj in $save_libobjs
7184
func_arith $len + $func_len_result
7185
len=$func_arith_result
7186
if test "X$objlist" = X ||
7187
test "$len" -lt "$max_cmd_len"; then
7188
func_append objlist " $obj"
7190
# The command $test_cmds is almost too long, add a
7191
# command to the queue.
7192
if test "$k" -eq 1 ; then
7193
# The first file doesn't have a previous command to add.
7194
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7196
# All subsequent reloadable object files will link in
7197
# the last one created.
7198
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7200
last_robj=$output_objdir/$output_la-${k}.$objext
7202
k=$func_arith_result
7203
output=$output_objdir/$output_la-${k}.$objext
7205
func_len " $last_robj"
7206
func_arith $len0 + $func_len_result
7207
len=$func_arith_result
7210
# Handle the remaining objects by creating one last
7211
# reloadable object file. All subsequent reloadable object
7212
# files will link in the last one created.
7213
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7214
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7215
if test -n "$last_robj"; then
7216
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7218
delfiles="$delfiles $output"
7224
if ${skipped_export-false}; then
7225
func_verbose "generating symbol list for \`$libname.la'"
7226
export_symbols="$output_objdir/$libname.exp"
7227
$opt_dry_run || $RM $export_symbols
7229
# Append the command to create the export file.
7230
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7231
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7232
if test -n "$last_robj"; then
7233
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7237
test -n "$save_libobjs" &&
7238
func_verbose "creating a temporary reloadable object file: $output"
7240
# Loop through the commands generated above and execute them.
7241
save_ifs="$IFS"; IFS='~'
7242
for cmd in $concat_cmds; do
7245
func_quote_for_expand "$cmd"
7246
eval "func_echo $func_quote_for_expand_result"
7248
$opt_dry_run || eval "$cmd" || {
7251
# Restore the uninstalled library and exit
7252
if test "$mode" = relink; then
7253
( cd "$output_objdir" && \
7254
$RM "${realname}T" && \
7255
$MV "${realname}U" "$realname" )
7263
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7264
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7265
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7269
if ${skipped_export-false}; then
7270
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7271
tmp_export_symbols="$export_symbols"
7272
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7273
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7276
if test -n "$orig_export_symbols"; then
7277
# The given exports_symbols file has to be filtered, so filter it.
7278
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7279
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7280
# 's' commands which not all seds can handle. GNU sed should be fine
7281
# though. Also, the filter scales superlinearly with the number of
7282
# global variables. join(1) would be nice here, but unfortunately
7283
# isn't a blessed tool.
7284
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7285
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7286
export_symbols=$output_objdir/$libname.def
7287
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7292
# Restore the value of output.
7295
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7296
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7297
test "X$libobjs" = "X " && libobjs=
7299
# Expand the library linking commands again to reset the
7300
# value of $libobjs for piecewise linking.
7302
# Do each of the archive commands.
7303
if test "$module" = yes && test -n "$module_cmds" ; then
7304
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7305
cmds=$module_expsym_cmds
7310
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7311
cmds=$archive_expsym_cmds
7318
if test -n "$delfiles"; then
7319
# Append the command to remove temporary files to $cmds.
7320
eval cmds=\"\$cmds~\$RM $delfiles\"
7323
# Add any objects from preloaded convenience libraries
7324
if test -n "$dlprefiles"; then
7325
gentop="$output_objdir/${outputname}x"
7326
generated="$generated $gentop"
7328
func_extract_archives $gentop $dlprefiles
7329
libobjs="$libobjs $func_extract_archives_result"
7330
test "X$libobjs" = "X " && libobjs=
7333
save_ifs="$IFS"; IFS='~'
7334
for cmd in $cmds; do
7338
func_quote_for_expand "$cmd"
7339
eval "func_echo $func_quote_for_expand_result"
7341
$opt_dry_run || eval "$cmd" || {
7344
# Restore the uninstalled library and exit
7345
if test "$mode" = relink; then
7346
( cd "$output_objdir" && \
7347
$RM "${realname}T" && \
7348
$MV "${realname}U" "$realname" )
7356
# Restore the uninstalled library and exit
7357
if test "$mode" = relink; then
7358
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7360
if test -n "$convenience"; then
7361
if test -z "$whole_archive_flag_spec"; then
7362
func_show_eval '${RM}r "$gentop"'
7369
# Create links to the real library.
7370
for linkname in $linknames; do
7371
if test "$realname" != "$linkname"; then
7372
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7376
# If -module or -export-dynamic was specified, set the dlname.
7377
if test "$module" = yes || test "$export_dynamic" = yes; then
7378
# On all known operating systems, these are identical.
7385
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7386
func_warning "\`-dlopen' is ignored for objects"
7391
func_warning "\`-l' and \`-L' are ignored for objects" ;;
7394
test -n "$rpath" && \
7395
func_warning "\`-rpath' is ignored for objects"
7397
test -n "$xrpath" && \
7398
func_warning "\`-R' is ignored for objects"
7400
test -n "$vinfo" && \
7401
func_warning "\`-version-info' is ignored for objects"
7403
test -n "$release" && \
7404
func_warning "\`-release' is ignored for objects"
7408
test -n "$objs$old_deplibs" && \
7409
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7413
obj=$func_lo2o_result
7421
# Delete the old objects.
7422
$opt_dry_run || $RM $obj $libobj
7424
# Objects from convenience libraries. This assumes
7425
# single-version convenience libraries. Whenever we create
7426
# different ones for PIC/non-PIC, this we'll have to duplicate
7430
# reload_cmds runs $LD directly, so let us get rid of
7431
# -Wl from whole_archive_flag_spec and hope we can get by with
7432
# turning comma into space..
7435
if test -n "$convenience"; then
7436
if test -n "$whole_archive_flag_spec"; then
7437
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7438
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7440
gentop="$output_objdir/${obj}x"
7441
generated="$generated $gentop"
7443
func_extract_archives $gentop $convenience
7444
reload_conv_objs="$reload_objs $func_extract_archives_result"
7448
# Create the old-style object.
7449
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
7452
func_execute_cmds "$reload_cmds" 'exit $?'
7454
# Exit if we aren't doing a library object file.
7455
if test -z "$libobj"; then
7456
if test -n "$gentop"; then
7457
func_show_eval '${RM}r "$gentop"'
7463
if test "$build_libtool_libs" != yes; then
7464
if test -n "$gentop"; then
7465
func_show_eval '${RM}r "$gentop"'
7468
# Create an invalid libtool object if no PIC, so that we don't
7469
# accidentally link it into a program.
7470
# $show "echo timestamp > $libobj"
7471
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7475
if test -n "$pic_flag" || test "$pic_mode" != default; then
7476
# Only do commands if we really have different PIC objects.
7477
reload_objs="$libobjs $reload_conv_objs"
7479
func_execute_cmds "$reload_cmds" 'exit $?'
7482
if test -n "$gentop"; then
7483
func_show_eval '${RM}r "$gentop"'
7491
*cygwin*) func_stripname '' '.exe' "$output"
7492
output=$func_stripname_result.exe;;
7494
test -n "$vinfo" && \
7495
func_warning "\`-version-info' is ignored for programs"
7497
test -n "$release" && \
7498
func_warning "\`-release' is ignored for programs"
7500
test "$preload" = yes \
7501
&& test "$dlopen_support" = unknown \
7502
&& test "$dlopen_self" = unknown \
7503
&& test "$dlopen_self_static" = unknown && \
7504
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7507
*-*-rhapsody* | *-*-darwin1.[012])
7508
# On Rhapsody replace the C library is the System framework
7509
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7510
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7516
# Don't allow lazy linking, it breaks C++ global constructors
7517
# But is supposedly fixed on 10.4 or later (yay!).
7518
if test "$tagname" = CXX ; then
7519
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7521
compile_command="$compile_command ${wl}-bind_at_load"
7522
finalize_command="$finalize_command ${wl}-bind_at_load"
7526
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7527
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7528
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7533
# move library search paths that coincide with paths to not yet
7534
# installed libraries to the beginning of the library search list
7536
for path in $notinst_path; do
7537
case " $new_libs " in
7538
*" -L$path/$objdir "*) ;;
7540
case " $compile_deplibs " in
7541
*" -L$path/$objdir "*)
7542
new_libs="$new_libs -L$path/$objdir" ;;
7547
for deplib in $compile_deplibs; do
7550
case " $new_libs " in
7552
*) new_libs="$new_libs $deplib" ;;
7555
*) new_libs="$new_libs $deplib" ;;
7558
compile_deplibs="$new_libs"
7561
compile_command="$compile_command $compile_deplibs"
7562
finalize_command="$finalize_command $finalize_deplibs"
7564
if test -n "$rpath$xrpath"; then
7565
# If the user specified any rpath flags, then add them.
7566
for libdir in $rpath $xrpath; do
7567
# This is the magic to use -rpath.
7568
case "$finalize_rpath " in
7570
*) finalize_rpath="$finalize_rpath $libdir" ;;
7575
# Now hardcode the library paths
7578
for libdir in $compile_rpath $finalize_rpath; do
7579
if test -n "$hardcode_libdir_flag_spec"; then
7580
if test -n "$hardcode_libdir_separator"; then
7581
if test -z "$hardcode_libdirs"; then
7582
hardcode_libdirs="$libdir"
7584
# Just accumulate the unique libdirs.
7585
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7586
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7589
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7594
eval flag=\"$hardcode_libdir_flag_spec\"
7595
rpath="$rpath $flag"
7597
elif test -n "$runpath_var"; then
7598
case "$perm_rpath " in
7600
*) perm_rpath="$perm_rpath $libdir" ;;
7604
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7605
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7606
case :$dllsearchpath: in
7608
::) dllsearchpath=$libdir;;
7609
*) dllsearchpath="$dllsearchpath:$libdir";;
7611
case :$dllsearchpath: in
7612
*":$testbindir:"*) ;;
7613
::) dllsearchpath=$testbindir;;
7614
*) dllsearchpath="$dllsearchpath:$testbindir";;
7619
# Substitute the hardcoded libdirs into the rpath.
7620
if test -n "$hardcode_libdir_separator" &&
7621
test -n "$hardcode_libdirs"; then
7622
libdir="$hardcode_libdirs"
7623
eval rpath=\" $hardcode_libdir_flag_spec\"
7625
compile_rpath="$rpath"
7629
for libdir in $finalize_rpath; do
7630
if test -n "$hardcode_libdir_flag_spec"; then
7631
if test -n "$hardcode_libdir_separator"; then
7632
if test -z "$hardcode_libdirs"; then
7633
hardcode_libdirs="$libdir"
7635
# Just accumulate the unique libdirs.
7636
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7637
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7640
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7645
eval flag=\"$hardcode_libdir_flag_spec\"
7646
rpath="$rpath $flag"
7648
elif test -n "$runpath_var"; then
7649
case "$finalize_perm_rpath " in
7651
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7655
# Substitute the hardcoded libdirs into the rpath.
7656
if test -n "$hardcode_libdir_separator" &&
7657
test -n "$hardcode_libdirs"; then
7658
libdir="$hardcode_libdirs"
7659
eval rpath=\" $hardcode_libdir_flag_spec\"
7661
finalize_rpath="$rpath"
7663
if test -n "$libobjs" && test "$build_old_libs" = yes; then
7664
# Transform all the library objects into standard objects.
7665
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7666
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7669
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7671
# template prelinking step
7672
if test -n "$prelink_cmds"; then
7673
func_execute_cmds "$prelink_cmds" 'exit $?'
7676
wrappers_required=yes
7678
*cygwin* | *mingw* )
7679
if test "$build_libtool_libs" != yes; then
7680
wrappers_required=no
7684
# Disable wrappers for cegcc, we are cross compiling anyway.
7685
wrappers_required=no
7688
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7689
wrappers_required=no
7693
if test "$wrappers_required" = no; then
7694
# Replace the output file specification.
7695
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7696
link_command="$compile_command$compile_rpath"
7698
# We have no uninstalled library dependencies, so finalize right now.
7700
func_show_eval "$link_command" 'exit_status=$?'
7702
# Delete the generated files.
7703
if test -f "$output_objdir/${outputname}S.${objext}"; then
7704
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7710
if test -n "$compile_shlibpath$finalize_shlibpath"; then
7711
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7713
if test -n "$finalize_shlibpath"; then
7714
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7719
if test -n "$runpath_var"; then
7720
if test -n "$perm_rpath"; then
7721
# We should set the runpath_var.
7723
for dir in $perm_rpath; do
7726
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7728
if test -n "$finalize_perm_rpath"; then
7729
# We should set the runpath_var.
7731
for dir in $finalize_perm_rpath; do
7734
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7738
if test "$no_install" = yes; then
7739
# We don't need to create a wrapper script.
7740
link_command="$compile_var$compile_command$compile_rpath"
7741
# Replace the output file specification.
7742
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
7743
# Delete the old output file.
7744
$opt_dry_run || $RM $output
7745
# Link the executable and exit
7746
func_show_eval "$link_command" 'exit $?'
7750
if test "$hardcode_action" = relink; then
7751
# Fast installation is not supported
7752
link_command="$compile_var$compile_command$compile_rpath"
7753
relink_command="$finalize_var$finalize_command$finalize_rpath"
7755
func_warning "this platform does not like uninstalled shared libraries"
7756
func_warning "\`$output' will be relinked during installation"
7758
if test "$fast_install" != no; then
7759
link_command="$finalize_var$compile_command$finalize_rpath"
7760
if test "$fast_install" = yes; then
7761
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
7763
# fast_install is set to needless
7767
link_command="$compile_var$compile_command$compile_rpath"
7768
relink_command="$finalize_var$finalize_command$finalize_rpath"
7772
# Replace the output file specification.
7773
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7775
# Delete the old output files.
7776
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
7778
func_show_eval "$link_command" 'exit $?'
7780
# Now create the wrapper script.
7781
func_verbose "creating $output"
7783
# Quote the relink command for shipping.
7784
if test -n "$relink_command"; then
7785
# Preserve any variables that may affect compiler behavior
7786
for var in $variables_saved_for_relink; do
7787
if eval test -z \"\${$var+set}\"; then
7788
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
7789
elif eval var_value=\$$var; test -z "$var_value"; then
7790
relink_command="$var=; export $var; $relink_command"
7792
func_quote_for_eval "$var_value"
7793
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
7796
relink_command="(cd `pwd`; $relink_command)"
7797
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
7800
# Quote $ECHO for shipping.
7801
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
7803
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
7804
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
7806
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
7808
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
7811
# Only actually do things if not in dry run mode.
7813
# win32 will think the script is a binary if it has
7814
# a .exe suffix, so we strip it off here.
7816
*.exe) func_stripname '' '.exe' "$output"
7817
output=$func_stripname_result ;;
7819
# test for cygwin because mv fails w/o .exe extensions
7823
func_stripname '' '.exe' "$outputname"
7824
outputname=$func_stripname_result ;;
7828
*cygwin* | *mingw* )
7829
func_dirname_and_basename "$output" "" "."
7830
output_name=$func_basename_result
7831
output_path=$func_dirname_result
7832
cwrappersource="$output_path/$objdir/lt-$output_name.c"
7833
cwrapper="$output_path/$output_name.exe"
7834
$RM $cwrappersource $cwrapper
7835
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
7837
func_emit_cwrapperexe_src > $cwrappersource
7839
# The wrapper executable is built using the $host compiler,
7840
# because it contains $host paths and files. If cross-
7841
# compiling, it, like the target executable, must be
7842
# executed on the $host or under an emulation environment.
7844
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
7848
# Now, create the wrapper script for func_source use:
7849
func_ltwrapper_scriptname $cwrapper
7850
$RM $func_ltwrapper_scriptname_result
7851
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
7853
# note: this script will not be executed, so do not chmod.
7854
if test "x$build" = "x$host" ; then
7855
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
7857
func_emit_wrapper no > $func_ltwrapper_scriptname_result
7863
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
7865
func_emit_wrapper no > $output
7874
# See if we need to build an old-fashioned archive.
7875
for oldlib in $oldlibs; do
7877
if test "$build_libtool_libs" = convenience; then
7878
oldobjs="$libobjs_save $symfileobj"
7879
addlibs="$convenience"
7880
build_libtool_libs=no
7882
if test "$build_libtool_libs" = module; then
7883
oldobjs="$libobjs_save"
7884
build_libtool_libs=no
7886
oldobjs="$old_deplibs $non_pic_objects"
7887
if test "$preload" = yes && test -f "$symfileobj"; then
7888
oldobjs="$oldobjs $symfileobj"
7891
addlibs="$old_convenience"
7894
if test -n "$addlibs"; then
7895
gentop="$output_objdir/${outputname}x"
7896
generated="$generated $gentop"
7898
func_extract_archives $gentop $addlibs
7899
oldobjs="$oldobjs $func_extract_archives_result"
7902
# Do each command in the archive commands.
7903
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
7904
cmds=$old_archive_from_new_cmds
7907
# Add any objects from preloaded convenience libraries
7908
if test -n "$dlprefiles"; then
7909
gentop="$output_objdir/${outputname}x"
7910
generated="$generated $gentop"
7912
func_extract_archives $gentop $dlprefiles
7913
oldobjs="$oldobjs $func_extract_archives_result"
7916
# POSIX demands no paths to be encoded in archives. We have
7917
# to avoid creating archives with duplicate basenames if we
7918
# might have to extract them afterwards, e.g., when creating a
7919
# static archive out of a convenience library, or when linking
7920
# the entirety of a libtool archive into another (currently
7921
# not supported by libtool).
7922
if (for obj in $oldobjs
7924
func_basename "$obj"
7925
$ECHO "$func_basename_result"
7926
done | sort | sort -uc >/dev/null 2>&1); then
7929
$ECHO "copying selected object files to avoid basename conflicts..."
7930
gentop="$output_objdir/${outputname}x"
7931
generated="$generated $gentop"
7932
func_mkdir_p "$gentop"
7933
save_oldobjs=$oldobjs
7936
for obj in $save_oldobjs
7938
func_basename "$obj"
7939
objbase="$func_basename_result"
7940
case " $oldobjs " in
7941
" ") oldobjs=$obj ;;
7944
# Make sure we don't pick an alternate name that also
7946
newobj=lt$counter-$objbase
7947
func_arith $counter + 1
7948
counter=$func_arith_result
7949
case " $oldobjs " in
7950
*[\ /]"$newobj "*) ;;
7951
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
7954
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
7955
oldobjs="$oldobjs $gentop/$newobj"
7957
*) oldobjs="$oldobjs $obj" ;;
7961
eval cmds=\"$old_archive_cmds\"
7964
len=$func_len_result
7965
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7966
cmds=$old_archive_cmds
7968
# the command line is too long to link in one step, link in parts
7969
func_verbose "using piecewise archive linking..."
7974
save_oldobjs=$oldobjs
7976
# Is there a better way of finding the last object in the list?
7977
for obj in $save_oldobjs
7981
eval test_cmds=\"$old_archive_cmds\"
7982
func_len " $test_cmds"
7983
len0=$func_len_result
7985
for obj in $save_oldobjs
7988
func_arith $len + $func_len_result
7989
len=$func_arith_result
7990
func_append objlist " $obj"
7991
if test "$len" -lt "$max_cmd_len"; then
7994
# the above command should be used before it gets too long
7996
if test "$obj" = "$last_oldobj" ; then
7999
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8000
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8007
if test "X$oldobjs" = "X" ; then
8008
eval cmds=\"\$concat_cmds\"
8010
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8014
func_execute_cmds "$cmds" 'exit $?'
8017
test -n "$generated" && \
8018
func_show_eval "${RM}r$generated"
8020
# Now create the libtool archive.
8024
test "$build_old_libs" = yes && old_library="$libname.$libext"
8025
func_verbose "creating $output"
8027
# Preserve any variables that may affect compiler behavior
8028
for var in $variables_saved_for_relink; do
8029
if eval test -z \"\${$var+set}\"; then
8030
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8031
elif eval var_value=\$$var; test -z "$var_value"; then
8032
relink_command="$var=; export $var; $relink_command"
8034
func_quote_for_eval "$var_value"
8035
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8038
# Quote the link command for shipping.
8039
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8040
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8041
if test "$hardcode_automatic" = yes ; then
8045
# Only create the output if not a dry run.
8047
for installed in no yes; do
8048
if test "$installed" = yes; then
8049
if test -z "$install_libdir"; then
8052
output="$output_objdir/$outputname"i
8053
# Replace all uninstalled libtool libraries with the installed ones
8055
for deplib in $dependency_libs; do
8058
func_basename "$deplib"
8059
name="$func_basename_result"
8060
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8061
test -z "$libdir" && \
8062
func_fatal_error "\`$deplib' is not a valid libtool archive"
8063
newdependency_libs="$newdependency_libs $libdir/$name"
8065
*) newdependency_libs="$newdependency_libs $deplib" ;;
8068
dependency_libs="$newdependency_libs"
8071
for lib in $dlfiles; do
8074
func_basename "$lib"
8075
name="$func_basename_result"
8076
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8077
test -z "$libdir" && \
8078
func_fatal_error "\`$lib' is not a valid libtool archive"
8079
newdlfiles="$newdlfiles $libdir/$name"
8081
*) newdlfiles="$newdlfiles $lib" ;;
8084
dlfiles="$newdlfiles"
8086
for lib in $dlprefiles; do
8089
# Only pass preopened files to the pseudo-archive (for
8090
# eventual linking with the app. that links it) if we
8091
# didn't already link the preopened objects directly into
8093
func_basename "$lib"
8094
name="$func_basename_result"
8095
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8096
test -z "$libdir" && \
8097
func_fatal_error "\`$lib' is not a valid libtool archive"
8098
newdlprefiles="$newdlprefiles $libdir/$name"
8102
dlprefiles="$newdlprefiles"
8105
for lib in $dlfiles; do
8107
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8108
*) abs=`pwd`"/$lib" ;;
8110
newdlfiles="$newdlfiles $abs"
8112
dlfiles="$newdlfiles"
8114
for lib in $dlprefiles; do
8116
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8117
*) abs=`pwd`"/$lib" ;;
8119
newdlprefiles="$newdlprefiles $abs"
8121
dlprefiles="$newdlprefiles"
8124
# place dlname in correct position for cygwin
8126
case $host,$output,$installed,$module,$dlname in
8127
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8130
# $outputname - a libtool library file
8131
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8133
# Please DO NOT delete this file!
8134
# It is necessary for linking the library.
8136
# The name that we can dlopen(3).
8139
# Names of this library.
8140
library_names='$library_names'
8142
# The name of the static archive.
8143
old_library='$old_library'
8145
# Linker flags that can not go in dependency_libs.
8146
inherited_linker_flags='$new_inherited_linker_flags'
8148
# Libraries that this one depends upon.
8149
dependency_libs='$dependency_libs'
8151
# Names of additional weak libraries provided by this library
8152
weak_library_names='$weak_libs'
8154
# Version information for $libname.
8159
# Is this an already installed library?
8160
installed=$installed
8162
# Should we warn about portability when linking against -modules?
8163
shouldnotlink=$module
8165
# Files to dlopen/dlpreopen
8167
dlpreopen='$dlprefiles'
8169
# Directory that this library needs to be installed in:
8170
libdir='$install_libdir'"
8171
if test "$installed" = no && test "$need_relink" = yes; then
8173
relink_command=\"$relink_command\""
8178
# Do a symbolic link so that the libtool archive can be found in
8179
# LD_LIBRARY_PATH before the program is installed.
8180
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8186
{ test "$mode" = link || test "$mode" = relink; } &&
8187
func_mode_link ${1+"$@"}
8190
# func_mode_uninstall arg...
8191
func_mode_uninstall ()
8199
# This variable tells wrapper scripts just to set variables rather
8200
# than running their programs.
8201
libtool_install_magic="$magic"
8206
-f) RM="$RM $arg"; rmforce=yes ;;
8207
-*) RM="$RM $arg" ;;
8208
*) files="$files $arg" ;;
8213
func_fatal_help "you must specify an RM program"
8217
origobjdir="$objdir"
8218
for file in $files; do
8219
func_dirname "$file" "" "."
8220
dir="$func_dirname_result"
8221
if test "X$dir" = X.; then
8222
objdir="$origobjdir"
8224
objdir="$dir/$origobjdir"
8226
func_basename "$file"
8227
name="$func_basename_result"
8228
test "$mode" = uninstall && objdir="$dir"
8230
# Remember objdir for removal later, being careful to avoid duplicates
8231
if test "$mode" = clean; then
8234
*) rmdirs="$rmdirs $objdir" ;;
8238
# Don't error if the file doesn't exist and rm -f was used.
8239
if { test -L "$file"; } >/dev/null 2>&1 ||
8240
{ test -h "$file"; } >/dev/null 2>&1 ||
8241
test -f "$file"; then
8243
elif test -d "$file"; then
8246
elif test "$rmforce" = yes; then
8254
# Possibly a libtool archive, so verify it.
8255
if func_lalib_p "$file"; then
8256
func_source $dir/$name
8258
# Delete the libtool libraries and symlinks.
8259
for n in $library_names; do
8260
rmfiles="$rmfiles $objdir/$n"
8262
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8266
case " $library_names " in
8267
# " " in the beginning catches empty $dlname
8269
*) rmfiles="$rmfiles $objdir/$dlname" ;;
8271
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8274
if test -n "$library_names"; then
8275
# Do each command in the postuninstall commands.
8276
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8279
if test -n "$old_library"; then
8280
# Do each command in the old_postuninstall commands.
8281
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8283
# FIXME: should reinstall the best remaining shared library.
8290
# Possibly a libtool object, so verify it.
8291
if func_lalib_p "$file"; then
8294
func_source $dir/$name
8296
# Add PIC object to the list of files to remove.
8297
if test -n "$pic_object" &&
8298
test "$pic_object" != none; then
8299
rmfiles="$rmfiles $dir/$pic_object"
8302
# Add non-PIC object to the list of files to remove.
8303
if test -n "$non_pic_object" &&
8304
test "$non_pic_object" != none; then
8305
rmfiles="$rmfiles $dir/$non_pic_object"
8311
if test "$mode" = clean ; then
8315
func_stripname '' '.exe' "$file"
8316
file=$func_stripname_result
8317
func_stripname '' '.exe' "$name"
8318
noexename=$func_stripname_result
8319
# $file with .exe has already been added to rmfiles,
8320
# add $file without .exe
8321
rmfiles="$rmfiles $file"
8324
# Do a test to see if this is a libtool program.
8325
if func_ltwrapper_p "$file"; then
8326
if func_ltwrapper_executable_p "$file"; then
8327
func_ltwrapper_scriptname "$file"
8329
func_source $func_ltwrapper_scriptname_result
8330
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8333
func_source $dir/$noexename
8336
# note $name still contains .exe if it was in $file originally
8337
# as does the version of $file that was added into $rmfiles
8338
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8339
if test "$fast_install" = yes && test -n "$relink_command"; then
8340
rmfiles="$rmfiles $objdir/lt-$name"
8342
if test "X$noexename" != "X$name" ; then
8343
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8349
func_show_eval "$RM $rmfiles" 'exit_status=1'
8351
objdir="$origobjdir"
8353
# Try to remove the ${objdir}s in the directories where we deleted files
8354
for dir in $rmdirs; do
8355
if test -d "$dir"; then
8356
func_show_eval "rmdir $dir >/dev/null 2>&1"
8363
{ test "$mode" = uninstall || test "$mode" = clean; } &&
8364
func_mode_uninstall ${1+"$@"}
8366
test -z "$mode" && {
8367
help="$generic_help"
8368
func_fatal_help "you must specify a MODE"
8371
test -z "$exec_cmd" && \
8372
func_fatal_help "invalid operation mode \`$mode'"
8374
if test -n "$exec_cmd"; then
8375
eval exec "$exec_cmd"
8382
# The TAGs below are defined such that we never get into a situation
8383
# in which we disable both kinds of libraries. Given conflicting
8384
# choices, we go for a static library, that is the most portable,
8385
# since we can't tell whether shared libraries were disabled because
8386
# the user asked for that or because the platform doesn't support
8387
# them. This is particularly important on AIX, because we don't
8388
# support having both static and shared libraries enabled at the same
8389
# time on that platform, so we default to a shared-only configuration.
8390
# If a disable-shared tag is given, we'll fallback to a static-only
8391
# configuration. But we'll never go from static-only to shared-only.
8393
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8394
build_libtool_libs=no
8396
# ### END LIBTOOL TAG CONFIG: disable-shared
8398
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8399
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8400
# ### END LIBTOOL TAG CONFIG: disable-static