3
# libtool - Provide generalized library-building support services.
4
# Generated automatically by config.status ()
5
# Libtool was configured on host nanolx:
6
# NOTE: Changes made to this file will be lost: look at ltmain.sh.
8
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
9
# 2006, 2007, 2008 Free Software Foundation, Inc.
10
# Written by Gordon Matzigkeit, 1996
12
# This file is part of GNU Libtool.
14
# GNU Libtool is free software; you can redistribute it and/or
15
# modify it under the terms of the GNU General Public License as
16
# published by the Free Software Foundation; either version 2 of
17
# the License, or (at your option) any later version.
19
# As a special exception to the GNU General Public License,
20
# if you distribute this file as part of a program or library that
21
# is built using GNU Libtool, you may include this file under the
22
# same distribution terms that you use for the rest of that program.
24
# GNU Libtool is distributed in the hope that it will be useful,
25
# but WITHOUT ANY WARRANTY; without even the implied warranty of
26
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27
# GNU General Public License for more details.
29
# You should have received a copy of the GNU General Public License
30
# along with GNU Libtool; see the file COPYING. If not, a copy
31
# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
32
# obtained by writing to the Free Software Foundation, Inc.,
33
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
36
# The names of the tagged configurations supported by this script.
39
# ### BEGIN LIBTOOL CONFIG
41
# Which release of libtool.m4 was used?
45
# Whether or not to build shared libraries.
46
build_libtool_libs=yes
48
# Whether or not to build static libraries.
51
# What type of objects to build.
54
# Whether or not to optimize for fast installation.
59
host=x86_64-unknown-linux-gnu
64
build=x86_64-unknown-linux-gnu
67
# A sed program that does not truncate output.
70
# Sed that helps us avoid accidentally triggering echo(1) options like -n.
71
Xsed="$SED -e 1s/^X//"
73
# A grep program that handles long lines.
79
# A literal string matcher.
82
# A BSD- or MS-compatible name lister.
85
# Whether we need soft or hard links.
88
# What is the maximum length of a command?
91
# Object file suffix (normally "o").
94
# Executable file suffix (normally "").
97
# whether the shell understands "unset".
100
# turn spaces into newlines.
101
SP2NL="tr \\040 \\012"
103
# turn newlines into spaces.
104
NL2SP="tr \\015\\012 \\040\\040"
106
# How to create reloadable object files.
108
reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
110
# An object symbol dumper.
113
# Method to check whether dependent libraries are shared objects.
114
deplibs_check_method="pass_all"
116
# Command to use when deplibs_check_method == "file_magic".
117
file_magic_cmd="\$MAGIC_CMD"
123
# A symbol stripping program.
126
# Commands used to install an old-style archive.
128
old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
129
old_postuninstall_cmds=""
134
# LTCC compiler flags.
135
LTCFLAGS="-march=athlon64 -m64 -O3 -mmmx -msse -msse2 -msse3 -m3dnow -pipe -Wno-error -fPIC"
137
# Take the output of nm and produce a listing of raw symbols and C names.
138
global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"
140
# Transform the output of nm in a proper C declaration.
141
global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
143
# Transform the output of nm in a C name address pair.
144
global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (void *) \\&\\2},/p'"
146
# Transform the output of nm in a C name address pair when lib prefix is needed.
147
global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/ {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/ {\"lib\\2\", (void *) \\&\\2},/p'"
149
# The name of the directory that contains temporary libtool files.
152
# Shell to use when invoking shell scripts.
155
# An echo program that does not interpret backslashes.
158
# Used to examine libraries when file_magic_cmd begins with "file".
161
# Must we lock files when doing compilation?
164
# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
167
# Tool to change global to local symbols on Mac OS X.
170
# Tool to manipulate fat objects and archives on Mac OS X.
173
# ldd/readelf like tool for Mach-O binaries on Mac OS X.
176
# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
179
# Old archive suffix (normally "a").
182
# Shared library suffix (normally ".so").
185
# The commands to extract the exported symbol list from a shared archive.
186
extract_expsyms_cmds=""
188
# Variables whose values should be saved in libtool wrapper scripts and
189
# restored at link time.
190
variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
192
# Do we need the "lib" prefix for modules?
195
# Do we need a version for libraries?
198
# Library versioning type.
201
# Shared library runtime path variable.
202
runpath_var=LD_RUN_PATH
204
# Shared library path variable.
205
shlibpath_var=LD_LIBRARY_PATH
207
# Is shlibpath searched before the hard-coded library search path?
208
shlibpath_overrides_runpath=no
210
# Format of library name prefix.
211
libname_spec="lib\$name"
213
# List of archive names. First name is the real one, the rest are links.
214
# The last name is the one that the linker finds with -lNAME
215
library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"
217
# The coded name of the library, if different from the real name.
218
soname_spec="\${libname}\${release}\${shared_ext}\$major"
220
# Command to use after installation of a shared archive.
223
# Command to use after uninstallation of a shared archive.
224
postuninstall_cmds=""
226
# Commands used to finish a libtool library installation in a directory.
227
finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
229
# As "finish_cmds", except a single script fragment to be evaled but
233
# Whether we should hardcode library paths into libraries.
234
hardcode_into_libs=yes
236
# Compile-time system search path for libraries.
237
sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/4.3.3 /usr/lib /lib"
239
# Run-time system search path for libraries.
240
sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/local/lib /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu "
242
# Whether dlopen is supported.
243
dlopen_support=unknown
245
# Whether dlopen of programs is supported.
248
# Whether dlopen of statically linked programs is supported.
249
dlopen_self_static=unknown
251
# Commands to strip libraries.
252
old_striplib="strip --strip-debug"
253
striplib="strip --strip-unneeded"
256
# The linker used to build libraries.
257
LD="/usr/bin/ld -m elf_x86_64"
259
# Commands used to build an old-style archive.
260
old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
262
# A language specific compiler.
265
# Is the compiler the GNU compiler?
268
# Compiler flag to turn off builtin functions.
269
no_builtin_flag=" -fno-builtin"
271
# How to pass a linker flag through the compiler.
274
# Additional compiler flags for building library objects.
275
pic_flag=" -fPIC -DPIC"
277
# Compiler flag to prevent dynamic linking.
278
link_static_flag="-static"
280
# Does compiler simultaneously support -c and -o options?
283
# Whether or not to add -lc for building shared libraries.
284
build_libtool_need_lc=no
286
# Whether or not to disallow shared libs when runtime libs are static.
287
allow_libtool_libs_with_static_runtimes=no
289
# Compiler flag to allow reflexive dlopens.
290
export_dynamic_flag_spec="\${wl}--export-dynamic"
292
# Compiler flag to generate shared objects directly from archives.
293
whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
295
# Whether the compiler copes with passing no objects directly.
296
compiler_needs_object="no"
298
# Create an old-style archive from a shared archive.
299
old_archive_from_new_cmds=""
301
# Create a temporary old-style archive to link instead of a shared archive.
302
old_archive_from_expsyms_cmds=""
304
# Commands used to build a shared archive.
305
archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
306
archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
307
cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
308
echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
309
\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"
311
# Commands used to build a loadable module if different from building
314
module_expsym_cmds=""
316
# Whether we are building with GNU ld or not.
319
# Flag that allows shared libraries with undefined symbols to be built.
320
allow_undefined_flag=""
322
# Flag that enforces no undefined symbols.
325
# Flag to hardcode $libdir into a binary during linking.
326
# This must work even if $libdir does not exist
327
hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"
329
# If ld is used when linking, flag to hardcode $libdir into a binary
330
# during linking. This must work even if $libdir does not exist.
331
hardcode_libdir_flag_spec_ld=""
333
# Whether we need a single "-rpath" flag with a separated argument.
334
hardcode_libdir_separator=""
336
# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
337
# DIR into the resulting binary.
340
# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
341
# DIR into the resulting binary and the resulting library dependency is
342
# "absolute",i.e impossible to change by setting ${shlibpath_var} if the
343
# library is relocated.
344
hardcode_direct_absolute=no
346
# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
347
# into the resulting binary.
350
# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
351
# into the resulting binary.
352
hardcode_shlibpath_var=unsupported
354
# Set to "yes" if building a shared library automatically hardcodes DIR
355
# into the library and all subsequent libraries and executables linked
357
hardcode_automatic=no
359
# Set to yes if linker adds runtime paths of dependent libraries
360
# to runtime path list.
363
# Whether libtool must link a program against all its dependency libraries.
364
link_all_deplibs=unknown
366
# Fix the shell variable $srcfile for the compiler.
369
# Set to "yes" if exported symbols are required.
370
always_export_symbols=no
372
# The commands to list exported symbols.
373
export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
375
# Symbols that should not be listed in the preloaded symbols.
376
exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
378
# Symbols that must always be exported.
381
# Commands necessary for linking programs (against libraries) with templates.
384
# Specify filename containing input files.
387
# How to hardcode a shared library path into an executable.
388
hardcode_action=immediate
390
# ### END LIBTOOL CONFIG
392
# Generated from ltmain.m4sh.
394
# ltmain.sh (GNU libtool) 2.2.6
395
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
397
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
398
# This is free software; see the source for copying conditions. There is NO
399
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
401
# GNU Libtool is free software; you can redistribute it and/or modify
402
# it under the terms of the GNU General Public License as published by
403
# the Free Software Foundation; either version 2 of the License, or
404
# (at your option) any later version.
406
# As a special exception to the GNU General Public License,
407
# if you distribute this file as part of a program or library that
408
# is built using GNU Libtool, you may include this file under the
409
# same distribution terms that you use for the rest of that program.
411
# GNU Libtool is distributed in the hope that it will be useful, but
412
# WITHOUT ANY WARRANTY; without even the implied warranty of
413
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
414
# General Public License for more details.
416
# You should have received a copy of the GNU General Public License
417
# along with GNU Libtool; see the file COPYING. If not, a copy
418
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
419
# or obtained by writing to the Free Software Foundation, Inc.,
420
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
422
# Usage: $progname [OPTION]... [MODE-ARG]...
424
# Provide generalized library-building support services.
426
# --config show all configuration variables
427
# --debug enable verbose shell tracing
428
# -n, --dry-run display commands without modifying any files
429
# --features display basic configuration information and exit
430
# --mode=MODE use operation mode MODE
431
# --preserve-dup-deps don't remove duplicate dependency libraries
432
# --quiet, --silent don't print informational messages
433
# --tag=TAG use configuration variables from tag TAG
434
# -v, --verbose print informational messages (default)
435
# --version print version information
436
# -h, --help print short or long help message
438
# MODE must be one of the following:
440
# clean remove files from the build directory
441
# compile compile a source file into a libtool object
442
# execute automatically set library path, then run a program
443
# finish complete the installation of libtool libraries
444
# install install libraries or executables
445
# link create a library or an executable
446
# uninstall remove libraries from an installed directory
448
# MODE-ARGS vary depending on the MODE.
449
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
451
# When reporting a bug, please describe a test case to reproduce it and
452
# include the following information:
454
# host-triplet: $host
457
# compiler flags: $LTCFLAGS
458
# linker: $LD (gnu? $with_gnu_ld)
459
# $progname: (GNU libtool) 2.2.6 Debian-2.2.6a-1nano
460
# automake: $automake_version
461
# autoconf: $autoconf_version
463
# Report bugs to <bug-libtool@gnu.org>.
467
VERSION="2.2.6 Debian-2.2.6a-1nano"
469
package_revision=1.3012
471
# Be Bourne compatible
472
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
475
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
476
# is contrary to our usage. Disable this feature.
477
alias -g '${1+"$@"}'='"$@"'
480
case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
482
BIN_SH=xpg4; export BIN_SH # for Tru64
483
DUALCASE=1; export DUALCASE # for MKS sh
485
# NLS nuisances: We save the old values to restore during execute mode.
486
# Only set LANG and LC_ALL to C if already set.
487
# These must not be set unconditionally because not all systems understand
488
# e.g. LANG=C (notably SCO).
491
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
493
eval "if test \"\${$lt_var+set}\" = set; then
494
save_$lt_var=\$$lt_var
497
lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
498
lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
510
: ${EGREP="/bin/grep -E"}
511
: ${FGREP="/bin/grep -F"}
512
: ${GREP="/bin/grep"}
519
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
520
: ${Xsed="$SED -e 1s/^X//"}
525
EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
526
EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
528
exit_status=$EXIT_SUCCESS
530
# Make sure IFS has a sensible default
535
dirname="s,/[^/]*$,,"
538
# func_dirname_and_basename file append nondir_replacement
539
# perform func_basename and func_dirname in a single function
541
# dirname: Compute the dirname of FILE. If nonempty,
542
# add APPEND to the result, otherwise set result
543
# to NONDIR_REPLACEMENT.
544
# value returned in "$func_dirname_result"
545
# basename: Compute filename of FILE.
546
# value retuned in "$func_basename_result"
547
# Implementation must be kept synchronized with func_dirname
548
# and func_basename. For efficiency, we do not delegate to
549
# those functions but instead duplicate the functionality here.
550
func_dirname_and_basename ()
552
# Extract subdirectory from the argument.
553
func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
554
if test "X$func_dirname_result" = "X${1}"; then
555
func_dirname_result="${3}"
557
func_dirname_result="$func_dirname_result${2}"
559
func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
562
# Generated shell functions inserted here.
564
# func_dirname file append nondir_replacement
565
# Compute the dirname of FILE. If nonempty, add APPEND to the result,
566
# otherwise set result to NONDIR_REPLACEMENT.
570
*/*) func_dirname_result="${1%/*}${2}" ;;
571
* ) func_dirname_result="${3}" ;;
578
func_basename_result="${1##*/}"
581
# func_dirname_and_basename file append nondir_replacement
582
# perform func_basename and func_dirname in a single function
584
# dirname: Compute the dirname of FILE. If nonempty,
585
# add APPEND to the result, otherwise set result
586
# to NONDIR_REPLACEMENT.
587
# value returned in "$func_dirname_result"
588
# basename: Compute filename of FILE.
589
# value retuned in "$func_basename_result"
590
# Implementation must be kept synchronized with func_dirname
591
# and func_basename. For efficiency, we do not delegate to
592
# those functions but instead duplicate the functionality here.
593
func_dirname_and_basename ()
596
*/*) func_dirname_result="${1%/*}${2}" ;;
597
* ) func_dirname_result="${3}" ;;
599
func_basename_result="${1##*/}"
602
# func_stripname prefix suffix name
603
# strip PREFIX and SUFFIX off of NAME.
604
# PREFIX and SUFFIX must not contain globbing or regex special
605
# characters, hashes, percent signs, but SUFFIX may contain a leading
606
# dot (in which case that matches only a dot).
609
# pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
610
# positional parameters, so assign one to ordinary parameter first.
611
func_stripname_result=${3}
612
func_stripname_result=${func_stripname_result#"${1}"}
613
func_stripname_result=${func_stripname_result%"${2}"}
619
func_opt_split_opt=${1%%=*}
620
func_opt_split_arg=${1#*=}
627
*.lo) func_lo2o_result=${1%.lo}.${objext} ;;
628
*) func_lo2o_result=${1} ;;
632
# func_xform libobj-or-source
635
func_xform_result=${1%.*}.lo
638
# func_arith arithmetic-term...
641
func_arith_result=$(( $* ))
645
# STRING may not start with a hyphen.
648
func_len_result=${#1}
652
# func_append var value
653
# Append VALUE to the end of shell variable VAR.
658
# Generated shell functions inserted here.
660
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
661
# is ksh but when the shell is invoked as "sh" and the current value of
662
# the _XPG environment variable is not equal to 1 (one), the special
663
# positional parameter $0, within a function call, is the name of the
667
# The name of this program:
668
# In the unlikely event $progname began with a '-', it would play havoc with
669
# func_echo (imagine progname=-n), so we prepend ./ in that case:
670
func_dirname_and_basename "$progpath"
671
progname=$func_basename_result
673
-*) progname=./$progname ;;
676
# Make sure we have an absolute path for reexecution:
678
[\\/]*|[A-Za-z]:\\*) ;;
680
progdir=$func_dirname_result
681
progdir=`cd "$progdir" && pwd`
682
progpath="$progdir/$progname"
687
for progdir in $PATH; do
689
test -x "$progdir/$progname" && break
692
test -n "$progdir" || progdir=`pwd`
693
progpath="$progdir/$progname"
697
# Sed substitution that helps us do robust quoting. It backslashifies
698
# metacharacters that are still active within double-quoted strings.
699
Xsed="${SED}"' -e 1s/^X//'
700
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
702
# Same as above, but do not quote variable references.
703
double_quote_subst='s/\(["`\\]\)/\\\1/g'
705
# Re-`\' parameter expansions in output of double_quote_subst that were
706
# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
707
# in input to double_quote_subst, that '$' was protected from expansion.
708
# Since each input `\' is now two `\'s, look for any number of runs of
709
# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
714
sed_double_backslash="\
718
s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
729
# Echo program name prefixed message, along with the current mode
730
# name if it has been set yet.
733
$ECHO "$progname${mode+: }$mode: $*"
736
# func_verbose arg...
737
# Echo program name prefixed message in verbose mode only.
740
$opt_verbose && func_echo ${1+"$@"}
742
# A bug in bash halts the script if the last line of a function
743
# fails when set -e is in force, so we need another command to
749
# Echo program name prefixed message to standard error.
752
$ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
755
# func_warning arg...
756
# Echo program name prefixed warning message to standard error.
759
$opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
765
# func_fatal_error arg...
766
# Echo program name prefixed message to standard error, and exit.
773
# func_fatal_help arg...
774
# Echo program name prefixed message to standard error, followed by
775
# a help hint, and exit.
779
func_fatal_error "$help"
781
help="Try \`$progname --help' for more information." ## default
784
# func_grep expression filename
785
# Check whether EXPRESSION matches any line of FILENAME, without output.
788
$GREP "$1" "$2" >/dev/null 2>&1
792
# func_mkdir_p directory-path
793
# Make sure the entire path to DIRECTORY-PATH is available.
796
my_directory_path="$1"
799
if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
801
# Protect directory names starting with `-'
802
case $my_directory_path in
803
-*) my_directory_path="./$my_directory_path" ;;
806
# While some portion of DIR does not yet exist...
807
while test ! -d "$my_directory_path"; do
808
# ...make a list in topmost first order. Use a colon delimited
809
# list incase some portion of path contains whitespace.
810
my_dir_list="$my_directory_path:$my_dir_list"
812
# If the last portion added has no slash in it, the list is done
813
case $my_directory_path in */*) ;; *) break ;; esac
815
# ...otherwise throw away the child directory and loop
816
my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
818
my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
820
save_mkdir_p_IFS="$IFS"; IFS=':'
821
for my_dir in $my_dir_list; do
822
IFS="$save_mkdir_p_IFS"
823
# mkdir can fail with a `File exist' error if two processes
824
# try to create one of the directories concurrently. Don't
826
$MKDIR "$my_dir" 2>/dev/null || :
828
IFS="$save_mkdir_p_IFS"
830
# Bail out if we (or some other process) failed to create a directory.
831
test -d "$my_directory_path" || \
832
func_fatal_error "Failed to create \`$1'"
837
# func_mktempdir [string]
838
# Make a temporary directory that won't clash with other running
839
# libtool processes, and avoids race conditions if possible. If
840
# given, STRING is the basename for that directory.
843
my_template="${TMPDIR-/tmp}/${1-$progname}"
845
if test "$opt_dry_run" = ":"; then
846
# Return a directory name, but don't create it in dry-run mode
847
my_tmpdir="${my_template}-$$"
850
# If mktemp works, use that first and foremost
851
my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
853
if test ! -d "$my_tmpdir"; then
854
# Failing that, at least try and use $RANDOM to avoid a race
855
my_tmpdir="${my_template}-${RANDOM-0}$$"
857
save_mktempdir_umask=`umask`
860
umask $save_mktempdir_umask
863
# If we're not in dry-run mode, bomb out on failure
864
test -d "$my_tmpdir" || \
865
func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
868
$ECHO "X$my_tmpdir" | $Xsed
872
# func_quote_for_eval arg
873
# Aesthetically quote ARG to be evaled later.
874
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
875
# is double-quoted, suitable for a subsequent eval, whereas
876
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
877
# which are still active within double quotes backslashified.
878
func_quote_for_eval ()
882
func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
884
func_quote_for_eval_unquoted_result="$1" ;;
887
case $func_quote_for_eval_unquoted_result in
888
# Double-quote args containing shell metacharacters to delay
889
# word splitting, command substitution and and variable
890
# expansion for a subsequent eval.
891
# Many Bourne shells cannot handle close brackets correctly
892
# in scan sets, so we specify it separately.
893
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
894
func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
897
func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
902
# func_quote_for_expand arg
903
# Aesthetically quote ARG to be evaled later; same as above,
904
# but do not quote variable references.
905
func_quote_for_expand ()
909
my_arg=`$ECHO "X$1" | $Xsed \
910
-e "$double_quote_subst" -e "$sed_double_backslash"` ;;
916
# Double-quote args containing shell metacharacters to delay
917
# word splitting and command substitution for a subsequent eval.
918
# Many Bourne shells cannot handle close brackets correctly
919
# in scan sets, so we specify it separately.
920
*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
925
func_quote_for_expand_result="$my_arg"
929
# func_show_eval cmd [fail_exp]
930
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
931
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
932
# is given, then evaluate it.
938
${opt_silent-false} || {
939
func_quote_for_expand "$my_cmd"
940
eval "func_echo $func_quote_for_expand_result"
943
if ${opt_dry_run-false}; then :; else
946
if test "$my_status" -eq 0; then :; else
947
eval "(exit $my_status); $my_fail_exp"
953
# func_show_eval_locale cmd [fail_exp]
954
# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
955
# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
956
# is given, then evaluate it. Use the saved locale for evaluation.
957
func_show_eval_locale ()
962
${opt_silent-false} || {
963
func_quote_for_expand "$my_cmd"
964
eval "func_echo $func_quote_for_expand_result"
967
if ${opt_dry_run-false}; then :; else
968
eval "$lt_user_locale
971
eval "$lt_safe_locale"
972
if test "$my_status" -eq 0; then :; else
973
eval "(exit $my_status); $my_fail_exp"
983
# Echo version message to standard output and exit.
986
$SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
989
s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
996
# Echo short help message to standard output and exit.
999
$SED -n '/^# Usage:/,/# -h/ {
1002
s/\$progname/'$progname'/
1006
$ECHO "run \`$progname --help | more' for full usage"
1011
# Echo long help message to standard output and exit.
1014
$SED -n '/^# Usage:/,/# Report bugs to/ {
1017
s*\$progname*'$progname'*
1019
s*\$SHELL*'"$SHELL"'*
1021
s*\$LTCFLAGS*'"$LTCFLAGS"'*
1023
s/\$with_gnu_ld/'"$with_gnu_ld"'/
1024
s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1025
s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1031
# func_missing_arg argname
1032
# Echo program name prefixed message to standard error and set global
1036
func_error "missing argument for $1"
1046
# Check that we have a working $ECHO.
1047
if test "X$1" = X--no-reexec; then
1048
# Discard the --no-reexec flag, and continue.
1050
elif test "X$1" = X--fallback-echo; then
1051
# Avoid inline document here, it may be left over
1053
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
1054
# Yippee, $ECHO works!
1057
# Restart under the correct shell, and then maybe $ECHO will work.
1058
exec $SHELL "$progpath" --no-reexec ${1+"$@"}
1061
if test "X$1" = X--fallback-echo; then
1062
# used as fallback echo
1070
magic="%%%MAGIC variable%%%"
1071
magic_exe="%%%MAGIC EXE variable%%%"
1078
lo2o="s/\\.lo\$/.${objext}/"
1079
o2lo="s/\\.${objext}\$/.lo/"
1084
opt_duplicate_deps=false
1088
# If this variable is set in any of the actions, the command in it
1089
# will be execed at the end. This prevents here-documents from being
1090
# left over by shells.
1093
# func_fatal_configuration arg...
1094
# Echo program name prefixed message to standard error, followed by
1095
# a configuration failure hint, and exit.
1096
func_fatal_configuration ()
1098
func_error ${1+"$@"}
1099
func_error "See the $PACKAGE documentation for more information."
1100
func_fatal_error "Fatal configuration error."
1105
# Display the configuration for all the tags in this script.
1108
re_begincf='^# ### BEGIN LIBTOOL'
1109
re_endcf='^# ### END LIBTOOL'
1111
# Default configuration.
1112
$SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1114
# Now print the configurations for the tags.
1115
for tagname in $taglist; do
1116
$SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1123
# Display the features supported by this script.
1127
if test "$build_libtool_libs" = yes; then
1128
$ECHO "enable shared libraries"
1130
$ECHO "disable shared libraries"
1132
if test "$build_old_libs" = yes; then
1133
$ECHO "enable static libraries"
1135
$ECHO "disable static libraries"
1141
# func_enable_tag tagname
1142
# Verify that TAGNAME is valid, and either flag an error and exit, or
1143
# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
1150
re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1151
re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1152
sed_extractcf="/$re_begincf/,/$re_endcf/p"
1157
func_fatal_error "invalid tag name: $tagname"
1161
# Don't test for the "default" C tag, as we know it's
1162
# there but not specially marked.
1166
if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1167
taglist="$taglist $tagname"
1169
# Evaluate the configuration. Be careful to quote the path
1170
# and the sed script, to avoid splitting on whitespace, but
1171
# also don't use non-portable quotes within backquotes within
1172
# quotes we have to do it in 2 steps:
1173
extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1176
func_error "ignoring unknown tag $tagname"
1182
# Parse options once, thoroughly. This comes as soon as possible in
1183
# the script to make things like `libtool --version' happen quickly.
1186
# Shorthand for --mode=foo, only valid as the first argument
1189
shift; set dummy --mode clean ${1+"$@"}; shift
1191
compile|compil|compi|comp|com|co|c)
1192
shift; set dummy --mode compile ${1+"$@"}; shift
1194
execute|execut|execu|exec|exe|ex|e)
1195
shift; set dummy --mode execute ${1+"$@"}; shift
1197
finish|finis|fini|fin|fi|f)
1198
shift; set dummy --mode finish ${1+"$@"}; shift
1200
install|instal|insta|inst|ins|in|i)
1201
shift; set dummy --mode install ${1+"$@"}; shift
1204
shift; set dummy --mode link ${1+"$@"}; shift
1206
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1207
shift; set dummy --mode uninstall ${1+"$@"}; shift
1211
# Parse non-mode specific arguments:
1212
while test "$#" -gt 0; do
1217
--config) func_config ;;
1219
--debug) preserve_args="$preserve_args $opt"
1220
func_echo "enabling shell trace mode"
1225
-dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
1226
execute_dlfiles="$execute_dlfiles $1"
1230
--dry-run | -n) opt_dry_run=: ;;
1231
--features) func_features ;;
1232
--finish) mode="finish" ;;
1234
--mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
1236
# Valid mode arguments:
1246
# Catch anything else as an error
1247
*) func_error "invalid argument for $opt"
1257
--preserve-dup-deps)
1258
opt_duplicate_deps=: ;;
1260
--quiet|--silent) preserve_args="$preserve_args $opt"
1264
--verbose| -v) preserve_args="$preserve_args $opt"
1268
--tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
1269
preserve_args="$preserve_args $opt $1"
1270
func_enable_tag "$1" # tagname is set here
1274
# Separate optargs to long options:
1275
-dlopen=*|--mode=*|--tag=*)
1276
func_opt_split "$opt"
1277
set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
1281
-\?|-h) func_usage ;;
1282
--help) opt_help=: ;;
1283
--version) func_version ;;
1285
-*) func_fatal_help "unrecognized option \`$opt'" ;;
1295
*cygwin* | *mingw* | *pw32* | *cegcc*)
1296
# don't eliminate duplications in $postdeps and $predeps
1297
opt_duplicate_compiler_generated_deps=:
1300
opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
1304
# Having warned about all mis-specified options, bail out if
1305
# anything was wrong.
1306
$exit_cmd $EXIT_FAILURE
1309
# func_check_version_match
1310
# Ensure that we are using m4 macros, and libtool script from the same
1311
# release of libtool.
1312
func_check_version_match ()
1314
if test "$package_revision" != "$macro_revision"; then
1315
if test "$VERSION" != "$macro_version"; then
1316
if test -z "$macro_version"; then
1318
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1319
$progname: definition of this LT_INIT comes from an older release.
1320
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1321
$progname: and run autoconf again.
1325
$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1326
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1327
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1328
$progname: and run autoconf again.
1333
$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1334
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
1335
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
1336
$progname: of $PACKAGE $VERSION and run autoconf again.
1350
# Sanity checks first:
1351
func_check_version_match
1353
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1354
func_fatal_configuration "not configured to build any kind of library"
1357
test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1361
eval std_shrext=\"$shrext_cmds\"
1364
# Only execute mode is allowed to have -dlopen flags.
1365
if test -n "$execute_dlfiles" && test "$mode" != execute; then
1366
func_error "unrecognized option \`-dlopen'"
1371
# Change the help message to a mode-specific one.
1372
generic_help="$help"
1373
help="Try \`$progname --help --mode=$mode' for more information."
1378
# True iff FILE is a libtool `.la' library or `.lo' object file.
1379
# This function is only a basic sanity check; it will hardly flush out
1380
# determined imposters.
1384
$SED -e 4q "$1" 2>/dev/null \
1385
| $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1388
# func_lalib_unsafe_p file
1389
# True iff FILE is a libtool `.la' library or `.lo' object file.
1390
# This function implements the same check as func_lalib_p without
1391
# resorting to external programs. To this end, it redirects stdin and
1392
# closes it afterwards, without saving the original file descriptor.
1393
# As a safety measure, use it only where a negative result would be
1394
# fatal anyway. Works if `file' does not exist.
1395
func_lalib_unsafe_p ()
1398
if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1399
for lalib_p_l in 1 2 3 4
1402
case "$lalib_p_line" in
1403
\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1408
test "$lalib_p" = yes
1411
# func_ltwrapper_script_p file
1412
# True iff FILE is a libtool wrapper script
1413
# This function is only a basic sanity check; it will hardly flush out
1414
# determined imposters.
1415
func_ltwrapper_script_p ()
1420
# func_ltwrapper_executable_p file
1421
# True iff FILE is a libtool wrapper executable
1422
# This function is only a basic sanity check; it will hardly flush out
1423
# determined imposters.
1424
func_ltwrapper_executable_p ()
1426
func_ltwrapper_exec_suffix=
1429
*) func_ltwrapper_exec_suffix=.exe ;;
1431
$GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1434
# func_ltwrapper_scriptname file
1435
# Assumes file is an ltwrapper_executable
1436
# uses $file to determine the appropriate filename for a
1437
# temporary ltwrapper_script.
1438
func_ltwrapper_scriptname ()
1440
func_ltwrapper_scriptname_result=""
1441
if func_ltwrapper_executable_p "$1"; then
1442
func_dirname_and_basename "$1" "" "."
1443
func_stripname '' '.exe' "$func_basename_result"
1444
func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1448
# func_ltwrapper_p file
1449
# True iff FILE is a libtool wrapper script or wrapper executable
1450
# This function is only a basic sanity check; it will hardly flush out
1451
# determined imposters.
1454
func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1458
# func_execute_cmds commands fail_cmd
1459
# Execute tilde-delimited COMMANDS.
1460
# If FAIL_CMD is given, eval that upon failure.
1461
# FAIL_CMD may read-access the current command in variable CMD!
1462
func_execute_cmds ()
1465
save_ifs=$IFS; IFS='~'
1469
func_show_eval "$cmd" "${2-:}"
1476
# Source FILE, adding directory component if necessary.
1477
# Note that it is not necessary on cygwin/mingw to append a dot to
1478
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1479
# behavior happens only for exec(3), not for open(2)! Also, sourcing
1480
# `FILE.' does not work on cygwin managed mounts.
1485
*/* | *\\*) . "$1" ;;
1491
# func_infer_tag arg
1492
# Infer tagged configuration to use if any are available and
1493
# if one wasn't chosen via the "--tag" command line option.
1494
# Only attempt this if the compiler in the base compile
1495
# command doesn't match the default compiler.
1496
# arg is usually of the form 'gcc ...'
1500
if test -n "$available_tags" && test -z "$tagname"; then
1503
func_quote_for_eval "$arg"
1504
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1507
# Blanks in the command may have been stripped by the calling shell,
1508
# but not from the CC environment variable when configure was run.
1509
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1510
# Blanks at the start of $base_compile will cause this to fail
1511
# if we don't check for them as well.
1513
for z in $available_tags; do
1514
if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1515
# Evaluate the configuration.
1516
eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1519
# Double-quote args containing other shell metacharacters.
1520
func_quote_for_eval "$arg"
1521
CC_quoted="$CC_quoted $func_quote_for_eval_result"
1524
" $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1525
# The compiler in the base compile command matches
1526
# the one in the tagged configuration.
1527
# Assume this is the tagged configuration we want.
1534
# If $tagname still isn't set, then no tagged configuration
1535
# was found and let the user know that the "--tag" command
1536
# line option must be used.
1537
if test -z "$tagname"; then
1538
func_echo "unable to infer tagged configuration"
1539
func_fatal_error "specify a tag with \`--tag'"
1541
# func_verbose "using $tagname tagged configuration"
1550
# func_write_libtool_object output_name pic_name nonpic_name
1551
# Create a libtool object file (analogous to a ".la" file),
1552
# but don't create it if we're doing a dry run.
1553
func_write_libtool_object ()
1556
if test "$build_libtool_libs" = yes; then
1562
if test "$build_old_libs" = yes; then
1563
write_oldobj=\'${3}\'
1569
cat >${write_libobj}T <<EOF
1570
# $write_libobj - a libtool object file
1571
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1573
# Please DO NOT delete this file!
1574
# It is necessary for linking the library.
1576
# Name of the PIC object.
1577
pic_object=$write_lobj
1579
# Name of the non-PIC object
1580
non_pic_object=$write_oldobj
1583
$MV "${write_libobj}T" "${write_libobj}"
1587
# func_mode_compile arg...
1588
func_mode_compile ()
1591
# Get the compilation command and the source file.
1593
srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1605
# do not "continue". Instead, add this to base_compile
1617
# Accept any command-line options.
1620
test -n "$libobj" && \
1621
func_fatal_error "you cannot specify \`-o' more than once"
1626
-pie | -fpie | -fPIE)
1627
pie_flag="$pie_flag $arg"
1631
-shared | -static | -prefer-pic | -prefer-non-pic)
1642
arg_mode=arg # the next one goes into the "base_compile" arg list
1643
continue # The current "srcfile" will either be retained or
1644
;; # replaced later. I would guess that would be a bug.
1647
func_stripname '-Wc,' '' "$arg"
1648
args=$func_stripname_result
1650
save_ifs="$IFS"; IFS=','
1651
for arg in $args; do
1653
func_quote_for_eval "$arg"
1654
lastarg="$lastarg $func_quote_for_eval_result"
1657
func_stripname ' ' '' "$lastarg"
1658
lastarg=$func_stripname_result
1660
# Add the arguments to base_compile.
1661
base_compile="$base_compile $lastarg"
1666
# Accept the current argument as the source file.
1667
# The previous "srcfile" becomes the current argument.
1674
esac # case $arg_mode
1676
# Aesthetically quote the previous argument.
1677
func_quote_for_eval "$lastarg"
1678
base_compile="$base_compile $func_quote_for_eval_result"
1683
func_fatal_error "you must specify an argument for -Xcompile"
1686
func_fatal_error "you must specify a target with \`-o'"
1689
# Get the name of the library object.
1690
test -z "$libobj" && {
1691
func_basename "$srcfile"
1692
libobj="$func_basename_result"
1697
# Recognize several different file suffixes.
1698
# If the user specifies -o file.o, it is replaced with file.lo
1701
*.ada | *.adb | *.ads | *.asm | \
1702
*.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1703
*.[fF][09]? | *.for | *.java | *.obj | *.sx)
1704
func_xform "$libobj"
1705
libobj=$func_xform_result
1710
*.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1712
func_fatal_error "cannot determine name of library object from \`$libobj'"
1716
func_infer_tag $base_compile
1718
for arg in $later; do
1721
test "$build_libtool_libs" != yes && \
1722
func_fatal_configuration "can not build a shared library"
1728
build_libtool_libs=no
1745
func_quote_for_eval "$libobj"
1746
test "X$libobj" != "X$func_quote_for_eval_result" \
1747
&& $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1748
&& func_warning "libobj name \`$libobj' may not contain shell special characters."
1749
func_dirname_and_basename "$obj" "/" ""
1750
objname="$func_basename_result"
1751
xdir="$func_dirname_result"
1752
lobj=${xdir}$objdir/$objname
1754
test -z "$base_compile" && \
1755
func_fatal_help "you must specify a compilation command"
1757
# Delete any leftover library objects.
1758
if test "$build_old_libs" = yes; then
1759
removelist="$obj $lobj $libobj ${libobj}T"
1761
removelist="$lobj $libobj ${libobj}T"
1764
# On Cygwin there's no "real" PIC flag so we must build both object types
1766
cygwin* | mingw* | pw32* | os2* | cegcc*)
1770
if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1771
# non-PIC code in shared libraries is not supported
1775
# Calculate the filename of the output object if compiler does
1776
# not support -o with -c
1777
if test "$compiler_c_o" = no; then
1778
output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1779
lockfile="$output_obj.lock"
1786
# Lock this critical section if it is needed
1787
# We use this script file to make the link, it avoids creating a new file
1788
if test "$need_locks" = yes; then
1789
until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1790
func_echo "Waiting for $lockfile to be removed"
1793
elif test "$need_locks" = warn; then
1794
if test -f "$lockfile"; then
1796
*** ERROR, $lockfile exists and contains:
1797
`cat $lockfile 2>/dev/null`
1799
This indicates that another process is trying to use the same
1800
temporary object file, and libtool could not work around it because
1801
your compiler does not support \`-c' and \`-o' together. If you
1802
repeat this compilation, it may succeed, by chance, but you had better
1803
avoid parallel builds (make -j) in this platform, or get a better
1806
$opt_dry_run || $RM $removelist
1809
removelist="$removelist $output_obj"
1810
$ECHO "$srcfile" > "$lockfile"
1813
$opt_dry_run || $RM $removelist
1814
removelist="$removelist $lockfile"
1815
trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1817
if test -n "$fix_srcfile_path"; then
1818
eval srcfile=\"$fix_srcfile_path\"
1820
func_quote_for_eval "$srcfile"
1821
qsrcfile=$func_quote_for_eval_result
1823
# Only build a PIC object if we are building libtool libraries.
1824
if test "$build_libtool_libs" = yes; then
1825
# Without this assignment, base_compile gets emptied.
1826
fbsd_hideous_sh_bug=$base_compile
1828
if test "$pic_mode" != no; then
1829
command="$base_compile $qsrcfile $pic_flag"
1831
# Don't build PIC code
1832
command="$base_compile $qsrcfile"
1835
func_mkdir_p "$xdir$objdir"
1837
if test -z "$output_obj"; then
1838
# Place PIC objects in $objdir
1839
command="$command -o $lobj"
1842
func_show_eval_locale "$command" \
1843
'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1845
if test "$need_locks" = warn &&
1846
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1848
*** ERROR, $lockfile contains:
1849
`cat $lockfile 2>/dev/null`
1851
but it should contain:
1854
This indicates that another process is trying to use the same
1855
temporary object file, and libtool could not work around it because
1856
your compiler does not support \`-c' and \`-o' together. If you
1857
repeat this compilation, it may succeed, by chance, but you had better
1858
avoid parallel builds (make -j) in this platform, or get a better
1861
$opt_dry_run || $RM $removelist
1865
# Just move the object if needed, then go on to compile the next one
1866
if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1867
func_show_eval '$MV "$output_obj" "$lobj"' \
1868
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1871
# Allow error messages only from the first compilation.
1872
if test "$suppress_opt" = yes; then
1873
suppress_output=' >/dev/null 2>&1'
1877
# Only build a position-dependent object if we build old libraries.
1878
if test "$build_old_libs" = yes; then
1879
if test "$pic_mode" != yes; then
1880
# Don't build PIC code
1881
command="$base_compile $qsrcfile$pie_flag"
1883
command="$base_compile $qsrcfile $pic_flag"
1885
if test "$compiler_c_o" = yes; then
1886
command="$command -o $obj"
1889
# Suppress compiler output if we already did a PIC compilation.
1890
command="$command$suppress_output"
1891
func_show_eval_locale "$command" \
1892
'$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1894
if test "$need_locks" = warn &&
1895
test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1897
*** ERROR, $lockfile contains:
1898
`cat $lockfile 2>/dev/null`
1900
but it should contain:
1903
This indicates that another process is trying to use the same
1904
temporary object file, and libtool could not work around it because
1905
your compiler does not support \`-c' and \`-o' together. If you
1906
repeat this compilation, it may succeed, by chance, but you had better
1907
avoid parallel builds (make -j) in this platform, or get a better
1910
$opt_dry_run || $RM $removelist
1914
# Just move the object if needed
1915
if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1916
func_show_eval '$MV "$output_obj" "$obj"' \
1917
'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1922
func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1924
# Unlock the critical section if it was locked
1925
if test "$need_locks" != no; then
1926
removelist=$lockfile
1935
test "$mode" = compile && func_mode_compile ${1+"$@"}
1940
# We need to display help for each of the modes.
1943
# Generic help is extracted from the usage comments
1944
# at the start of this file.
1950
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1952
Remove files from the build directory.
1954
RM is the name of the program to use to delete files associated with each FILE
1955
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1958
If FILE is a libtool library, object or program, all the files associated
1959
with it are deleted. Otherwise, only FILE itself is deleted using RM."
1964
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1966
Compile a source file into a libtool library object.
1968
This mode accepts the following additional options:
1970
-o OUTPUT-FILE set the output file name to OUTPUT-FILE
1971
-no-suppress do not suppress compiler output for multiple passes
1972
-prefer-pic try to building PIC objects only
1973
-prefer-non-pic try to building non-PIC objects only
1974
-shared do not build a \`.o' file suitable for static linking
1975
-static only build a \`.o' file suitable for static linking
1977
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1978
from the given SOURCEFILE.
1980
The output file name is determined by removing the directory component from
1981
SOURCEFILE, then substituting the C source code suffix \`.c' with the
1982
library object suffix, \`.lo'."
1987
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1989
Automatically set library path, then run a program.
1991
This mode accepts the following additional options:
1993
-dlopen FILE add the directory containing FILE to the library path
1995
This mode sets the library path environment variable according to \`-dlopen'
1998
If any of the ARGS are libtool executable wrappers, then they are translated
1999
into their corresponding uninstalled binary, and any of their required library
2000
directories are added to the library path.
2002
Then, COMMAND is executed, with ARGS as arguments."
2007
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2009
Complete the installation of libtool libraries.
2011
Each LIBDIR is a directory that contains libtool libraries.
2013
The commands that this mode executes may require superuser privileges. Use
2014
the \`--dry-run' option if you just want to see what would be executed."
2019
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2021
Install executables or libraries.
2023
INSTALL-COMMAND is the installation command. The first component should be
2024
either the \`install' or \`cp' program.
2026
The following components of INSTALL-COMMAND are treated specially:
2028
-inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2030
The rest of the components are interpreted as arguments to that command (only
2031
BSD-compatible install options are recognized)."
2036
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2038
Link object files or libraries together to form another library, or to
2039
create an executable program.
2041
LINK-COMMAND is a command using the C compiler that you would use to create
2042
a program from several object files.
2044
The following components of LINK-COMMAND are treated specially:
2046
-all-static do not do any dynamic linking at all
2047
-avoid-version do not add a version suffix if possible
2048
-dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2049
-dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2050
-export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2051
-export-symbols SYMFILE
2052
try to export only the symbols listed in SYMFILE
2053
-export-symbols-regex REGEX
2054
try to export only the symbols matching REGEX
2055
-LLIBDIR search LIBDIR for required installed libraries
2056
-lNAME OUTPUT-FILE requires the installed library libNAME
2057
-module build a library that can dlopened
2058
-no-fast-install disable the fast-install mode
2059
-no-install link a not-installable executable
2060
-no-undefined declare that a library does not refer to external symbols
2061
-o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2062
-objectlist FILE Use a list of object files found in FILE to specify objects
2063
-precious-files-regex REGEX
2064
don't remove output files matching REGEX
2065
-release RELEASE specify package release information
2066
-rpath LIBDIR the created library will eventually be installed in LIBDIR
2067
-R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2068
-shared only do dynamic linking of libtool libraries
2069
-shrext SUFFIX override the standard shared library file extension
2070
-static do not do any dynamic linking of uninstalled libtool libraries
2071
-static-libtool-libs
2072
do not do any dynamic linking of libtool libraries
2073
-version-info CURRENT[:REVISION[:AGE]]
2074
specify library version info [each variable defaults to 0]
2075
-weak LIBNAME declare that the target provides the LIBNAME interface
2077
All other options (arguments beginning with \`-') are ignored.
2079
Every other argument is treated as a filename. Files ending in \`.la' are
2080
treated as uninstalled libtool libraries, other files are standard or library
2083
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2084
only library objects (\`.lo' files) may be specified, and \`-rpath' is
2085
required, except when creating a convenience library.
2087
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2088
using \`ar' and \`ranlib', or on Windows using \`lib'.
2090
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2091
is created, otherwise an executable program is created."
2096
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2098
Remove libraries from an installation directory.
2100
RM is the name of the program to use to delete files associated with each FILE
2101
(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2104
If FILE is a libtool library, all the files associated with it are deleted.
2105
Otherwise, only FILE itself is deleted using RM."
2109
func_fatal_help "invalid operation mode \`$mode'"
2114
$ECHO "Try \`$progname --help' for more information about other modes."
2119
# Now that we've collected a possible --mode arg, show help if necessary
2120
$opt_help && func_mode_help
2123
# func_mode_execute arg...
2124
func_mode_execute ()
2127
# The first argument is the command name.
2130
func_fatal_help "you must specify a COMMAND"
2132
# Handle -dlopen flags immediately.
2133
for file in $execute_dlfiles; do
2135
|| func_fatal_help "\`$file' is not a file"
2140
# Check to see that this really is a libtool archive.
2141
func_lalib_unsafe_p "$file" \
2142
|| func_fatal_help "\`$lib' is not a valid libtool archive"
2144
# Read the libtool library.
2149
# Skip this library if it cannot be dlopened.
2150
if test -z "$dlname"; then
2151
# Warn if it was a shared library.
2152
test -n "$library_names" && \
2153
func_warning "\`$file' was not linked with \`-export-dynamic'"
2157
func_dirname "$file" "" "."
2158
dir="$func_dirname_result"
2160
if test -f "$dir/$objdir/$dlname"; then
2163
if test ! -f "$dir/$dlname"; then
2164
func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2170
# Just add the directory containing the .lo file.
2171
func_dirname "$file" "" "."
2172
dir="$func_dirname_result"
2176
func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2181
# Get the absolute pathname.
2182
absdir=`cd "$dir" && pwd`
2183
test -n "$absdir" && dir="$absdir"
2185
# Now add the directory to shlibpath_var.
2186
if eval "test -z \"\$$shlibpath_var\""; then
2187
eval "$shlibpath_var=\"\$dir\""
2189
eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2193
# This variable tells wrapper scripts just to set shlibpath_var
2194
# rather than running their programs.
2195
libtool_execute_magic="$magic"
2197
# Check if any of the arguments is a wrapper script.
2204
# Do a test to see if this is really a libtool program.
2205
if func_ltwrapper_script_p "$file"; then
2207
# Transform arg to wrapped name.
2208
file="$progdir/$program"
2209
elif func_ltwrapper_executable_p "$file"; then
2210
func_ltwrapper_scriptname "$file"
2211
func_source "$func_ltwrapper_scriptname_result"
2212
# Transform arg to wrapped name.
2213
file="$progdir/$program"
2217
# Quote arguments (to preserve shell metacharacters).
2218
func_quote_for_eval "$file"
2219
args="$args $func_quote_for_eval_result"
2222
if test "X$opt_dry_run" = Xfalse; then
2223
if test -n "$shlibpath_var"; then
2224
# Export the shlibpath_var.
2225
eval "export $shlibpath_var"
2228
# Restore saved environment variables
2229
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2231
eval "if test \"\${save_$lt_var+set}\" = set; then
2232
$lt_var=\$save_$lt_var; export $lt_var
2238
# Now prepare to actually exec the command.
2239
exec_cmd="\$cmd$args"
2241
# Display what would be done.
2242
if test -n "$shlibpath_var"; then
2243
eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2244
$ECHO "export $shlibpath_var"
2251
test "$mode" = execute && func_mode_execute ${1+"$@"}
2254
# func_mode_finish arg...
2261
if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2264
libdirs="$libdirs $dir"
2267
for libdir in $libdirs; do
2268
if test -n "$finish_cmds"; then
2269
# Do each command in the finish commands.
2270
func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2273
if test -n "$finish_eval"; then
2274
# Do the single finish_eval.
2275
eval cmds=\"$finish_eval\"
2276
$opt_dry_run || eval "$cmds" || admincmds="$admincmds
2282
# Exit here if they wanted silent mode.
2283
$opt_silent && exit $EXIT_SUCCESS
2285
$ECHO "X----------------------------------------------------------------------" | $Xsed
2286
$ECHO "Libraries have been installed in:"
2287
for libdir in $libdirs; do
2291
$ECHO "If you ever happen to want to link against installed libraries"
2292
$ECHO "in a given directory, LIBDIR, you must either use libtool, and"
2293
$ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
2294
$ECHO "flag during linking and do at least one of the following:"
2295
if test -n "$shlibpath_var"; then
2296
$ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
2297
$ECHO " during execution"
2299
if test -n "$runpath_var"; then
2300
$ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
2301
$ECHO " during linking"
2303
if test -n "$hardcode_libdir_flag_spec"; then
2305
eval flag=\"$hardcode_libdir_flag_spec\"
2307
$ECHO " - use the \`$flag' linker flag"
2309
if test -n "$admincmds"; then
2310
$ECHO " - have your system administrator run these commands:$admincmds"
2312
if test -f /etc/ld.so.conf; then
2313
$ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2317
$ECHO "See any operating system documentation about shared libraries for"
2319
solaris2.[6789]|solaris2.1[0-9])
2320
$ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2324
$ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
2327
$ECHO "X----------------------------------------------------------------------" | $Xsed
2331
test "$mode" = finish && func_mode_finish ${1+"$@"}
2334
# func_mode_install arg...
2335
func_mode_install ()
2338
# There may be an optional sh(1) argument at the beginning of
2339
# install_prog (especially on Windows NT).
2340
if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2341
# Allow the use of GNU shtool's install command.
2342
$ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2343
# Aesthetically quote it.
2344
func_quote_for_eval "$nonopt"
2345
install_prog="$func_quote_for_eval_result "
2353
# The real first argument should be the name of the installation program.
2354
# Aesthetically quote it.
2355
func_quote_for_eval "$arg"
2356
install_prog="$install_prog$func_quote_for_eval_result"
2358
# We need to accept at least all the BSD install flags.
2368
if test -n "$dest"; then
2369
files="$files $dest"
2377
case " $install_prog " in
2392
# If the previous option needed an argument, then skip it.
2393
if test -n "$prev"; then
2402
# Aesthetically quote the argument.
2403
func_quote_for_eval "$arg"
2404
install_prog="$install_prog $func_quote_for_eval_result"
2407
test -z "$install_prog" && \
2408
func_fatal_help "you must specify an install program"
2410
test -n "$prev" && \
2411
func_fatal_help "the \`$prev' option requires an argument"
2413
if test -z "$files"; then
2414
if test -z "$dest"; then
2415
func_fatal_help "no file or destination specified"
2417
func_fatal_help "you must specify a destination"
2421
# Strip any trailing slash from the destination.
2422
func_stripname '' '/' "$dest"
2423
dest=$func_stripname_result
2425
# Check to see that the destination is a directory.
2426
test -d "$dest" && isdir=yes
2427
if test "$isdir" = yes; then
2431
func_dirname_and_basename "$dest" "" "."
2432
destdir="$func_dirname_result"
2433
destname="$func_basename_result"
2435
# Not a directory, so check to see that there is only one file specified.
2436
set dummy $files; shift
2437
test "$#" -gt 1 && \
2438
func_fatal_help "\`$dest' is not a directory"
2441
[\\/]* | [A-Za-z]:[\\/]*) ;;
2443
for file in $files; do
2447
func_fatal_help "\`$destdir' must be an absolute directory name"
2454
# This variable tells wrapper scripts just to set variables rather
2455
# than running their programs.
2456
libtool_install_magic="$magic"
2461
for file in $files; do
2463
# Do each installation.
2466
# Do the static libraries later.
2467
staticlibs="$staticlibs $file"
2471
# Check to see that this really is a libtool archive.
2472
func_lalib_unsafe_p "$file" \
2473
|| func_fatal_help "\`$file' is not a valid libtool archive"
2480
# Add the libdir to current_libdirs if it is the destination.
2481
if test "X$destdir" = "X$libdir"; then
2482
case "$current_libdirs " in
2484
*) current_libdirs="$current_libdirs $libdir" ;;
2487
# Note the libdir as a future libdir.
2488
case "$future_libdirs " in
2490
*) future_libdirs="$future_libdirs $libdir" ;;
2494
func_dirname "$file" "/" ""
2495
dir="$func_dirname_result"
2498
if test -n "$relink_command"; then
2499
# Determine the prefix the user has applied to our future dir.
2500
inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2502
# Don't allow the user to place us outside of our expected
2503
# location b/c this prevents finding dependent libraries that
2504
# are installed to the same prefix.
2505
# At present, this check doesn't affect windows .dll's that
2506
# are installed into $libdir/../bin (currently, that works fine)
2507
# but it's something to keep an eye on.
2508
test "$inst_prefix_dir" = "$destdir" && \
2509
func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2511
if test -n "$inst_prefix_dir"; then
2512
# Stick the inst_prefix_dir data into the link command.
2513
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2515
relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2518
func_warning "relinking \`$file'"
2519
func_show_eval "$relink_command" \
2520
'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2523
# See the names of the shared library.
2524
set dummy $library_names; shift
2525
if test -n "$1"; then
2530
test -n "$relink_command" && srcname="$realname"T
2532
# Install the shared library and build the symlinks.
2533
func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2537
cygwin* | mingw* | pw32* | cegcc*)
2545
if test -n "$tstripme" && test -n "$striplib"; then
2546
func_show_eval "$striplib $destdir/$realname" 'exit $?'
2549
if test "$#" -gt 0; then
2550
# Delete the old symlinks, and create new ones.
2551
# Try `ln -sf' first, because the `ln' binary might depend on
2552
# the symlink we replace! Solaris /bin/ln does not understand -f,
2553
# so we also need to try rm && ln -s.
2556
test "$linkname" != "$realname" \
2557
&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2561
# Do each command in the postinstall commands.
2562
lib="$destdir/$realname"
2563
func_execute_cmds "$postinstall_cmds" 'exit $?'
2566
# Install the pseudo-library for information purposes.
2567
func_basename "$file"
2568
name="$func_basename_result"
2569
instname="$dir/$name"i
2570
func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2572
# Maybe install the static library, too.
2573
test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2577
# Install (i.e. copy) a libtool object.
2579
# Figure out destination file name, if it wasn't already specified.
2580
if test -n "$destname"; then
2581
destfile="$destdir/$destname"
2583
func_basename "$file"
2584
destfile="$func_basename_result"
2585
destfile="$destdir/$destfile"
2588
# Deduce the name of the destination old-style object file.
2591
func_lo2o "$destfile"
2592
staticdest=$func_lo2o_result
2595
staticdest="$destfile"
2599
func_fatal_help "cannot copy a libtool object to \`$destfile'"
2603
# Install the libtool object if requested.
2604
test -n "$destfile" && \
2605
func_show_eval "$install_prog $file $destfile" 'exit $?'
2607
# Install the old object if enabled.
2608
if test "$build_old_libs" = yes; then
2609
# Deduce the name of the old-style object file.
2611
staticobj=$func_lo2o_result
2612
func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2618
# Figure out destination file name, if it wasn't already specified.
2619
if test -n "$destname"; then
2620
destfile="$destdir/$destname"
2622
func_basename "$file"
2623
destfile="$func_basename_result"
2624
destfile="$destdir/$destfile"
2627
# If the file is missing, and there is a .exe on the end, strip it
2628
# because it is most likely a libtool script we actually want to
2633
if test ! -f "$file"; then
2634
func_stripname '' '.exe' "$file"
2635
file=$func_stripname_result
2641
# Do a test to see if this is really a libtool program.
2644
if func_ltwrapper_executable_p "$file"; then
2645
func_ltwrapper_scriptname "$file"
2646
wrapper=$func_ltwrapper_scriptname_result
2648
func_stripname '' '.exe' "$file"
2649
wrapper=$func_stripname_result
2656
if func_ltwrapper_script_p "$wrapper"; then
2660
func_source "$wrapper"
2662
# Check the variables that should have been set.
2663
test -z "$generated_by_libtool_version" && \
2664
func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2667
for lib in $notinst_deplibs; do
2668
# Check to see that each library is installed.
2670
if test -f "$lib"; then
2673
libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2674
if test -n "$libdir" && test ! -f "$libfile"; then
2675
func_warning "\`$lib' has not been installed in \`$libdir'"
2681
func_source "$wrapper"
2684
if test "$fast_install" = no && test -n "$relink_command"; then
2686
if test "$finalize" = yes; then
2687
tmpdir=`func_mktempdir`
2688
func_basename "$file$stripped_ext"
2689
file="$func_basename_result"
2690
outputname="$tmpdir/$file"
2691
# Replace the output file specification.
2692
relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2695
func_quote_for_expand "$relink_command"
2696
eval "func_echo $func_quote_for_expand_result"
2698
if eval "$relink_command"; then :
2700
func_error "error: relink \`$file' with the above command before installing it"
2701
$opt_dry_run || ${RM}r "$tmpdir"
2706
func_warning "cannot relink \`$file'"
2710
# Install the binary that we compiled earlier.
2711
file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2715
# remove .exe since cygwin /usr/bin/install will append another
2717
case $install_prog,$host in
2718
*/usr/bin/install*,*cygwin*)
2719
case $file:$destfile in
2724
destfile=$destfile.exe
2727
func_stripname '' '.exe' "$destfile"
2728
destfile=$func_stripname_result
2733
func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2734
$opt_dry_run || if test -n "$outputname"; then
2741
for file in $staticlibs; do
2742
func_basename "$file"
2743
name="$func_basename_result"
2745
# Set up the ranlib parameters.
2746
oldlib="$destdir/$name"
2748
func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2750
if test -n "$stripme" && test -n "$old_striplib"; then
2751
func_show_eval "$old_striplib $oldlib" 'exit $?'
2754
# Do each command in the postinstall commands.
2755
func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2758
test -n "$future_libdirs" && \
2759
func_warning "remember to run \`$progname --finish$future_libdirs'"
2761
if test -n "$current_libdirs"; then
2762
# Maybe just do a dry run.
2763
$opt_dry_run && current_libdirs=" -n$current_libdirs"
2764
exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2770
test "$mode" = install && func_mode_install ${1+"$@"}
2773
# func_generate_dlsyms outputname originator pic_p
2774
# Extract symbols from dlprefiles and create ${outputname}S.o with
2775
# a dlpreopen symbol table.
2776
func_generate_dlsyms ()
2782
my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2785
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2786
if test -n "$NM" && test -n "$global_symbol_pipe"; then
2787
my_dlsyms="${my_outputname}S.c"
2789
func_error "not configured to extract global symbols from dlpreopened files"
2793
if test -n "$my_dlsyms"; then
2797
# Discover the nlist of each of the dlfiles.
2798
nlist="$output_objdir/${my_outputname}.nm"
2800
func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2802
# Parse the name list into a source file.
2803
func_verbose "creating $output_objdir/$my_dlsyms"
2805
$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2806
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2807
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2813
/* External symbol declarations for the compiler. */\
2816
if test "$dlself" = yes; then
2817
func_verbose "generating symbol list for \`$output'"
2819
$opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2821
# Add our own program objects to the symbol list.
2822
progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2823
for progfile in $progfiles; do
2824
func_verbose "extracting global C symbols from \`$progfile'"
2825
$opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2828
if test -n "$exclude_expsyms"; then
2830
eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2831
eval '$MV "$nlist"T "$nlist"'
2835
if test -n "$export_symbols_regex"; then
2837
eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2838
eval '$MV "$nlist"T "$nlist"'
2842
# Prepare the list of exported symbols
2843
if test -z "$export_symbols"; then
2844
export_symbols="$output_objdir/$outputname.exp"
2847
eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2849
*cygwin* | *mingw* | *cegcc* )
2850
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2851
eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2857
eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2858
eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2859
eval '$MV "$nlist"T "$nlist"'
2861
*cygwin | *mingw* | *cegcc* )
2862
eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2863
eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2870
for dlprefile in $dlprefiles; do
2871
func_verbose "extracting global C symbols from \`$dlprefile'"
2872
func_basename "$dlprefile"
2873
name="$func_basename_result"
2875
eval '$ECHO ": $name " >> "$nlist"'
2876
eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2881
# Make sure we have at least an empty file.
2882
test -f "$nlist" || : > "$nlist"
2884
if test -n "$exclude_expsyms"; then
2885
$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2886
$MV "$nlist"T "$nlist"
2889
# Try sorting and uniquifying the output.
2890
if $GREP -v "^: " < "$nlist" |
2891
if sort -k 3 </dev/null >/dev/null 2>&1; then
2896
uniq > "$nlist"S; then
2899
$GREP -v "^: " < "$nlist" > "$nlist"S
2902
if test -f "$nlist"S; then
2903
eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2905
$ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2908
$ECHO >> "$output_objdir/$my_dlsyms" "\
2910
/* The mapping between symbol names and symbols. */
2917
*cygwin* | *mingw* | *cegcc* )
2918
$ECHO >> "$output_objdir/$my_dlsyms" "\
2919
/* DATA imports from DLLs on WIN32 con't be const, because
2920
runtime relocations are performed -- see ld's documentation
2921
on pseudo-relocs. */"
2924
echo >> "$output_objdir/$my_dlsyms" "\
2925
/* This system does not cope well with relocations in const data */"
2928
lt_dlsym_const=const ;;
2931
$ECHO >> "$output_objdir/$my_dlsyms" "\
2932
extern $lt_dlsym_const lt_dlsymlist
2933
lt_${my_prefix}_LTX_preloaded_symbols[];
2934
$lt_dlsym_const lt_dlsymlist
2935
lt_${my_prefix}_LTX_preloaded_symbols[] =
2937
{ \"$my_originator\", (void *) 0 },"
2939
case $need_lib_prefix in
2941
eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2944
eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2947
$ECHO >> "$output_objdir/$my_dlsyms" "\
2951
/* This works around a problem in FreeBSD linker */
2952
#ifdef FREEBSD_WORKAROUND
2953
static const void *lt_preloaded_setup() {
2954
return lt_${my_prefix}_LTX_preloaded_symbols;
2964
pic_flag_for_symtable=
2965
case "$compile_command " in
2969
# compiling the symbol table file with pic_flag works around
2970
# a FreeBSD bug that causes programs to crash when -lm is
2971
# linked before any other PIC object. But we must not use
2972
# pic_flag when linking with -static. The problem exists in
2973
# FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2974
*-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2975
pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2977
pic_flag_for_symtable=" $pic_flag" ;;
2979
if test "X$my_pic_p" != Xno; then
2980
pic_flag_for_symtable=" $pic_flag"
2987
for arg in $LTCFLAGS; do
2989
-pie | -fpie | -fPIE) ;;
2990
*) symtab_cflags="$symtab_cflags $arg" ;;
2994
# Now compile the dynamic symbol file.
2995
func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2997
# Clean up the generated files.
2998
func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3000
# Transform the symbol file into the correct name.
3001
symfileobj="$output_objdir/${my_outputname}S.$objext"
3003
*cygwin* | *mingw* | *cegcc* )
3004
if test -f "$output_objdir/$my_outputname.def"; then
3005
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3006
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3008
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3009
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3013
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3014
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3019
func_fatal_error "unknown suffix for \`$my_dlsyms'"
3023
# We keep going just in case the user didn't refer to
3024
# lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3025
# really was required.
3027
# Nullify the symbol file.
3028
compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3029
finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3033
# func_win32_libid arg
3034
# return the library type of file 'arg'
3036
# Need a lot of goo to handle *both* DLLs and import libs
3037
# Has to be a shell function in order to 'eat' the argument
3038
# that is supplied when $file_magic_command is called.
3042
win32_libid_type="unknown"
3043
win32_fileres=`file -L $1 2>/dev/null`
3044
case $win32_fileres in
3045
*ar\ archive\ import\ library*) # definitely import
3046
win32_libid_type="x86 archive import"
3048
*ar\ archive*) # could be an import, or static
3049
if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3050
$EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
3051
win32_nmres=`eval $NM -f posix -A $1 |
3060
case $win32_nmres in
3061
import*) win32_libid_type="x86 archive import";;
3062
*) win32_libid_type="x86 archive static";;
3067
win32_libid_type="x86 DLL"
3069
*executable*) # but shell scripts are "executable" too...
3070
case $win32_fileres in
3071
*MS\ Windows\ PE\ Intel*)
3072
win32_libid_type="x86 DLL"
3077
$ECHO "$win32_libid_type"
3082
# func_extract_an_archive dir oldlib
3083
func_extract_an_archive ()
3086
f_ex_an_ar_dir="$1"; shift
3087
f_ex_an_ar_oldlib="$1"
3088
func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3089
if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3092
func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3097
# func_extract_archives gentop oldlib ...
3098
func_extract_archives ()
3101
my_gentop="$1"; shift
3102
my_oldlibs=${1+"$@"}
3108
for my_xlib in $my_oldlibs; do
3109
# Extract the objects.
3111
[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3112
*) my_xabs=`pwd`"/$my_xlib" ;;
3114
func_basename "$my_xlib"
3115
my_xlib="$func_basename_result"
3118
case " $extracted_archives " in
3120
func_arith $extracted_serial + 1
3121
extracted_serial=$func_arith_result
3122
my_xlib_u=lt$extracted_serial-$my_xlib ;;
3126
extracted_archives="$extracted_archives $my_xlib_u"
3127
my_xdir="$my_gentop/$my_xlib_u"
3129
func_mkdir_p "$my_xdir"
3133
func_verbose "Extracting $my_xabs"
3134
# Do not bother doing anything if just a dry run
3136
darwin_orig_dir=`pwd`
3137
cd $my_xdir || exit $?
3138
darwin_archive=$my_xabs
3140
darwin_base_archive=`basename "$darwin_archive"`
3141
darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3142
if test -n "$darwin_arches"; then
3143
darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3145
func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3146
for darwin_arch in $darwin_arches ; do
3147
func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3148
$LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3149
cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3150
func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3152
$RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3153
done # $darwin_arches
3154
## Okay now we've a bunch of thin objects, gotta fatten them up :)
3155
darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3158
for darwin_file in $darwin_filelist; do
3159
darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3160
$LIPO -create -output "$darwin_file" $darwin_files
3161
done # $darwin_filelist
3163
cd "$darwin_orig_dir"
3166
func_extract_an_archive "$my_xdir" "$my_xabs"
3171
func_extract_an_archive "$my_xdir" "$my_xabs"
3174
my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3177
func_extract_archives_result="$my_oldobjs"
3182
# func_emit_wrapper_part1 [arg=no]
3184
# Emit the first part of a libtool wrapper script on stdout.
3185
# For more information, see the description associated with
3186
# func_emit_wrapper(), below.
3187
func_emit_wrapper_part1 ()
3189
func_emit_wrapper_part1_arg1=no
3190
if test -n "$1" ; then
3191
func_emit_wrapper_part1_arg1=$1
3197
# $output - temporary wrapper script for $objdir/$outputname
3198
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3200
# The $output program cannot be directly executed until all the libtool
3201
# libraries that it depends on are installed.
3203
# This wrapper script should never be moved out of the build directory.
3204
# If it is, it will not operate correctly.
3206
# Sed substitution that helps us do robust quoting. It backslashifies
3207
# metacharacters that are still active within double-quoted strings.
3208
Xsed='${SED} -e 1s/^X//'
3209
sed_quote_subst='$sed_quote_subst'
3211
# Be Bourne compatible
3212
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3215
# Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3216
# is contrary to our usage. Disable this feature.
3217
alias -g '\${1+\"\$@\"}'='\"\$@\"'
3218
setopt NO_GLOB_SUBST
3220
case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3222
BIN_SH=xpg4; export BIN_SH # for Tru64
3223
DUALCASE=1; export DUALCASE # for MKS sh
3225
# The HP-UX ksh and POSIX shell print the target directory to stdout
3227
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3229
relink_command=\"$relink_command\"
3231
# This environment variable determines our operation mode.
3232
if test \"\$libtool_install_magic\" = \"$magic\"; then
3233
# install mode needs the following variables:
3234
generated_by_libtool_version='$macro_version'
3235
notinst_deplibs='$notinst_deplibs'
3237
# When we are sourced in execute mode, \$file and \$ECHO are already set.
3238
if test \"\$libtool_execute_magic\" != \"$magic\"; then
3241
# Make sure echo works.
3242
if test \"X\$1\" = X--no-reexec; then
3243
# Discard the --no-reexec flag, and continue.
3245
elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
3246
# Yippee, \$ECHO works!
3249
# Restart under the correct shell, and then maybe \$ECHO will work.
3250
exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3256
# Find the directory that this script lives in.
3257
thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3258
test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3260
# Follow symbolic links until we get to the real thisdir.
3261
file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
3262
while test -n \"\$file\"; do
3263
destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3265
# If there was a directory component, then change thisdir.
3266
if test \"x\$destdir\" != \"x\$file\"; then
3267
case \"\$destdir\" in
3268
[\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3269
*) thisdir=\"\$thisdir/\$destdir\" ;;
3273
file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3274
file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
3278
# end: func_emit_wrapper_part1
3280
# func_emit_wrapper_part2 [arg=no]
3282
# Emit the second part of a libtool wrapper script on stdout.
3283
# For more information, see the description associated with
3284
# func_emit_wrapper(), below.
3285
func_emit_wrapper_part2 ()
3287
func_emit_wrapper_part2_arg1=no
3288
if test -n "$1" ; then
3289
func_emit_wrapper_part2_arg1=$1
3294
# Usually 'no', except on cygwin/mingw when embedded into
3296
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
3297
if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3298
# special case for '.'
3299
if test \"\$thisdir\" = \".\"; then
3302
# remove .libs from thisdir
3303
case \"\$thisdir\" in
3304
*[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
3305
$objdir ) thisdir=. ;;
3309
# Try to get the absolute directory name.
3310
absdir=\`cd \"\$thisdir\" && pwd\`
3311
test -n \"\$absdir\" && thisdir=\"\$absdir\"
3314
if test "$fast_install" = yes; then
3316
program=lt-'$outputname'$exeext
3317
progdir=\"\$thisdir/$objdir\"
3319
if test ! -f \"\$progdir/\$program\" ||
3320
{ file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3321
test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3323
file=\"\$\$-\$program\"
3325
if test ! -d \"\$progdir\"; then
3326
$MKDIR \"\$progdir\"
3328
$RM \"\$progdir/\$file\"
3333
# relink executable if necessary
3334
if test -n \"\$relink_command\"; then
3335
if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3337
$ECHO \"\$relink_command_output\" >&2
3338
$RM \"\$progdir/\$file\"
3343
$MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3344
{ $RM \"\$progdir/\$program\";
3345
$MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3346
$RM \"\$progdir/\$file\"
3350
program='$outputname'
3351
progdir=\"\$thisdir/$objdir\"
3357
if test -f \"\$progdir/\$program\"; then"
3359
# Export our shlibpath_var if we have one.
3360
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3362
# Add our own library path to $shlibpath_var
3363
$shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3365
# Some systems cannot cope with colon-terminated $shlibpath_var
3366
# The second colon is a workaround for a bug in BeOS R4 sed
3367
$shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3369
export $shlibpath_var
3373
# fixup the dll searchpath if we need to.
3374
if test -n "$dllsearchpath"; then
3376
# Add the dll search path components to the executable PATH
3377
PATH=$dllsearchpath:\$PATH
3382
if test \"\$libtool_execute_magic\" != \"$magic\"; then
3383
# Run the actual program with our arguments.
3386
# Backslashes separate directories on plain windows
3387
*-*-mingw | *-*-os2* | *-cegcc*)
3389
exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3395
exec \"\$progdir/\$program\" \${1+\"\$@\"}
3400
\$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3404
# The program doesn't exist.
3405
\$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3406
\$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3407
$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3413
# end: func_emit_wrapper_part2
3416
# func_emit_wrapper [arg=no]
3418
# Emit a libtool wrapper script on stdout.
3419
# Don't directly open a file because we may want to
3420
# incorporate the script contents within a cygwin/mingw
3421
# wrapper executable. Must ONLY be called from within
3422
# func_mode_link because it depends on a number of variables
3425
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3426
# variable will take. If 'yes', then the emitted script
3427
# will assume that the directory in which it is stored is
3428
# the $objdir directory. This is a cygwin/mingw-specific
3430
func_emit_wrapper ()
3432
func_emit_wrapper_arg1=no
3433
if test -n "$1" ; then
3434
func_emit_wrapper_arg1=$1
3437
# split this up so that func_emit_cwrapperexe_src
3438
# can call each part independently.
3439
func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
3440
func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
3444
# func_to_host_path arg
3446
# Convert paths to host format when used with build tools.
3447
# Intended for use with "native" mingw (where libtool itself
3448
# is running under the msys shell), or in the following cross-
3449
# build environments:
3451
# mingw (msys) mingw [e.g. native]
3454
# where wine is equipped with the `winepath' executable.
3455
# In the native mingw case, the (msys) shell automatically
3456
# converts paths for any non-msys applications it launches,
3457
# but that facility isn't available from inside the cwrapper.
3458
# Similar accommodations are necessary for $host mingw and
3459
# $build cygwin. Calling this function does no harm for other
3460
# $host/$build combinations not listed above.
3462
# ARG is the path (on $build) that should be converted to
3463
# the proper representation for $host. The result is stored
3464
# in $func_to_host_path_result.
3465
func_to_host_path ()
3467
func_to_host_path_result="$1"
3468
if test -n "$1" ; then
3471
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3473
*mingw* ) # actually, msys
3474
# awkward: cmd appends spaces to result
3475
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3476
func_to_host_path_tmp1=`( cmd //c echo "$1" |\
3477
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3478
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3479
$SED -e "$lt_sed_naive_backslashify"`
3482
func_to_host_path_tmp1=`cygpath -w "$1"`
3483
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3484
$SED -e "$lt_sed_naive_backslashify"`
3487
# Unfortunately, winepath does not exit with a non-zero
3488
# error code, so we are forced to check the contents of
3489
# stdout. On the other hand, if the command is not
3490
# found, the shell will set an exit code of 127 and print
3491
# *an error message* to stdout. So we must check for both
3492
# error code of zero AND non-empty stdout, which explains
3493
# the odd construction:
3494
func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3495
if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3496
func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3497
$SED -e "$lt_sed_naive_backslashify"`
3499
# Allow warning below.
3500
func_to_host_path_result=""
3504
if test -z "$func_to_host_path_result" ; then
3505
func_error "Could not determine host path corresponding to"
3507
func_error "Continuing, but uninstalled executables may not work."
3509
func_to_host_path_result="$1"
3515
# end: func_to_host_path
3517
# func_to_host_pathlist arg
3519
# Convert pathlists to host format when used with build tools.
3520
# See func_to_host_path(), above. This function supports the
3521
# following $build/$host combinations (but does no harm for
3522
# combinations not listed here):
3524
# mingw (msys) mingw [e.g. native]
3528
# Path separators are also converted from $build format to
3529
# $host format. If ARG begins or ends with a path separator
3530
# character, it is preserved (but converted to $host format)
3533
# ARG is a pathlist (on $build) that should be converted to
3534
# the proper representation on $host. The result is stored
3535
# in $func_to_host_pathlist_result.
3536
func_to_host_pathlist ()
3538
func_to_host_pathlist_result="$1"
3539
if test -n "$1" ; then
3542
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3543
# Remove leading and trailing path separator characters from
3544
# ARG. msys behavior is inconsistent here, cygpath turns them
3545
# into '.;' and ';.', and winepath ignores them completely.
3546
func_to_host_pathlist_tmp2="$1"
3547
# Once set for this call, this variable should not be
3548
# reassigned. It is used in tha fallback case.
3549
func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3550
$SED -e 's|^:*||' -e 's|:*$||'`
3552
*mingw* ) # Actually, msys.
3553
# Awkward: cmd appends spaces to result.
3554
lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3555
func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3556
$SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3557
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3558
$SED -e "$lt_sed_naive_backslashify"`
3561
func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3562
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3563
$SED -e "$lt_sed_naive_backslashify"`
3566
# unfortunately, winepath doesn't convert pathlists
3567
func_to_host_pathlist_result=""
3568
func_to_host_pathlist_oldIFS=$IFS
3570
for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3571
IFS=$func_to_host_pathlist_oldIFS
3572
if test -n "$func_to_host_pathlist_f" ; then
3573
func_to_host_path "$func_to_host_pathlist_f"
3574
if test -n "$func_to_host_path_result" ; then
3575
if test -z "$func_to_host_pathlist_result" ; then
3576
func_to_host_pathlist_result="$func_to_host_path_result"
3578
func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3584
IFS=$func_to_host_pathlist_oldIFS
3587
if test -z "$func_to_host_pathlist_result" ; then
3588
func_error "Could not determine the host path(s) corresponding to"
3590
func_error "Continuing, but uninstalled executables may not work."
3591
# Fallback. This may break if $1 contains DOS-style drive
3592
# specifications. The fix is not to complicate the expression
3593
# below, but for the user to provide a working wine installation
3594
# with winepath so that path translation in the cross-to-mingw
3595
# case works properly.
3596
lt_replace_pathsep_nix_to_dos="s|:|;|g"
3597
func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3598
$SED -e "$lt_replace_pathsep_nix_to_dos"`
3600
# Now, add the leading and trailing path separators back
3602
:* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3606
*: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3613
# end: func_to_host_pathlist
3615
# func_emit_cwrapperexe_src
3616
# emit the source code for a wrapper executable on stdout
3617
# Must ONLY be called from within func_mode_link because
3618
# it depends on a number of variable set therein.
3619
func_emit_cwrapperexe_src ()
3623
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3624
Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3626
The $output program cannot be directly executed until all the libtool
3627
libraries that it depends on are installed.
3629
This wrapper executable should never be moved out of the build directory.
3630
If it is, it will not operate correctly.
3632
Currently, it simply execs the wrapper *script* "$SHELL $output",
3633
but could eventually absorb all of the scripts functionality and
3634
exec $objdir/$outputname directly.
3641
# include <direct.h>
3642
# include <process.h>
3644
# define setmode _setmode
3646
# include <unistd.h>
3647
# include <stdint.h>
3650
# define HAVE_SETENV
3651
# ifdef __STRICT_ANSI__
3652
char *realpath (const char *, char *);
3653
int putenv (char *);
3654
int setenv (const char *, const char *, int);
3665
#include <sys/stat.h>
3667
#if defined(PATH_MAX)
3668
# define LT_PATHMAX PATH_MAX
3669
#elif defined(MAXPATHLEN)
3670
# define LT_PATHMAX MAXPATHLEN
3672
# define LT_PATHMAX 1024
3683
# define S_IXUSR _S_IEXEC
3685
# ifndef _INTPTR_T_DEFINED
3686
# define intptr_t int
3690
#ifndef DIR_SEPARATOR
3691
# define DIR_SEPARATOR '/'
3692
# define PATH_SEPARATOR ':'
3695
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3697
# define HAVE_DOS_BASED_FILE_SYSTEM
3698
# define FOPEN_WB "wb"
3699
# ifndef DIR_SEPARATOR_2
3700
# define DIR_SEPARATOR_2 '\\'
3702
# ifndef PATH_SEPARATOR_2
3703
# define PATH_SEPARATOR_2 ';'
3707
#ifndef DIR_SEPARATOR_2
3708
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3709
#else /* DIR_SEPARATOR_2 */
3710
# define IS_DIR_SEPARATOR(ch) \
3711
(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3712
#endif /* DIR_SEPARATOR_2 */
3714
#ifndef PATH_SEPARATOR_2
3715
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3716
#else /* PATH_SEPARATOR_2 */
3717
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3718
#endif /* PATH_SEPARATOR_2 */
3721
# define FOPEN_WB "wb"
3725
# define FOPEN_WB "w"
3728
# define _O_BINARY 0
3731
#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3732
#define XFREE(stale) do { \
3733
if (stale) { free ((void *) stale); stale = 0; } \
3736
#undef LTWRAPPER_DEBUGPRINTF
3737
#if defined DEBUGWRAPPER
3738
# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3740
ltwrapper_debugprintf (const char *fmt, ...)
3743
va_start (args, fmt);
3744
(void) vfprintf (stderr, fmt, args);
3748
# define LTWRAPPER_DEBUGPRINTF(args)
3751
const char *program_name = NULL;
3753
void *xmalloc (size_t num);
3754
char *xstrdup (const char *string);
3755
const char *base_name (const char *name);
3756
char *find_executable (const char *wrapper);
3757
char *chase_symlinks (const char *pathspec);
3758
int make_executable (const char *path);
3759
int check_executable (const char *path);
3760
char *strendzap (char *str, const char *pat);
3761
void lt_fatal (const char *message, ...);
3762
void lt_setenv (const char *name, const char *value);
3763
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3764
void lt_opt_process_env_set (const char *arg);
3765
void lt_opt_process_env_prepend (const char *arg);
3766
void lt_opt_process_env_append (const char *arg);
3767
int lt_split_name_value (const char *arg, char** name, char** value);
3768
void lt_update_exe_path (const char *name, const char *value);
3769
void lt_update_lib_path (const char *name, const char *value);
3771
static const char *script_text_part1 =
3774
func_emit_wrapper_part1 yes |
3775
$SED -e 's/\([\\"]\)/\\\1/g' \
3776
-e 's/^/ "/' -e 's/$/\\n"/'
3780
static const char *script_text_part2 =
3782
func_emit_wrapper_part2 yes |
3783
$SED -e 's/\([\\"]\)/\\\1/g' \
3784
-e 's/^/ "/' -e 's/$/\\n"/'
3788
const char * MAGIC_EXE = "$magic_exe";
3789
const char * LIB_PATH_VARNAME = "$shlibpath_var";
3792
if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3793
func_to_host_pathlist "$temp_rpath"
3795
const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3799
const char * LIB_PATH_VALUE = "";
3803
if test -n "$dllsearchpath"; then
3804
func_to_host_pathlist "$dllsearchpath:"
3806
const char * EXE_PATH_VARNAME = "PATH";
3807
const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3811
const char * EXE_PATH_VARNAME = "";
3812
const char * EXE_PATH_VALUE = "";
3816
if test "$fast_install" = yes; then
3818
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3822
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3829
#define LTWRAPPER_OPTION_PREFIX "--lt-"
3830
#define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3832
static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3833
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3835
static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3837
static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3838
static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";
3839
/* argument is putenv-style "foo=bar", value of foo is set to bar */
3841
static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3842
static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";
3843
/* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3845
static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3846
static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";
3847
/* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3850
main (int argc, char *argv[])
3855
char *actual_cwrapper_path;
3856
char *actual_cwrapper_name;
3859
intptr_t rval = 127;
3863
program_name = (char *) xstrdup (base_name (argv[0]));
3864
LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3865
LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3867
/* very simple arg parsing; don't want to rely on getopt */
3868
for (i = 1; i < argc; i++)
3870
if (strcmp (argv[i], dumpscript_opt) == 0)
3874
*mingw* | *cygwin* )
3875
# make stdout use "unix" line endings
3876
echo " setmode(1,_O_BINARY);"
3881
printf ("%s", script_text_part1);
3882
printf ("%s", script_text_part2);
3887
newargz = XMALLOC (char *, argc + 1);
3888
tmp_pathspec = find_executable (argv[0]);
3889
if (tmp_pathspec == NULL)
3890
lt_fatal ("Couldn't find %s", argv[0]);
3891
LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3894
actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3895
LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3896
actual_cwrapper_path));
3897
XFREE (tmp_pathspec);
3899
actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3900
strendzap (actual_cwrapper_path, actual_cwrapper_name);
3902
/* wrapper name transforms */
3903
strendzap (actual_cwrapper_name, ".exe");
3904
tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3905
XFREE (actual_cwrapper_name);
3906
actual_cwrapper_name = tmp_pathspec;
3909
/* target_name transforms -- use actual target program name; might have lt- prefix */
3910
target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3911
strendzap (target_name, ".exe");
3912
tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3913
XFREE (target_name);
3914
target_name = tmp_pathspec;
3917
LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3923
XMALLOC (char, (strlen (actual_cwrapper_path) +
3924
strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3925
strcpy (newargz[0], actual_cwrapper_path);
3926
strcat (newargz[0], "$objdir");
3927
strcat (newargz[0], "/");
3931
/* stop here, and copy so we don't have to do this twice */
3932
tmp_pathspec = xstrdup (newargz[0]);
3934
/* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3935
strcat (newargz[0], actual_cwrapper_name);
3937
/* DO want the lt- prefix here if it exists, so use target_name */
3938
lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3939
XFREE (tmp_pathspec);
3940
tmp_pathspec = NULL;
3948
while ((p = strchr (newargz[0], '\\')) != NULL)
3952
while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3962
XFREE (target_name);
3963
XFREE (actual_cwrapper_path);
3964
XFREE (actual_cwrapper_name);
3966
lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3967
lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3968
lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3969
lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3972
for (i = 1; i < argc; i++)
3974
if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3976
if (argv[i][env_set_opt_len] == '=')
3978
const char *p = argv[i] + env_set_opt_len + 1;
3979
lt_opt_process_env_set (p);
3981
else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3983
lt_opt_process_env_set (argv[++i]); /* don't copy */
3986
lt_fatal ("%s missing required argument", env_set_opt);
3989
if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3991
if (argv[i][env_prepend_opt_len] == '=')
3993
const char *p = argv[i] + env_prepend_opt_len + 1;
3994
lt_opt_process_env_prepend (p);
3996
else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
3998
lt_opt_process_env_prepend (argv[++i]); /* don't copy */
4001
lt_fatal ("%s missing required argument", env_prepend_opt);
4004
if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
4006
if (argv[i][env_append_opt_len] == '=')
4008
const char *p = argv[i] + env_append_opt_len + 1;
4009
lt_opt_process_env_append (p);
4011
else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
4013
lt_opt_process_env_append (argv[++i]); /* don't copy */
4016
lt_fatal ("%s missing required argument", env_append_opt);
4019
if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
4021
/* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4022
namespace, but it is not one of the ones we know about and
4023
have already dealt with, above (inluding dump-script), then
4024
report an error. Otherwise, targets might begin to believe
4025
they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4026
namespace. The first time any user complains about this, we'll
4027
need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4028
or a configure.ac-settable value.
4030
lt_fatal ("Unrecognized option in %s namespace: '%s'",
4031
ltwrapper_option_prefix, argv[i]);
4034
newargz[++newargc] = xstrdup (argv[i]);
4036
newargz[++newargc] = NULL;
4038
LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
4039
for (i = 0; i < newargc; i++)
4041
LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4049
/* execv doesn't actually work on mingw as expected on unix */
4050
rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4053
/* failed to start process */
4054
LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4062
execv (lt_argv_zero, newargz);
4063
return rval; /* =127, but avoids unused variable warning */
4072
xmalloc (size_t num)
4074
void *p = (void *) malloc (num);
4076
lt_fatal ("Memory exhausted");
4082
xstrdup (const char *string)
4084
return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4089
base_name (const char *name)
4093
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4094
/* Skip over the disk name in MSDOS pathnames. */
4095
if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4099
for (base = name; *name; name++)
4100
if (IS_DIR_SEPARATOR (*name))
4106
check_executable (const char *path)
4110
LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
4111
path ? (*path ? path : "EMPTY!") : "NULL!"));
4112
if ((!path) || (!*path))
4115
if ((stat (path, &st) >= 0)
4116
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4123
make_executable (const char *path)
4128
LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
4129
path ? (*path ? path : "EMPTY!") : "NULL!"));
4130
if ((!path) || (!*path))
4133
if (stat (path, &st) >= 0)
4135
rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4140
/* Searches for the full path of the wrapper. Returns
4141
newly allocated full path name if found, NULL otherwise
4142
Does not chase symlinks, even on platforms that support them.
4145
find_executable (const char *wrapper)
4150
/* static buffer for getcwd */
4151
char tmp[LT_PATHMAX + 1];
4155
LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
4156
wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4158
if ((wrapper == NULL) || (*wrapper == '\0'))
4161
/* Absolute path? */
4162
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4163
if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4165
concat_name = xstrdup (wrapper);
4166
if (check_executable (concat_name))
4168
XFREE (concat_name);
4173
if (IS_DIR_SEPARATOR (wrapper[0]))
4175
concat_name = xstrdup (wrapper);
4176
if (check_executable (concat_name))
4178
XFREE (concat_name);
4180
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4184
for (p = wrapper; *p; p++)
4192
/* no slashes; search PATH */
4193
const char *path = getenv ("PATH");
4196
for (p = path; *p; p = p_next)
4200
for (q = p; *q; q++)
4201
if (IS_PATH_SEPARATOR (*q))
4204
p_next = (*q == '\0' ? q : q + 1);
4207
/* empty path: current directory */
4208
if (getcwd (tmp, LT_PATHMAX) == NULL)
4209
lt_fatal ("getcwd failed");
4210
tmp_len = strlen (tmp);
4212
XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4213
memcpy (concat_name, tmp, tmp_len);
4214
concat_name[tmp_len] = '/';
4215
strcpy (concat_name + tmp_len + 1, wrapper);
4220
XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4221
memcpy (concat_name, p, p_len);
4222
concat_name[p_len] = '/';
4223
strcpy (concat_name + p_len + 1, wrapper);
4225
if (check_executable (concat_name))
4227
XFREE (concat_name);
4230
/* not found in PATH; assume curdir */
4232
/* Relative path | not found in path: prepend cwd */
4233
if (getcwd (tmp, LT_PATHMAX) == NULL)
4234
lt_fatal ("getcwd failed");
4235
tmp_len = strlen (tmp);
4236
concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4237
memcpy (concat_name, tmp, tmp_len);
4238
concat_name[tmp_len] = '/';
4239
strcpy (concat_name + tmp_len + 1, wrapper);
4241
if (check_executable (concat_name))
4243
XFREE (concat_name);
4248
chase_symlinks (const char *pathspec)
4251
return xstrdup (pathspec);
4253
char buf[LT_PATHMAX];
4255
char *tmp_pathspec = xstrdup (pathspec);
4257
int has_symlinks = 0;
4258
while (strlen (tmp_pathspec) && !has_symlinks)
4260
LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
4262
if (lstat (tmp_pathspec, &s) == 0)
4264
if (S_ISLNK (s.st_mode) != 0)
4270
/* search backwards for last DIR_SEPARATOR */
4271
p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4272
while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4274
if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4276
/* no more DIR_SEPARATORS left */
4283
char *errstr = strerror (errno);
4284
lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4287
XFREE (tmp_pathspec);
4291
return xstrdup (pathspec);
4294
tmp_pathspec = realpath (pathspec, buf);
4295
if (tmp_pathspec == 0)
4297
lt_fatal ("Could not follow symlinks for %s", pathspec);
4299
return xstrdup (tmp_pathspec);
4304
strendzap (char *str, const char *pat)
4308
assert (str != NULL);
4309
assert (pat != NULL);
4312
patlen = strlen (pat);
4316
str += len - patlen;
4317
if (strcmp (str, pat) == 0)
4324
lt_error_core (int exit_status, const char *mode,
4325
const char *message, va_list ap)
4327
fprintf (stderr, "%s: %s: ", program_name, mode);
4328
vfprintf (stderr, message, ap);
4329
fprintf (stderr, ".\n");
4331
if (exit_status >= 0)
4336
lt_fatal (const char *message, ...)
4339
va_start (ap, message);
4340
lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4345
lt_setenv (const char *name, const char *value)
4347
LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4348
(name ? name : "<NULL>"),
4349
(value ? value : "<NULL>")));
4352
/* always make a copy, for consistency with !HAVE_SETENV */
4353
char *str = xstrdup (value);
4354
setenv (name, str, 1);
4356
int len = strlen (name) + 1 + strlen (value) + 1;
4357
char *str = XMALLOC (char, len);
4358
sprintf (str, "%s=%s", name, value);
4359
if (putenv (str) != EXIT_SUCCESS)
4368
lt_extend_str (const char *orig_value, const char *add, int to_end)
4371
if (orig_value && *orig_value)
4373
int orig_value_len = strlen (orig_value);
4374
int add_len = strlen (add);
4375
new_value = XMALLOC (char, add_len + orig_value_len + 1);
4378
strcpy (new_value, orig_value);
4379
strcpy (new_value + orig_value_len, add);
4383
strcpy (new_value, add);
4384
strcpy (new_value + add_len, orig_value);
4389
new_value = xstrdup (add);
4395
lt_split_name_value (const char *arg, char** name, char** value)
4402
p = strchr (arg, (int)'=');
4407
*value = xstrdup (++p);
4409
len = strlen (arg) - strlen (*value);
4410
*name = XMALLOC (char, len);
4411
strncpy (*name, arg, len-1);
4412
(*name)[len - 1] = '\0';
4418
lt_opt_process_env_set (const char *arg)
4423
if (lt_split_name_value (arg, &name, &value) != 0)
4427
lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
4430
lt_setenv (name, value);
4436
lt_opt_process_env_prepend (const char *arg)
4440
char *new_value = NULL;
4442
if (lt_split_name_value (arg, &name, &value) != 0)
4446
lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
4449
new_value = lt_extend_str (getenv (name), value, 0);
4450
lt_setenv (name, new_value);
4457
lt_opt_process_env_append (const char *arg)
4461
char *new_value = NULL;
4463
if (lt_split_name_value (arg, &name, &value) != 0)
4467
lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
4470
new_value = lt_extend_str (getenv (name), value, 1);
4471
lt_setenv (name, new_value);
4478
lt_update_exe_path (const char *name, const char *value)
4480
LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4481
(name ? name : "<NULL>"),
4482
(value ? value : "<NULL>")));
4484
if (name && *name && value && *value)
4486
char *new_value = lt_extend_str (getenv (name), value, 0);
4487
/* some systems can't cope with a ':'-terminated path #' */
4488
int len = strlen (new_value);
4489
while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4491
new_value[len-1] = '\0';
4493
lt_setenv (name, new_value);
4499
lt_update_lib_path (const char *name, const char *value)
4501
LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4502
(name ? name : "<NULL>"),
4503
(value ? value : "<NULL>")));
4505
if (name && *name && value && *value)
4507
char *new_value = lt_extend_str (getenv (name), value, 0);
4508
lt_setenv (name, new_value);
4516
# end: func_emit_cwrapperexe_src
4518
# func_mode_link arg...
4523
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4524
# It is impossible to link a dll without this setting, and
4525
# we shouldn't force the makefile maintainer to figure out
4526
# which system we are compiling for in order to pass an extra
4527
# flag for every libtool invocation.
4528
# allow_undefined=no
4530
# FIXME: Unfortunately, there are problems with the above when trying
4531
# to make a dll which has undefined symbols, in which case not
4532
# even a static library is built. For now, we need to specify
4533
# -no-undefined on the libtool link line when we can be certain
4534
# that all symbols are satisfied, otherwise we get a static library.
4541
libtool_args=$nonopt
4542
base_compile="$nonopt $@"
4543
compile_command=$nonopt
4544
finalize_command=$nonopt
4557
lib_search_path=`pwd`
4559
new_inherited_linker_flags=
4567
export_symbols_regex=
4575
precious_files_regex=
4576
prefer_static_libs=no
4589
single_module="${wl}-single_module"
4590
func_infer_tag $base_compile
4592
# We need to know -static, to get the right output filenames.
4597
test "$build_libtool_libs" != yes && \
4598
func_fatal_configuration "can not build a shared library"
4602
-all-static | -static | -static-libtool-libs)
4605
if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4606
func_warning "complete static linking is impossible in this configuration"
4608
if test -n "$link_static_flag"; then
4609
dlopen_self=$dlopen_self_static
4611
prefer_static_libs=yes
4614
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4615
dlopen_self=$dlopen_self_static
4617
prefer_static_libs=built
4619
-static-libtool-libs)
4620
if test -z "$pic_flag" && test -n "$link_static_flag"; then
4621
dlopen_self=$dlopen_self_static
4623
prefer_static_libs=yes
4626
build_libtool_libs=no
4633
# See if our shared archives depend on static archives.
4634
test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4636
# Go through the arguments, transforming them on the way.
4637
while test "$#" -gt 0; do
4640
func_quote_for_eval "$arg"
4641
qarg=$func_quote_for_eval_unquoted_result
4642
func_append libtool_args " $func_quote_for_eval_result"
4644
# If the previous option needs an argument, assign it.
4645
if test -n "$prev"; then
4648
func_append compile_command " @OUTPUT@"
4649
func_append finalize_command " @OUTPUT@"
4655
if test "$preload" = no; then
4656
# Add the symbol object into the linking commands.
4657
func_append compile_command " @SYMFILE@"
4658
func_append finalize_command " @SYMFILE@"
4662
*.la | *.lo) ;; # We handle these cases below.
4664
if test "$dlself" = no; then
4672
if test "$prev" = dlprefiles; then
4674
elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4684
if test "$prev" = dlfiles; then
4685
dlfiles="$dlfiles $arg"
4687
dlprefiles="$dlprefiles $arg"
4695
export_symbols="$arg"
4697
|| func_fatal_error "symbol file \`$arg' does not exist"
4702
export_symbols_regex="$arg"
4710
*" $qarg.ltframework "*) ;;
4711
*) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4720
inst_prefix_dir="$arg"
4725
if test -f "$arg"; then
4728
for fil in `cat "$save_arg"`
4730
# moreargs="$moreargs $fil"
4732
# A libtool-controlled object.
4734
# Check to see that this really is a libtool object.
4735
if func_lalib_unsafe_p "$arg"; then
4742
if test -z "$pic_object" ||
4743
test -z "$non_pic_object" ||
4744
test "$pic_object" = none &&
4745
test "$non_pic_object" = none; then
4746
func_fatal_error "cannot find name of object for \`$arg'"
4749
# Extract subdirectory from the argument.
4750
func_dirname "$arg" "/" ""
4751
xdir="$func_dirname_result"
4753
if test "$pic_object" != none; then
4754
# Prepend the subdirectory the object is found in.
4755
pic_object="$xdir$pic_object"
4757
if test "$prev" = dlfiles; then
4758
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4759
dlfiles="$dlfiles $pic_object"
4763
# If libtool objects are unsupported, then we need to preload.
4768
# CHECK ME: I think I busted this. -Ossama
4769
if test "$prev" = dlprefiles; then
4770
# Preload the old-style object.
4771
dlprefiles="$dlprefiles $pic_object"
4776
func_append libobjs " $pic_object"
4781
if test "$non_pic_object" != none; then
4782
# Prepend the subdirectory the object is found in.
4783
non_pic_object="$xdir$non_pic_object"
4785
# A standard non-PIC object
4786
func_append non_pic_objects " $non_pic_object"
4787
if test -z "$pic_object" || test "$pic_object" = none ; then
4788
arg="$non_pic_object"
4791
# If the PIC object exists, use it instead.
4792
# $xdir was prepended to $pic_object above.
4793
non_pic_object="$pic_object"
4794
func_append non_pic_objects " $non_pic_object"
4797
# Only an error if not doing a dry-run.
4798
if $opt_dry_run; then
4799
# Extract subdirectory from the argument.
4800
func_dirname "$arg" "/" ""
4801
xdir="$func_dirname_result"
4804
pic_object=$xdir$objdir/$func_lo2o_result
4805
non_pic_object=$xdir$func_lo2o_result
4806
func_append libobjs " $pic_object"
4807
func_append non_pic_objects " $non_pic_object"
4809
func_fatal_error "\`$arg' is not a valid libtool object"
4814
func_fatal_error "link input file \`$arg' does not exist"
4821
precious_files_regex="$arg"
4831
# We need an absolute path.
4833
[\\/]* | [A-Za-z]:[\\/]*) ;;
4835
func_fatal_error "only absolute run-paths are allowed"
4838
if test "$prev" = rpath; then
4841
*) rpath="$rpath $arg" ;;
4846
*) xrpath="$xrpath $arg" ;;
4858
weak_libs="$weak_libs $arg"
4863
linker_flags="$linker_flags $qarg"
4864
compiler_flags="$compiler_flags $qarg"
4866
func_append compile_command " $qarg"
4867
func_append finalize_command " $qarg"
4871
compiler_flags="$compiler_flags $qarg"
4873
func_append compile_command " $qarg"
4874
func_append finalize_command " $qarg"
4878
linker_flags="$linker_flags $qarg"
4879
compiler_flags="$compiler_flags $wl$qarg"
4881
func_append compile_command " $wl$qarg"
4882
func_append finalize_command " $wl$qarg"
4886
eval "$prev=\"\$arg\""
4891
fi # test -n "$prev"
4897
if test -n "$link_static_flag"; then
4898
# See comment for -static flag below, for more details.
4899
func_append compile_command " $link_static_flag"
4900
func_append finalize_command " $link_static_flag"
4906
# FIXME: remove this flag sometime in the future.
4907
func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4930
-export-symbols | -export-symbols-regex)
4931
if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4932
func_fatal_error "more than one -exported-symbols argument is not allowed"
4934
if test "X$arg" = "X-export-symbols"; then
4952
# The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4953
# so, if we see these flags be careful not to treat them like -L
4955
case $with_gcc/$host in
4956
no/*-*-irix* | /*-*-irix*)
4957
func_append compile_command " $arg"
4958
func_append finalize_command " $arg"
4965
func_stripname '-L' '' "$arg"
4966
dir=$func_stripname_result
4967
if test -z "$dir"; then
4968
if test "$#" -gt 0; then
4969
func_fatal_error "require no space between \`-L' and \`$1'"
4971
func_fatal_error "need path for \`-L' option"
4974
# We need an absolute path.
4976
[\\/]* | [A-Za-z]:[\\/]*) ;;
4978
absdir=`cd "$dir" && pwd`
4979
test -z "$absdir" && \
4980
func_fatal_error "cannot determine absolute directory name of \`$dir'"
4987
deplibs="$deplibs -L$dir"
4988
lib_search_path="$lib_search_path $dir"
4992
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4993
testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
4994
case :$dllsearchpath: in
4996
::) dllsearchpath=$dir;;
4997
*) dllsearchpath="$dllsearchpath:$dir";;
4999
case :$dllsearchpath: in
5000
*":$testbindir:"*) ;;
5001
::) dllsearchpath=$testbindir;;
5002
*) dllsearchpath="$dllsearchpath:$testbindir";;
5010
if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5012
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5013
# These systems don't actually have a C or math library (as such)
5017
# These systems don't actually have a C library (as such)
5018
test "X$arg" = "X-lc" && continue
5020
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5021
# Do not include libc due to us having libc/libc_r.
5022
test "X$arg" = "X-lc" && continue
5024
*-*-rhapsody* | *-*-darwin1.[012])
5025
# Rhapsody C and math libraries are in the System framework
5026
deplibs="$deplibs System.ltframework"
5029
*-*-sco3.2v5* | *-*-sco5v6*)
5030
# Causes problems with __ctype
5031
test "X$arg" = "X-lc" && continue
5033
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5034
# Compiler inserts libc in the correct place for threads to work
5035
test "X$arg" = "X-lc" && continue
5038
elif test "X$arg" = "X-lc_r"; then
5040
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5041
# Do not include libc_r directly, use -pthread flag.
5046
deplibs="$deplibs $arg"
5055
# Tru64 UNIX uses -model [arg] to determine the layout of C++
5056
# classes, name mangling, and exception handling.
5057
# Darwin uses the -arch flag to determine output architecture.
5058
-model|-arch|-isysroot)
5059
compiler_flags="$compiler_flags $arg"
5060
func_append compile_command " $arg"
5061
func_append finalize_command " $arg"
5066
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5067
compiler_flags="$compiler_flags $arg"
5068
func_append compile_command " $arg"
5069
func_append finalize_command " $arg"
5070
case "$new_inherited_linker_flags " in
5072
* ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5078
single_module="${wl}-multi_module"
5089
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5090
# The PATH hackery in wrapper scripts is required on Windows
5091
# and Darwin in order for the loader to find any dlls it needs.
5092
func_warning "\`-no-install' is ignored for $host"
5093
func_warning "assuming \`-no-fast-install' instead"
5096
*) no_install=yes ;;
5113
-precious-files-regex)
5134
func_stripname '-R' '' "$arg"
5135
dir=$func_stripname_result
5136
# We need an absolute path.
5138
[\\/]* | [A-Za-z]:[\\/]*) ;;
5140
func_fatal_error "only absolute run-paths are allowed"
5145
*) xrpath="$xrpath $dir" ;;
5151
# The effects of -shared are defined in a previous loop.
5160
-static | -static-libtool-libs)
5161
# The effects of -static are defined in a previous loop.
5162
# We used to do the same as -all-static on platforms that
5163
# didn't have a PIC flag, but the assumption that the effects
5164
# would be equivalent was wrong. It would break on at least
5165
# Digital Unix and AIX.
5191
func_stripname '-Wc,' '' "$arg"
5192
args=$func_stripname_result
5194
save_ifs="$IFS"; IFS=','
5195
for flag in $args; do
5197
func_quote_for_eval "$flag"
5198
arg="$arg $wl$func_quote_for_eval_result"
5199
compiler_flags="$compiler_flags $func_quote_for_eval_result"
5202
func_stripname ' ' '' "$arg"
5203
arg=$func_stripname_result
5207
func_stripname '-Wl,' '' "$arg"
5208
args=$func_stripname_result
5210
save_ifs="$IFS"; IFS=','
5211
for flag in $args; do
5213
func_quote_for_eval "$flag"
5214
arg="$arg $wl$func_quote_for_eval_result"
5215
compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
5216
linker_flags="$linker_flags $func_quote_for_eval_result"
5219
func_stripname ' ' '' "$arg"
5220
arg=$func_stripname_result
5240
func_quote_for_eval "$arg"
5241
arg="$func_quote_for_eval_result"
5244
# -64, -mips[0-9] enable 64-bit mode on the SGI compiler
5245
# -r[0-9][0-9]* specifies the processor on the SGI compiler
5246
# -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
5247
# +DA*, +DD* enable 64-bit mode on the HP compiler
5248
# -q* pass through compiler args for the IBM compiler
5249
# -m*, -t[45]*, -txscale* pass through architecture-specific
5250
# compiler args for GCC
5251
# -F/path gives path to uninstalled frameworks, gcc on darwin
5252
# -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
5253
# @file GCC response files
5254
-64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5255
-t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5256
func_quote_for_eval "$arg"
5257
arg="$func_quote_for_eval_result"
5258
func_append compile_command " $arg"
5259
func_append finalize_command " $arg"
5260
compiler_flags="$compiler_flags $arg"
5264
# Some other compiler flag.
5266
func_quote_for_eval "$arg"
5267
arg="$func_quote_for_eval_result"
5271
# A standard object.
5276
# A libtool-controlled object.
5278
# Check to see that this really is a libtool object.
5279
if func_lalib_unsafe_p "$arg"; then
5286
if test -z "$pic_object" ||
5287
test -z "$non_pic_object" ||
5288
test "$pic_object" = none &&
5289
test "$non_pic_object" = none; then
5290
func_fatal_error "cannot find name of object for \`$arg'"
5293
# Extract subdirectory from the argument.
5294
func_dirname "$arg" "/" ""
5295
xdir="$func_dirname_result"
5297
if test "$pic_object" != none; then
5298
# Prepend the subdirectory the object is found in.
5299
pic_object="$xdir$pic_object"
5301
if test "$prev" = dlfiles; then
5302
if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5303
dlfiles="$dlfiles $pic_object"
5307
# If libtool objects are unsupported, then we need to preload.
5312
# CHECK ME: I think I busted this. -Ossama
5313
if test "$prev" = dlprefiles; then
5314
# Preload the old-style object.
5315
dlprefiles="$dlprefiles $pic_object"
5320
func_append libobjs " $pic_object"
5325
if test "$non_pic_object" != none; then
5326
# Prepend the subdirectory the object is found in.
5327
non_pic_object="$xdir$non_pic_object"
5329
# A standard non-PIC object
5330
func_append non_pic_objects " $non_pic_object"
5331
if test -z "$pic_object" || test "$pic_object" = none ; then
5332
arg="$non_pic_object"
5335
# If the PIC object exists, use it instead.
5336
# $xdir was prepended to $pic_object above.
5337
non_pic_object="$pic_object"
5338
func_append non_pic_objects " $non_pic_object"
5341
# Only an error if not doing a dry-run.
5342
if $opt_dry_run; then
5343
# Extract subdirectory from the argument.
5344
func_dirname "$arg" "/" ""
5345
xdir="$func_dirname_result"
5348
pic_object=$xdir$objdir/$func_lo2o_result
5349
non_pic_object=$xdir$func_lo2o_result
5350
func_append libobjs " $pic_object"
5351
func_append non_pic_objects " $non_pic_object"
5353
func_fatal_error "\`$arg' is not a valid libtool object"
5360
deplibs="$deplibs $arg"
5361
old_deplibs="$old_deplibs $arg"
5366
# A libtool-controlled library.
5368
if test "$prev" = dlfiles; then
5369
# This library was specified with -dlopen.
5370
dlfiles="$dlfiles $arg"
5372
elif test "$prev" = dlprefiles; then
5373
# The library was specified with -dlpreopen.
5374
dlprefiles="$dlprefiles $arg"
5377
deplibs="$deplibs $arg"
5382
# Some other compiler argument.
5384
# Unknown arguments in both finalize_command and compile_command need
5385
# to be aesthetically quoted because they are evaled later.
5386
func_quote_for_eval "$arg"
5387
arg="$func_quote_for_eval_result"
5391
# Now actually substitute the argument into the commands.
5392
if test -n "$arg"; then
5393
func_append compile_command " $arg"
5394
func_append finalize_command " $arg"
5396
done # argument parsing loop
5398
test -n "$prev" && \
5399
func_fatal_help "the \`$prevarg' option requires an argument"
5401
if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5402
eval arg=\"$export_dynamic_flag_spec\"
5403
func_append compile_command " $arg"
5404
func_append finalize_command " $arg"
5408
# calculate the name of the file, without its directory
5409
func_basename "$output"
5410
outputname="$func_basename_result"
5411
libobjs_save="$libobjs"
5413
if test -n "$shlibpath_var"; then
5414
# get the directories listed in $shlibpath_var
5415
eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
5419
eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5420
eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5422
func_dirname "$output" "/" ""
5423
output_objdir="$func_dirname_result$objdir"
5424
# Create the object directory.
5425
func_mkdir_p "$output_objdir"
5427
# Determine the type of output
5430
func_fatal_help "you must specify an output file"
5432
*.$libext) linkmode=oldlib ;;
5433
*.lo | *.$objext) linkmode=obj ;;
5434
*.la) linkmode=lib ;;
5435
*) linkmode=prog ;; # Anything else should be a program.
5441
# Find all interdependent deplibs by searching for libraries
5442
# that are linked more than once (e.g. -la -lb -la)
5443
for deplib in $deplibs; do
5444
if $opt_duplicate_deps ; then
5446
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5449
libs="$libs $deplib"
5452
if test "$linkmode" = lib; then
5453
libs="$predeps $libs $compiler_lib_search_path $postdeps"
5455
# Compute libraries that are listed more than once in $predeps
5456
# $postdeps and mark them as special (i.e., whose duplicates are
5457
# not to be eliminated).
5459
if $opt_duplicate_compiler_generated_deps; then
5460
for pre_post_dep in $predeps $postdeps; do
5461
case "$pre_post_deps " in
5462
*" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5464
pre_post_deps="$pre_post_deps $pre_post_dep"
5473
need_relink=no # whether we're linking any uninstalled libtool libraries
5474
notinst_deplibs= # not-installed libtool libraries
5475
notinst_path= # paths that contain not-installed libtool libraries
5479
passes="conv dlpreopen link"
5480
for file in $dlfiles $dlprefiles; do
5484
func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5495
passes="conv scan dlopen dlpreopen link"
5501
for pass in $passes; do
5502
# The preopen pass in lib mode reverses $deplibs; put it back here
5503
# so that -L comes before libs that need it for instance...
5504
if test "$linkmode,$pass" = "lib,link"; then
5505
## FIXME: Find the place where the list is rebuilt in the wrong
5506
## order, and fix it there properly
5508
for deplib in $deplibs; do
5509
tmp_deplibs="$deplib $tmp_deplibs"
5511
deplibs="$tmp_deplibs"
5514
if test "$linkmode,$pass" = "lib,link" ||
5515
test "$linkmode,$pass" = "prog,scan"; then
5519
if test "$linkmode" = prog; then
5521
dlopen) libs="$dlfiles" ;;
5522
dlpreopen) libs="$dlprefiles" ;;
5524
libs="$deplibs %DEPLIBS%"
5525
test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
5529
if test "$linkmode,$pass" = "lib,dlpreopen"; then
5530
# Collect and forward deplibs of preopened libtool libs
5531
for lib in $dlprefiles; do
5532
# Ignore non-libtool-libs
5535
*.la) func_source "$lib" ;;
5538
# Collect preopened libtool deplibs, except any this library
5539
# has declared as weak libs
5540
for deplib in $dependency_libs; do
5541
deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5542
case " $weak_libs " in
5543
*" $deplib_base "*) ;;
5544
*) deplibs="$deplibs $deplib" ;;
5550
if test "$pass" = dlopen; then
5551
# Collect dlpreopened libraries
5552
save_deplibs="$deplibs"
5556
for deplib in $libs; do
5560
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5561
if test "$linkmode,$pass" = "prog,link"; then
5562
compile_deplibs="$deplib $compile_deplibs"
5563
finalize_deplibs="$deplib $finalize_deplibs"
5565
compiler_flags="$compiler_flags $deplib"
5566
if test "$linkmode" = lib ; then
5567
case "$new_inherited_linker_flags " in
5569
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5576
if test "$linkmode" != lib && test "$linkmode" != prog; then
5577
func_warning "\`-l' is ignored for archives/objects"
5580
func_stripname '-l' '' "$deplib"
5581
name=$func_stripname_result
5582
if test "$linkmode" = lib; then
5583
searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5585
searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5587
for searchdir in $searchdirs; do
5588
for search_ext in .la $std_shrext .so .a; do
5589
# Search the libtool library
5590
lib="$searchdir/lib${name}${search_ext}"
5591
if test -f "$lib"; then
5592
if test "$search_ext" = ".la"; then
5601
if test "$found" != yes; then
5602
# deplib doesn't seem to be a libtool library
5603
if test "$linkmode,$pass" = "prog,link"; then
5604
compile_deplibs="$deplib $compile_deplibs"
5605
finalize_deplibs="$deplib $finalize_deplibs"
5607
deplibs="$deplib $deplibs"
5608
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5611
else # deplib is a libtool library
5612
# If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5613
# We need to do some special things here, and not later.
5614
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5615
case " $predeps $postdeps " in
5617
if func_lalib_p "$lib"; then
5621
for l in $old_library $library_names; do
5624
if test "X$ll" = "X$old_library" ; then # only static version available
5626
func_dirname "$lib" "" "."
5627
ladir="$func_dirname_result"
5628
lib=$ladir/$old_library
5629
if test "$linkmode,$pass" = "prog,link"; then
5630
compile_deplibs="$deplib $compile_deplibs"
5631
finalize_deplibs="$deplib $finalize_deplibs"
5633
deplibs="$deplib $deplibs"
5634
test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5646
if test "$linkmode,$pass" = "prog,link"; then
5647
compile_deplibs="$deplib $compile_deplibs"
5648
finalize_deplibs="$deplib $finalize_deplibs"
5650
deplibs="$deplib $deplibs"
5651
if test "$linkmode" = lib ; then
5652
case "$new_inherited_linker_flags " in
5654
* ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5663
deplibs="$deplib $deplibs"
5664
test "$pass" = conv && continue
5665
newdependency_libs="$deplib $newdependency_libs"
5666
func_stripname '-L' '' "$deplib"
5667
newlib_search_path="$newlib_search_path $func_stripname_result"
5670
if test "$pass" = conv; then
5671
deplibs="$deplib $deplibs"
5674
if test "$pass" = scan; then
5675
deplibs="$deplib $deplibs"
5677
compile_deplibs="$deplib $compile_deplibs"
5678
finalize_deplibs="$deplib $finalize_deplibs"
5680
func_stripname '-L' '' "$deplib"
5681
newlib_search_path="$newlib_search_path $func_stripname_result"
5684
func_warning "\`-L' is ignored for archives/objects"
5690
if test "$pass" = link; then
5691
func_stripname '-R' '' "$deplib"
5692
dir=$func_stripname_result
5693
# Make sure the xrpath contains only unique directories.
5696
*) xrpath="$xrpath $dir" ;;
5699
deplibs="$deplib $deplibs"
5702
*.la) lib="$deplib" ;;
5704
if test "$pass" = conv; then
5705
deplibs="$deplib $deplibs"
5710
# Linking convenience modules into shared libraries is allowed,
5711
# but linking other static libraries is non-portable.
5712
case " $dlpreconveniencelibs " in
5716
case $deplibs_check_method in
5718
set dummy $deplibs_check_method; shift
5719
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5720
if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5721
| $EGREP "$match_pattern_regex" > /dev/null; then
5729
if test "$valid_a_lib" != yes; then
5731
$ECHO "*** Warning: Trying to link with static lib archive $deplib."
5732
$ECHO "*** I have the capability to make that library automatically link in when"
5733
$ECHO "*** you link to this library. But I can only do this if you have a"
5734
$ECHO "*** shared version of the library, which you do not appear to have"
5735
$ECHO "*** because the file extensions .$libext of this argument makes me believe"
5736
$ECHO "*** that it is just a static archive that I should not use here."
5739
$ECHO "*** Warning: Linking the shared library $output against the"
5740
$ECHO "*** static library $deplib is not portable!"
5741
deplibs="$deplib $deplibs"
5748
if test "$pass" != link; then
5749
deplibs="$deplib $deplibs"
5751
compile_deplibs="$deplib $compile_deplibs"
5752
finalize_deplibs="$deplib $finalize_deplibs"
5759
if test "$pass" = conv; then
5760
deplibs="$deplib $deplibs"
5761
elif test "$linkmode" = prog; then
5762
if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5763
# If there is no dlopen support or we're linking statically,
5764
# we need to preload.
5765
newdlprefiles="$newdlprefiles $deplib"
5766
compile_deplibs="$deplib $compile_deplibs"
5767
finalize_deplibs="$deplib $finalize_deplibs"
5769
newdlfiles="$newdlfiles $deplib"
5780
if test "$found" = yes || test -f "$lib"; then :
5782
func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5785
# Check to see that this really is a libtool archive.
5786
func_lalib_unsafe_p "$lib" \
5787
|| func_fatal_error "\`$lib' is not a valid libtool archive"
5789
func_dirname "$lib" "" "."
5790
ladir="$func_dirname_result"
5798
inherited_linker_flags=
5799
# If the library was installed with an old release of libtool,
5800
# it will not redefine variables installed, or shouldnotlink
5809
# Convert "-framework foo" to "foo.ltframework"
5810
if test -n "$inherited_linker_flags"; then
5811
tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5812
for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5813
case " $new_inherited_linker_flags " in
5814
*" $tmp_inherited_linker_flag "*) ;;
5815
*) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5819
dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5820
if test "$linkmode,$pass" = "lib,link" ||
5821
test "$linkmode,$pass" = "prog,scan" ||
5822
{ test "$linkmode" != prog && test "$linkmode" != lib; }; then
5823
test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5824
test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5827
if test "$pass" = conv; then
5828
# Only check for convenience libraries
5829
deplibs="$lib $deplibs"
5830
if test -z "$libdir"; then
5831
if test -z "$old_library"; then
5832
func_fatal_error "cannot find name of link library for \`$lib'"
5834
# It is a libtool convenience library, so add in its objects.
5835
convenience="$convenience $ladir/$objdir/$old_library"
5836
old_convenience="$old_convenience $ladir/$objdir/$old_library"
5837
elif test "$linkmode" != prog && test "$linkmode" != lib; then
5838
func_fatal_error "\`$lib' is not a convenience library"
5841
for deplib in $dependency_libs; do
5842
deplibs="$deplib $deplibs"
5843
if $opt_duplicate_deps ; then
5844
case "$tmp_libs " in
5845
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5848
tmp_libs="$tmp_libs $deplib"
5854
# Get the name of the library we link against.
5856
for l in $old_library $library_names; do
5859
if test -z "$linklib"; then
5860
func_fatal_error "cannot find name of link library for \`$lib'"
5863
# This library was specified with -dlopen.
5864
if test "$pass" = dlopen; then
5865
if test -z "$libdir"; then
5866
func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5868
if test -z "$dlname" ||
5869
test "$dlopen_support" != yes ||
5870
test "$build_libtool_libs" = no; then
5871
# If there is no dlname, no dlopen support or we're linking
5872
# statically, we need to preload. We also need to preload any
5873
# dependent libraries so libltdl's deplib preloader doesn't
5874
# bomb out in the load deplibs phase.
5875
dlprefiles="$dlprefiles $lib $dependency_libs"
5877
newdlfiles="$newdlfiles $lib"
5882
# We need an absolute path.
5884
[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5886
abs_ladir=`cd "$ladir" && pwd`
5887
if test -z "$abs_ladir"; then
5888
func_warning "cannot determine absolute directory name of \`$ladir'"
5889
func_warning "passing it literally to the linker, although it might fail"
5894
func_basename "$lib"
5895
laname="$func_basename_result"
5897
# Find the relevant object directory and library name.
5898
if test "X$installed" = Xyes; then
5899
if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5900
func_warning "library \`$lib' was moved."
5908
test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5910
if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5913
# Remove this search path later
5914
notinst_path="$notinst_path $abs_ladir"
5916
dir="$ladir/$objdir"
5917
absdir="$abs_ladir/$objdir"
5918
# Remove this search path later
5919
notinst_path="$notinst_path $abs_ladir"
5921
fi # $installed = yes
5922
func_stripname 'lib' '.la' "$laname"
5923
name=$func_stripname_result
5925
# This library was specified with -dlpreopen.
5926
if test "$pass" = dlpreopen; then
5927
if test -z "$libdir" && test "$linkmode" = prog; then
5928
func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5930
# Prefer using a static library (so that no silly _DYNAMIC symbols
5931
# are required to link).
5932
if test -n "$old_library"; then
5933
newdlprefiles="$newdlprefiles $dir/$old_library"
5934
# Keep a list of preopened convenience libraries to check
5935
# that they are being used correctly in the link pass.
5936
test -z "$libdir" && \
5937
dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5938
# Otherwise, use the dlname, so that lt_dlopen finds it.
5939
elif test -n "$dlname"; then
5940
newdlprefiles="$newdlprefiles $dir/$dlname"
5942
newdlprefiles="$newdlprefiles $dir/$linklib"
5944
fi # $pass = dlpreopen
5946
if test -z "$libdir"; then
5947
# Link the convenience library
5948
if test "$linkmode" = lib; then
5949
deplibs="$dir/$old_library $deplibs"
5950
elif test "$linkmode,$pass" = "prog,link"; then
5951
compile_deplibs="$dir/$old_library $compile_deplibs"
5952
finalize_deplibs="$dir/$old_library $finalize_deplibs"
5954
deplibs="$lib $deplibs" # used for prog,scan pass
5960
if test "$linkmode" = prog && test "$pass" != link; then
5961
newlib_search_path="$newlib_search_path $ladir"
5962
deplibs="$lib $deplibs"
5965
if test "$link_all_deplibs" != no || test -z "$library_names" ||
5966
test "$build_libtool_libs" = no; then
5971
for deplib in $dependency_libs; do
5973
-L*) func_stripname '-L' '' "$deplib"
5974
newlib_search_path="$newlib_search_path $func_stripname_result"
5977
# Need to link against all dependency_libs?
5978
if test "$linkalldeplibs" = yes; then
5979
deplibs="$deplib $deplibs"
5981
# Need to hardcode shared library paths
5982
# or/and link against static libraries
5983
newdependency_libs="$deplib $newdependency_libs"
5985
if $opt_duplicate_deps ; then
5986
case "$tmp_libs " in
5987
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5990
tmp_libs="$tmp_libs $deplib"
5993
fi # $linkmode = prog...
5995
if test "$linkmode,$pass" = "prog,link"; then
5996
if test -n "$library_names" &&
5997
{ { test "$prefer_static_libs" = no ||
5998
test "$prefer_static_libs,$installed" = "built,yes"; } ||
5999
test -z "$old_library"; }; then
6000
# We need to hardcode the library path
6001
if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6002
# Make sure the rpath contains only unique directories.
6003
case "$temp_rpath:" in
6005
*) temp_rpath="$temp_rpath$absdir:" ;;
6009
# Hardcode the library path.
6010
# Skip directories that are in the system default run-time
6012
case " $sys_lib_dlsearch_path " in
6015
case "$compile_rpath " in
6017
*) compile_rpath="$compile_rpath $absdir"
6021
case " $sys_lib_dlsearch_path " in
6024
case "$finalize_rpath " in
6026
*) finalize_rpath="$finalize_rpath $libdir"
6030
fi # $linkmode,$pass = prog,link...
6032
if test "$alldeplibs" = yes &&
6033
{ test "$deplibs_check_method" = pass_all ||
6034
{ test "$build_libtool_libs" = yes &&
6035
test -n "$library_names"; }; }; then
6036
# We only need to search for static libraries
6041
link_static=no # Whether the deplib will be linked statically
6042
use_static_libs=$prefer_static_libs
6043
if test "$use_static_libs" = built && test "$installed" = yes; then
6046
if test -n "$library_names" &&
6047
{ test "$use_static_libs" = no || test -z "$old_library"; }; then
6049
*cygwin* | *mingw* | *cegcc*)
6050
# No point in relinking DLLs because paths are not encoded
6051
notinst_deplibs="$notinst_deplibs $lib"
6055
if test "$installed" = no; then
6056
notinst_deplibs="$notinst_deplibs $lib"
6061
# This is a shared library
6063
# Warn about portability, can't link against -module's on some
6064
# systems (darwin). Don't bleat about dlopened modules though!
6066
for dlpremoduletest in $dlprefiles; do
6067
if test "X$dlpremoduletest" = "X$lib"; then
6068
dlopenmodule="$dlpremoduletest"
6072
if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6074
if test "$linkmode" = prog; then
6075
$ECHO "*** Warning: Linking the executable $output against the loadable module"
6077
$ECHO "*** Warning: Linking the shared library $output against the loadable module"
6079
$ECHO "*** $linklib is not portable!"
6081
if test "$linkmode" = lib &&
6082
test "$hardcode_into_libs" = yes; then
6083
# Hardcode the library path.
6084
# Skip directories that are in the system default run-time
6086
case " $sys_lib_dlsearch_path " in
6089
case "$compile_rpath " in
6091
*) compile_rpath="$compile_rpath $absdir"
6095
case " $sys_lib_dlsearch_path " in
6098
case "$finalize_rpath " in
6100
*) finalize_rpath="$finalize_rpath $libdir"
6106
if test -n "$old_archive_from_expsyms_cmds"; then
6107
# figure out the soname
6108
set dummy $library_names
6112
libname=`eval "\\$ECHO \"$libname_spec\""`
6113
# use dlname if we got it. it's perfectly good, no?
6114
if test -n "$dlname"; then
6116
elif test -n "$soname_spec"; then
6119
*cygwin* | mingw* | *cegcc*)
6120
func_arith $current - $age
6121
major=$func_arith_result
6125
eval soname=\"$soname_spec\"
6130
# Make a new name for the extract_expsyms_cmds to use
6132
func_basename "$soroot"
6133
soname="$func_basename_result"
6134
func_stripname 'lib' '.dll' "$soname"
6135
newlib=libimp-$func_stripname_result.a
6137
# If the library has no export list, then create one now
6138
if test -f "$output_objdir/$soname-def"; then :
6140
func_verbose "extracting exported symbol list from \`$soname'"
6141
func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6145
if test -f "$output_objdir/$newlib"; then :; else
6146
func_verbose "generating import library for \`$soname'"
6147
func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6149
# make sure the library variables are pointing to the new library
6152
fi # test -n "$old_archive_from_expsyms_cmds"
6154
if test "$linkmode" = prog || test "$mode" != relink; then
6159
case $hardcode_action in
6160
immediate | unsupported)
6161
if test "$hardcode_direct" = no; then
6164
*-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6165
*-*-sysv4*uw2*) add_dir="-L$dir" ;;
6166
*-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6167
*-*-unixware7*) add_dir="-L$dir" ;;
6169
# if the lib is a (non-dlopened) module then we can not
6170
# link against it, someone is ignoring the earlier warnings
6171
if /usr/bin/file -L $add 2> /dev/null |
6172
$GREP ": [^:]* bundle" >/dev/null ; then
6173
if test "X$dlopenmodule" != "X$lib"; then
6174
$ECHO "*** Warning: lib $linklib is a module, not a shared library"
6175
if test -z "$old_library" ; then
6177
$ECHO "*** And there doesn't seem to be a static archive available"
6178
$ECHO "*** The link will probably fail, sorry"
6180
add="$dir/$old_library"
6182
elif test -n "$old_library"; then
6183
add="$dir/$old_library"
6187
elif test "$hardcode_minus_L" = no; then
6189
*-*-sunos*) add_shlibpath="$dir" ;;
6193
elif test "$hardcode_shlibpath_var" = no; then
6194
add_shlibpath="$dir"
6201
if test "$hardcode_direct" = yes &&
6202
test "$hardcode_direct_absolute" = no; then
6204
elif test "$hardcode_minus_L" = yes; then
6206
# Try looking first in the location we're being installed to.
6207
if test -n "$inst_prefix_dir"; then
6210
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6215
elif test "$hardcode_shlibpath_var" = yes; then
6216
add_shlibpath="$dir"
6225
if test "$lib_linked" != yes; then
6226
func_fatal_configuration "unsupported hardcode properties"
6229
if test -n "$add_shlibpath"; then
6230
case :$compile_shlibpath: in
6231
*":$add_shlibpath:"*) ;;
6232
*) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6235
if test "$linkmode" = prog; then
6236
test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6237
test -n "$add" && compile_deplibs="$add $compile_deplibs"
6239
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6240
test -n "$add" && deplibs="$add $deplibs"
6241
if test "$hardcode_direct" != yes &&
6242
test "$hardcode_minus_L" != yes &&
6243
test "$hardcode_shlibpath_var" = yes; then
6244
case :$finalize_shlibpath: in
6246
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6252
if test "$linkmode" = prog || test "$mode" = relink; then
6256
# Finalize command for both is simple: just hardcode it.
6257
if test "$hardcode_direct" = yes &&
6258
test "$hardcode_direct_absolute" = no; then
6259
add="$libdir/$linklib"
6260
elif test "$hardcode_minus_L" = yes; then
6263
elif test "$hardcode_shlibpath_var" = yes; then
6264
case :$finalize_shlibpath: in
6266
*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6269
elif test "$hardcode_automatic" = yes; then
6270
if test -n "$inst_prefix_dir" &&
6271
test -f "$inst_prefix_dir$libdir/$linklib" ; then
6272
add="$inst_prefix_dir$libdir/$linklib"
6274
add="$libdir/$linklib"
6277
# We cannot seem to hardcode it, guess we'll fake it.
6279
# Try looking first in the location we're being installed to.
6280
if test -n "$inst_prefix_dir"; then
6283
add_dir="$add_dir -L$inst_prefix_dir$libdir"
6290
if test "$linkmode" = prog; then
6291
test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6292
test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6294
test -n "$add_dir" && deplibs="$add_dir $deplibs"
6295
test -n "$add" && deplibs="$add $deplibs"
6298
elif test "$linkmode" = prog; then
6299
# Here we assume that one of hardcode_direct or hardcode_minus_L
6300
# is not unsupported. This is valid on all known static and
6302
if test "$hardcode_direct" != unsupported; then
6303
test -n "$old_library" && linklib="$old_library"
6304
compile_deplibs="$dir/$linklib $compile_deplibs"
6305
finalize_deplibs="$dir/$linklib $finalize_deplibs"
6307
compile_deplibs="-l$name -L$dir $compile_deplibs"
6308
finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6310
elif test "$build_libtool_libs" = yes; then
6311
# Not a shared library
6312
if test "$deplibs_check_method" != pass_all; then
6313
# We're trying link a shared library against a static one
6314
# but the system doesn't support it.
6316
# Just print a warning and add the library to dependency_libs so
6317
# that the program can be linked against the static library.
6319
$ECHO "*** Warning: This system can not link to static lib archive $lib."
6320
$ECHO "*** I have the capability to make that library automatically link in when"
6321
$ECHO "*** you link to this library. But I can only do this if you have a"
6322
$ECHO "*** shared version of the library, which you do not appear to have."
6323
if test "$module" = yes; then
6324
$ECHO "*** But as you try to build a module library, libtool will still create "
6325
$ECHO "*** a static module, that should work as long as the dlopening application"
6326
$ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6327
if test -z "$global_symbol_pipe"; then
6329
$ECHO "*** However, this would only work if libtool was able to extract symbol"
6330
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6331
$ECHO "*** not find such a program. So, this module is probably useless."
6332
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6334
if test "$build_old_libs" = no; then
6335
build_libtool_libs=module
6338
build_libtool_libs=no
6342
deplibs="$dir/$old_library $deplibs"
6345
fi # link shared/static library?
6347
if test "$linkmode" = lib; then
6348
if test -n "$dependency_libs" &&
6349
{ test "$hardcode_into_libs" != yes ||
6350
test "$build_old_libs" = yes ||
6351
test "$link_static" = yes; }; then
6352
# Extract -R from dependency_libs
6354
for libdir in $dependency_libs; do
6356
-R*) func_stripname '-R' '' "$libdir"
6357
temp_xrpath=$func_stripname_result
6359
*" $temp_xrpath "*) ;;
6360
*) xrpath="$xrpath $temp_xrpath";;
6362
*) temp_deplibs="$temp_deplibs $libdir";;
6365
dependency_libs="$temp_deplibs"
6368
newlib_search_path="$newlib_search_path $absdir"
6369
# Link against this library
6370
test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6371
# ... and its dependency_libs
6373
for deplib in $dependency_libs; do
6374
newdependency_libs="$deplib $newdependency_libs"
6375
if $opt_duplicate_deps ; then
6376
case "$tmp_libs " in
6377
*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6380
tmp_libs="$tmp_libs $deplib"
6383
if test "$link_all_deplibs" != no; then
6384
# Add the search paths of all dependency libraries
6385
for deplib in $dependency_libs; do
6387
-L*) path="$deplib" ;;
6389
func_dirname "$deplib" "" "."
6390
dir="$func_dirname_result"
6391
# We need an absolute path.
6393
[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6395
absdir=`cd "$dir" && pwd`
6396
if test -z "$absdir"; then
6397
func_warning "cannot determine absolute directory name of \`$dir'"
6402
if $GREP "^installed=no" $deplib > /dev/null; then
6406
eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6407
if test -n "$deplibrary_names" ; then
6408
for tmp in $deplibrary_names ; do
6411
if test -f "$absdir/$objdir/$depdepl" ; then
6412
depdepl="$absdir/$objdir/$depdepl"
6413
darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6414
if test -z "$darwin_install_name"; then
6415
darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6417
compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6418
linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6424
path="-L$absdir/$objdir"
6428
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6429
test -z "$libdir" && \
6430
func_fatal_error "\`$deplib' is not a valid libtool archive"
6431
test "$absdir" != "$libdir" && \
6432
func_warning "\`$deplib' seems to be moved"
6438
case " $deplibs " in
6440
*) deplibs="$path $deplibs" ;;
6443
fi # link_all_deplibs != no
6445
done # for deplib in $libs
6446
if test "$pass" = link; then
6447
if test "$linkmode" = "prog"; then
6448
compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6449
finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6451
compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6454
dependency_libs="$newdependency_libs"
6455
if test "$pass" = dlpreopen; then
6456
# Link the dlpreopened libraries before other libraries
6457
for deplib in $save_deplibs; do
6458
deplibs="$deplib $deplibs"
6461
if test "$pass" != dlopen; then
6462
if test "$pass" != conv; then
6463
# Make sure lib_search_path contains only unique directories.
6465
for dir in $newlib_search_path; do
6466
case "$lib_search_path " in
6468
*) lib_search_path="$lib_search_path $dir" ;;
6474
if test "$linkmode,$pass" != "prog,link"; then
6477
vars="compile_deplibs finalize_deplibs"
6479
for var in $vars dependency_libs; do
6480
# Add libraries to $var in reverse order
6481
eval tmp_libs=\"\$$var\"
6483
for deplib in $tmp_libs; do
6484
# FIXME: Pedantically, this is the right thing to do, so
6485
# that some nasty dependency loop isn't accidentally
6487
#new_libs="$deplib $new_libs"
6488
# Pragmatically, this seems to cause very few problems in
6491
-L*) new_libs="$deplib $new_libs" ;;
6494
# And here is the reason: when a library appears more
6495
# than once as an explicit dependence of a library, or
6496
# is implicitly linked in more than once by the
6497
# compiler, it is considered special, and multiple
6498
# occurrences thereof are not removed. Compare this
6499
# with having the same library being listed as a
6500
# dependency of multiple other libraries: in this case,
6501
# we know (pedantically, we assume) the library does not
6502
# need to be listed more than once, so we keep only the
6503
# last copy. This is not always right, but it is rare
6504
# enough that we require users that really mean to play
6505
# such unportable linking tricks to link the library
6506
# using -Wl,-lname, so that libtool does not consider it
6507
# for duplicate removal.
6508
case " $specialdeplibs " in
6509
*" $deplib "*) new_libs="$deplib $new_libs" ;;
6511
case " $new_libs " in
6513
*) new_libs="$deplib $new_libs" ;;
6521
for deplib in $new_libs; do
6524
case " $tmp_libs " in
6526
*) tmp_libs="$tmp_libs $deplib" ;;
6529
*) tmp_libs="$tmp_libs $deplib" ;;
6532
eval $var=\"$tmp_libs\"
6535
# Last step: remove runtime libs from dependency_libs
6536
# (they stay in deplibs)
6538
for i in $dependency_libs ; do
6539
case " $predeps $postdeps $compiler_lib_search_path " in
6544
if test -n "$i" ; then
6545
tmp_libs="$tmp_libs $i"
6548
dependency_libs=$tmp_libs
6550
if test "$linkmode" = prog; then
6551
dlfiles="$newdlfiles"
6553
if test "$linkmode" = prog || test "$linkmode" = lib; then
6554
dlprefiles="$newdlprefiles"
6559
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6560
func_warning "\`-dlopen' is ignored for archives"
6565
func_warning "\`-l' and \`-L' are ignored for archives" ;;
6568
test -n "$rpath" && \
6569
func_warning "\`-rpath' is ignored for archives"
6571
test -n "$xrpath" && \
6572
func_warning "\`-R' is ignored for archives"
6574
test -n "$vinfo" && \
6575
func_warning "\`-version-info/-version-number' is ignored for archives"
6577
test -n "$release" && \
6578
func_warning "\`-release' is ignored for archives"
6580
test -n "$export_symbols$export_symbols_regex" && \
6581
func_warning "\`-export-symbols' is ignored for archives"
6583
# Now set the variables for building old libraries.
6584
build_libtool_libs=no
6586
objs="$objs$old_deplibs"
6590
# Make sure we only generate libraries of the form `libNAME.la'.
6593
func_stripname 'lib' '.la' "$outputname"
6594
name=$func_stripname_result
6595
eval shared_ext=\"$shrext_cmds\"
6596
eval libname=\"$libname_spec\"
6599
test "$module" = no && \
6600
func_fatal_help "libtool library \`$output' must begin with \`lib'"
6602
if test "$need_lib_prefix" != no; then
6603
# Add the "lib" prefix for modules if required
6604
func_stripname '' '.la' "$outputname"
6605
name=$func_stripname_result
6606
eval shared_ext=\"$shrext_cmds\"
6607
eval libname=\"$libname_spec\"
6609
func_stripname '' '.la' "$outputname"
6610
libname=$func_stripname_result
6615
if test -n "$objs"; then
6616
if test "$deplibs_check_method" != pass_all; then
6617
func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6620
$ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6621
$ECHO "*** objects $objs is not portable!"
6622
libobjs="$libobjs $objs"
6626
test "$dlself" != no && \
6627
func_warning "\`-dlopen self' is ignored for libtool libraries"
6631
test "$#" -gt 1 && \
6632
func_warning "ignoring multiple \`-rpath's for a libtool library"
6637
if test -z "$rpath"; then
6638
if test "$build_libtool_libs" = yes; then
6639
# Building a libtool convenience library.
6640
# Some compilers have problems with a `.al' extension so
6641
# convenience libraries should have the same extension an
6642
# archive normally would.
6643
oldlibs="$output_objdir/$libname.$libext $oldlibs"
6644
build_libtool_libs=convenience
6648
test -n "$vinfo" && \
6649
func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6651
test -n "$release" && \
6652
func_warning "\`-release' is ignored for convenience libraries"
6655
# Parse the version information argument.
6656
save_ifs="$IFS"; IFS=':'
6657
set dummy $vinfo 0 0 0
6662
func_fatal_help "too many parameters to \`-version-info'"
6664
# convert absolute version numbers to libtool ages
6665
# this retains compatibility with .la files and attempts
6666
# to make the code below a bit more comprehensible
6668
case $vinfo_number in
6672
number_revision="$3"
6674
# There are really only two kinds -- those that
6675
# use the current revision as the major version
6676
# and those that subtract age and use age as
6677
# a minor version. But, then there is irix
6678
# which has an extra 1 added just for fun
6680
case $version_type in
6681
darwin|linux|osf|windows|none)
6682
func_arith $number_major + $number_minor
6683
current=$func_arith_result
6685
revision="$number_revision"
6687
freebsd-aout|freebsd-elf|sunos)
6688
current="$number_major"
6689
revision="$number_minor"
6693
func_arith $number_major + $number_minor
6694
current=$func_arith_result
6696
revision="$number_minor"
6697
lt_irix_increment=no
6700
func_fatal_configuration "$modename: unknown library version type \`$version_type'"
6711
# Check that each of the things are valid numbers.
6713
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]) ;;
6715
func_error "CURRENT \`$current' must be a nonnegative integer"
6716
func_fatal_error "\`$vinfo' is not valid version information"
6721
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]) ;;
6723
func_error "REVISION \`$revision' must be a nonnegative integer"
6724
func_fatal_error "\`$vinfo' is not valid version information"
6729
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]) ;;
6731
func_error "AGE \`$age' must be a nonnegative integer"
6732
func_fatal_error "\`$vinfo' is not valid version information"
6736
if test "$age" -gt "$current"; then
6737
func_error "AGE \`$age' is greater than the current interface number \`$current'"
6738
func_fatal_error "\`$vinfo' is not valid version information"
6741
# Calculate the version variables.
6745
case $version_type in
6749
# Like Linux, but with the current version available in
6750
# verstring for coding it into the library header
6751
func_arith $current - $age
6752
major=.$func_arith_result
6753
versuffix="$major.$age.$revision"
6754
# Darwin ld doesn't like 0 for these options...
6755
func_arith $current + 1
6756
minor_current=$func_arith_result
6757
xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6758
verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6763
versuffix=".$current.$revision";
6768
versuffix=".$current"
6772
if test "X$lt_irix_increment" = "Xno"; then
6773
func_arith $current - $age
6775
func_arith $current - $age + 1
6777
major=$func_arith_result
6779
case $version_type in
6780
nonstopux) verstring_prefix=nonstopux ;;
6781
*) verstring_prefix=sgi ;;
6783
verstring="$verstring_prefix$major.$revision"
6785
# Add in all the interfaces that we are compatible with.
6787
while test "$loop" -ne 0; do
6788
func_arith $revision - $loop
6789
iface=$func_arith_result
6790
func_arith $loop - 1
6791
loop=$func_arith_result
6792
verstring="$verstring_prefix$major.$iface:$verstring"
6795
# Before this point, $major must not contain `.'.
6797
versuffix="$major.$revision"
6801
func_arith $current - $age
6802
major=.$func_arith_result
6803
versuffix="$major.$age.$revision"
6807
func_arith $current - $age
6808
major=.$func_arith_result
6809
versuffix=".$current.$age.$revision"
6810
verstring="$current.$age.$revision"
6812
# Add in all the interfaces that we are compatible with.
6814
while test "$loop" -ne 0; do
6815
func_arith $current - $loop
6816
iface=$func_arith_result
6817
func_arith $loop - 1
6818
loop=$func_arith_result
6819
verstring="$verstring:${iface}.0"
6822
# Make executables depend on our current version.
6823
verstring="$verstring:${current}.0"
6828
versuffix=".$current"
6833
versuffix=".$current.$revision"
6837
# Use '-' rather than '.', since we only want one
6838
# extension on DOS 8.3 filesystems.
6839
func_arith $current - $age
6840
major=$func_arith_result
6845
func_fatal_configuration "unknown library version type \`$version_type'"
6849
# Clear the version info if we defaulted, and they specified a release.
6850
if test -z "$vinfo" && test -n "$release"; then
6852
case $version_type in
6854
# we can't check for "0.0" in archive_cmds due to quoting
6855
# problems, so we reset it completely
6862
if test "$need_version" = no; then
6869
# Remove version info from name if versioning should be avoided
6870
if test "$avoid_version" = yes && test "$need_version" = no; then
6876
# Check to see if the archive will have undefined symbols.
6877
if test "$allow_undefined" = yes; then
6878
if test "$allow_undefined_flag" = unsupported; then
6879
func_warning "undefined symbols not allowed in $host shared libraries"
6880
build_libtool_libs=no
6884
# Don't allow undefined symbols.
6885
allow_undefined_flag="$no_undefined_flag"
6890
func_generate_dlsyms "$libname" "$libname" "yes"
6891
libobjs="$libobjs $symfileobj"
6892
test "X$libobjs" = "X " && libobjs=
6894
if test "$mode" != relink; then
6895
# Remove our outputs, but don't remove object files since they
6896
# may have been created when compiling PIC objects.
6898
tempremovelist=`$ECHO "$output_objdir/*"`
6899
for p in $tempremovelist; do
6903
$output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6904
if test "X$precious_files_regex" != "X"; then
6905
if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6910
removelist="$removelist $p"
6915
test -n "$removelist" && \
6916
func_show_eval "${RM}r \$removelist"
6919
# Now set the variables for building old libraries.
6920
if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6921
oldlibs="$oldlibs $output_objdir/$libname.$libext"
6923
# Transform .lo files to .o files.
6924
oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6927
# Eliminate all temporary directories.
6928
#for path in $notinst_path; do
6929
# lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6930
# deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6931
# dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6934
if test -n "$xrpath"; then
6935
# If the user specified any rpath flags, then add them.
6937
for libdir in $xrpath; do
6938
temp_xrpath="$temp_xrpath -R$libdir"
6939
case "$finalize_rpath " in
6941
*) finalize_rpath="$finalize_rpath $libdir" ;;
6944
if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6945
dependency_libs="$temp_xrpath $dependency_libs"
6949
# Make sure dlfiles contains only unique files that won't be dlpreopened
6950
old_dlfiles="$dlfiles"
6952
for lib in $old_dlfiles; do
6953
case " $dlprefiles $dlfiles " in
6955
*) dlfiles="$dlfiles $lib" ;;
6959
# Make sure dlprefiles contains only unique files
6960
old_dlprefiles="$dlprefiles"
6962
for lib in $old_dlprefiles; do
6963
case "$dlprefiles " in
6965
*) dlprefiles="$dlprefiles $lib" ;;
6969
if test "$build_libtool_libs" = yes; then
6970
if test -n "$rpath"; then
6972
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6973
# these systems don't actually have a c library (as such)!
6975
*-*-rhapsody* | *-*-darwin1.[012])
6976
# Rhapsody C library is in the System framework
6977
deplibs="$deplibs System.ltframework"
6980
# Don't link with libc until the a.out ld.so is fixed.
6982
*-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6983
# Do not include libc due to us having libc/libc_r.
6985
*-*-sco3.2v5* | *-*-sco5v6*)
6986
# Causes problems with __ctype
6988
*-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6989
# Compiler inserts libc in the correct place for threads to work
6992
# Add libc to deplibs on all other systems if necessary.
6993
if test "$build_libtool_need_lc" = "yes"; then
6994
deplibs="$deplibs -lc"
7000
# Transform deplibs into only deplibs that can be linked in shared.
7002
libname_save=$libname
7003
release_save=$release
7004
versuffix_save=$versuffix
7006
# I'm not sure if I'm treating the release correctly. I think
7007
# release should show up in the -l (ie -lgmp5) so we don't want to
7008
# add it in twice. Is that correct?
7014
case $deplibs_check_method in
7016
# Don't check for shared/static. Everything works.
7017
# This might be a little naive. We might want to check
7018
# whether the library exists or not. But this is on
7019
# osf3 & osf4 and I'm not really sure... Just
7020
# implementing what was already the behavior.
7024
# This code stresses the "libraries are programs" paradigm to its
7025
# limits. Maybe even breaks it. We compile a program, linking it
7026
# against the deplibs as a proxy for the library. Then we can check
7027
# whether they linked in statically or dynamically with ldd.
7028
$opt_dry_run || $RM conftest.c
7029
cat > conftest.c <<EOF
7030
int main() { return 0; }
7032
$opt_dry_run || $RM conftest
7033
if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7034
ldd_output=`ldd conftest`
7035
for i in $deplibs; do
7038
func_stripname -l '' "$i"
7039
name=$func_stripname_result
7040
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7041
case " $predeps $postdeps " in
7043
newdeplibs="$newdeplibs $i"
7048
if test -n "$i" ; then
7049
libname=`eval "\\$ECHO \"$libname_spec\""`
7050
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7051
set dummy $deplib_matches; shift
7053
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7054
newdeplibs="$newdeplibs $i"
7058
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7059
$ECHO "*** I have the capability to make that library automatically link in when"
7060
$ECHO "*** you link to this library. But I can only do this if you have a"
7061
$ECHO "*** shared version of the library, which I believe you do not have"
7062
$ECHO "*** because a test_compile did reveal that the linker did not use it for"
7063
$ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7068
newdeplibs="$newdeplibs $i"
7073
# Error occurred in the first compile. Let's try to salvage
7074
# the situation: Compile a separate program for each library.
7075
for i in $deplibs; do
7078
func_stripname -l '' "$i"
7079
name=$func_stripname_result
7080
$opt_dry_run || $RM conftest
7081
if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7082
ldd_output=`ldd conftest`
7083
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7084
case " $predeps $postdeps " in
7086
newdeplibs="$newdeplibs $i"
7091
if test -n "$i" ; then
7092
libname=`eval "\\$ECHO \"$libname_spec\""`
7093
deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7094
set dummy $deplib_matches; shift
7096
if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7097
newdeplibs="$newdeplibs $i"
7101
$ECHO "*** Warning: dynamic linker does not accept needed library $i."
7102
$ECHO "*** I have the capability to make that library automatically link in when"
7103
$ECHO "*** you link to this library. But I can only do this if you have a"
7104
$ECHO "*** shared version of the library, which you do not appear to have"
7105
$ECHO "*** because a test_compile did reveal that the linker did not use this one"
7106
$ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7112
$ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7113
$ECHO "*** make it link in! You will probably need to install it or some"
7114
$ECHO "*** library that it depends on before this library will be fully"
7115
$ECHO "*** functional. Installing it before continuing would be even better."
7119
newdeplibs="$newdeplibs $i"
7126
set dummy $deplibs_check_method; shift
7127
file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7128
for a_deplib in $deplibs; do
7131
func_stripname -l '' "$a_deplib"
7132
name=$func_stripname_result
7133
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7134
case " $predeps $postdeps " in
7136
newdeplibs="$newdeplibs $a_deplib"
7141
if test -n "$a_deplib" ; then
7142
libname=`eval "\\$ECHO \"$libname_spec\""`
7143
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7144
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7145
for potent_lib in $potential_libs; do
7146
# Follow soft links.
7147
if ls -lLd "$potent_lib" 2>/dev/null |
7148
$GREP " -> " >/dev/null; then
7151
# The statement above tries to avoid entering an
7152
# endless loop below, in case of cyclic links.
7153
# We might still enter an endless loop, since a link
7154
# loop can be closed while we follow links,
7156
potlib="$potent_lib"
7157
while test -h "$potlib" 2>/dev/null; do
7158
potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7160
[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7161
*) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7164
if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7166
$EGREP "$file_magic_regex" > /dev/null; then
7167
newdeplibs="$newdeplibs $a_deplib"
7174
if test -n "$a_deplib" ; then
7177
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7178
$ECHO "*** I have the capability to make that library automatically link in when"
7179
$ECHO "*** you link to this library. But I can only do this if you have a"
7180
$ECHO "*** shared version of the library, which you do not appear to have"
7181
$ECHO "*** because I did check the linker path looking for a file starting"
7182
if test -z "$potlib" ; then
7183
$ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7185
$ECHO "*** with $libname and none of the candidates passed a file format test"
7186
$ECHO "*** using a file magic. Last file checked: $potlib"
7191
# Add a -L argument.
7192
newdeplibs="$newdeplibs $a_deplib"
7195
done # Gone through all deplibs.
7198
set dummy $deplibs_check_method; shift
7199
match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7200
for a_deplib in $deplibs; do
7203
func_stripname -l '' "$a_deplib"
7204
name=$func_stripname_result
7205
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7206
case " $predeps $postdeps " in
7208
newdeplibs="$newdeplibs $a_deplib"
7213
if test -n "$a_deplib" ; then
7214
libname=`eval "\\$ECHO \"$libname_spec\""`
7215
for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7216
potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7217
for potent_lib in $potential_libs; do
7218
potlib="$potent_lib" # see symlink-check above in file_magic test
7219
if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7220
$EGREP "$match_pattern_regex" > /dev/null; then
7221
newdeplibs="$newdeplibs $a_deplib"
7228
if test -n "$a_deplib" ; then
7231
$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7232
$ECHO "*** I have the capability to make that library automatically link in when"
7233
$ECHO "*** you link to this library. But I can only do this if you have a"
7234
$ECHO "*** shared version of the library, which you do not appear to have"
7235
$ECHO "*** because I did check the linker path looking for a file starting"
7236
if test -z "$potlib" ; then
7237
$ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7239
$ECHO "*** with $libname and none of the candidates passed a file format test"
7240
$ECHO "*** using a regex pattern. Last file checked: $potlib"
7245
# Add a -L argument.
7246
newdeplibs="$newdeplibs $a_deplib"
7249
done # Gone through all deplibs.
7253
tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
7254
-e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7255
if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7256
for i in $predeps $postdeps ; do
7257
# can't use Xsed below, because $i might contain '/'
7258
tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7261
if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
7262
$GREP . >/dev/null; then
7264
if test "X$deplibs_check_method" = "Xnone"; then
7265
$ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7267
$ECHO "*** Warning: inter-library dependencies are not known to be supported."
7269
$ECHO "*** All declared inter-library dependencies are being dropped."
7274
versuffix=$versuffix_save
7276
release=$release_save
7277
libname=$libname_save
7281
*-*-rhapsody* | *-*-darwin1.[012])
7282
# On Rhapsody replace the C library with the System framework
7283
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7287
if test "$droppeddeps" = yes; then
7288
if test "$module" = yes; then
7290
$ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7291
$ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7292
$ECHO "*** a static module, that should work as long as the dlopening"
7293
$ECHO "*** application is linked with the -dlopen flag."
7294
if test -z "$global_symbol_pipe"; then
7296
$ECHO "*** However, this would only work if libtool was able to extract symbol"
7297
$ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
7298
$ECHO "*** not find such a program. So, this module is probably useless."
7299
$ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7301
if test "$build_old_libs" = no; then
7302
oldlibs="$output_objdir/$libname.$libext"
7303
build_libtool_libs=module
7306
build_libtool_libs=no
7309
$ECHO "*** The inter-library dependencies that have been dropped here will be"
7310
$ECHO "*** automatically added whenever a program is linked with this library"
7311
$ECHO "*** or is declared to -dlopen it."
7313
if test "$allow_undefined" = no; then
7315
$ECHO "*** Since this library must not contain undefined symbols,"
7316
$ECHO "*** because either the platform does not support them or"
7317
$ECHO "*** it was explicitly requested with -no-undefined,"
7318
$ECHO "*** libtool will only create a static version of it."
7319
if test "$build_old_libs" = no; then
7320
oldlibs="$output_objdir/$libname.$libext"
7321
build_libtool_libs=module
7324
build_libtool_libs=no
7329
# Done checking deplibs!
7332
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
7335
newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7336
new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7337
deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7341
# move library search paths that coincide with paths to not yet
7342
# installed libraries to the beginning of the library search list
7344
for path in $notinst_path; do
7345
case " $new_libs " in
7346
*" -L$path/$objdir "*) ;;
7348
case " $deplibs " in
7349
*" -L$path/$objdir "*)
7350
new_libs="$new_libs -L$path/$objdir" ;;
7355
for deplib in $deplibs; do
7358
case " $new_libs " in
7360
*) new_libs="$new_libs $deplib" ;;
7363
*) new_libs="$new_libs $deplib" ;;
7368
# All the library-specific variables (install_libdir is set above).
7373
# Test again, we may have decided not to build it any more
7374
if test "$build_libtool_libs" = yes; then
7375
if test "$hardcode_into_libs" = yes; then
7376
# Hardcode the library paths
7379
rpath="$finalize_rpath"
7380
test "$mode" != relink && rpath="$compile_rpath$rpath"
7381
for libdir in $rpath; do
7382
if test -n "$hardcode_libdir_flag_spec"; then
7383
if test -n "$hardcode_libdir_separator"; then
7384
if test -z "$hardcode_libdirs"; then
7385
hardcode_libdirs="$libdir"
7387
# Just accumulate the unique libdirs.
7388
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7389
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7392
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7397
eval flag=\"$hardcode_libdir_flag_spec\"
7398
dep_rpath="$dep_rpath $flag"
7400
elif test -n "$runpath_var"; then
7401
case "$perm_rpath " in
7403
*) perm_rpath="$perm_rpath $libdir" ;;
7407
# Substitute the hardcoded libdirs into the rpath.
7408
if test -n "$hardcode_libdir_separator" &&
7409
test -n "$hardcode_libdirs"; then
7410
libdir="$hardcode_libdirs"
7411
if test -n "$hardcode_libdir_flag_spec_ld"; then
7412
eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
7414
eval dep_rpath=\"$hardcode_libdir_flag_spec\"
7417
if test -n "$runpath_var" && test -n "$perm_rpath"; then
7418
# We should set the runpath_var.
7420
for dir in $perm_rpath; do
7423
eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
7425
test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7428
shlibpath="$finalize_shlibpath"
7429
test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7430
if test -n "$shlibpath"; then
7431
eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
7434
# Get the real and link names of the library.
7435
eval shared_ext=\"$shrext_cmds\"
7436
eval library_names=\"$library_names_spec\"
7437
set dummy $library_names
7442
if test -n "$soname_spec"; then
7443
eval soname=\"$soname_spec\"
7447
if test -z "$dlname"; then
7451
lib="$output_objdir/$realname"
7455
linknames="$linknames $link"
7458
# Use standard objects if they are pic
7459
test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7460
test "X$libobjs" = "X " && libobjs=
7463
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7464
$opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7465
export_symbols="$output_objdir/$libname.uexp"
7466
delfiles="$delfiles $export_symbols"
7469
orig_export_symbols=
7471
cygwin* | mingw* | cegcc*)
7472
if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7473
# exporting using user supplied symfile
7474
if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7475
# and it's NOT already a .def file. Must figure out
7476
# which of the given symbols are data symbols and tag
7477
# them as such. So, trigger use of export_symbols_cmds.
7478
# export_symbols gets reassigned inside the "prepare
7479
# the list of exported symbols" if statement, so the
7480
# include_expsyms logic still works.
7481
orig_export_symbols="$export_symbols"
7483
always_export_symbols=yes
7489
# Prepare the list of exported symbols
7490
if test -z "$export_symbols"; then
7491
if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7492
func_verbose "generating symbol list for \`$libname.la'"
7493
export_symbols="$output_objdir/$libname.exp"
7494
$opt_dry_run || $RM $export_symbols
7495
cmds=$export_symbols_cmds
7496
save_ifs="$IFS"; IFS='~'
7497
for cmd in $cmds; do
7501
len=$func_len_result
7502
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7503
func_show_eval "$cmd" 'exit $?'
7504
skipped_export=false
7506
# The command line is too long to execute in one step.
7507
func_verbose "using reloadable object file for export list..."
7509
# Break out early, otherwise skipped_export may be
7510
# set to false by a later but shorter cmd.
7515
if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7516
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7517
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7522
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7523
tmp_export_symbols="$export_symbols"
7524
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7525
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7528
if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7529
# The given exports_symbols file has to be filtered, so filter it.
7530
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7531
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7532
# 's' commands which not all seds can handle. GNU sed should be fine
7533
# though. Also, the filter scales superlinearly with the number of
7534
# global variables. join(1) would be nice here, but unfortunately
7535
# isn't a blessed tool.
7536
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7537
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7538
export_symbols=$output_objdir/$libname.def
7539
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7543
for test_deplib in $deplibs; do
7544
case " $convenience " in
7545
*" $test_deplib "*) ;;
7547
tmp_deplibs="$tmp_deplibs $test_deplib"
7551
deplibs="$tmp_deplibs"
7553
if test -n "$convenience"; then
7554
if test -n "$whole_archive_flag_spec" &&
7555
test "$compiler_needs_object" = yes &&
7556
test -z "$libobjs"; then
7557
# extract the archives, so we have objects to list.
7558
# TODO: could optimize this to just extract one archive.
7559
whole_archive_flag_spec=
7561
if test -n "$whole_archive_flag_spec"; then
7562
save_libobjs=$libobjs
7563
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7564
test "X$libobjs" = "X " && libobjs=
7566
gentop="$output_objdir/${outputname}x"
7567
generated="$generated $gentop"
7569
func_extract_archives $gentop $convenience
7570
libobjs="$libobjs $func_extract_archives_result"
7571
test "X$libobjs" = "X " && libobjs=
7575
if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7576
eval flag=\"$thread_safe_flag_spec\"
7577
linker_flags="$linker_flags $flag"
7580
# Make a backup of the uninstalled library when relinking
7581
if test "$mode" = relink; then
7582
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7585
# Do each of the archive commands.
7586
if test "$module" = yes && test -n "$module_cmds" ; then
7587
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7588
eval test_cmds=\"$module_expsym_cmds\"
7589
cmds=$module_expsym_cmds
7591
eval test_cmds=\"$module_cmds\"
7595
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7596
eval test_cmds=\"$archive_expsym_cmds\"
7597
cmds=$archive_expsym_cmds
7599
eval test_cmds=\"$archive_cmds\"
7604
if test "X$skipped_export" != "X:" &&
7605
func_len " $test_cmds" &&
7606
len=$func_len_result &&
7607
test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7610
# The command line is too long to link in one step, link piecewise
7611
# or, if using GNU ld and skipped_export is not :, use a linker
7614
# Save the value of $output and $libobjs because we want to
7615
# use them later. If we have whole_archive_flag_spec, we
7616
# want to use save_libobjs as it was before
7617
# whole_archive_flag_spec was expanded, because we can't
7618
# assume the linker understands whole_archive_flag_spec.
7619
# This may have to be revisited, in case too many
7620
# convenience libraries get linked in and end up exceeding
7622
if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7623
save_libobjs=$libobjs
7626
output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7628
# Clear the reloadable object creation command queue and
7629
# initialize k to one.
7636
if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7637
output=${output_objdir}/${output_la}.lnkscript
7638
func_verbose "creating GNU ld script: $output"
7639
$ECHO 'INPUT (' > $output
7640
for obj in $save_libobjs
7642
$ECHO "$obj" >> $output
7644
$ECHO ')' >> $output
7645
delfiles="$delfiles $output"
7646
elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7647
output=${output_objdir}/${output_la}.lnk
7648
func_verbose "creating linker input file list: $output"
7653
if test "$compiler_needs_object" = yes; then
7659
$ECHO "$obj" >> $output
7661
delfiles="$delfiles $output"
7662
output=$firstobj\"$file_list_spec$output\"
7664
if test -n "$save_libobjs"; then
7665
func_verbose "creating reloadable object files..."
7666
output=$output_objdir/$output_la-${k}.$objext
7667
eval test_cmds=\"$reload_cmds\"
7668
func_len " $test_cmds"
7669
len0=$func_len_result
7672
# Loop over the list of objects to be linked.
7673
for obj in $save_libobjs
7676
func_arith $len + $func_len_result
7677
len=$func_arith_result
7678
if test "X$objlist" = X ||
7679
test "$len" -lt "$max_cmd_len"; then
7680
func_append objlist " $obj"
7682
# The command $test_cmds is almost too long, add a
7683
# command to the queue.
7684
if test "$k" -eq 1 ; then
7685
# The first file doesn't have a previous command to add.
7686
eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7688
# All subsequent reloadable object files will link in
7689
# the last one created.
7690
eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7692
last_robj=$output_objdir/$output_la-${k}.$objext
7694
k=$func_arith_result
7695
output=$output_objdir/$output_la-${k}.$objext
7697
func_len " $last_robj"
7698
func_arith $len0 + $func_len_result
7699
len=$func_arith_result
7702
# Handle the remaining objects by creating one last
7703
# reloadable object file. All subsequent reloadable object
7704
# files will link in the last one created.
7705
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7706
eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7707
if test -n "$last_robj"; then
7708
eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7710
delfiles="$delfiles $output"
7716
if ${skipped_export-false}; then
7717
func_verbose "generating symbol list for \`$libname.la'"
7718
export_symbols="$output_objdir/$libname.exp"
7719
$opt_dry_run || $RM $export_symbols
7721
# Append the command to create the export file.
7722
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7723
eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7724
if test -n "$last_robj"; then
7725
eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7729
test -n "$save_libobjs" &&
7730
func_verbose "creating a temporary reloadable object file: $output"
7732
# Loop through the commands generated above and execute them.
7733
save_ifs="$IFS"; IFS='~'
7734
for cmd in $concat_cmds; do
7737
func_quote_for_expand "$cmd"
7738
eval "func_echo $func_quote_for_expand_result"
7740
$opt_dry_run || eval "$cmd" || {
7743
# Restore the uninstalled library and exit
7744
if test "$mode" = relink; then
7745
( cd "$output_objdir" && \
7746
$RM "${realname}T" && \
7747
$MV "${realname}U" "$realname" )
7755
if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7756
func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7757
func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7761
if ${skipped_export-false}; then
7762
if test -n "$export_symbols" && test -n "$include_expsyms"; then
7763
tmp_export_symbols="$export_symbols"
7764
test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7765
$opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7768
if test -n "$orig_export_symbols"; then
7769
# The given exports_symbols file has to be filtered, so filter it.
7770
func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7771
# FIXME: $output_objdir/$libname.filter potentially contains lots of
7772
# 's' commands which not all seds can handle. GNU sed should be fine
7773
# though. Also, the filter scales superlinearly with the number of
7774
# global variables. join(1) would be nice here, but unfortunately
7775
# isn't a blessed tool.
7776
$opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7777
delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7778
export_symbols=$output_objdir/$libname.def
7779
$opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7784
# Restore the value of output.
7787
if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7788
eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7789
test "X$libobjs" = "X " && libobjs=
7791
# Expand the library linking commands again to reset the
7792
# value of $libobjs for piecewise linking.
7794
# Do each of the archive commands.
7795
if test "$module" = yes && test -n "$module_cmds" ; then
7796
if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7797
cmds=$module_expsym_cmds
7802
if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7803
cmds=$archive_expsym_cmds
7810
if test -n "$delfiles"; then
7811
# Append the command to remove temporary files to $cmds.
7812
eval cmds=\"\$cmds~\$RM $delfiles\"
7815
# Add any objects from preloaded convenience libraries
7816
if test -n "$dlprefiles"; then
7817
gentop="$output_objdir/${outputname}x"
7818
generated="$generated $gentop"
7820
func_extract_archives $gentop $dlprefiles
7821
libobjs="$libobjs $func_extract_archives_result"
7822
test "X$libobjs" = "X " && libobjs=
7825
save_ifs="$IFS"; IFS='~'
7826
for cmd in $cmds; do
7830
func_quote_for_expand "$cmd"
7831
eval "func_echo $func_quote_for_expand_result"
7833
$opt_dry_run || eval "$cmd" || {
7836
# Restore the uninstalled library and exit
7837
if test "$mode" = relink; then
7838
( cd "$output_objdir" && \
7839
$RM "${realname}T" && \
7840
$MV "${realname}U" "$realname" )
7848
# Restore the uninstalled library and exit
7849
if test "$mode" = relink; then
7850
$opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7852
if test -n "$convenience"; then
7853
if test -z "$whole_archive_flag_spec"; then
7854
func_show_eval '${RM}r "$gentop"'
7861
# Create links to the real library.
7862
for linkname in $linknames; do
7863
if test "$realname" != "$linkname"; then
7864
func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7868
# If -module or -export-dynamic was specified, set the dlname.
7869
if test "$module" = yes || test "$export_dynamic" = yes; then
7870
# On all known operating systems, these are identical.
7877
if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7878
func_warning "\`-dlopen' is ignored for objects"
7883
func_warning "\`-l' and \`-L' are ignored for objects" ;;
7886
test -n "$rpath" && \
7887
func_warning "\`-rpath' is ignored for objects"
7889
test -n "$xrpath" && \
7890
func_warning "\`-R' is ignored for objects"
7892
test -n "$vinfo" && \
7893
func_warning "\`-version-info' is ignored for objects"
7895
test -n "$release" && \
7896
func_warning "\`-release' is ignored for objects"
7900
test -n "$objs$old_deplibs" && \
7901
func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7905
obj=$func_lo2o_result
7913
# Delete the old objects.
7914
$opt_dry_run || $RM $obj $libobj
7916
# Objects from convenience libraries. This assumes
7917
# single-version convenience libraries. Whenever we create
7918
# different ones for PIC/non-PIC, this we'll have to duplicate
7922
# reload_cmds runs $LD directly, so let us get rid of
7923
# -Wl from whole_archive_flag_spec and hope we can get by with
7924
# turning comma into space..
7927
if test -n "$convenience"; then
7928
if test -n "$whole_archive_flag_spec"; then
7929
eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7930
reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7932
gentop="$output_objdir/${obj}x"
7933
generated="$generated $gentop"
7935
func_extract_archives $gentop $convenience
7936
reload_conv_objs="$reload_objs $func_extract_archives_result"
7940
# Create the old-style object.
7941
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
7944
func_execute_cmds "$reload_cmds" 'exit $?'
7946
# Exit if we aren't doing a library object file.
7947
if test -z "$libobj"; then
7948
if test -n "$gentop"; then
7949
func_show_eval '${RM}r "$gentop"'
7955
if test "$build_libtool_libs" != yes; then
7956
if test -n "$gentop"; then
7957
func_show_eval '${RM}r "$gentop"'
7960
# Create an invalid libtool object if no PIC, so that we don't
7961
# accidentally link it into a program.
7962
# $show "echo timestamp > $libobj"
7963
# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7967
if test -n "$pic_flag" || test "$pic_mode" != default; then
7968
# Only do commands if we really have different PIC objects.
7969
reload_objs="$libobjs $reload_conv_objs"
7971
func_execute_cmds "$reload_cmds" 'exit $?'
7974
if test -n "$gentop"; then
7975
func_show_eval '${RM}r "$gentop"'
7983
*cygwin*) func_stripname '' '.exe' "$output"
7984
output=$func_stripname_result.exe;;
7986
test -n "$vinfo" && \
7987
func_warning "\`-version-info' is ignored for programs"
7989
test -n "$release" && \
7990
func_warning "\`-release' is ignored for programs"
7992
test "$preload" = yes \
7993
&& test "$dlopen_support" = unknown \
7994
&& test "$dlopen_self" = unknown \
7995
&& test "$dlopen_self_static" = unknown && \
7996
func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7999
*-*-rhapsody* | *-*-darwin1.[012])
8000
# On Rhapsody replace the C library is the System framework
8001
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8002
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8008
# Don't allow lazy linking, it breaks C++ global constructors
8009
# But is supposedly fixed on 10.4 or later (yay!).
8010
if test "$tagname" = CXX ; then
8011
case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8013
compile_command="$compile_command ${wl}-bind_at_load"
8014
finalize_command="$finalize_command ${wl}-bind_at_load"
8018
# Time to change all our "foo.ltframework" stuff back to "-framework foo"
8019
compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8020
finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8025
# move library search paths that coincide with paths to not yet
8026
# installed libraries to the beginning of the library search list
8028
for path in $notinst_path; do
8029
case " $new_libs " in
8030
*" -L$path/$objdir "*) ;;
8032
case " $compile_deplibs " in
8033
*" -L$path/$objdir "*)
8034
new_libs="$new_libs -L$path/$objdir" ;;
8039
for deplib in $compile_deplibs; do
8042
case " $new_libs " in
8044
*) new_libs="$new_libs $deplib" ;;
8047
*) new_libs="$new_libs $deplib" ;;
8050
compile_deplibs="$new_libs"
8053
compile_command="$compile_command $compile_deplibs"
8054
finalize_command="$finalize_command $finalize_deplibs"
8056
if test -n "$rpath$xrpath"; then
8057
# If the user specified any rpath flags, then add them.
8058
for libdir in $rpath $xrpath; do
8059
# This is the magic to use -rpath.
8060
case "$finalize_rpath " in
8062
*) finalize_rpath="$finalize_rpath $libdir" ;;
8067
# Now hardcode the library paths
8070
for libdir in $compile_rpath $finalize_rpath; do
8071
if test -n "$hardcode_libdir_flag_spec"; then
8072
if test -n "$hardcode_libdir_separator"; then
8073
if test -z "$hardcode_libdirs"; then
8074
hardcode_libdirs="$libdir"
8076
# Just accumulate the unique libdirs.
8077
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8078
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8081
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8086
eval flag=\"$hardcode_libdir_flag_spec\"
8087
rpath="$rpath $flag"
8089
elif test -n "$runpath_var"; then
8090
case "$perm_rpath " in
8092
*) perm_rpath="$perm_rpath $libdir" ;;
8096
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8097
testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8098
case :$dllsearchpath: in
8100
::) dllsearchpath=$libdir;;
8101
*) dllsearchpath="$dllsearchpath:$libdir";;
8103
case :$dllsearchpath: in
8104
*":$testbindir:"*) ;;
8105
::) dllsearchpath=$testbindir;;
8106
*) dllsearchpath="$dllsearchpath:$testbindir";;
8111
# Substitute the hardcoded libdirs into the rpath.
8112
if test -n "$hardcode_libdir_separator" &&
8113
test -n "$hardcode_libdirs"; then
8114
libdir="$hardcode_libdirs"
8115
eval rpath=\" $hardcode_libdir_flag_spec\"
8117
compile_rpath="$rpath"
8121
for libdir in $finalize_rpath; do
8122
if test -n "$hardcode_libdir_flag_spec"; then
8123
if test -n "$hardcode_libdir_separator"; then
8124
if test -z "$hardcode_libdirs"; then
8125
hardcode_libdirs="$libdir"
8127
# Just accumulate the unique libdirs.
8128
case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8129
*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8132
hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8137
eval flag=\"$hardcode_libdir_flag_spec\"
8138
rpath="$rpath $flag"
8140
elif test -n "$runpath_var"; then
8141
case "$finalize_perm_rpath " in
8143
*) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8147
# Substitute the hardcoded libdirs into the rpath.
8148
if test -n "$hardcode_libdir_separator" &&
8149
test -n "$hardcode_libdirs"; then
8150
libdir="$hardcode_libdirs"
8151
eval rpath=\" $hardcode_libdir_flag_spec\"
8153
finalize_rpath="$rpath"
8155
if test -n "$libobjs" && test "$build_old_libs" = yes; then
8156
# Transform all the library objects into standard objects.
8157
compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8158
finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8161
func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8163
# template prelinking step
8164
if test -n "$prelink_cmds"; then
8165
func_execute_cmds "$prelink_cmds" 'exit $?'
8168
wrappers_required=yes
8170
*cygwin* | *mingw* )
8171
if test "$build_libtool_libs" != yes; then
8172
wrappers_required=no
8176
# Disable wrappers for cegcc, we are cross compiling anyway.
8177
wrappers_required=no
8180
if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8181
wrappers_required=no
8185
if test "$wrappers_required" = no; then
8186
# Replace the output file specification.
8187
compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8188
link_command="$compile_command$compile_rpath"
8190
# We have no uninstalled library dependencies, so finalize right now.
8192
func_show_eval "$link_command" 'exit_status=$?'
8194
# Delete the generated files.
8195
if test -f "$output_objdir/${outputname}S.${objext}"; then
8196
func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8202
if test -n "$compile_shlibpath$finalize_shlibpath"; then
8203
compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8205
if test -n "$finalize_shlibpath"; then
8206
finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8211
if test -n "$runpath_var"; then
8212
if test -n "$perm_rpath"; then
8213
# We should set the runpath_var.
8215
for dir in $perm_rpath; do
8218
compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8220
if test -n "$finalize_perm_rpath"; then
8221
# We should set the runpath_var.
8223
for dir in $finalize_perm_rpath; do
8226
finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8230
if test "$no_install" = yes; then
8231
# We don't need to create a wrapper script.
8232
link_command="$compile_var$compile_command$compile_rpath"
8233
# Replace the output file specification.
8234
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8235
# Delete the old output file.
8236
$opt_dry_run || $RM $output
8237
# Link the executable and exit
8238
func_show_eval "$link_command" 'exit $?'
8242
if test "$hardcode_action" = relink; then
8243
# Fast installation is not supported
8244
link_command="$compile_var$compile_command$compile_rpath"
8245
relink_command="$finalize_var$finalize_command$finalize_rpath"
8247
func_warning "this platform does not like uninstalled shared libraries"
8248
func_warning "\`$output' will be relinked during installation"
8250
if test "$fast_install" != no; then
8251
link_command="$finalize_var$compile_command$finalize_rpath"
8252
if test "$fast_install" = yes; then
8253
relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8255
# fast_install is set to needless
8259
link_command="$compile_var$compile_command$compile_rpath"
8260
relink_command="$finalize_var$finalize_command$finalize_rpath"
8264
# Replace the output file specification.
8265
link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8267
# Delete the old output files.
8268
$opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8270
func_show_eval "$link_command" 'exit $?'
8272
# Now create the wrapper script.
8273
func_verbose "creating $output"
8275
# Quote the relink command for shipping.
8276
if test -n "$relink_command"; then
8277
# Preserve any variables that may affect compiler behavior
8278
for var in $variables_saved_for_relink; do
8279
if eval test -z \"\${$var+set}\"; then
8280
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8281
elif eval var_value=\$$var; test -z "$var_value"; then
8282
relink_command="$var=; export $var; $relink_command"
8284
func_quote_for_eval "$var_value"
8285
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8288
relink_command="(cd `pwd`; $relink_command)"
8289
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8292
# Quote $ECHO for shipping.
8293
if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
8295
[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
8296
*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
8298
qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
8300
qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
8303
# Only actually do things if not in dry run mode.
8305
# win32 will think the script is a binary if it has
8306
# a .exe suffix, so we strip it off here.
8308
*.exe) func_stripname '' '.exe' "$output"
8309
output=$func_stripname_result ;;
8311
# test for cygwin because mv fails w/o .exe extensions
8315
func_stripname '' '.exe' "$outputname"
8316
outputname=$func_stripname_result ;;
8320
*cygwin* | *mingw* )
8321
func_dirname_and_basename "$output" "" "."
8322
output_name=$func_basename_result
8323
output_path=$func_dirname_result
8324
cwrappersource="$output_path/$objdir/lt-$output_name.c"
8325
cwrapper="$output_path/$output_name.exe"
8326
$RM $cwrappersource $cwrapper
8327
trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8329
func_emit_cwrapperexe_src > $cwrappersource
8331
# The wrapper executable is built using the $host compiler,
8332
# because it contains $host paths and files. If cross-
8333
# compiling, it, like the target executable, must be
8334
# executed on the $host or under an emulation environment.
8336
$LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8340
# Now, create the wrapper script for func_source use:
8341
func_ltwrapper_scriptname $cwrapper
8342
$RM $func_ltwrapper_scriptname_result
8343
trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8345
# note: this script will not be executed, so do not chmod.
8346
if test "x$build" = "x$host" ; then
8347
$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8349
func_emit_wrapper no > $func_ltwrapper_scriptname_result
8355
trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8357
func_emit_wrapper no > $output
8366
# See if we need to build an old-fashioned archive.
8367
for oldlib in $oldlibs; do
8369
if test "$build_libtool_libs" = convenience; then
8370
oldobjs="$libobjs_save $symfileobj"
8371
addlibs="$convenience"
8372
build_libtool_libs=no
8374
if test "$build_libtool_libs" = module; then
8375
oldobjs="$libobjs_save"
8376
build_libtool_libs=no
8378
oldobjs="$old_deplibs $non_pic_objects"
8379
if test "$preload" = yes && test -f "$symfileobj"; then
8380
oldobjs="$oldobjs $symfileobj"
8383
addlibs="$old_convenience"
8386
if test -n "$addlibs"; then
8387
gentop="$output_objdir/${outputname}x"
8388
generated="$generated $gentop"
8390
func_extract_archives $gentop $addlibs
8391
oldobjs="$oldobjs $func_extract_archives_result"
8394
# Do each command in the archive commands.
8395
if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8396
cmds=$old_archive_from_new_cmds
8399
# Add any objects from preloaded convenience libraries
8400
if test -n "$dlprefiles"; then
8401
gentop="$output_objdir/${outputname}x"
8402
generated="$generated $gentop"
8404
func_extract_archives $gentop $dlprefiles
8405
oldobjs="$oldobjs $func_extract_archives_result"
8408
# POSIX demands no paths to be encoded in archives. We have
8409
# to avoid creating archives with duplicate basenames if we
8410
# might have to extract them afterwards, e.g., when creating a
8411
# static archive out of a convenience library, or when linking
8412
# the entirety of a libtool archive into another (currently
8413
# not supported by libtool).
8414
if (for obj in $oldobjs
8416
func_basename "$obj"
8417
$ECHO "$func_basename_result"
8418
done | sort | sort -uc >/dev/null 2>&1); then
8421
$ECHO "copying selected object files to avoid basename conflicts..."
8422
gentop="$output_objdir/${outputname}x"
8423
generated="$generated $gentop"
8424
func_mkdir_p "$gentop"
8425
save_oldobjs=$oldobjs
8428
for obj in $save_oldobjs
8430
func_basename "$obj"
8431
objbase="$func_basename_result"
8432
case " $oldobjs " in
8433
" ") oldobjs=$obj ;;
8436
# Make sure we don't pick an alternate name that also
8438
newobj=lt$counter-$objbase
8439
func_arith $counter + 1
8440
counter=$func_arith_result
8441
case " $oldobjs " in
8442
*[\ /]"$newobj "*) ;;
8443
*) if test ! -f "$gentop/$newobj"; then break; fi ;;
8446
func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8447
oldobjs="$oldobjs $gentop/$newobj"
8449
*) oldobjs="$oldobjs $obj" ;;
8453
eval cmds=\"$old_archive_cmds\"
8456
len=$func_len_result
8457
if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8458
cmds=$old_archive_cmds
8460
# the command line is too long to link in one step, link in parts
8461
func_verbose "using piecewise archive linking..."
8466
save_oldobjs=$oldobjs
8468
# Is there a better way of finding the last object in the list?
8469
for obj in $save_oldobjs
8473
eval test_cmds=\"$old_archive_cmds\"
8474
func_len " $test_cmds"
8475
len0=$func_len_result
8477
for obj in $save_oldobjs
8480
func_arith $len + $func_len_result
8481
len=$func_arith_result
8482
func_append objlist " $obj"
8483
if test "$len" -lt "$max_cmd_len"; then
8486
# the above command should be used before it gets too long
8488
if test "$obj" = "$last_oldobj" ; then
8491
test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8492
eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8499
if test "X$oldobjs" = "X" ; then
8500
eval cmds=\"\$concat_cmds\"
8502
eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8506
func_execute_cmds "$cmds" 'exit $?'
8509
test -n "$generated" && \
8510
func_show_eval "${RM}r$generated"
8512
# Now create the libtool archive.
8516
test "$build_old_libs" = yes && old_library="$libname.$libext"
8517
func_verbose "creating $output"
8519
# Preserve any variables that may affect compiler behavior
8520
for var in $variables_saved_for_relink; do
8521
if eval test -z \"\${$var+set}\"; then
8522
relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8523
elif eval var_value=\$$var; test -z "$var_value"; then
8524
relink_command="$var=; export $var; $relink_command"
8526
func_quote_for_eval "$var_value"
8527
relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8530
# Quote the link command for shipping.
8531
relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8532
relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8533
if test "$hardcode_automatic" = yes ; then
8537
# Only create the output if not a dry run.
8539
for installed in no yes; do
8540
if test "$installed" = yes; then
8541
if test -z "$install_libdir"; then
8544
output="$output_objdir/$outputname"i
8545
# Replace all uninstalled libtool libraries with the installed ones
8547
for deplib in $dependency_libs; do
8550
func_basename "$deplib"
8551
name="$func_basename_result"
8552
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8553
test -z "$libdir" && \
8554
func_fatal_error "\`$deplib' is not a valid libtool archive"
8555
newdependency_libs="$newdependency_libs $libdir/$name"
8557
*) newdependency_libs="$newdependency_libs $deplib" ;;
8560
dependency_libs="$newdependency_libs"
8563
for lib in $dlfiles; do
8566
func_basename "$lib"
8567
name="$func_basename_result"
8568
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8569
test -z "$libdir" && \
8570
func_fatal_error "\`$lib' is not a valid libtool archive"
8571
newdlfiles="$newdlfiles $libdir/$name"
8573
*) newdlfiles="$newdlfiles $lib" ;;
8576
dlfiles="$newdlfiles"
8578
for lib in $dlprefiles; do
8581
# Only pass preopened files to the pseudo-archive (for
8582
# eventual linking with the app. that links it) if we
8583
# didn't already link the preopened objects directly into
8585
func_basename "$lib"
8586
name="$func_basename_result"
8587
eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8588
test -z "$libdir" && \
8589
func_fatal_error "\`$lib' is not a valid libtool archive"
8590
newdlprefiles="$newdlprefiles $libdir/$name"
8594
dlprefiles="$newdlprefiles"
8597
for lib in $dlfiles; do
8599
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8600
*) abs=`pwd`"/$lib" ;;
8602
newdlfiles="$newdlfiles $abs"
8604
dlfiles="$newdlfiles"
8606
for lib in $dlprefiles; do
8608
[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8609
*) abs=`pwd`"/$lib" ;;
8611
newdlprefiles="$newdlprefiles $abs"
8613
dlprefiles="$newdlprefiles"
8616
# place dlname in correct position for cygwin
8618
case $host,$output,$installed,$module,$dlname in
8619
*cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8622
# $outputname - a libtool library file
8623
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8625
# Please DO NOT delete this file!
8626
# It is necessary for linking the library.
8628
# The name that we can dlopen(3).
8631
# Names of this library.
8632
library_names='$library_names'
8634
# The name of the static archive.
8635
old_library='$old_library'
8637
# Linker flags that can not go in dependency_libs.
8638
inherited_linker_flags='$new_inherited_linker_flags'
8640
# Libraries that this one depends upon.
8641
dependency_libs='$dependency_libs'
8643
# Names of additional weak libraries provided by this library
8644
weak_library_names='$weak_libs'
8646
# Version information for $libname.
8651
# Is this an already installed library?
8652
installed=$installed
8654
# Should we warn about portability when linking against -modules?
8655
shouldnotlink=$module
8657
# Files to dlopen/dlpreopen
8659
dlpreopen='$dlprefiles'
8661
# Directory that this library needs to be installed in:
8662
libdir='$install_libdir'"
8663
if test "$installed" = no && test "$need_relink" = yes; then
8665
relink_command=\"$relink_command\""
8670
# Do a symbolic link so that the libtool archive can be found in
8671
# LD_LIBRARY_PATH before the program is installed.
8672
func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8678
{ test "$mode" = link || test "$mode" = relink; } &&
8679
func_mode_link ${1+"$@"}
8682
# func_mode_uninstall arg...
8683
func_mode_uninstall ()
8691
# This variable tells wrapper scripts just to set variables rather
8692
# than running their programs.
8693
libtool_install_magic="$magic"
8698
-f) RM="$RM $arg"; rmforce=yes ;;
8699
-*) RM="$RM $arg" ;;
8700
*) files="$files $arg" ;;
8705
func_fatal_help "you must specify an RM program"
8709
origobjdir="$objdir"
8710
for file in $files; do
8711
func_dirname "$file" "" "."
8712
dir="$func_dirname_result"
8713
if test "X$dir" = X.; then
8714
objdir="$origobjdir"
8716
objdir="$dir/$origobjdir"
8718
func_basename "$file"
8719
name="$func_basename_result"
8720
test "$mode" = uninstall && objdir="$dir"
8722
# Remember objdir for removal later, being careful to avoid duplicates
8723
if test "$mode" = clean; then
8726
*) rmdirs="$rmdirs $objdir" ;;
8730
# Don't error if the file doesn't exist and rm -f was used.
8731
if { test -L "$file"; } >/dev/null 2>&1 ||
8732
{ test -h "$file"; } >/dev/null 2>&1 ||
8733
test -f "$file"; then
8735
elif test -d "$file"; then
8738
elif test "$rmforce" = yes; then
8746
# Possibly a libtool archive, so verify it.
8747
if func_lalib_p "$file"; then
8748
func_source $dir/$name
8750
# Delete the libtool libraries and symlinks.
8751
for n in $library_names; do
8752
rmfiles="$rmfiles $objdir/$n"
8754
test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8758
case " $library_names " in
8759
# " " in the beginning catches empty $dlname
8761
*) rmfiles="$rmfiles $objdir/$dlname" ;;
8763
test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8766
if test -n "$library_names"; then
8767
# Do each command in the postuninstall commands.
8768
func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8771
if test -n "$old_library"; then
8772
# Do each command in the old_postuninstall commands.
8773
func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8775
# FIXME: should reinstall the best remaining shared library.
8782
# Possibly a libtool object, so verify it.
8783
if func_lalib_p "$file"; then
8786
func_source $dir/$name
8788
# Add PIC object to the list of files to remove.
8789
if test -n "$pic_object" &&
8790
test "$pic_object" != none; then
8791
rmfiles="$rmfiles $dir/$pic_object"
8794
# Add non-PIC object to the list of files to remove.
8795
if test -n "$non_pic_object" &&
8796
test "$non_pic_object" != none; then
8797
rmfiles="$rmfiles $dir/$non_pic_object"
8803
if test "$mode" = clean ; then
8807
func_stripname '' '.exe' "$file"
8808
file=$func_stripname_result
8809
func_stripname '' '.exe' "$name"
8810
noexename=$func_stripname_result
8811
# $file with .exe has already been added to rmfiles,
8812
# add $file without .exe
8813
rmfiles="$rmfiles $file"
8816
# Do a test to see if this is a libtool program.
8817
if func_ltwrapper_p "$file"; then
8818
if func_ltwrapper_executable_p "$file"; then
8819
func_ltwrapper_scriptname "$file"
8821
func_source $func_ltwrapper_scriptname_result
8822
rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8825
func_source $dir/$noexename
8828
# note $name still contains .exe if it was in $file originally
8829
# as does the version of $file that was added into $rmfiles
8830
rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8831
if test "$fast_install" = yes && test -n "$relink_command"; then
8832
rmfiles="$rmfiles $objdir/lt-$name"
8834
if test "X$noexename" != "X$name" ; then
8835
rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8841
func_show_eval "$RM $rmfiles" 'exit_status=1'
8843
objdir="$origobjdir"
8845
# Try to remove the ${objdir}s in the directories where we deleted files
8846
for dir in $rmdirs; do
8847
if test -d "$dir"; then
8848
func_show_eval "rmdir $dir >/dev/null 2>&1"
8855
{ test "$mode" = uninstall || test "$mode" = clean; } &&
8856
func_mode_uninstall ${1+"$@"}
8858
test -z "$mode" && {
8859
help="$generic_help"
8860
func_fatal_help "you must specify a MODE"
8863
test -z "$exec_cmd" && \
8864
func_fatal_help "invalid operation mode \`$mode'"
8866
if test -n "$exec_cmd"; then
8867
eval exec "$exec_cmd"
8874
# The TAGs below are defined such that we never get into a situation
8875
# in which we disable both kinds of libraries. Given conflicting
8876
# choices, we go for a static library, that is the most portable,
8877
# since we can't tell whether shared libraries were disabled because
8878
# the user asked for that or because the platform doesn't support
8879
# them. This is particularly important on AIX, because we don't
8880
# support having both static and shared libraries enabled at the same
8881
# time on that platform, so we default to a shared-only configuration.
8882
# If a disable-shared tag is given, we'll fallback to a static-only
8883
# configuration. But we'll never go from static-only to shared-only.
8885
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8886
build_libtool_libs=no
8888
# ### END LIBTOOL TAG CONFIG: disable-shared
8890
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
8891
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8892
# ### END LIBTOOL TAG CONFIG: disable-static