1 # Generated from ltmain.m4sh.
3 # libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
4 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
6 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
7 # 2007, 2008, 2009 Free Software Foundation, Inc.
8 # This is free software; see the source for copying conditions. There is NO
9 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 # GNU Libtool is free software; you can redistribute it and/or modify
12 # it under the terms of the GNU General Public License as published by
13 # the Free Software Foundation; either version 2 of the License, or
14 # (at your option) any later version.
16 # As a special exception to the GNU General Public License,
17 # if you distribute this file as part of a program or library that
18 # is built using GNU Libtool, you may include this file under the
19 # same distribution terms that you use for the rest of that program.
21 # GNU Libtool is distributed in the hope that it will be useful, but
22 # WITHOUT ANY WARRANTY; without even the implied warranty of
23 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 # General Public License for more details.
26 # You should have received a copy of the GNU General Public License
27 # along with GNU Libtool; see the file COPYING. If not, a copy
28 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
29 # or obtained by writing to the Free Software Foundation, Inc.,
30 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
32 # Usage: $progname [OPTION]... [MODE-ARG]...
34 # Provide generalized library-building support services.
36 # --config show all configuration variables
37 # --debug enable verbose shell tracing
38 # -n, --dry-run display commands without modifying any files
39 # --features display basic configuration information and exit
40 # --mode=MODE use operation mode MODE
41 # --no-finish let install mode avoid finish commands
42 # --preserve-dup-deps don't remove duplicate dependency libraries
43 # --quiet, --silent don't print informational messages
44 # --no-quiet, --no-silent
45 # print informational messages (default)
46 # --tag=TAG use configuration variables from tag TAG
47 # -v, --verbose print more informational messages than default
48 # --no-verbose don't print the extra informational messages
49 # --version print version information
50 # -h, --help, --help-all print short, long, or detailed help message
52 # MODE must be one of the following:
54 # clean remove files from the build directory
55 # compile compile a source file into a libtool object
56 # execute automatically set library path, then run a program
57 # finish complete the installation of libtool libraries
58 # install install libraries or executables
59 # link create a library or an executable
60 # uninstall remove libraries from an installed directory
62 # MODE-ARGS vary depending on the MODE. When passed as first option,
63 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
64 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
66 # When reporting a bug, please describe a test case to reproduce it and
67 # include the following information:
72 # compiler flags: $LTCFLAGS
73 # linker: $LD (gnu? $with_gnu_ld)
74 # $progname: (GNU libtool 1.3134 2009-11-29) 2.2.7a
75 # automake: $automake_version
76 # autoconf: $autoconf_version
78 # Report bugs to <bug-libtool@gnu.org>.
83 TIMESTAMP=" 1.3134 2009-11-29"
84 package_revision=1.3134
86 # Be Bourne compatible
87 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
90 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91 # is contrary to our usage. Disable this feature.
92 alias -g '${1+"$@"}'='"$@"'
95 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97 BIN_SH=xpg4; export BIN_SH # for Tru64
98 DUALCASE=1; export DUALCASE # for MKS sh
100 # A function that is used when there is no print builtin or printf.
101 func_fallback_echo ()
103 eval 'cat <<_LTECHO_EOF
108 # NLS nuisances: We save the old values to restore during execute mode.
109 # Only set LANG and LC_ALL to C if already set.
110 # These must not be set unconditionally because not all systems understand
111 # e.g. LANG=C (notably SCO).
114 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
116 eval "if test \"\${$lt_var+set}\" = set; then
117 save_$lt_var=\$$lt_var
120 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
121 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
133 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
134 # is ksh but when the shell is invoked as "sh" and the current value of
135 # the _XPG environment variable is not equal to 1 (one), the special
136 # positional parameter $0, within a function call, is the name of the
144 : ${EGREP="/bin/grep -E"}
145 : ${FGREP="/bin/grep -F"}
146 : ${GREP="/bin/grep"}
152 : ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"}
153 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
154 : ${Xsed="$SED -e 1s/^X//"}
159 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
160 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
162 exit_status=$EXIT_SUCCESS
164 # Make sure IFS has a sensible default
169 dirname="s,/[^/]*$,,"
172 # func_dirname_and_basename file append nondir_replacement
173 # perform func_basename and func_dirname in a single function
175 # dirname: Compute the dirname of FILE. If nonempty,
176 # add APPEND to the result, otherwise set result
177 # to NONDIR_REPLACEMENT.
178 # value returned in "$func_dirname_result"
179 # basename: Compute filename of FILE.
180 # value returned in "$func_basename_result"
181 # Implementation must be kept synchronized with func_dirname
182 # and func_basename. For efficiency, we do not delegate to
183 # those functions but instead duplicate the functionality here.
184 func_dirname_and_basename ()
186 # Extract subdirectory from the argument.
187 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
188 if test "X$func_dirname_result" = "X${1}"; then
189 func_dirname_result="${3}"
191 func_dirname_result="$func_dirname_result${2}"
193 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
196 # Generated shell functions inserted here.
198 # These SED scripts presuppose an absolute path with a trailing slash.
199 pathcar='s,^/\([^/]*\).*$,\1,'
200 pathcdr='s,^/[^/]*,,'
201 removedotparts=':dotsl
205 collapseslashes='s@/\{1,\}@/@g'
206 finalslash='s,/*$,/,'
208 # func_normal_abspath PATH
209 # Remove doubled-up and trailing slashes, "." path components,
210 # and cancel out any ".." path components in PATH after making
211 # it an absolute path.
212 # value returned in "$func_normal_abspath_result"
213 func_normal_abspath ()
215 # Start from root dir and reassemble the path.
216 func_normal_abspath_result=
217 func_normal_abspath_tpath=$1
218 func_normal_abspath_altnamespace=
219 case $func_normal_abspath_tpath in
221 # Empty path, that just means $cwd.
222 func_stripname '' '/' "`pwd`"
223 func_normal_abspath_result=$func_stripname_result
226 # The next three entries are used to spot a run of precisely
227 # two leading slashes without using negated character classes;
228 # we take advantage of case's first-match behaviour.
230 # Unusual form of absolute path, do nothing.
233 # Not necessarily an ordinary path; POSIX reserves leading '//'
234 # and for example Cygwin uses it to access remote file shares
235 # over CIFS/SMB, so we conserve a leading double slash if found.
236 func_normal_abspath_altnamespace=/
239 # Absolute path, do nothing.
242 # Relative path, prepend $cwd.
243 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
246 # Cancel out all the simple stuff to save iterations. We also want
247 # the path to end with a slash for ease of parsing, so make sure
248 # there is one (and only one) here.
249 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
250 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
252 # Processed it all yet?
253 if test "$func_normal_abspath_tpath" = / ; then
254 # If we ascended to the root using ".." the result may be empty now.
255 if test -z "$func_normal_abspath_result" ; then
256 func_normal_abspath_result=/
260 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
262 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
264 # Figure out what to do with it
265 case $func_normal_abspath_tcomponent in
267 # Trailing empty path component, ignore it.
270 # Parent dir; strip last assembled component from result.
271 func_dirname "$func_normal_abspath_result"
272 func_normal_abspath_result=$func_dirname_result
275 # Actual path component, append it.
276 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
280 # Restore leading double-slash if one was found on entry.
281 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
284 # func_relative_path SRCDIR DSTDIR
285 # generates a relative path from SRCDIR to DSTDIR, with a trailing
286 # slash if non-empty, suitable for immediately appending a filename
287 # without needing to append a separator.
288 # value returned in "$func_relative_path_result"
289 func_relative_path ()
291 func_relative_path_result=
292 func_normal_abspath "$1"
293 func_relative_path_tlibdir=$func_normal_abspath_result
294 func_normal_abspath "$2"
295 func_relative_path_tbindir=$func_normal_abspath_result
297 # Ascend the tree starting from libdir
299 # check if we have found a prefix of bindir
300 case $func_relative_path_tbindir in
301 $func_relative_path_tlibdir)
302 # found an exact match
303 func_relative_path_tcancelled=
306 $func_relative_path_tlibdir*)
307 # found a matching prefix
308 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
309 func_relative_path_tcancelled=$func_stripname_result
310 if test -z "$func_relative_path_result"; then
311 func_relative_path_result=.
316 func_dirname $func_relative_path_tlibdir
317 func_relative_path_tlibdir=${func_dirname_result}
318 if test "x$func_relative_path_tlibdir" = x ; then
319 # Have to descend all the way to the root!
320 func_relative_path_result=../$func_relative_path_result
321 func_relative_path_tcancelled=$func_relative_path_tbindir
324 func_relative_path_result=../$func_relative_path_result
329 # Now calculate path; take care to avoid doubling-up slashes.
330 func_stripname '' '/' "$func_relative_path_result"
331 func_relative_path_result=$func_stripname_result
332 func_stripname '/' '/' "$func_relative_path_tcancelled"
333 if test "x$func_stripname_result" != x ; then
334 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
337 # Normalisation. If bindir is libdir, return empty string,
338 # else relative path ending with a slash; either way, target
339 # file name can be directly appended.
340 if test ! -z "$func_relative_path_result"; then
341 func_stripname './' '' "$func_relative_path_result/"
342 func_relative_path_result=$func_stripname_result
346 # The name of this program:
347 func_dirname_and_basename "$progpath"
348 progname=$func_basename_result
350 # Make sure we have an absolute path for reexecution:
352 [\\/]*|[A-Za-z]:\\*) ;;
354 progdir=$func_dirname_result
355 progdir=`cd "$progdir" && pwd`
356 progpath="$progdir/$progname"
361 for progdir in $PATH; do
363 test -x "$progdir/$progname" && break
366 test -n "$progdir" || progdir=`pwd`
367 progpath="$progdir/$progname"
371 # Sed substitution that helps us do robust quoting. It backslashifies
372 # metacharacters that are still active within double-quoted strings.
373 Xsed="${SED}"' -e 1s/^X//'
374 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
376 # Same as above, but do not quote variable references.
377 double_quote_subst='s/\(["`\\]\)/\\\1/g'
379 # Re-`\' parameter expansions in output of double_quote_subst that were
380 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
381 # in input to double_quote_subst, that '$' was protected from expansion.
382 # Since each input `\' is now two `\'s, look for any number of runs of
383 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
388 sed_double_backslash="\
392 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
403 # Echo program name prefixed message, along with the current mode
404 # name if it has been set yet.
407 $ECHO "$progname${mode+: }$mode: $*"
410 # func_verbose arg...
411 # Echo program name prefixed message in verbose mode only.
414 $opt_verbose && func_echo ${1+"$@"}
416 # A bug in bash halts the script if the last line of a function
417 # fails when set -e is in force, so we need another command to
422 # func_echo_all arg...
423 # Invoke $ECHO with all args, space-separated.
430 # Echo program name prefixed message to standard error.
433 $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
436 # func_warning arg...
437 # Echo program name prefixed warning message to standard error.
440 $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
446 # func_fatal_error arg...
447 # Echo program name prefixed message to standard error, and exit.
454 # func_fatal_help arg...
455 # Echo program name prefixed message to standard error, followed by
456 # a help hint, and exit.
460 func_fatal_error "$help"
462 help="Try \`$progname --help' for more information." ## default
465 # func_grep expression filename
466 # Check whether EXPRESSION matches any line of FILENAME, without output.
469 $GREP "$1" "$2" >/dev/null 2>&1
473 # func_mkdir_p directory-path
474 # Make sure the entire path to DIRECTORY-PATH is available.
477 my_directory_path="$1"
480 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
482 # Protect directory names starting with `-'
483 case $my_directory_path in
484 -*) my_directory_path="./$my_directory_path" ;;
487 # While some portion of DIR does not yet exist...
488 while test ! -d "$my_directory_path"; do
489 # ...make a list in topmost first order. Use a colon delimited
490 # list in case some portion of path contains whitespace.
491 my_dir_list="$my_directory_path:$my_dir_list"
493 # If the last portion added has no slash in it, the list is done
494 case $my_directory_path in */*) ;; *) break ;; esac
496 # ...otherwise throw away the child directory and loop
497 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
499 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
501 save_mkdir_p_IFS="$IFS"; IFS=':'
502 for my_dir in $my_dir_list; do
503 IFS="$save_mkdir_p_IFS"
504 # mkdir can fail with a `File exist' error if two processes
505 # try to create one of the directories concurrently. Don't
507 $MKDIR "$my_dir" 2>/dev/null || :
509 IFS="$save_mkdir_p_IFS"
511 # Bail out if we (or some other process) failed to create a directory.
512 test -d "$my_directory_path" || \
513 func_fatal_error "Failed to create \`$1'"
518 # func_mktempdir [string]
519 # Make a temporary directory that won't clash with other running
520 # libtool processes, and avoids race conditions if possible. If
521 # given, STRING is the basename for that directory.
524 my_template="${TMPDIR-/tmp}/${1-$progname}"
526 if test "$opt_dry_run" = ":"; then
527 # Return a directory name, but don't create it in dry-run mode
528 my_tmpdir="${my_template}-$$"
531 # If mktemp works, use that first and foremost
532 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
534 if test ! -d "$my_tmpdir"; then
535 # Failing that, at least try and use $RANDOM to avoid a race
536 my_tmpdir="${my_template}-${RANDOM-0}$$"
538 save_mktempdir_umask=`umask`
541 umask $save_mktempdir_umask
544 # If we're not in dry-run mode, bomb out on failure
545 test -d "$my_tmpdir" || \
546 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
553 # func_quote_for_eval arg
554 # Aesthetically quote ARG to be evaled later.
555 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
556 # is double-quoted, suitable for a subsequent eval, whereas
557 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
558 # which are still active within double quotes backslashified.
559 func_quote_for_eval ()
563 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
565 func_quote_for_eval_unquoted_result="$1" ;;
568 case $func_quote_for_eval_unquoted_result in
569 # Double-quote args containing shell metacharacters to delay
570 # word splitting, command substitution and and variable
571 # expansion for a subsequent eval.
572 # Many Bourne shells cannot handle close brackets correctly
573 # in scan sets, so we specify it separately.
574 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
575 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
578 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
583 # func_quote_for_expand arg
584 # Aesthetically quote ARG to be evaled later; same as above,
585 # but do not quote variable references.
586 func_quote_for_expand ()
590 my_arg=`$ECHO "$1" | $SED \
591 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
597 # Double-quote args containing shell metacharacters to delay
598 # word splitting and command substitution for a subsequent eval.
599 # Many Bourne shells cannot handle close brackets correctly
600 # in scan sets, so we specify it separately.
601 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
606 func_quote_for_expand_result="$my_arg"
610 # func_show_eval cmd [fail_exp]
611 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
612 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
613 # is given, then evaluate it.
619 ${opt_silent-false} || {
620 func_quote_for_expand "$my_cmd"
621 eval "func_echo $func_quote_for_expand_result"
624 if ${opt_dry_run-false}; then :; else
627 if test "$my_status" -eq 0; then :; else
628 eval "(exit $my_status); $my_fail_exp"
634 # func_show_eval_locale cmd [fail_exp]
635 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
636 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
637 # is given, then evaluate it. Use the saved locale for evaluation.
638 func_show_eval_locale ()
643 ${opt_silent-false} || {
644 func_quote_for_expand "$my_cmd"
645 eval "func_echo $func_quote_for_expand_result"
648 if ${opt_dry_run-false}; then :; else
649 eval "$lt_user_locale
652 eval "$lt_safe_locale"
653 if test "$my_status" -eq 0; then :; else
654 eval "(exit $my_status); $my_fail_exp"
664 # Echo version message to standard output and exit.
675 /^# '$PROGRAM' (GNU /,/# warranty; / {
678 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
685 # Echo short help message to standard output and exit.
688 $SED -n '/^# Usage:/,/^# *-h/ {
691 s/\$progname/'$progname'/
695 $ECHO "run \`$progname --help | more' for full usage"
700 # Echo long help message to standard output and exit,
701 # unless 'noexit' is passed as argument.
704 $SED -n '/^# Usage:/,/# Report bugs to/ {
707 s*\$progname*'$progname'*
709 s*\$SHELL*'"$SHELL"'*
711 s*\$LTCFLAGS*'"$LTCFLAGS"'*
713 s/\$with_gnu_ld/'"$with_gnu_ld"'/
714 s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
715 s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
719 if test -z "$1"; then
724 # func_missing_arg argname
725 # Echo program name prefixed message to standard error and set global
729 func_error "missing argument for $1"
740 magic="%%%MAGIC variable%%%"
741 magic_exe="%%%MAGIC EXE variable%%%"
748 lo2o="s/\\.lo\$/.${objext}/"
749 o2lo="s/\\.${objext}\$/.lo/"
755 opt_duplicate_deps=false
759 # If this variable is set in any of the actions, the command in it
760 # will be execed at the end. This prevents here-documents from being
761 # left over by shells.
764 # func_fatal_configuration arg...
765 # Echo program name prefixed message to standard error, followed by
766 # a configuration failure hint, and exit.
767 func_fatal_configuration ()
770 func_error "See the $PACKAGE documentation for more information."
771 func_fatal_error "Fatal configuration error."
776 # Display the configuration for all the tags in this script.
779 re_begincf='^# ### BEGIN LIBTOOL'
780 re_endcf='^# ### END LIBTOOL'
782 # Default configuration.
783 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
785 # Now print the configurations for the tags.
786 for tagname in $taglist; do
787 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
794 # Display the features supported by this script.
798 if test "$build_libtool_libs" = yes; then
799 echo "enable shared libraries"
801 echo "disable shared libraries"
803 if test "$build_old_libs" = yes; then
804 echo "enable static libraries"
806 echo "disable static libraries"
812 # func_enable_tag tagname
813 # Verify that TAGNAME is valid, and either flag an error and exit, or
814 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
821 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
822 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
823 sed_extractcf="/$re_begincf/,/$re_endcf/p"
828 func_fatal_error "invalid tag name: $tagname"
832 # Don't test for the "default" C tag, as we know it's
833 # there but not specially marked.
837 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
838 taglist="$taglist $tagname"
840 # Evaluate the configuration. Be careful to quote the path
841 # and the sed script, to avoid splitting on whitespace, but
842 # also don't use non-portable quotes within backquotes within
843 # quotes we have to do it in 2 steps:
844 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
847 func_error "ignoring unknown tag $tagname"
853 # Parse options once, thoroughly. This comes as soon as possible in
854 # the script to make things like `libtool --version' happen quickly.
857 # Shorthand for --mode=foo, only valid as the first argument
860 shift; set dummy --mode clean ${1+"$@"}; shift
862 compile|compil|compi|comp|com|co|c)
863 shift; set dummy --mode compile ${1+"$@"}; shift
865 execute|execut|execu|exec|exe|ex|e)
866 shift; set dummy --mode execute ${1+"$@"}; shift
868 finish|finis|fini|fin|fi|f)
869 shift; set dummy --mode finish ${1+"$@"}; shift
871 install|instal|insta|inst|ins|in|i)
872 shift; set dummy --mode install ${1+"$@"}; shift
875 shift; set dummy --mode link ${1+"$@"}; shift
877 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
878 shift; set dummy --mode uninstall ${1+"$@"}; shift
882 # Parse non-mode specific arguments:
883 while test "$#" -gt 0; do
888 --config) func_config ;;
890 --debug) preserve_args="$preserve_args $opt"
891 func_echo "enabling shell trace mode"
896 -dlopen) test "$#" -eq 0 && func_missing_arg "$opt" && break
897 execute_dlfiles="$execute_dlfiles $1"
901 --dry-run | -n) opt_dry_run=: ;;
902 --features) func_features ;;
903 --finish) mode="finish" ;;
904 --no-finish) opt_finish=false ;;
906 --mode) test "$#" -eq 0 && func_missing_arg "$opt" && break
908 # Valid mode arguments:
918 # Catch anything else as an error
919 *) func_error "invalid argument for $opt"
930 opt_duplicate_deps=: ;;
932 --quiet|--silent) preserve_args="$preserve_args $opt"
937 --no-quiet|--no-silent)
938 preserve_args="$preserve_args $opt"
942 --verbose| -v) preserve_args="$preserve_args $opt"
947 --no-verbose) preserve_args="$preserve_args $opt"
951 --tag) test "$#" -eq 0 && func_missing_arg "$opt" && break
952 preserve_args="$preserve_args $opt $1"
953 func_enable_tag "$1" # tagname is set here
957 # Separate optargs to long options:
958 -dlopen=*|--mode=*|--tag=*)
959 func_opt_split "$opt"
960 set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
964 -\?|-h) func_usage ;;
965 --help) opt_help=: ;;
966 --help-all) opt_help=': help-all' ;;
967 --version) func_version ;;
969 -*) func_fatal_help "unrecognized option \`$opt'" ;;
979 *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* )
980 # don't eliminate duplications in $postdeps and $predeps
981 opt_duplicate_compiler_generated_deps=:
984 opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
988 # Having warned about all mis-specified options, bail out if
989 # anything was wrong.
990 $exit_cmd $EXIT_FAILURE
993 # func_check_version_match
994 # Ensure that we are using m4 macros, and libtool script from the same
995 # release of libtool.
996 func_check_version_match ()
998 if test "$package_revision" != "$macro_revision"; then
999 if test "$VERSION" != "$macro_version"; then
1000 if test -z "$macro_version"; then
1002 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1003 $progname: definition of this LT_INIT comes from an older release.
1004 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1005 $progname: and run autoconf again.
1009 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
1010 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1011 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1012 $progname: and run autoconf again.
1017 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1018 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1019 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1020 $progname: of $PACKAGE $VERSION and run autoconf again.
1034 # Sanity checks first:
1035 func_check_version_match
1037 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1038 func_fatal_configuration "not configured to build any kind of library"
1041 test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1045 eval "std_shrext=\"$shrext_cmds\""
1048 # Only execute mode is allowed to have -dlopen flags.
1049 if test -n "$execute_dlfiles" && test "$mode" != execute; then
1050 func_error "unrecognized option \`-dlopen'"
1055 # Change the help message to a mode-specific one.
1056 generic_help="$help"
1057 help="Try \`$progname --help --mode=$mode' for more information."
1062 # True iff FILE is a libtool `.la' library or `.lo' object file.
1063 # This function is only a basic sanity check; it will hardly flush out
1064 # determined imposters.
1068 $SED -e 4q "$1" 2>/dev/null \
1069 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1072 # func_lalib_unsafe_p file
1073 # True iff FILE is a libtool `.la' library or `.lo' object file.
1074 # This function implements the same check as func_lalib_p without
1075 # resorting to external programs. To this end, it redirects stdin and
1076 # closes it afterwards, without saving the original file descriptor.
1077 # As a safety measure, use it only where a negative result would be
1078 # fatal anyway. Works if `file' does not exist.
1079 func_lalib_unsafe_p ()
1082 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1083 for lalib_p_l in 1 2 3 4
1086 case "$lalib_p_line" in
1087 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1092 test "$lalib_p" = yes
1095 # func_ltwrapper_script_p file
1096 # True iff FILE is a libtool wrapper script
1097 # This function is only a basic sanity check; it will hardly flush out
1098 # determined imposters.
1099 func_ltwrapper_script_p ()
1104 # func_ltwrapper_executable_p file
1105 # True iff FILE is a libtool wrapper executable
1106 # This function is only a basic sanity check; it will hardly flush out
1107 # determined imposters.
1108 func_ltwrapper_executable_p ()
1110 func_ltwrapper_exec_suffix=
1113 *) func_ltwrapper_exec_suffix=.exe ;;
1115 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1118 # func_ltwrapper_scriptname file
1119 # Assumes file is an ltwrapper_executable
1120 # uses $file to determine the appropriate filename for a
1121 # temporary ltwrapper_script.
1122 func_ltwrapper_scriptname ()
1124 func_ltwrapper_scriptname_result=""
1125 if func_ltwrapper_executable_p "$1"; then
1126 func_dirname_and_basename "$1" "" "."
1127 func_stripname '' '.exe' "$func_basename_result"
1128 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1132 # func_ltwrapper_p file
1133 # True iff FILE is a libtool wrapper script or wrapper executable
1134 # This function is only a basic sanity check; it will hardly flush out
1135 # determined imposters.
1138 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1142 # func_execute_cmds commands fail_cmd
1143 # Execute tilde-delimited COMMANDS.
1144 # If FAIL_CMD is given, eval that upon failure.
1145 # FAIL_CMD may read-access the current command in variable CMD!
1146 func_execute_cmds ()
1149 save_ifs=$IFS; IFS='~'
1153 func_show_eval "$cmd" "${2-:}"
1160 # Source FILE, adding directory component if necessary.
1161 # Note that it is not necessary on cygwin/mingw to append a dot to
1162 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1163 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1164 # `FILE.' does not work on cygwin managed mounts.
1169 */* | *\\*) . "$1" ;;
1175 # func_infer_tag arg
1176 # Infer tagged configuration to use if any are available and
1177 # if one wasn't chosen via the "--tag" command line option.
1178 # Only attempt this if the compiler in the base compile
1179 # command doesn't match the default compiler.
1180 # arg is usually of the form 'gcc ...'
1184 if test -n "$available_tags" && test -z "$tagname"; then
1187 func_quote_for_eval "$arg"
1188 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1190 CC_expanded=`func_echo_all $CC`
1191 CC_quoted_expanded=`func_echo_all $CC_quoted`
1193 # Blanks in the command may have been stripped by the calling shell,
1194 # but not from the CC environment variable when configure was run.
1195 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1196 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1197 # Blanks at the start of $base_compile will cause this to fail
1198 # if we don't check for them as well.
1200 for z in $available_tags; do
1201 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1202 # Evaluate the configuration.
1203 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1206 # Double-quote args containing other shell metacharacters.
1207 func_quote_for_eval "$arg"
1208 CC_quoted="$CC_quoted $func_quote_for_eval_result"
1210 CC_expanded=`func_echo_all $CC`
1211 CC_quoted_expanded=`func_echo_all $CC_quoted`
1213 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1214 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1215 # The compiler in the base compile command matches
1216 # the one in the tagged configuration.
1217 # Assume this is the tagged configuration we want.
1224 # If $tagname still isn't set, then no tagged configuration
1225 # was found and let the user know that the "--tag" command
1226 # line option must be used.
1227 if test -z "$tagname"; then
1228 func_echo "unable to infer tagged configuration"
1229 func_fatal_error "specify a tag with \`--tag'"
1231 # func_verbose "using $tagname tagged configuration"
1240 # func_write_libtool_object output_name pic_name nonpic_name
1241 # Create a libtool object file (analogous to a ".la" file),
1242 # but don't create it if we're doing a dry run.
1243 func_write_libtool_object ()
1246 if test "$build_libtool_libs" = yes; then
1252 if test "$build_old_libs" = yes; then
1253 write_oldobj=\'${3}\'
1259 cat >${write_libobj}T <<EOF
1260 # $write_libobj - a libtool object file
1261 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1263 # Please DO NOT delete this file!
1264 # It is necessary for linking the library.
1266 # Name of the PIC object.
1267 pic_object=$write_lobj
1269 # Name of the non-PIC object
1270 non_pic_object=$write_oldobj
1273 $MV "${write_libobj}T" "${write_libobj}"
1277 # func_mode_compile arg...
1278 func_mode_compile ()
1281 # Get the compilation command and the source file.
1283 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1295 # do not "continue". Instead, add this to base_compile
1307 # Accept any command-line options.
1310 test -n "$libobj" && \
1311 func_fatal_error "you cannot specify \`-o' more than once"
1316 -pie | -fpie | -fPIE)
1317 pie_flag="$pie_flag $arg"
1321 -shared | -static | -prefer-pic | -prefer-non-pic)
1332 arg_mode=arg # the next one goes into the "base_compile" arg list
1333 continue # The current "srcfile" will either be retained or
1334 ;; # replaced later. I would guess that would be a bug.
1337 func_stripname '-Wc,' '' "$arg"
1338 args=$func_stripname_result
1340 save_ifs="$IFS"; IFS=','
1341 for arg in $args; do
1343 func_quote_for_eval "$arg"
1344 lastarg="$lastarg $func_quote_for_eval_result"
1347 func_stripname ' ' '' "$lastarg"
1348 lastarg=$func_stripname_result
1350 # Add the arguments to base_compile.
1351 base_compile="$base_compile $lastarg"
1356 # Accept the current argument as the source file.
1357 # The previous "srcfile" becomes the current argument.
1364 esac # case $arg_mode
1366 # Aesthetically quote the previous argument.
1367 func_quote_for_eval "$lastarg"
1368 base_compile="$base_compile $func_quote_for_eval_result"
1373 func_fatal_error "you must specify an argument for -Xcompile"
1376 func_fatal_error "you must specify a target with \`-o'"
1379 # Get the name of the library object.
1380 test -z "$libobj" && {
1381 func_basename "$srcfile"
1382 libobj="$func_basename_result"
1387 # Recognize several different file suffixes.
1388 # If the user specifies -o file.o, it is replaced with file.lo
1391 *.ada | *.adb | *.ads | *.asm | \
1392 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1393 *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
1394 func_xform "$libobj"
1395 libobj=$func_xform_result
1400 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1402 func_fatal_error "cannot determine name of library object from \`$libobj'"
1406 func_infer_tag $base_compile
1408 for arg in $later; do
1411 test "$build_libtool_libs" != yes && \
1412 func_fatal_configuration "can not build a shared library"
1418 build_libtool_libs=no
1435 func_quote_for_eval "$libobj"
1436 test "X$libobj" != "X$func_quote_for_eval_result" \
1437 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
1438 && func_warning "libobj name \`$libobj' may not contain shell special characters."
1439 func_dirname_and_basename "$obj" "/" ""
1440 objname="$func_basename_result"
1441 xdir="$func_dirname_result"
1442 lobj=${xdir}$objdir/$objname
1444 test -z "$base_compile" && \
1445 func_fatal_help "you must specify a compilation command"
1447 # Delete any leftover library objects.
1448 if test "$build_old_libs" = yes; then
1449 removelist="$obj $lobj $libobj ${libobj}T"
1451 removelist="$lobj $libobj ${libobj}T"
1454 # On Cygwin there's no "real" PIC flag so we must build both object types
1456 cygwin* | mingw* | pw32* | os2* | cegcc*)
1460 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1461 # non-PIC code in shared libraries is not supported
1465 # Calculate the filename of the output object if compiler does
1466 # not support -o with -c
1467 if test "$compiler_c_o" = no; then
1468 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
1469 lockfile="$output_obj.lock"
1476 # Lock this critical section if it is needed
1477 # We use this script file to make the link, it avoids creating a new file
1478 if test "$need_locks" = yes; then
1479 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1480 func_echo "Waiting for $lockfile to be removed"
1483 elif test "$need_locks" = warn; then
1484 if test -f "$lockfile"; then
1486 *** ERROR, $lockfile exists and contains:
1487 `cat $lockfile 2>/dev/null`
1489 This indicates that another process is trying to use the same
1490 temporary object file, and libtool could not work around it because
1491 your compiler does not support \`-c' and \`-o' together. If you
1492 repeat this compilation, it may succeed, by chance, but you had better
1493 avoid parallel builds (make -j) in this platform, or get a better
1496 $opt_dry_run || $RM $removelist
1499 removelist="$removelist $output_obj"
1500 $ECHO "$srcfile" > "$lockfile"
1503 $opt_dry_run || $RM $removelist
1504 removelist="$removelist $lockfile"
1505 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1507 if test -n "$fix_srcfile_path"; then
1508 eval "srcfile=\"$fix_srcfile_path\""
1510 func_quote_for_eval "$srcfile"
1511 qsrcfile=$func_quote_for_eval_result
1513 # Only build a PIC object if we are building libtool libraries.
1514 if test "$build_libtool_libs" = yes; then
1515 # Without this assignment, base_compile gets emptied.
1516 fbsd_hideous_sh_bug=$base_compile
1518 if test "$pic_mode" != no; then
1519 command="$base_compile $qsrcfile $pic_flag"
1521 # Don't build PIC code
1522 command="$base_compile $qsrcfile"
1525 func_mkdir_p "$xdir$objdir"
1527 if test -z "$output_obj"; then
1528 # Place PIC objects in $objdir
1529 command="$command -o $lobj"
1532 func_show_eval_locale "$command" \
1533 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1535 if test "$need_locks" = warn &&
1536 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1538 *** ERROR, $lockfile contains:
1539 `cat $lockfile 2>/dev/null`
1541 but it should contain:
1544 This indicates that another process is trying to use the same
1545 temporary object file, and libtool could not work around it because
1546 your compiler does not support \`-c' and \`-o' together. If you
1547 repeat this compilation, it may succeed, by chance, but you had better
1548 avoid parallel builds (make -j) in this platform, or get a better
1551 $opt_dry_run || $RM $removelist
1555 # Just move the object if needed, then go on to compile the next one
1556 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1557 func_show_eval '$MV "$output_obj" "$lobj"' \
1558 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1561 # Allow error messages only from the first compilation.
1562 if test "$suppress_opt" = yes; then
1563 suppress_output=' >/dev/null 2>&1'
1567 # Only build a position-dependent object if we build old libraries.
1568 if test "$build_old_libs" = yes; then
1569 if test "$pic_mode" != yes; then
1570 # Don't build PIC code
1571 command="$base_compile $qsrcfile$pie_flag"
1573 command="$base_compile $qsrcfile $pic_flag"
1575 if test "$compiler_c_o" = yes; then
1576 command="$command -o $obj"
1579 # Suppress compiler output if we already did a PIC compilation.
1580 command="$command$suppress_output"
1581 func_show_eval_locale "$command" \
1582 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1584 if test "$need_locks" = warn &&
1585 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1587 *** ERROR, $lockfile contains:
1588 `cat $lockfile 2>/dev/null`
1590 but it should contain:
1593 This indicates that another process is trying to use the same
1594 temporary object file, and libtool could not work around it because
1595 your compiler does not support \`-c' and \`-o' together. If you
1596 repeat this compilation, it may succeed, by chance, but you had better
1597 avoid parallel builds (make -j) in this platform, or get a better
1600 $opt_dry_run || $RM $removelist
1604 # Just move the object if needed
1605 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1606 func_show_eval '$MV "$output_obj" "$obj"' \
1607 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1612 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1614 # Unlock the critical section if it was locked
1615 if test "$need_locks" != no; then
1616 removelist=$lockfile
1625 test "$mode" = compile && func_mode_compile ${1+"$@"}
1630 # We need to display help for each of the modes.
1633 # Generic help is extracted from the usage comments
1634 # at the start of this file.
1640 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1642 Remove files from the build directory.
1644 RM is the name of the program to use to delete files associated with each FILE
1645 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1648 If FILE is a libtool library, object or program, all the files associated
1649 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1654 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1656 Compile a source file into a libtool library object.
1658 This mode accepts the following additional options:
1660 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
1661 -no-suppress do not suppress compiler output for multiple passes
1662 -prefer-pic try to building PIC objects only
1663 -prefer-non-pic try to building non-PIC objects only
1664 -shared do not build a \`.o' file suitable for static linking
1665 -static only build a \`.o' file suitable for static linking
1666 -Wc,FLAG pass FLAG directly to the compiler
1668 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1669 from the given SOURCEFILE.
1671 The output file name is determined by removing the directory component from
1672 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1673 library object suffix, \`.lo'."
1678 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1680 Automatically set library path, then run a program.
1682 This mode accepts the following additional options:
1684 -dlopen FILE add the directory containing FILE to the library path
1686 This mode sets the library path environment variable according to \`-dlopen'
1689 If any of the ARGS are libtool executable wrappers, then they are translated
1690 into their corresponding uninstalled binary, and any of their required library
1691 directories are added to the library path.
1693 Then, COMMAND is executed, with ARGS as arguments."
1698 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
1700 Complete the installation of libtool libraries.
1702 Each LIBDIR is a directory that contains libtool libraries.
1704 The commands that this mode executes may require superuser privileges. Use
1705 the \`--dry-run' option if you just want to see what would be executed."
1710 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
1712 Install executables or libraries.
1714 INSTALL-COMMAND is the installation command. The first component should be
1715 either the \`install' or \`cp' program.
1717 The following components of INSTALL-COMMAND are treated specially:
1719 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
1721 The rest of the components are interpreted as arguments to that command (only
1722 BSD-compatible install options are recognized)."
1727 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
1729 Link object files or libraries together to form another library, or to
1730 create an executable program.
1732 LINK-COMMAND is a command using the C compiler that you would use to create
1733 a program from several object files.
1735 The following components of LINK-COMMAND are treated specially:
1737 -all-static do not do any dynamic linking at all
1738 -avoid-version do not add a version suffix if possible
1739 -bindir BINDIR specify path to binaries directory (for systems where
1740 libraries must be found in the PATH setting at runtime)
1741 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
1742 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
1743 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
1744 -export-symbols SYMFILE
1745 try to export only the symbols listed in SYMFILE
1746 -export-symbols-regex REGEX
1747 try to export only the symbols matching REGEX
1748 -LLIBDIR search LIBDIR for required installed libraries
1749 -lNAME OUTPUT-FILE requires the installed library libNAME
1750 -module build a library that can dlopened
1751 -no-fast-install disable the fast-install mode
1752 -no-install link a not-installable executable
1753 -no-undefined declare that a library does not refer to external symbols
1754 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
1755 -objectlist FILE Use a list of object files found in FILE to specify objects
1756 -precious-files-regex REGEX
1757 don't remove output files matching REGEX
1758 -release RELEASE specify package release information
1759 -rpath LIBDIR the created library will eventually be installed in LIBDIR
1760 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
1761 -shared only do dynamic linking of libtool libraries
1762 -shrext SUFFIX override the standard shared library file extension
1763 -static do not do any dynamic linking of uninstalled libtool libraries
1764 -static-libtool-libs
1765 do not do any dynamic linking of libtool libraries
1766 -version-info CURRENT[:REVISION[:AGE]]
1767 specify library version info [each variable defaults to 0]
1768 -weak LIBNAME declare that the target provides the LIBNAME interface
1770 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
1772 -Xlinker FLAG pass linker-specific FLAG directly to the linker
1773 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
1775 All other options (arguments beginning with \`-') are ignored.
1777 Every other argument is treated as a filename. Files ending in \`.la' are
1778 treated as uninstalled libtool libraries, other files are standard or library
1781 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
1782 only library objects (\`.lo' files) may be specified, and \`-rpath' is
1783 required, except when creating a convenience library.
1785 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
1786 using \`ar' and \`ranlib', or on Windows using \`lib'.
1788 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
1789 is created, otherwise an executable program is created."
1794 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
1796 Remove libraries from an installation directory.
1798 RM is the name of the program to use to delete files associated with each FILE
1799 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
1802 If FILE is a libtool library, all the files associated with it are deleted.
1803 Otherwise, only FILE itself is deleted using RM."
1807 func_fatal_help "invalid operation mode \`$mode'"
1812 $ECHO "Try \`$progname --help' for more information about other modes."
1815 # Now that we've collected a possible --mode arg, show help if necessary
1817 if test "$opt_help" = :; then
1822 for mode in compile link execute install finish uninstall clean; do
1825 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
1828 for mode in compile link execute install finish uninstall clean; do
1834 /^When reporting/,/^Report/{
1839 /information about other modes/d
1840 /more detailed .*MODE/d
1841 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
1847 # func_mode_execute arg...
1848 func_mode_execute ()
1851 # The first argument is the command name.
1854 func_fatal_help "you must specify a COMMAND"
1856 # Handle -dlopen flags immediately.
1857 for file in $execute_dlfiles; do
1859 || func_fatal_help "\`$file' is not a file"
1864 # Check to see that this really is a libtool archive.
1865 func_lalib_unsafe_p "$file" \
1866 || func_fatal_help "\`$lib' is not a valid libtool archive"
1868 # Read the libtool library.
1873 # Skip this library if it cannot be dlopened.
1874 if test -z "$dlname"; then
1875 # Warn if it was a shared library.
1876 test -n "$library_names" && \
1877 func_warning "\`$file' was not linked with \`-export-dynamic'"
1881 func_dirname "$file" "" "."
1882 dir="$func_dirname_result"
1884 if test -f "$dir/$objdir/$dlname"; then
1887 if test ! -f "$dir/$dlname"; then
1888 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
1894 # Just add the directory containing the .lo file.
1895 func_dirname "$file" "" "."
1896 dir="$func_dirname_result"
1900 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
1905 # Get the absolute pathname.
1906 absdir=`cd "$dir" && pwd`
1907 test -n "$absdir" && dir="$absdir"
1909 # Now add the directory to shlibpath_var.
1910 if eval test -z \"\$$shlibpath_var\"; then
1911 eval $shlibpath_var=\$dir
1913 eval $shlibpath_var=\$dir:\$$shlibpath_var
1917 # This variable tells wrapper scripts just to set shlibpath_var
1918 # rather than running their programs.
1919 libtool_execute_magic="$magic"
1921 # Check if any of the arguments is a wrapper script.
1926 -* | *.la | *.lo ) ;;
1928 # Do a test to see if this is really a libtool program.
1929 if func_ltwrapper_script_p "$file"; then
1931 # Transform arg to wrapped name.
1932 file="$progdir/$program"
1933 elif func_ltwrapper_executable_p "$file"; then
1934 func_ltwrapper_scriptname "$file"
1935 func_source "$func_ltwrapper_scriptname_result"
1936 # Transform arg to wrapped name.
1937 file="$progdir/$program"
1941 # Quote arguments (to preserve shell metacharacters).
1942 func_quote_for_eval "$file"
1943 args="$args $func_quote_for_eval_result"
1946 if test "X$opt_dry_run" = Xfalse; then
1947 if test -n "$shlibpath_var"; then
1948 # Export the shlibpath_var.
1949 eval "export $shlibpath_var"
1952 # Restore saved environment variables
1953 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
1955 eval "if test \"\${save_$lt_var+set}\" = set; then
1956 $lt_var=\$save_$lt_var; export $lt_var
1962 # Now prepare to actually exec the command.
1963 exec_cmd="\$cmd$args"
1965 # Display what would be done.
1966 if test -n "$shlibpath_var"; then
1967 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
1968 echo "export $shlibpath_var"
1975 test "$mode" = execute && func_mode_execute ${1+"$@"}
1978 # func_mode_finish arg...
1985 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
1988 libdirs="$libdirs $dir"
1991 for libdir in $libdirs; do
1992 if test -n "$finish_cmds"; then
1993 # Do each command in the finish commands.
1994 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
1997 if test -n "$finish_eval"; then
1998 # Do the single finish_eval.
1999 eval cmds=\"$finish_eval\"
2000 $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2006 # Exit here if they wanted silent mode.
2007 $opt_silent && exit $EXIT_SUCCESS
2009 echo "----------------------------------------------------------------------"
2010 echo "Libraries have been installed in:"
2011 for libdir in $libdirs; do
2015 echo "If you ever happen to want to link against installed libraries"
2016 echo "in a given directory, LIBDIR, you must either use libtool, and"
2017 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2018 echo "flag during linking and do at least one of the following:"
2019 if test -n "$shlibpath_var"; then
2020 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2021 echo " during execution"
2023 if test -n "$runpath_var"; then
2024 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2025 echo " during linking"
2027 if test -n "$hardcode_libdir_flag_spec"; then
2029 eval "flag=\"$hardcode_libdir_flag_spec\""
2031 $ECHO " - use the \`$flag' linker flag"
2033 if test -n "$admincmds"; then
2034 $ECHO " - have your system administrator run these commands:$admincmds"
2036 if test -f /etc/ld.so.conf; then
2037 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2041 echo "See any operating system documentation about shared libraries for"
2043 solaris2.[6789]|solaris2.1[0-9])
2044 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2048 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2051 echo "----------------------------------------------------------------------"
2055 test "$mode" = finish && func_mode_finish ${1+"$@"}
2058 # func_mode_install arg...
2059 func_mode_install ()
2062 # There may be an optional sh(1) argument at the beginning of
2063 # install_prog (especially on Windows NT).
2064 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2065 # Allow the use of GNU shtool's install command.
2066 case $nonopt in *shtool*) :;; *) false;; esac; then
2067 # Aesthetically quote it.
2068 func_quote_for_eval "$nonopt"
2069 install_prog="$func_quote_for_eval_result "
2077 # The real first argument should be the name of the installation program.
2078 # Aesthetically quote it.
2079 func_quote_for_eval "$arg"
2080 install_prog="$install_prog$func_quote_for_eval_result"
2081 install_shared_prog=$install_prog
2082 case " $install_prog " in
2083 *[\\\ /]cp\ *) install_cp=: ;;
2084 *) install_cp=false ;;
2087 # We need to accept at least all the BSD install flags.
2099 if test -n "$dest"; then
2100 files="$files $dest"
2108 if $install_cp; then :; else
2122 # If the previous option needed an argument, then skip it.
2123 if test -n "$prev"; then
2124 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2125 arg2=$install_override_mode
2136 # Aesthetically quote the argument.
2137 func_quote_for_eval "$arg"
2138 install_prog="$install_prog $func_quote_for_eval_result"
2139 if test -n "$arg2"; then
2140 func_quote_for_eval "$arg2"
2142 install_shared_prog="$install_shared_prog $func_quote_for_eval_result"
2145 test -z "$install_prog" && \
2146 func_fatal_help "you must specify an install program"
2148 test -n "$prev" && \
2149 func_fatal_help "the \`$prev' option requires an argument"
2151 if test -n "$install_override_mode" && $no_mode; then
2152 if $install_cp; then :; else
2153 func_quote_for_eval "$install_override_mode"
2154 install_shared_prog="$install_shared_prog -m $func_quote_for_eval_result"
2158 if test -z "$files"; then
2159 if test -z "$dest"; then
2160 func_fatal_help "no file or destination specified"
2162 func_fatal_help "you must specify a destination"
2166 # Strip any trailing slash from the destination.
2167 func_stripname '' '/' "$dest"
2168 dest=$func_stripname_result
2170 # Check to see that the destination is a directory.
2171 test -d "$dest" && isdir=yes
2172 if test "$isdir" = yes; then
2176 func_dirname_and_basename "$dest" "" "."
2177 destdir="$func_dirname_result"
2178 destname="$func_basename_result"
2180 # Not a directory, so check to see that there is only one file specified.
2181 set dummy $files; shift
2182 test "$#" -gt 1 && \
2183 func_fatal_help "\`$dest' is not a directory"
2186 [\\/]* | [A-Za-z]:[\\/]*) ;;
2188 for file in $files; do
2192 func_fatal_help "\`$destdir' must be an absolute directory name"
2199 # This variable tells wrapper scripts just to set variables rather
2200 # than running their programs.
2201 libtool_install_magic="$magic"
2206 for file in $files; do
2208 # Do each installation.
2211 # Do the static libraries later.
2212 staticlibs="$staticlibs $file"
2216 # Check to see that this really is a libtool archive.
2217 func_lalib_unsafe_p "$file" \
2218 || func_fatal_help "\`$file' is not a valid libtool archive"
2225 # Add the libdir to current_libdirs if it is the destination.
2226 if test "X$destdir" = "X$libdir"; then
2227 case "$current_libdirs " in
2229 *) current_libdirs="$current_libdirs $libdir" ;;
2232 # Note the libdir as a future libdir.
2233 case "$future_libdirs " in
2235 *) future_libdirs="$future_libdirs $libdir" ;;
2239 func_dirname "$file" "/" ""
2240 dir="$func_dirname_result"
2243 if test -n "$relink_command"; then
2244 # Determine the prefix the user has applied to our future dir.
2245 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2247 # Don't allow the user to place us outside of our expected
2248 # location b/c this prevents finding dependent libraries that
2249 # are installed to the same prefix.
2250 # At present, this check doesn't affect windows .dll's that
2251 # are installed into $libdir/../bin (currently, that works fine)
2252 # but it's something to keep an eye on.
2253 test "$inst_prefix_dir" = "$destdir" && \
2254 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2256 if test -n "$inst_prefix_dir"; then
2257 # Stick the inst_prefix_dir data into the link command.
2258 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2260 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2263 func_warning "relinking \`$file'"
2264 func_show_eval "$relink_command" \
2265 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2268 # See the names of the shared library.
2269 set dummy $library_names; shift
2270 if test -n "$1"; then
2275 test -n "$relink_command" && srcname="$realname"T
2277 # Install the shared library and build the symlinks.
2278 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2282 cygwin* | mingw* | pw32* | cegcc*)
2290 if test -n "$tstripme" && test -n "$striplib"; then
2291 func_show_eval "$striplib $destdir/$realname" 'exit $?'
2294 if test "$#" -gt 0; then
2295 # Delete the old symlinks, and create new ones.
2296 # Try `ln -sf' first, because the `ln' binary might depend on
2297 # the symlink we replace! Solaris /bin/ln does not understand -f,
2298 # so we also need to try rm && ln -s.
2301 test "$linkname" != "$realname" \
2302 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2306 # Do each command in the postinstall commands.
2307 lib="$destdir/$realname"
2308 func_execute_cmds "$postinstall_cmds" 'exit $?'
2311 # Install the pseudo-library for information purposes.
2312 func_basename "$file"
2313 name="$func_basename_result"
2314 instname="$dir/$name"i
2315 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2317 # Maybe install the static library, too.
2318 test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2322 # Install (i.e. copy) a libtool object.
2324 # Figure out destination file name, if it wasn't already specified.
2325 if test -n "$destname"; then
2326 destfile="$destdir/$destname"
2328 func_basename "$file"
2329 destfile="$func_basename_result"
2330 destfile="$destdir/$destfile"
2333 # Deduce the name of the destination old-style object file.
2336 func_lo2o "$destfile"
2337 staticdest=$func_lo2o_result
2340 staticdest="$destfile"
2344 func_fatal_help "cannot copy a libtool object to \`$destfile'"
2348 # Install the libtool object if requested.
2349 test -n "$destfile" && \
2350 func_show_eval "$install_prog $file $destfile" 'exit $?'
2352 # Install the old object if enabled.
2353 if test "$build_old_libs" = yes; then
2354 # Deduce the name of the old-style object file.
2356 staticobj=$func_lo2o_result
2357 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2363 # Figure out destination file name, if it wasn't already specified.
2364 if test -n "$destname"; then
2365 destfile="$destdir/$destname"
2367 func_basename "$file"
2368 destfile="$func_basename_result"
2369 destfile="$destdir/$destfile"
2372 # If the file is missing, and there is a .exe on the end, strip it
2373 # because it is most likely a libtool script we actually want to
2378 if test ! -f "$file"; then
2379 func_stripname '' '.exe' "$file"
2380 file=$func_stripname_result
2386 # Do a test to see if this is really a libtool program.
2389 if func_ltwrapper_executable_p "$file"; then
2390 func_ltwrapper_scriptname "$file"
2391 wrapper=$func_ltwrapper_scriptname_result
2393 func_stripname '' '.exe' "$file"
2394 wrapper=$func_stripname_result
2401 if func_ltwrapper_script_p "$wrapper"; then
2405 func_source "$wrapper"
2407 # Check the variables that should have been set.
2408 test -z "$generated_by_libtool_version" && \
2409 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2412 for lib in $notinst_deplibs; do
2413 # Check to see that each library is installed.
2415 if test -f "$lib"; then
2418 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
2419 if test -n "$libdir" && test ! -f "$libfile"; then
2420 func_warning "\`$lib' has not been installed in \`$libdir'"
2426 func_source "$wrapper"
2429 if test "$fast_install" = no && test -n "$relink_command"; then
2431 if test "$finalize" = yes; then
2432 tmpdir=`func_mktempdir`
2433 func_basename "$file$stripped_ext"
2434 file="$func_basename_result"
2435 outputname="$tmpdir/$file"
2436 # Replace the output file specification.
2437 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
2440 func_quote_for_expand "$relink_command"
2441 eval "func_echo $func_quote_for_expand_result"
2443 if eval "$relink_command"; then :
2445 func_error "error: relink \`$file' with the above command before installing it"
2446 $opt_dry_run || ${RM}r "$tmpdir"
2451 func_warning "cannot relink \`$file'"
2455 # Install the binary that we compiled earlier.
2456 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
2460 # remove .exe since cygwin /usr/bin/install will append another
2462 case $install_prog,$host in
2463 */usr/bin/install*,*cygwin*)
2464 case $file:$destfile in
2469 destfile=$destfile.exe
2472 func_stripname '' '.exe' "$destfile"
2473 destfile=$func_stripname_result
2478 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2479 $opt_dry_run || if test -n "$outputname"; then
2486 for file in $staticlibs; do
2487 func_basename "$file"
2488 name="$func_basename_result"
2490 # Set up the ranlib parameters.
2491 oldlib="$destdir/$name"
2493 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2495 if test -n "$stripme" && test -n "$old_striplib"; then
2496 func_show_eval "$old_striplib $oldlib" 'exit $?'
2499 # Do each command in the postinstall commands.
2500 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2503 test -n "$future_libdirs" && \
2504 func_warning "remember to run \`$progname --finish$future_libdirs'"
2506 if test -n "$current_libdirs" && $opt_finish; then
2507 # Maybe just do a dry run.
2508 $opt_dry_run && current_libdirs=" -n$current_libdirs"
2509 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2515 test "$mode" = install && func_mode_install ${1+"$@"}
2518 # func_generate_dlsyms outputname originator pic_p
2519 # Extract symbols from dlprefiles and create ${outputname}S.o with
2520 # a dlpreopen symbol table.
2521 func_generate_dlsyms ()
2527 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2530 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2531 if test -n "$NM" && test -n "$global_symbol_pipe"; then
2532 my_dlsyms="${my_outputname}S.c"
2534 func_error "not configured to extract global symbols from dlpreopened files"
2538 if test -n "$my_dlsyms"; then
2542 # Discover the nlist of each of the dlfiles.
2543 nlist="$output_objdir/${my_outputname}.nm"
2545 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2547 # Parse the name list into a source file.
2548 func_verbose "creating $output_objdir/$my_dlsyms"
2550 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2551 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2552 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2558 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
2559 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
2562 /* External symbol declarations for the compiler. */\
2565 if test "$dlself" = yes; then
2566 func_verbose "generating symbol list for \`$output'"
2568 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2570 # Add our own program objects to the symbol list.
2571 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
2572 for progfile in $progfiles; do
2573 func_verbose "extracting global C symbols from \`$progfile'"
2574 $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2577 if test -n "$exclude_expsyms"; then
2579 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2580 $MV "$nlist"T "$nlist"
2584 if test -n "$export_symbols_regex"; then
2586 $EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T
2587 $MV "$nlist"T "$nlist"
2591 # Prepare the list of exported symbols
2592 if test -z "$export_symbols"; then
2593 export_symbols="$output_objdir/$outputname.exp"
2596 ${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' < "$nlist" > "$export_symbols"
2598 *cygwin* | *mingw* | *cegcc* )
2599 echo EXPORTS > "$output_objdir/$outputname.def"
2600 cat "$export_symbols" >> "$output_objdir/$outputname.def"
2606 ${SED} -e 's/\([].[*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp"
2607 $GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T
2608 $MV "$nlist"T "$nlist"
2610 *cygwin* | *mingw* | *cegcc* )
2611 echo EXPORTS > "$output_objdir/$outputname.def"
2612 cat "$nlist" >> "$output_objdir/$outputname.def"
2619 for dlprefile in $dlprefiles; do
2620 func_verbose "extracting global C symbols from \`$dlprefile'"
2621 func_basename "$dlprefile"
2622 name="$func_basename_result"
2624 $ECHO ": $name " >> "$nlist"
2625 eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2630 # Make sure we have at least an empty file.
2631 test -f "$nlist" || : > "$nlist"
2633 if test -n "$exclude_expsyms"; then
2634 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2635 $MV "$nlist"T "$nlist"
2638 # Try sorting and uniquifying the output.
2639 if $GREP -v "^: " < "$nlist" |
2640 if sort -k 3 </dev/null >/dev/null 2>&1; then
2645 uniq > "$nlist"S; then
2648 $GREP -v "^: " < "$nlist" > "$nlist"S
2651 if test -f "$nlist"S; then
2652 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2654 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
2657 echo >> "$output_objdir/$my_dlsyms" "\
2659 /* The mapping between symbol names and symbols. */
2666 *cygwin* | *mingw* | *cegcc* )
2667 echo >> "$output_objdir/$my_dlsyms" "\
2668 /* DATA imports from DLLs on WIN32 con't be const, because
2669 runtime relocations are performed -- see ld's documentation
2670 on pseudo-relocs. */"
2673 echo >> "$output_objdir/$my_dlsyms" "\
2674 /* This system does not cope well with relocations in const data */"
2677 lt_dlsym_const=const ;;
2680 echo >> "$output_objdir/$my_dlsyms" "\
2681 extern $lt_dlsym_const lt_dlsymlist
2682 lt_${my_prefix}_LTX_preloaded_symbols[];
2683 $lt_dlsym_const lt_dlsymlist
2684 lt_${my_prefix}_LTX_preloaded_symbols[] =
2686 { \"$my_originator\", (void *) 0 },"
2688 case $need_lib_prefix in
2690 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2693 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2696 echo >> "$output_objdir/$my_dlsyms" "\
2700 /* This works around a problem in FreeBSD linker */
2701 #ifdef FREEBSD_WORKAROUND
2702 static const void *lt_preloaded_setup() {
2703 return lt_${my_prefix}_LTX_preloaded_symbols;
2713 pic_flag_for_symtable=
2714 case "$compile_command " in
2718 # compiling the symbol table file with pic_flag works around
2719 # a FreeBSD bug that causes programs to crash when -lm is
2720 # linked before any other PIC object. But we must not use
2721 # pic_flag when linking with -static. The problem exists in
2722 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2723 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2724 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2726 pic_flag_for_symtable=" $pic_flag" ;;
2728 if test "X$my_pic_p" != Xno; then
2729 pic_flag_for_symtable=" $pic_flag"
2736 for arg in $LTCFLAGS; do
2738 -pie | -fpie | -fPIE) ;;
2739 *) symtab_cflags="$symtab_cflags $arg" ;;
2743 # Now compile the dynamic symbol file.
2744 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
2746 # Clean up the generated files.
2747 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
2749 # Transform the symbol file into the correct name.
2750 symfileobj="$output_objdir/${my_outputname}S.$objext"
2752 *cygwin* | *mingw* | *cegcc* )
2753 if test -f "$output_objdir/$my_outputname.def"; then
2754 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2755 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
2757 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2758 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2762 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2763 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
2768 func_fatal_error "unknown suffix for \`$my_dlsyms'"
2772 # We keep going just in case the user didn't refer to
2773 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
2774 # really was required.
2776 # Nullify the symbol file.
2777 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
2778 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
2782 # func_win32_libid arg
2783 # return the library type of file 'arg'
2785 # Need a lot of goo to handle *both* DLLs and import libs
2786 # Has to be a shell function in order to 'eat' the argument
2787 # that is supplied when $file_magic_command is called.
2788 # Despite the name, also deal with 64 bit binaries.
2792 win32_libid_type="unknown"
2793 win32_fileres=`file -L $1 2>/dev/null`
2794 case $win32_fileres in
2795 *ar\ archive\ import\ library*) # definitely import
2796 win32_libid_type="x86 archive import"
2798 *ar\ archive*) # could be an import, or static
2799 if $OBJDUMP -f "$1" | $SED -e '10q' 2>/dev/null |
2800 $EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
2801 win32_nmres=`$NM -f posix -A "$1" |
2810 case $win32_nmres in
2811 import*) win32_libid_type="x86 archive import";;
2812 *) win32_libid_type="x86 archive static";;
2817 win32_libid_type="x86 DLL"
2819 *executable*) # but shell scripts are "executable" too...
2820 case $win32_fileres in
2821 *MS\ Windows\ PE\ Intel*)
2822 win32_libid_type="x86 DLL"
2827 $ECHO "$win32_libid_type"
2832 # func_extract_an_archive dir oldlib
2833 func_extract_an_archive ()
2836 f_ex_an_ar_dir="$1"; shift
2837 f_ex_an_ar_oldlib="$1"
2838 if test "$lock_old_archive_extraction" = yes; then
2839 lockfile=$f_ex_an_ar_oldlib.lock
2840 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2841 func_echo "Waiting for $lockfile to be removed"
2845 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
2846 'stat=$?; rm -f "$lockfile"; exit $stat'
2847 if test "$lock_old_archive_extraction" = yes; then
2848 $opt_dry_run || rm -f "$lockfile"
2850 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
2853 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
2858 # func_extract_archives gentop oldlib ...
2859 func_extract_archives ()
2862 my_gentop="$1"; shift
2863 my_oldlibs=${1+"$@"}
2869 for my_xlib in $my_oldlibs; do
2870 # Extract the objects.
2872 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
2873 *) my_xabs=`pwd`"/$my_xlib" ;;
2875 func_basename "$my_xlib"
2876 my_xlib="$func_basename_result"
2879 case " $extracted_archives " in
2881 func_arith $extracted_serial + 1
2882 extracted_serial=$func_arith_result
2883 my_xlib_u=lt$extracted_serial-$my_xlib ;;
2887 extracted_archives="$extracted_archives $my_xlib_u"
2888 my_xdir="$my_gentop/$my_xlib_u"
2890 func_mkdir_p "$my_xdir"
2894 func_verbose "Extracting $my_xabs"
2895 # Do not bother doing anything if just a dry run
2897 darwin_orig_dir=`pwd`
2898 cd $my_xdir || exit $?
2899 darwin_archive=$my_xabs
2901 darwin_base_archive=`basename "$darwin_archive"`
2902 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
2903 if test -n "$darwin_arches"; then
2904 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
2906 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
2907 for darwin_arch in $darwin_arches ; do
2908 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2909 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
2910 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
2911 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
2913 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
2914 done # $darwin_arches
2915 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
2916 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
2919 for darwin_file in $darwin_filelist; do
2920 darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
2921 $LIPO -create -output "$darwin_file" $darwin_files
2922 done # $darwin_filelist
2924 cd "$darwin_orig_dir"
2927 func_extract_an_archive "$my_xdir" "$my_xabs"
2932 func_extract_an_archive "$my_xdir" "$my_xabs"
2935 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
2938 func_extract_archives_result="$my_oldobjs"
2942 # func_emit_wrapper [arg=no]
2944 # Emit a libtool wrapper script on stdout.
2945 # Don't directly open a file because we may want to
2946 # incorporate the script contents within a cygwin/mingw
2947 # wrapper executable. Must ONLY be called from within
2948 # func_mode_link because it depends on a number of variables
2951 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
2952 # variable will take. If 'yes', then the emitted script
2953 # will assume that the directory in which it is stored is
2954 # the $objdir directory. This is a cygwin/mingw-specific
2956 func_emit_wrapper ()
2958 func_emit_wrapper_arg1=${1-no}
2963 # $output - temporary wrapper script for $objdir/$outputname
2964 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
2966 # The $output program cannot be directly executed until all the libtool
2967 # libraries that it depends on are installed.
2969 # This wrapper script should never be moved out of the build directory.
2970 # If it is, it will not operate correctly.
2972 # Sed substitution that helps us do robust quoting. It backslashifies
2973 # metacharacters that are still active within double-quoted strings.
2974 sed_quote_subst='$sed_quote_subst'
2976 # Be Bourne compatible
2977 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
2980 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
2981 # is contrary to our usage. Disable this feature.
2982 alias -g '\${1+\"\$@\"}'='\"\$@\"'
2983 setopt NO_GLOB_SUBST
2985 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
2987 BIN_SH=xpg4; export BIN_SH # for Tru64
2988 DUALCASE=1; export DUALCASE # for MKS sh
2990 # The HP-UX ksh and POSIX shell print the target directory to stdout
2992 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
2994 relink_command=\"$relink_command\"
2996 # This environment variable determines our operation mode.
2997 if test \"\$libtool_install_magic\" = \"$magic\"; then
2998 # install mode needs the following variables:
2999 generated_by_libtool_version='$macro_version'
3000 notinst_deplibs='$notinst_deplibs'
3002 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3003 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3006 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3009 # A function that is used when there is no print builtin or printf.
3010 func_fallback_echo ()
3012 eval 'cat <<_LTECHO_EOF
3019 # Find the directory that this script lives in.
3020 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3021 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3023 # Follow symbolic links until we get to the real thisdir.
3024 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3025 while test -n \"\$file\"; do
3026 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3028 # If there was a directory component, then change thisdir.
3029 if test \"x\$destdir\" != \"x\$file\"; then
3030 case \"\$destdir\" in
3031 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3032 *) thisdir=\"\$thisdir/\$destdir\" ;;
3036 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3037 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3040 # Usually 'no', except on cygwin/mingw when embedded into
3042 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3043 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3044 # special case for '.'
3045 if test \"\$thisdir\" = \".\"; then
3048 # remove .libs from thisdir
3049 case \"\$thisdir\" in
3050 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3051 $objdir ) thisdir=. ;;
3055 # Try to get the absolute directory name.
3056 absdir=\`cd \"\$thisdir\" && pwd\`
3057 test -n \"\$absdir\" && thisdir=\"\$absdir\"
3060 if test "$fast_install" = yes; then
3062 program=lt-'$outputname'$exeext
3063 progdir=\"\$thisdir/$objdir\"
3065 if test ! -f \"\$progdir/\$program\" ||
3066 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3067 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3069 file=\"\$\$-\$program\"
3071 if test ! -d \"\$progdir\"; then
3072 $MKDIR \"\$progdir\"
3074 $RM \"\$progdir/\$file\"
3079 # relink executable if necessary
3080 if test -n \"\$relink_command\"; then
3081 if relink_command_output=\`eval \"\$relink_command\" 2>&1\`; then :
3083 $ECHO \"\$relink_command_output\" >&2
3084 $RM \"\$progdir/\$file\"
3089 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3090 { $RM \"\$progdir/\$program\";
3091 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3092 $RM \"\$progdir/\$file\"
3096 program='$outputname'
3097 progdir=\"\$thisdir/$objdir\"
3103 if test -f \"\$progdir/\$program\"; then"
3105 # Export our shlibpath_var if we have one.
3106 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3108 # Add our own library path to $shlibpath_var
3109 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3111 # Some systems cannot cope with colon-terminated $shlibpath_var
3112 # The second colon is a workaround for a bug in BeOS R4 sed
3113 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
3115 export $shlibpath_var
3119 # fixup the dll searchpath if we need to.
3120 if test -n "$dllsearchpath"; then
3122 # Add the dll search path components to the executable PATH
3123 PATH=$dllsearchpath:\$PATH
3128 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3129 # Run the actual program with our arguments.
3132 # Backslashes separate directories on plain windows
3133 *-*-mingw | *-*-os2* | *-cegcc*)
3135 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3141 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3146 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3150 # The program doesn't exist.
3151 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3152 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3153 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3161 # func_to_host_path arg
3163 # Convert paths to host format when used with build tools.
3164 # Intended for use with "native" mingw (where libtool itself
3165 # is running under the msys shell), or in the following cross-
3166 # build environments:
3168 # mingw (msys) mingw [e.g. native]
3171 # where wine is equipped with the `winepath' executable.
3172 # In the native mingw case, the (msys) shell automatically
3173 # converts paths for any non-msys applications it launches,
3174 # but that facility isn't available from inside the cwrapper.
3175 # Similar accommodations are necessary for $host mingw and
3176 # $build cygwin. Calling this function does no harm for other
3177 # $host/$build combinations not listed above.
3179 # ARG is the path (on $build) that should be converted to
3180 # the proper representation for $host. The result is stored
3181 # in $func_to_host_path_result.
3182 func_to_host_path ()
3184 func_to_host_path_result="$1"
3185 if test -n "$1"; then
3188 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3190 *mingw* ) # actually, msys
3191 # awkward: cmd appends spaces to result
3192 func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null |
3193 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3196 func_to_host_path_result=`cygpath -w "$1" |
3197 $SED -e "$lt_sed_naive_backslashify"`
3200 # Unfortunately, winepath does not exit with a non-zero
3201 # error code, so we are forced to check the contents of
3202 # stdout. On the other hand, if the command is not
3203 # found, the shell will set an exit code of 127 and print
3204 # *an error message* to stdout. So we must check for both
3205 # error code of zero AND non-empty stdout, which explains
3206 # the odd construction:
3207 func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3208 if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3209 func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" |
3210 $SED -e "$lt_sed_naive_backslashify"`
3212 # Allow warning below.
3213 func_to_host_path_result=
3217 if test -z "$func_to_host_path_result" ; then
3218 func_error "Could not determine host path corresponding to"
3220 func_error "Continuing, but uninstalled executables may not work."
3222 func_to_host_path_result="$1"
3228 # end: func_to_host_path
3230 # func_to_host_pathlist arg
3232 # Convert pathlists to host format when used with build tools.
3233 # See func_to_host_path(), above. This function supports the
3234 # following $build/$host combinations (but does no harm for
3235 # combinations not listed here):
3237 # mingw (msys) mingw [e.g. native]
3241 # Path separators are also converted from $build format to
3242 # $host format. If ARG begins or ends with a path separator
3243 # character, it is preserved (but converted to $host format)
3246 # ARG is a pathlist (on $build) that should be converted to
3247 # the proper representation on $host. The result is stored
3248 # in $func_to_host_pathlist_result.
3249 func_to_host_pathlist ()
3251 func_to_host_pathlist_result="$1"
3252 if test -n "$1"; then
3255 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3256 # Remove leading and trailing path separator characters from
3257 # ARG. msys behavior is inconsistent here, cygpath turns them
3258 # into '.;' and ';.', and winepath ignores them completely.
3259 func_stripname : : "$1"
3260 func_to_host_pathlist_tmp1=$func_stripname_result
3262 *mingw* ) # Actually, msys.
3263 # Awkward: cmd appends spaces to result.
3264 func_to_host_pathlist_result=`
3265 ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null |
3266 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
3269 func_to_host_pathlist_result=`cygpath -w -p "$func_to_host_pathlist_tmp1" |
3270 $SED -e "$lt_sed_naive_backslashify"`
3273 # unfortunately, winepath doesn't convert pathlists
3274 func_to_host_pathlist_result=""
3275 func_to_host_pathlist_oldIFS=$IFS
3277 for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3278 IFS=$func_to_host_pathlist_oldIFS
3279 if test -n "$func_to_host_pathlist_f" ; then
3280 func_to_host_path "$func_to_host_pathlist_f"
3281 if test -n "$func_to_host_path_result" ; then
3282 if test -z "$func_to_host_pathlist_result" ; then
3283 func_to_host_pathlist_result="$func_to_host_path_result"
3285 func_append func_to_host_pathlist_result ";$func_to_host_path_result"
3290 IFS=$func_to_host_pathlist_oldIFS
3293 if test -z "$func_to_host_pathlist_result"; then
3294 func_error "Could not determine the host path(s) corresponding to"
3296 func_error "Continuing, but uninstalled executables may not work."
3297 # Fallback. This may break if $1 contains DOS-style drive
3298 # specifications. The fix is not to complicate the expression
3299 # below, but for the user to provide a working wine installation
3300 # with winepath so that path translation in the cross-to-mingw
3301 # case works properly.
3302 lt_replace_pathsep_nix_to_dos="s|:|;|g"
3303 func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3304 $SED -e "$lt_replace_pathsep_nix_to_dos"`
3306 # Now, add the leading and trailing path separators back
3308 :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3312 *: ) func_append func_to_host_pathlist_result ";"
3319 # end: func_to_host_pathlist
3321 # func_emit_cwrapperexe_src
3322 # emit the source code for a wrapper executable on stdout
3323 # Must ONLY be called from within func_mode_link because
3324 # it depends on a number of variable set therein.
3325 func_emit_cwrapperexe_src ()
3329 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3330 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3332 The $output program cannot be directly executed until all the libtool
3333 libraries that it depends on are installed.
3335 This wrapper executable should never be moved out of the build directory.
3336 If it is, it will not operate correctly.
3338 Currently, it simply execs the wrapper *script* "$SHELL $output",
3339 but could eventually absorb all of the scripts functionality and
3340 exec $objdir/$outputname directly.
3345 # define _CRT_SECURE_NO_DEPRECATE 1
3350 # include <direct.h>
3351 # include <process.h>
3354 # include <unistd.h>
3355 # include <stdint.h>
3367 #include <sys/stat.h>
3369 /* declarations of non-ANSI functions */
3370 #if defined(__MINGW32__)
3371 # ifdef __STRICT_ANSI__
3372 int _putenv (const char *);
3374 #elif defined(__CYGWIN__)
3375 # ifdef __STRICT_ANSI__
3376 char *realpath (const char *, char *);
3377 int putenv (char *);
3378 int setenv (const char *, const char *, int);
3380 /* #elif defined (other platforms) ... */
3383 /* portability defines, excluding path handling macros */
3384 #if defined(_MSC_VER)
3385 # define setmode _setmode
3387 # define chmod _chmod
3388 # define getcwd _getcwd
3389 # define putenv _putenv
3390 # define S_IXUSR _S_IEXEC
3391 # ifndef _INTPTR_T_DEFINED
3392 # define _INTPTR_T_DEFINED
3393 # define intptr_t int
3395 #elif defined(__MINGW32__)
3396 # define setmode _setmode
3398 # define chmod _chmod
3399 # define getcwd _getcwd
3400 # define putenv _putenv
3401 #elif defined(__CYGWIN__)
3402 # define HAVE_SETENV
3403 # define FOPEN_WB "wb"
3404 /* #elif defined (other platforms) ... */
3407 #if defined(PATH_MAX)
3408 # define LT_PATHMAX PATH_MAX
3409 #elif defined(MAXPATHLEN)
3410 # define LT_PATHMAX MAXPATHLEN
3412 # define LT_PATHMAX 1024
3422 /* path handling portability macros */
3423 #ifndef DIR_SEPARATOR
3424 # define DIR_SEPARATOR '/'
3425 # define PATH_SEPARATOR ':'
3428 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3430 # define HAVE_DOS_BASED_FILE_SYSTEM
3431 # define FOPEN_WB "wb"
3432 # ifndef DIR_SEPARATOR_2
3433 # define DIR_SEPARATOR_2 '\\'
3435 # ifndef PATH_SEPARATOR_2
3436 # define PATH_SEPARATOR_2 ';'
3440 #ifndef DIR_SEPARATOR_2
3441 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3442 #else /* DIR_SEPARATOR_2 */
3443 # define IS_DIR_SEPARATOR(ch) \
3444 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3445 #endif /* DIR_SEPARATOR_2 */
3447 #ifndef PATH_SEPARATOR_2
3448 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3449 #else /* PATH_SEPARATOR_2 */
3450 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3451 #endif /* PATH_SEPARATOR_2 */
3454 # define FOPEN_WB "w"
3457 # define _O_BINARY 0
3460 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
3461 #define XFREE(stale) do { \
3462 if (stale) { free ((void *) stale); stale = 0; } \
3465 #undef LTWRAPPER_DEBUGPRINTF
3466 #if defined LT_DEBUGWRAPPER
3467 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3469 ltwrapper_debugprintf (const char *fmt, ...)
3472 va_start (args, fmt);
3473 (void) vfprintf (stderr, fmt, args);
3477 # define LTWRAPPER_DEBUGPRINTF(args)
3480 const char *program_name = NULL;
3482 void *xmalloc (size_t num);
3483 char *xstrdup (const char *string);
3484 const char *base_name (const char *name);
3485 char *find_executable (const char *wrapper);
3486 char *chase_symlinks (const char *pathspec);
3487 int make_executable (const char *path);
3488 int check_executable (const char *path);
3489 char *strendzap (char *str, const char *pat);
3490 void lt_fatal (const char *message, ...);
3491 void lt_setenv (const char *name, const char *value);
3492 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3493 void lt_update_exe_path (const char *name, const char *value);
3494 void lt_update_lib_path (const char *name, const char *value);
3495 char **prepare_spawn (char **argv);
3496 void lt_dump_script (FILE *f);
3500 const char * MAGIC_EXE = "$magic_exe";
3501 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3504 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3505 func_to_host_pathlist "$temp_rpath"
3507 const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result";
3511 const char * LIB_PATH_VALUE = "";
3515 if test -n "$dllsearchpath"; then
3516 func_to_host_pathlist "$dllsearchpath:"
3518 const char * EXE_PATH_VARNAME = "PATH";
3519 const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result";
3523 const char * EXE_PATH_VARNAME = "";
3524 const char * EXE_PATH_VALUE = "";
3528 if test "$fast_install" = yes; then
3530 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3534 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3541 #define LTWRAPPER_OPTION_PREFIX "--lt-"
3542 #define LTWRAPPER_OPTION_PREFIX_LENGTH 5
3544 static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH;
3545 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3547 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
3550 main (int argc, char *argv[])
3555 char *actual_cwrapper_path;
3556 char *actual_cwrapper_name;
3559 intptr_t rval = 127;
3563 program_name = (char *) xstrdup (base_name (argv[0]));
3564 LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0]));
3565 LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3567 /* very simple arg parsing; don't want to rely on getopt */
3568 for (i = 1; i < argc; i++)
3570 if (strcmp (argv[i], dumpscript_opt) == 0)
3574 *mingw* | *cygwin* )
3575 # make stdout use "unix" line endings
3576 echo " setmode(1,_O_BINARY);"
3581 lt_dump_script (stdout);
3586 newargz = XMALLOC (char *, argc + 1);
3587 tmp_pathspec = find_executable (argv[0]);
3588 if (tmp_pathspec == NULL)
3589 lt_fatal ("Couldn't find %s", argv[0]);
3590 LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3593 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3594 LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3595 actual_cwrapper_path));
3596 XFREE (tmp_pathspec);
3598 actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3599 strendzap (actual_cwrapper_path, actual_cwrapper_name);
3601 /* wrapper name transforms */
3602 strendzap (actual_cwrapper_name, ".exe");
3603 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3604 XFREE (actual_cwrapper_name);
3605 actual_cwrapper_name = tmp_pathspec;
3608 /* target_name transforms -- use actual target program name; might have lt- prefix */
3609 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3610 strendzap (target_name, ".exe");
3611 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3612 XFREE (target_name);
3613 target_name = tmp_pathspec;
3616 LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3622 XMALLOC (char, (strlen (actual_cwrapper_path) +
3623 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3624 strcpy (newargz[0], actual_cwrapper_path);
3625 strcat (newargz[0], "$objdir");
3626 strcat (newargz[0], "/");
3630 /* stop here, and copy so we don't have to do this twice */
3631 tmp_pathspec = xstrdup (newargz[0]);
3633 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3634 strcat (newargz[0], actual_cwrapper_name);
3636 /* DO want the lt- prefix here if it exists, so use target_name */
3637 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3638 XFREE (tmp_pathspec);
3639 tmp_pathspec = NULL;
3647 while ((p = strchr (newargz[0], '\\')) != NULL)
3651 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3661 XFREE (target_name);
3662 XFREE (actual_cwrapper_path);
3663 XFREE (actual_cwrapper_name);
3665 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3666 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
3667 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3668 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3671 for (i = 1; i < argc; i++)
3673 if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
3675 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
3676 namespace, but it is not one of the ones we know about and
3677 have already dealt with, above (inluding dump-script), then
3678 report an error. Otherwise, targets might begin to believe
3679 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
3680 namespace. The first time any user complains about this, we'll
3681 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
3682 or a configure.ac-settable value.
3684 lt_fatal ("Unrecognized option in %s namespace: '%s'",
3685 ltwrapper_option_prefix, argv[i]);
3688 newargz[++newargc] = xstrdup (argv[i]);
3690 newargz[++newargc] = NULL;
3692 LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
3693 for (i = 0; i < newargc; i++)
3695 LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
3703 /* execv doesn't actually work on mingw as expected on unix */
3704 newargz = prepare_spawn (newargz);
3705 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
3708 /* failed to start process */
3709 LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
3717 execv (lt_argv_zero, newargz);
3718 return rval; /* =127, but avoids unused variable warning */
3727 xmalloc (size_t num)
3729 void *p = (void *) malloc (num);
3731 lt_fatal ("Memory exhausted");
3737 xstrdup (const char *string)
3739 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
3744 base_name (const char *name)
3748 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3749 /* Skip over the disk name in MSDOS pathnames. */
3750 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
3754 for (base = name; *name; name++)
3755 if (IS_DIR_SEPARATOR (*name))
3761 check_executable (const char *path)
3765 LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n",
3766 path ? (*path ? path : "EMPTY!") : "NULL!"));
3767 if ((!path) || (!*path))
3770 if ((stat (path, &st) >= 0)
3771 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
3778 make_executable (const char *path)
3783 LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n",
3784 path ? (*path ? path : "EMPTY!") : "NULL!"));
3785 if ((!path) || (!*path))
3788 if (stat (path, &st) >= 0)
3790 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
3795 /* Searches for the full path of the wrapper. Returns
3796 newly allocated full path name if found, NULL otherwise
3797 Does not chase symlinks, even on platforms that support them.
3800 find_executable (const char *wrapper)
3805 /* static buffer for getcwd */
3806 char tmp[LT_PATHMAX + 1];
3810 LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n",
3811 wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
3813 if ((wrapper == NULL) || (*wrapper == '\0'))
3816 /* Absolute path? */
3817 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3818 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
3820 concat_name = xstrdup (wrapper);
3821 if (check_executable (concat_name))
3823 XFREE (concat_name);
3828 if (IS_DIR_SEPARATOR (wrapper[0]))
3830 concat_name = xstrdup (wrapper);
3831 if (check_executable (concat_name))
3833 XFREE (concat_name);
3835 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
3839 for (p = wrapper; *p; p++)
3847 /* no slashes; search PATH */
3848 const char *path = getenv ("PATH");
3851 for (p = path; *p; p = p_next)
3855 for (q = p; *q; q++)
3856 if (IS_PATH_SEPARATOR (*q))
3859 p_next = (*q == '\0' ? q : q + 1);
3862 /* empty path: current directory */
3863 if (getcwd (tmp, LT_PATHMAX) == NULL)
3864 lt_fatal ("getcwd failed");
3865 tmp_len = strlen (tmp);
3867 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3868 memcpy (concat_name, tmp, tmp_len);
3869 concat_name[tmp_len] = '/';
3870 strcpy (concat_name + tmp_len + 1, wrapper);
3875 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
3876 memcpy (concat_name, p, p_len);
3877 concat_name[p_len] = '/';
3878 strcpy (concat_name + p_len + 1, wrapper);
3880 if (check_executable (concat_name))
3882 XFREE (concat_name);
3885 /* not found in PATH; assume curdir */
3887 /* Relative path | not found in path: prepend cwd */
3888 if (getcwd (tmp, LT_PATHMAX) == NULL)
3889 lt_fatal ("getcwd failed");
3890 tmp_len = strlen (tmp);
3891 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
3892 memcpy (concat_name, tmp, tmp_len);
3893 concat_name[tmp_len] = '/';
3894 strcpy (concat_name + tmp_len + 1, wrapper);
3896 if (check_executable (concat_name))
3898 XFREE (concat_name);
3903 chase_symlinks (const char *pathspec)
3906 return xstrdup (pathspec);
3908 char buf[LT_PATHMAX];
3910 char *tmp_pathspec = xstrdup (pathspec);
3912 int has_symlinks = 0;
3913 while (strlen (tmp_pathspec) && !has_symlinks)
3915 LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
3917 if (lstat (tmp_pathspec, &s) == 0)
3919 if (S_ISLNK (s.st_mode) != 0)
3925 /* search backwards for last DIR_SEPARATOR */
3926 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
3927 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3929 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
3931 /* no more DIR_SEPARATORS left */
3938 char *errstr = strerror (errno);
3939 lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
3942 XFREE (tmp_pathspec);
3946 return xstrdup (pathspec);
3949 tmp_pathspec = realpath (pathspec, buf);
3950 if (tmp_pathspec == 0)
3952 lt_fatal ("Could not follow symlinks for %s", pathspec);
3954 return xstrdup (tmp_pathspec);
3959 strendzap (char *str, const char *pat)
3963 assert (str != NULL);
3964 assert (pat != NULL);
3967 patlen = strlen (pat);
3971 str += len - patlen;
3972 if (strcmp (str, pat) == 0)
3979 lt_error_core (int exit_status, const char *mode,
3980 const char *message, va_list ap)
3982 fprintf (stderr, "%s: %s: ", program_name, mode);
3983 vfprintf (stderr, message, ap);
3984 fprintf (stderr, ".\n");
3986 if (exit_status >= 0)
3991 lt_fatal (const char *message, ...)
3994 va_start (ap, message);
3995 lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4000 lt_setenv (const char *name, const char *value)
4002 LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4003 (name ? name : "<NULL>"),
4004 (value ? value : "<NULL>")));
4007 /* always make a copy, for consistency with !HAVE_SETENV */
4008 char *str = xstrdup (value);
4009 setenv (name, str, 1);
4011 int len = strlen (name) + 1 + strlen (value) + 1;
4012 char *str = XMALLOC (char, len);
4013 sprintf (str, "%s=%s", name, value);
4014 if (putenv (str) != EXIT_SUCCESS)
4023 lt_extend_str (const char *orig_value, const char *add, int to_end)
4026 if (orig_value && *orig_value)
4028 int orig_value_len = strlen (orig_value);
4029 int add_len = strlen (add);
4030 new_value = XMALLOC (char, add_len + orig_value_len + 1);
4033 strcpy (new_value, orig_value);
4034 strcpy (new_value + orig_value_len, add);
4038 strcpy (new_value, add);
4039 strcpy (new_value + add_len, orig_value);
4044 new_value = xstrdup (add);
4050 lt_update_exe_path (const char *name, const char *value)
4052 LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4053 (name ? name : "<NULL>"),
4054 (value ? value : "<NULL>")));
4056 if (name && *name && value && *value)
4058 char *new_value = lt_extend_str (getenv (name), value, 0);
4059 /* some systems can't cope with a ':'-terminated path #' */
4060 int len = strlen (new_value);
4061 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4063 new_value[len-1] = '\0';
4065 lt_setenv (name, new_value);
4071 lt_update_lib_path (const char *name, const char *value)
4073 LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4074 (name ? name : "<NULL>"),
4075 (value ? value : "<NULL>")));
4077 if (name && *name && value && *value)
4079 char *new_value = lt_extend_str (getenv (name), value, 0);
4080 lt_setenv (name, new_value);
4090 /* Prepares an argument vector before calling spawn().
4091 Note that spawn() does not by itself call the command interpreter
4092 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4093 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4095 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4096 }) ? "cmd.exe" : "command.com").
4097 Instead it simply concatenates the arguments, separated by ' ', and calls
4098 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4099 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4101 - Space and tab are interpreted as delimiters. They are not treated as
4102 delimiters if they are surrounded by double quotes: "...".
4103 - Unescaped double quotes are removed from the input. Their only effect is
4104 that within double quotes, space and tab are treated like normal
4106 - Backslashes not followed by double quotes are not special.
4107 - But 2*n+1 backslashes followed by a double quote become
4108 n backslashes followed by a double quote (n >= 0):
4113 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4114 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
4116 prepare_spawn (char **argv)
4122 /* Count number of arguments. */
4123 for (argc = 0; argv[argc] != NULL; argc++)
4126 /* Allocate new argument vector. */
4127 new_argv = XMALLOC (char *, argc + 1);
4129 /* Put quoted arguments into the new argument vector. */
4130 for (i = 0; i < argc; i++)
4132 const char *string = argv[i];
4134 if (string[0] == '\0')
4135 new_argv[i] = xstrdup ("\"\"");
4136 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4138 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4140 unsigned int backslashes;
4142 char *quoted_string;
4149 for (s = string; *s != '\0'; s++)
4153 length += backslashes + 1;
4161 length += backslashes + 1;
4163 quoted_string = XMALLOC (char, length + 1);
4169 for (s = string; *s != '\0'; s++)
4175 for (j = backslashes + 1; j > 0; j--)
4187 for (j = backslashes; j > 0; j--)
4193 new_argv[i] = quoted_string;
4196 new_argv[i] = (char *) string;
4198 new_argv[argc] = NULL;
4207 void lt_dump_script (FILE* f)
4210 func_emit_wrapper yes |
4211 $SED -e 's/\([\\"]\)/\\\1/g' \
4212 -e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
4218 # end: func_emit_cwrapperexe_src
4220 # func_win32_import_lib_p ARG
4221 # True if ARG is an import lib, as indicated by $file_magic_cmd
4222 func_win32_import_lib_p ()
4225 case `eval "$file_magic_cmd \"\$1\" 2>/dev/null" | $SED -e 10q` in
4231 # func_mode_link arg...
4236 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4237 # It is impossible to link a dll without this setting, and
4238 # we shouldn't force the makefile maintainer to figure out
4239 # which system we are compiling for in order to pass an extra
4240 # flag for every libtool invocation.
4241 # allow_undefined=no
4243 # FIXME: Unfortunately, there are problems with the above when trying
4244 # to make a dll which has undefined symbols, in which case not
4245 # even a static library is built. For now, we need to specify
4246 # -no-undefined on the libtool link line when we can be certain
4247 # that all symbols are satisfied, otherwise we get a static library.
4254 libtool_args=$nonopt
4255 base_compile="$nonopt $@"
4256 compile_command=$nonopt
4257 finalize_command=$nonopt
4270 lib_search_path=`pwd`
4272 new_inherited_linker_flags=
4281 export_symbols_regex=
4289 precious_files_regex=
4290 prefer_static_libs=no
4303 single_module="${wl}-single_module"
4304 func_infer_tag $base_compile
4306 # We need to know -static, to get the right output filenames.
4311 test "$build_libtool_libs" != yes && \
4312 func_fatal_configuration "can not build a shared library"
4316 -all-static | -static | -static-libtool-libs)
4319 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4320 func_warning "complete static linking is impossible in this configuration"
4322 if test -n "$link_static_flag"; then
4323 dlopen_self=$dlopen_self_static
4325 prefer_static_libs=yes
4328 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4329 dlopen_self=$dlopen_self_static
4331 prefer_static_libs=built
4333 -static-libtool-libs)
4334 if test -z "$pic_flag" && test -n "$link_static_flag"; then
4335 dlopen_self=$dlopen_self_static
4337 prefer_static_libs=yes
4340 build_libtool_libs=no
4347 # See if our shared archives depend on static archives.
4348 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4350 # Go through the arguments, transforming them on the way.
4351 while test "$#" -gt 0; do
4354 func_quote_for_eval "$arg"
4355 qarg=$func_quote_for_eval_unquoted_result
4356 func_append libtool_args " $func_quote_for_eval_result"
4358 # If the previous option needs an argument, assign it.
4359 if test -n "$prev"; then
4362 func_append compile_command " @OUTPUT@"
4363 func_append finalize_command " @OUTPUT@"
4374 if test "$preload" = no; then
4375 # Add the symbol object into the linking commands.
4376 func_append compile_command " @SYMFILE@"
4377 func_append finalize_command " @SYMFILE@"
4381 *.la | *.lo) ;; # We handle these cases below.
4383 if test "$dlself" = no; then
4391 if test "$prev" = dlprefiles; then
4393 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4403 if test "$prev" = dlfiles; then
4404 dlfiles="$dlfiles $arg"
4406 dlprefiles="$dlprefiles $arg"
4414 export_symbols="$arg"
4416 || func_fatal_error "symbol file \`$arg' does not exist"
4421 export_symbols_regex="$arg"
4429 *" $qarg.ltframework "*) ;;
4430 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4439 inst_prefix_dir="$arg"
4444 if test -f "$arg"; then
4447 for fil in `cat "$save_arg"`
4449 # moreargs="$moreargs $fil"
4451 # A libtool-controlled object.
4453 # Check to see that this really is a libtool object.
4454 if func_lalib_unsafe_p "$arg"; then
4461 if test -z "$pic_object" ||
4462 test -z "$non_pic_object" ||
4463 test "$pic_object" = none &&
4464 test "$non_pic_object" = none; then
4465 func_fatal_error "cannot find name of object for \`$arg'"
4468 # Extract subdirectory from the argument.
4469 func_dirname "$arg" "/" ""
4470 xdir="$func_dirname_result"
4472 if test "$pic_object" != none; then
4473 # Prepend the subdirectory the object is found in.
4474 pic_object="$xdir$pic_object"
4476 if test "$prev" = dlfiles; then
4477 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4478 dlfiles="$dlfiles $pic_object"
4482 # If libtool objects are unsupported, then we need to preload.
4487 # CHECK ME: I think I busted this. -Ossama
4488 if test "$prev" = dlprefiles; then
4489 # Preload the old-style object.
4490 dlprefiles="$dlprefiles $pic_object"
4495 func_append libobjs " $pic_object"
4500 if test "$non_pic_object" != none; then
4501 # Prepend the subdirectory the object is found in.
4502 non_pic_object="$xdir$non_pic_object"
4504 # A standard non-PIC object
4505 func_append non_pic_objects " $non_pic_object"
4506 if test -z "$pic_object" || test "$pic_object" = none ; then
4507 arg="$non_pic_object"
4510 # If the PIC object exists, use it instead.
4511 # $xdir was prepended to $pic_object above.
4512 non_pic_object="$pic_object"
4513 func_append non_pic_objects " $non_pic_object"
4516 # Only an error if not doing a dry-run.
4517 if $opt_dry_run; then
4518 # Extract subdirectory from the argument.
4519 func_dirname "$arg" "/" ""
4520 xdir="$func_dirname_result"
4523 pic_object=$xdir$objdir/$func_lo2o_result
4524 non_pic_object=$xdir$func_lo2o_result
4525 func_append libobjs " $pic_object"
4526 func_append non_pic_objects " $non_pic_object"
4528 func_fatal_error "\`$arg' is not a valid libtool object"
4533 func_fatal_error "link input file \`$arg' does not exist"
4540 precious_files_regex="$arg"
4550 # We need an absolute path.
4552 [\\/]* | [A-Za-z]:[\\/]*) ;;
4554 func_fatal_error "only absolute run-paths are allowed"
4557 if test "$prev" = rpath; then
4560 *) rpath="$rpath $arg" ;;
4565 *) xrpath="$xrpath $arg" ;;
4577 weak_libs="$weak_libs $arg"
4582 linker_flags="$linker_flags $qarg"
4583 compiler_flags="$compiler_flags $qarg"
4585 func_append compile_command " $qarg"
4586 func_append finalize_command " $qarg"
4590 compiler_flags="$compiler_flags $qarg"
4592 func_append compile_command " $qarg"
4593 func_append finalize_command " $qarg"
4597 linker_flags="$linker_flags $qarg"
4598 compiler_flags="$compiler_flags $wl$qarg"
4600 func_append compile_command " $wl$qarg"
4601 func_append finalize_command " $wl$qarg"
4605 eval "$prev=\"\$arg\""
4610 fi # test -n "$prev"
4616 if test -n "$link_static_flag"; then
4617 # See comment for -static flag below, for more details.
4618 func_append compile_command " $link_static_flag"
4619 func_append finalize_command " $link_static_flag"
4625 # FIXME: remove this flag sometime in the future.
4626 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4654 -export-symbols | -export-symbols-regex)
4655 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4656 func_fatal_error "more than one -exported-symbols argument is not allowed"
4658 if test "X$arg" = "X-export-symbols"; then
4676 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4677 # so, if we see these flags be careful not to treat them like -L
4679 case $with_gcc/$host in
4680 no/*-*-irix* | /*-*-irix*)
4681 func_append compile_command " $arg"
4682 func_append finalize_command " $arg"
4689 func_stripname '-L' '' "$arg"
4690 dir=$func_stripname_result
4691 if test -z "$dir"; then
4692 if test "$#" -gt 0; then
4693 func_fatal_error "require no space between \`-L' and \`$1'"
4695 func_fatal_error "need path for \`-L' option"
4698 # We need an absolute path.
4700 [\\/]* | [A-Za-z]:[\\/]*) ;;
4702 absdir=`cd "$dir" && pwd`
4703 test -z "$absdir" && \
4704 func_fatal_error "cannot determine absolute directory name of \`$dir'"
4711 deplibs="$deplibs -L$dir"
4712 lib_search_path="$lib_search_path $dir"
4716 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4717 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
4718 case :$dllsearchpath: in
4720 ::) dllsearchpath=$dir;;
4721 *) dllsearchpath="$dllsearchpath:$dir";;
4723 case :$dllsearchpath: in
4724 *":$testbindir:"*) ;;
4725 ::) dllsearchpath=$testbindir;;
4726 *) dllsearchpath="$dllsearchpath:$testbindir";;
4734 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
4736 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
4737 # These systems don't actually have a C or math library (as such)
4741 # These systems don't actually have a C library (as such)
4742 test "X$arg" = "X-lc" && continue
4744 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
4745 # Do not include libc due to us having libc/libc_r.
4746 test "X$arg" = "X-lc" && continue
4748 *-*-rhapsody* | *-*-darwin1.[012])
4749 # Rhapsody C and math libraries are in the System framework
4750 deplibs="$deplibs System.ltframework"
4753 *-*-sco3.2v5* | *-*-sco5v6*)
4754 # Causes problems with __ctype
4755 test "X$arg" = "X-lc" && continue
4757 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
4758 # Compiler inserts libc in the correct place for threads to work
4759 test "X$arg" = "X-lc" && continue
4762 test "X$arg" = "X-lc" && continue
4765 elif test "X$arg" = "X-lc_r"; then
4767 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
4768 # Do not include libc_r directly, use -pthread flag.
4773 deplibs="$deplibs $arg"
4782 # Tru64 UNIX uses -model [arg] to determine the layout of C++
4783 # classes, name mangling, and exception handling.
4784 # Darwin uses the -arch flag to determine output architecture.
4785 -model|-arch|-isysroot)
4786 compiler_flags="$compiler_flags $arg"
4787 func_append compile_command " $arg"
4788 func_append finalize_command " $arg"
4793 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
4794 compiler_flags="$compiler_flags $arg"
4795 func_append compile_command " $arg"
4796 func_append finalize_command " $arg"
4797 case "$new_inherited_linker_flags " in
4799 * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
4805 single_module="${wl}-multi_module"
4816 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
4817 # The PATH hackery in wrapper scripts is required on Windows
4818 # and Darwin in order for the loader to find any dlls it needs.
4819 func_warning "\`-no-install' is ignored for $host"
4820 func_warning "assuming \`-no-fast-install' instead"
4823 *) no_install=yes ;;
4840 -precious-files-regex)
4861 func_stripname '-R' '' "$arg"
4862 dir=$func_stripname_result
4863 # We need an absolute path.
4865 [\\/]* | [A-Za-z]:[\\/]*) ;;
4867 func_fatal_error "only absolute run-paths are allowed"
4872 *) xrpath="$xrpath $dir" ;;
4878 # The effects of -shared are defined in a previous loop.
4887 -static | -static-libtool-libs)
4888 # The effects of -static are defined in a previous loop.
4889 # We used to do the same as -all-static on platforms that
4890 # didn't have a PIC flag, but the assumption that the effects
4891 # would be equivalent was wrong. It would break on at least
4892 # Digital Unix and AIX.
4918 func_stripname '-Wc,' '' "$arg"
4919 args=$func_stripname_result
4921 save_ifs="$IFS"; IFS=','
4922 for flag in $args; do
4924 func_quote_for_eval "$flag"
4925 arg="$arg $func_quote_for_eval_result"
4926 compiler_flags="$compiler_flags $func_quote_for_eval_result"
4929 func_stripname ' ' '' "$arg"
4930 arg=$func_stripname_result
4934 func_stripname '-Wl,' '' "$arg"
4935 args=$func_stripname_result
4937 save_ifs="$IFS"; IFS=','
4938 for flag in $args; do
4940 func_quote_for_eval "$flag"
4941 arg="$arg $wl$func_quote_for_eval_result"
4942 compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
4943 linker_flags="$linker_flags $func_quote_for_eval_result"
4946 func_stripname ' ' '' "$arg"
4947 arg=$func_stripname_result
4967 func_quote_for_eval "$arg"
4968 arg="$func_quote_for_eval_result"
4971 # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
4972 # -r[0-9][0-9]* specifies the processor on the SGI compiler
4973 # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
4974 # +DA*, +DD* enable 64-bit mode on the HP compiler
4975 # -q* pass through compiler args for the IBM compiler
4976 # -m*, -t[45]*, -txscale* pass through architecture-specific
4977 # compiler args for GCC
4978 # -F/path gives path to uninstalled frameworks, gcc on darwin
4979 # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
4980 # @file GCC response files
4981 # -tp=* Portland pgcc target processor selection
4982 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
4983 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*)
4984 func_quote_for_eval "$arg"
4985 arg="$func_quote_for_eval_result"
4986 func_append compile_command " $arg"
4987 func_append finalize_command " $arg"
4988 compiler_flags="$compiler_flags $arg"
4992 # Some other compiler flag.
4994 func_quote_for_eval "$arg"
4995 arg="$func_quote_for_eval_result"
4999 # A standard object.
5004 # A libtool-controlled object.
5006 # Check to see that this really is a libtool object.
5007 if func_lalib_unsafe_p "$arg"; then
5014 if test -z "$pic_object" ||
5015 test -z "$non_pic_object" ||
5016 test "$pic_object" = none &&
5017 test "$non_pic_object" = none; then
5018 func_fatal_error "cannot find name of object for \`$arg'"
5021 # Extract subdirectory from the argument.
5022 func_dirname "$arg" "/" ""
5023 xdir="$func_dirname_result"
5025 if test "$pic_object" != none; then
5026 # Prepend the subdirectory the object is found in.
5027 pic_object="$xdir$pic_object"
5029 if test "$prev" = dlfiles; then
5030 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5031 dlfiles="$dlfiles $pic_object"
5035 # If libtool objects are unsupported, then we need to preload.
5040 # CHECK ME: I think I busted this. -Ossama
5041 if test "$prev" = dlprefiles; then
5042 # Preload the old-style object.
5043 dlprefiles="$dlprefiles $pic_object"
5048 func_append libobjs " $pic_object"
5053 if test "$non_pic_object" != none; then
5054 # Prepend the subdirectory the object is found in.
5055 non_pic_object="$xdir$non_pic_object"
5057 # A standard non-PIC object
5058 func_append non_pic_objects " $non_pic_object"
5059 if test -z "$pic_object" || test "$pic_object" = none ; then
5060 arg="$non_pic_object"
5063 # If the PIC object exists, use it instead.
5064 # $xdir was prepended to $pic_object above.
5065 non_pic_object="$pic_object"
5066 func_append non_pic_objects " $non_pic_object"
5069 # Only an error if not doing a dry-run.
5070 if $opt_dry_run; then
5071 # Extract subdirectory from the argument.
5072 func_dirname "$arg" "/" ""
5073 xdir="$func_dirname_result"
5076 pic_object=$xdir$objdir/$func_lo2o_result
5077 non_pic_object=$xdir$func_lo2o_result
5078 func_append libobjs " $pic_object"
5079 func_append non_pic_objects " $non_pic_object"
5081 func_fatal_error "\`$arg' is not a valid libtool object"
5088 deplibs="$deplibs $arg"
5089 old_deplibs="$old_deplibs $arg"
5094 # A libtool-controlled library.
5096 if test "$prev" = dlfiles; then
5097 # This library was specified with -dlopen.
5098 dlfiles="$dlfiles $arg"
5100 elif test "$prev" = dlprefiles; then
5101 # The library was specified with -dlpreopen.
5102 dlprefiles="$dlprefiles $arg"
5105 deplibs="$deplibs $arg"
5110 # Some other compiler argument.
5112 # Unknown arguments in both finalize_command and compile_command need
5113 # to be aesthetically quoted because they are evaled later.
5114 func_quote_for_eval "$arg"
5115 arg="$func_quote_for_eval_result"
5119 # Now actually substitute the argument into the commands.
5120 if test -n "$arg"; then
5121 func_append compile_command " $arg"
5122 func_append finalize_command " $arg"
5124 done # argument parsing loop
5126 test -n "$prev" && \
5127 func_fatal_help "the \`$prevarg' option requires an argument"
5129 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5130 eval "arg=\"$export_dynamic_flag_spec\""
5131 func_append compile_command " $arg"
5132 func_append finalize_command " $arg"
5136 # calculate the name of the file, without its directory
5137 func_basename "$output"
5138 outputname="$func_basename_result"
5139 libobjs_save="$libobjs"
5141 if test -n "$shlibpath_var"; then
5142 # get the directories listed in $shlibpath_var
5143 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5147 eval "sys_lib_search_path=\"$sys_lib_search_path_spec\""
5148 eval "sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\""
5150 func_dirname "$output" "/" ""
5151 output_objdir="$func_dirname_result$objdir"
5152 # Create the object directory.
5153 func_mkdir_p "$output_objdir"
5155 # Determine the type of output
5158 func_fatal_help "you must specify an output file"
5160 *.$libext) linkmode=oldlib ;;
5161 *.lo | *.$objext) linkmode=obj ;;
5162 *.la) linkmode=lib ;;
5163 *) linkmode=prog ;; # Anything else should be a program.
5169 # Find all interdependent deplibs by searching for libraries
5170 # that are linked more than once (e.g. -la -lb -la)
5171 for deplib in $deplibs; do
5172 if $opt_duplicate_deps ; then
5174 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5177 libs="$libs $deplib"
5180 if test "$linkmode" = lib; then
5181 libs="$predeps $libs $compiler_lib_search_path $postdeps"
5183 # Compute libraries that are listed more than once in $predeps
5184 # $postdeps and mark them as special (i.e., whose duplicates are
5185 # not to be eliminated).
5187 if $opt_duplicate_compiler_generated_deps; then
5188 for pre_post_dep in $predeps $postdeps; do
5189 case "$pre_post_deps " in
5190 *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5192 pre_post_deps="$pre_post_deps $pre_post_dep"
5201 need_relink=no # whether we're linking any uninstalled libtool libraries
5202 notinst_deplibs= # not-installed libtool libraries
5203 notinst_path= # paths that contain not-installed libtool libraries
5207 passes="conv dlpreopen link"
5208 for file in $dlfiles $dlprefiles; do
5212 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5223 passes="conv scan dlopen dlpreopen link"
5229 for pass in $passes; do
5230 # The preopen pass in lib mode reverses $deplibs; put it back here
5231 # so that -L comes before libs that need it for instance...
5232 if test "$linkmode,$pass" = "lib,link"; then
5233 ## FIXME: Find the place where the list is rebuilt in the wrong
5234 ## order, and fix it there properly
5236 for deplib in $deplibs; do
5237 tmp_deplibs="$deplib $tmp_deplibs"
5239 deplibs="$tmp_deplibs"
5242 if test "$linkmode,$pass" = "lib,link" ||
5243 test "$linkmode,$pass" = "prog,scan"; then
5247 if test "$linkmode" = prog; then
5249 dlopen) libs="$dlfiles" ;;
5250 dlpreopen) libs="$dlprefiles" ;;
5251 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5254 if test "$linkmode,$pass" = "lib,dlpreopen"; then
5255 # Collect and forward deplibs of preopened libtool libs
5256 for lib in $dlprefiles; do
5257 # Ignore non-libtool-libs
5260 *.la) func_source "$lib" ;;
5263 # Collect preopened libtool deplibs, except any this library
5264 # has declared as weak libs
5265 for deplib in $dependency_libs; do
5266 func_basename "$deplib"
5267 deplib_base=$func_basename_result
5268 case " $weak_libs " in
5269 *" $deplib_base "*) ;;
5270 *) deplibs="$deplibs $deplib" ;;
5276 if test "$pass" = dlopen; then
5277 # Collect dlpreopened libraries
5278 save_deplibs="$deplibs"
5282 for deplib in $libs; do
5286 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5287 if test "$linkmode,$pass" = "prog,link"; then
5288 compile_deplibs="$deplib $compile_deplibs"
5289 finalize_deplibs="$deplib $finalize_deplibs"
5291 compiler_flags="$compiler_flags $deplib"
5292 if test "$linkmode" = lib ; then
5293 case "$new_inherited_linker_flags " in
5295 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5302 if test "$linkmode" != lib && test "$linkmode" != prog; then
5303 func_warning "\`-l' is ignored for archives/objects"
5306 func_stripname '-l' '' "$deplib"
5307 name=$func_stripname_result
5308 if test "$linkmode" = lib; then
5309 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5311 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5313 for searchdir in $searchdirs; do
5314 for search_ext in .la $std_shrext .so .a; do
5315 # Search the libtool library
5316 lib="$searchdir/lib${name}${search_ext}"
5317 if test -f "$lib"; then
5318 if test "$search_ext" = ".la"; then
5327 if test "$found" != yes; then
5328 # deplib doesn't seem to be a libtool library
5329 if test "$linkmode,$pass" = "prog,link"; then
5330 compile_deplibs="$deplib $compile_deplibs"
5331 finalize_deplibs="$deplib $finalize_deplibs"
5333 deplibs="$deplib $deplibs"
5334 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5337 else # deplib is a libtool library
5338 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5339 # We need to do some special things here, and not later.
5340 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5341 case " $predeps $postdeps " in
5343 if func_lalib_p "$lib"; then
5347 for l in $old_library $library_names; do
5350 if test "X$ll" = "X$old_library" ; then # only static version available
5352 func_dirname "$lib" "" "."
5353 ladir="$func_dirname_result"
5354 lib=$ladir/$old_library
5355 if test "$linkmode,$pass" = "prog,link"; then
5356 compile_deplibs="$deplib $compile_deplibs"
5357 finalize_deplibs="$deplib $finalize_deplibs"
5359 deplibs="$deplib $deplibs"
5360 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5372 if test "$linkmode,$pass" = "prog,link"; then
5373 compile_deplibs="$deplib $compile_deplibs"
5374 finalize_deplibs="$deplib $finalize_deplibs"
5376 deplibs="$deplib $deplibs"
5377 if test "$linkmode" = lib ; then
5378 case "$new_inherited_linker_flags " in
5380 * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5389 deplibs="$deplib $deplibs"
5390 test "$pass" = conv && continue
5391 newdependency_libs="$deplib $newdependency_libs"
5392 func_stripname '-L' '' "$deplib"
5393 newlib_search_path="$newlib_search_path $func_stripname_result"
5396 if test "$pass" = conv; then
5397 deplibs="$deplib $deplibs"
5400 if test "$pass" = scan; then
5401 deplibs="$deplib $deplibs"
5403 compile_deplibs="$deplib $compile_deplibs"
5404 finalize_deplibs="$deplib $finalize_deplibs"
5406 func_stripname '-L' '' "$deplib"
5407 newlib_search_path="$newlib_search_path $func_stripname_result"
5410 func_warning "\`-L' is ignored for archives/objects"
5416 if test "$pass" = link; then
5417 func_stripname '-R' '' "$deplib"
5418 dir=$func_stripname_result
5419 # Make sure the xrpath contains only unique directories.
5422 *) xrpath="$xrpath $dir" ;;
5425 deplibs="$deplib $deplibs"
5428 *.la) lib="$deplib" ;;
5430 if test "$pass" = conv; then
5431 deplibs="$deplib $deplibs"
5436 # Linking convenience modules into shared libraries is allowed,
5437 # but linking other static libraries is non-portable.
5438 case " $dlpreconveniencelibs " in
5442 case $deplibs_check_method in
5444 set dummy $deplibs_check_method; shift
5445 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5446 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
5447 | $EGREP "$match_pattern_regex" > /dev/null; then
5455 if test "$valid_a_lib" != yes; then
5457 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5458 echo "*** I have the capability to make that library automatically link in when"
5459 echo "*** you link to this library. But I can only do this if you have a"
5460 echo "*** shared version of the library, which you do not appear to have"
5461 echo "*** because the file extensions .$libext of this argument makes me believe"
5462 echo "*** that it is just a static archive that I should not use here."
5465 $ECHO "*** Warning: Linking the shared library $output against the"
5466 $ECHO "*** static library $deplib is not portable!"
5467 deplibs="$deplib $deplibs"
5474 if test "$pass" != link; then
5475 deplibs="$deplib $deplibs"
5477 compile_deplibs="$deplib $compile_deplibs"
5478 finalize_deplibs="$deplib $finalize_deplibs"
5485 if test "$pass" = conv; then
5486 deplibs="$deplib $deplibs"
5487 elif test "$linkmode" = prog; then
5488 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5489 # If there is no dlopen support or we're linking statically,
5490 # we need to preload.
5491 newdlprefiles="$newdlprefiles $deplib"
5492 compile_deplibs="$deplib $compile_deplibs"
5493 finalize_deplibs="$deplib $finalize_deplibs"
5495 newdlfiles="$newdlfiles $deplib"
5506 if test "$found" = yes || test -f "$lib"; then :
5508 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5511 # Check to see that this really is a libtool archive.
5512 func_lalib_unsafe_p "$lib" \
5513 || func_fatal_error "\`$lib' is not a valid libtool archive"
5515 func_dirname "$lib" "" "."
5516 ladir="$func_dirname_result"
5524 inherited_linker_flags=
5525 # If the library was installed with an old release of libtool,
5526 # it will not redefine variables installed, or shouldnotlink
5535 # Convert "-framework foo" to "foo.ltframework"
5536 if test -n "$inherited_linker_flags"; then
5537 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
5538 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5539 case " $new_inherited_linker_flags " in
5540 *" $tmp_inherited_linker_flag "*) ;;
5541 *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5545 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
5546 if test "$linkmode,$pass" = "lib,link" ||
5547 test "$linkmode,$pass" = "prog,scan" ||
5548 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5549 test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5550 test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5553 if test "$pass" = conv; then
5554 # Only check for convenience libraries
5555 deplibs="$lib $deplibs"
5556 if test -z "$libdir"; then
5557 if test -z "$old_library"; then
5558 func_fatal_error "cannot find name of link library for \`$lib'"
5560 # It is a libtool convenience library, so add in its objects.
5561 convenience="$convenience $ladir/$objdir/$old_library"
5562 old_convenience="$old_convenience $ladir/$objdir/$old_library"
5563 elif test "$linkmode" != prog && test "$linkmode" != lib; then
5564 func_fatal_error "\`$lib' is not a convenience library"
5567 for deplib in $dependency_libs; do
5568 deplibs="$deplib $deplibs"
5569 if $opt_duplicate_deps ; then
5570 case "$tmp_libs " in
5571 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5574 tmp_libs="$tmp_libs $deplib"
5580 # Get the name of the library we link against.
5582 for l in $old_library $library_names; do
5585 if test -z "$linklib"; then
5586 func_fatal_error "cannot find name of link library for \`$lib'"
5589 # This library was specified with -dlopen.
5590 if test "$pass" = dlopen; then
5591 if test -z "$libdir"; then
5592 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5594 if test -z "$dlname" ||
5595 test "$dlopen_support" != yes ||
5596 test "$build_libtool_libs" = no; then
5597 # If there is no dlname, no dlopen support or we're linking
5598 # statically, we need to preload. We also need to preload any
5599 # dependent libraries so libltdl's deplib preloader doesn't
5600 # bomb out in the load deplibs phase.
5601 dlprefiles="$dlprefiles $lib $dependency_libs"
5603 newdlfiles="$newdlfiles $lib"
5608 # We need an absolute path.
5610 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5612 abs_ladir=`cd "$ladir" && pwd`
5613 if test -z "$abs_ladir"; then
5614 func_warning "cannot determine absolute directory name of \`$ladir'"
5615 func_warning "passing it literally to the linker, although it might fail"
5620 func_basename "$lib"
5621 laname="$func_basename_result"
5623 # Find the relevant object directory and library name.
5624 if test "X$installed" = Xyes; then
5625 if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5626 func_warning "library \`$lib' was moved."
5634 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5636 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5639 # Remove this search path later
5640 notinst_path="$notinst_path $abs_ladir"
5642 dir="$ladir/$objdir"
5643 absdir="$abs_ladir/$objdir"
5644 # Remove this search path later
5645 notinst_path="$notinst_path $abs_ladir"
5647 fi # $installed = yes
5648 func_stripname 'lib' '.la' "$laname"
5649 name=$func_stripname_result
5651 # This library was specified with -dlpreopen.
5652 if test "$pass" = dlpreopen; then
5653 if test -z "$libdir" && test "$linkmode" = prog; then
5654 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5656 # Prefer using a static library (so that no silly _DYNAMIC symbols
5657 # are required to link).
5658 if test -n "$old_library"; then
5659 newdlprefiles="$newdlprefiles $dir/$old_library"
5660 # Keep a list of preopened convenience libraries to check
5661 # that they are being used correctly in the link pass.
5662 test -z "$libdir" && \
5663 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5664 # Otherwise, use the dlname, so that lt_dlopen finds it.
5665 elif test -n "$dlname"; then
5666 newdlprefiles="$newdlprefiles $dir/$dlname"
5668 newdlprefiles="$newdlprefiles $dir/$linklib"
5670 fi # $pass = dlpreopen
5672 if test -z "$libdir"; then
5673 # Link the convenience library
5674 if test "$linkmode" = lib; then
5675 deplibs="$dir/$old_library $deplibs"
5676 elif test "$linkmode,$pass" = "prog,link"; then
5677 compile_deplibs="$dir/$old_library $compile_deplibs"
5678 finalize_deplibs="$dir/$old_library $finalize_deplibs"
5680 deplibs="$lib $deplibs" # used for prog,scan pass
5686 if test "$linkmode" = prog && test "$pass" != link; then
5687 newlib_search_path="$newlib_search_path $ladir"
5688 deplibs="$lib $deplibs"
5691 if test "$link_all_deplibs" != no || test -z "$library_names" ||
5692 test "$build_libtool_libs" = no; then
5697 for deplib in $dependency_libs; do
5699 -L*) func_stripname '-L' '' "$deplib"
5700 newlib_search_path="$newlib_search_path $func_stripname_result"
5703 # Need to link against all dependency_libs?
5704 if test "$linkalldeplibs" = yes; then
5705 deplibs="$deplib $deplibs"
5707 # Need to hardcode shared library paths
5708 # or/and link against static libraries
5709 newdependency_libs="$deplib $newdependency_libs"
5711 if $opt_duplicate_deps ; then
5712 case "$tmp_libs " in
5713 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5716 tmp_libs="$tmp_libs $deplib"
5719 fi # $linkmode = prog...
5721 if test "$linkmode,$pass" = "prog,link"; then
5722 if test -n "$library_names" &&
5723 { { test "$prefer_static_libs" = no ||
5724 test "$prefer_static_libs,$installed" = "built,yes"; } ||
5725 test -z "$old_library"; }; then
5726 # We need to hardcode the library path
5727 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
5728 # Make sure the rpath contains only unique directories.
5729 case "$temp_rpath:" in
5731 *) temp_rpath="$temp_rpath$absdir:" ;;
5735 # Hardcode the library path.
5736 # Skip directories that are in the system default run-time
5738 case " $sys_lib_dlsearch_path " in
5741 case "$compile_rpath " in
5743 *) compile_rpath="$compile_rpath $absdir"
5747 case " $sys_lib_dlsearch_path " in
5750 case "$finalize_rpath " in
5752 *) finalize_rpath="$finalize_rpath $libdir"
5756 fi # $linkmode,$pass = prog,link...
5758 if test "$alldeplibs" = yes &&
5759 { test "$deplibs_check_method" = pass_all ||
5760 { test "$build_libtool_libs" = yes &&
5761 test -n "$library_names"; }; }; then
5762 # We only need to search for static libraries
5767 link_static=no # Whether the deplib will be linked statically
5768 use_static_libs=$prefer_static_libs
5769 if test "$use_static_libs" = built && test "$installed" = yes; then
5772 if test -n "$library_names" &&
5773 { test "$use_static_libs" = no || test -z "$old_library"; }; then
5775 *cygwin* | *mingw* | *cegcc*)
5776 # No point in relinking DLLs because paths are not encoded
5777 notinst_deplibs="$notinst_deplibs $lib"
5781 if test "$installed" = no; then
5782 notinst_deplibs="$notinst_deplibs $lib"
5787 # This is a shared library
5789 # Warn about portability, can't link against -module's on some
5790 # systems (darwin). Don't bleat about dlopened modules though!
5792 for dlpremoduletest in $dlprefiles; do
5793 if test "X$dlpremoduletest" = "X$lib"; then
5794 dlopenmodule="$dlpremoduletest"
5798 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
5800 if test "$linkmode" = prog; then
5801 $ECHO "*** Warning: Linking the executable $output against the loadable module"
5803 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
5805 $ECHO "*** $linklib is not portable!"
5807 if test "$linkmode" = lib &&
5808 test "$hardcode_into_libs" = yes; then
5809 # Hardcode the library path.
5810 # Skip directories that are in the system default run-time
5812 case " $sys_lib_dlsearch_path " in
5815 case "$compile_rpath " in
5817 *) compile_rpath="$compile_rpath $absdir"
5821 case " $sys_lib_dlsearch_path " in
5824 case "$finalize_rpath " in
5826 *) finalize_rpath="$finalize_rpath $libdir"
5832 if test -n "$old_archive_from_expsyms_cmds"; then
5833 # figure out the soname
5834 set dummy $library_names
5838 eval "libname=\"$libname_spec\""
5839 # use dlname if we got it. it's perfectly good, no?
5840 if test -n "$dlname"; then
5842 elif test -n "$soname_spec"; then
5845 *cygwin* | mingw* | *cegcc*)
5846 func_arith $current - $age
5847 major=$func_arith_result
5851 eval "soname=\"$soname_spec\""
5856 # Make a new name for the extract_expsyms_cmds to use
5858 func_basename "$soroot"
5859 soname="$func_basename_result"
5860 func_stripname 'lib' '.dll' "$soname"
5861 newlib=libimp-$func_stripname_result.a
5863 # If the library has no export list, then create one now
5864 if test -f "$output_objdir/$soname-def"; then :
5866 func_verbose "extracting exported symbol list from \`$soname'"
5867 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
5871 if test -f "$output_objdir/$newlib"; then :; else
5872 func_verbose "generating import library for \`$soname'"
5873 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
5875 # make sure the library variables are pointing to the new library
5878 fi # test -n "$old_archive_from_expsyms_cmds"
5880 if test "$linkmode" = prog || test "$mode" != relink; then
5885 case $hardcode_action in
5886 immediate | unsupported)
5887 if test "$hardcode_direct" = no; then
5890 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
5891 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
5892 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
5893 *-*-unixware7*) add_dir="-L$dir" ;;
5895 # if the lib is a (non-dlopened) module then we can not
5896 # link against it, someone is ignoring the earlier warnings
5897 if /usr/bin/file -L $add 2> /dev/null |
5898 $GREP ": [^:]* bundle" >/dev/null ; then
5899 if test "X$dlopenmodule" != "X$lib"; then
5900 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
5901 if test -z "$old_library" ; then
5903 echo "*** And there doesn't seem to be a static archive available"
5904 echo "*** The link will probably fail, sorry"
5906 add="$dir/$old_library"
5908 elif test -n "$old_library"; then
5909 add="$dir/$old_library"
5913 elif test "$hardcode_minus_L" = no; then
5915 *-*-sunos*) add_shlibpath="$dir" ;;
5919 elif test "$hardcode_shlibpath_var" = no; then
5920 add_shlibpath="$dir"
5927 if test "$hardcode_direct" = yes &&
5928 test "$hardcode_direct_absolute" = no; then
5930 elif test "$hardcode_minus_L" = yes; then
5932 # Try looking first in the location we're being installed to.
5933 if test -n "$inst_prefix_dir"; then
5936 add_dir="$add_dir -L$inst_prefix_dir$libdir"
5941 elif test "$hardcode_shlibpath_var" = yes; then
5942 add_shlibpath="$dir"
5951 if test "$lib_linked" != yes; then
5952 func_fatal_configuration "unsupported hardcode properties"
5955 if test -n "$add_shlibpath"; then
5956 case :$compile_shlibpath: in
5957 *":$add_shlibpath:"*) ;;
5958 *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
5961 if test "$linkmode" = prog; then
5962 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
5963 test -n "$add" && compile_deplibs="$add $compile_deplibs"
5965 test -n "$add_dir" && deplibs="$add_dir $deplibs"
5966 test -n "$add" && deplibs="$add $deplibs"
5967 if test "$hardcode_direct" != yes &&
5968 test "$hardcode_minus_L" != yes &&
5969 test "$hardcode_shlibpath_var" = yes; then
5970 case :$finalize_shlibpath: in
5972 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5978 if test "$linkmode" = prog || test "$mode" = relink; then
5982 # Finalize command for both is simple: just hardcode it.
5983 if test "$hardcode_direct" = yes &&
5984 test "$hardcode_direct_absolute" = no; then
5985 add="$libdir/$linklib"
5986 elif test "$hardcode_minus_L" = yes; then
5989 elif test "$hardcode_shlibpath_var" = yes; then
5990 case :$finalize_shlibpath: in
5992 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
5995 elif test "$hardcode_automatic" = yes; then
5996 if test -n "$inst_prefix_dir" &&
5997 test -f "$inst_prefix_dir$libdir/$linklib" ; then
5998 add="$inst_prefix_dir$libdir/$linklib"
6000 add="$libdir/$linklib"
6003 # We cannot seem to hardcode it, guess we'll fake it.
6005 # Try looking first in the location we're being installed to.
6006 if test -n "$inst_prefix_dir"; then
6009 add_dir="$add_dir -L$inst_prefix_dir$libdir"
6016 if test "$linkmode" = prog; then
6017 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6018 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6020 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6021 test -n "$add" && deplibs="$add $deplibs"
6024 elif test "$linkmode" = prog; then
6025 # Here we assume that one of hardcode_direct or hardcode_minus_L
6026 # is not unsupported. This is valid on all known static and
6028 if test "$hardcode_direct" != unsupported; then
6029 test -n "$old_library" && linklib="$old_library"
6030 compile_deplibs="$dir/$linklib $compile_deplibs"
6031 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6033 compile_deplibs="-l$name -L$dir $compile_deplibs"
6034 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6036 elif test "$build_libtool_libs" = yes; then
6037 # Not a shared library
6038 if test "$deplibs_check_method" != pass_all; then
6039 # We're trying link a shared library against a static one
6040 # but the system doesn't support it.
6042 # Just print a warning and add the library to dependency_libs so
6043 # that the program can be linked against the static library.
6045 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6046 echo "*** I have the capability to make that library automatically link in when"
6047 echo "*** you link to this library. But I can only do this if you have a"
6048 echo "*** shared version of the library, which you do not appear to have."
6049 if test "$module" = yes; then
6050 echo "*** But as you try to build a module library, libtool will still create "
6051 echo "*** a static module, that should work as long as the dlopening application"
6052 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6053 if test -z "$global_symbol_pipe"; then
6055 echo "*** However, this would only work if libtool was able to extract symbol"
6056 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6057 echo "*** not find such a program. So, this module is probably useless."
6058 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6060 if test "$build_old_libs" = no; then
6061 build_libtool_libs=module
6064 build_libtool_libs=no
6068 deplibs="$dir/$old_library $deplibs"
6071 fi # link shared/static library?
6073 if test "$linkmode" = lib; then
6074 if test -n "$dependency_libs" &&
6075 { test "$hardcode_into_libs" != yes ||
6076 test "$build_old_libs" = yes ||
6077 test "$link_static" = yes; }; then
6078 # Extract -R from dependency_libs
6080 for libdir in $dependency_libs; do
6082 -R*) func_stripname '-R' '' "$libdir"
6083 temp_xrpath=$func_stripname_result
6085 *" $temp_xrpath "*) ;;
6086 *) xrpath="$xrpath $temp_xrpath";;
6088 *) temp_deplibs="$temp_deplibs $libdir";;
6091 dependency_libs="$temp_deplibs"
6094 newlib_search_path="$newlib_search_path $absdir"
6095 # Link against this library
6096 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6097 # ... and its dependency_libs
6099 for deplib in $dependency_libs; do
6100 newdependency_libs="$deplib $newdependency_libs"
6101 if $opt_duplicate_deps ; then
6102 case "$tmp_libs " in
6103 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6106 tmp_libs="$tmp_libs $deplib"
6109 if test "$link_all_deplibs" != no; then
6110 # Add the search paths of all dependency libraries
6111 for deplib in $dependency_libs; do
6114 -L*) path="$deplib" ;;
6116 func_dirname "$deplib" "" "."
6117 dir="$func_dirname_result"
6118 # We need an absolute path.
6120 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6122 absdir=`cd "$dir" && pwd`
6123 if test -z "$absdir"; then
6124 func_warning "cannot determine absolute directory name of \`$dir'"
6129 if $GREP "^installed=no" $deplib > /dev/null; then
6133 deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6134 if test -n "$deplibrary_names" ; then
6135 for tmp in $deplibrary_names ; do
6138 if test -f "$absdir/$objdir/$depdepl" ; then
6139 depdepl="$absdir/$objdir/$depdepl"
6140 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6141 if test -z "$darwin_install_name"; then
6142 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6144 compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6145 linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6151 path="-L$absdir/$objdir"
6155 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6156 test -z "$libdir" && \
6157 func_fatal_error "\`$deplib' is not a valid libtool archive"
6158 test "$absdir" != "$libdir" && \
6159 func_warning "\`$deplib' seems to be moved"
6165 case " $deplibs " in
6167 *) deplibs="$path $deplibs" ;;
6170 fi # link_all_deplibs != no
6172 done # for deplib in $libs
6173 if test "$pass" = link; then
6174 if test "$linkmode" = "prog"; then
6175 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6176 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6178 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6181 dependency_libs="$newdependency_libs"
6182 if test "$pass" = dlpreopen; then
6183 # Link the dlpreopened libraries before other libraries
6184 for deplib in $save_deplibs; do
6185 deplibs="$deplib $deplibs"
6188 if test "$pass" != dlopen; then
6189 if test "$pass" != conv; then
6190 # Make sure lib_search_path contains only unique directories.
6192 for dir in $newlib_search_path; do
6193 case "$lib_search_path " in
6195 *) lib_search_path="$lib_search_path $dir" ;;
6201 if test "$linkmode,$pass" != "prog,link"; then
6204 vars="compile_deplibs finalize_deplibs"
6206 for var in $vars dependency_libs; do
6207 # Add libraries to $var in reverse order
6208 eval tmp_libs=\$$var
6210 for deplib in $tmp_libs; do
6211 # FIXME: Pedantically, this is the right thing to do, so
6212 # that some nasty dependency loop isn't accidentally
6214 #new_libs="$deplib $new_libs"
6215 # Pragmatically, this seems to cause very few problems in
6218 -L*) new_libs="$deplib $new_libs" ;;
6221 # And here is the reason: when a library appears more
6222 # than once as an explicit dependence of a library, or
6223 # is implicitly linked in more than once by the
6224 # compiler, it is considered special, and multiple
6225 # occurrences thereof are not removed. Compare this
6226 # with having the same library being listed as a
6227 # dependency of multiple other libraries: in this case,
6228 # we know (pedantically, we assume) the library does not
6229 # need to be listed more than once, so we keep only the
6230 # last copy. This is not always right, but it is rare
6231 # enough that we require users that really mean to play
6232 # such unportable linking tricks to link the library
6233 # using -Wl,-lname, so that libtool does not consider it
6234 # for duplicate removal.
6235 case " $specialdeplibs " in
6236 *" $deplib "*) new_libs="$deplib $new_libs" ;;
6238 case " $new_libs " in
6240 *) new_libs="$deplib $new_libs" ;;
6248 for deplib in $new_libs; do
6251 case " $tmp_libs " in
6253 *) tmp_libs="$tmp_libs $deplib" ;;
6256 *) tmp_libs="$tmp_libs $deplib" ;;
6259 eval $var=\$tmp_libs
6262 # Last step: remove runtime libs from dependency_libs
6263 # (they stay in deplibs)
6265 for i in $dependency_libs ; do
6266 case " $predeps $postdeps $compiler_lib_search_path " in
6271 if test -n "$i" ; then
6272 tmp_libs="$tmp_libs $i"
6275 dependency_libs=$tmp_libs
6277 if test "$linkmode" = prog; then
6278 dlfiles="$newdlfiles"
6280 if test "$linkmode" = prog || test "$linkmode" = lib; then
6281 dlprefiles="$newdlprefiles"
6286 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6287 func_warning "\`-dlopen' is ignored for archives"
6292 func_warning "\`-l' and \`-L' are ignored for archives" ;;
6295 test -n "$rpath" && \
6296 func_warning "\`-rpath' is ignored for archives"
6298 test -n "$xrpath" && \
6299 func_warning "\`-R' is ignored for archives"
6301 test -n "$vinfo" && \
6302 func_warning "\`-version-info/-version-number' is ignored for archives"
6304 test -n "$release" && \
6305 func_warning "\`-release' is ignored for archives"
6307 test -n "$export_symbols$export_symbols_regex" && \
6308 func_warning "\`-export-symbols' is ignored for archives"
6310 # Now set the variables for building old libraries.
6311 build_libtool_libs=no
6313 objs="$objs$old_deplibs"
6317 # Make sure we only generate libraries of the form `libNAME.la'.
6320 func_stripname 'lib' '.la' "$outputname"
6321 name=$func_stripname_result
6322 eval "shared_ext=\"$shrext_cmds\""
6323 eval "libname=\"$libname_spec\""
6326 test "$module" = no && \
6327 func_fatal_help "libtool library \`$output' must begin with \`lib'"
6329 if test "$need_lib_prefix" != no; then
6330 # Add the "lib" prefix for modules if required
6331 func_stripname '' '.la' "$outputname"
6332 name=$func_stripname_result
6333 eval "shared_ext=\"$shrext_cmds\""
6334 eval "libname=\"$libname_spec\""
6336 func_stripname '' '.la' "$outputname"
6337 libname=$func_stripname_result
6342 if test -n "$objs"; then
6343 if test "$deplibs_check_method" != pass_all; then
6344 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6347 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6348 $ECHO "*** objects $objs is not portable!"
6349 libobjs="$libobjs $objs"
6353 test "$dlself" != no && \
6354 func_warning "\`-dlopen self' is ignored for libtool libraries"
6358 test "$#" -gt 1 && \
6359 func_warning "ignoring multiple \`-rpath's for a libtool library"
6364 if test -z "$rpath"; then
6365 if test "$build_libtool_libs" = yes; then
6366 # Building a libtool convenience library.
6367 # Some compilers have problems with a `.al' extension so
6368 # convenience libraries should have the same extension an
6369 # archive normally would.
6370 oldlibs="$output_objdir/$libname.$libext $oldlibs"
6371 build_libtool_libs=convenience
6375 test -n "$vinfo" && \
6376 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6378 test -n "$release" && \
6379 func_warning "\`-release' is ignored for convenience libraries"
6382 # Parse the version information argument.
6383 save_ifs="$IFS"; IFS=':'
6384 set dummy $vinfo 0 0 0
6389 func_fatal_help "too many parameters to \`-version-info'"
6391 # convert absolute version numbers to libtool ages
6392 # this retains compatibility with .la files and attempts
6393 # to make the code below a bit more comprehensible
6395 case $vinfo_number in
6399 number_revision="$3"
6401 # There are really only two kinds -- those that
6402 # use the current revision as the major version
6403 # and those that subtract age and use age as
6404 # a minor version. But, then there is irix
6405 # which has an extra 1 added just for fun
6407 case $version_type in
6408 darwin|linux|osf|windows|none)
6409 func_arith $number_major + $number_minor
6410 current=$func_arith_result
6412 revision="$number_revision"
6414 freebsd-aout|freebsd-elf|qnx|sunos)
6415 current="$number_major"
6416 revision="$number_minor"
6420 func_arith $number_major + $number_minor
6421 current=$func_arith_result
6423 revision="$number_minor"
6424 lt_irix_increment=no
6435 # Check that each of the things are valid numbers.
6437 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]) ;;
6439 func_error "CURRENT \`$current' must be a nonnegative integer"
6440 func_fatal_error "\`$vinfo' is not valid version information"
6445 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]) ;;
6447 func_error "REVISION \`$revision' must be a nonnegative integer"
6448 func_fatal_error "\`$vinfo' is not valid version information"
6453 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]) ;;
6455 func_error "AGE \`$age' must be a nonnegative integer"
6456 func_fatal_error "\`$vinfo' is not valid version information"
6460 if test "$age" -gt "$current"; then
6461 func_error "AGE \`$age' is greater than the current interface number \`$current'"
6462 func_fatal_error "\`$vinfo' is not valid version information"
6465 # Calculate the version variables.
6469 case $version_type in
6473 # Like Linux, but with the current version available in
6474 # verstring for coding it into the library header
6475 func_arith $current - $age
6476 major=.$func_arith_result
6477 versuffix="$major.$age.$revision"
6478 # Darwin ld doesn't like 0 for these options...
6479 func_arith $current + 1
6480 minor_current=$func_arith_result
6481 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6482 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6487 versuffix=".$current.$revision";
6492 versuffix=".$current"
6496 if test "X$lt_irix_increment" = "Xno"; then
6497 func_arith $current - $age
6499 func_arith $current - $age + 1
6501 major=$func_arith_result
6503 case $version_type in
6504 nonstopux) verstring_prefix=nonstopux ;;
6505 *) verstring_prefix=sgi ;;
6507 verstring="$verstring_prefix$major.$revision"
6509 # Add in all the interfaces that we are compatible with.
6511 while test "$loop" -ne 0; do
6512 func_arith $revision - $loop
6513 iface=$func_arith_result
6514 func_arith $loop - 1
6515 loop=$func_arith_result
6516 verstring="$verstring_prefix$major.$iface:$verstring"
6519 # Before this point, $major must not contain `.'.
6521 versuffix="$major.$revision"
6525 func_arith $current - $age
6526 major=.$func_arith_result
6527 versuffix="$major.$age.$revision"
6531 func_arith $current - $age
6532 major=.$func_arith_result
6533 versuffix=".$current.$age.$revision"
6534 verstring="$current.$age.$revision"
6536 # Add in all the interfaces that we are compatible with.
6538 while test "$loop" -ne 0; do
6539 func_arith $current - $loop
6540 iface=$func_arith_result
6541 func_arith $loop - 1
6542 loop=$func_arith_result
6543 verstring="$verstring:${iface}.0"
6546 # Make executables depend on our current version.
6547 verstring="$verstring:${current}.0"
6552 versuffix=".$current"
6557 versuffix=".$current.$revision"
6561 # Use '-' rather than '.', since we only want one
6562 # extension on DOS 8.3 filesystems.
6563 func_arith $current - $age
6564 major=$func_arith_result
6569 func_fatal_configuration "unknown library version type \`$version_type'"
6573 # Clear the version info if we defaulted, and they specified a release.
6574 if test -z "$vinfo" && test -n "$release"; then
6576 case $version_type in
6578 # we can't check for "0.0" in archive_cmds due to quoting
6579 # problems, so we reset it completely
6586 if test "$need_version" = no; then
6593 # Remove version info from name if versioning should be avoided
6594 if test "$avoid_version" = yes && test "$need_version" = no; then
6600 # Check to see if the archive will have undefined symbols.
6601 if test "$allow_undefined" = yes; then
6602 if test "$allow_undefined_flag" = unsupported; then
6603 func_warning "undefined symbols not allowed in $host shared libraries"
6604 build_libtool_libs=no
6608 # Don't allow undefined symbols.
6609 allow_undefined_flag="$no_undefined_flag"
6614 func_generate_dlsyms "$libname" "$libname" "yes"
6615 libobjs="$libobjs $symfileobj"
6616 test "X$libobjs" = "X " && libobjs=
6618 if test "$mode" != relink; then
6619 # Remove our outputs, but don't remove object files since they
6620 # may have been created when compiling PIC objects.
6622 tempremovelist=`$ECHO "$output_objdir/*"`
6623 for p in $tempremovelist; do
6627 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6628 if test "X$precious_files_regex" != "X"; then
6629 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6634 removelist="$removelist $p"
6639 test -n "$removelist" && \
6640 func_show_eval "${RM}r \$removelist"
6643 # Now set the variables for building old libraries.
6644 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6645 oldlibs="$oldlibs $output_objdir/$libname.$libext"
6647 # Transform .lo files to .o files.
6648 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
6651 # Eliminate all temporary directories.
6652 #for path in $notinst_path; do
6653 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
6654 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
6655 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
6658 if test -n "$xrpath"; then
6659 # If the user specified any rpath flags, then add them.
6661 for libdir in $xrpath; do
6662 temp_xrpath="$temp_xrpath -R$libdir"
6663 case "$finalize_rpath " in
6665 *) finalize_rpath="$finalize_rpath $libdir" ;;
6668 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6669 dependency_libs="$temp_xrpath $dependency_libs"
6673 # Make sure dlfiles contains only unique files that won't be dlpreopened
6674 old_dlfiles="$dlfiles"
6676 for lib in $old_dlfiles; do
6677 case " $dlprefiles $dlfiles " in
6679 *) dlfiles="$dlfiles $lib" ;;
6683 # Make sure dlprefiles contains only unique files
6684 old_dlprefiles="$dlprefiles"
6686 for lib in $old_dlprefiles; do
6687 case "$dlprefiles " in
6689 *) dlprefiles="$dlprefiles $lib" ;;
6693 if test "$build_libtool_libs" = yes; then
6694 if test -n "$rpath"; then
6696 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
6697 # these systems don't actually have a c library (as such)!
6699 *-*-rhapsody* | *-*-darwin1.[012])
6700 # Rhapsody C library is in the System framework
6701 deplibs="$deplibs System.ltframework"
6704 # Don't link with libc until the a.out ld.so is fixed.
6706 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6707 # Do not include libc due to us having libc/libc_r.
6709 *-*-sco3.2v5* | *-*-sco5v6*)
6710 # Causes problems with __ctype
6712 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6713 # Compiler inserts libc in the correct place for threads to work
6716 # Add libc to deplibs on all other systems if necessary.
6717 if test "$build_libtool_need_lc" = "yes"; then
6718 deplibs="$deplibs -lc"
6724 # Transform deplibs into only deplibs that can be linked in shared.
6726 libname_save=$libname
6727 release_save=$release
6728 versuffix_save=$versuffix
6730 # I'm not sure if I'm treating the release correctly. I think
6731 # release should show up in the -l (ie -lgmp5) so we don't want to
6732 # add it in twice. Is that correct?
6738 case $deplibs_check_method in
6740 # Don't check for shared/static. Everything works.
6741 # This might be a little naive. We might want to check
6742 # whether the library exists or not. But this is on
6743 # osf3 & osf4 and I'm not really sure... Just
6744 # implementing what was already the behavior.
6748 # This code stresses the "libraries are programs" paradigm to its
6749 # limits. Maybe even breaks it. We compile a program, linking it
6750 # against the deplibs as a proxy for the library. Then we can check
6751 # whether they linked in statically or dynamically with ldd.
6752 $opt_dry_run || $RM conftest.c
6753 cat > conftest.c <<EOF
6754 int main() { return 0; }
6756 $opt_dry_run || $RM conftest
6757 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
6758 ldd_output=`ldd conftest`
6759 for i in $deplibs; do
6762 func_stripname -l '' "$i"
6763 name=$func_stripname_result
6764 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6765 case " $predeps $postdeps " in
6767 newdeplibs="$newdeplibs $i"
6772 if test -n "$i" ; then
6773 eval "libname=\"$libname_spec\""
6774 eval "deplib_matches=\"$library_names_spec\""
6775 set dummy $deplib_matches; shift
6777 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6778 newdeplibs="$newdeplibs $i"
6782 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6783 echo "*** I have the capability to make that library automatically link in when"
6784 echo "*** you link to this library. But I can only do this if you have a"
6785 echo "*** shared version of the library, which I believe you do not have"
6786 echo "*** because a test_compile did reveal that the linker did not use it for"
6787 echo "*** its dynamic dependency list that programs get resolved with at runtime."
6792 newdeplibs="$newdeplibs $i"
6797 # Error occurred in the first compile. Let's try to salvage
6798 # the situation: Compile a separate program for each library.
6799 for i in $deplibs; do
6802 func_stripname -l '' "$i"
6803 name=$func_stripname_result
6804 $opt_dry_run || $RM conftest
6805 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
6806 ldd_output=`ldd conftest`
6807 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6808 case " $predeps $postdeps " in
6810 newdeplibs="$newdeplibs $i"
6815 if test -n "$i" ; then
6816 eval "libname=\"$libname_spec\""
6817 eval "deplib_matches=\"$library_names_spec\""
6818 set dummy $deplib_matches; shift
6820 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
6821 newdeplibs="$newdeplibs $i"
6825 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
6826 echo "*** I have the capability to make that library automatically link in when"
6827 echo "*** you link to this library. But I can only do this if you have a"
6828 echo "*** shared version of the library, which you do not appear to have"
6829 echo "*** because a test_compile did reveal that the linker did not use this one"
6830 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
6836 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
6837 echo "*** make it link in! You will probably need to install it or some"
6838 echo "*** library that it depends on before this library will be fully"
6839 echo "*** functional. Installing it before continuing would be even better."
6843 newdeplibs="$newdeplibs $i"
6850 set dummy $deplibs_check_method; shift
6851 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6852 for a_deplib in $deplibs; do
6855 func_stripname -l '' "$a_deplib"
6856 name=$func_stripname_result
6857 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6858 case " $predeps $postdeps " in
6860 newdeplibs="$newdeplibs $a_deplib"
6865 if test -n "$a_deplib" ; then
6866 eval "libname=\"$libname_spec\""
6867 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6868 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6869 for potent_lib in $potential_libs; do
6870 # Follow soft links.
6871 if ls -lLd "$potent_lib" 2>/dev/null |
6872 $GREP " -> " >/dev/null; then
6875 # The statement above tries to avoid entering an
6876 # endless loop below, in case of cyclic links.
6877 # We might still enter an endless loop, since a link
6878 # loop can be closed while we follow links,
6880 potlib="$potent_lib"
6881 while test -h "$potlib" 2>/dev/null; do
6882 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
6884 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
6885 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
6888 if eval "$file_magic_cmd \"\$potlib\"" 2>/dev/null |
6890 $EGREP "$file_magic_regex" > /dev/null; then
6891 newdeplibs="$newdeplibs $a_deplib"
6898 if test -n "$a_deplib" ; then
6901 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6902 echo "*** I have the capability to make that library automatically link in when"
6903 echo "*** you link to this library. But I can only do this if you have a"
6904 echo "*** shared version of the library, which you do not appear to have"
6905 echo "*** because I did check the linker path looking for a file starting"
6906 if test -z "$potlib" ; then
6907 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
6909 $ECHO "*** with $libname and none of the candidates passed a file format test"
6910 $ECHO "*** using a file magic. Last file checked: $potlib"
6915 # Add a -L argument.
6916 newdeplibs="$newdeplibs $a_deplib"
6919 done # Gone through all deplibs.
6922 set dummy $deplibs_check_method; shift
6923 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6924 for a_deplib in $deplibs; do
6927 func_stripname -l '' "$a_deplib"
6928 name=$func_stripname_result
6929 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6930 case " $predeps $postdeps " in
6932 newdeplibs="$newdeplibs $a_deplib"
6937 if test -n "$a_deplib" ; then
6938 eval "libname=\"$libname_spec\""
6939 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
6940 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
6941 for potent_lib in $potential_libs; do
6942 potlib="$potent_lib" # see symlink-check above in file_magic test
6943 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
6944 $EGREP "$match_pattern_regex" > /dev/null; then
6945 newdeplibs="$newdeplibs $a_deplib"
6952 if test -n "$a_deplib" ; then
6955 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
6956 echo "*** I have the capability to make that library automatically link in when"
6957 echo "*** you link to this library. But I can only do this if you have a"
6958 echo "*** shared version of the library, which you do not appear to have"
6959 echo "*** because I did check the linker path looking for a file starting"
6960 if test -z "$potlib" ; then
6961 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
6963 $ECHO "*** with $libname and none of the candidates passed a file format test"
6964 $ECHO "*** using a regex pattern. Last file checked: $potlib"
6969 # Add a -L argument.
6970 newdeplibs="$newdeplibs $a_deplib"
6973 done # Gone through all deplibs.
6977 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
6978 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6979 for i in $predeps $postdeps ; do
6980 # can't use Xsed below, because $i might contain '/'
6981 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
6984 case $tmp_deplibs in
6987 if test "X$deplibs_check_method" = "Xnone"; then
6988 echo "*** Warning: inter-library dependencies are not supported in this platform."
6990 echo "*** Warning: inter-library dependencies are not known to be supported."
6992 echo "*** All declared inter-library dependencies are being dropped."
6998 versuffix=$versuffix_save
7000 release=$release_save
7001 libname=$libname_save
7005 *-*-rhapsody* | *-*-darwin1.[012])
7006 # On Rhapsody replace the C library with the System framework
7007 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7011 if test "$droppeddeps" = yes; then
7012 if test "$module" = yes; then
7014 echo "*** Warning: libtool could not satisfy all declared inter-library"
7015 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7016 echo "*** a static module, that should work as long as the dlopening"
7017 echo "*** application is linked with the -dlopen flag."
7018 if test -z "$global_symbol_pipe"; then
7020 echo "*** However, this would only work if libtool was able to extract symbol"
7021 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7022 echo "*** not find such a program. So, this module is probably useless."
7023 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7025 if test "$build_old_libs" = no; then
7026 oldlibs="$output_objdir/$libname.$libext"
7027 build_libtool_libs=module
7030 build_libtool_libs=no
7033 echo "*** The inter-library dependencies that have been dropped here will be"
7034 echo "*** automatically added whenever a program is linked with this library"
7035 echo "*** or is declared to -dlopen it."
7037 if test "$allow_undefined" = no; then
7039 echo "*** Since this library must not contain undefined symbols,"
7040 echo "*** because either the platform does not support them or"
7041 echo "*** it was explicitly requested with -no-undefined,"
7042 echo "*** libtool will only create a static version of it."
7043 if test "$build_old_libs" = no; then
7044 oldlibs="$output_objdir/$libname.$libext"
7045 build_libtool_libs=module
7048 build_libtool_libs=no
7053 # Done checking deplibs!
7056 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7059 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7060 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7061 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7065 # move library search paths that coincide with paths to not yet
7066 # installed libraries to the beginning of the library search list
7068 for path in $notinst_path; do
7069 case " $new_libs " in
7070 *" -L$path/$objdir "*) ;;
7072 case " $deplibs " in
7073 *" -L$path/$objdir "*)
7074 new_libs="$new_libs -L$path/$objdir" ;;
7079 for deplib in $deplibs; do
7082 case " $new_libs " in
7084 *) new_libs="$new_libs $deplib" ;;
7087 *) new_libs="$new_libs $deplib" ;;
7092 # All the library-specific variables (install_libdir is set above).
7097 # Test again, we may have decided not to build it any more
7098 if test "$build_libtool_libs" = yes; then
7099 if test "$hardcode_into_libs" = yes; then
7100 # Hardcode the library paths
7103 rpath="$finalize_rpath"
7104 test "$mode" != relink && rpath="$compile_rpath$rpath"
7105 for libdir in $rpath; do
7106 if test -n "$hardcode_libdir_flag_spec"; then
7107 if test -n "$hardcode_libdir_separator"; then
7108 if test -z "$hardcode_libdirs"; then
7109 hardcode_libdirs="$libdir"
7111 # Just accumulate the unique libdirs.
7112 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7113 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7116 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7121 eval "flag=\"$hardcode_libdir_flag_spec\""
7122 dep_rpath="$dep_rpath $flag"
7124 elif test -n "$runpath_var"; then
7125 case "$perm_rpath " in
7127 *) perm_rpath="$perm_rpath $libdir" ;;
7131 # Substitute the hardcoded libdirs into the rpath.
7132 if test -n "$hardcode_libdir_separator" &&
7133 test -n "$hardcode_libdirs"; then
7134 libdir="$hardcode_libdirs"
7135 if test -n "$hardcode_libdir_flag_spec_ld"; then
7136 eval "dep_rpath=\"$hardcode_libdir_flag_spec_ld\""
7138 eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
7141 if test -n "$runpath_var" && test -n "$perm_rpath"; then
7142 # We should set the runpath_var.
7144 for dir in $perm_rpath; do
7147 eval $runpath_var=\$rpath\$$runpath_var
7150 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7153 shlibpath="$finalize_shlibpath"
7154 test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7155 if test -n "$shlibpath"; then
7156 eval $shlibpath_var=\$shlibpath\$$shlibpath_var
7157 export $shlibpath_var
7160 # Get the real and link names of the library.
7161 eval "shared_ext=\"$shrext_cmds\""
7162 eval "library_names=\"$library_names_spec\""
7163 set dummy $library_names
7168 if test -n "$soname_spec"; then
7169 eval "soname=\"$soname_spec\""
7173 if test -z "$dlname"; then
7177 lib="$output_objdir/$realname"
7181 linknames="$linknames $link"
7184 # Use standard objects if they are pic
7185 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
7186 test "X$libobjs" = "X " && libobjs=
7189 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7190 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7191 export_symbols="$output_objdir/$libname.uexp"
7192 delfiles="$delfiles $export_symbols"
7195 orig_export_symbols=
7197 cygwin* | mingw* | cegcc*)
7198 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7199 # exporting using user supplied symfile
7200 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7201 # and it's NOT already a .def file. Must figure out
7202 # which of the given symbols are data symbols and tag
7203 # them as such. So, trigger use of export_symbols_cmds.
7204 # export_symbols gets reassigned inside the "prepare
7205 # the list of exported symbols" if statement, so the
7206 # include_expsyms logic still works.
7207 orig_export_symbols="$export_symbols"
7209 always_export_symbols=yes
7215 # Prepare the list of exported symbols
7216 if test -z "$export_symbols"; then
7217 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7218 func_verbose "generating symbol list for \`$libname.la'"
7219 export_symbols="$output_objdir/$libname.exp"
7220 $opt_dry_run || $RM $export_symbols
7221 cmds=$export_symbols_cmds
7222 save_ifs="$IFS"; IFS='~'
7223 for cmd in $cmds; do
7227 len=$func_len_result
7228 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7229 func_show_eval "$cmd" 'exit $?'
7230 skipped_export=false
7232 # The command line is too long to execute in one step.
7233 func_verbose "using reloadable object file for export list..."
7235 # Break out early, otherwise skipped_export may be
7236 # set to false by a later but shorter cmd.
7241 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7242 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7243 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7248 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7249 tmp_export_symbols="$export_symbols"
7250 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7251 $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
7254 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7255 # The given exports_symbols file has to be filtered, so filter it.
7256 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7257 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7258 # 's' commands which not all seds can handle. GNU sed should be fine
7259 # though. Also, the filter scales superlinearly with the number of
7260 # global variables. join(1) would be nice here, but unfortunately
7261 # isn't a blessed tool.
7262 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7263 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7264 export_symbols=$output_objdir/$libname.def
7265 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7269 for test_deplib in $deplibs; do
7270 case " $convenience " in
7271 *" $test_deplib "*) ;;
7273 tmp_deplibs="$tmp_deplibs $test_deplib"
7277 deplibs="$tmp_deplibs"
7279 if test -n "$convenience"; then
7280 if test -n "$whole_archive_flag_spec" &&
7281 test "$compiler_needs_object" = yes &&
7282 test -z "$libobjs"; then
7283 # extract the archives, so we have objects to list.
7284 # TODO: could optimize this to just extract one archive.
7285 whole_archive_flag_spec=
7287 if test -n "$whole_archive_flag_spec"; then
7288 save_libobjs=$libobjs
7289 eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7290 test "X$libobjs" = "X " && libobjs=
7292 gentop="$output_objdir/${outputname}x"
7293 generated="$generated $gentop"
7295 func_extract_archives $gentop $convenience
7296 libobjs="$libobjs $func_extract_archives_result"
7297 test "X$libobjs" = "X " && libobjs=
7301 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7302 eval "flag=\"$thread_safe_flag_spec\""
7303 linker_flags="$linker_flags $flag"
7306 # Make a backup of the uninstalled library when relinking
7307 if test "$mode" = relink; then
7308 $opt_dry_run || (cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U) || exit $?
7311 # Do each of the archive commands.
7312 if test "$module" = yes && test -n "$module_cmds" ; then
7313 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7314 eval "test_cmds=\"$module_expsym_cmds\""
7315 cmds=$module_expsym_cmds
7317 eval "test_cmds=\"$module_cmds\""
7321 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7322 eval "test_cmds=\"$archive_expsym_cmds\""
7323 cmds=$archive_expsym_cmds
7325 eval "test_cmds=\"$archive_cmds\""
7330 if test "X$skipped_export" != "X:" &&
7331 func_len " $test_cmds" &&
7332 len=$func_len_result &&
7333 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7336 # The command line is too long to link in one step, link piecewise
7337 # or, if using GNU ld and skipped_export is not :, use a linker
7340 # Save the value of $output and $libobjs because we want to
7341 # use them later. If we have whole_archive_flag_spec, we
7342 # want to use save_libobjs as it was before
7343 # whole_archive_flag_spec was expanded, because we can't
7344 # assume the linker understands whole_archive_flag_spec.
7345 # This may have to be revisited, in case too many
7346 # convenience libraries get linked in and end up exceeding
7348 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7349 save_libobjs=$libobjs
7352 func_basename "$output"
7353 output_la=$func_basename_result
7355 # Clear the reloadable object creation command queue and
7356 # initialize k to one.
7363 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7364 output=${output_objdir}/${output_la}.lnkscript
7365 func_verbose "creating GNU ld script: $output"
7366 echo 'INPUT (' > $output
7367 for obj in $save_libobjs
7369 $ECHO "$obj" >> $output
7372 delfiles="$delfiles $output"
7373 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7374 output=${output_objdir}/${output_la}.lnk
7375 func_verbose "creating linker input file list: $output"
7380 if test "$compiler_needs_object" = yes; then
7386 $ECHO "$obj" >> $output
7388 delfiles="$delfiles $output"
7389 output=$firstobj\"$file_list_spec$output\"
7391 if test -n "$save_libobjs"; then
7392 func_verbose "creating reloadable object files..."
7393 output=$output_objdir/$output_la-${k}.$objext
7394 eval "test_cmds=\"$reload_cmds\""
7395 func_len " $test_cmds"
7396 len0=$func_len_result
7399 # Loop over the list of objects to be linked.
7400 for obj in $save_libobjs
7403 func_arith $len + $func_len_result
7404 len=$func_arith_result
7405 if test "X$objlist" = X ||
7406 test "$len" -lt "$max_cmd_len"; then
7407 func_append objlist " $obj"
7409 # The command $test_cmds is almost too long, add a
7410 # command to the queue.
7411 if test "$k" -eq 1 ; then
7412 # The first file doesn't have a previous command to add.
7413 reload_objs=$objlist
7414 eval "concat_cmds=\"$reload_cmds\""
7416 # All subsequent reloadable object files will link in
7417 # the last one created.
7418 reload_objs="$objlist $last_robj"
7419 eval "concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\""
7421 last_robj=$output_objdir/$output_la-${k}.$objext
7423 k=$func_arith_result
7424 output=$output_objdir/$output_la-${k}.$objext
7426 func_len " $last_robj"
7427 func_arith $len0 + $func_len_result
7428 len=$func_arith_result
7431 # Handle the remaining objects by creating one last
7432 # reloadable object file. All subsequent reloadable object
7433 # files will link in the last one created.
7434 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7435 reload_objs="$objlist $last_robj"
7436 eval "concat_cmds=\"\${concat_cmds}$reload_cmds\""
7437 if test -n "$last_robj"; then
7438 eval "concat_cmds=\"\${concat_cmds}~\$RM $last_robj\""
7440 delfiles="$delfiles $output"
7446 if ${skipped_export-false}; then
7447 func_verbose "generating symbol list for \`$libname.la'"
7448 export_symbols="$output_objdir/$libname.exp"
7449 $opt_dry_run || $RM $export_symbols
7451 # Append the command to create the export file.
7452 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7453 eval "concat_cmds=\"\$concat_cmds$export_symbols_cmds\""
7454 if test -n "$last_robj"; then
7455 eval "concat_cmds=\"\$concat_cmds~\$RM $last_robj\""
7459 test -n "$save_libobjs" &&
7460 func_verbose "creating a temporary reloadable object file: $output"
7462 # Loop through the commands generated above and execute them.
7463 save_ifs="$IFS"; IFS='~'
7464 for cmd in $concat_cmds; do
7467 func_quote_for_expand "$cmd"
7468 eval "func_echo $func_quote_for_expand_result"
7470 $opt_dry_run || eval "$cmd" || {
7473 # Restore the uninstalled library and exit
7474 if test "$mode" = relink; then
7475 ( cd "$output_objdir" && \
7476 $RM "${realname}T" && \
7477 $MV "${realname}U" "$realname" )
7485 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7486 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7487 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7491 if ${skipped_export-false}; then
7492 if test -n "$export_symbols" && test -n "$include_expsyms"; then
7493 tmp_export_symbols="$export_symbols"
7494 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7495 $opt_dry_run || $ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"
7498 if test -n "$orig_export_symbols"; then
7499 # The given exports_symbols file has to be filtered, so filter it.
7500 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7501 # FIXME: $output_objdir/$libname.filter potentially contains lots of
7502 # 's' commands which not all seds can handle. GNU sed should be fine
7503 # though. Also, the filter scales superlinearly with the number of
7504 # global variables. join(1) would be nice here, but unfortunately
7505 # isn't a blessed tool.
7506 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7507 delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7508 export_symbols=$output_objdir/$libname.def
7509 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7514 # Restore the value of output.
7517 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7518 eval "libobjs=\"\$libobjs $whole_archive_flag_spec\""
7519 test "X$libobjs" = "X " && libobjs=
7521 # Expand the library linking commands again to reset the
7522 # value of $libobjs for piecewise linking.
7524 # Do each of the archive commands.
7525 if test "$module" = yes && test -n "$module_cmds" ; then
7526 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7527 cmds=$module_expsym_cmds
7532 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7533 cmds=$archive_expsym_cmds
7540 if test -n "$delfiles"; then
7541 # Append the command to remove temporary files to $cmds.
7542 eval "cmds=\"\$cmds~\$RM $delfiles\""
7545 # Add any objects from preloaded convenience libraries
7546 if test -n "$dlprefiles"; then
7547 gentop="$output_objdir/${outputname}x"
7548 generated="$generated $gentop"
7550 func_extract_archives $gentop $dlprefiles
7551 libobjs="$libobjs $func_extract_archives_result"
7552 test "X$libobjs" = "X " && libobjs=
7555 save_ifs="$IFS"; IFS='~'
7556 for cmd in $cmds; do
7560 func_quote_for_expand "$cmd"
7561 eval "func_echo $func_quote_for_expand_result"
7563 $opt_dry_run || eval "$cmd" || {
7566 # Restore the uninstalled library and exit
7567 if test "$mode" = relink; then
7568 ( cd "$output_objdir" && \
7569 $RM "${realname}T" && \
7570 $MV "${realname}U" "$realname" )
7578 # Restore the uninstalled library and exit
7579 if test "$mode" = relink; then
7580 $opt_dry_run || (cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname) || exit $?
7582 if test -n "$convenience"; then
7583 if test -z "$whole_archive_flag_spec"; then
7584 func_show_eval '${RM}r "$gentop"'
7591 # Create links to the real library.
7592 for linkname in $linknames; do
7593 if test "$realname" != "$linkname"; then
7594 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7598 # If -module or -export-dynamic was specified, set the dlname.
7599 if test "$module" = yes || test "$export_dynamic" = yes; then
7600 # On all known operating systems, these are identical.
7607 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7608 func_warning "\`-dlopen' is ignored for objects"
7613 func_warning "\`-l' and \`-L' are ignored for objects" ;;
7616 test -n "$rpath" && \
7617 func_warning "\`-rpath' is ignored for objects"
7619 test -n "$xrpath" && \
7620 func_warning "\`-R' is ignored for objects"
7622 test -n "$vinfo" && \
7623 func_warning "\`-version-info' is ignored for objects"
7625 test -n "$release" && \
7626 func_warning "\`-release' is ignored for objects"
7630 test -n "$objs$old_deplibs" && \
7631 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7635 obj=$func_lo2o_result
7643 # Delete the old objects.
7644 $opt_dry_run || $RM $obj $libobj
7646 # Objects from convenience libraries. This assumes
7647 # single-version convenience libraries. Whenever we create
7648 # different ones for PIC/non-PIC, this we'll have to duplicate
7652 # reload_cmds runs $LD directly, so let us get rid of
7653 # -Wl from whole_archive_flag_spec and hope we can get by with
7654 # turning comma into space..
7657 if test -n "$convenience"; then
7658 if test -n "$whole_archive_flag_spec"; then
7659 eval "tmp_whole_archive_flags=\"$whole_archive_flag_spec\""
7660 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
7662 gentop="$output_objdir/${obj}x"
7663 generated="$generated $gentop"
7665 func_extract_archives $gentop $convenience
7666 reload_conv_objs="$reload_objs $func_extract_archives_result"
7670 # Create the old-style object.
7671 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7674 func_execute_cmds "$reload_cmds" 'exit $?'
7676 # Exit if we aren't doing a library object file.
7677 if test -z "$libobj"; then
7678 if test -n "$gentop"; then
7679 func_show_eval '${RM}r "$gentop"'
7685 if test "$build_libtool_libs" != yes; then
7686 if test -n "$gentop"; then
7687 func_show_eval '${RM}r "$gentop"'
7690 # Create an invalid libtool object if no PIC, so that we don't
7691 # accidentally link it into a program.
7692 # $show "echo timestamp > $libobj"
7693 # $opt_dry_run || echo timestamp > $libobj || exit $?
7697 if test -n "$pic_flag" || test "$pic_mode" != default; then
7698 # Only do commands if we really have different PIC objects.
7699 reload_objs="$libobjs $reload_conv_objs"
7701 func_execute_cmds "$reload_cmds" 'exit $?'
7704 if test -n "$gentop"; then
7705 func_show_eval '${RM}r "$gentop"'
7713 *cygwin*) func_stripname '' '.exe' "$output"
7714 output=$func_stripname_result.exe;;
7716 test -n "$vinfo" && \
7717 func_warning "\`-version-info' is ignored for programs"
7719 test -n "$release" && \
7720 func_warning "\`-release' is ignored for programs"
7722 test "$preload" = yes \
7723 && test "$dlopen_support" = unknown \
7724 && test "$dlopen_self" = unknown \
7725 && test "$dlopen_self_static" = unknown && \
7726 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7729 *-*-rhapsody* | *-*-darwin1.[012])
7730 # On Rhapsody replace the C library is the System framework
7731 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
7732 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
7738 # Don't allow lazy linking, it breaks C++ global constructors
7739 # But is supposedly fixed on 10.4 or later (yay!).
7740 if test "$tagname" = CXX ; then
7741 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
7743 compile_command="$compile_command ${wl}-bind_at_load"
7744 finalize_command="$finalize_command ${wl}-bind_at_load"
7748 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7749 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7750 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7755 # move library search paths that coincide with paths to not yet
7756 # installed libraries to the beginning of the library search list
7758 for path in $notinst_path; do
7759 case " $new_libs " in
7760 *" -L$path/$objdir "*) ;;
7762 case " $compile_deplibs " in
7763 *" -L$path/$objdir "*)
7764 new_libs="$new_libs -L$path/$objdir" ;;
7769 for deplib in $compile_deplibs; do
7772 case " $new_libs " in
7774 *) new_libs="$new_libs $deplib" ;;
7777 *) new_libs="$new_libs $deplib" ;;
7780 compile_deplibs="$new_libs"
7783 compile_command="$compile_command $compile_deplibs"
7784 finalize_command="$finalize_command $finalize_deplibs"
7786 if test -n "$rpath$xrpath"; then
7787 # If the user specified any rpath flags, then add them.
7788 for libdir in $rpath $xrpath; do
7789 # This is the magic to use -rpath.
7790 case "$finalize_rpath " in
7792 *) finalize_rpath="$finalize_rpath $libdir" ;;
7797 # Now hardcode the library paths
7800 for libdir in $compile_rpath $finalize_rpath; do
7801 if test -n "$hardcode_libdir_flag_spec"; then
7802 if test -n "$hardcode_libdir_separator"; then
7803 if test -z "$hardcode_libdirs"; then
7804 hardcode_libdirs="$libdir"
7806 # Just accumulate the unique libdirs.
7807 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7808 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7811 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7816 eval "flag=\"$hardcode_libdir_flag_spec\""
7817 rpath="$rpath $flag"
7819 elif test -n "$runpath_var"; then
7820 case "$perm_rpath " in
7822 *) perm_rpath="$perm_rpath $libdir" ;;
7826 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7827 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
7828 case :$dllsearchpath: in
7830 ::) dllsearchpath=$libdir;;
7831 *) dllsearchpath="$dllsearchpath:$libdir";;
7833 case :$dllsearchpath: in
7834 *":$testbindir:"*) ;;
7835 ::) dllsearchpath=$testbindir;;
7836 *) dllsearchpath="$dllsearchpath:$testbindir";;
7841 # Substitute the hardcoded libdirs into the rpath.
7842 if test -n "$hardcode_libdir_separator" &&
7843 test -n "$hardcode_libdirs"; then
7844 libdir="$hardcode_libdirs"
7845 eval "rpath=\" $hardcode_libdir_flag_spec\""
7847 compile_rpath="$rpath"
7851 for libdir in $finalize_rpath; do
7852 if test -n "$hardcode_libdir_flag_spec"; then
7853 if test -n "$hardcode_libdir_separator"; then
7854 if test -z "$hardcode_libdirs"; then
7855 hardcode_libdirs="$libdir"
7857 # Just accumulate the unique libdirs.
7858 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7859 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7862 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7867 eval "flag=\"$hardcode_libdir_flag_spec\""
7868 rpath="$rpath $flag"
7870 elif test -n "$runpath_var"; then
7871 case "$finalize_perm_rpath " in
7873 *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
7877 # Substitute the hardcoded libdirs into the rpath.
7878 if test -n "$hardcode_libdir_separator" &&
7879 test -n "$hardcode_libdirs"; then
7880 libdir="$hardcode_libdirs"
7881 eval "rpath=\" $hardcode_libdir_flag_spec\""
7883 finalize_rpath="$rpath"
7885 if test -n "$libobjs" && test "$build_old_libs" = yes; then
7886 # Transform all the library objects into standard objects.
7887 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7888 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
7891 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
7893 # template prelinking step
7894 if test -n "$prelink_cmds"; then
7895 func_execute_cmds "$prelink_cmds" 'exit $?'
7898 wrappers_required=yes
7900 *cegcc* | *mingw32ce*)
7901 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
7902 wrappers_required=no
7904 *cygwin* | *mingw* )
7905 if test "$build_libtool_libs" != yes; then
7906 wrappers_required=no
7910 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
7911 wrappers_required=no
7915 if test "$wrappers_required" = no; then
7916 # Replace the output file specification.
7917 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7918 link_command="$compile_command$compile_rpath"
7920 # We have no uninstalled library dependencies, so finalize right now.
7922 func_show_eval "$link_command" 'exit_status=$?'
7924 # Delete the generated files.
7925 if test -f "$output_objdir/${outputname}S.${objext}"; then
7926 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
7932 if test -n "$compile_shlibpath$finalize_shlibpath"; then
7933 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
7935 if test -n "$finalize_shlibpath"; then
7936 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
7941 if test -n "$runpath_var"; then
7942 if test -n "$perm_rpath"; then
7943 # We should set the runpath_var.
7945 for dir in $perm_rpath; do
7948 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
7950 if test -n "$finalize_perm_rpath"; then
7951 # We should set the runpath_var.
7953 for dir in $finalize_perm_rpath; do
7956 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
7960 if test "$no_install" = yes; then
7961 # We don't need to create a wrapper script.
7962 link_command="$compile_var$compile_command$compile_rpath"
7963 # Replace the output file specification.
7964 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
7965 # Delete the old output file.
7966 $opt_dry_run || $RM $output
7967 # Link the executable and exit
7968 func_show_eval "$link_command" 'exit $?'
7972 if test "$hardcode_action" = relink; then
7973 # Fast installation is not supported
7974 link_command="$compile_var$compile_command$compile_rpath"
7975 relink_command="$finalize_var$finalize_command$finalize_rpath"
7977 func_warning "this platform does not like uninstalled shared libraries"
7978 func_warning "\`$output' will be relinked during installation"
7980 if test "$fast_install" != no; then
7981 link_command="$finalize_var$compile_command$finalize_rpath"
7982 if test "$fast_install" = yes; then
7983 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
7985 # fast_install is set to needless
7989 link_command="$compile_var$compile_command$compile_rpath"
7990 relink_command="$finalize_var$finalize_command$finalize_rpath"
7994 # Replace the output file specification.
7995 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
7997 # Delete the old output files.
7998 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8000 func_show_eval "$link_command" 'exit $?'
8002 # Now create the wrapper script.
8003 func_verbose "creating $output"
8005 # Quote the relink command for shipping.
8006 if test -n "$relink_command"; then
8007 # Preserve any variables that may affect compiler behavior
8008 for var in $variables_saved_for_relink; do
8009 if eval test -z \"\${$var+set}\"; then
8010 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8011 elif eval var_value=\$$var; test -z "$var_value"; then
8012 relink_command="$var=; export $var; $relink_command"
8014 func_quote_for_eval "$var_value"
8015 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8018 relink_command="(cd `pwd`; $relink_command)"
8019 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8022 # Only actually do things if not in dry run mode.
8024 # win32 will think the script is a binary if it has
8025 # a .exe suffix, so we strip it off here.
8027 *.exe) func_stripname '' '.exe' "$output"
8028 output=$func_stripname_result ;;
8030 # test for cygwin because mv fails w/o .exe extensions
8034 func_stripname '' '.exe' "$outputname"
8035 outputname=$func_stripname_result ;;
8039 *cygwin* | *mingw* )
8040 func_dirname_and_basename "$output" "" "."
8041 output_name=$func_basename_result
8042 output_path=$func_dirname_result
8043 cwrappersource="$output_path/$objdir/lt-$output_name.c"
8044 cwrapper="$output_path/$output_name.exe"
8045 $RM $cwrappersource $cwrapper
8046 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8048 func_emit_cwrapperexe_src > $cwrappersource
8050 # The wrapper executable is built using the $host compiler,
8051 # because it contains $host paths and files. If cross-
8052 # compiling, it, like the target executable, must be
8053 # executed on the $host or under an emulation environment.
8055 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8059 # Now, create the wrapper script for func_source use:
8060 func_ltwrapper_scriptname $cwrapper
8061 $RM $func_ltwrapper_scriptname_result
8062 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8064 # note: this script will not be executed, so do not chmod.
8065 if test "x$build" = "x$host" ; then
8066 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8068 func_emit_wrapper no > $func_ltwrapper_scriptname_result
8074 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8076 func_emit_wrapper no > $output
8085 # See if we need to build an old-fashioned archive.
8086 for oldlib in $oldlibs; do
8088 if test "$build_libtool_libs" = convenience; then
8089 oldobjs="$libobjs_save $symfileobj"
8090 addlibs="$convenience"
8091 build_libtool_libs=no
8093 if test "$build_libtool_libs" = module; then
8094 oldobjs="$libobjs_save"
8095 build_libtool_libs=no
8097 oldobjs="$old_deplibs $non_pic_objects"
8098 if test "$preload" = yes && test -f "$symfileobj"; then
8099 oldobjs="$oldobjs $symfileobj"
8102 addlibs="$old_convenience"
8105 if test -n "$addlibs"; then
8106 gentop="$output_objdir/${outputname}x"
8107 generated="$generated $gentop"
8109 func_extract_archives $gentop $addlibs
8110 oldobjs="$oldobjs $func_extract_archives_result"
8113 # Do each command in the archive commands.
8114 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8115 cmds=$old_archive_from_new_cmds
8118 # Add any objects from preloaded convenience libraries
8119 if test -n "$dlprefiles"; then
8120 gentop="$output_objdir/${outputname}x"
8121 generated="$generated $gentop"
8123 func_extract_archives $gentop $dlprefiles
8124 oldobjs="$oldobjs $func_extract_archives_result"
8127 # POSIX demands no paths to be encoded in archives. We have
8128 # to avoid creating archives with duplicate basenames if we
8129 # might have to extract them afterwards, e.g., when creating a
8130 # static archive out of a convenience library, or when linking
8131 # the entirety of a libtool archive into another (currently
8132 # not supported by libtool).
8133 if (for obj in $oldobjs
8135 func_basename "$obj"
8136 $ECHO "$func_basename_result"
8137 done | sort | sort -uc >/dev/null 2>&1); then
8140 echo "copying selected object files to avoid basename conflicts..."
8141 gentop="$output_objdir/${outputname}x"
8142 generated="$generated $gentop"
8143 func_mkdir_p "$gentop"
8144 save_oldobjs=$oldobjs
8147 for obj in $save_oldobjs
8149 func_basename "$obj"
8150 objbase="$func_basename_result"
8151 case " $oldobjs " in
8152 " ") oldobjs=$obj ;;
8155 # Make sure we don't pick an alternate name that also
8157 newobj=lt$counter-$objbase
8158 func_arith $counter + 1
8159 counter=$func_arith_result
8160 case " $oldobjs " in
8161 *[\ /]"$newobj "*) ;;
8162 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
8165 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8166 oldobjs="$oldobjs $gentop/$newobj"
8168 *) oldobjs="$oldobjs $obj" ;;
8172 eval "cmds=\"$old_archive_cmds\""
8175 len=$func_len_result
8176 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8177 cmds=$old_archive_cmds
8179 # the command line is too long to link in one step, link in parts
8180 func_verbose "using piecewise archive linking..."
8185 save_oldobjs=$oldobjs
8187 # Is there a better way of finding the last object in the list?
8188 for obj in $save_oldobjs
8192 eval "test_cmds=\"$old_archive_cmds\""
8193 func_len " $test_cmds"
8194 len0=$func_len_result
8196 for obj in $save_oldobjs
8199 func_arith $len + $func_len_result
8200 len=$func_arith_result
8201 func_append objlist " $obj"
8202 if test "$len" -lt "$max_cmd_len"; then
8205 # the above command should be used before it gets too long
8207 if test "$obj" = "$last_oldobj" ; then
8210 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8211 eval "concat_cmds=\"\${concat_cmds}$old_archive_cmds\""
8218 if test "X$oldobjs" = "X" ; then
8219 eval "cmds=\"\$concat_cmds\""
8221 eval "cmds=\"\$concat_cmds~\$old_archive_cmds\""
8225 func_execute_cmds "$cmds" 'exit $?'
8228 test -n "$generated" && \
8229 func_show_eval "${RM}r$generated"
8231 # Now create the libtool archive.
8235 test "$build_old_libs" = yes && old_library="$libname.$libext"
8236 func_verbose "creating $output"
8238 # Preserve any variables that may affect compiler behavior
8239 for var in $variables_saved_for_relink; do
8240 if eval test -z \"\${$var+set}\"; then
8241 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8242 elif eval var_value=\$$var; test -z "$var_value"; then
8243 relink_command="$var=; export $var; $relink_command"
8245 func_quote_for_eval "$var_value"
8246 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8249 # Quote the link command for shipping.
8250 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8251 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8252 if test "$hardcode_automatic" = yes ; then
8256 # Only create the output if not a dry run.
8258 for installed in no yes; do
8259 if test "$installed" = yes; then
8260 if test -z "$install_libdir"; then
8263 output="$output_objdir/$outputname"i
8264 # Replace all uninstalled libtool libraries with the installed ones
8266 for deplib in $dependency_libs; do
8269 func_basename "$deplib"
8270 name="$func_basename_result"
8271 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8272 test -z "$libdir" && \
8273 func_fatal_error "\`$deplib' is not a valid libtool archive"
8274 newdependency_libs="$newdependency_libs $libdir/$name"
8276 *) newdependency_libs="$newdependency_libs $deplib" ;;
8279 dependency_libs="$newdependency_libs"
8282 for lib in $dlfiles; do
8285 func_basename "$lib"
8286 name="$func_basename_result"
8287 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8288 test -z "$libdir" && \
8289 func_fatal_error "\`$lib' is not a valid libtool archive"
8290 newdlfiles="$newdlfiles $libdir/$name"
8292 *) newdlfiles="$newdlfiles $lib" ;;
8295 dlfiles="$newdlfiles"
8297 for lib in $dlprefiles; do
8300 # Only pass preopened files to the pseudo-archive (for
8301 # eventual linking with the app. that links it) if we
8302 # didn't already link the preopened objects directly into
8304 func_basename "$lib"
8305 name="$func_basename_result"
8306 libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8307 test -z "$libdir" && \
8308 func_fatal_error "\`$lib' is not a valid libtool archive"
8309 newdlprefiles="$newdlprefiles $libdir/$name"
8313 dlprefiles="$newdlprefiles"
8316 for lib in $dlfiles; do
8318 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8319 *) abs=`pwd`"/$lib" ;;
8321 newdlfiles="$newdlfiles $abs"
8323 dlfiles="$newdlfiles"
8325 for lib in $dlprefiles; do
8327 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8328 *) abs=`pwd`"/$lib" ;;
8330 newdlprefiles="$newdlprefiles $abs"
8332 dlprefiles="$newdlprefiles"
8335 # place dlname in correct position for cygwin
8336 # In fact, it would be nice if we could use this code for all target
8337 # systems that can't hard-code library paths into their executables
8338 # and that have no shared library path variable independent of PATH,
8339 # but it turns out we can't easily determine that from inspecting
8340 # libtool variables, so we have to hard-code the OSs to which it
8341 # applies here; at the moment, that means platforms that use the PE
8342 # object format with DLL files. See the long comment at the top of
8343 # tests/bindir.at for full details.
8345 case $host,$output,$installed,$module,$dlname in
8346 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
8347 # If a -bindir argument was supplied, place the dll there.
8348 if test "x$bindir" != x ;
8350 func_relative_path "$install_libdir" "$bindir"
8351 tdlname=$func_relative_path_result$dlname
8353 # Otherwise fall back on heuristic.
8354 tdlname=../bin/$dlname
8359 # $outputname - a libtool library file
8360 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8362 # Please DO NOT delete this file!
8363 # It is necessary for linking the library.
8365 # The name that we can dlopen(3).
8368 # Names of this library.
8369 library_names='$library_names'
8371 # The name of the static archive.
8372 old_library='$old_library'
8374 # Linker flags that can not go in dependency_libs.
8375 inherited_linker_flags='$new_inherited_linker_flags'
8377 # Libraries that this one depends upon.
8378 dependency_libs='$dependency_libs'
8380 # Names of additional weak libraries provided by this library
8381 weak_library_names='$weak_libs'
8383 # Version information for $libname.
8388 # Is this an already installed library?
8389 installed=$installed
8391 # Should we warn about portability when linking against -modules?
8392 shouldnotlink=$module
8394 # Files to dlopen/dlpreopen
8396 dlpreopen='$dlprefiles'
8398 # Directory that this library needs to be installed in:
8399 libdir='$install_libdir'"
8400 if test "$installed" = no && test "$need_relink" = yes; then
8402 relink_command=\"$relink_command\""
8407 # Do a symbolic link so that the libtool archive can be found in
8408 # LD_LIBRARY_PATH before the program is installed.
8409 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8415 { test "$mode" = link || test "$mode" = relink; } &&
8416 func_mode_link ${1+"$@"}
8419 # func_mode_uninstall arg...
8420 func_mode_uninstall ()
8428 # This variable tells wrapper scripts just to set variables rather
8429 # than running their programs.
8430 libtool_install_magic="$magic"
8435 -f) RM="$RM $arg"; rmforce=yes ;;
8436 -*) RM="$RM $arg" ;;
8437 *) files="$files $arg" ;;
8442 func_fatal_help "you must specify an RM program"
8446 origobjdir="$objdir"
8447 for file in $files; do
8448 func_dirname "$file" "" "."
8449 dir="$func_dirname_result"
8450 if test "X$dir" = X.; then
8451 objdir="$origobjdir"
8453 objdir="$dir/$origobjdir"
8455 func_basename "$file"
8456 name="$func_basename_result"
8457 test "$mode" = uninstall && objdir="$dir"
8459 # Remember objdir for removal later, being careful to avoid duplicates
8460 if test "$mode" = clean; then
8463 *) rmdirs="$rmdirs $objdir" ;;
8467 # Don't error if the file doesn't exist and rm -f was used.
8468 if { test -L "$file"; } >/dev/null 2>&1 ||
8469 { test -h "$file"; } >/dev/null 2>&1 ||
8470 test -f "$file"; then
8472 elif test -d "$file"; then
8475 elif test "$rmforce" = yes; then
8483 # Possibly a libtool archive, so verify it.
8484 if func_lalib_p "$file"; then
8485 func_source $dir/$name
8487 # Delete the libtool libraries and symlinks.
8488 for n in $library_names; do
8489 rmfiles="$rmfiles $objdir/$n"
8491 test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8495 case " $library_names " in
8496 # " " in the beginning catches empty $dlname
8498 *) rmfiles="$rmfiles $objdir/$dlname" ;;
8500 test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8503 if test -n "$library_names"; then
8504 # Do each command in the postuninstall commands.
8505 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8508 if test -n "$old_library"; then
8509 # Do each command in the old_postuninstall commands.
8510 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8512 # FIXME: should reinstall the best remaining shared library.
8519 # Possibly a libtool object, so verify it.
8520 if func_lalib_p "$file"; then
8523 func_source $dir/$name
8525 # Add PIC object to the list of files to remove.
8526 if test -n "$pic_object" &&
8527 test "$pic_object" != none; then
8528 rmfiles="$rmfiles $dir/$pic_object"
8531 # Add non-PIC object to the list of files to remove.
8532 if test -n "$non_pic_object" &&
8533 test "$non_pic_object" != none; then
8534 rmfiles="$rmfiles $dir/$non_pic_object"
8540 if test "$mode" = clean ; then
8544 func_stripname '' '.exe' "$file"
8545 file=$func_stripname_result
8546 func_stripname '' '.exe' "$name"
8547 noexename=$func_stripname_result
8548 # $file with .exe has already been added to rmfiles,
8549 # add $file without .exe
8550 rmfiles="$rmfiles $file"
8553 # Do a test to see if this is a libtool program.
8554 if func_ltwrapper_p "$file"; then
8555 if func_ltwrapper_executable_p "$file"; then
8556 func_ltwrapper_scriptname "$file"
8558 func_source $func_ltwrapper_scriptname_result
8559 rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8562 func_source $dir/$noexename
8565 # note $name still contains .exe if it was in $file originally
8566 # as does the version of $file that was added into $rmfiles
8567 rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8568 if test "$fast_install" = yes && test -n "$relink_command"; then
8569 rmfiles="$rmfiles $objdir/lt-$name"
8571 if test "X$noexename" != "X$name" ; then
8572 rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8578 func_show_eval "$RM $rmfiles" 'exit_status=1'
8580 objdir="$origobjdir"
8582 # Try to remove the ${objdir}s in the directories where we deleted files
8583 for dir in $rmdirs; do
8584 if test -d "$dir"; then
8585 func_show_eval "rmdir $dir >/dev/null 2>&1"
8592 { test "$mode" = uninstall || test "$mode" = clean; } &&
8593 func_mode_uninstall ${1+"$@"}
8595 test -z "$mode" && {
8596 help="$generic_help"
8597 func_fatal_help "you must specify a MODE"
8600 test -z "$exec_cmd" && \
8601 func_fatal_help "invalid operation mode \`$mode'"
8603 if test -n "$exec_cmd"; then
8604 eval exec "$exec_cmd"
8611 # The TAGs below are defined such that we never get into a situation
8612 # in which we disable both kinds of libraries. Given conflicting
8613 # choices, we go for a static library, that is the most portable,
8614 # since we can't tell whether shared libraries were disabled because
8615 # the user asked for that or because the platform doesn't support
8616 # them. This is particularly important on AIX, because we don't
8617 # support having both static and shared libraries enabled at the same
8618 # time on that platform, so we default to a shared-only configuration.
8619 # If a disable-shared tag is given, we'll fallback to a static-only
8620 # configuration. But we'll never go from static-only to shared-only.
8622 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8623 build_libtool_libs=no
8625 # ### END LIBTOOL TAG CONFIG: disable-shared
8627 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8628 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8629 # ### END LIBTOOL TAG CONFIG: disable-static