2 # libtool (GNU libtool) 2.4
3 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
7 # This is free software; see the source for copying conditions. There is NO
8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10 # GNU Libtool is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
15 # As a special exception to the GNU General Public License,
16 # if you distribute this file as part of a program or library that
17 # is built using GNU Libtool, you may include this file under the
18 # same distribution terms that you use for the rest of that program.
20 # GNU Libtool is distributed in the hope that it will be useful, but
21 # WITHOUT ANY WARRANTY; without even the implied warranty of
22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 # General Public License for more details.
25 # You should have received a copy of the GNU General Public License
26 # along with GNU Libtool; see the file COPYING. If not, a copy
27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28 # or obtained by writing to the Free Software Foundation, Inc.,
29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31 # Usage: $progname [OPTION]... [MODE-ARG]...
33 # Provide generalized library-building support services.
35 # --config show all configuration variables
36 # --debug enable verbose shell tracing
37 # -n, --dry-run display commands without modifying any files
38 # --features display basic configuration information and exit
39 # --mode=MODE use operation mode MODE
40 # --preserve-dup-deps don't remove duplicate dependency libraries
41 # --quiet, --silent don't print informational messages
42 # --no-quiet, --no-silent
43 # print informational messages (default)
44 # --tag=TAG use configuration variables from tag TAG
45 # -v, --verbose print more informational messages than default
46 # --no-verbose don't print the extra informational messages
47 # --version print version information
48 # -h, --help, --help-all print short, long, or detailed help message
50 # MODE must be one of the following:
52 # clean remove files from the build directory
53 # compile compile a source file into a libtool object
54 # execute automatically set library path, then run a program
55 # finish complete the installation of libtool libraries
56 # install install libraries or executables
57 # link create a library or an executable
58 # uninstall remove libraries from an installed directory
60 # MODE-ARGS vary depending on the MODE. When passed as first option,
61 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
62 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64 # When reporting a bug, please describe a test case to reproduce it and
65 # include the following information:
70 # compiler flags: $LTCFLAGS
71 # linker: $LD (gnu? $with_gnu_ld)
72 # $progname: (GNU libtool) 2.4
73 # automake: $automake_version
74 # autoconf: $autoconf_version
76 # Report bugs to <bug-libtool@gnu.org>.
77 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
78 # General help using GNU software: <http://www.gnu.org/gethelp/>.
84 package_revision=1.3293
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.
111 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113 eval "if test \"\${$lt_var+set}\" = set; then
114 save_$lt_var=\$$lt_var
117 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
118 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
123 export LANGUAGE LC_ALL
128 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
129 # is ksh but when the shell is invoked as "sh" and the current value of
130 # the _XPG environment variable is not equal to 1 (one), the special
131 # positional parameter $0, within a function call, is the name of the
138 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
139 : ${EGREP="/bin/grep -E"}
140 : ${FGREP="/bin/grep -F"}
141 : ${GREP="/bin/grep"}
148 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
149 : ${Xsed="$SED -e 1s/^X//"}
154 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
155 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
157 exit_status=$EXIT_SUCCESS
159 # Make sure IFS has a sensible default
164 dirname="s,/[^/]*$,,"
167 # func_dirname file append nondir_replacement
168 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
169 # otherwise set result to NONDIR_REPLACEMENT.
172 func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
173 if test "X$func_dirname_result" = "X${1}"; then
174 func_dirname_result="${3}"
176 func_dirname_result="$func_dirname_result${2}"
178 } # func_dirname may be replaced by extended shell implementation
184 func_basename_result=`$ECHO "${1}" | $SED "$basename"`
185 } # func_basename may be replaced by extended shell implementation
188 # func_dirname_and_basename file append nondir_replacement
189 # perform func_basename and func_dirname in a single function
191 # dirname: Compute the dirname of FILE. If nonempty,
192 # add APPEND to the result, otherwise set result
193 # to NONDIR_REPLACEMENT.
194 # value returned in "$func_dirname_result"
195 # basename: Compute filename of FILE.
196 # value retuned in "$func_basename_result"
197 # Implementation must be kept synchronized with func_dirname
198 # and func_basename. For efficiency, we do not delegate to
199 # those functions but instead duplicate the functionality here.
200 func_dirname_and_basename ()
202 # Extract subdirectory from the argument.
203 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
204 if test "X$func_dirname_result" = "X${1}"; then
205 func_dirname_result="${3}"
207 func_dirname_result="$func_dirname_result${2}"
209 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
210 } # func_dirname_and_basename may be replaced by extended shell implementation
213 # func_stripname prefix suffix name
214 # strip PREFIX and SUFFIX off of NAME.
215 # PREFIX and SUFFIX must not contain globbing or regex special
216 # characters, hashes, percent signs, but SUFFIX may contain a leading
217 # dot (in which case that matches only a dot).
218 # func_strip_suffix prefix name
222 .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
223 *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
225 } # func_stripname may be replaced by extended shell implementation
228 # These SED scripts presuppose an absolute path with a trailing slash.
229 pathcar='s,^/\([^/]*\).*$,\1,'
230 pathcdr='s,^/[^/]*,,'
231 removedotparts=':dotsl
235 collapseslashes='s@/\{1,\}@/@g'
236 finalslash='s,/*$,/,'
238 # func_normal_abspath PATH
239 # Remove doubled-up and trailing slashes, "." path components,
240 # and cancel out any ".." path components in PATH after making
241 # it an absolute path.
242 # value returned in "$func_normal_abspath_result"
243 func_normal_abspath ()
245 # Start from root dir and reassemble the path.
246 func_normal_abspath_result=
247 func_normal_abspath_tpath=$1
248 func_normal_abspath_altnamespace=
249 case $func_normal_abspath_tpath in
251 # Empty path, that just means $cwd.
252 func_stripname '' '/' "`pwd`"
253 func_normal_abspath_result=$func_stripname_result
256 # The next three entries are used to spot a run of precisely
257 # two leading slashes without using negated character classes;
258 # we take advantage of case's first-match behaviour.
260 # Unusual form of absolute path, do nothing.
263 # Not necessarily an ordinary path; POSIX reserves leading '//'
264 # and for example Cygwin uses it to access remote file shares
265 # over CIFS/SMB, so we conserve a leading double slash if found.
266 func_normal_abspath_altnamespace=/
269 # Absolute path, do nothing.
272 # Relative path, prepend $cwd.
273 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
276 # Cancel out all the simple stuff to save iterations. We also want
277 # the path to end with a slash for ease of parsing, so make sure
278 # there is one (and only one) here.
279 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
280 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
282 # Processed it all yet?
283 if test "$func_normal_abspath_tpath" = / ; then
284 # If we ascended to the root using ".." the result may be empty now.
285 if test -z "$func_normal_abspath_result" ; then
286 func_normal_abspath_result=/
290 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
292 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
294 # Figure out what to do with it
295 case $func_normal_abspath_tcomponent in
297 # Trailing empty path component, ignore it.
300 # Parent dir; strip last assembled component from result.
301 func_dirname "$func_normal_abspath_result"
302 func_normal_abspath_result=$func_dirname_result
305 # Actual path component, append it.
306 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
310 # Restore leading double-slash if one was found on entry.
311 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
314 # func_relative_path SRCDIR DSTDIR
315 # generates a relative path from SRCDIR to DSTDIR, with a trailing
316 # slash if non-empty, suitable for immediately appending a filename
317 # without needing to append a separator.
318 # value returned in "$func_relative_path_result"
319 func_relative_path ()
321 func_relative_path_result=
322 func_normal_abspath "$1"
323 func_relative_path_tlibdir=$func_normal_abspath_result
324 func_normal_abspath "$2"
325 func_relative_path_tbindir=$func_normal_abspath_result
327 # Ascend the tree starting from libdir
329 # check if we have found a prefix of bindir
330 case $func_relative_path_tbindir in
331 $func_relative_path_tlibdir)
332 # found an exact match
333 func_relative_path_tcancelled=
336 $func_relative_path_tlibdir*)
337 # found a matching prefix
338 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
339 func_relative_path_tcancelled=$func_stripname_result
340 if test -z "$func_relative_path_result"; then
341 func_relative_path_result=.
346 func_dirname $func_relative_path_tlibdir
347 func_relative_path_tlibdir=${func_dirname_result}
348 if test "x$func_relative_path_tlibdir" = x ; then
349 # Have to descend all the way to the root!
350 func_relative_path_result=../$func_relative_path_result
351 func_relative_path_tcancelled=$func_relative_path_tbindir
354 func_relative_path_result=../$func_relative_path_result
359 # Now calculate path; take care to avoid doubling-up slashes.
360 func_stripname '' '/' "$func_relative_path_result"
361 func_relative_path_result=$func_stripname_result
362 func_stripname '/' '/' "$func_relative_path_tcancelled"
363 if test "x$func_stripname_result" != x ; then
364 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
367 # Normalisation. If bindir is libdir, return empty string,
368 # else relative path ending with a slash; either way, target
369 # file name can be directly appended.
370 if test ! -z "$func_relative_path_result"; then
371 func_stripname './' '' "$func_relative_path_result/"
372 func_relative_path_result=$func_stripname_result
376 # The name of this program:
377 func_dirname_and_basename "$progpath"
378 progname=$func_basename_result
380 # Make sure we have an absolute path for reexecution:
382 [\\/]*|[A-Za-z]:\\*) ;;
384 progdir=$func_dirname_result
385 progdir=`cd "$progdir" && pwd`
386 progpath="$progdir/$progname"
391 for progdir in $PATH; do
393 test -x "$progdir/$progname" && break
396 test -n "$progdir" || progdir=`pwd`
397 progpath="$progdir/$progname"
401 # Sed substitution that helps us do robust quoting. It backslashifies
402 # metacharacters that are still active within double-quoted strings.
403 Xsed="${SED}"' -e 1s/^X//'
404 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
406 # Same as above, but do not quote variable references.
407 double_quote_subst='s/\(["`\\]\)/\\\1/g'
409 # Sed substitution that turns a string into a regex matching for the
411 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
413 # Sed substitution that converts a w32 file name or path
414 # which contains forward slashes, into one that contains
415 # (escaped) backslashes. A very naive implementation.
416 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
418 # Re-`\' parameter expansions in output of double_quote_subst that were
419 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
420 # in input to double_quote_subst, that '$' was protected from expansion.
421 # Since each input `\' is now two `\'s, look for any number of runs of
422 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
427 sed_double_backslash="\
431 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
442 # Echo program name prefixed message, along with the current mode
443 # name if it has been set yet.
446 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
449 # func_verbose arg...
450 # Echo program name prefixed message in verbose mode only.
453 $opt_verbose && func_echo ${1+"$@"}
455 # A bug in bash halts the script if the last line of a function
456 # fails when set -e is in force, so we need another command to
461 # func_echo_all arg...
462 # Invoke $ECHO with all args, space-separated.
469 # Echo program name prefixed message to standard error.
472 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
475 # func_warning arg...
476 # Echo program name prefixed warning message to standard error.
479 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
485 # func_fatal_error arg...
486 # Echo program name prefixed message to standard error, and exit.
493 # func_fatal_help arg...
494 # Echo program name prefixed message to standard error, followed by
495 # a help hint, and exit.
499 func_fatal_error "$help"
501 help="Try \`$progname --help' for more information." ## default
504 # func_grep expression filename
505 # Check whether EXPRESSION matches any line of FILENAME, without output.
508 $GREP "$1" "$2" >/dev/null 2>&1
512 # func_mkdir_p directory-path
513 # Make sure the entire path to DIRECTORY-PATH is available.
516 my_directory_path="$1"
519 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
521 # Protect directory names starting with `-'
522 case $my_directory_path in
523 -*) my_directory_path="./$my_directory_path" ;;
526 # While some portion of DIR does not yet exist...
527 while test ! -d "$my_directory_path"; do
528 # ...make a list in topmost first order. Use a colon delimited
529 # list incase some portion of path contains whitespace.
530 my_dir_list="$my_directory_path:$my_dir_list"
532 # If the last portion added has no slash in it, the list is done
533 case $my_directory_path in */*) ;; *) break ;; esac
535 # ...otherwise throw away the child directory and loop
536 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
538 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
540 save_mkdir_p_IFS="$IFS"; IFS=':'
541 for my_dir in $my_dir_list; do
542 IFS="$save_mkdir_p_IFS"
543 # mkdir can fail with a `File exist' error if two processes
544 # try to create one of the directories concurrently. Don't
546 $MKDIR "$my_dir" 2>/dev/null || :
548 IFS="$save_mkdir_p_IFS"
550 # Bail out if we (or some other process) failed to create a directory.
551 test -d "$my_directory_path" || \
552 func_fatal_error "Failed to create \`$1'"
557 # func_mktempdir [string]
558 # Make a temporary directory that won't clash with other running
559 # libtool processes, and avoids race conditions if possible. If
560 # given, STRING is the basename for that directory.
563 my_template="${TMPDIR-/tmp}/${1-$progname}"
565 if test "$opt_dry_run" = ":"; then
566 # Return a directory name, but don't create it in dry-run mode
567 my_tmpdir="${my_template}-$$"
570 # If mktemp works, use that first and foremost
571 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
573 if test ! -d "$my_tmpdir"; then
574 # Failing that, at least try and use $RANDOM to avoid a race
575 my_tmpdir="${my_template}-${RANDOM-0}$$"
577 save_mktempdir_umask=`umask`
580 umask $save_mktempdir_umask
583 # If we're not in dry-run mode, bomb out on failure
584 test -d "$my_tmpdir" || \
585 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
592 # func_quote_for_eval arg
593 # Aesthetically quote ARG to be evaled later.
594 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
595 # is double-quoted, suitable for a subsequent eval, whereas
596 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
597 # which are still active within double quotes backslashified.
598 func_quote_for_eval ()
602 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
604 func_quote_for_eval_unquoted_result="$1" ;;
607 case $func_quote_for_eval_unquoted_result in
608 # Double-quote args containing shell metacharacters to delay
609 # word splitting, command substitution and and variable
610 # expansion for a subsequent eval.
611 # Many Bourne shells cannot handle close brackets correctly
612 # in scan sets, so we specify it separately.
613 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
614 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
617 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
622 # func_quote_for_expand arg
623 # Aesthetically quote ARG to be evaled later; same as above,
624 # but do not quote variable references.
625 func_quote_for_expand ()
629 my_arg=`$ECHO "$1" | $SED \
630 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
636 # Double-quote args containing shell metacharacters to delay
637 # word splitting and command substitution for a subsequent eval.
638 # Many Bourne shells cannot handle close brackets correctly
639 # in scan sets, so we specify it separately.
640 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
645 func_quote_for_expand_result="$my_arg"
649 # func_show_eval cmd [fail_exp]
650 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
651 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
652 # is given, then evaluate it.
658 ${opt_silent-false} || {
659 func_quote_for_expand "$my_cmd"
660 eval "func_echo $func_quote_for_expand_result"
663 if ${opt_dry_run-false}; then :; else
666 if test "$my_status" -eq 0; then :; else
667 eval "(exit $my_status); $my_fail_exp"
673 # func_show_eval_locale cmd [fail_exp]
674 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
675 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
676 # is given, then evaluate it. Use the saved locale for evaluation.
677 func_show_eval_locale ()
682 ${opt_silent-false} || {
683 func_quote_for_expand "$my_cmd"
684 eval "func_echo $func_quote_for_expand_result"
687 if ${opt_dry_run-false}; then :; else
688 eval "$lt_user_locale
691 eval "$lt_safe_locale"
692 if test "$my_status" -eq 0; then :; else
693 eval "(exit $my_status); $my_fail_exp"
699 # Turn $1 into a string suitable for a shell variable name.
700 # Result is stored in $func_tr_sh_result. All characters
701 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
702 # if $1 begins with a digit, a '_' is prepended as well.
706 [0-9]* | *[!a-zA-Z0-9_]*)
707 func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
717 # Echo version message to standard output and exit.
730 /^# '$PROGRAM' (GNU /,/# warranty; / {
733 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
740 # Echo short help message to standard output and exit.
745 $SED -n '/^# Usage:/,/^# *.*--help/ {
748 s/\$progname/'$progname'/
752 $ECHO "run \`$progname --help | more' for full usage"
757 # Echo long help message to standard output and exit,
758 # unless 'noexit' is passed as argument.
763 $SED -n '/^# Usage:/,/# Report bugs to/ {
767 s*\$progname*'$progname'*
769 s*\$SHELL*'"$SHELL"'*
771 s*\$LTCFLAGS*'"$LTCFLAGS"'*
773 s/\$with_gnu_ld/'"$with_gnu_ld"'/
774 s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
775 s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
779 /^# .* home page:/b print
780 /^# General help using/b print
783 if test -z "$1"; then
788 # func_missing_arg argname
789 # Echo program name prefixed message to standard error and set global
795 func_error "missing argument for $1."
800 # func_split_short_opt shortopt
801 # Set func_split_short_opt_name and func_split_short_opt_arg shell
802 # variables after splitting SHORTOPT after the 2nd character.
803 func_split_short_opt ()
805 my_sed_short_opt='1s/^\(..\).*$/\1/;q'
806 my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
808 func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
809 func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
810 } # func_split_short_opt may be replaced by extended shell implementation
813 # func_split_long_opt longopt
814 # Set func_split_long_opt_name and func_split_long_opt_arg shell
815 # variables after splitting LONGOPT at the `=' sign.
816 func_split_long_opt ()
818 my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
819 my_sed_long_arg='1s/^--[^=]*=//'
821 func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
822 func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
823 } # func_split_long_opt may be replaced by extended shell implementation
831 magic="%%%MAGIC variable%%%"
832 magic_exe="%%%MAGIC EXE variable%%%"
837 lo2o="s/\\.lo\$/.${objext}/"
838 o2lo="s/\\.${objext}\$/.lo/"
842 # If this variable is set in any of the actions, the command in it
843 # will be execed at the end. This prevents here-documents from being
844 # left over by shells.
847 # func_append var value
848 # Append VALUE to the end of shell variable VAR.
851 eval "${1}=\$${1}\${2}"
852 } # func_append may be replaced by extended shell implementation
854 # func_append_quoted var value
855 # Quote VALUE and append to the end of shell variable VAR, separated
857 func_append_quoted ()
859 func_quote_for_eval "${2}"
860 eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
861 } # func_append_quoted may be replaced by extended shell implementation
864 # func_arith arithmetic-term...
867 func_arith_result=`expr "${@}"`
868 } # func_arith may be replaced by extended shell implementation
872 # STRING may not start with a hyphen.
875 func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
876 } # func_len may be replaced by extended shell implementation
882 func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
883 } # func_lo2o may be replaced by extended shell implementation
886 # func_xform libobj-or-source
889 func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
890 } # func_xform may be replaced by extended shell implementation
893 # func_fatal_configuration arg...
894 # Echo program name prefixed message to standard error, followed by
895 # a configuration failure hint, and exit.
896 func_fatal_configuration ()
899 func_error "See the $PACKAGE documentation for more information."
900 func_fatal_error "Fatal configuration error."
905 # Display the configuration for all the tags in this script.
908 re_begincf='^# ### BEGIN LIBTOOL'
909 re_endcf='^# ### END LIBTOOL'
911 # Default configuration.
912 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
914 # Now print the configurations for the tags.
915 for tagname in $taglist; do
916 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
923 # Display the features supported by this script.
927 if test "$build_libtool_libs" = yes; then
928 echo "enable shared libraries"
930 echo "disable shared libraries"
932 if test "$build_old_libs" = yes; then
933 echo "enable static libraries"
935 echo "disable static libraries"
941 # func_enable_tag tagname
942 # Verify that TAGNAME is valid, and either flag an error and exit, or
943 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
950 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
951 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
952 sed_extractcf="/$re_begincf/,/$re_endcf/p"
957 func_fatal_error "invalid tag name: $tagname"
961 # Don't test for the "default" C tag, as we know it's
962 # there but not specially marked.
966 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
967 taglist="$taglist $tagname"
969 # Evaluate the configuration. Be careful to quote the path
970 # and the sed script, to avoid splitting on whitespace, but
971 # also don't use non-portable quotes within backquotes within
972 # quotes we have to do it in 2 steps:
973 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
976 func_error "ignoring unknown tag $tagname"
982 # func_check_version_match
983 # Ensure that we are using m4 macros, and libtool script from the same
984 # release of libtool.
985 func_check_version_match ()
987 if test "$package_revision" != "$macro_revision"; then
988 if test "$VERSION" != "$macro_version"; then
989 if test -z "$macro_version"; then
991 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
992 $progname: definition of this LT_INIT comes from an older release.
993 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
994 $progname: and run autoconf again.
998 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
999 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1000 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1001 $progname: and run autoconf again.
1006 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1007 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1008 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1009 $progname: of $PACKAGE $VERSION and run autoconf again.
1018 # Shorthand for --mode=foo, only valid as the first argument
1021 shift; set dummy --mode clean ${1+"$@"}; shift
1023 compile|compil|compi|comp|com|co|c)
1024 shift; set dummy --mode compile ${1+"$@"}; shift
1026 execute|execut|execu|exec|exe|ex|e)
1027 shift; set dummy --mode execute ${1+"$@"}; shift
1029 finish|finis|fini|fin|fi|f)
1030 shift; set dummy --mode finish ${1+"$@"}; shift
1032 install|instal|insta|inst|ins|in|i)
1033 shift; set dummy --mode install ${1+"$@"}; shift
1036 shift; set dummy --mode link ${1+"$@"}; shift
1038 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1039 shift; set dummy --mode uninstall ${1+"$@"}; shift
1049 opt_preserve_dup_deps=false
1060 # Parse options once, thoroughly. This comes as soon as possible in the
1061 # script to make things like `--version' happen as quickly as we can.
1063 # this just eases exit handling
1064 while test $# -gt 0; do
1068 --debug|-x) opt_debug='set -x'
1069 func_echo "enabling shell trace mode"
1072 --dry-run|--dryrun|-n)
1081 opt_dlopen="${opt_dlopen+$opt_dlopen
1085 --preserve-dup-deps)
1086 opt_preserve_dup_deps=:
1094 set dummy --mode finish ${1+"$@"}; shift
1101 opt_help=': help-all'
1104 test $# = 0 && func_missing_arg $opt && break
1108 # Valid mode arguments:
1109 clean|compile|execute|finish|install|link|relink|uninstall) ;;
1111 # Catch anything else as an error
1112 *) func_error "invalid argument for $opt"
1119 --no-silent|--no-quiet)
1121 func_append preserve_args " $opt"
1125 func_append preserve_args " $opt"
1129 func_append preserve_args " $opt"
1134 func_append preserve_args " $opt"
1138 test $# = 0 && func_missing_arg $opt && break
1141 func_append preserve_args " $opt $optarg"
1142 func_enable_tag "$optarg"
1146 -\?|-h) func_usage ;;
1147 --help) func_help ;;
1148 --version) func_version ;;
1150 # Separate optargs to long options:
1152 func_split_long_opt "$opt"
1153 set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1157 # Separate non-argument short options:
1159 func_split_short_opt "$opt"
1160 set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1165 -*) func_fatal_help "unrecognized option \`$opt'" ;;
1166 *) set dummy "$opt" ${1+"$@"}; shift; break ;;
1172 # save first non-option argument
1173 if test "$#" -gt 0; then
1179 test "$opt_debug" = : || func_append preserve_args " --debug"
1182 *cygwin* | *mingw* | *pw32* | *cegcc*)
1183 # don't eliminate duplications in $postdeps and $predeps
1184 opt_duplicate_compiler_generated_deps=:
1187 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1192 # Sanity checks first:
1193 func_check_version_match
1195 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1196 func_fatal_configuration "not configured to build any kind of library"
1200 eval std_shrext=\"$shrext_cmds\"
1202 # Only execute mode is allowed to have -dlopen flags.
1203 if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1204 func_error "unrecognized option \`-dlopen'"
1209 # Change the help message to a mode-specific one.
1210 generic_help="$help"
1211 help="Try \`$progname --help --mode=$opt_mode' for more information."
1215 # Bail if the options were screwed
1216 $exit_cmd $EXIT_FAILURE
1227 # True iff FILE is a libtool `.la' library or `.lo' object file.
1228 # This function is only a basic sanity check; it will hardly flush out
1229 # determined imposters.
1233 $SED -e 4q "$1" 2>/dev/null \
1234 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1237 # func_lalib_unsafe_p file
1238 # True iff FILE is a libtool `.la' library or `.lo' object file.
1239 # This function implements the same check as func_lalib_p without
1240 # resorting to external programs. To this end, it redirects stdin and
1241 # closes it afterwards, without saving the original file descriptor.
1242 # As a safety measure, use it only where a negative result would be
1243 # fatal anyway. Works if `file' does not exist.
1244 func_lalib_unsafe_p ()
1247 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1248 for lalib_p_l in 1 2 3 4
1251 case "$lalib_p_line" in
1252 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1257 test "$lalib_p" = yes
1260 # func_ltwrapper_script_p file
1261 # True iff FILE is a libtool wrapper script
1262 # This function is only a basic sanity check; it will hardly flush out
1263 # determined imposters.
1264 func_ltwrapper_script_p ()
1269 # func_ltwrapper_executable_p file
1270 # True iff FILE is a libtool wrapper executable
1271 # This function is only a basic sanity check; it will hardly flush out
1272 # determined imposters.
1273 func_ltwrapper_executable_p ()
1275 func_ltwrapper_exec_suffix=
1278 *) func_ltwrapper_exec_suffix=.exe ;;
1280 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1283 # func_ltwrapper_scriptname file
1284 # Assumes file is an ltwrapper_executable
1285 # uses $file to determine the appropriate filename for a
1286 # temporary ltwrapper_script.
1287 func_ltwrapper_scriptname ()
1289 func_dirname_and_basename "$1" "" "."
1290 func_stripname '' '.exe' "$func_basename_result"
1291 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1294 # func_ltwrapper_p file
1295 # True iff FILE is a libtool wrapper script or wrapper executable
1296 # This function is only a basic sanity check; it will hardly flush out
1297 # determined imposters.
1300 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1304 # func_execute_cmds commands fail_cmd
1305 # Execute tilde-delimited COMMANDS.
1306 # If FAIL_CMD is given, eval that upon failure.
1307 # FAIL_CMD may read-access the current command in variable CMD!
1308 func_execute_cmds ()
1311 save_ifs=$IFS; IFS='~'
1315 func_show_eval "$cmd" "${2-:}"
1322 # Source FILE, adding directory component if necessary.
1323 # Note that it is not necessary on cygwin/mingw to append a dot to
1324 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1325 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1326 # `FILE.' does not work on cygwin managed mounts.
1331 */* | *\\*) . "$1" ;;
1337 # func_resolve_sysroot PATH
1338 # Replace a leading = in PATH with a sysroot. Store the result into
1339 # func_resolve_sysroot_result
1340 func_resolve_sysroot ()
1342 func_resolve_sysroot_result=$1
1343 case $func_resolve_sysroot_result in
1345 func_stripname '=' '' "$func_resolve_sysroot_result"
1346 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1351 # func_replace_sysroot PATH
1352 # If PATH begins with the sysroot, replace it with = and
1353 # store the result into func_replace_sysroot_result.
1354 func_replace_sysroot ()
1356 case "$lt_sysroot:$1" in
1358 func_stripname "$lt_sysroot" '' "$1"
1359 func_replace_sysroot_result="=$func_stripname_result"
1362 # Including no sysroot.
1363 func_replace_sysroot_result=$1
1368 # func_infer_tag arg
1369 # Infer tagged configuration to use if any are available and
1370 # if one wasn't chosen via the "--tag" command line option.
1371 # Only attempt this if the compiler in the base compile
1372 # command doesn't match the default compiler.
1373 # arg is usually of the form 'gcc ...'
1377 if test -n "$available_tags" && test -z "$tagname"; then
1380 func_append_quoted CC_quoted "$arg"
1382 CC_expanded=`func_echo_all $CC`
1383 CC_quoted_expanded=`func_echo_all $CC_quoted`
1385 # Blanks in the command may have been stripped by the calling shell,
1386 # but not from the CC environment variable when configure was run.
1387 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1389 # Blanks at the start of $base_compile will cause this to fail
1390 # if we don't check for them as well.
1392 for z in $available_tags; do
1393 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1394 # Evaluate the configuration.
1395 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1398 # Double-quote args containing other shell metacharacters.
1399 func_append_quoted CC_quoted "$arg"
1401 CC_expanded=`func_echo_all $CC`
1402 CC_quoted_expanded=`func_echo_all $CC_quoted`
1404 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1406 # The compiler in the base compile command matches
1407 # the one in the tagged configuration.
1408 # Assume this is the tagged configuration we want.
1415 # If $tagname still isn't set, then no tagged configuration
1416 # was found and let the user know that the "--tag" command
1417 # line option must be used.
1418 if test -z "$tagname"; then
1419 func_echo "unable to infer tagged configuration"
1420 func_fatal_error "specify a tag with \`--tag'"
1422 # func_verbose "using $tagname tagged configuration"
1431 # func_write_libtool_object output_name pic_name nonpic_name
1432 # Create a libtool object file (analogous to a ".la" file),
1433 # but don't create it if we're doing a dry run.
1434 func_write_libtool_object ()
1437 if test "$build_libtool_libs" = yes; then
1443 if test "$build_old_libs" = yes; then
1444 write_oldobj=\'${3}\'
1450 cat >${write_libobj}T <<EOF
1451 # $write_libobj - a libtool object file
1452 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454 # Please DO NOT delete this file!
1455 # It is necessary for linking the library.
1457 # Name of the PIC object.
1458 pic_object=$write_lobj
1460 # Name of the non-PIC object
1461 non_pic_object=$write_oldobj
1464 $MV "${write_libobj}T" "${write_libobj}"
1469 ##################################################
1470 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1471 ##################################################
1473 # func_convert_core_file_wine_to_w32 ARG
1474 # Helper function used by file name conversion functions when $build is *nix,
1475 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1476 # correctly configured wine environment available, with the winepath program
1477 # in $build's $PATH.
1479 # ARG is the $build file name to be converted to w32 format.
1480 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1481 # be empty on error (or when ARG is empty)
1482 func_convert_core_file_wine_to_w32 ()
1485 func_convert_core_file_wine_to_w32_result="$1"
1486 if test -n "$1"; then
1487 # Unfortunately, winepath does not exit with a non-zero error code, so we
1488 # are forced to check the contents of stdout. On the other hand, if the
1489 # command is not found, the shell will set an exit code of 127 and print
1490 # *an error message* to stdout. So we must check for both error code of
1491 # zero AND non-empty stdout, which explains the odd construction:
1492 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1493 if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1494 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1495 $SED -e "$lt_sed_naive_backslashify"`
1497 func_convert_core_file_wine_to_w32_result=
1501 # end: func_convert_core_file_wine_to_w32
1504 # func_convert_core_path_wine_to_w32 ARG
1505 # Helper function used by path conversion functions when $build is *nix, and
1506 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1507 # configured wine environment available, with the winepath program in $build's
1508 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1510 # ARG is path to be converted from $build format to win32.
1511 # Result is available in $func_convert_core_path_wine_to_w32_result.
1512 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1513 # are convertible, then the result may be empty.
1514 func_convert_core_path_wine_to_w32 ()
1517 # unfortunately, winepath doesn't convert paths, only file names
1518 func_convert_core_path_wine_to_w32_result=""
1519 if test -n "$1"; then
1522 for func_convert_core_path_wine_to_w32_f in $1; do
1524 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1525 if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1526 if test -z "$func_convert_core_path_wine_to_w32_result"; then
1527 func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1536 # end: func_convert_core_path_wine_to_w32
1539 # func_cygpath ARGS...
1540 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1541 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1542 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1543 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1544 # file name or path is assumed to be in w32 format, as previously converted
1545 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1546 # or path in func_cygpath_result (input file name or path is assumed to be in
1547 # Cygwin format). Returns an empty string on error.
1549 # ARGS are passed to cygpath, with the last one being the file name or path to
1552 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1553 # environment variable; do not put it in $PATH.
1557 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1558 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1559 if test "$?" -ne 0; then
1560 # on failure, ensure result is empty
1561 func_cygpath_result=
1564 func_cygpath_result=
1565 func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1571 # func_convert_core_msys_to_w32 ARG
1572 # Convert file name or path ARG from MSYS format to w32 format. Return
1573 # result in func_convert_core_msys_to_w32_result.
1574 func_convert_core_msys_to_w32 ()
1577 # awkward: cmd appends spaces to result
1578 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1579 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581 #end: func_convert_core_msys_to_w32
1584 # func_convert_file_check ARG1 ARG2
1585 # Verify that ARG1 (a file name in $build format) was converted to $host
1586 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1587 # func_to_host_file_result to ARG1).
1588 func_convert_file_check ()
1591 if test -z "$2" && test -n "$1" ; then
1592 func_error "Could not determine host file name corresponding to"
1594 func_error "Continuing, but uninstalled executables may not work."
1596 func_to_host_file_result="$1"
1599 # end func_convert_file_check
1602 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1603 # Verify that FROM_PATH (a path in $build format) was converted to $host
1604 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1605 # func_to_host_file_result to a simplistic fallback value (see below).
1606 func_convert_path_check ()
1609 if test -z "$4" && test -n "$3"; then
1610 func_error "Could not determine the host path corresponding to"
1612 func_error "Continuing, but uninstalled executables may not work."
1613 # Fallback. This is a deliberately simplistic "conversion" and
1614 # should not be "improved". See libtool.info.
1615 if test "x$1" != "x$2"; then
1616 lt_replace_pathsep_chars="s|$1|$2|g"
1617 func_to_host_path_result=`echo "$3" |
1618 $SED -e "$lt_replace_pathsep_chars"`
1620 func_to_host_path_result="$3"
1624 # end func_convert_path_check
1627 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1628 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1629 # and appending REPL if ORIG matches BACKPAT.
1630 func_convert_path_front_back_pathsep ()
1634 $1 ) func_to_host_path_result="$3$func_to_host_path_result"
1638 $2 ) func_append func_to_host_path_result "$3"
1642 # end func_convert_path_front_back_pathsep
1645 ##################################################
1646 # $build to $host FILE NAME CONVERSION FUNCTIONS #
1647 ##################################################
1648 # invoked via `$to_host_file_cmd ARG'
1650 # In each case, ARG is the path to be converted from $build to $host format.
1651 # Result will be available in $func_to_host_file_result.
1654 # func_to_host_file ARG
1655 # Converts the file name ARG from $build format to $host format. Return result
1656 # in func_to_host_file_result.
1657 func_to_host_file ()
1660 $to_host_file_cmd "$1"
1662 # end func_to_host_file
1665 # func_to_tool_file ARG LAZY
1666 # converts the file name ARG from $build format to toolchain format. Return
1667 # result in func_to_tool_file_result. If the conversion in use is listed
1668 # in (the comma separated) LAZY, no conversion takes place.
1669 func_to_tool_file ()
1673 *,"$to_tool_file_cmd",*)
1674 func_to_tool_file_result=$1
1677 $to_tool_file_cmd "$1"
1678 func_to_tool_file_result=$func_to_host_file_result
1682 # end func_to_tool_file
1685 # func_convert_file_noop ARG
1686 # Copy ARG to func_to_host_file_result.
1687 func_convert_file_noop ()
1689 func_to_host_file_result="$1"
1691 # end func_convert_file_noop
1694 # func_convert_file_msys_to_w32 ARG
1695 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1696 # conversion to w32 is not available inside the cwrapper. Returns result in
1697 # func_to_host_file_result.
1698 func_convert_file_msys_to_w32 ()
1701 func_to_host_file_result="$1"
1702 if test -n "$1"; then
1703 func_convert_core_msys_to_w32 "$1"
1704 func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706 func_convert_file_check "$1" "$func_to_host_file_result"
1708 # end func_convert_file_msys_to_w32
1711 # func_convert_file_cygwin_to_w32 ARG
1712 # Convert file name ARG from Cygwin to w32 format. Returns result in
1713 # func_to_host_file_result.
1714 func_convert_file_cygwin_to_w32 ()
1717 func_to_host_file_result="$1"
1718 if test -n "$1"; then
1719 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1720 # LT_CYGPATH in this case.
1721 func_to_host_file_result=`cygpath -m "$1"`
1723 func_convert_file_check "$1" "$func_to_host_file_result"
1725 # end func_convert_file_cygwin_to_w32
1728 # func_convert_file_nix_to_w32 ARG
1729 # Convert file name ARG from *nix to w32 format. Requires a wine environment
1730 # and a working winepath. Returns result in func_to_host_file_result.
1731 func_convert_file_nix_to_w32 ()
1734 func_to_host_file_result="$1"
1735 if test -n "$1"; then
1736 func_convert_core_file_wine_to_w32 "$1"
1737 func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739 func_convert_file_check "$1" "$func_to_host_file_result"
1741 # end func_convert_file_nix_to_w32
1744 # func_convert_file_msys_to_cygwin ARG
1745 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1746 # Returns result in func_to_host_file_result.
1747 func_convert_file_msys_to_cygwin ()
1750 func_to_host_file_result="$1"
1751 if test -n "$1"; then
1752 func_convert_core_msys_to_w32 "$1"
1753 func_cygpath -u "$func_convert_core_msys_to_w32_result"
1754 func_to_host_file_result="$func_cygpath_result"
1756 func_convert_file_check "$1" "$func_to_host_file_result"
1758 # end func_convert_file_msys_to_cygwin
1761 # func_convert_file_nix_to_cygwin ARG
1762 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1763 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1764 # in func_to_host_file_result.
1765 func_convert_file_nix_to_cygwin ()
1768 func_to_host_file_result="$1"
1769 if test -n "$1"; then
1770 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1771 func_convert_core_file_wine_to_w32 "$1"
1772 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1773 func_to_host_file_result="$func_cygpath_result"
1775 func_convert_file_check "$1" "$func_to_host_file_result"
1777 # end func_convert_file_nix_to_cygwin
1780 #############################################
1781 # $build to $host PATH CONVERSION FUNCTIONS #
1782 #############################################
1783 # invoked via `$to_host_path_cmd ARG'
1785 # In each case, ARG is the path to be converted from $build to $host format.
1786 # The result will be available in $func_to_host_path_result.
1788 # Path separators are also converted from $build format to $host format. If
1789 # ARG begins or ends with a path separator character, it is preserved (but
1790 # converted to $host format) on output.
1792 # All path conversion functions are named using the following convention:
1793 # file name conversion function : func_convert_file_X_to_Y ()
1794 # path conversion function : func_convert_path_X_to_Y ()
1795 # where, for any given $build/$host combination the 'X_to_Y' value is the
1796 # same. If conversion functions are added for new $build/$host combinations,
1797 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1801 # func_init_to_host_path_cmd
1802 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1803 # appropriate value, based on the value of $to_host_file_cmd.
1805 func_init_to_host_path_cmd ()
1808 if test -z "$to_host_path_cmd"; then
1809 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1810 to_host_path_cmd="func_convert_path_${func_stripname_result}"
1815 # func_to_host_path ARG
1816 # Converts the path ARG from $build format to $host format. Return result
1817 # in func_to_host_path_result.
1818 func_to_host_path ()
1821 func_init_to_host_path_cmd
1822 $to_host_path_cmd "$1"
1824 # end func_to_host_path
1827 # func_convert_path_noop ARG
1828 # Copy ARG to func_to_host_path_result.
1829 func_convert_path_noop ()
1831 func_to_host_path_result="$1"
1833 # end func_convert_path_noop
1836 # func_convert_path_msys_to_w32 ARG
1837 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1838 # conversion to w32 is not available inside the cwrapper. Returns result in
1839 # func_to_host_path_result.
1840 func_convert_path_msys_to_w32 ()
1843 func_to_host_path_result="$1"
1844 if test -n "$1"; then
1845 # Remove leading and trailing path separator characters from ARG. MSYS
1846 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1847 # and winepath ignores them completely.
1848 func_stripname : : "$1"
1849 func_to_host_path_tmp1=$func_stripname_result
1850 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1851 func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1852 func_convert_path_check : ";" \
1853 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1854 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1857 # end func_convert_path_msys_to_w32
1860 # func_convert_path_cygwin_to_w32 ARG
1861 # Convert path ARG from Cygwin to w32 format. Returns result in
1862 # func_to_host_file_result.
1863 func_convert_path_cygwin_to_w32 ()
1866 func_to_host_path_result="$1"
1867 if test -n "$1"; then
1868 # See func_convert_path_msys_to_w32:
1869 func_stripname : : "$1"
1870 func_to_host_path_tmp1=$func_stripname_result
1871 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1872 func_convert_path_check : ";" \
1873 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1874 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1877 # end func_convert_path_cygwin_to_w32
1880 # func_convert_path_nix_to_w32 ARG
1881 # Convert path ARG from *nix to w32 format. Requires a wine environment and
1882 # a working winepath. Returns result in func_to_host_file_result.
1883 func_convert_path_nix_to_w32 ()
1886 func_to_host_path_result="$1"
1887 if test -n "$1"; then
1888 # See func_convert_path_msys_to_w32:
1889 func_stripname : : "$1"
1890 func_to_host_path_tmp1=$func_stripname_result
1891 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1892 func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1893 func_convert_path_check : ";" \
1894 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1895 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1898 # end func_convert_path_nix_to_w32
1901 # func_convert_path_msys_to_cygwin ARG
1902 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1903 # Returns result in func_to_host_file_result.
1904 func_convert_path_msys_to_cygwin ()
1907 func_to_host_path_result="$1"
1908 if test -n "$1"; then
1909 # See func_convert_path_msys_to_w32:
1910 func_stripname : : "$1"
1911 func_to_host_path_tmp1=$func_stripname_result
1912 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1913 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1914 func_to_host_path_result="$func_cygpath_result"
1915 func_convert_path_check : : \
1916 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1917 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1920 # end func_convert_path_msys_to_cygwin
1923 # func_convert_path_nix_to_cygwin ARG
1924 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1925 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1926 # func_to_host_file_result.
1927 func_convert_path_nix_to_cygwin ()
1930 func_to_host_path_result="$1"
1931 if test -n "$1"; then
1932 # Remove leading and trailing path separator characters from
1933 # ARG. msys behavior is inconsistent here, cygpath turns them
1934 # into '.;' and ';.', and winepath ignores them completely.
1935 func_stripname : : "$1"
1936 func_to_host_path_tmp1=$func_stripname_result
1937 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1938 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1939 func_to_host_path_result="$func_cygpath_result"
1940 func_convert_path_check : : \
1941 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1942 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1945 # end func_convert_path_nix_to_cygwin
1948 # func_mode_compile arg...
1949 func_mode_compile ()
1952 # Get the compilation command and the source file.
1954 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1966 # do not "continue". Instead, add this to base_compile
1978 # Accept any command-line options.
1981 test -n "$libobj" && \
1982 func_fatal_error "you cannot specify \`-o' more than once"
1987 -pie | -fpie | -fPIE)
1988 func_append pie_flag " $arg"
1992 -shared | -static | -prefer-pic | -prefer-non-pic)
1993 func_append later " $arg"
2003 arg_mode=arg # the next one goes into the "base_compile" arg list
2004 continue # The current "srcfile" will either be retained or
2005 ;; # replaced later. I would guess that would be a bug.
2008 func_stripname '-Wc,' '' "$arg"
2009 args=$func_stripname_result
2011 save_ifs="$IFS"; IFS=','
2012 for arg in $args; do
2014 func_append_quoted lastarg "$arg"
2017 func_stripname ' ' '' "$lastarg"
2018 lastarg=$func_stripname_result
2020 # Add the arguments to base_compile.
2021 func_append base_compile " $lastarg"
2026 # Accept the current argument as the source file.
2027 # The previous "srcfile" becomes the current argument.
2034 esac # case $arg_mode
2036 # Aesthetically quote the previous argument.
2037 func_append_quoted base_compile "$lastarg"
2042 func_fatal_error "you must specify an argument for -Xcompile"
2045 func_fatal_error "you must specify a target with \`-o'"
2048 # Get the name of the library object.
2049 test -z "$libobj" && {
2050 func_basename "$srcfile"
2051 libobj="$func_basename_result"
2056 # Recognize several different file suffixes.
2057 # If the user specifies -o file.o, it is replaced with file.lo
2060 *.ada | *.adb | *.ads | *.asm | \
2061 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2062 *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
2063 func_xform "$libobj"
2064 libobj=$func_xform_result
2069 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071 func_fatal_error "cannot determine name of library object from \`$libobj'"
2075 func_infer_tag $base_compile
2077 for arg in $later; do
2080 test "$build_libtool_libs" != yes && \
2081 func_fatal_configuration "can not build a shared library"
2087 build_libtool_libs=no
2104 func_quote_for_eval "$libobj"
2105 test "X$libobj" != "X$func_quote_for_eval_result" \
2106 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2107 && func_warning "libobj name \`$libobj' may not contain shell special characters."
2108 func_dirname_and_basename "$obj" "/" ""
2109 objname="$func_basename_result"
2110 xdir="$func_dirname_result"
2111 lobj=${xdir}$objdir/$objname
2113 test -z "$base_compile" && \
2114 func_fatal_help "you must specify a compilation command"
2116 # Delete any leftover library objects.
2117 if test "$build_old_libs" = yes; then
2118 removelist="$obj $lobj $libobj ${libobj}T"
2120 removelist="$lobj $libobj ${libobj}T"
2123 # On Cygwin there's no "real" PIC flag so we must build both object types
2125 cygwin* | mingw* | pw32* | os2* | cegcc*)
2129 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2130 # non-PIC code in shared libraries is not supported
2134 # Calculate the filename of the output object if compiler does
2135 # not support -o with -c
2136 if test "$compiler_c_o" = no; then
2137 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2138 lockfile="$output_obj.lock"
2145 # Lock this critical section if it is needed
2146 # We use this script file to make the link, it avoids creating a new file
2147 if test "$need_locks" = yes; then
2148 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2149 func_echo "Waiting for $lockfile to be removed"
2152 elif test "$need_locks" = warn; then
2153 if test -f "$lockfile"; then
2155 *** ERROR, $lockfile exists and contains:
2156 `cat $lockfile 2>/dev/null`
2158 This indicates that another process is trying to use the same
2159 temporary object file, and libtool could not work around it because
2160 your compiler does not support \`-c' and \`-o' together. If you
2161 repeat this compilation, it may succeed, by chance, but you had better
2162 avoid parallel builds (make -j) in this platform, or get a better
2165 $opt_dry_run || $RM $removelist
2168 func_append removelist " $output_obj"
2169 $ECHO "$srcfile" > "$lockfile"
2172 $opt_dry_run || $RM $removelist
2173 func_append removelist " $lockfile"
2174 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177 srcfile=$func_to_tool_file_result
2178 func_quote_for_eval "$srcfile"
2179 qsrcfile=$func_quote_for_eval_result
2181 # Only build a PIC object if we are building libtool libraries.
2182 if test "$build_libtool_libs" = yes; then
2183 # Without this assignment, base_compile gets emptied.
2184 fbsd_hideous_sh_bug=$base_compile
2186 if test "$pic_mode" != no; then
2187 command="$base_compile $qsrcfile $pic_flag"
2189 # Don't build PIC code
2190 command="$base_compile $qsrcfile"
2193 func_mkdir_p "$xdir$objdir"
2195 if test -z "$output_obj"; then
2196 # Place PIC objects in $objdir
2197 func_append command " -o $lobj"
2200 func_show_eval_locale "$command" \
2201 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203 if test "$need_locks" = warn &&
2204 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206 *** ERROR, $lockfile contains:
2207 `cat $lockfile 2>/dev/null`
2209 but it should contain:
2212 This indicates that another process is trying to use the same
2213 temporary object file, and libtool could not work around it because
2214 your compiler does not support \`-c' and \`-o' together. If you
2215 repeat this compilation, it may succeed, by chance, but you had better
2216 avoid parallel builds (make -j) in this platform, or get a better
2219 $opt_dry_run || $RM $removelist
2223 # Just move the object if needed, then go on to compile the next one
2224 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2225 func_show_eval '$MV "$output_obj" "$lobj"' \
2226 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2229 # Allow error messages only from the first compilation.
2230 if test "$suppress_opt" = yes; then
2231 suppress_output=' >/dev/null 2>&1'
2235 # Only build a position-dependent object if we build old libraries.
2236 if test "$build_old_libs" = yes; then
2237 if test "$pic_mode" != yes; then
2238 # Don't build PIC code
2239 command="$base_compile $qsrcfile$pie_flag"
2241 command="$base_compile $qsrcfile $pic_flag"
2243 if test "$compiler_c_o" = yes; then
2244 func_append command " -o $obj"
2247 # Suppress compiler output if we already did a PIC compilation.
2248 func_append command "$suppress_output"
2249 func_show_eval_locale "$command" \
2250 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252 if test "$need_locks" = warn &&
2253 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255 *** ERROR, $lockfile contains:
2256 `cat $lockfile 2>/dev/null`
2258 but it should contain:
2261 This indicates that another process is trying to use the same
2262 temporary object file, and libtool could not work around it because
2263 your compiler does not support \`-c' and \`-o' together. If you
2264 repeat this compilation, it may succeed, by chance, but you had better
2265 avoid parallel builds (make -j) in this platform, or get a better
2268 $opt_dry_run || $RM $removelist
2272 # Just move the object if needed
2273 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2274 func_show_eval '$MV "$output_obj" "$obj"' \
2275 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2280 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282 # Unlock the critical section if it was locked
2283 if test "$need_locks" != no; then
2284 removelist=$lockfile
2293 test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2298 # We need to display help for each of the modes.
2301 # Generic help is extracted from the usage comments
2302 # at the start of this file.
2308 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310 Remove files from the build directory.
2312 RM is the name of the program to use to delete files associated with each FILE
2313 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2316 If FILE is a libtool library, object or program, all the files associated
2317 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2322 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324 Compile a source file into a libtool library object.
2326 This mode accepts the following additional options:
2328 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
2329 -no-suppress do not suppress compiler output for multiple passes
2330 -prefer-pic try to build PIC objects only
2331 -prefer-non-pic try to build non-PIC objects only
2332 -shared do not build a \`.o' file suitable for static linking
2333 -static only build a \`.o' file suitable for static linking
2334 -Wc,FLAG pass FLAG directly to the compiler
2336 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2337 from the given SOURCEFILE.
2339 The output file name is determined by removing the directory component from
2340 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2341 library object suffix, \`.lo'."
2346 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348 Automatically set library path, then run a program.
2350 This mode accepts the following additional options:
2352 -dlopen FILE add the directory containing FILE to the library path
2354 This mode sets the library path environment variable according to \`-dlopen'
2357 If any of the ARGS are libtool executable wrappers, then they are translated
2358 into their corresponding uninstalled binary, and any of their required library
2359 directories are added to the library path.
2361 Then, COMMAND is executed, with ARGS as arguments."
2366 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368 Complete the installation of libtool libraries.
2370 Each LIBDIR is a directory that contains libtool libraries.
2372 The commands that this mode executes may require superuser privileges. Use
2373 the \`--dry-run' option if you just want to see what would be executed."
2378 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380 Install executables or libraries.
2382 INSTALL-COMMAND is the installation command. The first component should be
2383 either the \`install' or \`cp' program.
2385 The following components of INSTALL-COMMAND are treated specially:
2387 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2389 The rest of the components are interpreted as arguments to that command (only
2390 BSD-compatible install options are recognized)."
2395 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397 Link object files or libraries together to form another library, or to
2398 create an executable program.
2400 LINK-COMMAND is a command using the C compiler that you would use to create
2401 a program from several object files.
2403 The following components of LINK-COMMAND are treated specially:
2405 -all-static do not do any dynamic linking at all
2406 -avoid-version do not add a version suffix if possible
2407 -bindir BINDIR specify path to binaries directory (for systems where
2408 libraries must be found in the PATH setting at runtime)
2409 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2410 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2411 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2412 -export-symbols SYMFILE
2413 try to export only the symbols listed in SYMFILE
2414 -export-symbols-regex REGEX
2415 try to export only the symbols matching REGEX
2416 -LLIBDIR search LIBDIR for required installed libraries
2417 -lNAME OUTPUT-FILE requires the installed library libNAME
2418 -module build a library that can dlopened
2419 -no-fast-install disable the fast-install mode
2420 -no-install link a not-installable executable
2421 -no-undefined declare that a library does not refer to external symbols
2422 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2423 -objectlist FILE Use a list of object files found in FILE to specify objects
2424 -precious-files-regex REGEX
2425 don't remove output files matching REGEX
2426 -release RELEASE specify package release information
2427 -rpath LIBDIR the created library will eventually be installed in LIBDIR
2428 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2429 -shared only do dynamic linking of libtool libraries
2430 -shrext SUFFIX override the standard shared library file extension
2431 -static do not do any dynamic linking of uninstalled libtool libraries
2432 -static-libtool-libs
2433 do not do any dynamic linking of libtool libraries
2434 -version-info CURRENT[:REVISION[:AGE]]
2435 specify library version info [each variable defaults to 0]
2436 -weak LIBNAME declare that the target provides the LIBNAME interface
2438 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2440 -Xlinker FLAG pass linker-specific FLAG directly to the linker
2441 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2443 All other options (arguments beginning with \`-') are ignored.
2445 Every other argument is treated as a filename. Files ending in \`.la' are
2446 treated as uninstalled libtool libraries, other files are standard or library
2449 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2450 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2451 required, except when creating a convenience library.
2453 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2454 using \`ar' and \`ranlib', or on Windows using \`lib'.
2456 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2457 is created, otherwise an executable program is created."
2462 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464 Remove libraries from an installation directory.
2466 RM is the name of the program to use to delete files associated with each FILE
2467 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2470 If FILE is a libtool library, all the files associated with it are deleted.
2471 Otherwise, only FILE itself is deleted using RM."
2475 func_fatal_help "invalid operation mode \`$opt_mode'"
2480 $ECHO "Try \`$progname --help' for more information about other modes."
2483 # Now that we've collected a possible --mode arg, show help if necessary
2485 if test "$opt_help" = :; then
2490 for opt_mode in compile link execute install finish uninstall clean; do
2493 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
2496 for opt_mode in compile link execute install finish uninstall clean; do
2502 /^When reporting/,/^Report/{
2507 /information about other modes/d
2508 /more detailed .*MODE/d
2509 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2515 # func_mode_execute arg...
2516 func_mode_execute ()
2519 # The first argument is the command name.
2522 func_fatal_help "you must specify a COMMAND"
2524 # Handle -dlopen flags immediately.
2525 for file in $opt_dlopen; do
2527 || func_fatal_help "\`$file' is not a file"
2532 func_resolve_sysroot "$file"
2533 file=$func_resolve_sysroot_result
2535 # Check to see that this really is a libtool archive.
2536 func_lalib_unsafe_p "$file" \
2537 || func_fatal_help "\`$lib' is not a valid libtool archive"
2539 # Read the libtool library.
2544 # Skip this library if it cannot be dlopened.
2545 if test -z "$dlname"; then
2546 # Warn if it was a shared library.
2547 test -n "$library_names" && \
2548 func_warning "\`$file' was not linked with \`-export-dynamic'"
2552 func_dirname "$file" "" "."
2553 dir="$func_dirname_result"
2555 if test -f "$dir/$objdir/$dlname"; then
2556 func_append dir "/$objdir"
2558 if test ! -f "$dir/$dlname"; then
2559 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2565 # Just add the directory containing the .lo file.
2566 func_dirname "$file" "" "."
2567 dir="$func_dirname_result"
2571 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2576 # Get the absolute pathname.
2577 absdir=`cd "$dir" && pwd`
2578 test -n "$absdir" && dir="$absdir"
2580 # Now add the directory to shlibpath_var.
2581 if eval "test -z \"\$$shlibpath_var\""; then
2582 eval "$shlibpath_var=\"\$dir\""
2584 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2588 # This variable tells wrapper scripts just to set shlibpath_var
2589 # rather than running their programs.
2590 libtool_execute_magic="$magic"
2592 # Check if any of the arguments is a wrapper script.
2597 -* | *.la | *.lo ) ;;
2599 # Do a test to see if this is really a libtool program.
2600 if func_ltwrapper_script_p "$file"; then
2602 # Transform arg to wrapped name.
2603 file="$progdir/$program"
2604 elif func_ltwrapper_executable_p "$file"; then
2605 func_ltwrapper_scriptname "$file"
2606 func_source "$func_ltwrapper_scriptname_result"
2607 # Transform arg to wrapped name.
2608 file="$progdir/$program"
2612 # Quote arguments (to preserve shell metacharacters).
2613 func_append_quoted args "$file"
2616 if test "X$opt_dry_run" = Xfalse; then
2617 if test -n "$shlibpath_var"; then
2618 # Export the shlibpath_var.
2619 eval "export $shlibpath_var"
2622 # Restore saved environment variables
2623 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625 eval "if test \"\${save_$lt_var+set}\" = set; then
2626 $lt_var=\$save_$lt_var; export $lt_var
2632 # Now prepare to actually exec the command.
2633 exec_cmd="\$cmd$args"
2635 # Display what would be done.
2636 if test -n "$shlibpath_var"; then
2637 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2638 echo "export $shlibpath_var"
2645 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2648 # func_mode_finish arg...
2656 for opt in "$nonopt" ${1+"$@"}
2658 if test -d "$opt"; then
2659 func_append libdirs " $opt"
2661 elif test -f "$opt"; then
2662 if func_lalib_unsafe_p "$opt"; then
2663 func_append libs " $opt"
2665 func_warning "\`$opt' is not a valid libtool archive"
2669 func_fatal_error "invalid argument \`$opt'"
2673 if test -n "$libs"; then
2674 if test -n "$lt_sysroot"; then
2675 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2676 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2681 # Remove sysroot references
2682 if $opt_dry_run; then
2683 for lib in $libs; do
2684 echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2687 tmpdir=`func_mktempdir`
2688 for lib in $libs; do
2689 sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691 mv -f $tmpdir/tmp-la $lib
2697 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2698 for libdir in $libdirs; do
2699 if test -n "$finish_cmds"; then
2700 # Do each command in the finish commands.
2701 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2704 if test -n "$finish_eval"; then
2705 # Do the single finish_eval.
2706 eval cmds=\"$finish_eval\"
2707 $opt_dry_run || eval "$cmds" || func_append admincmds "
2713 # Exit here if they wanted silent mode.
2714 $opt_silent && exit $EXIT_SUCCESS
2716 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2717 echo "----------------------------------------------------------------------"
2718 echo "Libraries have been installed in:"
2719 for libdir in $libdirs; do
2723 echo "If you ever happen to want to link against installed libraries"
2724 echo "in a given directory, LIBDIR, you must either use libtool, and"
2725 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2726 echo "flag during linking and do at least one of the following:"
2727 if test -n "$shlibpath_var"; then
2728 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2729 echo " during execution"
2731 if test -n "$runpath_var"; then
2732 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2733 echo " during linking"
2735 if test -n "$hardcode_libdir_flag_spec"; then
2737 eval flag=\"$hardcode_libdir_flag_spec\"
2739 $ECHO " - use the \`$flag' linker flag"
2741 if test -n "$admincmds"; then
2742 $ECHO " - have your system administrator run these commands:$admincmds"
2744 if test -f /etc/ld.so.conf; then
2745 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2749 echo "See any operating system documentation about shared libraries for"
2751 solaris2.[6789]|solaris2.1[0-9])
2752 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2756 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2759 echo "----------------------------------------------------------------------"
2764 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2767 # func_mode_install arg...
2768 func_mode_install ()
2771 # There may be an optional sh(1) argument at the beginning of
2772 # install_prog (especially on Windows NT).
2773 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2774 # Allow the use of GNU shtool's install command.
2775 case $nonopt in *shtool*) :;; *) false;; esac; then
2776 # Aesthetically quote it.
2777 func_quote_for_eval "$nonopt"
2778 install_prog="$func_quote_for_eval_result "
2786 # The real first argument should be the name of the installation program.
2787 # Aesthetically quote it.
2788 func_quote_for_eval "$arg"
2789 func_append install_prog "$func_quote_for_eval_result"
2790 install_shared_prog=$install_prog
2791 case " $install_prog " in
2792 *[\\\ /]cp\ *) install_cp=: ;;
2793 *) install_cp=false ;;
2796 # We need to accept at least all the BSD install flags.
2808 if test -n "$dest"; then
2809 func_append files " $dest"
2817 if $install_cp; then :; else
2831 # If the previous option needed an argument, then skip it.
2832 if test -n "$prev"; then
2833 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2834 arg2=$install_override_mode
2845 # Aesthetically quote the argument.
2846 func_quote_for_eval "$arg"
2847 func_append install_prog " $func_quote_for_eval_result"
2848 if test -n "$arg2"; then
2849 func_quote_for_eval "$arg2"
2851 func_append install_shared_prog " $func_quote_for_eval_result"
2854 test -z "$install_prog" && \
2855 func_fatal_help "you must specify an install program"
2857 test -n "$prev" && \
2858 func_fatal_help "the \`$prev' option requires an argument"
2860 if test -n "$install_override_mode" && $no_mode; then
2861 if $install_cp; then :; else
2862 func_quote_for_eval "$install_override_mode"
2863 func_append install_shared_prog " -m $func_quote_for_eval_result"
2867 if test -z "$files"; then
2868 if test -z "$dest"; then
2869 func_fatal_help "no file or destination specified"
2871 func_fatal_help "you must specify a destination"
2875 # Strip any trailing slash from the destination.
2876 func_stripname '' '/' "$dest"
2877 dest=$func_stripname_result
2879 # Check to see that the destination is a directory.
2880 test -d "$dest" && isdir=yes
2881 if test "$isdir" = yes; then
2885 func_dirname_and_basename "$dest" "" "."
2886 destdir="$func_dirname_result"
2887 destname="$func_basename_result"
2889 # Not a directory, so check to see that there is only one file specified.
2890 set dummy $files; shift
2891 test "$#" -gt 1 && \
2892 func_fatal_help "\`$dest' is not a directory"
2895 [\\/]* | [A-Za-z]:[\\/]*) ;;
2897 for file in $files; do
2901 func_fatal_help "\`$destdir' must be an absolute directory name"
2908 # This variable tells wrapper scripts just to set variables rather
2909 # than running their programs.
2910 libtool_install_magic="$magic"
2915 for file in $files; do
2917 # Do each installation.
2920 # Do the static libraries later.
2921 func_append staticlibs " $file"
2925 func_resolve_sysroot "$file"
2926 file=$func_resolve_sysroot_result
2928 # Check to see that this really is a libtool archive.
2929 func_lalib_unsafe_p "$file" \
2930 || func_fatal_help "\`$file' is not a valid libtool archive"
2937 # Add the libdir to current_libdirs if it is the destination.
2938 if test "X$destdir" = "X$libdir"; then
2939 case "$current_libdirs " in
2941 *) func_append current_libdirs " $libdir" ;;
2944 # Note the libdir as a future libdir.
2945 case "$future_libdirs " in
2947 *) func_append future_libdirs " $libdir" ;;
2951 func_dirname "$file" "/" ""
2952 dir="$func_dirname_result"
2953 func_append dir "$objdir"
2955 if test -n "$relink_command"; then
2956 # Determine the prefix the user has applied to our future dir.
2957 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959 # Don't allow the user to place us outside of our expected
2960 # location b/c this prevents finding dependent libraries that
2961 # are installed to the same prefix.
2962 # At present, this check doesn't affect windows .dll's that
2963 # are installed into $libdir/../bin (currently, that works fine)
2964 # but it's something to keep an eye on.
2965 test "$inst_prefix_dir" = "$destdir" && \
2966 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968 if test -n "$inst_prefix_dir"; then
2969 # Stick the inst_prefix_dir data into the link command.
2970 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2975 func_warning "relinking \`$file'"
2976 func_show_eval "$relink_command" \
2977 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2980 # See the names of the shared library.
2981 set dummy $library_names; shift
2982 if test -n "$1"; then
2987 test -n "$relink_command" && srcname="$realname"T
2989 # Install the shared library and build the symlinks.
2990 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2994 cygwin* | mingw* | pw32* | cegcc*)
3002 if test -n "$tstripme" && test -n "$striplib"; then
3003 func_show_eval "$striplib $destdir/$realname" 'exit $?'
3006 if test "$#" -gt 0; then
3007 # Delete the old symlinks, and create new ones.
3008 # Try `ln -sf' first, because the `ln' binary might depend on
3009 # the symlink we replace! Solaris /bin/ln does not understand -f,
3010 # so we also need to try rm && ln -s.
3013 test "$linkname" != "$realname" \
3014 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3018 # Do each command in the postinstall commands.
3019 lib="$destdir/$realname"
3020 func_execute_cmds "$postinstall_cmds" 'exit $?'
3023 # Install the pseudo-library for information purposes.
3024 func_basename "$file"
3025 name="$func_basename_result"
3026 instname="$dir/$name"i
3027 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029 # Maybe install the static library, too.
3030 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3034 # Install (i.e. copy) a libtool object.
3036 # Figure out destination file name, if it wasn't already specified.
3037 if test -n "$destname"; then
3038 destfile="$destdir/$destname"
3040 func_basename "$file"
3041 destfile="$func_basename_result"
3042 destfile="$destdir/$destfile"
3045 # Deduce the name of the destination old-style object file.
3048 func_lo2o "$destfile"
3049 staticdest=$func_lo2o_result
3052 staticdest="$destfile"
3056 func_fatal_help "cannot copy a libtool object to \`$destfile'"
3060 # Install the libtool object if requested.
3061 test -n "$destfile" && \
3062 func_show_eval "$install_prog $file $destfile" 'exit $?'
3064 # Install the old object if enabled.
3065 if test "$build_old_libs" = yes; then
3066 # Deduce the name of the old-style object file.
3068 staticobj=$func_lo2o_result
3069 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3075 # Figure out destination file name, if it wasn't already specified.
3076 if test -n "$destname"; then
3077 destfile="$destdir/$destname"
3079 func_basename "$file"
3080 destfile="$func_basename_result"
3081 destfile="$destdir/$destfile"
3084 # If the file is missing, and there is a .exe on the end, strip it
3085 # because it is most likely a libtool script we actually want to
3090 if test ! -f "$file"; then
3091 func_stripname '' '.exe' "$file"
3092 file=$func_stripname_result
3098 # Do a test to see if this is really a libtool program.
3101 if func_ltwrapper_executable_p "$file"; then
3102 func_ltwrapper_scriptname "$file"
3103 wrapper=$func_ltwrapper_scriptname_result
3105 func_stripname '' '.exe' "$file"
3106 wrapper=$func_stripname_result
3113 if func_ltwrapper_script_p "$wrapper"; then
3117 func_source "$wrapper"
3119 # Check the variables that should have been set.
3120 test -z "$generated_by_libtool_version" && \
3121 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3124 for lib in $notinst_deplibs; do
3125 # Check to see that each library is installed.
3127 if test -f "$lib"; then
3130 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3131 if test -n "$libdir" && test ! -f "$libfile"; then
3132 func_warning "\`$lib' has not been installed in \`$libdir'"
3138 func_source "$wrapper"
3141 if test "$fast_install" = no && test -n "$relink_command"; then
3143 if test "$finalize" = yes; then
3144 tmpdir=`func_mktempdir`
3145 func_basename "$file$stripped_ext"
3146 file="$func_basename_result"
3147 outputname="$tmpdir/$file"
3148 # Replace the output file specification.
3149 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3152 func_quote_for_expand "$relink_command"
3153 eval "func_echo $func_quote_for_expand_result"
3155 if eval "$relink_command"; then :
3157 func_error "error: relink \`$file' with the above command before installing it"
3158 $opt_dry_run || ${RM}r "$tmpdir"
3163 func_warning "cannot relink \`$file'"
3167 # Install the binary that we compiled earlier.
3168 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3172 # remove .exe since cygwin /usr/bin/install will append another
3174 case $install_prog,$host in
3175 */usr/bin/install*,*cygwin*)
3176 case $file:$destfile in
3181 destfile=$destfile.exe
3184 func_stripname '' '.exe' "$destfile"
3185 destfile=$func_stripname_result
3190 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3191 $opt_dry_run || if test -n "$outputname"; then
3198 for file in $staticlibs; do
3199 func_basename "$file"
3200 name="$func_basename_result"
3202 # Set up the ranlib parameters.
3203 oldlib="$destdir/$name"
3205 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3207 if test -n "$stripme" && test -n "$old_striplib"; then
3208 func_show_eval "$old_striplib $oldlib" 'exit $?'
3211 # Do each command in the postinstall commands.
3212 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3215 test -n "$future_libdirs" && \
3216 func_warning "remember to run \`$progname --finish$future_libdirs'"
3218 if test -n "$current_libdirs"; then
3219 # Maybe just do a dry run.
3220 $opt_dry_run && current_libdirs=" -n$current_libdirs"
3221 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3227 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3230 # func_generate_dlsyms outputname originator pic_p
3231 # Extract symbols from dlprefiles and create ${outputname}S.o with
3232 # a dlpreopen symbol table.
3233 func_generate_dlsyms ()
3239 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3242 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3243 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3244 my_dlsyms="${my_outputname}S.c"
3246 func_error "not configured to extract global symbols from dlpreopened files"
3250 if test -n "$my_dlsyms"; then
3254 # Discover the nlist of each of the dlfiles.
3255 nlist="$output_objdir/${my_outputname}.nm"
3257 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3259 # Parse the name list into a source file.
3260 func_verbose "creating $output_objdir/$my_dlsyms"
3262 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3263 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3264 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3270 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3271 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3274 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3275 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3276 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3277 relocations are performed -- see ld's documentation on pseudo-relocs. */
3278 # define LT_DLSYM_CONST
3279 #elif defined(__osf__)
3280 /* This system does not cope well with relocations in const data. */
3281 # define LT_DLSYM_CONST
3283 # define LT_DLSYM_CONST const
3286 /* External symbol declarations for the compiler. */\
3289 if test "$dlself" = yes; then
3290 func_verbose "generating symbol list for \`$output'"
3292 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3294 # Add our own program objects to the symbol list.
3295 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3296 for progfile in $progfiles; do
3297 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3298 func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3299 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3302 if test -n "$exclude_expsyms"; then
3304 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3305 eval '$MV "$nlist"T "$nlist"'
3309 if test -n "$export_symbols_regex"; then
3311 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3312 eval '$MV "$nlist"T "$nlist"'
3316 # Prepare the list of exported symbols
3317 if test -z "$export_symbols"; then
3318 export_symbols="$output_objdir/$outputname.exp"
3321 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3323 *cygwin* | *mingw* | *cegcc* )
3324 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3325 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3331 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3332 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3333 eval '$MV "$nlist"T "$nlist"'
3335 *cygwin* | *mingw* | *cegcc* )
3336 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3337 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3344 for dlprefile in $dlprefiles; do
3345 func_verbose "extracting global C symbols from \`$dlprefile'"
3346 func_basename "$dlprefile"
3347 name="$func_basename_result"
3349 *cygwin* | *mingw* | *cegcc* )
3350 # if an import library, we need to obtain dlname
3351 if func_win32_import_lib_p "$dlprefile"; then
3352 func_tr_sh "$dlprefile"
3353 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3354 dlprefile_dlbasename=""
3355 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3356 # Use subshell, to avoid clobbering current variable values
3357 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3358 if test -n "$dlprefile_dlname" ; then
3359 func_basename "$dlprefile_dlname"
3360 dlprefile_dlbasename="$func_basename_result"
3362 # no lafile. user explicitly requested -dlpreopen <import library>.
3363 $sharedlib_from_linklib_cmd "$dlprefile"
3364 dlprefile_dlbasename=$sharedlib_from_linklib_result
3368 if test -n "$dlprefile_dlbasename" ; then
3369 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3371 func_warning "Could not compute DLL name from $name"
3372 eval '$ECHO ": $name " >> "$nlist"'
3374 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3375 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3376 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3378 else # not an import lib
3380 eval '$ECHO ": $name " >> "$nlist"'
3381 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3382 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3388 eval '$ECHO ": $name " >> "$nlist"'
3389 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3390 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3397 # Make sure we have at least an empty file.
3398 test -f "$nlist" || : > "$nlist"
3400 if test -n "$exclude_expsyms"; then
3401 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3402 $MV "$nlist"T "$nlist"
3405 # Try sorting and uniquifying the output.
3406 if $GREP -v "^: " < "$nlist" |
3407 if sort -k 3 </dev/null >/dev/null 2>&1; then
3412 uniq > "$nlist"S; then
3415 $GREP -v "^: " < "$nlist" > "$nlist"S
3418 if test -f "$nlist"S; then
3419 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3421 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3424 echo >> "$output_objdir/$my_dlsyms" "\
3426 /* The mapping between symbol names and symbols. */
3431 extern LT_DLSYM_CONST lt_dlsymlist
3432 lt_${my_prefix}_LTX_preloaded_symbols[];
3433 LT_DLSYM_CONST lt_dlsymlist
3434 lt_${my_prefix}_LTX_preloaded_symbols[] =
3436 { \"$my_originator\", (void *) 0 },"
3438 case $need_lib_prefix in
3440 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3443 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3446 echo >> "$output_objdir/$my_dlsyms" "\
3450 /* This works around a problem in FreeBSD linker */
3451 #ifdef FREEBSD_WORKAROUND
3452 static const void *lt_preloaded_setup() {
3453 return lt_${my_prefix}_LTX_preloaded_symbols;
3463 pic_flag_for_symtable=
3464 case "$compile_command " in
3468 # compiling the symbol table file with pic_flag works around
3469 # a FreeBSD bug that causes programs to crash when -lm is
3470 # linked before any other PIC object. But we must not use
3471 # pic_flag when linking with -static. The problem exists in
3472 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3473 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3474 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3476 pic_flag_for_symtable=" $pic_flag" ;;
3478 if test "X$my_pic_p" != Xno; then
3479 pic_flag_for_symtable=" $pic_flag"
3486 for arg in $LTCFLAGS; do
3488 -pie | -fpie | -fPIE) ;;
3489 *) func_append symtab_cflags " $arg" ;;
3493 # Now compile the dynamic symbol file.
3494 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3496 # Clean up the generated files.
3497 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3499 # Transform the symbol file into the correct name.
3500 symfileobj="$output_objdir/${my_outputname}S.$objext"
3502 *cygwin* | *mingw* | *cegcc* )
3503 if test -f "$output_objdir/$my_outputname.def"; then
3504 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3505 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3507 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3508 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3518 func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522 # We keep going just in case the user didn't refer to
3523 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3524 # really was required.
3526 # Nullify the symbol file.
3527 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3528 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532 # func_win32_libid arg
3533 # return the library type of file 'arg'
3535 # Need a lot of goo to handle *both* DLLs and import libs
3536 # Has to be a shell function in order to 'eat' the argument
3537 # that is supplied when $file_magic_command is called.
3538 # Despite the name, also deal with 64 bit binaries.
3542 win32_libid_type="unknown"
3543 win32_fileres=`file -L $1 2>/dev/null`
3544 case $win32_fileres in
3545 *ar\ archive\ import\ library*) # definitely import
3546 win32_libid_type="x86 archive import"
3548 *ar\ archive*) # could be an import, or static
3549 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3550 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3551 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3552 func_to_tool_file "$1" func_convert_file_msys_to_w32
3553 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3562 case $win32_nmres in
3563 import*) win32_libid_type="x86 archive import";;
3564 *) win32_libid_type="x86 archive static";;
3569 win32_libid_type="x86 DLL"
3571 *executable*) # but shell scripts are "executable" too...
3572 case $win32_fileres in
3573 *MS\ Windows\ PE\ Intel*)
3574 win32_libid_type="x86 DLL"
3579 $ECHO "$win32_libid_type"
3582 # func_cygming_dll_for_implib ARG
3584 # Platform-specific function to extract the
3585 # name of the DLL associated with the specified
3586 # import library ARG.
3587 # Invoked by eval'ing the libtool variable
3588 # $sharedlib_from_linklib_cmd
3589 # Result is available in the variable
3590 # $sharedlib_from_linklib_result
3591 func_cygming_dll_for_implib ()
3594 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3597 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3599 # The is the core of a fallback implementation of a
3600 # platform-specific function to extract the name of the
3601 # DLL associated with the specified import library LIBNAME.
3603 # SECTION_NAME is either .idata$6 or .idata$7, depending
3604 # on the platform and compiler that created the implib.
3606 # Echos the name of the DLL associated with the
3607 # specified import library.
3608 func_cygming_dll_for_implib_fallback_core ()
3611 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3612 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3613 $SED '/^Contents of section '"$match_literal"':/{
3614 # Place marker at beginning of archive member dllname section
3619 # These lines can sometimes be longer than 43 characters, but
3620 # are always uninteresting
3621 /:[ ]*file format pe[i]\{,1\}-/d
3622 /^In archive [^:]*:/d
3623 # Ensure marker is printed
3625 # Remove all lines with less than 43 characters
3627 # From remaining lines, remove first 43 characters
3630 # Join marker and all lines until next marker into a single line
3631 /^====MARK====/ b para
3640 # Remove trailing dots and whitespace
3644 # we now have a list, one entry per line, of the stringified
3645 # contents of the appropriate section of all members of the
3646 # archive which possess that section. Heuristic: eliminate
3647 # all those which have a first or second character that is
3648 # a '.' (that is, objdump's representation of an unprintable
3649 # character.) This should work for all archives with less than
3650 # 0x302f exports -- but will fail for DLLs whose name actually
3651 # begins with a literal '.' or a single character followed by
3654 # Of those that remain, print the first one.
3655 $SED -e '/^\./d;/^.\./d;q'
3658 # func_cygming_gnu_implib_p ARG
3659 # This predicate returns with zero status (TRUE) if
3660 # ARG is a GNU/binutils-style import library. Returns
3661 # with nonzero status (FALSE) otherwise.
3662 func_cygming_gnu_implib_p ()
3665 func_to_tool_file "$1" func_convert_file_msys_to_w32
3666 func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3667 test -n "$func_cygming_gnu_implib_tmp"
3670 # func_cygming_ms_implib_p ARG
3671 # This predicate returns with zero status (TRUE) if
3672 # ARG is an MS-style import library. Returns
3673 # with nonzero status (FALSE) otherwise.
3674 func_cygming_ms_implib_p ()
3677 func_to_tool_file "$1" func_convert_file_msys_to_w32
3678 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3679 test -n "$func_cygming_ms_implib_tmp"
3682 # func_cygming_dll_for_implib_fallback ARG
3683 # Platform-specific function to extract the
3684 # name of the DLL associated with the specified
3685 # import library ARG.
3687 # This fallback implementation is for use when $DLLTOOL
3688 # does not support the --identify-strict option.
3689 # Invoked by eval'ing the libtool variable
3690 # $sharedlib_from_linklib_cmd
3691 # Result is available in the variable
3692 # $sharedlib_from_linklib_result
3693 func_cygming_dll_for_implib_fallback ()
3696 if func_cygming_gnu_implib_p "$1" ; then
3697 # binutils import library
3698 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3699 elif func_cygming_ms_implib_p "$1" ; then
3700 # ms-generated import library
3701 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3704 sharedlib_from_linklib_result=""
3709 # func_extract_an_archive dir oldlib
3710 func_extract_an_archive ()
3713 f_ex_an_ar_dir="$1"; shift
3714 f_ex_an_ar_oldlib="$1"
3715 if test "$lock_old_archive_extraction" = yes; then
3716 lockfile=$f_ex_an_ar_oldlib.lock
3717 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3718 func_echo "Waiting for $lockfile to be removed"
3722 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3723 'stat=$?; rm -f "$lockfile"; exit $stat'
3724 if test "$lock_old_archive_extraction" = yes; then
3725 $opt_dry_run || rm -f "$lockfile"
3727 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3730 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3735 # func_extract_archives gentop oldlib ...
3736 func_extract_archives ()
3739 my_gentop="$1"; shift
3740 my_oldlibs=${1+"$@"}
3746 for my_xlib in $my_oldlibs; do
3747 # Extract the objects.
3749 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3750 *) my_xabs=`pwd`"/$my_xlib" ;;
3752 func_basename "$my_xlib"
3753 my_xlib="$func_basename_result"
3756 case " $extracted_archives " in
3758 func_arith $extracted_serial + 1
3759 extracted_serial=$func_arith_result
3760 my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764 extracted_archives="$extracted_archives $my_xlib_u"
3765 my_xdir="$my_gentop/$my_xlib_u"
3767 func_mkdir_p "$my_xdir"
3771 func_verbose "Extracting $my_xabs"
3772 # Do not bother doing anything if just a dry run
3774 darwin_orig_dir=`pwd`
3775 cd $my_xdir || exit $?
3776 darwin_archive=$my_xabs
3778 darwin_base_archive=`basename "$darwin_archive"`
3779 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3780 if test -n "$darwin_arches"; then
3781 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3783 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3784 for darwin_arch in $darwin_arches ; do
3785 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3786 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3787 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3788 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3790 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3791 done # $darwin_arches
3792 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3793 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3796 for darwin_file in $darwin_filelist; do
3797 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3798 $LIPO -create -output "$darwin_file" $darwin_files
3799 done # $darwin_filelist
3801 cd "$darwin_orig_dir"
3804 func_extract_an_archive "$my_xdir" "$my_xabs"
3809 func_extract_an_archive "$my_xdir" "$my_xabs"
3812 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3815 func_extract_archives_result="$my_oldobjs"
3819 # func_emit_wrapper [arg=no]
3821 # Emit a libtool wrapper script on stdout.
3822 # Don't directly open a file because we may want to
3823 # incorporate the script contents within a cygwin/mingw
3824 # wrapper executable. Must ONLY be called from within
3825 # func_mode_link because it depends on a number of variables
3828 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3829 # variable will take. If 'yes', then the emitted script
3830 # will assume that the directory in which it is stored is
3831 # the $objdir directory. This is a cygwin/mingw-specific
3833 func_emit_wrapper ()
3835 func_emit_wrapper_arg1=${1-no}
3840 # $output - temporary wrapper script for $objdir/$outputname
3841 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3843 # The $output program cannot be directly executed until all the libtool
3844 # libraries that it depends on are installed.
3846 # This wrapper script should never be moved out of the build directory.
3847 # If it is, it will not operate correctly.
3849 # Sed substitution that helps us do robust quoting. It backslashifies
3850 # metacharacters that are still active within double-quoted strings.
3851 sed_quote_subst='$sed_quote_subst'
3853 # Be Bourne compatible
3854 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3857 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3858 # is contrary to our usage. Disable this feature.
3859 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3860 setopt NO_GLOB_SUBST
3862 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3864 BIN_SH=xpg4; export BIN_SH # for Tru64
3865 DUALCASE=1; export DUALCASE # for MKS sh
3867 # The HP-UX ksh and POSIX shell print the target directory to stdout
3869 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3871 relink_command=\"$relink_command\"
3873 # This environment variable determines our operation mode.
3874 if test \"\$libtool_install_magic\" = \"$magic\"; then
3875 # install mode needs the following variables:
3876 generated_by_libtool_version='$macro_version'
3877 notinst_deplibs='$notinst_deplibs'
3879 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3880 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3883 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3886 # A function that is used when there is no print builtin or printf.
3887 func_fallback_echo ()
3889 eval 'cat <<_LTECHO_EOF
3896 # Very basic option parsing. These options are (a) specific to
3897 # the libtool wrapper, (b) are identical between the wrapper
3898 # /script/ and the wrapper /executable/ which is used only on
3899 # windows platforms, and (c) all begin with the string "--lt-"
3900 # (application programs are unlikely to have options which match
3903 # There are only two supported options: --lt-debug and
3904 # --lt-dump-script. There is, deliberately, no --lt-help.
3906 # The first argument to this parsing function should be the
3907 # script's $0 value, followed by "$@".
3909 func_parse_lt_options ()
3915 case \"\$lt_opt\" in
3916 --lt-debug) lt_option_debug=1 ;;
3918 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3919 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3920 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3921 cat \"\$lt_dump_D/\$lt_dump_F\"
3925 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3931 # Print the debug banner immediately:
3932 if test -n \"\$lt_option_debug\"; then
3933 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3937 # Used when --lt-debug. Prints its arguments to stdout
3938 # (redirection is the responsibility of the caller)
3939 func_lt_dump_args ()
3944 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3945 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3949 # Core function for launching the target application
3950 func_exec_program_core ()
3954 # Backslashes separate directories on plain windows
3955 *-*-mingw | *-*-os2* | *-cegcc*)
3957 if test -n \"\$lt_option_debug\"; then
3958 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3959 func_lt_dump_args \${1+\"\$@\"} 1>&2
3961 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3967 if test -n \"\$lt_option_debug\"; then
3968 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3969 func_lt_dump_args \${1+\"\$@\"} 1>&2
3971 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3976 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3980 # A function to encapsulate launching the target application
3981 # Strips options in the --lt-* namespace from \$@ and
3982 # launches target application with the remaining arguments.
3983 func_exec_program ()
3989 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3993 func_exec_program_core \${1+\"\$@\"}
3997 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3999 # Find the directory that this script lives in.
4000 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4001 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4003 # Follow symbolic links until we get to the real thisdir.
4004 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4005 while test -n \"\$file\"; do
4006 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4008 # If there was a directory component, then change thisdir.
4009 if test \"x\$destdir\" != \"x\$file\"; then
4010 case \"\$destdir\" in
4011 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4012 *) thisdir=\"\$thisdir/\$destdir\" ;;
4016 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4017 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4020 # Usually 'no', except on cygwin/mingw when embedded into
4022 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4023 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4024 # special case for '.'
4025 if test \"\$thisdir\" = \".\"; then
4028 # remove .libs from thisdir
4029 case \"\$thisdir\" in
4030 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4031 $objdir ) thisdir=. ;;
4035 # Try to get the absolute directory name.
4036 absdir=\`cd \"\$thisdir\" && pwd\`
4037 test -n \"\$absdir\" && thisdir=\"\$absdir\"
4040 if test "$fast_install" = yes; then
4042 program=lt-'$outputname'$exeext
4043 progdir=\"\$thisdir/$objdir\"
4045 if test ! -f \"\$progdir/\$program\" ||
4046 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4047 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4049 file=\"\$\$-\$program\"
4051 if test ! -d \"\$progdir\"; then
4052 $MKDIR \"\$progdir\"
4054 $RM \"\$progdir/\$file\"
4059 # relink executable if necessary
4060 if test -n \"\$relink_command\"; then
4061 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4063 $ECHO \"\$relink_command_output\" >&2
4064 $RM \"\$progdir/\$file\"
4069 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4070 { $RM \"\$progdir/\$program\";
4071 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4072 $RM \"\$progdir/\$file\"
4076 program='$outputname'
4077 progdir=\"\$thisdir/$objdir\"
4083 if test -f \"\$progdir/\$program\"; then"
4085 # fixup the dll searchpath if we need to.
4087 # Fix the DLL searchpath if we need to. Do this before prepending
4088 # to shlibpath, because on Windows, both are PATH and uninstalled
4089 # libraries must come first.
4090 if test -n "$dllsearchpath"; then
4092 # Add the dll search path components to the executable PATH
4093 PATH=$dllsearchpath:\$PATH
4097 # Export our shlibpath_var if we have one.
4098 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4100 # Add our own library path to $shlibpath_var
4101 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4103 # Some systems cannot cope with colon-terminated $shlibpath_var
4104 # The second colon is a workaround for a bug in BeOS R4 sed
4105 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4107 export $shlibpath_var
4112 if test \"\$libtool_execute_magic\" != \"$magic\"; then
4113 # Run the actual program with our arguments.
4114 func_exec_program \${1+\"\$@\"}
4117 # The program doesn't exist.
4118 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4119 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4120 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4128 # func_emit_cwrapperexe_src
4129 # emit the source code for a wrapper executable on stdout
4130 # Must ONLY be called from within func_mode_link because
4131 # it depends on a number of variable set therein.
4132 func_emit_cwrapperexe_src ()
4136 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4137 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4139 The $output program cannot be directly executed until all the libtool
4140 libraries that it depends on are installed.
4142 This wrapper executable should never be moved out of the build directory.
4143 If it is, it will not operate correctly.
4148 # define _CRT_SECURE_NO_DEPRECATE 1
4153 # include <direct.h>
4154 # include <process.h>
4157 # include <unistd.h>
4158 # include <stdint.h>
4170 #include <sys/stat.h>
4172 /* declarations of non-ANSI functions */
4173 #if defined(__MINGW32__)
4174 # ifdef __STRICT_ANSI__
4175 int _putenv (const char *);
4177 #elif defined(__CYGWIN__)
4178 # ifdef __STRICT_ANSI__
4179 char *realpath (const char *, char *);
4180 int putenv (char *);
4181 int setenv (const char *, const char *, int);
4183 /* #elif defined (other platforms) ... */
4186 /* portability defines, excluding path handling macros */
4187 #if defined(_MSC_VER)
4188 # define setmode _setmode
4190 # define chmod _chmod
4191 # define getcwd _getcwd
4192 # define putenv _putenv
4193 # define S_IXUSR _S_IEXEC
4194 # ifndef _INTPTR_T_DEFINED
4195 # define _INTPTR_T_DEFINED
4196 # define intptr_t int
4198 #elif defined(__MINGW32__)
4199 # define setmode _setmode
4201 # define chmod _chmod
4202 # define getcwd _getcwd
4203 # define putenv _putenv
4204 #elif defined(__CYGWIN__)
4205 # define HAVE_SETENV
4206 # define FOPEN_WB "wb"
4207 /* #elif defined (other platforms) ... */
4210 #if defined(PATH_MAX)
4211 # define LT_PATHMAX PATH_MAX
4212 #elif defined(MAXPATHLEN)
4213 # define LT_PATHMAX MAXPATHLEN
4215 # define LT_PATHMAX 1024
4225 /* path handling portability macros */
4226 #ifndef DIR_SEPARATOR
4227 # define DIR_SEPARATOR '/'
4228 # define PATH_SEPARATOR ':'
4231 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4233 # define HAVE_DOS_BASED_FILE_SYSTEM
4234 # define FOPEN_WB "wb"
4235 # ifndef DIR_SEPARATOR_2
4236 # define DIR_SEPARATOR_2 '\\'
4238 # ifndef PATH_SEPARATOR_2
4239 # define PATH_SEPARATOR_2 ';'
4243 #ifndef DIR_SEPARATOR_2
4244 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4245 #else /* DIR_SEPARATOR_2 */
4246 # define IS_DIR_SEPARATOR(ch) \
4247 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4248 #endif /* DIR_SEPARATOR_2 */
4250 #ifndef PATH_SEPARATOR_2
4251 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4252 #else /* PATH_SEPARATOR_2 */
4253 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4254 #endif /* PATH_SEPARATOR_2 */
4257 # define FOPEN_WB "w"
4260 # define _O_BINARY 0
4263 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4264 #define XFREE(stale) do { \
4265 if (stale) { free ((void *) stale); stale = 0; } \
4268 #if defined(LT_DEBUGWRAPPER)
4269 static int lt_debug = 1;
4271 static int lt_debug = 0;
4274 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4276 void *xmalloc (size_t num);
4277 char *xstrdup (const char *string);
4278 const char *base_name (const char *name);
4279 char *find_executable (const char *wrapper);
4280 char *chase_symlinks (const char *pathspec);
4281 int make_executable (const char *path);
4282 int check_executable (const char *path);
4283 char *strendzap (char *str, const char *pat);
4284 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4285 void lt_fatal (const char *file, int line, const char *message, ...);
4286 static const char *nonnull (const char *s);
4287 static const char *nonempty (const char *s);
4288 void lt_setenv (const char *name, const char *value);
4289 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4290 void lt_update_exe_path (const char *name, const char *value);
4291 void lt_update_lib_path (const char *name, const char *value);
4292 char **prepare_spawn (char **argv);
4293 void lt_dump_script (FILE *f);
4297 volatile const char * MAGIC_EXE = "$magic_exe";
4298 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4301 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4302 func_to_host_path "$temp_rpath"
4304 const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4308 const char * LIB_PATH_VALUE = "";
4312 if test -n "$dllsearchpath"; then
4313 func_to_host_path "$dllsearchpath:"
4315 const char * EXE_PATH_VARNAME = "PATH";
4316 const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4320 const char * EXE_PATH_VARNAME = "";
4321 const char * EXE_PATH_VALUE = "";
4325 if test "$fast_install" = yes; then
4327 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4331 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4338 #define LTWRAPPER_OPTION_PREFIX "--lt-"
4340 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4341 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4342 static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
4345 main (int argc, char *argv[])
4350 char *actual_cwrapper_path;
4351 char *actual_cwrapper_name;
4354 intptr_t rval = 127;
4358 program_name = (char *) xstrdup (base_name (argv[0]));
4359 newargz = XMALLOC (char *, argc + 1);
4361 /* very simple arg parsing; don't want to rely on getopt
4362 * also, copy all non cwrapper options to newargz, except
4363 * argz[0], which is handled differently
4366 for (i = 1; i < argc; i++)
4368 if (strcmp (argv[i], dumpscript_opt) == 0)
4372 *mingw* | *cygwin* )
4373 # make stdout use "unix" line endings
4374 echo " setmode(1,_O_BINARY);"
4379 lt_dump_script (stdout);
4382 if (strcmp (argv[i], debug_opt) == 0)
4387 if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4389 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4390 namespace, but it is not one of the ones we know about and
4391 have already dealt with, above (inluding dump-script), then
4392 report an error. Otherwise, targets might begin to believe
4393 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4394 namespace. The first time any user complains about this, we'll
4395 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4396 or a configure.ac-settable value.
4398 lt_fatal (__FILE__, __LINE__,
4399 "unrecognized %s option: '%s'",
4400 ltwrapper_option_prefix, argv[i]);
4403 newargz[++newargc] = xstrdup (argv[i]);
4405 newargz[++newargc] = NULL;
4409 /* The GNU banner must be the first non-error debug message */
4410 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4413 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4414 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4416 tmp_pathspec = find_executable (argv[0]);
4417 if (tmp_pathspec == NULL)
4418 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4419 lt_debugprintf (__FILE__, __LINE__,
4420 "(main) found exe (before symlink chase) at: %s\n",
4423 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4424 lt_debugprintf (__FILE__, __LINE__,
4425 "(main) found exe (after symlink chase) at: %s\n",
4426 actual_cwrapper_path);
4427 XFREE (tmp_pathspec);
4429 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4430 strendzap (actual_cwrapper_path, actual_cwrapper_name);
4432 /* wrapper name transforms */
4433 strendzap (actual_cwrapper_name, ".exe");
4434 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4435 XFREE (actual_cwrapper_name);
4436 actual_cwrapper_name = tmp_pathspec;
4439 /* target_name transforms -- use actual target program name; might have lt- prefix */
4440 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4441 strendzap (target_name, ".exe");
4442 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4443 XFREE (target_name);
4444 target_name = tmp_pathspec;
4447 lt_debugprintf (__FILE__, __LINE__,
4448 "(main) libtool target name: %s\n",
4454 XMALLOC (char, (strlen (actual_cwrapper_path) +
4455 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4456 strcpy (newargz[0], actual_cwrapper_path);
4457 strcat (newargz[0], "$objdir");
4458 strcat (newargz[0], "/");
4462 /* stop here, and copy so we don't have to do this twice */
4463 tmp_pathspec = xstrdup (newargz[0]);
4465 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4466 strcat (newargz[0], actual_cwrapper_name);
4468 /* DO want the lt- prefix here if it exists, so use target_name */
4469 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4470 XFREE (tmp_pathspec);
4471 tmp_pathspec = NULL;
4479 while ((p = strchr (newargz[0], '\\')) != NULL)
4483 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4493 XFREE (target_name);
4494 XFREE (actual_cwrapper_path);
4495 XFREE (actual_cwrapper_name);
4497 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4498 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4499 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4500 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4501 because on Windows, both *_VARNAMEs are PATH but uninstalled
4502 libraries must come first. */
4503 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4504 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4506 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4507 nonnull (lt_argv_zero));
4508 for (i = 0; i < newargc; i++)
4510 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4511 i, nonnull (newargz[i]));
4519 /* execv doesn't actually work on mingw as expected on unix */
4520 newargz = prepare_spawn (newargz);
4521 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4524 /* failed to start process */
4525 lt_debugprintf (__FILE__, __LINE__,
4526 "(main) failed to launch target \"%s\": %s\n",
4527 lt_argv_zero, nonnull (strerror (errno)));
4535 execv (lt_argv_zero, newargz);
4536 return rval; /* =127, but avoids unused variable warning */
4545 xmalloc (size_t num)
4547 void *p = (void *) malloc (num);
4549 lt_fatal (__FILE__, __LINE__, "memory exhausted");
4555 xstrdup (const char *string)
4557 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4562 base_name (const char *name)
4566 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4567 /* Skip over the disk name in MSDOS pathnames. */
4568 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4572 for (base = name; *name; name++)
4573 if (IS_DIR_SEPARATOR (*name))
4579 check_executable (const char *path)
4583 lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4585 if ((!path) || (!*path))
4588 if ((stat (path, &st) >= 0)
4589 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4596 make_executable (const char *path)
4601 lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4603 if ((!path) || (!*path))
4606 if (stat (path, &st) >= 0)
4608 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4613 /* Searches for the full path of the wrapper. Returns
4614 newly allocated full path name if found, NULL otherwise
4615 Does not chase symlinks, even on platforms that support them.
4618 find_executable (const char *wrapper)
4623 /* static buffer for getcwd */
4624 char tmp[LT_PATHMAX + 1];
4628 lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4629 nonempty (wrapper));
4631 if ((wrapper == NULL) || (*wrapper == '\0'))
4634 /* Absolute path? */
4635 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4636 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4638 concat_name = xstrdup (wrapper);
4639 if (check_executable (concat_name))
4641 XFREE (concat_name);
4646 if (IS_DIR_SEPARATOR (wrapper[0]))
4648 concat_name = xstrdup (wrapper);
4649 if (check_executable (concat_name))
4651 XFREE (concat_name);
4653 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4657 for (p = wrapper; *p; p++)
4665 /* no slashes; search PATH */
4666 const char *path = getenv ("PATH");
4669 for (p = path; *p; p = p_next)
4673 for (q = p; *q; q++)
4674 if (IS_PATH_SEPARATOR (*q))
4677 p_next = (*q == '\0' ? q : q + 1);
4680 /* empty path: current directory */
4681 if (getcwd (tmp, LT_PATHMAX) == NULL)
4682 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4683 nonnull (strerror (errno)));
4684 tmp_len = strlen (tmp);
4686 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4687 memcpy (concat_name, tmp, tmp_len);
4688 concat_name[tmp_len] = '/';
4689 strcpy (concat_name + tmp_len + 1, wrapper);
4694 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4695 memcpy (concat_name, p, p_len);
4696 concat_name[p_len] = '/';
4697 strcpy (concat_name + p_len + 1, wrapper);
4699 if (check_executable (concat_name))
4701 XFREE (concat_name);
4704 /* not found in PATH; assume curdir */
4706 /* Relative path | not found in path: prepend cwd */
4707 if (getcwd (tmp, LT_PATHMAX) == NULL)
4708 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4709 nonnull (strerror (errno)));
4710 tmp_len = strlen (tmp);
4711 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4712 memcpy (concat_name, tmp, tmp_len);
4713 concat_name[tmp_len] = '/';
4714 strcpy (concat_name + tmp_len + 1, wrapper);
4716 if (check_executable (concat_name))
4718 XFREE (concat_name);
4723 chase_symlinks (const char *pathspec)
4726 return xstrdup (pathspec);
4728 char buf[LT_PATHMAX];
4730 char *tmp_pathspec = xstrdup (pathspec);
4732 int has_symlinks = 0;
4733 while (strlen (tmp_pathspec) && !has_symlinks)
4735 lt_debugprintf (__FILE__, __LINE__,
4736 "checking path component for symlinks: %s\n",
4738 if (lstat (tmp_pathspec, &s) == 0)
4740 if (S_ISLNK (s.st_mode) != 0)
4746 /* search backwards for last DIR_SEPARATOR */
4747 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4748 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4750 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4752 /* no more DIR_SEPARATORS left */
4759 lt_fatal (__FILE__, __LINE__,
4760 "error accessing file \"%s\": %s",
4761 tmp_pathspec, nonnull (strerror (errno)));
4764 XFREE (tmp_pathspec);
4768 return xstrdup (pathspec);
4771 tmp_pathspec = realpath (pathspec, buf);
4772 if (tmp_pathspec == 0)
4774 lt_fatal (__FILE__, __LINE__,
4775 "could not follow symlinks for %s", pathspec);
4777 return xstrdup (tmp_pathspec);
4782 strendzap (char *str, const char *pat)
4786 assert (str != NULL);
4787 assert (pat != NULL);
4790 patlen = strlen (pat);
4794 str += len - patlen;
4795 if (strcmp (str, pat) == 0)
4802 lt_debugprintf (const char *file, int line, const char *fmt, ...)
4807 (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4808 va_start (args, fmt);
4809 (void) vfprintf (stderr, fmt, args);
4815 lt_error_core (int exit_status, const char *file,
4816 int line, const char *mode,
4817 const char *message, va_list ap)
4819 fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4820 vfprintf (stderr, message, ap);
4821 fprintf (stderr, ".\n");
4823 if (exit_status >= 0)
4828 lt_fatal (const char *file, int line, const char *message, ...)
4831 va_start (ap, message);
4832 lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4837 nonnull (const char *s)
4839 return s ? s : "(null)";
4843 nonempty (const char *s)
4845 return (s && !*s) ? "(empty)" : nonnull (s);
4849 lt_setenv (const char *name, const char *value)
4851 lt_debugprintf (__FILE__, __LINE__,
4852 "(lt_setenv) setting '%s' to '%s'\n",
4853 nonnull (name), nonnull (value));
4856 /* always make a copy, for consistency with !HAVE_SETENV */
4857 char *str = xstrdup (value);
4858 setenv (name, str, 1);
4860 int len = strlen (name) + 1 + strlen (value) + 1;
4861 char *str = XMALLOC (char, len);
4862 sprintf (str, "%s=%s", name, value);
4863 if (putenv (str) != EXIT_SUCCESS)
4872 lt_extend_str (const char *orig_value, const char *add, int to_end)
4875 if (orig_value && *orig_value)
4877 int orig_value_len = strlen (orig_value);
4878 int add_len = strlen (add);
4879 new_value = XMALLOC (char, add_len + orig_value_len + 1);
4882 strcpy (new_value, orig_value);
4883 strcpy (new_value + orig_value_len, add);
4887 strcpy (new_value, add);
4888 strcpy (new_value + add_len, orig_value);
4893 new_value = xstrdup (add);
4899 lt_update_exe_path (const char *name, const char *value)
4901 lt_debugprintf (__FILE__, __LINE__,
4902 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4903 nonnull (name), nonnull (value));
4905 if (name && *name && value && *value)
4907 char *new_value = lt_extend_str (getenv (name), value, 0);
4908 /* some systems can't cope with a ':'-terminated path #' */
4909 int len = strlen (new_value);
4910 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4912 new_value[len-1] = '\0';
4914 lt_setenv (name, new_value);
4920 lt_update_lib_path (const char *name, const char *value)
4922 lt_debugprintf (__FILE__, __LINE__,
4923 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4924 nonnull (name), nonnull (value));
4926 if (name && *name && value && *value)
4928 char *new_value = lt_extend_str (getenv (name), value, 0);
4929 lt_setenv (name, new_value);
4939 /* Prepares an argument vector before calling spawn().
4940 Note that spawn() does not by itself call the command interpreter
4941 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4942 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4944 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4945 }) ? "cmd.exe" : "command.com").
4946 Instead it simply concatenates the arguments, separated by ' ', and calls
4947 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4948 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4950 - Space and tab are interpreted as delimiters. They are not treated as
4951 delimiters if they are surrounded by double quotes: "...".
4952 - Unescaped double quotes are removed from the input. Their only effect is
4953 that within double quotes, space and tab are treated like normal
4955 - Backslashes not followed by double quotes are not special.
4956 - But 2*n+1 backslashes followed by a double quote become
4957 n backslashes followed by a double quote (n >= 0):
4962 #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"
4963 #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"
4965 prepare_spawn (char **argv)
4971 /* Count number of arguments. */
4972 for (argc = 0; argv[argc] != NULL; argc++)
4975 /* Allocate new argument vector. */
4976 new_argv = XMALLOC (char *, argc + 1);
4978 /* Put quoted arguments into the new argument vector. */
4979 for (i = 0; i < argc; i++)
4981 const char *string = argv[i];
4983 if (string[0] == '\0')
4984 new_argv[i] = xstrdup ("\"\"");
4985 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4987 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4989 unsigned int backslashes;
4991 char *quoted_string;
4998 for (s = string; *s != '\0'; s++)
5002 length += backslashes + 1;
5010 length += backslashes + 1;
5012 quoted_string = XMALLOC (char, length + 1);
5018 for (s = string; *s != '\0'; s++)
5024 for (j = backslashes + 1; j > 0; j--)
5036 for (j = backslashes; j > 0; j--)
5042 new_argv[i] = quoted_string;
5045 new_argv[i] = (char *) string;
5047 new_argv[argc] = NULL;
5056 void lt_dump_script (FILE* f)
5059 func_emit_wrapper yes |
5060 $SED -e 's/\([\\"]\)/\\\1/g' \
5061 -e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
5067 # end: func_emit_cwrapperexe_src
5069 # func_win32_import_lib_p ARG
5070 # True if ARG is an import lib, as indicated by $file_magic_cmd
5071 func_win32_import_lib_p ()
5074 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5080 # func_mode_link arg...
5085 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5086 # It is impossible to link a dll without this setting, and
5087 # we shouldn't force the makefile maintainer to figure out
5088 # which system we are compiling for in order to pass an extra
5089 # flag for every libtool invocation.
5090 # allow_undefined=no
5092 # FIXME: Unfortunately, there are problems with the above when trying
5093 # to make a dll which has undefined symbols, in which case not
5094 # even a static library is built. For now, we need to specify
5095 # -no-undefined on the libtool link line when we can be certain
5096 # that all symbols are satisfied, otherwise we get a static library.
5103 libtool_args=$nonopt
5104 base_compile="$nonopt $@"
5105 compile_command=$nonopt
5106 finalize_command=$nonopt
5119 lib_search_path=`pwd`
5121 new_inherited_linker_flags=
5130 export_symbols_regex=
5138 precious_files_regex=
5139 prefer_static_libs=no
5152 single_module="${wl}-single_module"
5153 func_infer_tag $base_compile
5155 # We need to know -static, to get the right output filenames.
5160 test "$build_libtool_libs" != yes && \
5161 func_fatal_configuration "can not build a shared library"
5165 -all-static | -static | -static-libtool-libs)
5168 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5169 func_warning "complete static linking is impossible in this configuration"
5171 if test -n "$link_static_flag"; then
5172 dlopen_self=$dlopen_self_static
5174 prefer_static_libs=yes
5177 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5178 dlopen_self=$dlopen_self_static
5180 prefer_static_libs=built
5182 -static-libtool-libs)
5183 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5184 dlopen_self=$dlopen_self_static
5186 prefer_static_libs=yes
5189 build_libtool_libs=no
5196 # See if our shared archives depend on static archives.
5197 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5199 # Go through the arguments, transforming them on the way.
5200 while test "$#" -gt 0; do
5203 func_quote_for_eval "$arg"
5204 qarg=$func_quote_for_eval_unquoted_result
5205 func_append libtool_args " $func_quote_for_eval_result"
5207 # If the previous option needs an argument, assign it.
5208 if test -n "$prev"; then
5211 func_append compile_command " @OUTPUT@"
5212 func_append finalize_command " @OUTPUT@"
5223 if test "$preload" = no; then
5224 # Add the symbol object into the linking commands.
5225 func_append compile_command " @SYMFILE@"
5226 func_append finalize_command " @SYMFILE@"
5230 *.la | *.lo) ;; # We handle these cases below.
5232 if test "$dlself" = no; then
5240 if test "$prev" = dlprefiles; then
5242 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5252 if test "$prev" = dlfiles; then
5253 func_append dlfiles " $arg"
5255 func_append dlprefiles " $arg"
5263 export_symbols="$arg"
5265 || func_fatal_error "symbol file \`$arg' does not exist"
5270 export_symbols_regex="$arg"
5278 *" $qarg.ltframework "*) ;;
5279 *) func_append deplibs " $qarg.ltframework" # this is fixed later
5288 inst_prefix_dir="$arg"
5293 if test -f "$arg"; then
5296 for fil in `cat "$save_arg"`
5298 # func_append moreargs " $fil"
5300 # A libtool-controlled object.
5302 # Check to see that this really is a libtool object.
5303 if func_lalib_unsafe_p "$arg"; then
5310 if test -z "$pic_object" ||
5311 test -z "$non_pic_object" ||
5312 test "$pic_object" = none &&
5313 test "$non_pic_object" = none; then
5314 func_fatal_error "cannot find name of object for \`$arg'"
5317 # Extract subdirectory from the argument.
5318 func_dirname "$arg" "/" ""
5319 xdir="$func_dirname_result"
5321 if test "$pic_object" != none; then
5322 # Prepend the subdirectory the object is found in.
5323 pic_object="$xdir$pic_object"
5325 if test "$prev" = dlfiles; then
5326 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5327 func_append dlfiles " $pic_object"
5331 # If libtool objects are unsupported, then we need to preload.
5336 # CHECK ME: I think I busted this. -Ossama
5337 if test "$prev" = dlprefiles; then
5338 # Preload the old-style object.
5339 func_append dlprefiles " $pic_object"
5344 func_append libobjs " $pic_object"
5349 if test "$non_pic_object" != none; then
5350 # Prepend the subdirectory the object is found in.
5351 non_pic_object="$xdir$non_pic_object"
5353 # A standard non-PIC object
5354 func_append non_pic_objects " $non_pic_object"
5355 if test -z "$pic_object" || test "$pic_object" = none ; then
5356 arg="$non_pic_object"
5359 # If the PIC object exists, use it instead.
5360 # $xdir was prepended to $pic_object above.
5361 non_pic_object="$pic_object"
5362 func_append non_pic_objects " $non_pic_object"
5365 # Only an error if not doing a dry-run.
5366 if $opt_dry_run; then
5367 # Extract subdirectory from the argument.
5368 func_dirname "$arg" "/" ""
5369 xdir="$func_dirname_result"
5372 pic_object=$xdir$objdir/$func_lo2o_result
5373 non_pic_object=$xdir$func_lo2o_result
5374 func_append libobjs " $pic_object"
5375 func_append non_pic_objects " $non_pic_object"
5377 func_fatal_error "\`$arg' is not a valid libtool object"
5382 func_fatal_error "link input file \`$arg' does not exist"
5389 precious_files_regex="$arg"
5399 # We need an absolute path.
5401 [\\/]* | [A-Za-z]:[\\/]*) ;;
5403 func_fatal_error "only absolute run-paths are allowed"
5406 if test "$prev" = rpath; then
5409 *) func_append rpath " $arg" ;;
5414 *) func_append xrpath " $arg" ;;
5426 func_append weak_libs " $arg"
5431 func_append linker_flags " $qarg"
5432 func_append compiler_flags " $qarg"
5434 func_append compile_command " $qarg"
5435 func_append finalize_command " $qarg"
5439 func_append compiler_flags " $qarg"
5441 func_append compile_command " $qarg"
5442 func_append finalize_command " $qarg"
5446 func_append linker_flags " $qarg"
5447 func_append compiler_flags " $wl$qarg"
5449 func_append compile_command " $wl$qarg"
5450 func_append finalize_command " $wl$qarg"
5454 eval "$prev=\"\$arg\""
5459 fi # test -n "$prev"
5465 if test -n "$link_static_flag"; then
5466 # See comment for -static flag below, for more details.
5467 func_append compile_command " $link_static_flag"
5468 func_append finalize_command " $link_static_flag"
5474 # FIXME: remove this flag sometime in the future.
5475 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5503 -export-symbols | -export-symbols-regex)
5504 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5505 func_fatal_error "more than one -exported-symbols argument is not allowed"
5507 if test "X$arg" = "X-export-symbols"; then
5525 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5526 # so, if we see these flags be careful not to treat them like -L
5528 case $with_gcc/$host in
5529 no/*-*-irix* | /*-*-irix*)
5530 func_append compile_command " $arg"
5531 func_append finalize_command " $arg"
5538 func_stripname "-L" '' "$arg"
5539 if test -z "$func_stripname_result"; then
5540 if test "$#" -gt 0; then
5541 func_fatal_error "require no space between \`-L' and \`$1'"
5543 func_fatal_error "need path for \`-L' option"
5546 func_resolve_sysroot "$func_stripname_result"
5547 dir=$func_resolve_sysroot_result
5548 # We need an absolute path.
5550 [\\/]* | [A-Za-z]:[\\/]*) ;;
5552 absdir=`cd "$dir" && pwd`
5553 test -z "$absdir" && \
5554 func_fatal_error "cannot determine absolute directory name of \`$dir'"
5559 *" -L$dir "* | *" $arg "*)
5560 # Will only happen for absolute or sysroot arguments
5563 # Preserve sysroot, but never include relative directories
5565 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5566 *) func_append deplibs " -L$dir" ;;
5568 func_append lib_search_path " $dir"
5572 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5573 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5574 case :$dllsearchpath: in
5576 ::) dllsearchpath=$dir;;
5577 *) func_append dllsearchpath ":$dir";;
5579 case :$dllsearchpath: in
5580 *":$testbindir:"*) ;;
5581 ::) dllsearchpath=$testbindir;;
5582 *) func_append dllsearchpath ":$testbindir";;
5590 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5592 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5593 # These systems don't actually have a C or math library (as such)
5597 # These systems don't actually have a C library (as such)
5598 test "X$arg" = "X-lc" && continue
5600 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5601 # Do not include libc due to us having libc/libc_r.
5602 test "X$arg" = "X-lc" && continue
5604 *-*-rhapsody* | *-*-darwin1.[012])
5605 # Rhapsody C and math libraries are in the System framework
5606 func_append deplibs " System.ltframework"
5609 *-*-sco3.2v5* | *-*-sco5v6*)
5610 # Causes problems with __ctype
5611 test "X$arg" = "X-lc" && continue
5613 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5614 # Compiler inserts libc in the correct place for threads to work
5615 test "X$arg" = "X-lc" && continue
5618 elif test "X$arg" = "X-lc_r"; then
5620 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5621 # Do not include libc_r directly, use -pthread flag.
5626 func_append deplibs " $arg"
5635 # Tru64 UNIX uses -model [arg] to determine the layout of C++
5636 # classes, name mangling, and exception handling.
5637 # Darwin uses the -arch flag to determine output architecture.
5638 -model|-arch|-isysroot|--sysroot)
5639 func_append compiler_flags " $arg"
5640 func_append compile_command " $arg"
5641 func_append finalize_command " $arg"
5646 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5647 func_append compiler_flags " $arg"
5648 func_append compile_command " $arg"
5649 func_append finalize_command " $arg"
5650 case "$new_inherited_linker_flags " in
5652 * ) func_append new_inherited_linker_flags " $arg" ;;
5658 single_module="${wl}-multi_module"
5669 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5670 # The PATH hackery in wrapper scripts is required on Windows
5671 # and Darwin in order for the loader to find any dlls it needs.
5672 func_warning "\`-no-install' is ignored for $host"
5673 func_warning "assuming \`-no-fast-install' instead"
5676 *) no_install=yes ;;
5693 -precious-files-regex)
5714 func_stripname '-R' '' "$arg"
5715 dir=$func_stripname_result
5716 # We need an absolute path.
5718 [\\/]* | [A-Za-z]:[\\/]*) ;;
5720 func_stripname '=' '' "$dir"
5721 dir=$lt_sysroot$func_stripname_result
5724 func_fatal_error "only absolute run-paths are allowed"
5729 *) func_append xrpath " $dir" ;;
5735 # The effects of -shared are defined in a previous loop.
5744 -static | -static-libtool-libs)
5745 # The effects of -static are defined in a previous loop.
5746 # We used to do the same as -all-static on platforms that
5747 # didn't have a PIC flag, but the assumption that the effects
5748 # would be equivalent was wrong. It would break on at least
5749 # Digital Unix and AIX.
5775 func_stripname '-Wc,' '' "$arg"
5776 args=$func_stripname_result
5778 save_ifs="$IFS"; IFS=','
5779 for flag in $args; do
5781 func_quote_for_eval "$flag"
5782 func_append arg " $func_quote_for_eval_result"
5783 func_append compiler_flags " $func_quote_for_eval_result"
5786 func_stripname ' ' '' "$arg"
5787 arg=$func_stripname_result
5791 func_stripname '-Wl,' '' "$arg"
5792 args=$func_stripname_result
5794 save_ifs="$IFS"; IFS=','
5795 for flag in $args; do
5797 func_quote_for_eval "$flag"
5798 func_append arg " $wl$func_quote_for_eval_result"
5799 func_append compiler_flags " $wl$func_quote_for_eval_result"
5800 func_append linker_flags " $func_quote_for_eval_result"
5803 func_stripname ' ' '' "$arg"
5804 arg=$func_stripname_result
5824 func_quote_for_eval "$arg"
5825 arg="$func_quote_for_eval_result"
5828 # Flags to be passed through unchanged, with rationale:
5829 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5830 # -r[0-9][0-9]* specify processor for the SGI compiler
5831 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5832 # +DA*, +DD* enable 64-bit mode for the HP compiler
5833 # -q* compiler args for the IBM compiler
5834 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5835 # -F/path path to uninstalled frameworks, gcc on darwin
5836 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5837 # @file GCC response files
5838 # -tp=* Portland pgcc target processor selection
5839 # --sysroot=* for sysroot support
5840 # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5841 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5842 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5843 -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5844 func_quote_for_eval "$arg"
5845 arg="$func_quote_for_eval_result"
5846 func_append compile_command " $arg"
5847 func_append finalize_command " $arg"
5848 func_append compiler_flags " $arg"
5852 # Some other compiler flag.
5854 func_quote_for_eval "$arg"
5855 arg="$func_quote_for_eval_result"
5859 # A standard object.
5860 func_append objs " $arg"
5864 # A libtool-controlled object.
5866 # Check to see that this really is a libtool object.
5867 if func_lalib_unsafe_p "$arg"; then
5874 if test -z "$pic_object" ||
5875 test -z "$non_pic_object" ||
5876 test "$pic_object" = none &&
5877 test "$non_pic_object" = none; then
5878 func_fatal_error "cannot find name of object for \`$arg'"
5881 # Extract subdirectory from the argument.
5882 func_dirname "$arg" "/" ""
5883 xdir="$func_dirname_result"
5885 if test "$pic_object" != none; then
5886 # Prepend the subdirectory the object is found in.
5887 pic_object="$xdir$pic_object"
5889 if test "$prev" = dlfiles; then
5890 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5891 func_append dlfiles " $pic_object"
5895 # If libtool objects are unsupported, then we need to preload.
5900 # CHECK ME: I think I busted this. -Ossama
5901 if test "$prev" = dlprefiles; then
5902 # Preload the old-style object.
5903 func_append dlprefiles " $pic_object"
5908 func_append libobjs " $pic_object"
5913 if test "$non_pic_object" != none; then
5914 # Prepend the subdirectory the object is found in.
5915 non_pic_object="$xdir$non_pic_object"
5917 # A standard non-PIC object
5918 func_append non_pic_objects " $non_pic_object"
5919 if test -z "$pic_object" || test "$pic_object" = none ; then
5920 arg="$non_pic_object"
5923 # If the PIC object exists, use it instead.
5924 # $xdir was prepended to $pic_object above.
5925 non_pic_object="$pic_object"
5926 func_append non_pic_objects " $non_pic_object"
5929 # Only an error if not doing a dry-run.
5930 if $opt_dry_run; then
5931 # Extract subdirectory from the argument.
5932 func_dirname "$arg" "/" ""
5933 xdir="$func_dirname_result"
5936 pic_object=$xdir$objdir/$func_lo2o_result
5937 non_pic_object=$xdir$func_lo2o_result
5938 func_append libobjs " $pic_object"
5939 func_append non_pic_objects " $non_pic_object"
5941 func_fatal_error "\`$arg' is not a valid libtool object"
5948 func_append deplibs " $arg"
5949 func_append old_deplibs " $arg"
5954 # A libtool-controlled library.
5956 func_resolve_sysroot "$arg"
5957 if test "$prev" = dlfiles; then
5958 # This library was specified with -dlopen.
5959 func_append dlfiles " $func_resolve_sysroot_result"
5961 elif test "$prev" = dlprefiles; then
5962 # The library was specified with -dlpreopen.
5963 func_append dlprefiles " $func_resolve_sysroot_result"
5966 func_append deplibs " $func_resolve_sysroot_result"
5971 # Some other compiler argument.
5973 # Unknown arguments in both finalize_command and compile_command need
5974 # to be aesthetically quoted because they are evaled later.
5975 func_quote_for_eval "$arg"
5976 arg="$func_quote_for_eval_result"
5980 # Now actually substitute the argument into the commands.
5981 if test -n "$arg"; then
5982 func_append compile_command " $arg"
5983 func_append finalize_command " $arg"
5985 done # argument parsing loop
5987 test -n "$prev" && \
5988 func_fatal_help "the \`$prevarg' option requires an argument"
5990 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5991 eval arg=\"$export_dynamic_flag_spec\"
5992 func_append compile_command " $arg"
5993 func_append finalize_command " $arg"
5997 # calculate the name of the file, without its directory
5998 func_basename "$output"
5999 outputname="$func_basename_result"
6000 libobjs_save="$libobjs"
6002 if test -n "$shlibpath_var"; then
6003 # get the directories listed in $shlibpath_var
6004 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6008 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6009 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6011 func_dirname "$output" "/" ""
6012 output_objdir="$func_dirname_result$objdir"
6013 func_to_tool_file "$output_objdir/"
6014 tool_output_objdir=$func_to_tool_file_result
6015 # Create the object directory.
6016 func_mkdir_p "$output_objdir"
6018 # Determine the type of output
6021 func_fatal_help "you must specify an output file"
6023 *.$libext) linkmode=oldlib ;;
6024 *.lo | *.$objext) linkmode=obj ;;
6025 *.la) linkmode=lib ;;
6026 *) linkmode=prog ;; # Anything else should be a program.
6032 # Find all interdependent deplibs by searching for libraries
6033 # that are linked more than once (e.g. -la -lb -la)
6034 for deplib in $deplibs; do
6035 if $opt_preserve_dup_deps ; then
6037 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6040 func_append libs " $deplib"
6043 if test "$linkmode" = lib; then
6044 libs="$predeps $libs $compiler_lib_search_path $postdeps"
6046 # Compute libraries that are listed more than once in $predeps
6047 # $postdeps and mark them as special (i.e., whose duplicates are
6048 # not to be eliminated).
6050 if $opt_duplicate_compiler_generated_deps; then
6051 for pre_post_dep in $predeps $postdeps; do
6052 case "$pre_post_deps " in
6053 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6055 func_append pre_post_deps " $pre_post_dep"
6064 need_relink=no # whether we're linking any uninstalled libtool libraries
6065 notinst_deplibs= # not-installed libtool libraries
6066 notinst_path= # paths that contain not-installed libtool libraries
6070 passes="conv dlpreopen link"
6071 for file in $dlfiles $dlprefiles; do
6075 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6086 passes="conv scan dlopen dlpreopen link"
6092 for pass in $passes; do
6093 # The preopen pass in lib mode reverses $deplibs; put it back here
6094 # so that -L comes before libs that need it for instance...
6095 if test "$linkmode,$pass" = "lib,link"; then
6096 ## FIXME: Find the place where the list is rebuilt in the wrong
6097 ## order, and fix it there properly
6099 for deplib in $deplibs; do
6100 tmp_deplibs="$deplib $tmp_deplibs"
6102 deplibs="$tmp_deplibs"
6105 if test "$linkmode,$pass" = "lib,link" ||
6106 test "$linkmode,$pass" = "prog,scan"; then
6110 if test "$linkmode" = prog; then
6112 dlopen) libs="$dlfiles" ;;
6113 dlpreopen) libs="$dlprefiles" ;;
6114 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6117 if test "$linkmode,$pass" = "lib,dlpreopen"; then
6118 # Collect and forward deplibs of preopened libtool libs
6119 for lib in $dlprefiles; do
6120 # Ignore non-libtool-libs
6122 func_resolve_sysroot "$lib"
6124 *.la) func_source "$func_resolve_sysroot_result" ;;
6127 # Collect preopened libtool deplibs, except any this library
6128 # has declared as weak libs
6129 for deplib in $dependency_libs; do
6130 func_basename "$deplib"
6131 deplib_base=$func_basename_result
6132 case " $weak_libs " in
6133 *" $deplib_base "*) ;;
6134 *) func_append deplibs " $deplib" ;;
6140 if test "$pass" = dlopen; then
6141 # Collect dlpreopened libraries
6142 save_deplibs="$deplibs"
6146 for deplib in $libs; do
6150 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
6151 if test "$linkmode,$pass" = "prog,link"; then
6152 compile_deplibs="$deplib $compile_deplibs"
6153 finalize_deplibs="$deplib $finalize_deplibs"
6155 func_append compiler_flags " $deplib"
6156 if test "$linkmode" = lib ; then
6157 case "$new_inherited_linker_flags " in
6159 * ) func_append new_inherited_linker_flags " $deplib" ;;
6166 if test "$linkmode" != lib && test "$linkmode" != prog; then
6167 func_warning "\`-l' is ignored for archives/objects"
6170 func_stripname '-l' '' "$deplib"
6171 name=$func_stripname_result
6172 if test "$linkmode" = lib; then
6173 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6175 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6177 for searchdir in $searchdirs; do
6178 for search_ext in .la $std_shrext .so .a; do
6179 # Search the libtool library
6180 lib="$searchdir/lib${name}${search_ext}"
6181 if test -f "$lib"; then
6182 if test "$search_ext" = ".la"; then
6191 if test "$found" != yes; then
6192 # deplib doesn't seem to be a libtool library
6193 if test "$linkmode,$pass" = "prog,link"; then
6194 compile_deplibs="$deplib $compile_deplibs"
6195 finalize_deplibs="$deplib $finalize_deplibs"
6197 deplibs="$deplib $deplibs"
6198 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6201 else # deplib is a libtool library
6202 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6203 # We need to do some special things here, and not later.
6204 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6205 case " $predeps $postdeps " in
6207 if func_lalib_p "$lib"; then
6211 for l in $old_library $library_names; do
6214 if test "X$ll" = "X$old_library" ; then # only static version available
6216 func_dirname "$lib" "" "."
6217 ladir="$func_dirname_result"
6218 lib=$ladir/$old_library
6219 if test "$linkmode,$pass" = "prog,link"; then
6220 compile_deplibs="$deplib $compile_deplibs"
6221 finalize_deplibs="$deplib $finalize_deplibs"
6223 deplibs="$deplib $deplibs"
6224 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6236 if test "$linkmode,$pass" = "prog,link"; then
6237 compile_deplibs="$deplib $compile_deplibs"
6238 finalize_deplibs="$deplib $finalize_deplibs"
6240 deplibs="$deplib $deplibs"
6241 if test "$linkmode" = lib ; then
6242 case "$new_inherited_linker_flags " in
6244 * ) func_append new_inherited_linker_flags " $deplib" ;;
6253 deplibs="$deplib $deplibs"
6254 test "$pass" = conv && continue
6255 newdependency_libs="$deplib $newdependency_libs"
6256 func_stripname '-L' '' "$deplib"
6257 func_resolve_sysroot "$func_stripname_result"
6258 func_append newlib_search_path " $func_resolve_sysroot_result"
6261 if test "$pass" = conv; then
6262 deplibs="$deplib $deplibs"
6265 if test "$pass" = scan; then
6266 deplibs="$deplib $deplibs"
6268 compile_deplibs="$deplib $compile_deplibs"
6269 finalize_deplibs="$deplib $finalize_deplibs"
6271 func_stripname '-L' '' "$deplib"
6272 func_resolve_sysroot "$func_stripname_result"
6273 func_append newlib_search_path " $func_resolve_sysroot_result"
6276 func_warning "\`-L' is ignored for archives/objects"
6282 if test "$pass" = link; then
6283 func_stripname '-R' '' "$deplib"
6284 func_resolve_sysroot "$func_stripname_result"
6285 dir=$func_resolve_sysroot_result
6286 # Make sure the xrpath contains only unique directories.
6289 *) func_append xrpath " $dir" ;;
6292 deplibs="$deplib $deplibs"
6296 func_resolve_sysroot "$deplib"
6297 lib=$func_resolve_sysroot_result
6300 if test "$pass" = conv; then
6301 deplibs="$deplib $deplibs"
6306 # Linking convenience modules into shared libraries is allowed,
6307 # but linking other static libraries is non-portable.
6308 case " $dlpreconveniencelibs " in
6312 case $deplibs_check_method in
6314 set dummy $deplibs_check_method; shift
6315 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6316 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6317 | $EGREP "$match_pattern_regex" > /dev/null; then
6325 if test "$valid_a_lib" != yes; then
6327 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6328 echo "*** I have the capability to make that library automatically link in when"
6329 echo "*** you link to this library. But I can only do this if you have a"
6330 echo "*** shared version of the library, which you do not appear to have"
6331 echo "*** because the file extensions .$libext of this argument makes me believe"
6332 echo "*** that it is just a static archive that I should not use here."
6335 $ECHO "*** Warning: Linking the shared library $output against the"
6336 $ECHO "*** static library $deplib is not portable!"
6337 deplibs="$deplib $deplibs"
6344 if test "$pass" != link; then
6345 deplibs="$deplib $deplibs"
6347 compile_deplibs="$deplib $compile_deplibs"
6348 finalize_deplibs="$deplib $finalize_deplibs"
6355 if test "$pass" = conv; then
6356 deplibs="$deplib $deplibs"
6357 elif test "$linkmode" = prog; then
6358 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6359 # If there is no dlopen support or we're linking statically,
6360 # we need to preload.
6361 func_append newdlprefiles " $deplib"
6362 compile_deplibs="$deplib $compile_deplibs"
6363 finalize_deplibs="$deplib $finalize_deplibs"
6365 func_append newdlfiles " $deplib"
6376 if test "$found" = yes || test -f "$lib"; then :
6378 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6381 # Check to see that this really is a libtool archive.
6382 func_lalib_unsafe_p "$lib" \
6383 || func_fatal_error "\`$lib' is not a valid libtool archive"
6385 func_dirname "$lib" "" "."
6386 ladir="$func_dirname_result"
6394 inherited_linker_flags=
6395 # If the library was installed with an old release of libtool,
6396 # it will not redefine variables installed, or shouldnotlink
6405 # Convert "-framework foo" to "foo.ltframework"
6406 if test -n "$inherited_linker_flags"; then
6407 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6408 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6409 case " $new_inherited_linker_flags " in
6410 *" $tmp_inherited_linker_flag "*) ;;
6411 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6415 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6416 if test "$linkmode,$pass" = "lib,link" ||
6417 test "$linkmode,$pass" = "prog,scan" ||
6418 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6419 test -n "$dlopen" && func_append dlfiles " $dlopen"
6420 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6423 if test "$pass" = conv; then
6424 # Only check for convenience libraries
6425 deplibs="$lib $deplibs"
6426 if test -z "$libdir"; then
6427 if test -z "$old_library"; then
6428 func_fatal_error "cannot find name of link library for \`$lib'"
6430 # It is a libtool convenience library, so add in its objects.
6431 func_append convenience " $ladir/$objdir/$old_library"
6432 func_append old_convenience " $ladir/$objdir/$old_library"
6433 elif test "$linkmode" != prog && test "$linkmode" != lib; then
6434 func_fatal_error "\`$lib' is not a convenience library"
6437 for deplib in $dependency_libs; do
6438 deplibs="$deplib $deplibs"
6439 if $opt_preserve_dup_deps ; then
6440 case "$tmp_libs " in
6441 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6444 func_append tmp_libs " $deplib"
6450 # Get the name of the library we link against.
6452 if test -n "$old_library" &&
6453 { test "$prefer_static_libs" = yes ||
6454 test "$prefer_static_libs,$installed" = "built,no"; }; then
6455 linklib=$old_library
6457 for l in $old_library $library_names; do
6461 if test -z "$linklib"; then
6462 func_fatal_error "cannot find name of link library for \`$lib'"
6465 # This library was specified with -dlopen.
6466 if test "$pass" = dlopen; then
6467 if test -z "$libdir"; then
6468 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6470 if test -z "$dlname" ||
6471 test "$dlopen_support" != yes ||
6472 test "$build_libtool_libs" = no; then
6473 # If there is no dlname, no dlopen support or we're linking
6474 # statically, we need to preload. We also need to preload any
6475 # dependent libraries so libltdl's deplib preloader doesn't
6476 # bomb out in the load deplibs phase.
6477 func_append dlprefiles " $lib $dependency_libs"
6479 func_append newdlfiles " $lib"
6484 # We need an absolute path.
6486 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6488 abs_ladir=`cd "$ladir" && pwd`
6489 if test -z "$abs_ladir"; then
6490 func_warning "cannot determine absolute directory name of \`$ladir'"
6491 func_warning "passing it literally to the linker, although it might fail"
6496 func_basename "$lib"
6497 laname="$func_basename_result"
6499 # Find the relevant object directory and library name.
6500 if test "X$installed" = Xyes; then
6501 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6502 func_warning "library \`$lib' was moved."
6507 dir="$lt_sysroot$libdir"
6508 absdir="$lt_sysroot$libdir"
6510 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6512 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6515 # Remove this search path later
6516 func_append notinst_path " $abs_ladir"
6518 dir="$ladir/$objdir"
6519 absdir="$abs_ladir/$objdir"
6520 # Remove this search path later
6521 func_append notinst_path " $abs_ladir"
6523 fi # $installed = yes
6524 func_stripname 'lib' '.la' "$laname"
6525 name=$func_stripname_result
6527 # This library was specified with -dlpreopen.
6528 if test "$pass" = dlpreopen; then
6529 if test -z "$libdir" && test "$linkmode" = prog; then
6530 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6533 # special handling for platforms with PE-DLLs.
6534 *cygwin* | *mingw* | *cegcc* )
6535 # Linker will automatically link against shared library if both
6536 # static and shared are present. Therefore, ensure we extract
6537 # symbols from the import library if a shared library is present
6538 # (otherwise, the dlopen module name will be incorrect). We do
6539 # this by putting the import library name into $newdlprefiles.
6540 # We recover the dlopen module name by 'saving' the la file
6541 # name in a special purpose variable, and (later) extracting the
6542 # dlname from the la file.
6543 if test -n "$dlname"; then
6544 func_tr_sh "$dir/$linklib"
6545 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6546 func_append newdlprefiles " $dir/$linklib"
6548 func_append newdlprefiles " $dir/$old_library"
6549 # Keep a list of preopened convenience libraries to check
6550 # that they are being used correctly in the link pass.
6551 test -z "$libdir" && \
6552 func_append dlpreconveniencelibs " $dir/$old_library"
6556 # Prefer using a static library (so that no silly _DYNAMIC symbols
6557 # are required to link).
6558 if test -n "$old_library"; then
6559 func_append newdlprefiles " $dir/$old_library"
6560 # Keep a list of preopened convenience libraries to check
6561 # that they are being used correctly in the link pass.
6562 test -z "$libdir" && \
6563 func_append dlpreconveniencelibs " $dir/$old_library"
6564 # Otherwise, use the dlname, so that lt_dlopen finds it.
6565 elif test -n "$dlname"; then
6566 func_append newdlprefiles " $dir/$dlname"
6568 func_append newdlprefiles " $dir/$linklib"
6572 fi # $pass = dlpreopen
6574 if test -z "$libdir"; then
6575 # Link the convenience library
6576 if test "$linkmode" = lib; then
6577 deplibs="$dir/$old_library $deplibs"
6578 elif test "$linkmode,$pass" = "prog,link"; then
6579 compile_deplibs="$dir/$old_library $compile_deplibs"
6580 finalize_deplibs="$dir/$old_library $finalize_deplibs"
6582 deplibs="$lib $deplibs" # used for prog,scan pass
6588 if test "$linkmode" = prog && test "$pass" != link; then
6589 func_append newlib_search_path " $ladir"
6590 deplibs="$lib $deplibs"
6593 if test "$link_all_deplibs" != no || test -z "$library_names" ||
6594 test "$build_libtool_libs" = no; then
6599 for deplib in $dependency_libs; do
6601 -L*) func_stripname '-L' '' "$deplib"
6602 func_resolve_sysroot "$func_stripname_result"
6603 func_append newlib_search_path " $func_resolve_sysroot_result"
6606 # Need to link against all dependency_libs?
6607 if test "$linkalldeplibs" = yes; then
6608 deplibs="$deplib $deplibs"
6610 # Need to hardcode shared library paths
6611 # or/and link against static libraries
6612 newdependency_libs="$deplib $newdependency_libs"
6614 if $opt_preserve_dup_deps ; then
6615 case "$tmp_libs " in
6616 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6619 func_append tmp_libs " $deplib"
6622 fi # $linkmode = prog...
6624 if test "$linkmode,$pass" = "prog,link"; then
6625 if test -n "$library_names" &&
6626 { { test "$prefer_static_libs" = no ||
6627 test "$prefer_static_libs,$installed" = "built,yes"; } ||
6628 test -z "$old_library"; }; then
6629 # We need to hardcode the library path
6630 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6631 # Make sure the rpath contains only unique directories.
6632 case "$temp_rpath:" in
6634 *) func_append temp_rpath "$absdir:" ;;
6638 # Hardcode the library path.
6639 # Skip directories that are in the system default run-time
6641 case " $sys_lib_dlsearch_path " in
6644 case "$compile_rpath " in
6646 *) func_append compile_rpath " $absdir" ;;
6650 case " $sys_lib_dlsearch_path " in
6653 case "$finalize_rpath " in
6655 *) func_append finalize_rpath " $libdir" ;;
6659 fi # $linkmode,$pass = prog,link...
6661 if test "$alldeplibs" = yes &&
6662 { test "$deplibs_check_method" = pass_all ||
6663 { test "$build_libtool_libs" = yes &&
6664 test -n "$library_names"; }; }; then
6665 # We only need to search for static libraries
6670 link_static=no # Whether the deplib will be linked statically
6671 use_static_libs=$prefer_static_libs
6672 if test "$use_static_libs" = built && test "$installed" = yes; then
6675 if test -n "$library_names" &&
6676 { test "$use_static_libs" = no || test -z "$old_library"; }; then
6678 *cygwin* | *mingw* | *cegcc*)
6679 # No point in relinking DLLs because paths are not encoded
6680 func_append notinst_deplibs " $lib"
6684 if test "$installed" = no; then
6685 func_append notinst_deplibs " $lib"
6690 # This is a shared library
6692 # Warn about portability, can't link against -module's on some
6693 # systems (darwin). Don't bleat about dlopened modules though!
6695 for dlpremoduletest in $dlprefiles; do
6696 if test "X$dlpremoduletest" = "X$lib"; then
6697 dlopenmodule="$dlpremoduletest"
6701 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6703 if test "$linkmode" = prog; then
6704 $ECHO "*** Warning: Linking the executable $output against the loadable module"
6706 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6708 $ECHO "*** $linklib is not portable!"
6710 if test "$linkmode" = lib &&
6711 test "$hardcode_into_libs" = yes; then
6712 # Hardcode the library path.
6713 # Skip directories that are in the system default run-time
6715 case " $sys_lib_dlsearch_path " in
6718 case "$compile_rpath " in
6720 *) func_append compile_rpath " $absdir" ;;
6724 case " $sys_lib_dlsearch_path " in
6727 case "$finalize_rpath " in
6729 *) func_append finalize_rpath " $libdir" ;;
6735 if test -n "$old_archive_from_expsyms_cmds"; then
6736 # figure out the soname
6737 set dummy $library_names
6741 libname=`eval "\\$ECHO \"$libname_spec\""`
6742 # use dlname if we got it. it's perfectly good, no?
6743 if test -n "$dlname"; then
6745 elif test -n "$soname_spec"; then
6748 *cygwin* | mingw* | *cegcc*)
6749 func_arith $current - $age
6750 major=$func_arith_result
6754 eval soname=\"$soname_spec\"
6759 # Make a new name for the extract_expsyms_cmds to use
6761 func_basename "$soroot"
6762 soname="$func_basename_result"
6763 func_stripname 'lib' '.dll' "$soname"
6764 newlib=libimp-$func_stripname_result.a
6766 # If the library has no export list, then create one now
6767 if test -f "$output_objdir/$soname-def"; then :
6769 func_verbose "extracting exported symbol list from \`$soname'"
6770 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6774 if test -f "$output_objdir/$newlib"; then :; else
6775 func_verbose "generating import library for \`$soname'"
6776 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6778 # make sure the library variables are pointing to the new library
6781 fi # test -n "$old_archive_from_expsyms_cmds"
6783 if test "$linkmode" = prog || test "$opt_mode" != relink; then
6788 case $hardcode_action in
6789 immediate | unsupported)
6790 if test "$hardcode_direct" = no; then
6793 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6794 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6795 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6796 *-*-unixware7*) add_dir="-L$dir" ;;
6798 # if the lib is a (non-dlopened) module then we can not
6799 # link against it, someone is ignoring the earlier warnings
6800 if /usr/bin/file -L $add 2> /dev/null |
6801 $GREP ": [^:]* bundle" >/dev/null ; then
6802 if test "X$dlopenmodule" != "X$lib"; then
6803 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6804 if test -z "$old_library" ; then
6806 echo "*** And there doesn't seem to be a static archive available"
6807 echo "*** The link will probably fail, sorry"
6809 add="$dir/$old_library"
6811 elif test -n "$old_library"; then
6812 add="$dir/$old_library"
6816 elif test "$hardcode_minus_L" = no; then
6818 *-*-sunos*) add_shlibpath="$dir" ;;
6822 elif test "$hardcode_shlibpath_var" = no; then
6823 add_shlibpath="$dir"
6830 if test "$hardcode_direct" = yes &&
6831 test "$hardcode_direct_absolute" = no; then
6833 elif test "$hardcode_minus_L" = yes; then
6835 # Try looking first in the location we're being installed to.
6836 if test -n "$inst_prefix_dir"; then
6839 func_append add_dir " -L$inst_prefix_dir$libdir"
6844 elif test "$hardcode_shlibpath_var" = yes; then
6845 add_shlibpath="$dir"
6854 if test "$lib_linked" != yes; then
6855 func_fatal_configuration "unsupported hardcode properties"
6858 if test -n "$add_shlibpath"; then
6859 case :$compile_shlibpath: in
6860 *":$add_shlibpath:"*) ;;
6861 *) func_append compile_shlibpath "$add_shlibpath:" ;;
6864 if test "$linkmode" = prog; then
6865 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6866 test -n "$add" && compile_deplibs="$add $compile_deplibs"
6868 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6869 test -n "$add" && deplibs="$add $deplibs"
6870 if test "$hardcode_direct" != yes &&
6871 test "$hardcode_minus_L" != yes &&
6872 test "$hardcode_shlibpath_var" = yes; then
6873 case :$finalize_shlibpath: in
6875 *) func_append finalize_shlibpath "$libdir:" ;;
6881 if test "$linkmode" = prog || test "$opt_mode" = relink; then
6885 # Finalize command for both is simple: just hardcode it.
6886 if test "$hardcode_direct" = yes &&
6887 test "$hardcode_direct_absolute" = no; then
6888 add="$libdir/$linklib"
6889 elif test "$hardcode_minus_L" = yes; then
6892 elif test "$hardcode_shlibpath_var" = yes; then
6893 case :$finalize_shlibpath: in
6895 *) func_append finalize_shlibpath "$libdir:" ;;
6898 elif test "$hardcode_automatic" = yes; then
6899 if test -n "$inst_prefix_dir" &&
6900 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6901 add="$inst_prefix_dir$libdir/$linklib"
6903 add="$libdir/$linklib"
6906 # We cannot seem to hardcode it, guess we'll fake it.
6908 # Try looking first in the location we're being installed to.
6909 if test -n "$inst_prefix_dir"; then
6912 func_append add_dir " -L$inst_prefix_dir$libdir"
6919 if test "$linkmode" = prog; then
6920 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6921 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6923 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6924 test -n "$add" && deplibs="$add $deplibs"
6927 elif test "$linkmode" = prog; then
6928 # Here we assume that one of hardcode_direct or hardcode_minus_L
6929 # is not unsupported. This is valid on all known static and
6931 if test "$hardcode_direct" != unsupported; then
6932 test -n "$old_library" && linklib="$old_library"
6933 compile_deplibs="$dir/$linklib $compile_deplibs"
6934 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6936 compile_deplibs="-l$name -L$dir $compile_deplibs"
6937 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6939 elif test "$build_libtool_libs" = yes; then
6940 # Not a shared library
6941 if test "$deplibs_check_method" != pass_all; then
6942 # We're trying link a shared library against a static one
6943 # but the system doesn't support it.
6945 # Just print a warning and add the library to dependency_libs so
6946 # that the program can be linked against the static library.
6948 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6949 echo "*** I have the capability to make that library automatically link in when"
6950 echo "*** you link to this library. But I can only do this if you have a"
6951 echo "*** shared version of the library, which you do not appear to have."
6952 if test "$module" = yes; then
6953 echo "*** But as you try to build a module library, libtool will still create "
6954 echo "*** a static module, that should work as long as the dlopening application"
6955 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6956 if test -z "$global_symbol_pipe"; then
6958 echo "*** However, this would only work if libtool was able to extract symbol"
6959 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6960 echo "*** not find such a program. So, this module is probably useless."
6961 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6963 if test "$build_old_libs" = no; then
6964 build_libtool_libs=module
6967 build_libtool_libs=no
6971 deplibs="$dir/$old_library $deplibs"
6974 fi # link shared/static library?
6976 if test "$linkmode" = lib; then
6977 if test -n "$dependency_libs" &&
6978 { test "$hardcode_into_libs" != yes ||
6979 test "$build_old_libs" = yes ||
6980 test "$link_static" = yes; }; then
6981 # Extract -R from dependency_libs
6983 for libdir in $dependency_libs; do
6985 -R*) func_stripname '-R' '' "$libdir"
6986 temp_xrpath=$func_stripname_result
6988 *" $temp_xrpath "*) ;;
6989 *) func_append xrpath " $temp_xrpath";;
6991 *) func_append temp_deplibs " $libdir";;
6994 dependency_libs="$temp_deplibs"
6997 func_append newlib_search_path " $absdir"
6998 # Link against this library
6999 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7000 # ... and its dependency_libs
7002 for deplib in $dependency_libs; do
7003 newdependency_libs="$deplib $newdependency_libs"
7005 -L*) func_stripname '-L' '' "$deplib"
7006 func_resolve_sysroot "$func_stripname_result";;
7007 *) func_resolve_sysroot "$deplib" ;;
7009 if $opt_preserve_dup_deps ; then
7010 case "$tmp_libs " in
7011 *" $func_resolve_sysroot_result "*)
7012 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7015 func_append tmp_libs " $func_resolve_sysroot_result"
7018 if test "$link_all_deplibs" != no; then
7019 # Add the search paths of all dependency libraries
7020 for deplib in $dependency_libs; do
7023 -L*) path="$deplib" ;;
7025 func_resolve_sysroot "$deplib"
7026 deplib=$func_resolve_sysroot_result
7027 func_dirname "$deplib" "" "."
7028 dir=$func_dirname_result
7029 # We need an absolute path.
7031 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7033 absdir=`cd "$dir" && pwd`
7034 if test -z "$absdir"; then
7035 func_warning "cannot determine absolute directory name of \`$dir'"
7040 if $GREP "^installed=no" $deplib > /dev/null; then
7044 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7045 if test -n "$deplibrary_names" ; then
7046 for tmp in $deplibrary_names ; do
7049 if test -f "$absdir/$objdir/$depdepl" ; then
7050 depdepl="$absdir/$objdir/$depdepl"
7051 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7052 if test -z "$darwin_install_name"; then
7053 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7055 func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7056 func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7062 path="-L$absdir/$objdir"
7066 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7067 test -z "$libdir" && \
7068 func_fatal_error "\`$deplib' is not a valid libtool archive"
7069 test "$absdir" != "$libdir" && \
7070 func_warning "\`$deplib' seems to be moved"
7076 case " $deplibs " in
7078 *) deplibs="$path $deplibs" ;;
7081 fi # link_all_deplibs != no
7083 done # for deplib in $libs
7084 if test "$pass" = link; then
7085 if test "$linkmode" = "prog"; then
7086 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7087 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7089 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7092 dependency_libs="$newdependency_libs"
7093 if test "$pass" = dlpreopen; then
7094 # Link the dlpreopened libraries before other libraries
7095 for deplib in $save_deplibs; do
7096 deplibs="$deplib $deplibs"
7099 if test "$pass" != dlopen; then
7100 if test "$pass" != conv; then
7101 # Make sure lib_search_path contains only unique directories.
7103 for dir in $newlib_search_path; do
7104 case "$lib_search_path " in
7106 *) func_append lib_search_path " $dir" ;;
7112 if test "$linkmode,$pass" != "prog,link"; then
7115 vars="compile_deplibs finalize_deplibs"
7117 for var in $vars dependency_libs; do
7118 # Add libraries to $var in reverse order
7119 eval tmp_libs=\"\$$var\"
7121 for deplib in $tmp_libs; do
7122 # FIXME: Pedantically, this is the right thing to do, so
7123 # that some nasty dependency loop isn't accidentally
7125 #new_libs="$deplib $new_libs"
7126 # Pragmatically, this seems to cause very few problems in
7129 -L*) new_libs="$deplib $new_libs" ;;
7132 # And here is the reason: when a library appears more
7133 # than once as an explicit dependence of a library, or
7134 # is implicitly linked in more than once by the
7135 # compiler, it is considered special, and multiple
7136 # occurrences thereof are not removed. Compare this
7137 # with having the same library being listed as a
7138 # dependency of multiple other libraries: in this case,
7139 # we know (pedantically, we assume) the library does not
7140 # need to be listed more than once, so we keep only the
7141 # last copy. This is not always right, but it is rare
7142 # enough that we require users that really mean to play
7143 # such unportable linking tricks to link the library
7144 # using -Wl,-lname, so that libtool does not consider it
7145 # for duplicate removal.
7146 case " $specialdeplibs " in
7147 *" $deplib "*) new_libs="$deplib $new_libs" ;;
7149 case " $new_libs " in
7151 *) new_libs="$deplib $new_libs" ;;
7159 for deplib in $new_libs; do
7162 case " $tmp_libs " in
7164 *) func_append tmp_libs " $deplib" ;;
7167 *) func_append tmp_libs " $deplib" ;;
7170 eval $var=\"$tmp_libs\"
7173 # Last step: remove runtime libs from dependency_libs
7174 # (they stay in deplibs)
7176 for i in $dependency_libs ; do
7177 case " $predeps $postdeps $compiler_lib_search_path " in
7182 if test -n "$i" ; then
7183 func_append tmp_libs " $i"
7186 dependency_libs=$tmp_libs
7188 if test "$linkmode" = prog; then
7189 dlfiles="$newdlfiles"
7191 if test "$linkmode" = prog || test "$linkmode" = lib; then
7192 dlprefiles="$newdlprefiles"
7197 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7198 func_warning "\`-dlopen' is ignored for archives"
7203 func_warning "\`-l' and \`-L' are ignored for archives" ;;
7206 test -n "$rpath" && \
7207 func_warning "\`-rpath' is ignored for archives"
7209 test -n "$xrpath" && \
7210 func_warning "\`-R' is ignored for archives"
7212 test -n "$vinfo" && \
7213 func_warning "\`-version-info/-version-number' is ignored for archives"
7215 test -n "$release" && \
7216 func_warning "\`-release' is ignored for archives"
7218 test -n "$export_symbols$export_symbols_regex" && \
7219 func_warning "\`-export-symbols' is ignored for archives"
7221 # Now set the variables for building old libraries.
7222 build_libtool_libs=no
7224 func_append objs "$old_deplibs"
7228 # Make sure we only generate libraries of the form `libNAME.la'.
7231 func_stripname 'lib' '.la' "$outputname"
7232 name=$func_stripname_result
7233 eval shared_ext=\"$shrext_cmds\"
7234 eval libname=\"$libname_spec\"
7237 test "$module" = no && \
7238 func_fatal_help "libtool library \`$output' must begin with \`lib'"
7240 if test "$need_lib_prefix" != no; then
7241 # Add the "lib" prefix for modules if required
7242 func_stripname '' '.la' "$outputname"
7243 name=$func_stripname_result
7244 eval shared_ext=\"$shrext_cmds\"
7245 eval libname=\"$libname_spec\"
7247 func_stripname '' '.la' "$outputname"
7248 libname=$func_stripname_result
7253 if test -n "$objs"; then
7254 if test "$deplibs_check_method" != pass_all; then
7255 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7258 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7259 $ECHO "*** objects $objs is not portable!"
7260 func_append libobjs " $objs"
7264 test "$dlself" != no && \
7265 func_warning "\`-dlopen self' is ignored for libtool libraries"
7269 test "$#" -gt 1 && \
7270 func_warning "ignoring multiple \`-rpath's for a libtool library"
7275 if test -z "$rpath"; then
7276 if test "$build_libtool_libs" = yes; then
7277 # Building a libtool convenience library.
7278 # Some compilers have problems with a `.al' extension so
7279 # convenience libraries should have the same extension an
7280 # archive normally would.
7281 oldlibs="$output_objdir/$libname.$libext $oldlibs"
7282 build_libtool_libs=convenience
7286 test -n "$vinfo" && \
7287 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7289 test -n "$release" && \
7290 func_warning "\`-release' is ignored for convenience libraries"
7293 # Parse the version information argument.
7294 save_ifs="$IFS"; IFS=':'
7295 set dummy $vinfo 0 0 0
7300 func_fatal_help "too many parameters to \`-version-info'"
7302 # convert absolute version numbers to libtool ages
7303 # this retains compatibility with .la files and attempts
7304 # to make the code below a bit more comprehensible
7306 case $vinfo_number in
7310 number_revision="$3"
7312 # There are really only two kinds -- those that
7313 # use the current revision as the major version
7314 # and those that subtract age and use age as
7315 # a minor version. But, then there is irix
7316 # which has an extra 1 added just for fun
7318 case $version_type in
7319 darwin|linux|osf|windows|none)
7320 func_arith $number_major + $number_minor
7321 current=$func_arith_result
7323 revision="$number_revision"
7325 freebsd-aout|freebsd-elf|qnx|sunos)
7326 current="$number_major"
7327 revision="$number_minor"
7331 func_arith $number_major + $number_minor
7332 current=$func_arith_result
7334 revision="$number_minor"
7335 lt_irix_increment=no
7346 # Check that each of the things are valid numbers.
7348 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]) ;;
7350 func_error "CURRENT \`$current' must be a nonnegative integer"
7351 func_fatal_error "\`$vinfo' is not valid version information"
7356 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]) ;;
7358 func_error "REVISION \`$revision' must be a nonnegative integer"
7359 func_fatal_error "\`$vinfo' is not valid version information"
7364 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]) ;;
7366 func_error "AGE \`$age' must be a nonnegative integer"
7367 func_fatal_error "\`$vinfo' is not valid version information"
7371 if test "$age" -gt "$current"; then
7372 func_error "AGE \`$age' is greater than the current interface number \`$current'"
7373 func_fatal_error "\`$vinfo' is not valid version information"
7376 # Calculate the version variables.
7380 case $version_type in
7384 # Like Linux, but with the current version available in
7385 # verstring for coding it into the library header
7386 func_arith $current - $age
7387 major=.$func_arith_result
7388 versuffix="$major.$age.$revision"
7389 # Darwin ld doesn't like 0 for these options...
7390 func_arith $current + 1
7391 minor_current=$func_arith_result
7392 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7393 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7398 versuffix=".$current.$revision";
7403 versuffix=".$current"
7407 if test "X$lt_irix_increment" = "Xno"; then
7408 func_arith $current - $age
7410 func_arith $current - $age + 1
7412 major=$func_arith_result
7414 case $version_type in
7415 nonstopux) verstring_prefix=nonstopux ;;
7416 *) verstring_prefix=sgi ;;
7418 verstring="$verstring_prefix$major.$revision"
7420 # Add in all the interfaces that we are compatible with.
7422 while test "$loop" -ne 0; do
7423 func_arith $revision - $loop
7424 iface=$func_arith_result
7425 func_arith $loop - 1
7426 loop=$func_arith_result
7427 verstring="$verstring_prefix$major.$iface:$verstring"
7430 # Before this point, $major must not contain `.'.
7432 versuffix="$major.$revision"
7436 func_arith $current - $age
7437 major=.$func_arith_result
7438 versuffix="$major.$age.$revision"
7442 func_arith $current - $age
7443 major=.$func_arith_result
7444 versuffix=".$current.$age.$revision"
7445 verstring="$current.$age.$revision"
7447 # Add in all the interfaces that we are compatible with.
7449 while test "$loop" -ne 0; do
7450 func_arith $current - $loop
7451 iface=$func_arith_result
7452 func_arith $loop - 1
7453 loop=$func_arith_result
7454 verstring="$verstring:${iface}.0"
7457 # Make executables depend on our current version.
7458 func_append verstring ":${current}.0"
7463 versuffix=".$current"
7468 versuffix=".$current.$revision"
7472 # Use '-' rather than '.', since we only want one
7473 # extension on DOS 8.3 filesystems.
7474 func_arith $current - $age
7475 major=$func_arith_result
7480 func_fatal_configuration "unknown library version type \`$version_type'"
7484 # Clear the version info if we defaulted, and they specified a release.
7485 if test -z "$vinfo" && test -n "$release"; then
7487 case $version_type in
7489 # we can't check for "0.0" in archive_cmds due to quoting
7490 # problems, so we reset it completely
7497 if test "$need_version" = no; then
7504 # Remove version info from name if versioning should be avoided
7505 if test "$avoid_version" = yes && test "$need_version" = no; then
7511 # Check to see if the archive will have undefined symbols.
7512 if test "$allow_undefined" = yes; then
7513 if test "$allow_undefined_flag" = unsupported; then
7514 func_warning "undefined symbols not allowed in $host shared libraries"
7515 build_libtool_libs=no
7519 # Don't allow undefined symbols.
7520 allow_undefined_flag="$no_undefined_flag"
7525 func_generate_dlsyms "$libname" "$libname" "yes"
7526 func_append libobjs " $symfileobj"
7527 test "X$libobjs" = "X " && libobjs=
7529 if test "$opt_mode" != relink; then
7530 # Remove our outputs, but don't remove object files since they
7531 # may have been created when compiling PIC objects.
7533 tempremovelist=`$ECHO "$output_objdir/*"`
7534 for p in $tempremovelist; do
7538 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7539 if test "X$precious_files_regex" != "X"; then
7540 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7545 func_append removelist " $p"
7550 test -n "$removelist" && \
7551 func_show_eval "${RM}r \$removelist"
7554 # Now set the variables for building old libraries.
7555 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7556 func_append oldlibs " $output_objdir/$libname.$libext"
7558 # Transform .lo files to .o files.
7559 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7562 # Eliminate all temporary directories.
7563 #for path in $notinst_path; do
7564 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7565 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7566 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7569 if test -n "$xrpath"; then
7570 # If the user specified any rpath flags, then add them.
7572 for libdir in $xrpath; do
7573 func_replace_sysroot "$libdir"
7574 func_append temp_xrpath " -R$func_replace_sysroot_result"
7575 case "$finalize_rpath " in
7577 *) func_append finalize_rpath " $libdir" ;;
7580 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7581 dependency_libs="$temp_xrpath $dependency_libs"
7585 # Make sure dlfiles contains only unique files that won't be dlpreopened
7586 old_dlfiles="$dlfiles"
7588 for lib in $old_dlfiles; do
7589 case " $dlprefiles $dlfiles " in
7591 *) func_append dlfiles " $lib" ;;
7595 # Make sure dlprefiles contains only unique files
7596 old_dlprefiles="$dlprefiles"
7598 for lib in $old_dlprefiles; do
7599 case "$dlprefiles " in
7601 *) func_append dlprefiles " $lib" ;;
7605 if test "$build_libtool_libs" = yes; then
7606 if test -n "$rpath"; then
7608 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7609 # these systems don't actually have a c library (as such)!
7611 *-*-rhapsody* | *-*-darwin1.[012])
7612 # Rhapsody C library is in the System framework
7613 func_append deplibs " System.ltframework"
7616 # Don't link with libc until the a.out ld.so is fixed.
7618 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7619 # Do not include libc due to us having libc/libc_r.
7621 *-*-sco3.2v5* | *-*-sco5v6*)
7622 # Causes problems with __ctype
7624 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7625 # Compiler inserts libc in the correct place for threads to work
7628 # Add libc to deplibs on all other systems if necessary.
7629 if test "$build_libtool_need_lc" = "yes"; then
7630 func_append deplibs " -lc"
7636 # Transform deplibs into only deplibs that can be linked in shared.
7638 libname_save=$libname
7639 release_save=$release
7640 versuffix_save=$versuffix
7642 # I'm not sure if I'm treating the release correctly. I think
7643 # release should show up in the -l (ie -lgmp5) so we don't want to
7644 # add it in twice. Is that correct?
7650 case $deplibs_check_method in
7652 # Don't check for shared/static. Everything works.
7653 # This might be a little naive. We might want to check
7654 # whether the library exists or not. But this is on
7655 # osf3 & osf4 and I'm not really sure... Just
7656 # implementing what was already the behavior.
7660 # This code stresses the "libraries are programs" paradigm to its
7661 # limits. Maybe even breaks it. We compile a program, linking it
7662 # against the deplibs as a proxy for the library. Then we can check
7663 # whether they linked in statically or dynamically with ldd.
7664 $opt_dry_run || $RM conftest.c
7665 cat > conftest.c <<EOF
7666 int main() { return 0; }
7668 $opt_dry_run || $RM conftest
7669 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7670 ldd_output=`ldd conftest`
7671 for i in $deplibs; do
7674 func_stripname -l '' "$i"
7675 name=$func_stripname_result
7676 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7677 case " $predeps $postdeps " in
7679 func_append newdeplibs " $i"
7684 if test -n "$i" ; then
7685 libname=`eval "\\$ECHO \"$libname_spec\""`
7686 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7687 set dummy $deplib_matches; shift
7689 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7690 func_append newdeplibs " $i"
7694 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7695 echo "*** I have the capability to make that library automatically link in when"
7696 echo "*** you link to this library. But I can only do this if you have a"
7697 echo "*** shared version of the library, which I believe you do not have"
7698 echo "*** because a test_compile did reveal that the linker did not use it for"
7699 echo "*** its dynamic dependency list that programs get resolved with at runtime."
7704 func_append newdeplibs " $i"
7709 # Error occurred in the first compile. Let's try to salvage
7710 # the situation: Compile a separate program for each library.
7711 for i in $deplibs; do
7714 func_stripname -l '' "$i"
7715 name=$func_stripname_result
7716 $opt_dry_run || $RM conftest
7717 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7718 ldd_output=`ldd conftest`
7719 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7720 case " $predeps $postdeps " in
7722 func_append newdeplibs " $i"
7727 if test -n "$i" ; then
7728 libname=`eval "\\$ECHO \"$libname_spec\""`
7729 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7730 set dummy $deplib_matches; shift
7732 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7733 func_append newdeplibs " $i"
7737 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7738 echo "*** I have the capability to make that library automatically link in when"
7739 echo "*** you link to this library. But I can only do this if you have a"
7740 echo "*** shared version of the library, which you do not appear to have"
7741 echo "*** because a test_compile did reveal that the linker did not use this one"
7742 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7748 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7749 echo "*** make it link in! You will probably need to install it or some"
7750 echo "*** library that it depends on before this library will be fully"
7751 echo "*** functional. Installing it before continuing would be even better."
7755 func_append newdeplibs " $i"
7762 set dummy $deplibs_check_method; shift
7763 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7764 for a_deplib in $deplibs; do
7767 func_stripname -l '' "$a_deplib"
7768 name=$func_stripname_result
7769 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7770 case " $predeps $postdeps " in
7772 func_append newdeplibs " $a_deplib"
7777 if test -n "$a_deplib" ; then
7778 libname=`eval "\\$ECHO \"$libname_spec\""`
7779 if test -n "$file_magic_glob"; then
7780 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7782 libnameglob=$libname
7784 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7785 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7786 if test "$want_nocaseglob" = yes; then
7788 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7791 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7793 for potent_lib in $potential_libs; do
7794 # Follow soft links.
7795 if ls -lLd "$potent_lib" 2>/dev/null |
7796 $GREP " -> " >/dev/null; then
7799 # The statement above tries to avoid entering an
7800 # endless loop below, in case of cyclic links.
7801 # We might still enter an endless loop, since a link
7802 # loop can be closed while we follow links,
7804 potlib="$potent_lib"
7805 while test -h "$potlib" 2>/dev/null; do
7806 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7808 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7809 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7812 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7814 $EGREP "$file_magic_regex" > /dev/null; then
7815 func_append newdeplibs " $a_deplib"
7822 if test -n "$a_deplib" ; then
7825 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7826 echo "*** I have the capability to make that library automatically link in when"
7827 echo "*** you link to this library. But I can only do this if you have a"
7828 echo "*** shared version of the library, which you do not appear to have"
7829 echo "*** because I did check the linker path looking for a file starting"
7830 if test -z "$potlib" ; then
7831 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7833 $ECHO "*** with $libname and none of the candidates passed a file format test"
7834 $ECHO "*** using a file magic. Last file checked: $potlib"
7839 # Add a -L argument.
7840 func_append newdeplibs " $a_deplib"
7843 done # Gone through all deplibs.
7846 set dummy $deplibs_check_method; shift
7847 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7848 for a_deplib in $deplibs; do
7851 func_stripname -l '' "$a_deplib"
7852 name=$func_stripname_result
7853 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7854 case " $predeps $postdeps " in
7856 func_append newdeplibs " $a_deplib"
7861 if test -n "$a_deplib" ; then
7862 libname=`eval "\\$ECHO \"$libname_spec\""`
7863 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7864 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7865 for potent_lib in $potential_libs; do
7866 potlib="$potent_lib" # see symlink-check above in file_magic test
7867 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7868 $EGREP "$match_pattern_regex" > /dev/null; then
7869 func_append newdeplibs " $a_deplib"
7876 if test -n "$a_deplib" ; then
7879 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7880 echo "*** I have the capability to make that library automatically link in when"
7881 echo "*** you link to this library. But I can only do this if you have a"
7882 echo "*** shared version of the library, which you do not appear to have"
7883 echo "*** because I did check the linker path looking for a file starting"
7884 if test -z "$potlib" ; then
7885 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7887 $ECHO "*** with $libname and none of the candidates passed a file format test"
7888 $ECHO "*** using a regex pattern. Last file checked: $potlib"
7893 # Add a -L argument.
7894 func_append newdeplibs " $a_deplib"
7897 done # Gone through all deplibs.
7901 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7902 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7903 for i in $predeps $postdeps ; do
7904 # can't use Xsed below, because $i might contain '/'
7905 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7908 case $tmp_deplibs in
7911 if test "X$deplibs_check_method" = "Xnone"; then
7912 echo "*** Warning: inter-library dependencies are not supported in this platform."
7914 echo "*** Warning: inter-library dependencies are not known to be supported."
7916 echo "*** All declared inter-library dependencies are being dropped."
7922 versuffix=$versuffix_save
7924 release=$release_save
7925 libname=$libname_save
7929 *-*-rhapsody* | *-*-darwin1.[012])
7930 # On Rhapsody replace the C library with the System framework
7931 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7935 if test "$droppeddeps" = yes; then
7936 if test "$module" = yes; then
7938 echo "*** Warning: libtool could not satisfy all declared inter-library"
7939 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7940 echo "*** a static module, that should work as long as the dlopening"
7941 echo "*** application is linked with the -dlopen flag."
7942 if test -z "$global_symbol_pipe"; then
7944 echo "*** However, this would only work if libtool was able to extract symbol"
7945 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7946 echo "*** not find such a program. So, this module is probably useless."
7947 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7949 if test "$build_old_libs" = no; then
7950 oldlibs="$output_objdir/$libname.$libext"
7951 build_libtool_libs=module
7954 build_libtool_libs=no
7957 echo "*** The inter-library dependencies that have been dropped here will be"
7958 echo "*** automatically added whenever a program is linked with this library"
7959 echo "*** or is declared to -dlopen it."
7961 if test "$allow_undefined" = no; then
7963 echo "*** Since this library must not contain undefined symbols,"
7964 echo "*** because either the platform does not support them or"
7965 echo "*** it was explicitly requested with -no-undefined,"
7966 echo "*** libtool will only create a static version of it."
7967 if test "$build_old_libs" = no; then
7968 oldlibs="$output_objdir/$libname.$libext"
7969 build_libtool_libs=module
7972 build_libtool_libs=no
7977 # Done checking deplibs!
7980 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7983 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7984 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7985 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7989 # move library search paths that coincide with paths to not yet
7990 # installed libraries to the beginning of the library search list
7992 for path in $notinst_path; do
7993 case " $new_libs " in
7994 *" -L$path/$objdir "*) ;;
7996 case " $deplibs " in
7997 *" -L$path/$objdir "*)
7998 func_append new_libs " -L$path/$objdir" ;;
8003 for deplib in $deplibs; do
8006 case " $new_libs " in
8008 *) func_append new_libs " $deplib" ;;
8011 *) func_append new_libs " $deplib" ;;
8016 # All the library-specific variables (install_libdir is set above).
8021 # Test again, we may have decided not to build it any more
8022 if test "$build_libtool_libs" = yes; then
8023 if test "$hardcode_into_libs" = yes; then
8024 # Hardcode the library paths
8027 rpath="$finalize_rpath"
8028 test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8029 for libdir in $rpath; do
8030 if test -n "$hardcode_libdir_flag_spec"; then
8031 if test -n "$hardcode_libdir_separator"; then
8032 func_replace_sysroot "$libdir"
8033 libdir=$func_replace_sysroot_result
8034 if test -z "$hardcode_libdirs"; then
8035 hardcode_libdirs="$libdir"
8037 # Just accumulate the unique libdirs.
8038 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8039 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8042 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8047 eval flag=\"$hardcode_libdir_flag_spec\"
8048 func_append dep_rpath " $flag"
8050 elif test -n "$runpath_var"; then
8051 case "$perm_rpath " in
8053 *) func_apped perm_rpath " $libdir" ;;
8057 # Substitute the hardcoded libdirs into the rpath.
8058 if test -n "$hardcode_libdir_separator" &&
8059 test -n "$hardcode_libdirs"; then
8060 libdir="$hardcode_libdirs"
8061 if test -n "$hardcode_libdir_flag_spec_ld"; then
8062 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
8064 eval dep_rpath=\"$hardcode_libdir_flag_spec\"
8067 if test -n "$runpath_var" && test -n "$perm_rpath"; then
8068 # We should set the runpath_var.
8070 for dir in $perm_rpath; do
8071 func_append rpath "$dir:"
8073 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8075 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8078 shlibpath="$finalize_shlibpath"
8079 test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8080 if test -n "$shlibpath"; then
8081 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8084 # Get the real and link names of the library.
8085 eval shared_ext=\"$shrext_cmds\"
8086 eval library_names=\"$library_names_spec\"
8087 set dummy $library_names
8092 if test -n "$soname_spec"; then
8093 eval soname=\"$soname_spec\"
8097 if test -z "$dlname"; then
8101 lib="$output_objdir/$realname"
8105 func_append linknames " $link"
8108 # Use standard objects if they are pic
8109 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8110 test "X$libobjs" = "X " && libobjs=
8113 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8114 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8115 export_symbols="$output_objdir/$libname.uexp"
8116 func_append delfiles " $export_symbols"
8119 orig_export_symbols=
8121 cygwin* | mingw* | cegcc*)
8122 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8123 # exporting using user supplied symfile
8124 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8125 # and it's NOT already a .def file. Must figure out
8126 # which of the given symbols are data symbols and tag
8127 # them as such. So, trigger use of export_symbols_cmds.
8128 # export_symbols gets reassigned inside the "prepare
8129 # the list of exported symbols" if statement, so the
8130 # include_expsyms logic still works.
8131 orig_export_symbols="$export_symbols"
8133 always_export_symbols=yes
8139 # Prepare the list of exported symbols
8140 if test -z "$export_symbols"; then
8141 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8142 func_verbose "generating symbol list for \`$libname.la'"
8143 export_symbols="$output_objdir/$libname.exp"
8144 $opt_dry_run || $RM $export_symbols
8145 cmds=$export_symbols_cmds
8146 save_ifs="$IFS"; IFS='~'
8147 for cmd1 in $cmds; do
8149 # Take the normal branch if the nm_file_list_spec branch
8150 # doesn't work or if tool conversion is not needed.
8151 case $nm_file_list_spec~$to_tool_file_cmd in
8152 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8153 try_normal_branch=yes
8156 len=$func_len_result
8159 try_normal_branch=no
8162 if test "$try_normal_branch" = yes \
8163 && { test "$len" -lt "$max_cmd_len" \
8164 || test "$max_cmd_len" -le -1; }
8166 func_show_eval "$cmd" 'exit $?'
8167 skipped_export=false
8168 elif test -n "$nm_file_list_spec"; then
8169 func_basename "$output"
8170 output_la=$func_basename_result
8171 save_libobjs=$libobjs
8173 output=${output_objdir}/${output_la}.nm
8174 func_to_tool_file "$output"
8175 libobjs=$nm_file_list_spec$func_to_tool_file_result
8176 func_append delfiles " $output"
8177 func_verbose "creating $NM input file list: $output"
8178 for obj in $save_libobjs; do
8179 func_to_tool_file "$obj"
8180 $ECHO "$func_to_tool_file_result"
8183 func_show_eval "$cmd" 'exit $?'
8185 libobjs=$save_libobjs
8186 skipped_export=false
8188 # The command line is too long to execute in one step.
8189 func_verbose "using reloadable object file for export list..."
8191 # Break out early, otherwise skipped_export may be
8192 # set to false by a later but shorter cmd.
8197 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8198 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8199 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8204 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8205 tmp_export_symbols="$export_symbols"
8206 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8207 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8210 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8211 # The given exports_symbols file has to be filtered, so filter it.
8212 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8213 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8214 # 's' commands which not all seds can handle. GNU sed should be fine
8215 # though. Also, the filter scales superlinearly with the number of
8216 # global variables. join(1) would be nice here, but unfortunately
8217 # isn't a blessed tool.
8218 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8219 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8220 export_symbols=$output_objdir/$libname.def
8221 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8225 for test_deplib in $deplibs; do
8226 case " $convenience " in
8227 *" $test_deplib "*) ;;
8229 func_append tmp_deplibs " $test_deplib"
8233 deplibs="$tmp_deplibs"
8235 if test -n "$convenience"; then
8236 if test -n "$whole_archive_flag_spec" &&
8237 test "$compiler_needs_object" = yes &&
8238 test -z "$libobjs"; then
8239 # extract the archives, so we have objects to list.
8240 # TODO: could optimize this to just extract one archive.
8241 whole_archive_flag_spec=
8243 if test -n "$whole_archive_flag_spec"; then
8244 save_libobjs=$libobjs
8245 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8246 test "X$libobjs" = "X " && libobjs=
8248 gentop="$output_objdir/${outputname}x"
8249 func_append generated " $gentop"
8251 func_extract_archives $gentop $convenience
8252 func_append libobjs " $func_extract_archives_result"
8253 test "X$libobjs" = "X " && libobjs=
8257 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8258 eval flag=\"$thread_safe_flag_spec\"
8259 func_append linker_flags " $flag"
8262 # Make a backup of the uninstalled library when relinking
8263 if test "$opt_mode" = relink; then
8264 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8267 # Do each of the archive commands.
8268 if test "$module" = yes && test -n "$module_cmds" ; then
8269 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8270 eval test_cmds=\"$module_expsym_cmds\"
8271 cmds=$module_expsym_cmds
8273 eval test_cmds=\"$module_cmds\"
8277 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8278 eval test_cmds=\"$archive_expsym_cmds\"
8279 cmds=$archive_expsym_cmds
8281 eval test_cmds=\"$archive_cmds\"
8286 if test "X$skipped_export" != "X:" &&
8287 func_len " $test_cmds" &&
8288 len=$func_len_result &&
8289 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8292 # The command line is too long to link in one step, link piecewise
8293 # or, if using GNU ld and skipped_export is not :, use a linker
8296 # Save the value of $output and $libobjs because we want to
8297 # use them later. If we have whole_archive_flag_spec, we
8298 # want to use save_libobjs as it was before
8299 # whole_archive_flag_spec was expanded, because we can't
8300 # assume the linker understands whole_archive_flag_spec.
8301 # This may have to be revisited, in case too many
8302 # convenience libraries get linked in and end up exceeding
8304 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8305 save_libobjs=$libobjs
8308 func_basename "$output"
8309 output_la=$func_basename_result
8311 # Clear the reloadable object creation command queue and
8312 # initialize k to one.
8319 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8320 output=${output_objdir}/${output_la}.lnkscript
8321 func_verbose "creating GNU ld script: $output"
8322 echo 'INPUT (' > $output
8323 for obj in $save_libobjs
8325 func_to_tool_file "$obj"
8326 $ECHO "$func_to_tool_file_result" >> $output
8329 func_append delfiles " $output"
8330 func_to_tool_file "$output"
8331 output=$func_to_tool_file_result
8332 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8333 output=${output_objdir}/${output_la}.lnk
8334 func_verbose "creating linker input file list: $output"
8339 if test "$compiler_needs_object" = yes; then
8345 func_to_tool_file "$obj"
8346 $ECHO "$func_to_tool_file_result" >> $output
8348 func_append delfiles " $output"
8349 func_to_tool_file "$output"
8350 output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8352 if test -n "$save_libobjs"; then
8353 func_verbose "creating reloadable object files..."
8354 output=$output_objdir/$output_la-${k}.$objext
8355 eval test_cmds=\"$reload_cmds\"
8356 func_len " $test_cmds"
8357 len0=$func_len_result
8360 # Loop over the list of objects to be linked.
8361 for obj in $save_libobjs
8364 func_arith $len + $func_len_result
8365 len=$func_arith_result
8366 if test "X$objlist" = X ||
8367 test "$len" -lt "$max_cmd_len"; then
8368 func_append objlist " $obj"
8370 # The command $test_cmds is almost too long, add a
8371 # command to the queue.
8372 if test "$k" -eq 1 ; then
8373 # The first file doesn't have a previous command to add.
8374 reload_objs=$objlist
8375 eval concat_cmds=\"$reload_cmds\"
8377 # All subsequent reloadable object files will link in
8378 # the last one created.
8379 reload_objs="$objlist $last_robj"
8380 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8382 last_robj=$output_objdir/$output_la-${k}.$objext
8384 k=$func_arith_result
8385 output=$output_objdir/$output_la-${k}.$objext
8387 func_len " $last_robj"
8388 func_arith $len0 + $func_len_result
8389 len=$func_arith_result
8392 # Handle the remaining objects by creating one last
8393 # reloadable object file. All subsequent reloadable object
8394 # files will link in the last one created.
8395 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8396 reload_objs="$objlist $last_robj"
8397 eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8398 if test -n "$last_robj"; then
8399 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8401 func_append delfiles " $output"
8407 if ${skipped_export-false}; then
8408 func_verbose "generating symbol list for \`$libname.la'"
8409 export_symbols="$output_objdir/$libname.exp"
8410 $opt_dry_run || $RM $export_symbols
8412 # Append the command to create the export file.
8413 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8414 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8415 if test -n "$last_robj"; then
8416 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8420 test -n "$save_libobjs" &&
8421 func_verbose "creating a temporary reloadable object file: $output"
8423 # Loop through the commands generated above and execute them.
8424 save_ifs="$IFS"; IFS='~'
8425 for cmd in $concat_cmds; do
8428 func_quote_for_expand "$cmd"
8429 eval "func_echo $func_quote_for_expand_result"
8431 $opt_dry_run || eval "$cmd" || {
8434 # Restore the uninstalled library and exit
8435 if test "$opt_mode" = relink; then
8436 ( cd "$output_objdir" && \
8437 $RM "${realname}T" && \
8438 $MV "${realname}U" "$realname" )
8446 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8447 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8448 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8452 if ${skipped_export-false}; then
8453 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8454 tmp_export_symbols="$export_symbols"
8455 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8456 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8459 if test -n "$orig_export_symbols"; then
8460 # The given exports_symbols file has to be filtered, so filter it.
8461 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8462 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8463 # 's' commands which not all seds can handle. GNU sed should be fine
8464 # though. Also, the filter scales superlinearly with the number of
8465 # global variables. join(1) would be nice here, but unfortunately
8466 # isn't a blessed tool.
8467 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8468 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8469 export_symbols=$output_objdir/$libname.def
8470 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8475 # Restore the value of output.
8478 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8479 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8480 test "X$libobjs" = "X " && libobjs=
8482 # Expand the library linking commands again to reset the
8483 # value of $libobjs for piecewise linking.
8485 # Do each of the archive commands.
8486 if test "$module" = yes && test -n "$module_cmds" ; then
8487 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8488 cmds=$module_expsym_cmds
8493 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8494 cmds=$archive_expsym_cmds
8501 if test -n "$delfiles"; then
8502 # Append the command to remove temporary files to $cmds.
8503 eval cmds=\"\$cmds~\$RM $delfiles\"
8506 # Add any objects from preloaded convenience libraries
8507 if test -n "$dlprefiles"; then
8508 gentop="$output_objdir/${outputname}x"
8509 func_append generated " $gentop"
8511 func_extract_archives $gentop $dlprefiles
8512 func_append libobjs " $func_extract_archives_result"
8513 test "X$libobjs" = "X " && libobjs=
8516 save_ifs="$IFS"; IFS='~'
8517 for cmd in $cmds; do
8521 func_quote_for_expand "$cmd"
8522 eval "func_echo $func_quote_for_expand_result"
8524 $opt_dry_run || eval "$cmd" || {
8527 # Restore the uninstalled library and exit
8528 if test "$opt_mode" = relink; then
8529 ( cd "$output_objdir" && \
8530 $RM "${realname}T" && \
8531 $MV "${realname}U" "$realname" )
8539 # Restore the uninstalled library and exit
8540 if test "$opt_mode" = relink; then
8541 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8543 if test -n "$convenience"; then
8544 if test -z "$whole_archive_flag_spec"; then
8545 func_show_eval '${RM}r "$gentop"'
8552 # Create links to the real library.
8553 for linkname in $linknames; do
8554 if test "$realname" != "$linkname"; then
8555 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8559 # If -module or -export-dynamic was specified, set the dlname.
8560 if test "$module" = yes || test "$export_dynamic" = yes; then
8561 # On all known operating systems, these are identical.
8568 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8569 func_warning "\`-dlopen' is ignored for objects"
8574 func_warning "\`-l' and \`-L' are ignored for objects" ;;
8577 test -n "$rpath" && \
8578 func_warning "\`-rpath' is ignored for objects"
8580 test -n "$xrpath" && \
8581 func_warning "\`-R' is ignored for objects"
8583 test -n "$vinfo" && \
8584 func_warning "\`-version-info' is ignored for objects"
8586 test -n "$release" && \
8587 func_warning "\`-release' is ignored for objects"
8591 test -n "$objs$old_deplibs" && \
8592 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8596 obj=$func_lo2o_result
8604 # Delete the old objects.
8605 $opt_dry_run || $RM $obj $libobj
8607 # Objects from convenience libraries. This assumes
8608 # single-version convenience libraries. Whenever we create
8609 # different ones for PIC/non-PIC, this we'll have to duplicate
8613 # reload_cmds runs $LD directly, so let us get rid of
8614 # -Wl from whole_archive_flag_spec and hope we can get by with
8615 # turning comma into space..
8618 if test -n "$convenience"; then
8619 if test -n "$whole_archive_flag_spec"; then
8620 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8621 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8623 gentop="$output_objdir/${obj}x"
8624 func_append generated " $gentop"
8626 func_extract_archives $gentop $convenience
8627 reload_conv_objs="$reload_objs $func_extract_archives_result"
8631 # If we're not building shared, we need to use non_pic_objs
8632 test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8634 # Create the old-style object.
8635 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8638 func_execute_cmds "$reload_cmds" 'exit $?'
8640 # Exit if we aren't doing a library object file.
8641 if test -z "$libobj"; then
8642 if test -n "$gentop"; then
8643 func_show_eval '${RM}r "$gentop"'
8649 if test "$build_libtool_libs" != yes; then
8650 if test -n "$gentop"; then
8651 func_show_eval '${RM}r "$gentop"'
8654 # Create an invalid libtool object if no PIC, so that we don't
8655 # accidentally link it into a program.
8656 # $show "echo timestamp > $libobj"
8657 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8661 if test -n "$pic_flag" || test "$pic_mode" != default; then
8662 # Only do commands if we really have different PIC objects.
8663 reload_objs="$libobjs $reload_conv_objs"
8665 func_execute_cmds "$reload_cmds" 'exit $?'
8668 if test -n "$gentop"; then
8669 func_show_eval '${RM}r "$gentop"'
8677 *cygwin*) func_stripname '' '.exe' "$output"
8678 output=$func_stripname_result.exe;;
8680 test -n "$vinfo" && \
8681 func_warning "\`-version-info' is ignored for programs"
8683 test -n "$release" && \
8684 func_warning "\`-release' is ignored for programs"
8686 test "$preload" = yes \
8687 && test "$dlopen_support" = unknown \
8688 && test "$dlopen_self" = unknown \
8689 && test "$dlopen_self_static" = unknown && \
8690 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8693 *-*-rhapsody* | *-*-darwin1.[012])
8694 # On Rhapsody replace the C library is the System framework
8695 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8696 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8702 # Don't allow lazy linking, it breaks C++ global constructors
8703 # But is supposedly fixed on 10.4 or later (yay!).
8704 if test "$tagname" = CXX ; then
8705 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8707 func_append compile_command " ${wl}-bind_at_load"
8708 func_append finalize_command " ${wl}-bind_at_load"
8712 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8713 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8714 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8719 # move library search paths that coincide with paths to not yet
8720 # installed libraries to the beginning of the library search list
8722 for path in $notinst_path; do
8723 case " $new_libs " in
8724 *" -L$path/$objdir "*) ;;
8726 case " $compile_deplibs " in
8727 *" -L$path/$objdir "*)
8728 func_append new_libs " -L$path/$objdir" ;;
8733 for deplib in $compile_deplibs; do
8736 case " $new_libs " in
8738 *) func_append new_libs " $deplib" ;;
8741 *) func_append new_libs " $deplib" ;;
8744 compile_deplibs="$new_libs"
8747 func_append compile_command " $compile_deplibs"
8748 func_append finalize_command " $finalize_deplibs"
8750 if test -n "$rpath$xrpath"; then
8751 # If the user specified any rpath flags, then add them.
8752 for libdir in $rpath $xrpath; do
8753 # This is the magic to use -rpath.
8754 case "$finalize_rpath " in
8756 *) func_append finalize_rpath " $libdir" ;;
8761 # Now hardcode the library paths
8764 for libdir in $compile_rpath $finalize_rpath; do
8765 if test -n "$hardcode_libdir_flag_spec"; then
8766 if test -n "$hardcode_libdir_separator"; then
8767 if test -z "$hardcode_libdirs"; then
8768 hardcode_libdirs="$libdir"
8770 # Just accumulate the unique libdirs.
8771 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8772 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8775 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8780 eval flag=\"$hardcode_libdir_flag_spec\"
8781 func_append rpath " $flag"
8783 elif test -n "$runpath_var"; then
8784 case "$perm_rpath " in
8786 *) func_append perm_rpath " $libdir" ;;
8790 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8791 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8792 case :$dllsearchpath: in
8794 ::) dllsearchpath=$libdir;;
8795 *) func_append dllsearchpath ":$libdir";;
8797 case :$dllsearchpath: in
8798 *":$testbindir:"*) ;;
8799 ::) dllsearchpath=$testbindir;;
8800 *) func_append dllsearchpath ":$testbindir";;
8805 # Substitute the hardcoded libdirs into the rpath.
8806 if test -n "$hardcode_libdir_separator" &&
8807 test -n "$hardcode_libdirs"; then
8808 libdir="$hardcode_libdirs"
8809 eval rpath=\" $hardcode_libdir_flag_spec\"
8811 compile_rpath="$rpath"
8815 for libdir in $finalize_rpath; do
8816 if test -n "$hardcode_libdir_flag_spec"; then
8817 if test -n "$hardcode_libdir_separator"; then
8818 if test -z "$hardcode_libdirs"; then
8819 hardcode_libdirs="$libdir"
8821 # Just accumulate the unique libdirs.
8822 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8823 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8826 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8831 eval flag=\"$hardcode_libdir_flag_spec\"
8832 func_append rpath " $flag"
8834 elif test -n "$runpath_var"; then
8835 case "$finalize_perm_rpath " in
8837 *) func_append finalize_perm_rpath " $libdir" ;;
8841 # Substitute the hardcoded libdirs into the rpath.
8842 if test -n "$hardcode_libdir_separator" &&
8843 test -n "$hardcode_libdirs"; then
8844 libdir="$hardcode_libdirs"
8845 eval rpath=\" $hardcode_libdir_flag_spec\"
8847 finalize_rpath="$rpath"
8849 if test -n "$libobjs" && test "$build_old_libs" = yes; then
8850 # Transform all the library objects into standard objects.
8851 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8852 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8855 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8857 # template prelinking step
8858 if test -n "$prelink_cmds"; then
8859 func_execute_cmds "$prelink_cmds" 'exit $?'
8862 wrappers_required=yes
8864 *cegcc* | *mingw32ce*)
8865 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8866 wrappers_required=no
8868 *cygwin* | *mingw* )
8869 if test "$build_libtool_libs" != yes; then
8870 wrappers_required=no
8874 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8875 wrappers_required=no
8879 if test "$wrappers_required" = no; then
8880 # Replace the output file specification.
8881 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8882 link_command="$compile_command$compile_rpath"
8884 # We have no uninstalled library dependencies, so finalize right now.
8886 func_show_eval "$link_command" 'exit_status=$?'
8888 if test -n "$postlink_cmds"; then
8889 func_to_tool_file "$output"
8890 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8891 func_execute_cmds "$postlink_cmds" 'exit $?'
8894 # Delete the generated files.
8895 if test -f "$output_objdir/${outputname}S.${objext}"; then
8896 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8902 if test -n "$compile_shlibpath$finalize_shlibpath"; then
8903 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8905 if test -n "$finalize_shlibpath"; then
8906 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8911 if test -n "$runpath_var"; then
8912 if test -n "$perm_rpath"; then
8913 # We should set the runpath_var.
8915 for dir in $perm_rpath; do
8916 func_append rpath "$dir:"
8918 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8920 if test -n "$finalize_perm_rpath"; then
8921 # We should set the runpath_var.
8923 for dir in $finalize_perm_rpath; do
8924 func_append rpath "$dir:"
8926 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8930 if test "$no_install" = yes; then
8931 # We don't need to create a wrapper script.
8932 link_command="$compile_var$compile_command$compile_rpath"
8933 # Replace the output file specification.
8934 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8935 # Delete the old output file.
8936 $opt_dry_run || $RM $output
8937 # Link the executable and exit
8938 func_show_eval "$link_command" 'exit $?'
8940 if test -n "$postlink_cmds"; then
8941 func_to_tool_file "$output"
8942 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8943 func_execute_cmds "$postlink_cmds" 'exit $?'
8949 if test "$hardcode_action" = relink; then
8950 # Fast installation is not supported
8951 link_command="$compile_var$compile_command$compile_rpath"
8952 relink_command="$finalize_var$finalize_command$finalize_rpath"
8954 func_warning "this platform does not like uninstalled shared libraries"
8955 func_warning "\`$output' will be relinked during installation"
8957 if test "$fast_install" != no; then
8958 link_command="$finalize_var$compile_command$finalize_rpath"
8959 if test "$fast_install" = yes; then
8960 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8962 # fast_install is set to needless
8966 link_command="$compile_var$compile_command$compile_rpath"
8967 relink_command="$finalize_var$finalize_command$finalize_rpath"
8971 # Replace the output file specification.
8972 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8974 # Delete the old output files.
8975 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8977 func_show_eval "$link_command" 'exit $?'
8979 if test -n "$postlink_cmds"; then
8980 func_to_tool_file "$output_objdir/$outputname"
8981 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8982 func_execute_cmds "$postlink_cmds" 'exit $?'
8985 # Now create the wrapper script.
8986 func_verbose "creating $output"
8988 # Quote the relink command for shipping.
8989 if test -n "$relink_command"; then
8990 # Preserve any variables that may affect compiler behavior
8991 for var in $variables_saved_for_relink; do
8992 if eval test -z \"\${$var+set}\"; then
8993 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8994 elif eval var_value=\$$var; test -z "$var_value"; then
8995 relink_command="$var=; export $var; $relink_command"
8997 func_quote_for_eval "$var_value"
8998 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9001 relink_command="(cd `pwd`; $relink_command)"
9002 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9005 # Only actually do things if not in dry run mode.
9007 # win32 will think the script is a binary if it has
9008 # a .exe suffix, so we strip it off here.
9010 *.exe) func_stripname '' '.exe' "$output"
9011 output=$func_stripname_result ;;
9013 # test for cygwin because mv fails w/o .exe extensions
9017 func_stripname '' '.exe' "$outputname"
9018 outputname=$func_stripname_result ;;
9022 *cygwin* | *mingw* )
9023 func_dirname_and_basename "$output" "" "."
9024 output_name=$func_basename_result
9025 output_path=$func_dirname_result
9026 cwrappersource="$output_path/$objdir/lt-$output_name.c"
9027 cwrapper="$output_path/$output_name.exe"
9028 $RM $cwrappersource $cwrapper
9029 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9031 func_emit_cwrapperexe_src > $cwrappersource
9033 # The wrapper executable is built using the $host compiler,
9034 # because it contains $host paths and files. If cross-
9035 # compiling, it, like the target executable, must be
9036 # executed on the $host or under an emulation environment.
9038 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9042 # Now, create the wrapper script for func_source use:
9043 func_ltwrapper_scriptname $cwrapper
9044 $RM $func_ltwrapper_scriptname_result
9045 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9047 # note: this script will not be executed, so do not chmod.
9048 if test "x$build" = "x$host" ; then
9049 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9051 func_emit_wrapper no > $func_ltwrapper_scriptname_result
9057 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9059 func_emit_wrapper no > $output
9068 # See if we need to build an old-fashioned archive.
9069 for oldlib in $oldlibs; do
9071 if test "$build_libtool_libs" = convenience; then
9072 oldobjs="$libobjs_save $symfileobj"
9073 addlibs="$convenience"
9074 build_libtool_libs=no
9076 if test "$build_libtool_libs" = module; then
9077 oldobjs="$libobjs_save"
9078 build_libtool_libs=no
9080 oldobjs="$old_deplibs $non_pic_objects"
9081 if test "$preload" = yes && test -f "$symfileobj"; then
9082 func_append oldobjs " $symfileobj"
9085 addlibs="$old_convenience"
9088 if test -n "$addlibs"; then
9089 gentop="$output_objdir/${outputname}x"
9090 func_append generated " $gentop"
9092 func_extract_archives $gentop $addlibs
9093 func_append oldobjs " $func_extract_archives_result"
9096 # Do each command in the archive commands.
9097 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9098 cmds=$old_archive_from_new_cmds
9101 # Add any objects from preloaded convenience libraries
9102 if test -n "$dlprefiles"; then
9103 gentop="$output_objdir/${outputname}x"
9104 func_append generated " $gentop"
9106 func_extract_archives $gentop $dlprefiles
9107 func_append oldobjs " $func_extract_archives_result"
9110 # POSIX demands no paths to be encoded in archives. We have
9111 # to avoid creating archives with duplicate basenames if we
9112 # might have to extract them afterwards, e.g., when creating a
9113 # static archive out of a convenience library, or when linking
9114 # the entirety of a libtool archive into another (currently
9115 # not supported by libtool).
9116 if (for obj in $oldobjs
9118 func_basename "$obj"
9119 $ECHO "$func_basename_result"
9120 done | sort | sort -uc >/dev/null 2>&1); then
9123 echo "copying selected object files to avoid basename conflicts..."
9124 gentop="$output_objdir/${outputname}x"
9125 func_append generated " $gentop"
9126 func_mkdir_p "$gentop"
9127 save_oldobjs=$oldobjs
9130 for obj in $save_oldobjs
9132 func_basename "$obj"
9133 objbase="$func_basename_result"
9134 case " $oldobjs " in
9135 " ") oldobjs=$obj ;;
9138 # Make sure we don't pick an alternate name that also
9140 newobj=lt$counter-$objbase
9141 func_arith $counter + 1
9142 counter=$func_arith_result
9143 case " $oldobjs " in
9144 *[\ /]"$newobj "*) ;;
9145 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9148 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9149 func_append oldobjs " $gentop/$newobj"
9151 *) func_append oldobjs " $obj" ;;
9155 eval cmds=\"$old_archive_cmds\"
9158 len=$func_len_result
9159 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9160 cmds=$old_archive_cmds
9161 elif test -n "$archiver_list_spec"; then
9162 func_verbose "using command file archive linking..."
9165 func_to_tool_file "$obj"
9166 $ECHO "$func_to_tool_file_result"
9167 done > $output_objdir/$libname.libcmd
9168 func_to_tool_file "$output_objdir/$libname.libcmd"
9169 oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9170 cmds=$old_archive_cmds
9172 # the command line is too long to link in one step, link in parts
9173 func_verbose "using piecewise archive linking..."
9178 save_oldobjs=$oldobjs
9180 # Is there a better way of finding the last object in the list?
9181 for obj in $save_oldobjs
9185 eval test_cmds=\"$old_archive_cmds\"
9186 func_len " $test_cmds"
9187 len0=$func_len_result
9189 for obj in $save_oldobjs
9192 func_arith $len + $func_len_result
9193 len=$func_arith_result
9194 func_append objlist " $obj"
9195 if test "$len" -lt "$max_cmd_len"; then
9198 # the above command should be used before it gets too long
9200 if test "$obj" = "$last_oldobj" ; then
9203 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9204 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9211 if test "X$oldobjs" = "X" ; then
9212 eval cmds=\"\$concat_cmds\"
9214 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9218 func_execute_cmds "$cmds" 'exit $?'
9221 test -n "$generated" && \
9222 func_show_eval "${RM}r$generated"
9224 # Now create the libtool archive.
9228 test "$build_old_libs" = yes && old_library="$libname.$libext"
9229 func_verbose "creating $output"
9231 # Preserve any variables that may affect compiler behavior
9232 for var in $variables_saved_for_relink; do
9233 if eval test -z \"\${$var+set}\"; then
9234 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9235 elif eval var_value=\$$var; test -z "$var_value"; then
9236 relink_command="$var=; export $var; $relink_command"
9238 func_quote_for_eval "$var_value"
9239 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9242 # Quote the link command for shipping.
9243 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9244 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9245 if test "$hardcode_automatic" = yes ; then
9249 # Only create the output if not a dry run.
9251 for installed in no yes; do
9252 if test "$installed" = yes; then
9253 if test -z "$install_libdir"; then
9256 output="$output_objdir/$outputname"i
9257 # Replace all uninstalled libtool libraries with the installed ones
9259 for deplib in $dependency_libs; do
9262 func_basename "$deplib"
9263 name="$func_basename_result"
9264 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9265 test -z "$libdir" && \
9266 func_fatal_error "\`$deplib' is not a valid libtool archive"
9267 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9270 func_stripname -L '' "$deplib"
9271 func_replace_sysroot "$func_stripname_result"
9272 func_append newdependency_libs " -L$func_replace_sysroot_result"
9275 func_stripname -R '' "$deplib"
9276 func_replace_sysroot "$func_stripname_result"
9277 func_append newdependency_libs " -R$func_replace_sysroot_result"
9279 *) func_append newdependency_libs " $deplib" ;;
9282 dependency_libs="$newdependency_libs"
9285 for lib in $dlfiles; do
9288 func_basename "$lib"
9289 name="$func_basename_result"
9290 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9291 test -z "$libdir" && \
9292 func_fatal_error "\`$lib' is not a valid libtool archive"
9293 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9295 *) func_append newdlfiles " $lib" ;;
9298 dlfiles="$newdlfiles"
9300 for lib in $dlprefiles; do
9303 # Only pass preopened files to the pseudo-archive (for
9304 # eventual linking with the app. that links it) if we
9305 # didn't already link the preopened objects directly into
9307 func_basename "$lib"
9308 name="$func_basename_result"
9309 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310 test -z "$libdir" && \
9311 func_fatal_error "\`$lib' is not a valid libtool archive"
9312 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9316 dlprefiles="$newdlprefiles"
9319 for lib in $dlfiles; do
9321 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9322 *) abs=`pwd`"/$lib" ;;
9324 func_append newdlfiles " $abs"
9326 dlfiles="$newdlfiles"
9328 for lib in $dlprefiles; do
9330 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9331 *) abs=`pwd`"/$lib" ;;
9333 func_append newdlprefiles " $abs"
9335 dlprefiles="$newdlprefiles"
9338 # place dlname in correct position for cygwin
9339 # In fact, it would be nice if we could use this code for all target
9340 # systems that can't hard-code library paths into their executables
9341 # and that have no shared library path variable independent of PATH,
9342 # but it turns out we can't easily determine that from inspecting
9343 # libtool variables, so we have to hard-code the OSs to which it
9344 # applies here; at the moment, that means platforms that use the PE
9345 # object format with DLL files. See the long comment at the top of
9346 # tests/bindir.at for full details.
9348 case $host,$output,$installed,$module,$dlname in
9349 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9350 # If a -bindir argument was supplied, place the dll there.
9351 if test "x$bindir" != x ;
9353 func_relative_path "$install_libdir" "$bindir"
9354 tdlname=$func_relative_path_result$dlname
9356 # Otherwise fall back on heuristic.
9357 tdlname=../bin/$dlname
9362 # $outputname - a libtool library file
9363 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9365 # Please DO NOT delete this file!
9366 # It is necessary for linking the library.
9368 # The name that we can dlopen(3).
9371 # Names of this library.
9372 library_names='$library_names'
9374 # The name of the static archive.
9375 old_library='$old_library'
9377 # Linker flags that can not go in dependency_libs.
9378 inherited_linker_flags='$new_inherited_linker_flags'
9380 # Libraries that this one depends upon.
9381 dependency_libs='$dependency_libs'
9383 # Names of additional weak libraries provided by this library
9384 weak_library_names='$weak_libs'
9386 # Version information for $libname.
9391 # Is this an already installed library?
9392 installed=$installed
9394 # Should we warn about portability when linking against -modules?
9395 shouldnotlink=$module
9397 # Files to dlopen/dlpreopen
9399 dlpreopen='$dlprefiles'
9401 # Directory that this library needs to be installed in:
9402 libdir='$install_libdir'"
9403 if test "$installed" = no && test "$need_relink" = yes; then
9405 relink_command=\"$relink_command\""
9410 # Do a symbolic link so that the libtool archive can be found in
9411 # LD_LIBRARY_PATH before the program is installed.
9412 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9418 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9419 func_mode_link ${1+"$@"}
9422 # func_mode_uninstall arg...
9423 func_mode_uninstall ()
9431 # This variable tells wrapper scripts just to set variables rather
9432 # than running their programs.
9433 libtool_install_magic="$magic"
9438 -f) func_append RM " $arg"; rmforce=yes ;;
9439 -*) func_append RM " $arg" ;;
9440 *) func_append files " $arg" ;;
9445 func_fatal_help "you must specify an RM program"
9449 for file in $files; do
9450 func_dirname "$file" "" "."
9451 dir="$func_dirname_result"
9452 if test "X$dir" = X.; then
9457 func_basename "$file"
9458 name="$func_basename_result"
9459 test "$opt_mode" = uninstall && odir="$dir"
9461 # Remember odir for removal later, being careful to avoid duplicates
9462 if test "$opt_mode" = clean; then
9465 *) func_append rmdirs " $odir" ;;
9469 # Don't error if the file doesn't exist and rm -f was used.
9470 if { test -L "$file"; } >/dev/null 2>&1 ||
9471 { test -h "$file"; } >/dev/null 2>&1 ||
9472 test -f "$file"; then
9474 elif test -d "$file"; then
9477 elif test "$rmforce" = yes; then
9485 # Possibly a libtool archive, so verify it.
9486 if func_lalib_p "$file"; then
9487 func_source $dir/$name
9489 # Delete the libtool libraries and symlinks.
9490 for n in $library_names; do
9491 func_append rmfiles " $odir/$n"
9493 test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9497 case " $library_names " in
9499 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9501 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9504 if test -n "$library_names"; then
9505 # Do each command in the postuninstall commands.
9506 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9509 if test -n "$old_library"; then
9510 # Do each command in the old_postuninstall commands.
9511 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9513 # FIXME: should reinstall the best remaining shared library.
9520 # Possibly a libtool object, so verify it.
9521 if func_lalib_p "$file"; then
9524 func_source $dir/$name
9526 # Add PIC object to the list of files to remove.
9527 if test -n "$pic_object" &&
9528 test "$pic_object" != none; then
9529 func_append rmfiles " $dir/$pic_object"
9532 # Add non-PIC object to the list of files to remove.
9533 if test -n "$non_pic_object" &&
9534 test "$non_pic_object" != none; then
9535 func_append rmfiles " $dir/$non_pic_object"
9541 if test "$opt_mode" = clean ; then
9545 func_stripname '' '.exe' "$file"
9546 file=$func_stripname_result
9547 func_stripname '' '.exe' "$name"
9548 noexename=$func_stripname_result
9549 # $file with .exe has already been added to rmfiles,
9550 # add $file without .exe
9551 func_append rmfiles " $file"
9554 # Do a test to see if this is a libtool program.
9555 if func_ltwrapper_p "$file"; then
9556 if func_ltwrapper_executable_p "$file"; then
9557 func_ltwrapper_scriptname "$file"
9559 func_source $func_ltwrapper_scriptname_result
9560 func_append rmfiles " $func_ltwrapper_scriptname_result"
9563 func_source $dir/$noexename
9566 # note $name still contains .exe if it was in $file originally
9567 # as does the version of $file that was added into $rmfiles
9568 func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9569 if test "$fast_install" = yes && test -n "$relink_command"; then
9570 func_append rmfiles " $odir/lt-$name"
9572 if test "X$noexename" != "X$name" ; then
9573 func_append rmfiles " $odir/lt-${noexename}.c"
9579 func_show_eval "$RM $rmfiles" 'exit_status=1'
9582 # Try to remove the ${objdir}s in the directories where we deleted files
9583 for dir in $rmdirs; do
9584 if test -d "$dir"; then
9585 func_show_eval "rmdir $dir >/dev/null 2>&1"
9592 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9593 func_mode_uninstall ${1+"$@"}
9595 test -z "$opt_mode" && {
9596 help="$generic_help"
9597 func_fatal_help "you must specify a MODE"
9600 test -z "$exec_cmd" && \
9601 func_fatal_help "invalid operation mode \`$opt_mode'"
9603 if test -n "$exec_cmd"; then
9604 eval exec "$exec_cmd"
9611 # The TAGs below are defined such that we never get into a situation
9612 # in which we disable both kinds of libraries. Given conflicting
9613 # choices, we go for a static library, that is the most portable,
9614 # since we can't tell whether shared libraries were disabled because
9615 # the user asked for that or because the platform doesn't support
9616 # them. This is particularly important on AIX, because we don't
9617 # support having both static and shared libraries enabled at the same
9618 # time on that platform, so we default to a shared-only configuration.
9619 # If a disable-shared tag is given, we'll fallback to a static-only
9620 # configuration. But we'll never go from static-only to shared-only.
9622 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9623 build_libtool_libs=no
9625 # ### END LIBTOOL TAG CONFIG: disable-shared
9627 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9628 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9629 # ### END LIBTOOL TAG CONFIG: disable-static