3 # libtool - Provide generalized library-building support services.
4 # Generated automatically by config.status (fftw) 3.3
5 # Libtool was configured on host titan:
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 # Whether or not to build shared libraries.
47 # DLL creation program.
50 # Object dumper program.
53 # Which release of libtool.m4 was used?
57 # Whether or not to build static libraries.
60 # What type of objects to build.
63 # Whether or not to optimize for fast installation.
68 host=i686-pc-linux-gnu
73 build=i686-pc-linux-gnu
76 # A sed program that does not truncate output.
79 # Sed that helps us avoid accidentally triggering echo(1) options like -n.
80 Xsed="$SED -e 1s/^X//"
82 # A grep program that handles long lines.
88 # A literal string matcher.
91 # A BSD- or MS-compatible name lister.
94 # Whether we need soft or hard links.
97 # What is the maximum length of a command?
100 # Object file suffix (normally "o").
103 # Executable file suffix (normally "").
106 # whether the shell understands "unset".
109 # turn spaces into newlines.
110 SP2NL="tr \\040 \\012"
112 # turn newlines into spaces.
113 NL2SP="tr \\015\\012 \\040\\040"
115 # How to create reloadable object files.
117 reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
119 # Method to check whether dependent libraries are shared objects.
120 deplibs_check_method="pass_all"
122 # Command to use when deplibs_check_method == "file_magic".
123 file_magic_cmd="\$MAGIC_CMD"
129 # A symbol stripping program.
132 # Commands used to install an old-style archive.
134 old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
135 old_postuninstall_cmds=""
138 LTCC="gcc -std=gnu99"
140 # LTCC compiler flags.
141 LTCFLAGS="-O3 -fomit-frame-pointer -mtune=native -malign-double -fstrict-aliasing -ffast-math"
143 # Take the output of nm and produce a listing of raw symbols and C names.
144 global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"
146 # Transform the output of nm in a proper C declaration.
147 global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
149 # Transform the output of nm in a C name address pair.
150 global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (void *) \\&\\2},/p'"
152 # Transform the output of nm in a C name address pair when lib prefix is needed.
153 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'"
155 # The name of the directory that contains temporary libtool files.
158 # Shell to use when invoking shell scripts.
161 # An echo program that does not interpret backslashes.
164 # Used to examine libraries when file_magic_cmd begins with "file".
167 # Must we lock files when doing compilation?
170 # Tool to manipulate archived DWARF debug symbol files on Mac OS X.
173 # Tool to change global to local symbols on Mac OS X.
176 # Tool to manipulate fat objects and archives on Mac OS X.
179 # ldd/readelf like tool for Mach-O binaries on Mac OS X.
182 # ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
185 # Old archive suffix (normally "a").
188 # Shared library suffix (normally ".so").
191 # The commands to extract the exported symbol list from a shared archive.
192 extract_expsyms_cmds=""
194 # Variables whose values should be saved in libtool wrapper scripts and
195 # restored at link time.
196 variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
198 # Do we need the "lib" prefix for modules?
201 # Do we need a version for libraries?
204 # Library versioning type.
207 # Shared library runtime path variable.
208 runpath_var=LD_RUN_PATH
210 # Shared library path variable.
211 shlibpath_var=LD_LIBRARY_PATH
213 # Is shlibpath searched before the hard-coded library search path?
214 shlibpath_overrides_runpath=no
216 # Format of library name prefix.
217 libname_spec="lib\$name"
219 # List of archive names. First name is the real one, the rest are links.
220 # The last name is the one that the linker finds with -lNAME
221 library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"
223 # The coded name of the library, if different from the real name.
224 soname_spec="\${libname}\${release}\${shared_ext}\$major"
226 # Command to use after installation of a shared archive.
229 # Command to use after uninstallation of a shared archive.
230 postuninstall_cmds=""
232 # Commands used to finish a libtool library installation in a directory.
233 finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
235 # As "finish_cmds", except a single script fragment to be evaled but
239 # Whether we should hardcode library paths into libraries.
240 hardcode_into_libs=yes
242 # Compile-time system search path for libraries.
243 sys_lib_search_path_spec="/usr/lib/gcc/i486-linux-gnu/4.4.3 /usr/lib /lib /usr/lib/i486-linux-gnu"
245 # Run-time system search path for libraries.
246 sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/nvidia-current /lib/i486-linux-gnu /usr/lib/i486-linux-gnu /usr/lib/alsa-lib /usr/local/lib "
248 # Whether dlopen is supported.
249 dlopen_support=unknown
251 # Whether dlopen of programs is supported.
254 # Whether dlopen of statically linked programs is supported.
255 dlopen_self_static=unknown
257 # Commands to strip libraries.
258 old_striplib="strip --strip-debug"
259 striplib="strip --strip-unneeded"
262 # The linker used to build libraries.
265 # Commands used to build an old-style archive.
266 old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
268 # A language specific compiler.
271 # Is the compiler the GNU compiler?
274 # Compiler flag to turn off builtin functions.
275 no_builtin_flag=" -fno-builtin"
277 # How to pass a linker flag through the compiler.
280 # Additional compiler flags for building library objects.
281 pic_flag=" -fPIC -DPIC"
283 # Compiler flag to prevent dynamic linking.
286 # Does compiler simultaneously support -c and -o options?
289 # Whether or not to add -lc for building shared libraries.
290 build_libtool_need_lc=yes
292 # Whether or not to disallow shared libs when runtime libs are static.
293 allow_libtool_libs_with_static_runtimes=no
295 # Compiler flag to allow reflexive dlopens.
296 export_dynamic_flag_spec="\${wl}--export-dynamic"
298 # Compiler flag to generate shared objects directly from archives.
299 whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
301 # Whether the compiler copes with passing no objects directly.
302 compiler_needs_object="no"
304 # Create an old-style archive from a shared archive.
305 old_archive_from_new_cmds=""
307 # Create a temporary old-style archive to link instead of a shared archive.
308 old_archive_from_expsyms_cmds=""
310 # Commands used to build a shared archive.
311 archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
312 archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
313 cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
314 echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
315 \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"
317 # Commands used to build a loadable module if different from building
320 module_expsym_cmds=""
322 # Whether we are building with GNU ld or not.
325 # Flag that allows shared libraries with undefined symbols to be built.
326 allow_undefined_flag=""
328 # Flag that enforces no undefined symbols.
331 # Flag to hardcode $libdir into a binary during linking.
332 # This must work even if $libdir does not exist
333 hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"
335 # If ld is used when linking, flag to hardcode $libdir into a binary
336 # during linking. This must work even if $libdir does not exist.
337 hardcode_libdir_flag_spec_ld=""
339 # Whether we need a single "-rpath" flag with a separated argument.
340 hardcode_libdir_separator=""
342 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
343 # DIR into the resulting binary.
346 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
347 # DIR into the resulting binary and the resulting library dependency is
348 # "absolute",i.e impossible to change by setting ${shlibpath_var} if the
349 # library is relocated.
350 hardcode_direct_absolute=no
352 # Set to "yes" if using the -LDIR flag during linking hardcodes DIR
353 # into the resulting binary.
356 # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
357 # into the resulting binary.
358 hardcode_shlibpath_var=unsupported
360 # Set to "yes" if building a shared library automatically hardcodes DIR
361 # into the library and all subsequent libraries and executables linked
363 hardcode_automatic=no
365 # Set to yes if linker adds runtime paths of dependent libraries
366 # to runtime path list.
369 # Whether libtool must link a program against all its dependency libraries.
372 # Fix the shell variable $srcfile for the compiler.
375 # Set to "yes" if exported symbols are required.
376 always_export_symbols=no
378 # The commands to list exported symbols.
379 export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
381 # Symbols that should not be listed in the preloaded symbols.
382 exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
384 # Symbols that must always be exported.
387 # Commands necessary for linking programs (against libraries) with templates.
390 # Specify filename containing input files.
393 # How to hardcode a shared library path into an executable.
394 hardcode_action=immediate
396 # ### END LIBTOOL CONFIG
398 # Generated from ltmain.m4sh.
400 # ltmain.sh (GNU libtool) 2.2.6b
401 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
403 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
404 # This is free software; see the source for copying conditions. There is NO
405 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
407 # GNU Libtool is free software; you can redistribute it and/or modify
408 # it under the terms of the GNU General Public License as published by
409 # the Free Software Foundation; either version 2 of the License, or
410 # (at your option) any later version.
412 # As a special exception to the GNU General Public License,
413 # if you distribute this file as part of a program or library that
414 # is built using GNU Libtool, you may include this file under the
415 # same distribution terms that you use for the rest of that program.
417 # GNU Libtool is distributed in the hope that it will be useful, but
418 # WITHOUT ANY WARRANTY; without even the implied warranty of
419 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
420 # General Public License for more details.
422 # You should have received a copy of the GNU General Public License
423 # along with GNU Libtool; see the file COPYING. If not, a copy
424 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
425 # or obtained by writing to the Free Software Foundation, Inc.,
426 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
428 # Usage: $progname [OPTION]... [MODE-ARG]...
430 # Provide generalized library-building support services.
432 # --config show all configuration variables
433 # --debug enable verbose shell tracing
434 # -n, --dry-run display commands without modifying any files
435 # --features display basic configuration information and exit
436 # --mode=MODE use operation mode MODE
437 # --preserve-dup-deps don't remove duplicate dependency libraries
438 # --quiet, --silent don't print informational messages
439 # --tag=TAG use configuration variables from tag TAG
440 # -v, --verbose print informational messages (default)
441 # --version print version information
442 # -h, --help print short or long help message
444 # MODE must be one of the following:
446 # clean remove files from the build directory
447 # compile compile a source file into a libtool object
448 # execute automatically set library path, then run a program
449 # finish complete the installation of libtool libraries
450 # install install libraries or executables
451 # link create a library or an executable
452 # uninstall remove libraries from an installed directory
454 # MODE-ARGS vary depending on the MODE.
455 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
457 # When reporting a bug, please describe a test case to reproduce it and
458 # include the following information:
460 # host-triplet: $host
463 # compiler flags: $LTCFLAGS
464 # linker: $LD (gnu? $with_gnu_ld)
465 # $progname: (GNU libtool) 2.2.6b Debian-2.2.6b-2
466 # automake: $automake_version
467 # autoconf: $autoconf_version
469 # Report bugs to <bug-libtool@gnu.org>.
473 VERSION="2.2.6b Debian-2.2.6b-2"
475 package_revision=1.3017
477 # Be Bourne compatible
478 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
481 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
482 # is contrary to our usage. Disable this feature.
483 alias -g '${1+"$@"}'='"$@"'
486 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
488 BIN_SH=xpg4; export BIN_SH # for Tru64
489 DUALCASE=1; export DUALCASE # for MKS sh
491 # NLS nuisances: We save the old values to restore during execute mode.
492 # Only set LANG and LC_ALL to C if already set.
493 # These must not be set unconditionally because not all systems understand
494 # e.g. LANG=C (notably SCO).
497 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
499 eval "if test \"\${$lt_var+set}\" = set; then
500 save_$lt_var=\$$lt_var
503 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
504 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
516 : ${EGREP="/bin/grep -E"}
517 : ${FGREP="/bin/grep -F"}
518 : ${GREP="/bin/grep"}
525 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
526 : ${Xsed="$SED -e 1s/^X//"}
531 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
532 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
534 exit_status=$EXIT_SUCCESS
536 # Make sure IFS has a sensible default
541 dirname="s,/[^/]*$,,"
544 # func_dirname_and_basename file append nondir_replacement
545 # perform func_basename and func_dirname in a single function
547 # dirname: Compute the dirname of FILE. If nonempty,
548 # add APPEND to the result, otherwise set result
549 # to NONDIR_REPLACEMENT.
550 # value returned in "$func_dirname_result"
551 # basename: Compute filename of FILE.
552 # value retuned in "$func_basename_result"
553 # Implementation must be kept synchronized with func_dirname
554 # and func_basename. For efficiency, we do not delegate to
555 # those functions but instead duplicate the functionality here.
556 func_dirname_and_basename ()
558 # Extract subdirectory from the argument.
559 func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
560 if test "X$func_dirname_result" = "X${1}"; then
561 func_dirname_result="${3}"
563 func_dirname_result="$func_dirname_result${2}"
565 func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
568 # Generated shell functions inserted here.
570 # func_dirname file append nondir_replacement
571 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
572 # otherwise set result to NONDIR_REPLACEMENT.
576 */*) func_dirname_result="${1%/*}${2}" ;;
577 * ) func_dirname_result="${3}" ;;
584 func_basename_result="${1##*/}"
587 # func_dirname_and_basename file append nondir_replacement
588 # perform func_basename and func_dirname in a single function
590 # dirname: Compute the dirname of FILE. If nonempty,
591 # add APPEND to the result, otherwise set result
592 # to NONDIR_REPLACEMENT.
593 # value returned in "$func_dirname_result"
594 # basename: Compute filename of FILE.
595 # value retuned in "$func_basename_result"
596 # Implementation must be kept synchronized with func_dirname
597 # and func_basename. For efficiency, we do not delegate to
598 # those functions but instead duplicate the functionality here.
599 func_dirname_and_basename ()
602 */*) func_dirname_result="${1%/*}${2}" ;;
603 * ) func_dirname_result="${3}" ;;
605 func_basename_result="${1##*/}"
608 # func_stripname prefix suffix name
609 # strip PREFIX and SUFFIX off of NAME.
610 # PREFIX and SUFFIX must not contain globbing or regex special
611 # characters, hashes, percent signs, but SUFFIX may contain a leading
612 # dot (in which case that matches only a dot).
615 # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
616 # positional parameters, so assign one to ordinary parameter first.
617 func_stripname_result=${3}
618 func_stripname_result=${func_stripname_result#"${1}"}
619 func_stripname_result=${func_stripname_result%"${2}"}
625 func_opt_split_opt=${1%%=*}
626 func_opt_split_arg=${1#*=}
633 *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
634 *) func_lo2o_result=${1} ;;
638 # func_xform libobj-or-source
641 func_xform_result=${1%.*}.lo
644 # func_arith arithmetic-term...
647 func_arith_result=$(( $* ))
651 # STRING may not start with a hyphen.
654 func_len_result=${#1}
658 # func_append var value
659 # Append VALUE to the end of shell variable VAR.
664 # Generated shell functions inserted here.
666 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
667 # is ksh but when the shell is invoked as "sh" and the current value of
668 # the _XPG environment variable is not equal to 1 (one), the special
669 # positional parameter $0, within a function call, is the name of the
673 # The name of this program:
674 # In the unlikely event $progname began with a '-', it would play havoc with
675 # func_echo (imagine progname=-n), so we prepend ./ in that case:
676 func_dirname_and_basename "$progpath"
677 progname=$func_basename_result
679 -*) progname=./$progname ;;
682 # Make sure we have an absolute path for reexecution:
684 [\\/]*|[A-Za-z]:\\*) ;;
686 progdir=$func_dirname_result
687 progdir=`cd "$progdir" && pwd`
688 progpath="$progdir/$progname"
693 for progdir in $PATH; do
695 test -x "$progdir/$progname" && break
698 test -n "$progdir" || progdir=`pwd`
699 progpath="$progdir/$progname"
703 # Sed substitution that helps us do robust quoting. It backslashifies
704 # metacharacters that are still active within double-quoted strings.
705 Xsed="${SED}"' -e 1s/^X//'
706 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
708 # Same as above, but do not quote variable references.
709 double_quote_subst='s/\(["`\\]\)/\\\1/g'
711 # Re-`\' parameter expansions in output of double_quote_subst that were
712 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
713 # in input to double_quote_subst, that '$' was protected from expansion.
714 # Since each input `\' is now two `\'s, look for any number of runs of
715 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
720 sed_double_backslash="\
724 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
735 # Echo program name prefixed message, along with the current mode
736 # name if it has been set yet.
739 $ECHO "$progname${mode+: }$mode: $*"
742 # func_verbose arg...
743 # Echo program name prefixed message in verbose mode only.
746 $opt_verbose && func_echo ${1+"$@"}
748 # A bug in bash halts the script if the last line of a function
749 # fails when set -e is in force, so we need another command to
755 # Echo program name prefixed message to standard error.
758 $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
761 # func_warning arg...
762 # Echo program name prefixed warning message to standard error.
765 $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
771 # func_fatal_error arg...
772 # Echo program name prefixed message to standard error, and exit.
779 # func_fatal_help arg...
780 # Echo program name prefixed message to standard error, followed by
781 # a help hint, and exit.
785 func_fatal_error "$help"
787 help="Try \`$progname --help' for more information." ## default
790 # func_grep expression filename
791 # Check whether EXPRESSION matches any line of FILENAME, without output.
794 $GREP "$1" "$2" >/dev/null 2>&1
798 # func_mkdir_p directory-path
799 # Make sure the entire path to DIRECTORY-PATH is available.
802 my_directory_path="$1"
805 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
807 # Protect directory names starting with `-'
808 case $my_directory_path in
809 -*) my_directory_path="./$my_directory_path" ;;
812 # While some portion of DIR does not yet exist...
813 while test ! -d "$my_directory_path"; do
814 # ...make a list in topmost first order. Use a colon delimited
815 # list incase some portion of path contains whitespace.
816 my_dir_list="$my_directory_path:$my_dir_list"
818 # If the last portion added has no slash in it, the list is done
819 case $my_directory_path in */*) ;; *) break ;; esac
821 # ...otherwise throw away the child directory and loop
822 my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
824 my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
826 save_mkdir_p_IFS="$IFS"; IFS=':'
827 for my_dir in $my_dir_list; do
828 IFS="$save_mkdir_p_IFS"
829 # mkdir can fail with a `File exist' error if two processes
830 # try to create one of the directories concurrently. Don't
832 $MKDIR "$my_dir" 2>/dev/null || :
834 IFS="$save_mkdir_p_IFS"
836 # Bail out if we (or some other process) failed to create a directory.
837 test -d "$my_directory_path" || \
838 func_fatal_error "Failed to create \`$1'"
843 # func_mktempdir [string]
844 # Make a temporary directory that won't clash with other running
845 # libtool processes, and avoids race conditions if possible. If
846 # given, STRING is the basename for that directory.
849 my_template="${TMPDIR-/tmp}/${1-$progname}"
851 if test "$opt_dry_run" = ":"; then
852 # Return a directory name, but don't create it in dry-run mode
853 my_tmpdir="${my_template}-$$"
856 # If mktemp works, use that first and foremost
857 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
859 if test ! -d "$my_tmpdir"; then
860 # Failing that, at least try and use $RANDOM to avoid a race
861 my_tmpdir="${my_template}-${RANDOM-0}$$"
863 save_mktempdir_umask=`umask`
866 umask $save_mktempdir_umask
869 # If we're not in dry-run mode, bomb out on failure
870 test -d "$my_tmpdir" || \
871 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
874 $ECHO "X$my_tmpdir" | $Xsed
878 # func_quote_for_eval arg
879 # Aesthetically quote ARG to be evaled later.
880 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
881 # is double-quoted, suitable for a subsequent eval, whereas
882 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
883 # which are still active within double quotes backslashified.
884 func_quote_for_eval ()
888 func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
890 func_quote_for_eval_unquoted_result="$1" ;;
893 case $func_quote_for_eval_unquoted_result in
894 # Double-quote args containing shell metacharacters to delay
895 # word splitting, command substitution and and variable
896 # expansion for a subsequent eval.
897 # Many Bourne shells cannot handle close brackets correctly
898 # in scan sets, so we specify it separately.
899 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
900 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
903 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
908 # func_quote_for_expand arg
909 # Aesthetically quote ARG to be evaled later; same as above,
910 # but do not quote variable references.
911 func_quote_for_expand ()
915 my_arg=`$ECHO "X$1" | $Xsed \
916 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
922 # Double-quote args containing shell metacharacters to delay
923 # word splitting and command substitution for a subsequent eval.
924 # Many Bourne shells cannot handle close brackets correctly
925 # in scan sets, so we specify it separately.
926 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
931 func_quote_for_expand_result="$my_arg"
935 # func_show_eval cmd [fail_exp]
936 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
937 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
938 # is given, then evaluate it.
944 ${opt_silent-false} || {
945 func_quote_for_expand "$my_cmd"
946 eval "func_echo $func_quote_for_expand_result"
949 if ${opt_dry_run-false}; then :; else
952 if test "$my_status" -eq 0; then :; else
953 eval "(exit $my_status); $my_fail_exp"
959 # func_show_eval_locale cmd [fail_exp]
960 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
961 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
962 # is given, then evaluate it. Use the saved locale for evaluation.
963 func_show_eval_locale ()
968 ${opt_silent-false} || {
969 func_quote_for_expand "$my_cmd"
970 eval "func_echo $func_quote_for_expand_result"
973 if ${opt_dry_run-false}; then :; else
974 eval "$lt_user_locale
977 eval "$lt_safe_locale"
978 if test "$my_status" -eq 0; then :; else
979 eval "(exit $my_status); $my_fail_exp"
989 # Echo version message to standard output and exit.
992 $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
995 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
1002 # Echo short help message to standard output and exit.
1005 $SED -n '/^# Usage:/,/# -h/ {
1008 s/\$progname/'$progname'/
1012 $ECHO "run \`$progname --help | more' for full usage"
1017 # Echo long help message to standard output and exit.
1020 $SED -n '/^# Usage:/,/# Report bugs to/ {
1023 s*\$progname*'$progname'*
1025 s*\$SHELL*'"$SHELL"'*
1027 s*\$LTCFLAGS*'"$LTCFLAGS"'*
1029 s/\$with_gnu_ld/'"$with_gnu_ld"'/
1030 s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1031 s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1037 # func_missing_arg argname
1038 # Echo program name prefixed message to standard error and set global
1042 func_error "missing argument for $1"
1052 # Check that we have a working $ECHO.
1053 if test "X$1" = X--no-reexec; then
1054 # Discard the --no-reexec flag, and continue.
1056 elif test "X$1" = X--fallback-echo; then
1057 # Avoid inline document here, it may be left over
1059 elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
1060 # Yippee, $ECHO works!
1063 # Restart under the correct shell, and then maybe $ECHO will work.
1064 exec $SHELL "$progpath" --no-reexec ${1+"$@"}
1067 if test "X$1" = X--fallback-echo; then
1068 # used as fallback echo
1076 magic="%%%MAGIC variable%%%"
1077 magic_exe="%%%MAGIC EXE variable%%%"
1084 lo2o="s/\\.lo\$/.${objext}/"
1085 o2lo="s/\\.${objext}\$/.lo/"
1090 opt_duplicate_deps=false
1094 # If this variable is set in any of the actions, the command in it
1095 # will be execed at the end. This prevents here-documents from being
1096 # left over by shells.
1099 # func_fatal_configuration arg...
1100 # Echo program name prefixed message to standard error, followed by
1101 # a configuration failure hint, and exit.
1102 func_fatal_configuration ()
1104 func_error ${1+"$@"}
1105 func_error "See the $PACKAGE documentation for more information."
1106 func_fatal_error "Fatal configuration error."
1111 # Display the configuration for all the tags in this script.
1114 re_begincf='^# ### BEGIN LIBTOOL'
1115 re_endcf='^# ### END LIBTOOL'
1117 # Default configuration.
1118 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1120 # Now print the configurations for the tags.
1121 for tagname in $taglist; do
1122 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1129 # Display the features supported by this script.
1133 if test "$build_libtool_libs" = yes; then
1134 $ECHO "enable shared libraries"
1136 $ECHO "disable shared libraries"
1138 if test "$build_old_libs" = yes; then
1139 $ECHO "enable static libraries"
1141 $ECHO "disable static libraries"
1147 # func_enable_tag tagname
1148 # Verify that TAGNAME is valid, and either flag an error and exit, or
1149 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
1156 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1157 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1158 sed_extractcf="/$re_begincf/,/$re_endcf/p"
1163 func_fatal_error "invalid tag name: $tagname"
1167 # Don't test for the "default" C tag, as we know it's
1168 # there but not specially marked.
1172 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1173 taglist="$taglist $tagname"
1175 # Evaluate the configuration. Be careful to quote the path
1176 # and the sed script, to avoid splitting on whitespace, but
1177 # also don't use non-portable quotes within backquotes within
1178 # quotes we have to do it in 2 steps:
1179 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1182 func_error "ignoring unknown tag $tagname"
1188 # Parse options once, thoroughly. This comes as soon as possible in
1189 # the script to make things like `libtool --version' happen quickly.
1192 # Shorthand for --mode=foo, only valid as the first argument
1195 shift; set dummy --mode clean ${1+"$@"}; shift
1197 compile|compil|compi|comp|com|co|c)
1198 shift; set dummy --mode compile ${1+"$@"}; shift
1200 execute|execut|execu|exec|exe|ex|e)
1201 shift; set dummy --mode execute ${1+"$@"}; shift
1203 finish|finis|fini|fin|fi|f)
1204 shift; set dummy --mode finish ${1+"$@"}; shift
1206 install|instal|insta|inst|ins|in|i)
1207 shift; set dummy --mode install ${1+"$@"}; shift
1210 shift; set dummy --mode link ${1+"$@"}; shift
1212 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1213 shift; set dummy --mode uninstall ${1+"$@"}; shift
1217 # Parse non-mode specific arguments:
1218 while test "$#" -gt 0; do
1223 --config) func_config ;;
1225 --debug) preserve_args="$preserve_args $opt"
1226 func_echo "enabling shell trace mode"
1231 -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
1232 execute_dlfiles="$execute_dlfiles $1"
1236 --dry-run | -n) opt_dry_run=: ;;
1237 --features) func_features ;;
1238 --finish) mode="finish" ;;
1240 --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
1242 # Valid mode arguments:
1252 # Catch anything else as an error
1253 *) func_error "invalid argument for $opt"
1263 --preserve-dup-deps)
1264 opt_duplicate_deps=: ;;
1266 --quiet|--silent) preserve_args="$preserve_args $opt"
1270 --verbose| -v) preserve_args="$preserve_args $opt"
1274 --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
1275 preserve_args="$preserve_args $opt $1"
1276 func_enable_tag "$1" # tagname is set here
1280 # Separate optargs to long options:
1281 -dlopen=*|--mode=*|--tag=*)
1282 func_opt_split "$opt"
1283 set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
1287 -\?|-h) func_usage ;;
1288 --help) opt_help=: ;;
1289 --version) func_version ;;
1291 -*) func_fatal_help "unrecognized option \`$opt'" ;;
1301 *cygwin* | *mingw* | *pw32* | *cegcc*)
1302 # don't eliminate duplications in $postdeps and $predeps
1303 opt_duplicate_compiler_generated_deps=:
1306 opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
1310 # Having warned about all mis-specified options, bail out if
1311 # anything was wrong.
1312 $exit_cmd $EXIT_FAILURE
1315 # func_check_version_match
1316 # Ensure that we are using m4 macros, and libtool script from the same
1317 # release of libtool.
1318 func_check_version_match ()
1320 if test "$package_revision" != "$macro_revision"; then
1321 if test "$VERSION" != "$macro_version"; then
1322 if test -z "$macro_version"; then
1324 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1325 $progname: definition of this LT_INIT comes from an older release.
1326 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1327 $progname: and run autoconf again.
1331 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1332 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1333 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1334 $progname: and run autoconf again.
1339 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1340 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1341 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1342 $progname: of $PACKAGE $VERSION and run autoconf again.
1356 # Sanity checks first:
1357 func_check_version_match
1359 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1360 func_fatal_configuration "not configured to build any kind of library"
1363 test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1367 eval std_shrext=\"$shrext_cmds\"
1370 # Only execute mode is allowed to have -dlopen flags.
1371 if test -n "$execute_dlfiles" && test "$mode" != execute; then
1372 func_error "unrecognized option \`-dlopen'"
1377 # Change the help message to a mode-specific one.
1378 generic_help="$help"
1379 help="Try \`$progname --help --mode=$mode' for more information."
1384 # True iff FILE is a libtool `.la' library or `.lo' object file.
1385 # This function is only a basic sanity check; it will hardly flush out
1386 # determined imposters.
1390 $SED -e 4q "$1" 2>/dev/null \
1391 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1394 # func_lalib_unsafe_p file
1395 # True iff FILE is a libtool `.la' library or `.lo' object file.
1396 # This function implements the same check as func_lalib_p without
1397 # resorting to external programs. To this end, it redirects stdin and
1398 # closes it afterwards, without saving the original file descriptor.
1399 # As a safety measure, use it only where a negative result would be
1400 # fatal anyway. Works if `file' does not exist.
1401 func_lalib_unsafe_p ()
1404 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1405 for lalib_p_l in 1 2 3 4
1408 case "$lalib_p_line" in
1409 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1414 test "$lalib_p" = yes
1417 # func_ltwrapper_script_p file
1418 # True iff FILE is a libtool wrapper script
1419 # This function is only a basic sanity check; it will hardly flush out
1420 # determined imposters.
1421 func_ltwrapper_script_p ()
1426 # func_ltwrapper_executable_p file
1427 # True iff FILE is a libtool wrapper executable
1428 # This function is only a basic sanity check; it will hardly flush out
1429 # determined imposters.
1430 func_ltwrapper_executable_p ()
1432 func_ltwrapper_exec_suffix=
1435 *) func_ltwrapper_exec_suffix=.exe ;;
1437 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1440 # func_ltwrapper_scriptname file
1441 # Assumes file is an ltwrapper_executable
1442 # uses $file to determine the appropriate filename for a
1443 # temporary ltwrapper_script.
1444 func_ltwrapper_scriptname ()
1446 func_ltwrapper_scriptname_result=""
1447 if func_ltwrapper_executable_p "$1"; then
1448 func_dirname_and_basename "$1" "" "."
1449 func_stripname '' '.exe' "$func_basename_result"
1450 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1454 # func_ltwrapper_p file
1455 # True iff FILE is a libtool wrapper script or wrapper executable
1456 # This function is only a basic sanity check; it will hardly flush out
1457 # determined imposters.
1460 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1464 # func_execute_cmds commands fail_cmd
1465 # Execute tilde-delimited COMMANDS.
1466 # If FAIL_CMD is given, eval that upon failure.
1467 # FAIL_CMD may read-access the current command in variable CMD!
1468 func_execute_cmds ()
1471 save_ifs=$IFS; IFS='~'
1475 func_show_eval "$cmd" "${2-:}"
1482 # Source FILE, adding directory component if necessary.
1483 # Note that it is not necessary on cygwin/mingw to append a dot to
1484 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1485 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1486 # `FILE.' does not work on cygwin managed mounts.
1491 */* | *\\*) . "$1" ;;
1497 # func_infer_tag arg
1498 # Infer tagged configuration to use if any are available and
1499 # if one wasn't chosen via the "--tag" command line option.
1500 # Only attempt this if the compiler in the base compile
1501 # command doesn't match the default compiler.
1502 # arg is usually of the form 'gcc ...'
1506 if test -n "$available_tags" && test -z "$tagname"; then
1509 func_quote_for_eval "$arg"
1510 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1513 # Blanks in the command may have been stripped by the calling shell,
1514 # but not from the CC environment variable when configure was run.
1515 " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1516 # Blanks at the start of $base_compile will cause this to fail
1517 # if we don't check for them as well.
1519 for z in $available_tags; do
1520 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1521 # Evaluate the configuration.
1522 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1525 # Double-quote args containing other shell metacharacters.
1526 func_quote_for_eval "$arg"
1527 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1530 " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1531 # The compiler in the base compile command matches
1532 # the one in the tagged configuration.
1533 # Assume this is the tagged configuration we want.
1540 # If $tagname still isn't set, then no tagged configuration
1541 # was found and let the user know that the "--tag" command
1542 # line option must be used.
1543 if test -z "$tagname"; then
1544 func_echo "unable to infer tagged configuration"
1545 func_fatal_error "specify a tag with \`--tag'"
1547 # func_verbose "using $tagname tagged configuration"
1556 # func_write_libtool_object output_name pic_name nonpic_name
1557 # Create a libtool object file (analogous to a ".la" file),
1558 # but don't create it if we're doing a dry run.
1559 func_write_libtool_object ()
1562 if test "$build_libtool_libs" = yes; then
1568 if test "$build_old_libs" = yes; then
1569 write_oldobj=\'${3}\'
1575 cat >${write_libobj}T <<EOF
1576 # $write_libobj - a libtool object file
1577 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1579 # Please DO NOT delete this file!
1580 # It is necessary for linking the library.
1582 # Name of the PIC object.
1583 pic_object=$write_lobj
1585 # Name of the non-PIC object
1586 non_pic_object=$write_oldobj
1589 $MV "${write_libobj}T" "${write_libobj}"
1593 # func_mode_compile arg...
1594 func_mode_compile ()
1597 # Get the compilation command and the source file.
1599 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1611 # do not "continue". Instead, add this to base_compile
1623 # Accept any command-line options.
1626 test -n "$libobj" && \
1627 func_fatal_error "you cannot specify \`-o' more than once"
1632 -pie | -fpie | -fPIE)
1633 pie_flag="$pie_flag $arg"
1637 -shared | -static | -prefer-pic | -prefer-non-pic)
1648 arg_mode=arg # the next one goes into the "base_compile" arg list
1649 continue # The current "srcfile" will either be retained or
1650 ;; # replaced later. I would guess that would be a bug.
1653 func_stripname '-Wc,' '' "$arg"
1654 args=$func_stripname_result
1656 save_ifs="$IFS"; IFS=','
1657 for arg in $args; do
1659 func_quote_for_eval "$arg"
1660 lastarg="$lastarg $func_quote_for_eval_result"
1663 func_stripname ' ' '' "$lastarg"
1664 lastarg=$func_stripname_result
1666 # Add the arguments to base_compile.
1667 base_compile="$base_compile $lastarg"
1672 # Accept the current argument as the source file.
1673 # The previous "srcfile" becomes the current argument.
1680 esac # case $arg_mode
1682 # Aesthetically quote the previous argument.
1683 func_quote_for_eval "$lastarg"
1684 base_compile="$base_compile $func_quote_for_eval_result"
1689 func_fatal_error "you must specify an argument for -Xcompile"
1692 func_fatal_error "you must specify a target with \`-o'"
1695 # Get the name of the library object.
1696 test -z "$libobj" && {
1697 func_basename "$srcfile"
1698 libobj="$func_basename_result"
1703 # Recognize several different file suffixes.
1704 # If the user specifies -o file.o, it is replaced with file.lo
1707 *.ada | *.adb | *.ads | *.asm | \
1708 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1709 *.[fF][09]? | *.for | *.java | *.obj | *.sx)
1710 func_xform "$libobj"
1711 libobj=$func_xform_result
1716 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1718 func_fatal_error "cannot determine name of library object from \`$libobj'"
1722 func_infer_tag $base_compile
1724 for arg in $later; do
1727 test "$build_libtool_libs" != yes && \
1728 func_fatal_configuration "can not build a shared library"
1734 build_libtool_libs=no
1751 func_quote_for_eval "$libobj"
1752 test "X$libobj" != "X$func_quote_for_eval_result" \
1753 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1754 && func_warning "libobj name \`$libobj' may not contain shell special characters."
1755 func_dirname_and_basename "$obj" "/" ""
1756 objname="$func_basename_result"
1757 xdir="$func_dirname_result"
1758 lobj=${xdir}$objdir/$objname
1760 test -z "$base_compile" && \
1761 func_fatal_help "you must specify a compilation command"
1763 # Delete any leftover library objects.
1764 if test "$build_old_libs" = yes; then
1765 removelist="$obj $lobj $libobj ${libobj}T"
1767 removelist="$lobj $libobj ${libobj}T"
1770 # On Cygwin there's no "real" PIC flag so we must build both object types
1772 cygwin* | mingw* | pw32* | os2* | cegcc*)
1776 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1777 # non-PIC code in shared libraries is not supported
1781 # Calculate the filename of the output object if compiler does
1782 # not support -o with -c
1783 if test "$compiler_c_o" = no; then
1784 output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1785 lockfile="$output_obj.lock"
1792 # Lock this critical section if it is needed
1793 # We use this script file to make the link, it avoids creating a new file
1794 if test "$need_locks" = yes; then
1795 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1796 func_echo "Waiting for $lockfile to be removed"
1799 elif test "$need_locks" = warn; then
1800 if test -f "$lockfile"; then
1802 *** ERROR, $lockfile exists and contains:
1803 `cat $lockfile 2>/dev/null`
1805 This indicates that another process is trying to use the same
1806 temporary object file, and libtool could not work around it because
1807 your compiler does not support \`-c' and \`-o' together. If you
1808 repeat this compilation, it may succeed, by chance, but you had better
1809 avoid parallel builds (make -j) in this platform, or get a better
1812 $opt_dry_run || $RM $removelist
1815 removelist="$removelist $output_obj"
1816 $ECHO "$srcfile" > "$lockfile"
1819 $opt_dry_run || $RM $removelist
1820 removelist="$removelist $lockfile"
1821 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1823 if test -n "$fix_srcfile_path"; then
1824 eval srcfile=\"$fix_srcfile_path\"
1826 func_quote_for_eval "$srcfile"
1827 qsrcfile=$func_quote_for_eval_result
1829 # Only build a PIC object if we are building libtool libraries.
1830 if test "$build_libtool_libs" = yes; then
1831 # Without this assignment, base_compile gets emptied.
1832 fbsd_hideous_sh_bug=$base_compile
1834 if test "$pic_mode" != no; then
1835 command="$base_compile $qsrcfile $pic_flag"
1837 # Don't build PIC code
1838 command="$base_compile $qsrcfile"
1841 func_mkdir_p "$xdir$objdir"
1843 if test -z "$output_obj"; then
1844 # Place PIC objects in $objdir
1845 command="$command -o $lobj"
1848 func_show_eval_locale "$command" \
1849 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1851 if test "$need_locks" = warn &&
1852 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1854 *** ERROR, $lockfile contains:
1855 `cat $lockfile 2>/dev/null`
1857 but it should contain:
1860 This indicates that another process is trying to use the same
1861 temporary object file, and libtool could not work around it because
1862 your compiler does not support \`-c' and \`-o' together. If you
1863 repeat this compilation, it may succeed, by chance, but you had better
1864 avoid parallel builds (make -j) in this platform, or get a better
1867 $opt_dry_run || $RM $removelist
1871 # Just move the object if needed, then go on to compile the next one
1872 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1873 func_show_eval '$MV "$output_obj" "$lobj"' \
1874 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1877 # Allow error messages only from the first compilation.
1878 if test "$suppress_opt" = yes; then
1879 suppress_output=' >/dev/null 2>&1'
1883 # Only build a position-dependent object if we build old libraries.
1884 if test "$build_old_libs" = yes; then
1885 if test "$pic_mode" != yes; then
1886 # Don't build PIC code
1887 command="$base_compile $qsrcfile$pie_flag"
1889 command="$base_compile $qsrcfile $pic_flag"
1891 if test "$compiler_c_o" = yes; then
1892 command="$command -o $obj"
1895 # Suppress compiler output if we already did a PIC compilation.
1896 command="$command$suppress_output"
1897 func_show_eval_locale "$command" \
1898 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1900 if test "$need_locks" = warn &&
1901 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1903 *** ERROR, $lockfile contains:
1904 `cat $lockfile 2>/dev/null`
1906 but it should contain:
1909 This indicates that another process is trying to use the same
1910 temporary object file, and libtool could not work around it because
1911 your compiler does not support \`-c' and \`-o' together. If you
1912 repeat this compilation, it may succeed, by chance, but you had better
1913 avoid parallel builds (make -j) in this platform, or get a better
1916 $opt_dry_run || $RM $removelist
1920 # Just move the object if needed
1921 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1922 func_show_eval '$MV "$output_obj" "$obj"' \
1923 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1928 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1930 # Unlock the critical section if it was locked
1931 if test "$need_locks" != no; then
1932 removelist=$lockfile
1941 test "$mode" = compile && func_mode_compile ${1+"$@"}
1946 # We need to display help for each of the modes.
1949 # Generic help is extracted from the usage comments
1950 # at the start of this file.
1956 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1958 Remove files from the build directory.
1960 RM is the name of the program to use to delete files associated with each FILE
1961 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1964 If FILE is a libtool library, object or program, all the files associated
1965 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1970 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1972 Compile a source file into a libtool library object.
1974 This mode accepts the following additional options:
1976 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
1977 -no-suppress do not suppress compiler output for multiple passes
1978 -prefer-pic try to building PIC objects only
1979 -prefer-non-pic try to building non-PIC objects only
1980 -shared do not build a \`.o' file suitable for static linking
1981 -static only build a \`.o' file suitable for static linking
1983 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1984 from the given SOURCEFILE.
1986 The output file name is determined by removing the directory component from
1987 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1988 library object suffix, \`.lo'."
1993 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1995 Automatically set library path, then run a program.
1997 This mode accepts the following additional options:
1999 -dlopen FILE add the directory containing FILE to the library path
2001 This mode sets the library path environment variable according to \`-dlopen'
2004 If any of the ARGS are libtool executable wrappers, then they are translated
2005 into their corresponding uninstalled binary, and any of their required library
2006 directories are added to the library path.
2008 Then, COMMAND is executed, with ARGS as arguments."
2013 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2015 Complete the installation of libtool libraries.
2017 Each LIBDIR is a directory that contains libtool libraries.
2019 The commands that this mode executes may require superuser privileges. Use
2020 the \`--dry-run' option if you just want to see what would be executed."
2025 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2027 Install executables or libraries.
2029 INSTALL-COMMAND is the installation command. The first component should be
2030 either the \`install' or \`cp' program.
2032 The following components of INSTALL-COMMAND are treated specially:
2034 -inst-prefix PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2036 The rest of the components are interpreted as arguments to that command (only
2037 BSD-compatible install options are recognized)."
2042 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2044 Link object files or libraries together to form another library, or to
2045 create an executable program.
2047 LINK-COMMAND is a command using the C compiler that you would use to create
2048 a program from several object files.
2050 The following components of LINK-COMMAND are treated specially:
2052 -all-static do not do any dynamic linking at all
2053 -avoid-version do not add a version suffix if possible
2054 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2055 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2056 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2057 -export-symbols SYMFILE
2058 try to export only the symbols listed in SYMFILE
2059 -export-symbols-regex REGEX
2060 try to export only the symbols matching REGEX
2061 -LLIBDIR search LIBDIR for required installed libraries
2062 -lNAME OUTPUT-FILE requires the installed library libNAME
2063 -module build a library that can dlopened
2064 -no-fast-install disable the fast-install mode
2065 -no-install link a not-installable executable
2066 -no-undefined declare that a library does not refer to external symbols
2067 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2068 -objectlist FILE Use a list of object files found in FILE to specify objects
2069 -precious-files-regex REGEX
2070 don't remove output files matching REGEX
2071 -release RELEASE specify package release information
2072 -rpath LIBDIR the created library will eventually be installed in LIBDIR
2073 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2074 -shared only do dynamic linking of libtool libraries
2075 -shrext SUFFIX override the standard shared library file extension
2076 -static do not do any dynamic linking of uninstalled libtool libraries
2077 -static-libtool-libs
2078 do not do any dynamic linking of libtool libraries
2079 -version-info CURRENT[:REVISION[:AGE]]
2080 specify library version info [each variable defaults to 0]
2081 -weak LIBNAME declare that the target provides the LIBNAME interface
2083 All other options (arguments beginning with \`-') are ignored.
2085 Every other argument is treated as a filename. Files ending in \`.la' are
2086 treated as uninstalled libtool libraries, other files are standard or library
2089 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2090 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2091 required, except when creating a convenience library.
2093 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2094 using \`ar' and \`ranlib', or on Windows using \`lib'.
2096 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2097 is created, otherwise an executable program is created."
2102 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2104 Remove libraries from an installation directory.
2106 RM is the name of the program to use to delete files associated with each FILE
2107 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2110 If FILE is a libtool library, all the files associated with it are deleted.
2111 Otherwise, only FILE itself is deleted using RM."
2115 func_fatal_help "invalid operation mode \`$mode'"
2120 $ECHO "Try \`$progname --help' for more information about other modes."
2125 # Now that we've collected a possible --mode arg, show help if necessary
2126 $opt_help && func_mode_help
2129 # func_mode_execute arg...
2130 func_mode_execute ()
2133 # The first argument is the command name.
2136 func_fatal_help "you must specify a COMMAND"
2138 # Handle -dlopen flags immediately.
2139 for file in $execute_dlfiles; do
2141 || func_fatal_help "\`$file' is not a file"
2146 # Check to see that this really is a libtool archive.
2147 func_lalib_unsafe_p "$file" \
2148 || func_fatal_help "\`$lib' is not a valid libtool archive"
2150 # Read the libtool library.
2155 # Skip this library if it cannot be dlopened.
2156 if test -z "$dlname"; then
2157 # Warn if it was a shared library.
2158 test -n "$library_names" && \
2159 func_warning "\`$file' was not linked with \`-export-dynamic'"
2163 func_dirname "$file" "" "."
2164 dir="$func_dirname_result"
2166 if test -f "$dir/$objdir/$dlname"; then
2169 if test ! -f "$dir/$dlname"; then
2170 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2176 # Just add the directory containing the .lo file.
2177 func_dirname "$file" "" "."
2178 dir="$func_dirname_result"
2182 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2187 # Get the absolute pathname.
2188 absdir=`cd "$dir" && pwd`
2189 test -n "$absdir" && dir="$absdir"
2191 # Now add the directory to shlibpath_var.
2192 if eval "test -z \"\$$shlibpath_var\""; then
2193 eval "$shlibpath_var=\"\$dir\""
2195 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2199 # This variable tells wrapper scripts just to set shlibpath_var
2200 # rather than running their programs.
2201 libtool_execute_magic="$magic"
2203 # Check if any of the arguments is a wrapper script.
2210 # Do a test to see if this is really a libtool program.
2211 if func_ltwrapper_script_p "$file"; then
2213 # Transform arg to wrapped name.
2214 file="$progdir/$program"
2215 elif func_ltwrapper_executable_p "$file"; then
2216 func_ltwrapper_scriptname "$file"
2217 func_source "$func_ltwrapper_scriptname_result"
2218 # Transform arg to wrapped name.
2219 file="$progdir/$program"
2223 # Quote arguments (to preserve shell metacharacters).
2224 func_quote_for_eval "$file"
2225 args="$args $func_quote_for_eval_result"
2228 if test "X$opt_dry_run" = Xfalse; then
2229 if test -n "$shlibpath_var"; then
2230 # Export the shlibpath_var.
2231 eval "export $shlibpath_var"
2234 # Restore saved environment variables
2235 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2237 eval "if test \"\${save_$lt_var+set}\" = set; then
2238 $lt_var=\$save_$lt_var; export $lt_var
2244 # Now prepare to actually exec the command.
2245 exec_cmd="\$cmd$args"
2247 # Display what would be done.
2248 if test -n "$shlibpath_var"; then
2249 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2250 $ECHO "export $shlibpath_var"
2257 test "$mode" = execute && func_mode_execute ${1+"$@"}
2260 # func_mode_finish arg...
2267 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2270 libdirs="$libdirs $dir"
2273 for libdir in $libdirs; do
2274 if test -n "$finish_cmds"; then
2275 # Do each command in the finish commands.
2276 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2279 if test -n "$finish_eval"; then
2280 # Do the single finish_eval.
2281 eval cmds=\"$finish_eval\"
2282 $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2288 # Exit here if they wanted silent mode.
2289 $opt_silent && exit $EXIT_SUCCESS
2291 $ECHO "X----------------------------------------------------------------------" | $Xsed
2292 $ECHO "Libraries have been installed in:"
2293 for libdir in $libdirs; do
2297 $ECHO "If you ever happen to want to link against installed libraries"
2298 $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
2299 $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
2300 $ECHO "flag during linking and do at least one of the following:"
2301 if test -n "$shlibpath_var"; then
2302 $ECHO " - add LIBDIR to the \`$shlibpath_var' environment variable"
2303 $ECHO " during execution"
2305 if test -n "$runpath_var"; then
2306 $ECHO " - add LIBDIR to the \`$runpath_var' environment variable"
2307 $ECHO " during linking"
2309 if test -n "$hardcode_libdir_flag_spec"; then
2311 eval flag=\"$hardcode_libdir_flag_spec\"
2313 $ECHO " - use the \`$flag' linker flag"
2315 if test -n "$admincmds"; then
2316 $ECHO " - have your system administrator run these commands:$admincmds"
2318 if test -f /etc/ld.so.conf; then
2319 $ECHO " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2323 $ECHO "See any operating system documentation about shared libraries for"
2325 solaris2.[6789]|solaris2.1[0-9])
2326 $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2330 $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
2333 $ECHO "X----------------------------------------------------------------------" | $Xsed
2337 test "$mode" = finish && func_mode_finish ${1+"$@"}
2340 # func_mode_install arg...
2341 func_mode_install ()
2344 # There may be an optional sh(1) argument at the beginning of
2345 # install_prog (especially on Windows NT).
2346 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2347 # Allow the use of GNU shtool's install command.
2348 $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2349 # Aesthetically quote it.
2350 func_quote_for_eval "$nonopt"
2351 install_prog="$func_quote_for_eval_result "
2359 # The real first argument should be the name of the installation program.
2360 # Aesthetically quote it.
2361 func_quote_for_eval "$arg"
2362 install_prog="$install_prog$func_quote_for_eval_result"
2364 # We need to accept at least all the BSD install flags.
2374 if test -n "$dest"; then
2375 files="$files $dest"
2383 case " $install_prog " in
2398 # If the previous option needed an argument, then skip it.
2399 if test -n "$prev"; then
2408 # Aesthetically quote the argument.
2409 func_quote_for_eval "$arg"
2410 install_prog="$install_prog $func_quote_for_eval_result"
2413 test -z "$install_prog" && \
2414 func_fatal_help "you must specify an install program"
2416 test -n "$prev" && \
2417 func_fatal_help "the \`$prev' option requires an argument"
2419 if test -z "$files"; then
2420 if test -z "$dest"; then
2421 func_fatal_help "no file or destination specified"
2423 func_fatal_help "you must specify a destination"
2427 # Strip any trailing slash from the destination.
2428 func_stripname '' '/' "$dest"
2429 dest=$func_stripname_result
2431 # Check to see that the destination is a directory.
2432 test -d "$dest" && isdir=yes
2433 if test "$isdir" = yes; then
2437 func_dirname_and_basename "$dest" "" "."
2438 destdir="$func_dirname_result"
2439 destname="$func_basename_result"
2441 # Not a directory, so check to see that there is only one file specified.
2442 set dummy $files; shift
2443 test "$#" -gt 1 && \
2444 func_fatal_help "\`$dest' is not a directory"
2447 [\\/]* | [A-Za-z]:[\\/]*) ;;
2449 for file in $files; do
2453 func_fatal_help "\`$destdir' must be an absolute directory name"
2460 # This variable tells wrapper scripts just to set variables rather
2461 # than running their programs.
2462 libtool_install_magic="$magic"
2467 for file in $files; do
2469 # Do each installation.
2472 # Do the static libraries later.
2473 staticlibs="$staticlibs $file"
2477 # Check to see that this really is a libtool archive.
2478 func_lalib_unsafe_p "$file" \
2479 || func_fatal_help "\`$file' is not a valid libtool archive"
2486 # Add the libdir to current_libdirs if it is the destination.
2487 if test "X$destdir" = "X$libdir"; then
2488 case "$current_libdirs " in
2490 *) current_libdirs="$current_libdirs $libdir" ;;
2493 # Note the libdir as a future libdir.
2494 case "$future_libdirs " in
2496 *) future_libdirs="$future_libdirs $libdir" ;;
2500 func_dirname "$file" "/" ""
2501 dir="$func_dirname_result"
2504 if test -n "$relink_command"; then
2505 # Determine the prefix the user has applied to our future dir.
2506 inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2508 # Don't allow the user to place us outside of our expected
2509 # location b/c this prevents finding dependent libraries that
2510 # are installed to the same prefix.
2511 # At present, this check doesn't affect windows .dll's that
2512 # are installed into $libdir/../bin (currently, that works fine)
2513 # but it's something to keep an eye on.
2514 test "$inst_prefix_dir" = "$destdir" && \
2515 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2517 if test -n "$inst_prefix_dir"; then
2518 # Stick the inst_prefix_dir data into the link command.
2519 relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2521 relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2524 func_warning "relinking \`$file'"
2525 func_show_eval "$relink_command" \
2526 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2529 # See the names of the shared library.
2530 set dummy $library_names; shift
2531 if test -n "$1"; then
2536 test -n "$relink_command" && srcname="$realname"T
2538 # Install the shared library and build the symlinks.
2539 func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2543 cygwin* | mingw* | pw32* | cegcc*)
2551 if test -n "$tstripme" && test -n "$striplib"; then
2552 func_show_eval "$striplib $destdir/$realname" 'exit $?'
2555 if test "$#" -gt 0; then
2556 # Delete the old symlinks, and create new ones.
2557 # Try `ln -sf' first, because the `ln' binary might depend on
2558 # the symlink we replace! Solaris /bin/ln does not understand -f,
2559 # so we also need to try rm && ln -s.
2562 test "$linkname" != "$realname" \
2563 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2567 # Do each command in the postinstall commands.
2568 lib="$destdir/$realname"
2569 func_execute_cmds "$postinstall_cmds" 'exit $?'
2572 # Install the pseudo-library for information purposes.
2573 func_basename "$file"
2574 name="$func_basename_result"
2575 instname="$dir/$name"i
2576 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2578 # Maybe install the static library, too.
2579 test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2583 # Install (i.e. copy) a libtool object.
2585 # Figure out destination file name, if it wasn't already specified.
2586 if test -n "$destname"; then
2587 destfile="$destdir/$destname"
2589 func_basename "$file"
2590 destfile="$func_basename_result"
2591 destfile="$destdir/$destfile"
2594 # Deduce the name of the destination old-style object file.
2597 func_lo2o "$destfile"
2598 staticdest=$func_lo2o_result
2601 staticdest="$destfile"
2605 func_fatal_help "cannot copy a libtool object to \`$destfile'"
2609 # Install the libtool object if requested.
2610 test -n "$destfile" && \
2611 func_show_eval "$install_prog $file $destfile" 'exit $?'
2613 # Install the old object if enabled.
2614 if test "$build_old_libs" = yes; then
2615 # Deduce the name of the old-style object file.
2617 staticobj=$func_lo2o_result
2618 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2624 # Figure out destination file name, if it wasn't already specified.
2625 if test -n "$destname"; then
2626 destfile="$destdir/$destname"
2628 func_basename "$file"
2629 destfile="$func_basename_result"
2630 destfile="$destdir/$destfile"
2633 # If the file is missing, and there is a .exe on the end, strip it
2634 # because it is most likely a libtool script we actually want to
2639 if test ! -f "$file"; then
2640 func_stripname '' '.exe' "$file"
2641 file=$func_stripname_result
2647 # Do a test to see if this is really a libtool program.
2650 if func_ltwrapper_executable_p "$file"; then
2651 func_ltwrapper_scriptname "$file"
2652 wrapper=$func_ltwrapper_scriptname_result
2654 func_stripname '' '.exe' "$file"
2655 wrapper=$func_stripname_result
2662 if func_ltwrapper_script_p "$wrapper"; then
2666 func_source "$wrapper"
2668 # Check the variables that should have been set.
2669 test -z "$generated_by_libtool_version" && \
2670 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2673 for lib in $notinst_deplibs; do
2674 # Check to see that each library is installed.
2676 if test -f "$lib"; then
2679 libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2680 if test -n "$libdir" && test ! -f "$libfile"; then
2681 func_warning "\`$lib' has not been installed in \`$libdir'"
2687 func_source "$wrapper"
2690 if test "$fast_install" = no && test -n "$relink_command"; then
2692 if test "$finalize" = yes; then
2693 tmpdir=`func_mktempdir`
2694 func_basename "$file$stripped_ext"
2695 file="$func_basename_result"
2696 outputname="$tmpdir/$file"
2697 # Replace the output file specification.
2698 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2701 func_quote_for_expand "$relink_command"
2702 eval "func_echo $func_quote_for_expand_result"
2704 if eval "$relink_command"; then :
2706 func_error "error: relink \`$file' with the above command before installing it"
2707 $opt_dry_run || ${RM}r "$tmpdir"
2712 func_warning "cannot relink \`$file'"
2716 # Install the binary that we compiled earlier.
2717 file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2721 # remove .exe since cygwin /usr/bin/install will append another
2723 case $install_prog,$host in
2724 */usr/bin/install*,*cygwin*)
2725 case $file:$destfile in
2730 destfile=$destfile.exe
2733 func_stripname '' '.exe' "$destfile"
2734 destfile=$func_stripname_result
2739 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2740 $opt_dry_run || if test -n "$outputname"; then
2747 for file in $staticlibs; do
2748 func_basename "$file"
2749 name="$func_basename_result"
2751 # Set up the ranlib parameters.
2752 oldlib="$destdir/$name"
2754 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2756 if test -n "$stripme" && test -n "$old_striplib"; then
2757 func_show_eval "$old_striplib $oldlib" 'exit $?'
2760 # Do each command in the postinstall commands.
2761 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2764 test -n "$future_libdirs" && \
2765 func_warning "remember to run \`$progname --finish$future_libdirs'"
2767 if test -n "$current_libdirs"; then
2768 # Maybe just do a dry run.
2769 $opt_dry_run && current_libdirs=" -n$current_libdirs"
2770 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2776 test "$mode" = install && func_mode_install ${1+"$@"}
2779 # func_generate_dlsyms outputname originator pic_p
2780 # Extract symbols from dlprefiles and create ${outputname}S.o with
2781 # a dlpreopen symbol table.
2782 func_generate_dlsyms ()
2788 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2791 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2792 if test -n "$NM" && test -n "$global_symbol_pipe"; then
2793 my_dlsyms="${my_outputname}S.c"
2795 func_error "not configured to extract global symbols from dlpreopened files"
2799 if test -n "$my_dlsyms"; then
2803 # Discover the nlist of each of the dlfiles.
2804 nlist="$output_objdir/${my_outputname}.nm"
2806 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2808 # Parse the name list into a source file.
2809 func_verbose "creating $output_objdir/$my_dlsyms"
2811 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2812 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2813 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2819 /* External symbol declarations for the compiler. */\
2822 if test "$dlself" = yes; then
2823 func_verbose "generating symbol list for \`$output'"
2825 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2827 # Add our own program objects to the symbol list.
2828 progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2829 for progfile in $progfiles; do
2830 func_verbose "extracting global C symbols from \`$progfile'"
2831 $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2834 if test -n "$exclude_expsyms"; then
2836 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2837 eval '$MV "$nlist"T "$nlist"'
2841 if test -n "$export_symbols_regex"; then
2843 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2844 eval '$MV "$nlist"T "$nlist"'
2848 # Prepare the list of exported symbols
2849 if test -z "$export_symbols"; then
2850 export_symbols="$output_objdir/$outputname.exp"
2853 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2855 *cygwin* | *mingw* | *cegcc* )
2856 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2857 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2863 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2864 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2865 eval '$MV "$nlist"T "$nlist"'
2867 *cygwin | *mingw* | *cegcc* )
2868 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2869 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2876 for dlprefile in $dlprefiles; do
2877 func_verbose "extracting global C symbols from \`$dlprefile'"
2878 func_basename "$dlprefile"
2879 name="$func_basename_result"
2881 eval '$ECHO ": $name " >> "$nlist"'
2882 eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2887 # Make sure we have at least an empty file.
2888 test -f "$nlist" || : > "$nlist"
2890 if test -n "$exclude_expsyms"; then
2891 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2892 $MV "$nlist"T "$nlist"
2895 # Try sorting and uniquifying the output.
2896 if $GREP -v "^: " < "$nlist" |
2897 if sort -k 3 </dev/null >/dev/null 2>&1; then
2902 uniq > "$nlist"S; then
2905 $GREP -v "^: " < "$nlist" > "$nlist"S
2908 if test -f "$nlist"S; then
2909 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2911 $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2914 $ECHO >> "$output_objdir/$my_dlsyms" "\
2916 /* The mapping between symbol names and symbols. */
2923 *cygwin* | *mingw* | *cegcc* )
2924 $ECHO >> "$output_objdir/$my_dlsyms" "\
2925 /* DATA imports from DLLs on WIN32 con't be const, because
2926 runtime relocations are performed -- see ld's documentation
2927 on pseudo-relocs. */"
2930 echo >> "$output_objdir/$my_dlsyms" "\
2931 /* This system does not cope well with relocations in const data */"
2934 lt_dlsym_const=const ;;
2937 $ECHO >> "$output_objdir/$my_dlsyms" "\
2938 extern $lt_dlsym_const lt_dlsymlist
2939 lt_${my_prefix}_LTX_preloaded_symbols[];
2940 $lt_dlsym_const lt_dlsymlist
2941 lt_${my_prefix}_LTX_preloaded_symbols[] =
2943 { \"$my_originator\", (void *) 0 },"
2945 case $need_lib_prefix in
2947 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2950 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2953 $ECHO >> "$output_objdir/$my_dlsyms" "\
2957 /* This works around a problem in FreeBSD linker */
2958 #ifdef FREEBSD_WORKAROUND
2959 static const void *lt_preloaded_setup() {
2960 return lt_${my_prefix}_LTX_preloaded_symbols;
2970 pic_flag_for_symtable=
2971 case "$compile_command " in
2975 # compiling the symbol table file with pic_flag works around
2976 # a FreeBSD bug that causes programs to crash when -lm is
2977 # linked before any other PIC object. But we must not use
2978 # pic_flag when linking with -static. The problem exists in
2979 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2980 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2981 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2983 pic_flag_for_symtable=" $pic_flag" ;;
2985 if test "X$my_pic_p" != Xno; then
2986 pic_flag_for_symtable=" $pic_flag"
2993 for arg in $LTCFLAGS; do
2995 -pie | -fpie | -fPIE) ;;
2996 *) symtab_cflags="$symtab_cflags $arg" ;;
3000 # Now compile the dynamic symbol file.
3001 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3003 # Clean up the generated files.
3004 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3006 # Transform the symbol file into the correct name.
3007 symfileobj="$output_objdir/${my_outputname}S.$objext"
3009 *cygwin* | *mingw* | *cegcc* )
3010 if test -f "$output_objdir/$my_outputname.def"; then
3011 compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3012 finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3014 compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3015 finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3019 compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3020 finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3025 func_fatal_error "unknown suffix for \`$my_dlsyms'"
3029 # We keep going just in case the user didn't refer to
3030 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3031 # really was required.
3033 # Nullify the symbol file.
3034 compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3035 finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3039 # func_win32_libid arg
3040 # return the library type of file 'arg'
3042 # Need a lot of goo to handle *both* DLLs and import libs
3043 # Has to be a shell function in order to 'eat' the argument
3044 # that is supplied when $file_magic_command is called.
3048 win32_libid_type="unknown"
3049 win32_fileres=`file -L $1 2>/dev/null`
3050 case $win32_fileres in
3051 *ar\ archive\ import\ library*) # definitely import
3052 win32_libid_type="x86 archive import"
3054 *ar\ archive*) # could be an import, or static
3055 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3056 $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
3057 win32_nmres=`eval $NM -f posix -A $1 |
3066 case $win32_nmres in
3067 import*) win32_libid_type="x86 archive import";;
3068 *) win32_libid_type="x86 archive static";;
3073 win32_libid_type="x86 DLL"
3075 *executable*) # but shell scripts are "executable" too...
3076 case $win32_fileres in
3077 *MS\ Windows\ PE\ Intel*)
3078 win32_libid_type="x86 DLL"
3083 $ECHO "$win32_libid_type"
3088 # func_extract_an_archive dir oldlib
3089 func_extract_an_archive ()
3092 f_ex_an_ar_dir="$1"; shift
3093 f_ex_an_ar_oldlib="$1"
3094 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3095 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3098 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3103 # func_extract_archives gentop oldlib ...
3104 func_extract_archives ()
3107 my_gentop="$1"; shift
3108 my_oldlibs=${1+"$@"}
3114 for my_xlib in $my_oldlibs; do
3115 # Extract the objects.
3117 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3118 *) my_xabs=`pwd`"/$my_xlib" ;;
3120 func_basename "$my_xlib"
3121 my_xlib="$func_basename_result"
3124 case " $extracted_archives " in
3126 func_arith $extracted_serial + 1
3127 extracted_serial=$func_arith_result
3128 my_xlib_u=lt$extracted_serial-$my_xlib ;;
3132 extracted_archives="$extracted_archives $my_xlib_u"
3133 my_xdir="$my_gentop/$my_xlib_u"
3135 func_mkdir_p "$my_xdir"
3139 func_verbose "Extracting $my_xabs"
3140 # Do not bother doing anything if just a dry run
3142 darwin_orig_dir=`pwd`
3143 cd $my_xdir || exit $?
3144 darwin_archive=$my_xabs
3146 darwin_base_archive=`basename "$darwin_archive"`
3147 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3148 if test -n "$darwin_arches"; then
3149 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3151 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3152 for darwin_arch in $darwin_arches ; do
3153 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3154 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3155 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3156 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3158 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3159 done # $darwin_arches
3160 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3161 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3164 for darwin_file in $darwin_filelist; do
3165 darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3166 $LIPO -create -output "$darwin_file" $darwin_files
3167 done # $darwin_filelist
3169 cd "$darwin_orig_dir"
3172 func_extract_an_archive "$my_xdir" "$my_xabs"
3177 func_extract_an_archive "$my_xdir" "$my_xabs"
3180 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3183 func_extract_archives_result="$my_oldobjs"
3188 # func_emit_wrapper_part1 [arg=no]
3190 # Emit the first part of a libtool wrapper script on stdout.
3191 # For more information, see the description associated with
3192 # func_emit_wrapper(), below.
3193 func_emit_wrapper_part1 ()
3195 func_emit_wrapper_part1_arg1=no
3196 if test -n "$1" ; then
3197 func_emit_wrapper_part1_arg1=$1
3203 # $output - temporary wrapper script for $objdir/$outputname
3204 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3206 # The $output program cannot be directly executed until all the libtool
3207 # libraries that it depends on are installed.
3209 # This wrapper script should never be moved out of the build directory.
3210 # If it is, it will not operate correctly.
3212 # Sed substitution that helps us do robust quoting. It backslashifies
3213 # metacharacters that are still active within double-quoted strings.
3214 Xsed='${SED} -e 1s/^X//'
3215 sed_quote_subst='$sed_quote_subst'
3217 # Be Bourne compatible
3218 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3221 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3222 # is contrary to our usage. Disable this feature.
3223 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3224 setopt NO_GLOB_SUBST
3226 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3228 BIN_SH=xpg4; export BIN_SH # for Tru64
3229 DUALCASE=1; export DUALCASE # for MKS sh
3231 # The HP-UX ksh and POSIX shell print the target directory to stdout
3233 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3235 relink_command=\"$relink_command\"
3237 # This environment variable determines our operation mode.
3238 if test \"\$libtool_install_magic\" = \"$magic\"; then
3239 # install mode needs the following variables:
3240 generated_by_libtool_version='$macro_version'
3241 notinst_deplibs='$notinst_deplibs'
3243 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3244 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3247 # Make sure echo works.
3248 if test \"X\$1\" = X--no-reexec; then
3249 # Discard the --no-reexec flag, and continue.
3251 elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
3252 # Yippee, \$ECHO works!
3255 # Restart under the correct shell, and then maybe \$ECHO will work.
3256 exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3262 # Find the directory that this script lives in.
3263 thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3264 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3266 # Follow symbolic links until we get to the real thisdir.
3267 file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
3268 while test -n \"\$file\"; do
3269 destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3271 # If there was a directory component, then change thisdir.
3272 if test \"x\$destdir\" != \"x\$file\"; then
3273 case \"\$destdir\" in
3274 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3275 *) thisdir=\"\$thisdir/\$destdir\" ;;
3279 file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3280 file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
3284 # end: func_emit_wrapper_part1
3286 # func_emit_wrapper_part2 [arg=no]
3288 # Emit the second part of a libtool wrapper script on stdout.
3289 # For more information, see the description associated with
3290 # func_emit_wrapper(), below.
3291 func_emit_wrapper_part2 ()
3293 func_emit_wrapper_part2_arg1=no
3294 if test -n "$1" ; then
3295 func_emit_wrapper_part2_arg1=$1
3300 # Usually 'no', except on cygwin/mingw when embedded into
3302 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
3303 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3304 # special case for '.'
3305 if test \"\$thisdir\" = \".\"; then
3308 # remove .libs from thisdir
3309 case \"\$thisdir\" in
3310 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
3311 $objdir ) thisdir=. ;;
3315 # Try to get the absolute directory name.
3316 absdir=\`cd \"\$thisdir\" && pwd\`
3317 test -n \"\$absdir\" && thisdir=\"\$absdir\"
3320 if test "$fast_install" = yes; then
3322 program=lt-'$outputname'$exeext
3323 progdir=\"\$thisdir/$objdir\"
3325 if test ! -f \"\$progdir/\$program\" ||
3326 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3327 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3329 file=\"\$\$-\$program\"
3331 if test ! -d \"\$progdir\"; then
3332 $MKDIR \"\$progdir\"
3334 $RM \"\$progdir/\$file\"
3339 # relink executable if necessary
3340 if test -n \"\$relink_command\"; then
3341 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3343 $ECHO \"\$relink_command_output\" >&2
3344 $RM \"\$progdir/\$file\"
3349 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3350 { $RM \"\$progdir/\$program\";
3351 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3352 $RM \"\$progdir/\$file\"
3356 program='$outputname'
3357 progdir=\"\$thisdir/$objdir\"
3363 if test -f \"\$progdir/\$program\"; then"
3365 # Export our shlibpath_var if we have one.
3366 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3368 # Add our own library path to $shlibpath_var
3369 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3371 # Some systems cannot cope with colon-terminated $shlibpath_var
3372 # The second colon is a workaround for a bug in BeOS R4 sed
3373 $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3375 export $shlibpath_var
3379 # fixup the dll searchpath if we need to.
3380 if test -n "$dllsearchpath"; then
3382 # Add the dll search path components to the executable PATH
3383 PATH=$dllsearchpath:\$PATH
3388 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3389 # Run the actual program with our arguments.
3392 # Backslashes separate directories on plain windows
3393 *-*-mingw | *-*-os2* | *-cegcc*)
3395 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3401 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3406 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3410 # The program doesn't exist.
3411 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3412 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3413 $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3419 # end: func_emit_wrapper_part2
3422 # func_emit_wrapper [arg=no]
3424 # Emit a libtool wrapper script on stdout.
3425 # Don't directly open a file because we may want to
3426 # incorporate the script contents within a cygwin/mingw
3427 # wrapper executable. Must ONLY be called from within
3428 # func_mode_link because it depends on a number of variables
3431 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3432 # variable will take. If 'yes', then the emitted script
3433 # will assume that the directory in which it is stored is
3434 # the $objdir directory. This is a cygwin/mingw-specific
3436 func_emit_wrapper ()
3438 func_emit_wrapper_arg1=no
3439 if test -n "$1" ; then
3440 func_emit_wrapper_arg1=$1
3443 # split this up so that func_emit_cwrapperexe_src
3444 # can call each part independently.
3445 func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
3446 func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
3450 # func_to_host_path arg
3452 # Convert paths to host format when used with build tools.
3453 # Intended for use with "native" mingw (where libtool itself
3454 # is running under the msys shell), or in the following cross-
3455 # build environments:
3457 # mingw (msys) mingw [e.g. native]
3460 # where wine is equipped with the `winepath' executable.
3461 # In the native mingw case, the (msys) shell automatically
3462 # converts paths for any non-msys applications it launches,
3463 # but that facility isn't available from inside the cwrapper.
3464 # Similar accommodations are necessary for $host mingw and
3465 # $build cygwin. Calling this function does no harm for other
3466 # $host/$build combinations not listed above.
3468 # ARG is the path (on $build) that should be converted to
3469 # the proper representation for $host. The result is stored
3470 # in $func_to_host_path_result.
3471 func_to_host_path ()
3473 func_to_host_path_result="$1"
3474 if test -n "$1" ; then
3477 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3479 *mingw* ) # actually, msys
3480 # awkward: cmd appends spaces to result
3481 lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3482 func_to_host_path_tmp1=`( cmd //c echo "$1" |\
3483 $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3484 func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3485 $SED -e "$lt_sed_naive_backslashify"`
3488 func_to_host_path_tmp1=`cygpath -w "$1"`
3489 func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3490 $SED -e "$lt_sed_naive_backslashify"`
3493 # Unfortunately, winepath does not exit with a non-zero
3494 # error code, so we are forced to check the contents of
3495 # stdout. On the other hand, if the command is not
3496 # found, the shell will set an exit code of 127 and print
3497 # *an error message* to stdout. So we must check for both
3498 # error code of zero AND non-empty stdout, which explains
3499 # the odd construction:
3500 func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3501 if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3502 func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3503 $SED -e "$lt_sed_naive_backslashify"`
3505 # Allow warning below.
3506 func_to_host_path_result=""
3510 if test -z "$func_to_host_path_result" ; then
3511 func_error "Could not determine host path corresponding to"
3513 func_error "Continuing, but uninstalled executables may not work."
3515 func_to_host_path_result="$1"
3521 # end: func_to_host_path
3523 # func_to_host_pathlist arg
3525 # Convert pathlists to host format when used with build tools.
3526 # See func_to_host_path(), above. This function supports the
3527 # following $build/$host combinations (but does no harm for
3528 # combinations not listed here):
3530 # mingw (msys) mingw [e.g. native]
3534 # Path separators are also converted from $build format to
3535 # $host format. If ARG begins or ends with a path separator
3536 # character, it is preserved (but converted to $host format)
3539 # ARG is a pathlist (on $build) that should be converted to
3540 # the proper representation on $host. The result is stored
3541 # in $func_to_host_pathlist_result.
3542 func_to_host_pathlist ()
3544 func_to_host_pathlist_result="$1"
3545 if test -n "$1" ; then
3548 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3549 # Remove leading and trailing path separator characters from
3550 # ARG. msys behavior is inconsistent here, cygpath turns them
3551 # into '.;' and ';.', and winepath ignores them completely.
3552 func_to_host_pathlist_tmp2="$1"
3553 # Once set for this call, this variable should not be
3554 # reassigned. It is used in tha fallback case.
3555 func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3556 $SED -e 's|^:*||' -e 's|:*$||'`
3558 *mingw* ) # Actually, msys.
3559 # Awkward: cmd appends spaces to result.
3560 lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3561 func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3562 $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3563 func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3564 $SED -e "$lt_sed_naive_backslashify"`
3567 func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3568 func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3569 $SED -e "$lt_sed_naive_backslashify"`
3572 # unfortunately, winepath doesn't convert pathlists
3573 func_to_host_pathlist_result=""
3574 func_to_host_pathlist_oldIFS=$IFS
3576 for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3577 IFS=$func_to_host_pathlist_oldIFS
3578 if test -n "$func_to_host_pathlist_f" ; then
3579 func_to_host_path "$func_to_host_pathlist_f"
3580 if test -n "$func_to_host_path_result" ; then
3581 if test -z "$func_to_host_pathlist_result" ; then
3582 func_to_host_pathlist_result="$func_to_host_path_result"
3584 func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3590 IFS=$func_to_host_pathlist_oldIFS
3593 if test -z "$func_to_host_pathlist_result" ; then
3594 func_error "Could not determine the host path(s) corresponding to"
3596 func_error "Continuing, but uninstalled executables may not work."
3597 # Fallback. This may break if $1 contains DOS-style drive
3598 # specifications. The fix is not to complicate the expression
3599 # below, but for the user to provide a working wine installation
3600 # with winepath so that path translation in the cross-to-mingw
3601 # case works properly.
3602 lt_replace_pathsep_nix_to_dos="s|:|;|g"
3603 func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3604 $SED -e "$lt_replace_pathsep_nix_to_dos"`
3606 # Now, add the leading and trailing path separators back
3608 :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3612 *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3619 # end: func_to_host_pathlist
3621 # func_emit_cwrapperexe_src
3622 # emit the source code for a wrapper executable on stdout
3623 # Must ONLY be called from within func_mode_link because
3624 # it depends on a number of variable set therein.
3625 func_emit_cwrapperexe_src ()
3629 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3630 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3632 The $output program cannot be directly executed until all the libtool
3633 libraries that it depends on are installed.
3635 This wrapper executable should never be moved out of the build directory.
3636 If it is, it will not operate correctly.
3638 Currently, it simply execs the wrapper *script* "$SHELL $output",
3639 but could eventually absorb all of the scripts functionality and
3640 exec $objdir/$outputname directly.
3647 # include <direct.h>
3648 # include <process.h>
3650 # define setmode _setmode
3652 # include <unistd.h>
3653 # include <stdint.h>
3656 # define HAVE_SETENV
3657 # ifdef __STRICT_ANSI__
3658 char *realpath (const char *, char *);
3659 int putenv (char *);
3660 int setenv (const char *, const char *, int);
3671 #include <sys/stat.h>
3673 #if defined(PATH_MAX)
3674 # define LT_PATHMAX PATH_MAX
3675 #elif defined(MAXPATHLEN)
3676 # define LT_PATHMAX MAXPATHLEN
3678 # define LT_PATHMAX 1024
3689 # define S_IXUSR _S_IEXEC
3691 # ifndef _INTPTR_T_DEFINED
3692 # define intptr_t int
3696 #ifndef DIR_SEPARATOR
3697 # define DIR_SEPARATOR '/'
3698 # define PATH_SEPARATOR ':'
3701 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3703 # define HAVE_DOS_BASED_FILE_SYSTEM
3704 # define FOPEN_WB "wb"
3705 # ifndef DIR_SEPARATOR_2
3706 # define DIR_SEPARATOR_2 '\\'
3708 # ifndef PATH_SEPARATOR_2
3709 # define PATH_SEPARATOR_2 ';'
3713 #ifndef DIR_SEPARATOR_2
3714 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3715 #else /* DIR_SEPARATOR_2 */
3716 # define IS_DIR_SEPARATOR(ch) \
3717 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3718 #endif /* DIR_SEPARATOR_2 */
3720 #ifndef PATH_SEPARATOR_2
3721 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3722 #else /* PATH_SEPARATOR_2 */
3723 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3724 #endif /* PATH_SEPARATOR_2 */
3727 # define FOPEN_WB "wb"
3731 # define FOPEN_WB "w"
3734 # define _O_BINARY 0
3737 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3738 #define XFREE(stale) do { \
3739 if (stale) { free ((void *) stale); stale = 0; } \
3742 #undef LTWRAPPER_DEBUGPRINTF
3743 #if defined DEBUGWRAPPER
3744 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3746 ltwrapper_debugprintf (const char *fmt, ...)
3749 va_start (args, fmt);
3750 (void) vfprintf (stderr, fmt, args);
3754 # define LTWRAPPER_DEBUGPRINTF(args)
3757 const char *program_name = NULL;
3759 void *xmalloc (size_t num);
3760 char *xstrdup (const char *string);
3761 const char *base_name (const char *name);
3762 char *find_executable (const char *wrapper);
3763 char *chase_symlinks (const char *pathspec);
3764 int make_executable (const char *path);
3765 int check_executable (const char *path);
3766 char *strendzap (char *str, const char *pat);
3767 void lt_fatal (const char *message, ...);
3768 void lt_setenv (const char *name, const char *value);
3769 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3770 void lt_opt_process_env_set (const char *arg);
3771 void lt_opt_process_env_prepend (const char *arg);
3772 void lt_opt_process_env_append (const char *arg);
3773 int lt_split_name_value (const char *arg, char** name, char** value);
3774 void lt_update_exe_path (const char *name, const char *value);
3775 void lt_update_lib_path (const char *name, const char *value);
3777 static const char *script_text_part1 =
3780 func_emit_wrapper_part1 yes |
3781 $SED -e 's/\([\\"]\)/\\\1/g' \
3782 -e 's/^/ "/' -e 's/$/\\n"/'
3786 static const char *script_text_part2 =
3788 func_emit_wrapper_part2 yes |
3789 $SED -e 's/\([\\"]\)/\\\1/g' \
3790 -e 's/^/ "/' -e 's/$/\\n"/'
3794 const char * MAGIC_EXE = "$magic_exe";
3795 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3798 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3799 func_to_host_pathlist "$temp_rpath"
3801 const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3805 const char * LIB_PATH_VALUE = "";
3809 if test -n "$dllsearchpath"; then
3810 func_to_host_pathlist "$dllsearchpath:"
3812 const char * EXE_PATH_VARNAME = "PATH";
3813 const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3817 const char * EXE_PATH_VARNAME = "";
3818 const char * EXE_PATH_VALUE = "";
3822 if test "$fast_install" = yes; then
3824 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3828 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3835 #define LTWRAPPER_OPTION_PREFIX "--lt-"
3836 #define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3838 static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3839 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3841 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3843 static const size_t env_set_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3844 static const char *env_set_opt = LTWRAPPER_OPTION_PREFIX "env-set";
3845 /* argument is putenv-style "foo=bar", value of foo is set to bar */
3847 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3848 static const char *env_prepend_opt = LTWRAPPER_OPTION_PREFIX "env-prepend";
3849 /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3851 static const size_t env_append_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3852 static const char *env_append_opt = LTWRAPPER_OPTION_PREFIX "env-append";
3853 /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3856 main (int argc, char *argv[])
3861 char *actual_cwrapper_path;
3862 char *actual_cwrapper_name;
3865 intptr_t rval = 127;
3869 program_name = (char *) xstrdup (base_name (argv[0]));
3870 LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3871 LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3873 /* very simple arg parsing; don't want to rely on getopt */
3874 for (i = 1; i < argc; i++)
3876 if (strcmp (argv[i], dumpscript_opt) == 0)
3880 *mingw* | *cygwin* )
3881 # make stdout use "unix" line endings
3882 echo " setmode(1,_O_BINARY);"
3887 printf ("%s", script_text_part1);
3888 printf ("%s", script_text_part2);
3893 newargz = XMALLOC (char *, argc + 1);
3894 tmp_pathspec = find_executable (argv[0]);
3895 if (tmp_pathspec == NULL)
3896 lt_fatal ("Couldn't find %s", argv[0]);
3897 LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3900 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3901 LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3902 actual_cwrapper_path));
3903 XFREE (tmp_pathspec);
3905 actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3906 strendzap (actual_cwrapper_path, actual_cwrapper_name);
3908 /* wrapper name transforms */
3909 strendzap (actual_cwrapper_name, ".exe");
3910 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3911 XFREE (actual_cwrapper_name);
3912 actual_cwrapper_name = tmp_pathspec;
3915 /* target_name transforms -- use actual target program name; might have lt- prefix */
3916 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3917 strendzap (target_name, ".exe");
3918 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3919 XFREE (target_name);
3920 target_name = tmp_pathspec;
3923 LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3929 XMALLOC (char, (strlen (actual_cwrapper_path) +
3930 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3931 strcpy (newargz[0], actual_cwrapper_path);
3932 strcat (newargz[0], "$objdir");
3933 strcat (newargz[0], "/");
3937 /* stop here, and copy so we don't have to do this twice */
3938 tmp_pathspec = xstrdup (newargz[0]);
3940 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3941 strcat (newargz[0], actual_cwrapper_name);
3943 /* DO want the lt- prefix here if it exists, so use target_name */
3944 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3945 XFREE (tmp_pathspec);
3946 tmp_pathspec = NULL;
3954 while ((p = strchr (newargz[0], '\\')) != NULL)
3958 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3968 XFREE (target_name);
3969 XFREE (actual_cwrapper_path);
3970 XFREE (actual_cwrapper_name);
3972 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3973 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3974 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3975 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3978 for (i = 1; i < argc; i++)
3980 if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3982 if (argv[i][env_set_opt_len] == '=')
3984 const char *p = argv[i] + env_set_opt_len + 1;
3985 lt_opt_process_env_set (p);
3987 else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3989 lt_opt_process_env_set (argv[++i]); /* don't copy */
3992 lt_fatal ("%s missing required argument", env_set_opt);
3995 if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3997 if (argv[i][env_prepend_opt_len] == '=')
3999 const char *p = argv[i] + env_prepend_opt_len + 1;
4000 lt_opt_process_env_prepend (p);
4002 else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
4004 lt_opt_process_env_prepend (argv[++i]); /* don't copy */
4007 lt_fatal ("%s missing required argument", env_prepend_opt);
4010 if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
4012 if (argv[i][env_append_opt_len] == '=')
4014 const char *p = argv[i] + env_append_opt_len + 1;
4015 lt_opt_process_env_append (p);
4017 else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
4019 lt_opt_process_env_append (argv[++i]); /* don't copy */
4022 lt_fatal ("%s missing required argument", env_append_opt);
4025 if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
4027 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4028 namespace, but it is not one of the ones we know about and
4029 have already dealt with, above (inluding dump-script), then
4030 report an error. Otherwise, targets might begin to believe
4031 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4032 namespace. The first time any user complains about this, we'll
4033 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4034 or a configure.ac-settable value.
4036 lt_fatal ("Unrecognized option in %s namespace: '%s'",
4037 ltwrapper_option_prefix, argv[i]);
4040 newargz[++newargc] = xstrdup (argv[i]);
4042 newargz[++newargc] = NULL;
4044 LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
4045 for (i = 0; i < newargc; i++)
4047 LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4055 /* execv doesn't actually work on mingw as expected on unix */
4056 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4059 /* failed to start process */
4060 LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4068 execv (lt_argv_zero, newargz);
4069 return rval; /* =127, but avoids unused variable warning */
4078 xmalloc (size_t num)
4080 void *p = (void *) malloc (num);
4082 lt_fatal ("Memory exhausted");
4088 xstrdup (const char *string)
4090 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4095 base_name (const char *name)
4099 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4100 /* Skip over the disk name in MSDOS pathnames. */
4101 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4105 for (base = name; *name; name++)
4106 if (IS_DIR_SEPARATOR (*name))
4112 check_executable (const char *path)
4116 LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
4117 path ? (*path ? path : "EMPTY!") : "NULL!"));
4118 if ((!path) || (!*path))
4121 if ((stat (path, &st) >= 0)
4122 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4129 make_executable (const char *path)
4134 LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
4135 path ? (*path ? path : "EMPTY!") : "NULL!"));
4136 if ((!path) || (!*path))
4139 if (stat (path, &st) >= 0)
4141 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4146 /* Searches for the full path of the wrapper. Returns
4147 newly allocated full path name if found, NULL otherwise
4148 Does not chase symlinks, even on platforms that support them.
4151 find_executable (const char *wrapper)
4156 /* static buffer for getcwd */
4157 char tmp[LT_PATHMAX + 1];
4161 LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
4162 wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4164 if ((wrapper == NULL) || (*wrapper == '\0'))
4167 /* Absolute path? */
4168 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4169 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4171 concat_name = xstrdup (wrapper);
4172 if (check_executable (concat_name))
4174 XFREE (concat_name);
4179 if (IS_DIR_SEPARATOR (wrapper[0]))
4181 concat_name = xstrdup (wrapper);
4182 if (check_executable (concat_name))
4184 XFREE (concat_name);
4186 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4190 for (p = wrapper; *p; p++)
4198 /* no slashes; search PATH */
4199 const char *path = getenv ("PATH");
4202 for (p = path; *p; p = p_next)
4206 for (q = p; *q; q++)
4207 if (IS_PATH_SEPARATOR (*q))
4210 p_next = (*q == '\0' ? q : q + 1);
4213 /* empty path: current directory */
4214 if (getcwd (tmp, LT_PATHMAX) == NULL)
4215 lt_fatal ("getcwd failed");
4216 tmp_len = strlen (tmp);
4218 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4219 memcpy (concat_name, tmp, tmp_len);
4220 concat_name[tmp_len] = '/';
4221 strcpy (concat_name + tmp_len + 1, wrapper);
4226 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4227 memcpy (concat_name, p, p_len);
4228 concat_name[p_len] = '/';
4229 strcpy (concat_name + p_len + 1, wrapper);
4231 if (check_executable (concat_name))
4233 XFREE (concat_name);
4236 /* not found in PATH; assume curdir */
4238 /* Relative path | not found in path: prepend cwd */
4239 if (getcwd (tmp, LT_PATHMAX) == NULL)
4240 lt_fatal ("getcwd failed");
4241 tmp_len = strlen (tmp);
4242 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4243 memcpy (concat_name, tmp, tmp_len);
4244 concat_name[tmp_len] = '/';
4245 strcpy (concat_name + tmp_len + 1, wrapper);
4247 if (check_executable (concat_name))
4249 XFREE (concat_name);
4254 chase_symlinks (const char *pathspec)
4257 return xstrdup (pathspec);
4259 char buf[LT_PATHMAX];
4261 char *tmp_pathspec = xstrdup (pathspec);
4263 int has_symlinks = 0;
4264 while (strlen (tmp_pathspec) && !has_symlinks)
4266 LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
4268 if (lstat (tmp_pathspec, &s) == 0)
4270 if (S_ISLNK (s.st_mode) != 0)
4276 /* search backwards for last DIR_SEPARATOR */
4277 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4278 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4280 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4282 /* no more DIR_SEPARATORS left */
4289 char *errstr = strerror (errno);
4290 lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4293 XFREE (tmp_pathspec);
4297 return xstrdup (pathspec);
4300 tmp_pathspec = realpath (pathspec, buf);
4301 if (tmp_pathspec == 0)
4303 lt_fatal ("Could not follow symlinks for %s", pathspec);
4305 return xstrdup (tmp_pathspec);
4310 strendzap (char *str, const char *pat)
4314 assert (str != NULL);
4315 assert (pat != NULL);
4318 patlen = strlen (pat);
4322 str += len - patlen;
4323 if (strcmp (str, pat) == 0)
4330 lt_error_core (int exit_status, const char *mode,
4331 const char *message, va_list ap)
4333 fprintf (stderr, "%s: %s: ", program_name, mode);
4334 vfprintf (stderr, message, ap);
4335 fprintf (stderr, ".\n");
4337 if (exit_status >= 0)
4342 lt_fatal (const char *message, ...)
4345 va_start (ap, message);
4346 lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4351 lt_setenv (const char *name, const char *value)
4353 LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4354 (name ? name : "<NULL>"),
4355 (value ? value : "<NULL>")));
4358 /* always make a copy, for consistency with !HAVE_SETENV */
4359 char *str = xstrdup (value);
4360 setenv (name, str, 1);
4362 int len = strlen (name) + 1 + strlen (value) + 1;
4363 char *str = XMALLOC (char, len);
4364 sprintf (str, "%s=%s", name, value);
4365 if (putenv (str) != EXIT_SUCCESS)
4374 lt_extend_str (const char *orig_value, const char *add, int to_end)
4377 if (orig_value && *orig_value)
4379 int orig_value_len = strlen (orig_value);
4380 int add_len = strlen (add);
4381 new_value = XMALLOC (char, add_len + orig_value_len + 1);
4384 strcpy (new_value, orig_value);
4385 strcpy (new_value + orig_value_len, add);
4389 strcpy (new_value, add);
4390 strcpy (new_value + add_len, orig_value);
4395 new_value = xstrdup (add);
4401 lt_split_name_value (const char *arg, char** name, char** value)
4408 p = strchr (arg, (int)'=');
4413 *value = xstrdup (++p);
4415 len = strlen (arg) - strlen (*value);
4416 *name = XMALLOC (char, len);
4417 strncpy (*name, arg, len-1);
4418 (*name)[len - 1] = '\0';
4424 lt_opt_process_env_set (const char *arg)
4429 if (lt_split_name_value (arg, &name, &value) != 0)
4433 lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
4436 lt_setenv (name, value);
4442 lt_opt_process_env_prepend (const char *arg)
4446 char *new_value = NULL;
4448 if (lt_split_name_value (arg, &name, &value) != 0)
4452 lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
4455 new_value = lt_extend_str (getenv (name), value, 0);
4456 lt_setenv (name, new_value);
4463 lt_opt_process_env_append (const char *arg)
4467 char *new_value = NULL;
4469 if (lt_split_name_value (arg, &name, &value) != 0)
4473 lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
4476 new_value = lt_extend_str (getenv (name), value, 1);
4477 lt_setenv (name, new_value);
4484 lt_update_exe_path (const char *name, const char *value)
4486 LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4487 (name ? name : "<NULL>"),
4488 (value ? value : "<NULL>")));
4490 if (name && *name && value && *value)
4492 char *new_value = lt_extend_str (getenv (name), value, 0);
4493 /* some systems can't cope with a ':'-terminated path #' */
4494 int len = strlen (new_value);
4495 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4497 new_value[len-1] = '\0';
4499 lt_setenv (name, new_value);
4505 lt_update_lib_path (const char *name, const char *value)
4507 LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4508 (name ? name : "<NULL>"),
4509 (value ? value : "<NULL>")));
4511 if (name && *name && value && *value)
4513 char *new_value = lt_extend_str (getenv (name), value, 0);
4514 lt_setenv (name, new_value);
4522 # end: func_emit_cwrapperexe_src
4524 # func_mode_link arg...
4529 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4530 # It is impossible to link a dll without this setting, and
4531 # we shouldn't force the makefile maintainer to figure out
4532 # which system we are compiling for in order to pass an extra
4533 # flag for every libtool invocation.
4534 # allow_undefined=no
4536 # FIXME: Unfortunately, there are problems with the above when trying
4537 # to make a dll which has undefined symbols, in which case not
4538 # even a static library is built. For now, we need to specify
4539 # -no-undefined on the libtool link line when we can be certain
4540 # that all symbols are satisfied, otherwise we get a static library.
4547 libtool_args=$nonopt
4548 base_compile="$nonopt $@"
4549 compile_command=$nonopt
4550 finalize_command=$nonopt
4563 lib_search_path=`pwd`
4565 new_inherited_linker_flags=
4573 export_symbols_regex=
4581 precious_files_regex=
4582 prefer_static_libs=no
4595 single_module="${wl}-single_module"
4596 func_infer_tag $base_compile
4598 # We need to know -static, to get the right output filenames.
4603 test "$build_libtool_libs" != yes && \
4604 func_fatal_configuration "can not build a shared library"
4608 -all-static | -static | -static-libtool-libs)
4611 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4612 func_warning "complete static linking is impossible in this configuration"
4614 if test -n "$link_static_flag"; then
4615 dlopen_self=$dlopen_self_static
4617 prefer_static_libs=yes
4620 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4621 dlopen_self=$dlopen_self_static
4623 prefer_static_libs=built
4625 -static-libtool-libs)
4626 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4627 dlopen_self=$dlopen_self_static
4629 prefer_static_libs=yes
4632 build_libtool_libs=no
4639 # See if our shared archives depend on static archives.
4640 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4642 # Go through the arguments, transforming them on the way.
4643 while test "$#" -gt 0; do
4646 func_quote_for_eval "$arg"
4647 qarg=$func_quote_for_eval_unquoted_result
4648 func_append libtool_args " $func_quote_for_eval_result"
4650 # If the previous option needs an argument, assign it.
4651 if test -n "$prev"; then
4654 func_append compile_command " @OUTPUT@"
4655 func_append finalize_command " @OUTPUT@"
4661 if test "$preload" = no; then
4662 # Add the symbol object into the linking commands.
4663 func_append compile_command " @SYMFILE@"
4664 func_append finalize_command " @SYMFILE@"
4668 *.la | *.lo) ;; # We handle these cases below.
4670 if test "$dlself" = no; then
4678 if test "$prev" = dlprefiles; then
4680 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4690 if test "$prev" = dlfiles; then
4691 dlfiles="$dlfiles $arg"
4693 dlprefiles="$dlprefiles $arg"
4701 export_symbols="$arg"
4703 || func_fatal_error "symbol file \`$arg' does not exist"
4708 export_symbols_regex="$arg"
4716 *" $qarg.ltframework "*) ;;
4717 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4726 inst_prefix_dir="$arg"
4731 if test -f "$arg"; then
4734 for fil in `cat "$save_arg"`
4736 # moreargs="$moreargs $fil"
4738 # A libtool-controlled object.
4740 # Check to see that this really is a libtool object.
4741 if func_lalib_unsafe_p "$arg"; then
4748 if test -z "$pic_object" ||
4749 test -z "$non_pic_object" ||
4750 test "$pic_object" = none &&
4751 test "$non_pic_object" = none; then
4752 func_fatal_error "cannot find name of object for \`$arg'"
4755 # Extract subdirectory from the argument.
4756 func_dirname "$arg" "/" ""
4757 xdir="$func_dirname_result"
4759 if test "$pic_object" != none; then
4760 # Prepend the subdirectory the object is found in.
4761 pic_object="$xdir$pic_object"
4763 if test "$prev" = dlfiles; then
4764 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4765 dlfiles="$dlfiles $pic_object"
4769 # If libtool objects are unsupported, then we need to preload.
4774 # CHECK ME: I think I busted this. -Ossama
4775 if test "$prev" = dlprefiles; then
4776 # Preload the old-style object.
4777 dlprefiles="$dlprefiles $pic_object"
4782 func_append libobjs " $pic_object"
4787 if test "$non_pic_object" != none; then
4788 # Prepend the subdirectory the object is found in.
4789 non_pic_object="$xdir$non_pic_object"
4791 # A standard non-PIC object
4792 func_append non_pic_objects " $non_pic_object"
4793 if test -z "$pic_object" || test "$pic_object" = none ; then
4794 arg="$non_pic_object"
4797 # If the PIC object exists, use it instead.
4798 # $xdir was prepended to $pic_object above.
4799 non_pic_object="$pic_object"
4800 func_append non_pic_objects " $non_pic_object"
4803 # Only an error if not doing a dry-run.
4804 if $opt_dry_run; then
4805 # Extract subdirectory from the argument.
4806 func_dirname "$arg" "/" ""
4807 xdir="$func_dirname_result"
4810 pic_object=$xdir$objdir/$func_lo2o_result
4811 non_pic_object=$xdir$func_lo2o_result
4812 func_append libobjs " $pic_object"
4813 func_append non_pic_objects " $non_pic_object"
4815 func_fatal_error "\`$arg' is not a valid libtool object"
4820 func_fatal_error "link input file \`$arg' does not exist"
4827 precious_files_regex="$arg"
4837 # We need an absolute path.
4839 [\\/]* | [A-Za-z]:[\\/]*) ;;
4841 func_fatal_error "only absolute run-paths are allowed"
4844 if test "$prev" = rpath; then
4847 *) rpath="$rpath $arg" ;;
4852 *) xrpath="$xrpath $arg" ;;
4864 weak_libs="$weak_libs $arg"
4869 linker_flags="$linker_flags $qarg"
4870 compiler_flags="$compiler_flags $qarg"
4872 func_append compile_command " $qarg"
4873 func_append finalize_command " $qarg"
4877 compiler_flags="$compiler_flags $qarg"
4879 func_append compile_command " $qarg"
4880 func_append finalize_command " $qarg"
4884 linker_flags="$linker_flags $qarg"
4885 compiler_flags="$compiler_flags $wl$qarg"
4887 func_append compile_command " $wl$qarg"
4888 func_append finalize_command " $wl$qarg"
4892 eval "$prev=\"\$arg\""
4897 fi # test -n "$prev"
4903 if test -n "$link_static_flag"; then
4904 # See comment for -static flag below, for more details.
4905 func_append compile_command " $link_static_flag"
4906 func_append finalize_command " $link_static_flag"
4912 # FIXME: remove this flag sometime in the future.
4913 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4936 -export-symbols | -export-symbols-regex)
4937 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4938 func_fatal_error "more than one -exported-symbols argument is not allowed"
4940 if test "X$arg" = "X-export-symbols"; then
4958 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4959 # so, if we see these flags be careful not to treat them like -L
4961 case $with_gcc/$host in
4962 no/*-*-irix* | /*-*-irix*)
4963 func_append compile_command " $arg"
4964 func_append finalize_command " $arg"
4971 func_stripname '-L' '' "$arg"
4972 dir=$func_stripname_result
4973 if test -z "$dir"; then
4974 if test "$#" -gt 0; then
4975 func_fatal_error "require no space between \`-L' and \`$1'"
4977 func_fatal_error "need path for \`-L' option"
4980 # We need an absolute path.
4982 [\\/]* | [A-Za-z]:[\\/]*) ;;
4984 absdir=`cd "$dir" && pwd`
4985 test -z "$absdir" && \
4986 func_fatal_error "cannot determine absolute directory name of \`$dir'"
4993 deplibs="$deplibs -L$dir"
4994 lib_search_path="$lib_search_path $dir"
4998 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4999 testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
5000 case :$dllsearchpath: in
5002 ::) dllsearchpath=$dir;;
5003 *) dllsearchpath="$dllsearchpath:$dir";;
5005 case :$dllsearchpath: in
5006 *":$testbindir:"*) ;;
5007 ::) dllsearchpath=$testbindir;;
5008 *) dllsearchpath="$dllsearchpath:$testbindir";;
5016 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5018 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5019 # These systems don't actually have a C or math library (as such)
5023 # These systems don't actually have a C library (as such)
5024 test "X$arg" = "X-lc" && continue
5026 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5027 # Do not include libc due to us having libc/libc_r.
5028 test "X$arg" = "X-lc" && continue
5030 *-*-rhapsody* | *-*-darwin1.[012])
5031 # Rhapsody C and math libraries are in the System framework
5032 deplibs="$deplibs System.ltframework"
5035 *-*-sco3.2v5* | *-*-sco5v6*)
5036 # Causes problems with __ctype
5037 test "X$arg" = "X-lc" && continue
5039 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5040 # Compiler inserts libc in the correct place for threads to work
5041 test "X$arg" = "X-lc" && continue
5044 elif test "X$arg" = "X-lc_r"; then
5046 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5047 # Do not include libc_r directly, use -pthread flag.
5052 deplibs="$deplibs $arg"
5061 # Tru64 UNIX uses -model [arg] to determine the layout of C++
5062 # classes, name mangling, and exception handling.
5063 # Darwin uses the -arch flag to determine output architecture.
5064 -model|-arch|-isysroot)
5065 compiler_flags="$compiler_flags $arg"
5066 func_append compile_command " $arg"
5067 func_append finalize_command " $arg"
5072 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5073 compiler_flags="$compiler_flags $arg"
5074 func_append compile_command " $arg"
5075 func_append finalize_command " $arg"
5076 case "$new_inherited_linker_flags " in
5078 * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5084 single_module="${wl}-multi_module"
5095 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5096 # The PATH hackery in wrapper scripts is required on Windows
5097 # and Darwin in order for the loader to find any dlls it needs.
5098 func_warning "\`-no-install' is ignored for $host"
5099 func_warning "assuming \`-no-fast-install' instead"
5102 *) no_install=yes ;;
5119 -precious-files-regex)
5140 func_stripname '-R' '' "$arg"
5141 dir=$func_stripname_result
5142 # We need an absolute path.
5144 [\\/]* | [A-Za-z]:[\\/]*) ;;
5146 func_fatal_error "only absolute run-paths are allowed"
5151 *) xrpath="$xrpath $dir" ;;
5157 # The effects of -shared are defined in a previous loop.
5166 -static | -static-libtool-libs)
5167 # The effects of -static are defined in a previous loop.
5168 # We used to do the same as -all-static on platforms that
5169 # didn't have a PIC flag, but the assumption that the effects
5170 # would be equivalent was wrong. It would break on at least
5171 # Digital Unix and AIX.
5197 func_stripname '-Wc,' '' "$arg"
5198 args=$func_stripname_result
5200 save_ifs="$IFS"; IFS=','
5201 for flag in $args; do
5203 func_quote_for_eval "$flag"
5204 arg="$arg $wl$func_quote_for_eval_result"
5205 compiler_flags="$compiler_flags $func_quote_for_eval_result"
5208 func_stripname ' ' '' "$arg"
5209 arg=$func_stripname_result
5213 func_stripname '-Wl,' '' "$arg"
5214 args=$func_stripname_result
5216 save_ifs="$IFS"; IFS=','
5217 for flag in $args; do
5219 func_quote_for_eval "$flag"
5220 arg="$arg $wl$func_quote_for_eval_result"
5221 compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
5222 linker_flags="$linker_flags $func_quote_for_eval_result"
5225 func_stripname ' ' '' "$arg"
5226 arg=$func_stripname_result
5246 func_quote_for_eval "$arg"
5247 arg="$func_quote_for_eval_result"
5250 # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
5251 # -r[0-9][0-9]* specifies the processor on the SGI compiler
5252 # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
5253 # +DA*, +DD* enable 64-bit mode on the HP compiler
5254 # -q* pass through compiler args for the IBM compiler
5255 # -m*, -t[45]*, -txscale* pass through architecture-specific
5256 # compiler args for GCC
5257 # -F/path gives path to uninstalled frameworks, gcc on darwin
5258 # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
5259 # @file GCC response files
5260 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5261 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5262 func_quote_for_eval "$arg"
5263 arg="$func_quote_for_eval_result"
5264 func_append compile_command " $arg"
5265 func_append finalize_command " $arg"
5266 compiler_flags="$compiler_flags $arg"
5270 # Some other compiler flag.
5272 func_quote_for_eval "$arg"
5273 arg="$func_quote_for_eval_result"
5277 # A standard object.
5282 # A libtool-controlled object.
5284 # Check to see that this really is a libtool object.
5285 if func_lalib_unsafe_p "$arg"; then
5292 if test -z "$pic_object" ||
5293 test -z "$non_pic_object" ||
5294 test "$pic_object" = none &&
5295 test "$non_pic_object" = none; then
5296 func_fatal_error "cannot find name of object for \`$arg'"
5299 # Extract subdirectory from the argument.
5300 func_dirname "$arg" "/" ""
5301 xdir="$func_dirname_result"
5303 if test "$pic_object" != none; then
5304 # Prepend the subdirectory the object is found in.
5305 pic_object="$xdir$pic_object"
5307 if test "$prev" = dlfiles; then
5308 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5309 dlfiles="$dlfiles $pic_object"
5313 # If libtool objects are unsupported, then we need to preload.
5318 # CHECK ME: I think I busted this. -Ossama
5319 if test "$prev" = dlprefiles; then
5320 # Preload the old-style object.
5321 dlprefiles="$dlprefiles $pic_object"
5326 func_append libobjs " $pic_object"
5331 if test "$non_pic_object" != none; then
5332 # Prepend the subdirectory the object is found in.
5333 non_pic_object="$xdir$non_pic_object"
5335 # A standard non-PIC object
5336 func_append non_pic_objects " $non_pic_object"
5337 if test -z "$pic_object" || test "$pic_object" = none ; then
5338 arg="$non_pic_object"
5341 # If the PIC object exists, use it instead.
5342 # $xdir was prepended to $pic_object above.
5343 non_pic_object="$pic_object"
5344 func_append non_pic_objects " $non_pic_object"
5347 # Only an error if not doing a dry-run.
5348 if $opt_dry_run; then
5349 # Extract subdirectory from the argument.
5350 func_dirname "$arg" "/" ""
5351 xdir="$func_dirname_result"
5354 pic_object=$xdir$objdir/$func_lo2o_result
5355 non_pic_object=$xdir$func_lo2o_result
5356 func_append libobjs " $pic_object"
5357 func_append non_pic_objects " $non_pic_object"
5359 func_fatal_error "\`$arg' is not a valid libtool object"
5366 deplibs="$deplibs $arg"
5367 old_deplibs="$old_deplibs $arg"
5372 # A libtool-controlled library.
5374 if test "$prev" = dlfiles; then
5375 # This library was specified with -dlopen.
5376 dlfiles="$dlfiles $arg"
5378 elif test "$prev" = dlprefiles; then
5379 # The library was specified with -dlpreopen.
5380 dlprefiles="$dlprefiles $arg"
5383 deplibs="$deplibs $arg"
5388 # Some other compiler argument.
5390 # Unknown arguments in both finalize_command and compile_command need
5391 # to be aesthetically quoted because they are evaled later.
5392 func_quote_for_eval "$arg"
5393 arg="$func_quote_for_eval_result"
5397 # Now actually substitute the argument into the commands.
5398 if test -n "$arg"; then
5399 func_append compile_command " $arg"
5400 func_append finalize_command " $arg"
5402 done # argument parsing loop
5404 test -n "$prev" && \
5405 func_fatal_help "the \`$prevarg' option requires an argument"
5407 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5408 eval arg=\"$export_dynamic_flag_spec\"
5409 func_append compile_command " $arg"
5410 func_append finalize_command " $arg"
5414 # calculate the name of the file, without its directory
5415 func_basename "$output"
5416 outputname="$func_basename_result"
5417 libobjs_save="$libobjs"
5419 if test -n "$shlibpath_var"; then
5420 # get the directories listed in $shlibpath_var
5421 eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
5425 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5426 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5428 func_dirname "$output" "/" ""
5429 output_objdir="$func_dirname_result$objdir"
5430 # Create the object directory.
5431 func_mkdir_p "$output_objdir"
5433 # Determine the type of output
5436 func_fatal_help "you must specify an output file"
5438 *.$libext) linkmode=oldlib ;;
5439 *.lo | *.$objext) linkmode=obj ;;
5440 *.la) linkmode=lib ;;
5441 *) linkmode=prog ;; # Anything else should be a program.
5447 # Find all interdependent deplibs by searching for libraries
5448 # that are linked more than once (e.g. -la -lb -la)
5449 for deplib in $deplibs; do
5450 if $opt_duplicate_deps ; then
5452 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5455 libs="$libs $deplib"
5458 if test "$linkmode" = lib; then
5459 libs="$predeps $libs $compiler_lib_search_path $postdeps"
5461 # Compute libraries that are listed more than once in $predeps
5462 # $postdeps and mark them as special (i.e., whose duplicates are
5463 # not to be eliminated).
5465 if $opt_duplicate_compiler_generated_deps; then
5466 for pre_post_dep in $predeps $postdeps; do
5467 case "$pre_post_deps " in
5468 *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5470 pre_post_deps="$pre_post_deps $pre_post_dep"
5479 need_relink=no # whether we're linking any uninstalled libtool libraries
5480 notinst_deplibs= # not-installed libtool libraries
5481 notinst_path= # paths that contain not-installed libtool libraries
5485 passes="conv dlpreopen link"
5486 for file in $dlfiles $dlprefiles; do
5490 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5501 passes="conv scan dlopen dlpreopen link"
5507 for pass in $passes; do
5508 # The preopen pass in lib mode reverses $deplibs; put it back here
5509 # so that -L comes before libs that need it for instance...
5510 if test "$linkmode,$pass" = "lib,link"; then
5511 ## FIXME: Find the place where the list is rebuilt in the wrong
5512 ## order, and fix it there properly
5514 for deplib in $deplibs; do
5515 tmp_deplibs="$deplib $tmp_deplibs"
5517 deplibs="$tmp_deplibs"
5520 if test "$linkmode,$pass" = "lib,link" ||
5521 test "$linkmode,$pass" = "prog,scan"; then
5525 if test "$linkmode" = prog; then
5527 dlopen) libs="$dlfiles" ;;
5528 dlpreopen) libs="$dlprefiles" ;;
5530 libs="$deplibs %DEPLIBS%"
5531 test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
5535 if test "$linkmode,$pass" = "lib,dlpreopen"; then
5536 # Collect and forward deplibs of preopened libtool libs
5537 for lib in $dlprefiles; do
5538 # Ignore non-libtool-libs
5541 *.la) func_source "$lib" ;;
5544 # Collect preopened libtool deplibs, except any this library
5545 # has declared as weak libs
5546 for deplib in $dependency_libs; do
5547 deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5548 case " $weak_libs " in
5549 *" $deplib_base "*) ;;
5550 *) deplibs="$deplibs $deplib" ;;
5556 if test "$pass" = dlopen; then
5557 # Collect dlpreopened libraries
5558 save_deplibs="$deplibs"
5562 for deplib in $libs; do
5566 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5567 if test "$linkmode,$pass" = "prog,link"; then
5568 compile_deplibs="$deplib $compile_deplibs"
5569 finalize_deplibs="$deplib $finalize_deplibs"
5571 compiler_flags="$compiler_flags $deplib"
5572 if test "$linkmode" = lib ; then
5573 case "$new_inherited_linker_flags " in
5575 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5582 if test "$linkmode" != lib && test "$linkmode" != prog; then
5583 func_warning "\`-l' is ignored for archives/objects"
5586 func_stripname '-l' '' "$deplib"
5587 name=$func_stripname_result
5588 if test "$linkmode" = lib; then
5589 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5591 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5593 for searchdir in $searchdirs; do
5594 for search_ext in .la $std_shrext .so .a; do
5595 # Search the libtool library
5596 lib="$searchdir/lib${name}${search_ext}"
5597 if test -f "$lib"; then
5598 if test "$search_ext" = ".la"; then
5607 if test "$found" != yes; then
5608 # deplib doesn't seem to be a libtool library
5609 if test "$linkmode,$pass" = "prog,link"; then
5610 compile_deplibs="$deplib $compile_deplibs"
5611 finalize_deplibs="$deplib $finalize_deplibs"
5613 deplibs="$deplib $deplibs"
5614 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5617 else # deplib is a libtool library
5618 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5619 # We need to do some special things here, and not later.
5620 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5621 case " $predeps $postdeps " in
5623 if func_lalib_p "$lib"; then
5627 for l in $old_library $library_names; do
5630 if test "X$ll" = "X$old_library" ; then # only static version available
5632 func_dirname "$lib" "" "."
5633 ladir="$func_dirname_result"
5634 lib=$ladir/$old_library
5635 if test "$linkmode,$pass" = "prog,link"; then
5636 compile_deplibs="$deplib $compile_deplibs"
5637 finalize_deplibs="$deplib $finalize_deplibs"
5639 deplibs="$deplib $deplibs"
5640 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5652 if test "$linkmode,$pass" = "prog,link"; then
5653 compile_deplibs="$deplib $compile_deplibs"
5654 finalize_deplibs="$deplib $finalize_deplibs"
5656 deplibs="$deplib $deplibs"
5657 if test "$linkmode" = lib ; then
5658 case "$new_inherited_linker_flags " in
5660 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5669 deplibs="$deplib $deplibs"
5670 test "$pass" = conv && continue
5671 newdependency_libs="$deplib $newdependency_libs"
5672 func_stripname '-L' '' "$deplib"
5673 newlib_search_path="$newlib_search_path $func_stripname_result"
5676 if test "$pass" = conv; then
5677 deplibs="$deplib $deplibs"
5680 if test "$pass" = scan; then
5681 deplibs="$deplib $deplibs"
5683 compile_deplibs="$deplib $compile_deplibs"
5684 finalize_deplibs="$deplib $finalize_deplibs"
5686 func_stripname '-L' '' "$deplib"
5687 newlib_search_path="$newlib_search_path $func_stripname_result"
5690 func_warning "\`-L' is ignored for archives/objects"
5696 if test "$pass" = link; then
5697 func_stripname '-R' '' "$deplib"
5698 dir=$func_stripname_result
5699 # Make sure the xrpath contains only unique directories.
5702 *) xrpath="$xrpath $dir" ;;
5705 deplibs="$deplib $deplibs"
5708 *.la) lib="$deplib" ;;
5710 if test "$pass" = conv; then
5711 deplibs="$deplib $deplibs"
5716 # Linking convenience modules into shared libraries is allowed,
5717 # but linking other static libraries is non-portable.
5718 case " $dlpreconveniencelibs " in
5722 case $deplibs_check_method in
5724 set dummy $deplibs_check_method; shift
5725 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5726 if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5727 | $EGREP "$match_pattern_regex" > /dev/null; then
5735 if test "$valid_a_lib" != yes; then
5737 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5738 $ECHO "*** I have the capability to make that library automatically link in when"
5739 $ECHO "*** you link to this library. But I can only do this if you have a"
5740 $ECHO "*** shared version of the library, which you do not appear to have"
5741 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
5742 $ECHO "*** that it is just a static archive that I should not use here."
5745 $ECHO "*** Warning: Linking the shared library $output against the"
5746 $ECHO "*** static library $deplib is not portable!"
5747 deplibs="$deplib $deplibs"
5754 if test "$pass" != link; then
5755 deplibs="$deplib $deplibs"
5757 compile_deplibs="$deplib $compile_deplibs"
5758 finalize_deplibs="$deplib $finalize_deplibs"
5765 if test "$pass" = conv; then
5766 deplibs="$deplib $deplibs"
5767 elif test "$linkmode" = prog; then
5768 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5769 # If there is no dlopen support or we're linking statically,
5770 # we need to preload.
5771 newdlprefiles="$newdlprefiles $deplib"
5772 compile_deplibs="$deplib $compile_deplibs"
5773 finalize_deplibs="$deplib $finalize_deplibs"
5775 newdlfiles="$newdlfiles $deplib"
5786 if test "$found" = yes || test -f "$lib"; then :
5788 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5791 # Check to see that this really is a libtool archive.
5792 func_lalib_unsafe_p "$lib" \
5793 || func_fatal_error "\`$lib' is not a valid libtool archive"
5795 func_dirname "$lib" "" "."
5796 ladir="$func_dirname_result"
5804 inherited_linker_flags=
5805 # If the library was installed with an old release of libtool,
5806 # it will not redefine variables installed, or shouldnotlink
5815 # Convert "-framework foo" to "foo.ltframework"
5816 if test -n "$inherited_linker_flags"; then
5817 tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5818 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5819 case " $new_inherited_linker_flags " in
5820 *" $tmp_inherited_linker_flag "*) ;;
5821 *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5825 dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5826 if test "$linkmode,$pass" = "lib,link" ||
5827 test "$linkmode,$pass" = "prog,scan" ||
5828 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5829 test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5830 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5833 if test "$pass" = conv; then
5834 # Only check for convenience libraries
5835 deplibs="$lib $deplibs"
5836 if test -z "$libdir"; then
5837 if test -z "$old_library"; then
5838 func_fatal_error "cannot find name of link library for \`$lib'"
5840 # It is a libtool convenience library, so add in its objects.
5841 convenience="$convenience $ladir/$objdir/$old_library"
5842 old_convenience="$old_convenience $ladir/$objdir/$old_library"
5844 for deplib in $dependency_libs; do
5845 deplibs="$deplib $deplibs"
5846 if $opt_duplicate_deps ; then
5847 case "$tmp_libs " in
5848 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5851 tmp_libs="$tmp_libs $deplib"
5853 elif test "$linkmode" != prog && test "$linkmode" != lib; then
5854 func_fatal_error "\`$lib' is not a convenience library"
5860 # Get the name of the library we link against.
5862 for l in $old_library $library_names; do
5865 if test -z "$linklib"; then
5866 func_fatal_error "cannot find name of link library for \`$lib'"
5869 # This library was specified with -dlopen.
5870 if test "$pass" = dlopen; then
5871 if test -z "$libdir"; then
5872 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5874 if test -z "$dlname" ||
5875 test "$dlopen_support" != yes ||
5876 test "$build_libtool_libs" = no; then
5877 # If there is no dlname, no dlopen support or we're linking
5878 # statically, we need to preload. We also need to preload any
5879 # dependent libraries so libltdl's deplib preloader doesn't
5880 # bomb out in the load deplibs phase.
5881 dlprefiles="$dlprefiles $lib $dependency_libs"
5883 newdlfiles="$newdlfiles $lib"
5888 # We need an absolute path.
5890 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5892 abs_ladir=`cd "$ladir" && pwd`
5893 if test -z "$abs_ladir"; then
5894 func_warning "cannot determine absolute directory name of \`$ladir'"
5895 func_warning "passing it literally to the linker, although it might fail"
5900 func_basename "$lib"
5901 laname="$func_basename_result"
5903 # Find the relevant object directory and library name.
5904 if test "X$installed" = Xyes; then
5905 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5906 func_warning "library \`$lib' was moved."
5914 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5916 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5919 # Remove this search path later
5920 notinst_path="$notinst_path $abs_ladir"
5922 dir="$ladir/$objdir"
5923 absdir="$abs_ladir/$objdir"
5924 # Remove this search path later
5925 notinst_path="$notinst_path $abs_ladir"
5927 fi # $installed = yes
5928 func_stripname 'lib' '.la' "$laname"
5929 name=$func_stripname_result
5931 # This library was specified with -dlpreopen.
5932 if test "$pass" = dlpreopen; then
5933 if test -z "$libdir" && test "$linkmode" = prog; then
5934 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5936 # Prefer using a static library (so that no silly _DYNAMIC symbols
5937 # are required to link).
5938 if test -n "$old_library"; then
5939 newdlprefiles="$newdlprefiles $dir/$old_library"
5940 # Keep a list of preopened convenience libraries to check
5941 # that they are being used correctly in the link pass.
5942 test -z "$libdir" && \
5943 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5944 # Otherwise, use the dlname, so that lt_dlopen finds it.
5945 elif test -n "$dlname"; then
5946 newdlprefiles="$newdlprefiles $dir/$dlname"
5948 newdlprefiles="$newdlprefiles $dir/$linklib"
5950 fi # $pass = dlpreopen
5952 if test -z "$libdir"; then
5953 # Link the convenience library
5954 if test "$linkmode" = lib; then
5955 deplibs="$dir/$old_library $deplibs"
5956 elif test "$linkmode,$pass" = "prog,link"; then
5957 compile_deplibs="$dir/$old_library $compile_deplibs"
5958 finalize_deplibs="$dir/$old_library $finalize_deplibs"
5960 deplibs="$lib $deplibs" # used for prog,scan pass
5966 if test "$linkmode" = prog && test "$pass" != link; then
5967 newlib_search_path="$newlib_search_path $ladir"
5968 deplibs="$lib $deplibs"
5971 if test "$link_all_deplibs" != no || test -z "$library_names" ||
5972 test "$build_libtool_libs" = no; then
5977 for deplib in $dependency_libs; do
5979 -L*) func_stripname '-L' '' "$deplib"
5980 newlib_search_path="$newlib_search_path $func_stripname_result"
5983 # Need to link against all dependency_libs?
5984 if test "$linkalldeplibs" = yes; then
5985 deplibs="$deplib $deplibs"
5987 # Need to hardcode shared library paths
5988 # or/and link against static libraries
5989 newdependency_libs="$deplib $newdependency_libs"
5991 if $opt_duplicate_deps ; then
5992 case "$tmp_libs " in
5993 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5996 tmp_libs="$tmp_libs $deplib"
5999 fi # $linkmode = prog...
6001 if test "$linkmode,$pass" = "prog,link"; then
6002 if test -n "$library_names" &&
6003 { { test "$prefer_static_libs" = no ||
6004 test "$prefer_static_libs,$installed" = "built,yes"; } ||
6005 test -z "$old_library"; }; then
6006 # We need to hardcode the library path
6007 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6008 # Make sure the rpath contains only unique directories.
6009 case "$temp_rpath:" in
6011 *) temp_rpath="$temp_rpath$absdir:" ;;
6015 # Hardcode the library path.
6016 # Skip directories that are in the system default run-time
6018 case " $sys_lib_dlsearch_path " in
6021 case "$compile_rpath " in
6023 *) compile_rpath="$compile_rpath $absdir"
6027 case " $sys_lib_dlsearch_path " in
6030 case "$finalize_rpath " in
6032 *) finalize_rpath="$finalize_rpath $libdir"
6036 fi # $linkmode,$pass = prog,link...
6038 if test "$alldeplibs" = yes &&
6039 { test "$deplibs_check_method" = pass_all ||
6040 { test "$build_libtool_libs" = yes &&
6041 test -n "$library_names"; }; }; then
6042 # We only need to search for static libraries
6047 link_static=no # Whether the deplib will be linked statically
6048 use_static_libs=$prefer_static_libs
6049 if test "$use_static_libs" = built && test "$installed" = yes; then
6052 if test -n "$library_names" &&
6053 { test "$use_static_libs" = no || test -z "$old_library"; }; then
6055 *cygwin* | *mingw* | *cegcc*)
6056 # No point in relinking DLLs because paths are not encoded
6057 notinst_deplibs="$notinst_deplibs $lib"
6061 if test "$installed" = no; then
6062 notinst_deplibs="$notinst_deplibs $lib"
6067 # This is a shared library
6069 # Warn about portability, can't link against -module's on some
6070 # systems (darwin). Don't bleat about dlopened modules though!
6072 for dlpremoduletest in $dlprefiles; do
6073 if test "X$dlpremoduletest" = "X$lib"; then
6074 dlopenmodule="$dlpremoduletest"
6078 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6080 if test "$linkmode" = prog; then
6081 $ECHO "*** Warning: Linking the executable $output against the loadable module"
6083 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6085 $ECHO "*** $linklib is not portable!"
6087 if test "$linkmode" = lib &&
6088 test "$hardcode_into_libs" = yes; then
6089 # Hardcode the library path.
6090 # Skip directories that are in the system default run-time
6092 case " $sys_lib_dlsearch_path " in
6095 case "$compile_rpath " in
6097 *) compile_rpath="$compile_rpath $absdir"
6101 case " $sys_lib_dlsearch_path " in
6104 case "$finalize_rpath " in
6106 *) finalize_rpath="$finalize_rpath $libdir"
6112 if test -n "$old_archive_from_expsyms_cmds"; then
6113 # figure out the soname
6114 set dummy $library_names
6118 libname=`eval "\\$ECHO \"$libname_spec\""`
6119 # use dlname if we got it. it's perfectly good, no?
6120 if test -n "$dlname"; then
6122 elif test -n "$soname_spec"; then
6125 *cygwin* | mingw* | *cegcc*)
6126 func_arith $current - $age
6127 major=$func_arith_result
6131 eval soname=\"$soname_spec\"
6136 # Make a new name for the extract_expsyms_cmds to use
6138 func_basename "$soroot"
6139 soname="$func_basename_result"
6140 func_stripname 'lib' '.dll' "$soname"
6141 newlib=libimp-$func_stripname_result.a
6143 # If the library has no export list, then create one now
6144 if test -f "$output_objdir/$soname-def"; then :
6146 func_verbose "extracting exported symbol list from \`$soname'"
6147 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6151 if test -f "$output_objdir/$newlib"; then :; else
6152 func_verbose "generating import library for \`$soname'"
6153 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6155 # make sure the library variables are pointing to the new library
6158 fi # test -n "$old_archive_from_expsyms_cmds"
6160 if test "$linkmode" = prog || test "$mode" != relink; then
6165 case $hardcode_action in
6166 immediate | unsupported)
6167 if test "$hardcode_direct" = no; then
6170 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6171 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6172 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6173 *-*-unixware7*) add_dir="-L$dir" ;;
6175 # if the lib is a (non-dlopened) module then we can not
6176 # link against it, someone is ignoring the earlier warnings
6177 if /usr/bin/file -L $add 2> /dev/null |
6178 $GREP ": [^:]* bundle" >/dev/null ; then
6179 if test "X$dlopenmodule" != "X$lib"; then
6180 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6181 if test -z "$old_library" ; then
6183 $ECHO "*** And there doesn't seem to be a static archive available"
6184 $ECHO "*** The link will probably fail, sorry"
6186 add="$dir/$old_library"
6188 elif test -n "$old_library"; then
6189 add="$dir/$old_library"
6193 elif test "$hardcode_minus_L" = no; then
6195 *-*-sunos*) add_shlibpath="$dir" ;;
6199 elif test "$hardcode_shlibpath_var" = no; then
6200 add_shlibpath="$dir"
6207 if test "$hardcode_direct" = yes &&
6208 test "$hardcode_direct_absolute" = no; then
6210 elif test "$hardcode_minus_L" = yes; then
6212 # Try looking first in the location we're being installed to.
6213 if test -n "$inst_prefix_dir"; then
6216 add_dir="$add_dir -L$inst_prefix_dir$libdir"
6221 elif test "$hardcode_shlibpath_var" = yes; then
6222 add_shlibpath="$dir"
6231 if test "$lib_linked" != yes; then
6232 func_fatal_configuration "unsupported hardcode properties"
6235 if test -n "$add_shlibpath"; then
6236 case :$compile_shlibpath: in
6237 *":$add_shlibpath:"*) ;;
6238 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6241 if test "$linkmode" = prog; then
6242 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6243 test -n "$add" && compile_deplibs="$add $compile_deplibs"
6245 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6246 test -n "$add" && deplibs="$add $deplibs"
6247 if test "$hardcode_direct" != yes &&
6248 test "$hardcode_minus_L" != yes &&
6249 test "$hardcode_shlibpath_var" = yes; then
6250 case :$finalize_shlibpath: in
6252 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6258 if test "$linkmode" = prog || test "$mode" = relink; then
6262 # Finalize command for both is simple: just hardcode it.
6263 if test "$hardcode_direct" = yes &&
6264 test "$hardcode_direct_absolute" = no; then
6265 add="$libdir/$linklib"
6266 elif test "$hardcode_minus_L" = yes; then
6269 elif test "$hardcode_shlibpath_var" = yes; then
6270 case :$finalize_shlibpath: in
6272 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6275 elif test "$hardcode_automatic" = yes; then
6276 if test -n "$inst_prefix_dir" &&
6277 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6278 add="$inst_prefix_dir$libdir/$linklib"
6280 add="$libdir/$linklib"
6283 # We cannot seem to hardcode it, guess we'll fake it.
6285 # Try looking first in the location we're being installed to.
6286 if test -n "$inst_prefix_dir"; then
6289 add_dir="$add_dir -L$inst_prefix_dir$libdir"
6296 if test "$linkmode" = prog; then
6297 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6298 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6300 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6301 test -n "$add" && deplibs="$add $deplibs"
6304 elif test "$linkmode" = prog; then
6305 # Here we assume that one of hardcode_direct or hardcode_minus_L
6306 # is not unsupported. This is valid on all known static and
6308 if test "$hardcode_direct" != unsupported; then
6309 test -n "$old_library" && linklib="$old_library"
6310 compile_deplibs="$dir/$linklib $compile_deplibs"
6311 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6313 compile_deplibs="-l$name -L$dir $compile_deplibs"
6314 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6316 elif test "$build_libtool_libs" = yes; then
6317 # Not a shared library
6318 if test "$deplibs_check_method" != pass_all; then
6319 # We're trying link a shared library against a static one
6320 # but the system doesn't support it.
6322 # Just print a warning and add the library to dependency_libs so
6323 # that the program can be linked against the static library.
6325 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6326 $ECHO "*** I have the capability to make that library automatically link in when"
6327 $ECHO "*** you link to this library. But I can only do this if you have a"
6328 $ECHO "*** shared version of the library, which you do not appear to have."
6329 if test "$module" = yes; then
6330 $ECHO "*** But as you try to build a module library, libtool will still create "
6331 $ECHO "*** a static module, that should work as long as the dlopening application"
6332 $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6333 if test -z "$global_symbol_pipe"; then
6335 $ECHO "*** However, this would only work if libtool was able to extract symbol"
6336 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6337 $ECHO "*** not find such a program. So, this module is probably useless."
6338 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6340 if test "$build_old_libs" = no; then
6341 build_libtool_libs=module
6344 build_libtool_libs=no
6348 deplibs="$dir/$old_library $deplibs"
6351 fi # link shared/static library?
6353 if test "$linkmode" = lib; then
6354 if test -n "$dependency_libs" &&
6355 { test "$hardcode_into_libs" != yes ||
6356 test "$build_old_libs" = yes ||
6357 test "$link_static" = yes; }; then
6358 # Extract -R from dependency_libs
6360 for libdir in $dependency_libs; do
6362 -R*) func_stripname '-R' '' "$libdir"
6363 temp_xrpath=$func_stripname_result
6365 *" $temp_xrpath "*) ;;
6366 *) xrpath="$xrpath $temp_xrpath";;
6368 *) temp_deplibs="$temp_deplibs $libdir";;
6371 dependency_libs="$temp_deplibs"
6374 newlib_search_path="$newlib_search_path $absdir"
6375 # Link against this library
6376 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6377 # ... and its dependency_libs
6379 for deplib in $dependency_libs; do
6380 newdependency_libs="$deplib $newdependency_libs"
6381 if $opt_duplicate_deps ; then
6382 case "$tmp_libs " in
6383 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6386 tmp_libs="$tmp_libs $deplib"
6389 if test "$link_all_deplibs" != no; then
6390 # Add the search paths of all dependency libraries
6391 for deplib in $dependency_libs; do
6394 -L*) path="$deplib" ;;
6396 func_dirname "$deplib" "" "."
6397 dir="$func_dirname_result"
6398 # We need an absolute path.
6400 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6402 absdir=`cd "$dir" && pwd`
6403 if test -z "$absdir"; then
6404 func_warning "cannot determine absolute directory name of \`$dir'"
6409 if $GREP "^installed=no" $deplib > /dev/null; then
6413 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6414 if test -n "$deplibrary_names" ; then
6415 for tmp in $deplibrary_names ; do
6418 if test -f "$absdir/$objdir/$depdepl" ; then
6419 depdepl="$absdir/$objdir/$depdepl"
6420 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6421 if test -z "$darwin_install_name"; then
6422 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6424 compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6425 linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6431 path="-L$absdir/$objdir"
6435 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6436 test -z "$libdir" && \
6437 func_fatal_error "\`$deplib' is not a valid libtool archive"
6438 test "$absdir" != "$libdir" && \
6439 func_warning "\`$deplib' seems to be moved"
6445 case " $deplibs " in
6447 *) deplibs="$path $deplibs" ;;
6450 fi # link_all_deplibs != no
6452 done # for deplib in $libs
6453 if test "$pass" = link; then
6454 if test "$linkmode" = "prog"; then
6455 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6456 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6458 compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6461 dependency_libs="$newdependency_libs"
6462 if test "$pass" = dlpreopen; then
6463 # Link the dlpreopened libraries before other libraries
6464 for deplib in $save_deplibs; do
6465 deplibs="$deplib $deplibs"
6468 if test "$pass" != dlopen; then
6469 if test "$pass" != conv; then
6470 # Make sure lib_search_path contains only unique directories.
6472 for dir in $newlib_search_path; do
6473 case "$lib_search_path " in
6475 *) lib_search_path="$lib_search_path $dir" ;;
6481 if test "$linkmode,$pass" != "prog,link"; then
6484 vars="compile_deplibs finalize_deplibs"
6486 for var in $vars dependency_libs; do
6487 # Add libraries to $var in reverse order
6488 eval tmp_libs=\"\$$var\"
6490 for deplib in $tmp_libs; do
6491 # FIXME: Pedantically, this is the right thing to do, so
6492 # that some nasty dependency loop isn't accidentally
6494 #new_libs="$deplib $new_libs"
6495 # Pragmatically, this seems to cause very few problems in
6498 -L*) new_libs="$deplib $new_libs" ;;
6501 # And here is the reason: when a library appears more
6502 # than once as an explicit dependence of a library, or
6503 # is implicitly linked in more than once by the
6504 # compiler, it is considered special, and multiple
6505 # occurrences thereof are not removed. Compare this
6506 # with having the same library being listed as a
6507 # dependency of multiple other libraries: in this case,
6508 # we know (pedantically, we assume) the library does not
6509 # need to be listed more than once, so we keep only the
6510 # last copy. This is not always right, but it is rare
6511 # enough that we require users that really mean to play
6512 # such unportable linking tricks to link the library
6513 # using -Wl,-lname, so that libtool does not consider it
6514 # for duplicate removal.
6515 case " $specialdeplibs " in
6516 *" $deplib "*) new_libs="$deplib $new_libs" ;;
6518 case " $new_libs " in
6520 *) new_libs="$deplib $new_libs" ;;
6528 for deplib in $new_libs; do
6531 case " $tmp_libs " in
6533 *) tmp_libs="$tmp_libs $deplib" ;;
6536 *) tmp_libs="$tmp_libs $deplib" ;;
6539 eval $var=\"$tmp_libs\"
6542 # Last step: remove runtime libs from dependency_libs
6543 # (they stay in deplibs)
6545 for i in $dependency_libs ; do
6546 case " $predeps $postdeps $compiler_lib_search_path " in
6551 if test -n "$i" ; then
6552 tmp_libs="$tmp_libs $i"
6555 dependency_libs=$tmp_libs
6557 if test "$linkmode" = prog; then
6558 dlfiles="$newdlfiles"
6560 if test "$linkmode" = prog || test "$linkmode" = lib; then
6561 dlprefiles="$newdlprefiles"
6566 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6567 func_warning "\`-dlopen' is ignored for archives"
6572 func_warning "\`-l' and \`-L' are ignored for archives" ;;
6575 test -n "$rpath" && \
6576 func_warning "\`-rpath' is ignored for archives"
6578 test -n "$xrpath" && \
6579 func_warning "\`-R' is ignored for archives"
6581 test -n "$vinfo" && \
6582 func_warning "\`-version-info/-version-number' is ignored for archives"
6584 test -n "$release" && \
6585 func_warning "\`-release' is ignored for archives"
6587 test -n "$export_symbols$export_symbols_regex" && \
6588 func_warning "\`-export-symbols' is ignored for archives"
6590 # Now set the variables for building old libraries.
6591 build_libtool_libs=no
6593 objs="$objs$old_deplibs"
6597 # Make sure we only generate libraries of the form `libNAME.la'.
6600 func_stripname 'lib' '.la' "$outputname"
6601 name=$func_stripname_result
6602 eval shared_ext=\"$shrext_cmds\"
6603 eval libname=\"$libname_spec\"
6606 test "$module" = no && \
6607 func_fatal_help "libtool library \`$output' must begin with \`lib'"
6609 if test "$need_lib_prefix" != no; then
6610 # Add the "lib" prefix for modules if required
6611 func_stripname '' '.la' "$outputname"
6612 name=$func_stripname_result
6613 eval shared_ext=\"$shrext_cmds\"
6614 eval libname=\"$libname_spec\"
6616 func_stripname '' '.la' "$outputname"
6617 libname=$func_stripname_result
6622 if test -n "$objs"; then
6623 if test "$deplibs_check_method" != pass_all; then
6624 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6627 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6628 $ECHO "*** objects $objs is not portable!"
6629 libobjs="$libobjs $objs"
6633 test "$dlself" != no && \
6634 func_warning "\`-dlopen self' is ignored for libtool libraries"
6638 test "$#" -gt 1 && \
6639 func_warning "ignoring multiple \`-rpath's for a libtool library"
6644 if test -z "$rpath"; then
6645 if test "$build_libtool_libs" = yes; then
6646 # Building a libtool convenience library.
6647 # Some compilers have problems with a `.al' extension so
6648 # convenience libraries should have the same extension an
6649 # archive normally would.
6650 oldlibs="$output_objdir/$libname.$libext $oldlibs"
6651 build_libtool_libs=convenience
6655 test -n "$vinfo" && \
6656 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6658 test -n "$release" && \
6659 func_warning "\`-release' is ignored for convenience libraries"
6662 # Parse the version information argument.
6663 save_ifs="$IFS"; IFS=':'
6664 set dummy $vinfo 0 0 0
6669 func_fatal_help "too many parameters to \`-version-info'"
6671 # convert absolute version numbers to libtool ages
6672 # this retains compatibility with .la files and attempts
6673 # to make the code below a bit more comprehensible
6675 case $vinfo_number in
6679 number_revision="$3"
6681 # There are really only two kinds -- those that
6682 # use the current revision as the major version
6683 # and those that subtract age and use age as
6684 # a minor version. But, then there is irix
6685 # which has an extra 1 added just for fun
6687 case $version_type in
6688 darwin|linux|osf|windows|none)
6689 func_arith $number_major + $number_minor
6690 current=$func_arith_result
6692 revision="$number_revision"
6694 freebsd-aout|freebsd-elf|sunos)
6695 current="$number_major"
6696 revision="$number_minor"
6700 func_arith $number_major + $number_minor
6701 current=$func_arith_result
6703 revision="$number_minor"
6704 lt_irix_increment=no
6707 func_fatal_configuration "$modename: unknown library version type \`$version_type'"
6718 # Check that each of the things are valid numbers.
6720 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]) ;;
6722 func_error "CURRENT \`$current' must be a nonnegative integer"
6723 func_fatal_error "\`$vinfo' is not valid version information"
6728 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]) ;;
6730 func_error "REVISION \`$revision' must be a nonnegative integer"
6731 func_fatal_error "\`$vinfo' is not valid version information"
6736 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]) ;;
6738 func_error "AGE \`$age' must be a nonnegative integer"
6739 func_fatal_error "\`$vinfo' is not valid version information"
6743 if test "$age" -gt "$current"; then
6744 func_error "AGE \`$age' is greater than the current interface number \`$current'"
6745 func_fatal_error "\`$vinfo' is not valid version information"
6748 # Calculate the version variables.
6752 case $version_type in
6756 # Like Linux, but with the current version available in
6757 # verstring for coding it into the library header
6758 func_arith $current - $age
6759 major=.$func_arith_result
6760 versuffix="$major.$age.$revision"
6761 # Darwin ld doesn't like 0 for these options...
6762 func_arith $current + 1
6763 minor_current=$func_arith_result
6764 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6765 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6770 versuffix=".$current.$revision";
6775 versuffix=".$current"
6779 if test "X$lt_irix_increment" = "Xno"; then
6780 func_arith $current - $age
6782 func_arith $current - $age + 1
6784 major=$func_arith_result
6786 case $version_type in
6787 nonstopux) verstring_prefix=nonstopux ;;
6788 *) verstring_prefix=sgi ;;
6790 verstring="$verstring_prefix$major.$revision"
6792 # Add in all the interfaces that we are compatible with.
6794 while test "$loop" -ne 0; do
6795 func_arith $revision - $loop
6796 iface=$func_arith_result
6797 func_arith $loop - 1
6798 loop=$func_arith_result
6799 verstring="$verstring_prefix$major.$iface:$verstring"
6802 # Before this point, $major must not contain `.'.
6804 versuffix="$major.$revision"
6808 func_arith $current - $age
6809 major=.$func_arith_result
6810 versuffix="$major.$age.$revision"
6814 func_arith $current - $age
6815 major=.$func_arith_result
6816 versuffix=".$current.$age.$revision"
6817 verstring="$current.$age.$revision"
6819 # Add in all the interfaces that we are compatible with.
6821 while test "$loop" -ne 0; do
6822 func_arith $current - $loop
6823 iface=$func_arith_result
6824 func_arith $loop - 1
6825 loop=$func_arith_result
6826 verstring="$verstring:${iface}.0"
6829 # Make executables depend on our current version.
6830 verstring="$verstring:${current}.0"
6835 versuffix=".$current"
6840 versuffix=".$current.$revision"
6844 # Use '-' rather than '.', since we only want one
6845 # extension on DOS 8.3 filesystems.
6846 func_arith $current - $age
6847 major=$func_arith_result
6852 func_fatal_configuration "unknown library version type \`$version_type'"
6856 # Clear the version info if we defaulted, and they specified a release.
6857 if test -z "$vinfo" && test -n "$release"; then
6859 case $version_type in
6861 # we can't check for "0.0" in archive_cmds due to quoting
6862 # problems, so we reset it completely
6869 if test "$need_version" = no; then
6876 # Remove version info from name if versioning should be avoided
6877 if test "$avoid_version" = yes && test "$need_version" = no; then
6883 # Check to see if the archive will have undefined symbols.
6884 if test "$allow_undefined" = yes; then
6885 if test "$allow_undefined_flag" = unsupported; then
6886 func_warning "undefined symbols not allowed in $host shared libraries"
6887 build_libtool_libs=no
6891 # Don't allow undefined symbols.
6892 allow_undefined_flag="$no_undefined_flag"
6897 func_generate_dlsyms "$libname" "$libname" "yes"
6898 libobjs="$libobjs $symfileobj"
6899 test "X$libobjs" = "X " && libobjs=
6901 if test "$mode" != relink; then
6902 # Remove our outputs, but don't remove object files since they
6903 # may have been created when compiling PIC objects.
6905 tempremovelist=`$ECHO "$output_objdir/*"`
6906 for p in $tempremovelist; do
6910 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6911 if test "X$precious_files_regex" != "X"; then
6912 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6917 removelist="$removelist $p"
6922 test -n "$removelist" && \
6923 func_show_eval "${RM}r \$removelist"
6926 # Now set the variables for building old libraries.
6927 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6928 oldlibs="$oldlibs $output_objdir/$libname.$libext"
6930 # Transform .lo files to .o files.
6931 oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6934 # Eliminate all temporary directories.
6935 #for path in $notinst_path; do
6936 # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6937 # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6938 # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6941 if test -n "$xrpath"; then
6942 # If the user specified any rpath flags, then add them.
6944 for libdir in $xrpath; do
6945 temp_xrpath="$temp_xrpath -R$libdir"
6946 case "$finalize_rpath " in
6948 *) finalize_rpath="$finalize_rpath $libdir" ;;
6951 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6952 dependency_libs="$temp_xrpath $dependency_libs"
6956 # Make sure dlfiles contains only unique files that won't be dlpreopened
6957 old_dlfiles="$dlfiles"
6959 for lib in $old_dlfiles; do
6960 case " $dlprefiles $dlfiles " in
6962 *) dlfiles="$dlfiles $lib" ;;
6966 # Make sure dlprefiles contains only unique files
6967 old_dlprefiles="$dlprefiles"
6969 for lib in $old_dlprefiles; do
6970 case "$dlprefiles " in
6972 *) dlprefiles="$dlprefiles $lib" ;;
6976 if test "$build_libtool_libs" = yes; then
6977 if test -n "$rpath"; then
6979 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6980 # these systems don't actually have a c library (as such)!
6982 *-*-rhapsody* | *-*-darwin1.[012])
6983 # Rhapsody C library is in the System framework
6984 deplibs="$deplibs System.ltframework"
6987 # Don't link with libc until the a.out ld.so is fixed.
6989 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6990 # Do not include libc due to us having libc/libc_r.
6992 *-*-sco3.2v5* | *-*-sco5v6*)
6993 # Causes problems with __ctype
6995 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6996 # Compiler inserts libc in the correct place for threads to work
6999 # Add libc to deplibs on all other systems if necessary.
7000 if test "$build_libtool_need_lc" = "yes"; then
7001 deplibs="$deplibs -lc"
7007 # Transform deplibs into only deplibs that can be linked in shared.
7009 libname_save=$libname
7010 release_save=$release
7011 versuffix_save=$versuffix
7013 # I'm not sure if I'm treating the release correctly. I think
7014 # release should show up in the -l (ie -lgmp5) so we don't want to
7015 # add it in twice. Is that correct?
7021 case $deplibs_check_method in
7023 # Don't check for shared/static. Everything works.
7024 # This might be a little naive. We might want to check
7025 # whether the library exists or not. But this is on
7026 # osf3 & osf4 and I'm not really sure... Just
7027 # implementing what was already the behavior.
7031 # This code stresses the "libraries are programs" paradigm to its
7032 # limits. Maybe even breaks it. We compile a program, linking it
7033 # against the deplibs as a proxy for the library. Then we can check
7034 # whether they linked in statically or dynamically with ldd.
7035 $opt_dry_run || $RM conftest.c
7036 cat > conftest.c <<EOF
7037 int main() { return 0; }
7039 $opt_dry_run || $RM conftest
7040 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7041 ldd_output=`ldd conftest`
7042 for i in $deplibs; do
7045 func_stripname -l '' "$i"
7046 name=$func_stripname_result
7047 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7048 case " $predeps $postdeps " in
7050 newdeplibs="$newdeplibs $i"
7055 if test -n "$i" ; then
7056 libname=`eval "\\$ECHO \"$libname_spec\""`
7057 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7058 set dummy $deplib_matches; shift
7060 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7061 newdeplibs="$newdeplibs $i"
7065 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7066 $ECHO "*** I have the capability to make that library automatically link in when"
7067 $ECHO "*** you link to this library. But I can only do this if you have a"
7068 $ECHO "*** shared version of the library, which I believe you do not have"
7069 $ECHO "*** because a test_compile did reveal that the linker did not use it for"
7070 $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7075 newdeplibs="$newdeplibs $i"
7080 # Error occurred in the first compile. Let's try to salvage
7081 # the situation: Compile a separate program for each library.
7082 for i in $deplibs; do
7085 func_stripname -l '' "$i"
7086 name=$func_stripname_result
7087 $opt_dry_run || $RM conftest
7088 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7089 ldd_output=`ldd conftest`
7090 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7091 case " $predeps $postdeps " in
7093 newdeplibs="$newdeplibs $i"
7098 if test -n "$i" ; then
7099 libname=`eval "\\$ECHO \"$libname_spec\""`
7100 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7101 set dummy $deplib_matches; shift
7103 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7104 newdeplibs="$newdeplibs $i"
7108 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7109 $ECHO "*** I have the capability to make that library automatically link in when"
7110 $ECHO "*** you link to this library. But I can only do this if you have a"
7111 $ECHO "*** shared version of the library, which you do not appear to have"
7112 $ECHO "*** because a test_compile did reveal that the linker did not use this one"
7113 $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7119 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7120 $ECHO "*** make it link in! You will probably need to install it or some"
7121 $ECHO "*** library that it depends on before this library will be fully"
7122 $ECHO "*** functional. Installing it before continuing would be even better."
7126 newdeplibs="$newdeplibs $i"
7133 set dummy $deplibs_check_method; shift
7134 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7135 for a_deplib in $deplibs; do
7138 func_stripname -l '' "$a_deplib"
7139 name=$func_stripname_result
7140 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7141 case " $predeps $postdeps " in
7143 newdeplibs="$newdeplibs $a_deplib"
7148 if test -n "$a_deplib" ; then
7149 libname=`eval "\\$ECHO \"$libname_spec\""`
7150 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7151 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7152 for potent_lib in $potential_libs; do
7153 # Follow soft links.
7154 if ls -lLd "$potent_lib" 2>/dev/null |
7155 $GREP " -> " >/dev/null; then
7158 # The statement above tries to avoid entering an
7159 # endless loop below, in case of cyclic links.
7160 # We might still enter an endless loop, since a link
7161 # loop can be closed while we follow links,
7163 potlib="$potent_lib"
7164 while test -h "$potlib" 2>/dev/null; do
7165 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7167 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7168 *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7171 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7173 $EGREP "$file_magic_regex" > /dev/null; then
7174 newdeplibs="$newdeplibs $a_deplib"
7181 if test -n "$a_deplib" ; then
7184 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7185 $ECHO "*** I have the capability to make that library automatically link in when"
7186 $ECHO "*** you link to this library. But I can only do this if you have a"
7187 $ECHO "*** shared version of the library, which you do not appear to have"
7188 $ECHO "*** because I did check the linker path looking for a file starting"
7189 if test -z "$potlib" ; then
7190 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7192 $ECHO "*** with $libname and none of the candidates passed a file format test"
7193 $ECHO "*** using a file magic. Last file checked: $potlib"
7198 # Add a -L argument.
7199 newdeplibs="$newdeplibs $a_deplib"
7202 done # Gone through all deplibs.
7205 set dummy $deplibs_check_method; shift
7206 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7207 for a_deplib in $deplibs; do
7210 func_stripname -l '' "$a_deplib"
7211 name=$func_stripname_result
7212 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7213 case " $predeps $postdeps " in
7215 newdeplibs="$newdeplibs $a_deplib"
7220 if test -n "$a_deplib" ; then
7221 libname=`eval "\\$ECHO \"$libname_spec\""`
7222 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7223 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7224 for potent_lib in $potential_libs; do
7225 potlib="$potent_lib" # see symlink-check above in file_magic test
7226 if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7227 $EGREP "$match_pattern_regex" > /dev/null; then
7228 newdeplibs="$newdeplibs $a_deplib"
7235 if test -n "$a_deplib" ; then
7238 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7239 $ECHO "*** I have the capability to make that library automatically link in when"
7240 $ECHO "*** you link to this library. But I can only do this if you have a"
7241 $ECHO "*** shared version of the library, which you do not appear to have"
7242 $ECHO "*** because I did check the linker path looking for a file starting"
7243 if test -z "$potlib" ; then
7244 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7246 $ECHO "*** with $libname and none of the candidates passed a file format test"
7247 $ECHO "*** using a regex pattern. Last file checked: $potlib"
7252 # Add a -L argument.
7253 newdeplibs="$newdeplibs $a_deplib"
7256 done # Gone through all deplibs.
7260 tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
7261 -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7262 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7263 for i in $predeps $postdeps ; do
7264 # can't use Xsed below, because $i might contain '/'
7265 tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7268 if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[ ]//g' |
7269 $GREP . >/dev/null; then
7271 if test "X$deplibs_check_method" = "Xnone"; then
7272 $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7274 $ECHO "*** Warning: inter-library dependencies are not known to be supported."
7276 $ECHO "*** All declared inter-library dependencies are being dropped."
7281 versuffix=$versuffix_save
7283 release=$release_save
7284 libname=$libname_save
7288 *-*-rhapsody* | *-*-darwin1.[012])
7289 # On Rhapsody replace the C library with the System framework
7290 newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7294 if test "$droppeddeps" = yes; then
7295 if test "$module" = yes; then
7297 $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7298 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7299 $ECHO "*** a static module, that should work as long as the dlopening"
7300 $ECHO "*** application is linked with the -dlopen flag."
7301 if test -z "$global_symbol_pipe"; then
7303 $ECHO "*** However, this would only work if libtool was able to extract symbol"
7304 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
7305 $ECHO "*** not find such a program. So, this module is probably useless."
7306 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7308 if test "$build_old_libs" = no; then
7309 oldlibs="$output_objdir/$libname.$libext"
7310 build_libtool_libs=module
7313 build_libtool_libs=no
7316 $ECHO "*** The inter-library dependencies that have been dropped here will be"
7317 $ECHO "*** automatically added whenever a program is linked with this library"
7318 $ECHO "*** or is declared to -dlopen it."
7320 if test "$allow_undefined" = no; then
7322 $ECHO "*** Since this library must not contain undefined symbols,"
7323 $ECHO "*** because either the platform does not support them or"
7324 $ECHO "*** it was explicitly requested with -no-undefined,"
7325 $ECHO "*** libtool will only create a static version of it."
7326 if test "$build_old_libs" = no; then
7327 oldlibs="$output_objdir/$libname.$libext"
7328 build_libtool_libs=module
7331 build_libtool_libs=no
7336 # Done checking deplibs!
7339 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7342 newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7343 new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7344 deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7348 # move library search paths that coincide with paths to not yet
7349 # installed libraries to the beginning of the library search list
7351 for path in $notinst_path; do
7352 case " $new_libs " in
7353 *" -L$path/$objdir "*) ;;
7355 case " $deplibs " in
7356 *" -L$path/$objdir "*)
7357 new_libs="$new_libs -L$path/$objdir" ;;
7362 for deplib in $deplibs; do
7365 case " $new_libs " in
7367 *) new_libs="$new_libs $deplib" ;;
7370 *) new_libs="$new_libs $deplib" ;;
7375 # All the library-specific variables (install_libdir is set above).
7380 # Test again, we may have decided not to build it any more
7381 if test "$build_libtool_libs" = yes; then
7382 if test "$hardcode_into_libs" = yes; then
7383 # Hardcode the library paths
7386 rpath="$finalize_rpath"
7387 test "$mode" != relink && rpath="$compile_rpath$rpath"
7388 for libdir in $rpath; do
7389 if test -n "$hardcode_libdir_flag_spec"; then
7390 if test -n "$hardcode_libdir_separator"; then
7391 if test -z "$hardcode_libdirs"; then
7392 hardcode_libdirs="$libdir"
7394 # Just accumulate the unique libdirs.
7395 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7396 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7399 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7404 eval flag=\"$hardcode_libdir_flag_spec\"
7405 dep_rpath="$dep_rpath $flag"
7407 elif test -n "$runpath_var"; then
7408 case "$perm_rpath " in
7410 *) perm_rpath="$perm_rpath $libdir" ;;
7414 # Substitute the hardcoded libdirs into the rpath.
7415 if test -n "$hardcode_libdir_separator" &&
7416 test -n "$hardcode_libdirs"; then
7417 libdir="$hardcode_libdirs"
7418 if test -n "$hardcode_libdir_flag_spec_ld"; then
7419 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
7421 eval dep_rpath=\"$hardcode_libdir_flag_spec\"
7424 if test -n "$runpath_var" && test -n "$perm_rpath"; then
7425 # We should set the runpath_var.
7427 for dir in $perm_rpath; do
7430 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
7432 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7435 shlibpath="$finalize_shlibpath"
7436 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7437 if test -n "$shlibpath"; then
7438 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
7441 # Get the real and link names of the library.
7442 eval shared_ext=\"$shrext_cmds\"
7443 eval library_names=\"$library_names_spec\"
7444 set dummy $library_names
7449 if test -n "$soname_spec"; then
7450 eval soname=\"$soname_spec\"
7454 if test -z "$dlname"; then
7458 lib="$output_objdir/$realname"
7462 linknames="$linknames $link"
7465 # Use standard objects if they are pic
7466 test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7467 test "X$libobjs" = "X " && libobjs=
7470 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7471 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7472 export_symbols="$output_objdir/$libname.uexp"
7473 delfiles="$delfiles $export_symbols"
7476 orig_export_symbols=
7478 cygwin* | mingw* | cegcc*)
7479 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7480 # exporting using user supplied symfile
7481 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7482 # and it's NOT already a .def file. Must figure out
7483 # which of the given symbols are data symbols and tag
7484 # them as such. So, trigger use of export_symbols_cmds.
7485 # export_symbols gets reassigned inside the "prepare
7486 # the list of exported symbols" if statement, so the
7487 # include_expsyms logic still works.
7488 orig_export_symbols="$export_symbols"
7490 always_export_symbols=yes
7496 # Prepare the list of exported symbols
7497 if test -z "$export_symbols"; then
7498 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7499 func_verbose "generating symbol list for \`$libname.la'"
7500 export_symbols="$output_objdir/$libname.exp"
7501 $opt_dry_run || $RM $export_symbols
7502 cmds=$export_symbols_cmds
7503 save_ifs="$IFS"; IFS='~'
7504 for cmd in $cmds; do
7508 len=$func_len_result
7509 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7510 func_show_eval "$cmd" 'exit $?'
7511 skipped_export=false
7513 # The command line is too long to execute in one step.
7514 func_verbose "using reloadable object file for export list..."
7516 # Break out early, otherwise skipped_export may be
7517 # set to false by a later but shorter cmd.
7522 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7523 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7524 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7529 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7530 tmp_export_symbols="$export_symbols"
7531 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7532 $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7535 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7536 # The given exports_symbols file has to be filtered, so filter it.
7537 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7538 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7539 # 's' commands which not all seds can handle. GNU sed should be fine
7540 # though. Also, the filter scales superlinearly with the number of
7541 # global variables. join(1) would be nice here, but unfortunately
7542 # isn't a blessed tool.
7543 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7544 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7545 export_symbols=$output_objdir/$libname.def
7546 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7550 for test_deplib in $deplibs; do
7551 case " $convenience " in
7552 *" $test_deplib "*) ;;
7554 tmp_deplibs="$tmp_deplibs $test_deplib"
7558 deplibs="$tmp_deplibs"
7560 if test -n "$convenience"; then
7561 if test -n "$whole_archive_flag_spec" &&
7562 test "$compiler_needs_object" = yes &&
7563 test -z "$libobjs"; then
7564 # extract the archives, so we have objects to list.
7565 # TODO: could optimize this to just extract one archive.
7566 whole_archive_flag_spec=
7568 if test -n "$whole_archive_flag_spec"; then
7569 save_libobjs=$libobjs
7570 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7571 test "X$libobjs" = "X " && libobjs=
7573 gentop="$output_objdir/${outputname}x"
7574 generated="$generated $gentop"
7576 func_extract_archives $gentop $convenience
7577 libobjs="$libobjs $func_extract_archives_result"
7578 test "X$libobjs" = "X " && libobjs=
7582 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7583 eval flag=\"$thread_safe_flag_spec\"
7584 linker_flags="$linker_flags $flag"
7587 # Make a backup of the uninstalled library when relinking
7588 if test "$mode" = relink; then
7589 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7592 # Do each of the archive commands.
7593 if test "$module" = yes && test -n "$module_cmds" ; then
7594 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7595 eval test_cmds=\"$module_expsym_cmds\"
7596 cmds=$module_expsym_cmds
7598 eval test_cmds=\"$module_cmds\"
7602 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7603 eval test_cmds=\"$archive_expsym_cmds\"
7604 cmds=$archive_expsym_cmds
7606 eval test_cmds=\"$archive_cmds\"
7611 if test "X$skipped_export" != "X:" &&
7612 func_len " $test_cmds" &&
7613 len=$func_len_result &&
7614 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7617 # The command line is too long to link in one step, link piecewise
7618 # or, if using GNU ld and skipped_export is not :, use a linker
7621 # Save the value of $output and $libobjs because we want to
7622 # use them later. If we have whole_archive_flag_spec, we
7623 # want to use save_libobjs as it was before
7624 # whole_archive_flag_spec was expanded, because we can't
7625 # assume the linker understands whole_archive_flag_spec.
7626 # This may have to be revisited, in case too many
7627 # convenience libraries get linked in and end up exceeding
7629 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7630 save_libobjs=$libobjs
7633 output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7635 # Clear the reloadable object creation command queue and
7636 # initialize k to one.
7643 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7644 output=${output_objdir}/${output_la}.lnkscript
7645 func_verbose "creating GNU ld script: $output"
7646 $ECHO 'INPUT (' > $output
7647 for obj in $save_libobjs
7649 $ECHO "$obj" >> $output
7651 $ECHO ')' >> $output
7652 delfiles="$delfiles $output"
7653 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7654 output=${output_objdir}/${output_la}.lnk
7655 func_verbose "creating linker input file list: $output"
7660 if test "$compiler_needs_object" = yes; then
7666 $ECHO "$obj" >> $output
7668 delfiles="$delfiles $output"
7669 output=$firstobj\"$file_list_spec$output\"
7671 if test -n "$save_libobjs"; then
7672 func_verbose "creating reloadable object files..."
7673 output=$output_objdir/$output_la-${k}.$objext
7674 eval test_cmds=\"$reload_cmds\"
7675 func_len " $test_cmds"
7676 len0=$func_len_result
7679 # Loop over the list of objects to be linked.
7680 for obj in $save_libobjs
7683 func_arith $len + $func_len_result
7684 len=$func_arith_result
7685 if test "X$objlist" = X ||
7686 test "$len" -lt "$max_cmd_len"; then
7687 func_append objlist " $obj"
7689 # The command $test_cmds is almost too long, add a
7690 # command to the queue.
7691 if test "$k" -eq 1 ; then
7692 # The first file doesn't have a previous command to add.
7693 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7695 # All subsequent reloadable object files will link in
7696 # the last one created.
7697 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7699 last_robj=$output_objdir/$output_la-${k}.$objext
7701 k=$func_arith_result
7702 output=$output_objdir/$output_la-${k}.$objext
7704 func_len " $last_robj"
7705 func_arith $len0 + $func_len_result
7706 len=$func_arith_result
7709 # Handle the remaining objects by creating one last
7710 # reloadable object file. All subsequent reloadable object
7711 # files will link in the last one created.
7712 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7713 eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7714 if test -n "$last_robj"; then
7715 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7717 delfiles="$delfiles $output"
7723 if ${skipped_export-false}; then
7724 func_verbose "generating symbol list for \`$libname.la'"
7725 export_symbols="$output_objdir/$libname.exp"
7726 $opt_dry_run || $RM $export_symbols
7728 # Append the command to create the export file.
7729 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7730 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7731 if test -n "$last_robj"; then
7732 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7736 test -n "$save_libobjs" &&
7737 func_verbose "creating a temporary reloadable object file: $output"
7739 # Loop through the commands generated above and execute them.
7740 save_ifs="$IFS"; IFS='~'
7741 for cmd in $concat_cmds; do
7744 func_quote_for_expand "$cmd"
7745 eval "func_echo $func_quote_for_expand_result"
7747 $opt_dry_run || eval "$cmd" || {
7750 # Restore the uninstalled library and exit
7751 if test "$mode" = relink; then
7752 ( cd "$output_objdir" && \
7753 $RM "${realname}T" && \
7754 $MV "${realname}U" "$realname" )
7762 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7763 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7764 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7768 if ${skipped_export-false}; then
7769 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7770 tmp_export_symbols="$export_symbols"
7771 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7772 $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7775 if test -n "$orig_export_symbols"; then
7776 # The given exports_symbols file has to be filtered, so filter it.
7777 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7778 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7779 # 's' commands which not all seds can handle. GNU sed should be fine
7780 # though. Also, the filter scales superlinearly with the number of
7781 # global variables. join(1) would be nice here, but unfortunately
7782 # isn't a blessed tool.
7783 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7784 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7785 export_symbols=$output_objdir/$libname.def
7786 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7791 # Restore the value of output.
7794 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7795 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7796 test "X$libobjs" = "X " && libobjs=
7798 # Expand the library linking commands again to reset the
7799 # value of $libobjs for piecewise linking.
7801 # Do each of the archive commands.
7802 if test "$module" = yes && test -n "$module_cmds" ; then
7803 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7804 cmds=$module_expsym_cmds
7809 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7810 cmds=$archive_expsym_cmds
7817 if test -n "$delfiles"; then
7818 # Append the command to remove temporary files to $cmds.
7819 eval cmds=\"\$cmds~\$RM $delfiles\"
7822 # Add any objects from preloaded convenience libraries
7823 if test -n "$dlprefiles"; then
7824 gentop="$output_objdir/${outputname}x"
7825 generated="$generated $gentop"
7827 func_extract_archives $gentop $dlprefiles
7828 libobjs="$libobjs $func_extract_archives_result"
7829 test "X$libobjs" = "X " && libobjs=
7832 save_ifs="$IFS"; IFS='~'
7833 for cmd in $cmds; do
7837 func_quote_for_expand "$cmd"
7838 eval "func_echo $func_quote_for_expand_result"
7840 $opt_dry_run || eval "$cmd" || {
7843 # Restore the uninstalled library and exit
7844 if test "$mode" = relink; then
7845 ( cd "$output_objdir" && \
7846 $RM "${realname}T" && \
7847 $MV "${realname}U" "$realname" )
7855 # Restore the uninstalled library and exit
7856 if test "$mode" = relink; then
7857 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7859 if test -n "$convenience"; then
7860 if test -z "$whole_archive_flag_spec"; then
7861 func_show_eval '${RM}r "$gentop"'
7868 # Create links to the real library.
7869 for linkname in $linknames; do
7870 if test "$realname" != "$linkname"; then
7871 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7875 # If -module or -export-dynamic was specified, set the dlname.
7876 if test "$module" = yes || test "$export_dynamic" = yes; then
7877 # On all known operating systems, these are identical.
7884 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7885 func_warning "\`-dlopen' is ignored for objects"
7890 func_warning "\`-l' and \`-L' are ignored for objects" ;;
7893 test -n "$rpath" && \
7894 func_warning "\`-rpath' is ignored for objects"
7896 test -n "$xrpath" && \
7897 func_warning "\`-R' is ignored for objects"
7899 test -n "$vinfo" && \
7900 func_warning "\`-version-info' is ignored for objects"
7902 test -n "$release" && \
7903 func_warning "\`-release' is ignored for objects"
7907 test -n "$objs$old_deplibs" && \
7908 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7912 obj=$func_lo2o_result
7920 # Delete the old objects.
7921 $opt_dry_run || $RM $obj $libobj
7923 # Objects from convenience libraries. This assumes
7924 # single-version convenience libraries. Whenever we create
7925 # different ones for PIC/non-PIC, this we'll have to duplicate
7929 # reload_cmds runs $LD directly, so let us get rid of
7930 # -Wl from whole_archive_flag_spec and hope we can get by with
7931 # turning comma into space..
7934 if test -n "$convenience"; then
7935 if test -n "$whole_archive_flag_spec"; then
7936 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7937 reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7939 gentop="$output_objdir/${obj}x"
7940 generated="$generated $gentop"
7942 func_extract_archives $gentop $convenience
7943 reload_conv_objs="$reload_objs $func_extract_archives_result"
7947 # Create the old-style object.
7948 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
7951 func_execute_cmds "$reload_cmds" 'exit $?'
7953 # Exit if we aren't doing a library object file.
7954 if test -z "$libobj"; then
7955 if test -n "$gentop"; then
7956 func_show_eval '${RM}r "$gentop"'
7962 if test "$build_libtool_libs" != yes; then
7963 if test -n "$gentop"; then
7964 func_show_eval '${RM}r "$gentop"'
7967 # Create an invalid libtool object if no PIC, so that we don't
7968 # accidentally link it into a program.
7969 # $show "echo timestamp > $libobj"
7970 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7974 if test -n "$pic_flag" || test "$pic_mode" != default; then
7975 # Only do commands if we really have different PIC objects.
7976 reload_objs="$libobjs $reload_conv_objs"
7978 func_execute_cmds "$reload_cmds" 'exit $?'
7981 if test -n "$gentop"; then
7982 func_show_eval '${RM}r "$gentop"'
7990 *cygwin*) func_stripname '' '.exe' "$output"
7991 output=$func_stripname_result.exe;;
7993 test -n "$vinfo" && \
7994 func_warning "\`-version-info' is ignored for programs"
7996 test -n "$release" && \
7997 func_warning "\`-release' is ignored for programs"
7999 test "$preload" = yes \
8000 && test "$dlopen_support" = unknown \
8001 && test "$dlopen_self" = unknown \
8002 && test "$dlopen_self_static" = unknown && \
8003 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8006 *-*-rhapsody* | *-*-darwin1.[012])
8007 # On Rhapsody replace the C library is the System framework
8008 compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8009 finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8015 # Don't allow lazy linking, it breaks C++ global constructors
8016 # But is supposedly fixed on 10.4 or later (yay!).
8017 if test "$tagname" = CXX ; then
8018 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8020 compile_command="$compile_command ${wl}-bind_at_load"
8021 finalize_command="$finalize_command ${wl}-bind_at_load"
8025 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8026 compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8027 finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8032 # move library search paths that coincide with paths to not yet
8033 # installed libraries to the beginning of the library search list
8035 for path in $notinst_path; do
8036 case " $new_libs " in
8037 *" -L$path/$objdir "*) ;;
8039 case " $compile_deplibs " in
8040 *" -L$path/$objdir "*)
8041 new_libs="$new_libs -L$path/$objdir" ;;
8046 for deplib in $compile_deplibs; do
8049 case " $new_libs " in
8051 *) new_libs="$new_libs $deplib" ;;
8054 *) new_libs="$new_libs $deplib" ;;
8057 compile_deplibs="$new_libs"
8060 compile_command="$compile_command $compile_deplibs"
8061 finalize_command="$finalize_command $finalize_deplibs"
8063 if test -n "$rpath$xrpath"; then
8064 # If the user specified any rpath flags, then add them.
8065 for libdir in $rpath $xrpath; do
8066 # This is the magic to use -rpath.
8067 case "$finalize_rpath " in
8069 *) finalize_rpath="$finalize_rpath $libdir" ;;
8074 # Now hardcode the library paths
8077 for libdir in $compile_rpath $finalize_rpath; do
8078 if test -n "$hardcode_libdir_flag_spec"; then
8079 if test -n "$hardcode_libdir_separator"; then
8080 if test -z "$hardcode_libdirs"; then
8081 hardcode_libdirs="$libdir"
8083 # Just accumulate the unique libdirs.
8084 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8085 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8088 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8093 eval flag=\"$hardcode_libdir_flag_spec\"
8094 rpath="$rpath $flag"
8096 elif test -n "$runpath_var"; then
8097 case "$perm_rpath " in
8099 *) perm_rpath="$perm_rpath $libdir" ;;
8103 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8104 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8105 case :$dllsearchpath: in
8107 ::) dllsearchpath=$libdir;;
8108 *) dllsearchpath="$dllsearchpath:$libdir";;
8110 case :$dllsearchpath: in
8111 *":$testbindir:"*) ;;
8112 ::) dllsearchpath=$testbindir;;
8113 *) dllsearchpath="$dllsearchpath:$testbindir";;
8118 # Substitute the hardcoded libdirs into the rpath.
8119 if test -n "$hardcode_libdir_separator" &&
8120 test -n "$hardcode_libdirs"; then
8121 libdir="$hardcode_libdirs"
8122 eval rpath=\" $hardcode_libdir_flag_spec\"
8124 compile_rpath="$rpath"
8128 for libdir in $finalize_rpath; do
8129 if test -n "$hardcode_libdir_flag_spec"; then
8130 if test -n "$hardcode_libdir_separator"; then
8131 if test -z "$hardcode_libdirs"; then
8132 hardcode_libdirs="$libdir"
8134 # Just accumulate the unique libdirs.
8135 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8136 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8139 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8144 eval flag=\"$hardcode_libdir_flag_spec\"
8145 rpath="$rpath $flag"
8147 elif test -n "$runpath_var"; then
8148 case "$finalize_perm_rpath " in
8150 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8154 # Substitute the hardcoded libdirs into the rpath.
8155 if test -n "$hardcode_libdir_separator" &&
8156 test -n "$hardcode_libdirs"; then
8157 libdir="$hardcode_libdirs"
8158 eval rpath=\" $hardcode_libdir_flag_spec\"
8160 finalize_rpath="$rpath"
8162 if test -n "$libobjs" && test "$build_old_libs" = yes; then
8163 # Transform all the library objects into standard objects.
8164 compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8165 finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8168 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8170 # template prelinking step
8171 if test -n "$prelink_cmds"; then
8172 func_execute_cmds "$prelink_cmds" 'exit $?'
8175 wrappers_required=yes
8177 *cygwin* | *mingw* )
8178 if test "$build_libtool_libs" != yes; then
8179 wrappers_required=no
8183 # Disable wrappers for cegcc, we are cross compiling anyway.
8184 wrappers_required=no
8187 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8188 wrappers_required=no
8192 if test "$wrappers_required" = no; then
8193 # Replace the output file specification.
8194 compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8195 link_command="$compile_command$compile_rpath"
8197 # We have no uninstalled library dependencies, so finalize right now.
8199 func_show_eval "$link_command" 'exit_status=$?'
8201 # Delete the generated files.
8202 if test -f "$output_objdir/${outputname}S.${objext}"; then
8203 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8209 if test -n "$compile_shlibpath$finalize_shlibpath"; then
8210 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8212 if test -n "$finalize_shlibpath"; then
8213 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8218 if test -n "$runpath_var"; then
8219 if test -n "$perm_rpath"; then
8220 # We should set the runpath_var.
8222 for dir in $perm_rpath; do
8225 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8227 if test -n "$finalize_perm_rpath"; then
8228 # We should set the runpath_var.
8230 for dir in $finalize_perm_rpath; do
8233 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8237 if test "$no_install" = yes; then
8238 # We don't need to create a wrapper script.
8239 link_command="$compile_var$compile_command$compile_rpath"
8240 # Replace the output file specification.
8241 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8242 # Delete the old output file.
8243 $opt_dry_run || $RM $output
8244 # Link the executable and exit
8245 func_show_eval "$link_command" 'exit $?'
8249 if test "$hardcode_action" = relink; then
8250 # Fast installation is not supported
8251 link_command="$compile_var$compile_command$compile_rpath"
8252 relink_command="$finalize_var$finalize_command$finalize_rpath"
8254 func_warning "this platform does not like uninstalled shared libraries"
8255 func_warning "\`$output' will be relinked during installation"
8257 if test "$fast_install" != no; then
8258 link_command="$finalize_var$compile_command$finalize_rpath"
8259 if test "$fast_install" = yes; then
8260 relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8262 # fast_install is set to needless
8266 link_command="$compile_var$compile_command$compile_rpath"
8267 relink_command="$finalize_var$finalize_command$finalize_rpath"
8271 # Replace the output file specification.
8272 link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8274 # Delete the old output files.
8275 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8277 func_show_eval "$link_command" 'exit $?'
8279 # Now create the wrapper script.
8280 func_verbose "creating $output"
8282 # Quote the relink command for shipping.
8283 if test -n "$relink_command"; then
8284 # Preserve any variables that may affect compiler behavior
8285 for var in $variables_saved_for_relink; do
8286 if eval test -z \"\${$var+set}\"; then
8287 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8288 elif eval var_value=\$$var; test -z "$var_value"; then
8289 relink_command="$var=; export $var; $relink_command"
8291 func_quote_for_eval "$var_value"
8292 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8295 relink_command="(cd `pwd`; $relink_command)"
8296 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8299 # Quote $ECHO for shipping.
8300 if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
8302 [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
8303 *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
8305 qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
8307 qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
8310 # Only actually do things if not in dry run mode.
8312 # win32 will think the script is a binary if it has
8313 # a .exe suffix, so we strip it off here.
8315 *.exe) func_stripname '' '.exe' "$output"
8316 output=$func_stripname_result ;;
8318 # test for cygwin because mv fails w/o .exe extensions
8322 func_stripname '' '.exe' "$outputname"
8323 outputname=$func_stripname_result ;;
8327 *cygwin* | *mingw* )
8328 func_dirname_and_basename "$output" "" "."
8329 output_name=$func_basename_result
8330 output_path=$func_dirname_result
8331 cwrappersource="$output_path/$objdir/lt-$output_name.c"
8332 cwrapper="$output_path/$output_name.exe"
8333 $RM $cwrappersource $cwrapper
8334 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8336 func_emit_cwrapperexe_src > $cwrappersource
8338 # The wrapper executable is built using the $host compiler,
8339 # because it contains $host paths and files. If cross-
8340 # compiling, it, like the target executable, must be
8341 # executed on the $host or under an emulation environment.
8343 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8347 # Now, create the wrapper script for func_source use:
8348 func_ltwrapper_scriptname $cwrapper
8349 $RM $func_ltwrapper_scriptname_result
8350 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8352 # note: this script will not be executed, so do not chmod.
8353 if test "x$build" = "x$host" ; then
8354 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8356 func_emit_wrapper no > $func_ltwrapper_scriptname_result
8362 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8364 func_emit_wrapper no > $output
8373 # See if we need to build an old-fashioned archive.
8374 for oldlib in $oldlibs; do
8376 if test "$build_libtool_libs" = convenience; then
8377 oldobjs="$libobjs_save $symfileobj"
8378 addlibs="$convenience"
8379 build_libtool_libs=no
8381 if test "$build_libtool_libs" = module; then
8382 oldobjs="$libobjs_save"
8383 build_libtool_libs=no
8385 oldobjs="$old_deplibs $non_pic_objects"
8386 if test "$preload" = yes && test -f "$symfileobj"; then
8387 oldobjs="$oldobjs $symfileobj"
8390 addlibs="$old_convenience"
8393 if test -n "$addlibs"; then
8394 gentop="$output_objdir/${outputname}x"
8395 generated="$generated $gentop"
8397 func_extract_archives $gentop $addlibs
8398 oldobjs="$oldobjs $func_extract_archives_result"
8401 # Do each command in the archive commands.
8402 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8403 cmds=$old_archive_from_new_cmds
8406 # Add any objects from preloaded convenience libraries
8407 if test -n "$dlprefiles"; then
8408 gentop="$output_objdir/${outputname}x"
8409 generated="$generated $gentop"
8411 func_extract_archives $gentop $dlprefiles
8412 oldobjs="$oldobjs $func_extract_archives_result"
8415 # POSIX demands no paths to be encoded in archives. We have
8416 # to avoid creating archives with duplicate basenames if we
8417 # might have to extract them afterwards, e.g., when creating a
8418 # static archive out of a convenience library, or when linking
8419 # the entirety of a libtool archive into another (currently
8420 # not supported by libtool).
8421 if (for obj in $oldobjs
8423 func_basename "$obj"
8424 $ECHO "$func_basename_result"
8425 done | sort | sort -uc >/dev/null 2>&1); then
8428 $ECHO "copying selected object files to avoid basename conflicts..."
8429 gentop="$output_objdir/${outputname}x"
8430 generated="$generated $gentop"
8431 func_mkdir_p "$gentop"
8432 save_oldobjs=$oldobjs
8435 for obj in $save_oldobjs
8437 func_basename "$obj"
8438 objbase="$func_basename_result"
8439 case " $oldobjs " in
8440 " ") oldobjs=$obj ;;
8443 # Make sure we don't pick an alternate name that also
8445 newobj=lt$counter-$objbase
8446 func_arith $counter + 1
8447 counter=$func_arith_result
8448 case " $oldobjs " in
8449 *[\ /]"$newobj "*) ;;
8450 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
8453 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8454 oldobjs="$oldobjs $gentop/$newobj"
8456 *) oldobjs="$oldobjs $obj" ;;
8460 eval cmds=\"$old_archive_cmds\"
8463 len=$func_len_result
8464 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8465 cmds=$old_archive_cmds
8467 # the command line is too long to link in one step, link in parts
8468 func_verbose "using piecewise archive linking..."
8473 save_oldobjs=$oldobjs
8475 # Is there a better way of finding the last object in the list?
8476 for obj in $save_oldobjs
8480 eval test_cmds=\"$old_archive_cmds\"
8481 func_len " $test_cmds"
8482 len0=$func_len_result
8484 for obj in $save_oldobjs
8487 func_arith $len + $func_len_result
8488 len=$func_arith_result
8489 func_append objlist " $obj"
8490 if test "$len" -lt "$max_cmd_len"; then
8493 # the above command should be used before it gets too long
8495 if test "$obj" = "$last_oldobj" ; then
8498 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8499 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8506 if test "X$oldobjs" = "X" ; then
8507 eval cmds=\"\$concat_cmds\"
8509 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8513 func_execute_cmds "$cmds" 'exit $?'
8516 test -n "$generated" && \
8517 func_show_eval "${RM}r$generated"
8519 # Now create the libtool archive.
8523 test "$build_old_libs" = yes && old_library="$libname.$libext"
8524 func_verbose "creating $output"
8526 # Preserve any variables that may affect compiler behavior
8527 for var in $variables_saved_for_relink; do
8528 if eval test -z \"\${$var+set}\"; then
8529 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8530 elif eval var_value=\$$var; test -z "$var_value"; then
8531 relink_command="$var=; export $var; $relink_command"
8533 func_quote_for_eval "$var_value"
8534 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8537 # Quote the link command for shipping.
8538 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8539 relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8540 if test "$hardcode_automatic" = yes ; then
8544 # Only create the output if not a dry run.
8546 for installed in no yes; do
8547 if test "$installed" = yes; then
8548 if test -z "$install_libdir"; then
8551 output="$output_objdir/$outputname"i
8552 # Replace all uninstalled libtool libraries with the installed ones
8554 for deplib in $dependency_libs; do
8557 func_basename "$deplib"
8558 name="$func_basename_result"
8559 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8560 test -z "$libdir" && \
8561 func_fatal_error "\`$deplib' is not a valid libtool archive"
8562 newdependency_libs="$newdependency_libs $libdir/$name"
8564 *) newdependency_libs="$newdependency_libs $deplib" ;;
8567 dependency_libs="$newdependency_libs"
8570 for lib in $dlfiles; do
8573 func_basename "$lib"
8574 name="$func_basename_result"
8575 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8576 test -z "$libdir" && \
8577 func_fatal_error "\`$lib' is not a valid libtool archive"
8578 newdlfiles="$newdlfiles $libdir/$name"
8580 *) newdlfiles="$newdlfiles $lib" ;;
8583 dlfiles="$newdlfiles"
8585 for lib in $dlprefiles; do
8588 # Only pass preopened files to the pseudo-archive (for
8589 # eventual linking with the app. that links it) if we
8590 # didn't already link the preopened objects directly into
8592 func_basename "$lib"
8593 name="$func_basename_result"
8594 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8595 test -z "$libdir" && \
8596 func_fatal_error "\`$lib' is not a valid libtool archive"
8597 newdlprefiles="$newdlprefiles $libdir/$name"
8601 dlprefiles="$newdlprefiles"
8604 for lib in $dlfiles; do
8606 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8607 *) abs=`pwd`"/$lib" ;;
8609 newdlfiles="$newdlfiles $abs"
8611 dlfiles="$newdlfiles"
8613 for lib in $dlprefiles; do
8615 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8616 *) abs=`pwd`"/$lib" ;;
8618 newdlprefiles="$newdlprefiles $abs"
8620 dlprefiles="$newdlprefiles"
8623 # place dlname in correct position for cygwin
8625 case $host,$output,$installed,$module,$dlname in
8626 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8629 # $outputname - a libtool library file
8630 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8632 # Please DO NOT delete this file!
8633 # It is necessary for linking the library.
8635 # The name that we can dlopen(3).
8638 # Names of this library.
8639 library_names='$library_names'
8641 # The name of the static archive.
8642 old_library='$old_library'
8644 # Linker flags that can not go in dependency_libs.
8645 inherited_linker_flags='$new_inherited_linker_flags'
8647 # Libraries that this one depends upon.
8648 dependency_libs='$dependency_libs'
8650 # Names of additional weak libraries provided by this library
8651 weak_library_names='$weak_libs'
8653 # Version information for $libname.
8658 # Is this an already installed library?
8659 installed=$installed
8661 # Should we warn about portability when linking against -modules?
8662 shouldnotlink=$module
8664 # Files to dlopen/dlpreopen
8666 dlpreopen='$dlprefiles'
8668 # Directory that this library needs to be installed in:
8669 libdir='$install_libdir'"
8670 if test "$installed" = no && test "$need_relink" = yes; then
8672 relink_command=\"$relink_command\""
8677 # Do a symbolic link so that the libtool archive can be found in
8678 # LD_LIBRARY_PATH before the program is installed.
8679 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8685 { test "$mode" = link || test "$mode" = relink; } &&
8686 func_mode_link ${1+"$@"}
8689 # func_mode_uninstall arg...
8690 func_mode_uninstall ()
8698 # This variable tells wrapper scripts just to set variables rather
8699 # than running their programs.
8700 libtool_install_magic="$magic"
8705 -f) RM="$RM $arg"; rmforce=yes ;;
8706 -*) RM="$RM $arg" ;;
8707 *) files="$files $arg" ;;
8712 func_fatal_help "you must specify an RM program"
8716 origobjdir="$objdir"
8717 for file in $files; do
8718 func_dirname "$file" "" "."
8719 dir="$func_dirname_result"
8720 if test "X$dir" = X.; then
8721 objdir="$origobjdir"
8723 objdir="$dir/$origobjdir"
8725 func_basename "$file"
8726 name="$func_basename_result"
8727 test "$mode" = uninstall && objdir="$dir"
8729 # Remember objdir for removal later, being careful to avoid duplicates
8730 if test "$mode" = clean; then
8733 *) rmdirs="$rmdirs $objdir" ;;
8737 # Don't error if the file doesn't exist and rm -f was used.
8738 if { test -L "$file"; } >/dev/null 2>&1 ||
8739 { test -h "$file"; } >/dev/null 2>&1 ||
8740 test -f "$file"; then
8742 elif test -d "$file"; then
8745 elif test "$rmforce" = yes; then
8753 # Possibly a libtool archive, so verify it.
8754 if func_lalib_p "$file"; then
8755 func_source $dir/$name
8757 # Delete the libtool libraries and symlinks.
8758 for n in $library_names; do
8759 rmfiles="$rmfiles $objdir/$n"
8761 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8765 case " $library_names " in
8766 # " " in the beginning catches empty $dlname
8768 *) rmfiles="$rmfiles $objdir/$dlname" ;;
8770 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8773 if test -n "$library_names"; then
8774 # Do each command in the postuninstall commands.
8775 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8778 if test -n "$old_library"; then
8779 # Do each command in the old_postuninstall commands.
8780 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8782 # FIXME: should reinstall the best remaining shared library.
8789 # Possibly a libtool object, so verify it.
8790 if func_lalib_p "$file"; then
8793 func_source $dir/$name
8795 # Add PIC object to the list of files to remove.
8796 if test -n "$pic_object" &&
8797 test "$pic_object" != none; then
8798 rmfiles="$rmfiles $dir/$pic_object"
8801 # Add non-PIC object to the list of files to remove.
8802 if test -n "$non_pic_object" &&
8803 test "$non_pic_object" != none; then
8804 rmfiles="$rmfiles $dir/$non_pic_object"
8810 if test "$mode" = clean ; then
8814 func_stripname '' '.exe' "$file"
8815 file=$func_stripname_result
8816 func_stripname '' '.exe' "$name"
8817 noexename=$func_stripname_result
8818 # $file with .exe has already been added to rmfiles,
8819 # add $file without .exe
8820 rmfiles="$rmfiles $file"
8823 # Do a test to see if this is a libtool program.
8824 if func_ltwrapper_p "$file"; then
8825 if func_ltwrapper_executable_p "$file"; then
8826 func_ltwrapper_scriptname "$file"
8828 func_source $func_ltwrapper_scriptname_result
8829 rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8832 func_source $dir/$noexename
8835 # note $name still contains .exe if it was in $file originally
8836 # as does the version of $file that was added into $rmfiles
8837 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8838 if test "$fast_install" = yes && test -n "$relink_command"; then
8839 rmfiles="$rmfiles $objdir/lt-$name"
8841 if test "X$noexename" != "X$name" ; then
8842 rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8848 func_show_eval "$RM $rmfiles" 'exit_status=1'
8850 objdir="$origobjdir"
8852 # Try to remove the ${objdir}s in the directories where we deleted files
8853 for dir in $rmdirs; do
8854 if test -d "$dir"; then
8855 func_show_eval "rmdir $dir >/dev/null 2>&1"
8862 { test "$mode" = uninstall || test "$mode" = clean; } &&
8863 func_mode_uninstall ${1+"$@"}
8865 test -z "$mode" && {
8866 help="$generic_help"
8867 func_fatal_help "you must specify a MODE"
8870 test -z "$exec_cmd" && \
8871 func_fatal_help "invalid operation mode \`$mode'"
8873 if test -n "$exec_cmd"; then
8874 eval exec "$exec_cmd"
8881 # The TAGs below are defined such that we never get into a situation
8882 # in which we disable both kinds of libraries. Given conflicting
8883 # choices, we go for a static library, that is the most portable,
8884 # since we can't tell whether shared libraries were disabled because
8885 # the user asked for that or because the platform doesn't support
8886 # them. This is particularly important on AIX, because we don't
8887 # support having both static and shared libraries enabled at the same
8888 # time on that platform, so we default to a shared-only configuration.
8889 # If a disable-shared tag is given, we'll fallback to a static-only
8890 # configuration. But we'll never go from static-only to shared-only.
8892 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8893 build_libtool_libs=no
8895 # ### END LIBTOOL TAG CONFIG: disable-shared
8897 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8898 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8899 # ### END LIBTOOL TAG CONFIG: disable-static
8908 # ### BEGIN LIBTOOL TAG CONFIG: F77
8910 # The linker used to build libraries.
8913 # Commands used to build an old-style archive.
8914 old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
8916 # A language specific compiler.
8919 # Is the compiler the GNU compiler?
8922 # Compiler flag to turn off builtin functions.
8925 # How to pass a linker flag through the compiler.
8928 # Additional compiler flags for building library objects.
8931 # Compiler flag to prevent dynamic linking.
8934 # Does compiler simultaneously support -c and -o options?
8937 # Whether or not to add -lc for building shared libraries.
8938 build_libtool_need_lc=no
8940 # Whether or not to disallow shared libs when runtime libs are static.
8941 allow_libtool_libs_with_static_runtimes=no
8943 # Compiler flag to allow reflexive dlopens.
8944 export_dynamic_flag_spec=""
8946 # Compiler flag to generate shared objects directly from archives.
8947 whole_archive_flag_spec=""
8949 # Whether the compiler copes with passing no objects directly.
8950 compiler_needs_object=""
8952 # Create an old-style archive from a shared archive.
8953 old_archive_from_new_cmds=""
8955 # Create a temporary old-style archive to link instead of a shared archive.
8956 old_archive_from_expsyms_cmds=""
8958 # Commands used to build a shared archive.
8960 archive_expsym_cmds=""
8962 # Commands used to build a loadable module if different from building
8965 module_expsym_cmds=""
8967 # Whether we are building with GNU ld or not.
8970 # Flag that allows shared libraries with undefined symbols to be built.
8971 allow_undefined_flag=""
8973 # Flag that enforces no undefined symbols.
8974 no_undefined_flag=""
8976 # Flag to hardcode $libdir into a binary during linking.
8977 # This must work even if $libdir does not exist
8978 hardcode_libdir_flag_spec=""
8980 # If ld is used when linking, flag to hardcode $libdir into a binary
8981 # during linking. This must work even if $libdir does not exist.
8982 hardcode_libdir_flag_spec_ld=""
8984 # Whether we need a single "-rpath" flag with a separated argument.
8985 hardcode_libdir_separator=""
8987 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
8988 # DIR into the resulting binary.
8991 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
8992 # DIR into the resulting binary and the resulting library dependency is
8993 # "absolute",i.e impossible to change by setting ${shlibpath_var} if the
8994 # library is relocated.
8995 hardcode_direct_absolute=no
8997 # Set to "yes" if using the -LDIR flag during linking hardcodes DIR
8998 # into the resulting binary.
9001 # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
9002 # into the resulting binary.
9003 hardcode_shlibpath_var=
9005 # Set to "yes" if building a shared library automatically hardcodes DIR
9006 # into the library and all subsequent libraries and executables linked
9008 hardcode_automatic=no
9010 # Set to yes if linker adds runtime paths of dependent libraries
9011 # to runtime path list.
9014 # Whether libtool must link a program against all its dependency libraries.
9015 link_all_deplibs=unknown
9017 # Fix the shell variable $srcfile for the compiler.
9020 # Set to "yes" if exported symbols are required.
9021 always_export_symbols=no
9023 # The commands to list exported symbols.
9024 export_symbols_cmds=""
9026 # Symbols that should not be listed in the preloaded symbols.
9029 # Symbols that must always be exported.
9032 # Commands necessary for linking programs (against libraries) with templates.
9035 # Specify filename containing input files.
9038 # How to hardcode a shared library path into an executable.
9041 # ### END LIBTOOL TAG CONFIG: F77