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'}
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 -soname SONAME override the standard shared object name
2432 -static do not do any dynamic linking of uninstalled libtool libraries
2433 -static-libtool-libs
2434 do not do any dynamic linking of libtool libraries
2435 -version-info CURRENT[:REVISION[:AGE]]
2436 specify library version info [each variable defaults to 0]
2437 -weak LIBNAME declare that the target provides the LIBNAME interface
2439 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2441 -Xlinker FLAG pass linker-specific FLAG directly to the linker
2442 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2444 All other options (arguments beginning with \`-') are ignored.
2446 Every other argument is treated as a filename. Files ending in \`.la' are
2447 treated as uninstalled libtool libraries, other files are standard or library
2450 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2451 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2452 required, except when creating a convenience library.
2454 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2455 using \`ar' and \`ranlib', or on Windows using \`lib'.
2457 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2458 is created, otherwise an executable program is created."
2463 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2465 Remove libraries from an installation directory.
2467 RM is the name of the program to use to delete files associated with each FILE
2468 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2471 If FILE is a libtool library, all the files associated with it are deleted.
2472 Otherwise, only FILE itself is deleted using RM."
2476 func_fatal_help "invalid operation mode \`$opt_mode'"
2481 $ECHO "Try \`$progname --help' for more information about other modes."
2484 # Now that we've collected a possible --mode arg, show help if necessary
2486 if test "$opt_help" = :; then
2491 for opt_mode in compile link execute install finish uninstall clean; do
2494 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
2497 for opt_mode in compile link execute install finish uninstall clean; do
2503 /^When reporting/,/^Report/{
2508 /information about other modes/d
2509 /more detailed .*MODE/d
2510 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2516 # func_mode_execute arg...
2517 func_mode_execute ()
2520 # The first argument is the command name.
2523 func_fatal_help "you must specify a COMMAND"
2525 # Handle -dlopen flags immediately.
2526 for file in $opt_dlopen; do
2528 || func_fatal_help "\`$file' is not a file"
2533 func_resolve_sysroot "$file"
2534 file=$func_resolve_sysroot_result
2536 # Check to see that this really is a libtool archive.
2537 func_lalib_unsafe_p "$file" \
2538 || func_fatal_help "\`$lib' is not a valid libtool archive"
2540 # Read the libtool library.
2545 # Skip this library if it cannot be dlopened.
2546 if test -z "$dlname"; then
2547 # Warn if it was a shared library.
2548 test -n "$library_names" && \
2549 func_warning "\`$file' was not linked with \`-export-dynamic'"
2553 func_dirname "$file" "" "."
2554 dir="$func_dirname_result"
2556 if test -f "$dir/$objdir/$dlname"; then
2557 func_append dir "/$objdir"
2559 if test ! -f "$dir/$dlname"; then
2560 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2566 # Just add the directory containing the .lo file.
2567 func_dirname "$file" "" "."
2568 dir="$func_dirname_result"
2572 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2577 # Get the absolute pathname.
2578 absdir=`cd "$dir" && pwd`
2579 test -n "$absdir" && dir="$absdir"
2581 # Now add the directory to shlibpath_var.
2582 if eval "test -z \"\$$shlibpath_var\""; then
2583 eval "$shlibpath_var=\"\$dir\""
2585 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2589 # This variable tells wrapper scripts just to set shlibpath_var
2590 # rather than running their programs.
2591 libtool_execute_magic="$magic"
2593 # Check if any of the arguments is a wrapper script.
2598 -* | *.la | *.lo ) ;;
2600 # Do a test to see if this is really a libtool program.
2601 if func_ltwrapper_script_p "$file"; then
2603 # Transform arg to wrapped name.
2604 file="$progdir/$program"
2605 elif func_ltwrapper_executable_p "$file"; then
2606 func_ltwrapper_scriptname "$file"
2607 func_source "$func_ltwrapper_scriptname_result"
2608 # Transform arg to wrapped name.
2609 file="$progdir/$program"
2613 # Quote arguments (to preserve shell metacharacters).
2614 func_append_quoted args "$file"
2617 if test "X$opt_dry_run" = Xfalse; then
2618 if test -n "$shlibpath_var"; then
2619 # Export the shlibpath_var.
2620 eval "export $shlibpath_var"
2623 # Restore saved environment variables
2624 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2626 eval "if test \"\${save_$lt_var+set}\" = set; then
2627 $lt_var=\$save_$lt_var; export $lt_var
2633 # Now prepare to actually exec the command.
2634 exec_cmd="\$cmd$args"
2636 # Display what would be done.
2637 if test -n "$shlibpath_var"; then
2638 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2639 echo "export $shlibpath_var"
2646 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2649 # func_mode_finish arg...
2657 for opt in "$nonopt" ${1+"$@"}
2659 if test -d "$opt"; then
2660 func_append libdirs " $opt"
2662 elif test -f "$opt"; then
2663 if func_lalib_unsafe_p "$opt"; then
2664 func_append libs " $opt"
2666 func_warning "\`$opt' is not a valid libtool archive"
2670 func_fatal_error "invalid argument \`$opt'"
2674 if test -n "$libs"; then
2675 if test -n "$lt_sysroot"; then
2676 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2677 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2682 # Remove sysroot references
2683 if $opt_dry_run; then
2684 for lib in $libs; do
2685 echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2688 tmpdir=`func_mktempdir`
2689 for lib in $libs; do
2690 sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2692 mv -f $tmpdir/tmp-la $lib
2698 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2699 for libdir in $libdirs; do
2700 if test -n "$finish_cmds"; then
2701 # Do each command in the finish commands.
2702 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2705 if test -n "$finish_eval"; then
2706 # Do the single finish_eval.
2707 eval cmds=\"$finish_eval\"
2708 $opt_dry_run || eval "$cmds" || func_append admincmds "
2714 # Exit here if they wanted silent mode.
2715 $opt_silent && exit $EXIT_SUCCESS
2717 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2718 echo "----------------------------------------------------------------------"
2719 echo "Libraries have been installed in:"
2720 for libdir in $libdirs; do
2724 echo "If you ever happen to want to link against installed libraries"
2725 echo "in a given directory, LIBDIR, you must either use libtool, and"
2726 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2727 echo "flag during linking and do at least one of the following:"
2728 if test -n "$shlibpath_var"; then
2729 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2730 echo " during execution"
2732 if test -n "$runpath_var"; then
2733 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2734 echo " during linking"
2736 if test -n "$hardcode_libdir_flag_spec"; then
2738 eval flag=\"$hardcode_libdir_flag_spec\"
2740 $ECHO " - use the \`$flag' linker flag"
2742 if test -n "$admincmds"; then
2743 $ECHO " - have your system administrator run these commands:$admincmds"
2745 if test -f /etc/ld.so.conf; then
2746 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2750 echo "See any operating system documentation about shared libraries for"
2752 solaris2.[6789]|solaris2.1[0-9])
2753 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2757 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2760 echo "----------------------------------------------------------------------"
2765 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2768 # func_mode_install arg...
2769 func_mode_install ()
2772 # There may be an optional sh(1) argument at the beginning of
2773 # install_prog (especially on Windows NT).
2774 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2775 # Allow the use of GNU shtool's install command.
2776 case $nonopt in *shtool*) :;; *) false;; esac; then
2777 # Aesthetically quote it.
2778 func_quote_for_eval "$nonopt"
2779 install_prog="$func_quote_for_eval_result "
2787 # The real first argument should be the name of the installation program.
2788 # Aesthetically quote it.
2789 func_quote_for_eval "$arg"
2790 func_append install_prog "$func_quote_for_eval_result"
2791 install_shared_prog=$install_prog
2792 case " $install_prog " in
2793 *[\\\ /]cp\ *) install_cp=: ;;
2794 *) install_cp=false ;;
2797 # We need to accept at least all the BSD install flags.
2809 if test -n "$dest"; then
2810 func_append files " $dest"
2818 if $install_cp; then :; else
2832 # If the previous option needed an argument, then skip it.
2833 if test -n "$prev"; then
2834 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2835 arg2=$install_override_mode
2846 # Aesthetically quote the argument.
2847 func_quote_for_eval "$arg"
2848 func_append install_prog " $func_quote_for_eval_result"
2849 if test -n "$arg2"; then
2850 func_quote_for_eval "$arg2"
2852 func_append install_shared_prog " $func_quote_for_eval_result"
2855 test -z "$install_prog" && \
2856 func_fatal_help "you must specify an install program"
2858 test -n "$prev" && \
2859 func_fatal_help "the \`$prev' option requires an argument"
2861 if test -n "$install_override_mode" && $no_mode; then
2862 if $install_cp; then :; else
2863 func_quote_for_eval "$install_override_mode"
2864 func_append install_shared_prog " -m $func_quote_for_eval_result"
2868 if test -z "$files"; then
2869 if test -z "$dest"; then
2870 func_fatal_help "no file or destination specified"
2872 func_fatal_help "you must specify a destination"
2876 # Strip any trailing slash from the destination.
2877 func_stripname '' '/' "$dest"
2878 dest=$func_stripname_result
2880 # Check to see that the destination is a directory.
2881 test -d "$dest" && isdir=yes
2882 if test "$isdir" = yes; then
2886 func_dirname_and_basename "$dest" "" "."
2887 destdir="$func_dirname_result"
2888 destname="$func_basename_result"
2890 # Not a directory, so check to see that there is only one file specified.
2891 set dummy $files; shift
2892 test "$#" -gt 1 && \
2893 func_fatal_help "\`$dest' is not a directory"
2896 [\\/]* | [A-Za-z]:[\\/]*) ;;
2898 for file in $files; do
2902 func_fatal_help "\`$destdir' must be an absolute directory name"
2909 # This variable tells wrapper scripts just to set variables rather
2910 # than running their programs.
2911 libtool_install_magic="$magic"
2916 for file in $files; do
2918 # Do each installation.
2921 # Do the static libraries later.
2922 func_append staticlibs " $file"
2926 func_resolve_sysroot "$file"
2927 file=$func_resolve_sysroot_result
2929 # Check to see that this really is a libtool archive.
2930 func_lalib_unsafe_p "$file" \
2931 || func_fatal_help "\`$file' is not a valid libtool archive"
2938 # Add the libdir to current_libdirs if it is the destination.
2939 if test "X$destdir" = "X$libdir"; then
2940 case "$current_libdirs " in
2942 *) func_append current_libdirs " $libdir" ;;
2945 # Note the libdir as a future libdir.
2946 case "$future_libdirs " in
2948 *) func_append future_libdirs " $libdir" ;;
2952 func_dirname "$file" "/" ""
2953 dir="$func_dirname_result"
2954 func_append dir "$objdir"
2956 if test -n "$relink_command"; then
2957 # Determine the prefix the user has applied to our future dir.
2958 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2960 # Don't allow the user to place us outside of our expected
2961 # location b/c this prevents finding dependent libraries that
2962 # are installed to the same prefix.
2963 # At present, this check doesn't affect windows .dll's that
2964 # are installed into $libdir/../bin (currently, that works fine)
2965 # but it's something to keep an eye on.
2966 test "$inst_prefix_dir" = "$destdir" && \
2967 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2969 if test -n "$inst_prefix_dir"; then
2970 # Stick the inst_prefix_dir data into the link command.
2971 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2973 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2976 func_warning "relinking \`$file'"
2977 func_show_eval "$relink_command" \
2978 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2981 # See the names of the shared library.
2982 set dummy $library_names; shift
2983 if test -n "$1"; then
2988 test -n "$relink_command" && srcname="$realname"T
2990 # Install the shared library and build the symlinks.
2991 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2995 cygwin* | mingw* | pw32* | cegcc*)
3003 if test -n "$tstripme" && test -n "$striplib"; then
3004 func_show_eval "$striplib $destdir/$realname" 'exit $?'
3007 if test "$#" -gt 0; then
3008 # Delete the old symlinks, and create new ones.
3009 # Try `ln -sf' first, because the `ln' binary might depend on
3010 # the symlink we replace! Solaris /bin/ln does not understand -f,
3011 # so we also need to try rm && ln -s.
3014 test "$linkname" != "$realname" \
3015 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3019 # Do each command in the postinstall commands.
3020 lib="$destdir/$realname"
3021 func_execute_cmds "$postinstall_cmds" 'exit $?'
3024 # Install the pseudo-library for information purposes.
3025 func_basename "$file"
3026 name="$func_basename_result"
3027 instname="$dir/$name"i
3028 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3030 # Maybe install the static library, too.
3031 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3035 # Install (i.e. copy) a libtool object.
3037 # Figure out destination file name, if it wasn't already specified.
3038 if test -n "$destname"; then
3039 destfile="$destdir/$destname"
3041 func_basename "$file"
3042 destfile="$func_basename_result"
3043 destfile="$destdir/$destfile"
3046 # Deduce the name of the destination old-style object file.
3049 func_lo2o "$destfile"
3050 staticdest=$func_lo2o_result
3053 staticdest="$destfile"
3057 func_fatal_help "cannot copy a libtool object to \`$destfile'"
3061 # Install the libtool object if requested.
3062 test -n "$destfile" && \
3063 func_show_eval "$install_prog $file $destfile" 'exit $?'
3065 # Install the old object if enabled.
3066 if test "$build_old_libs" = yes; then
3067 # Deduce the name of the old-style object file.
3069 staticobj=$func_lo2o_result
3070 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3076 # Figure out destination file name, if it wasn't already specified.
3077 if test -n "$destname"; then
3078 destfile="$destdir/$destname"
3080 func_basename "$file"
3081 destfile="$func_basename_result"
3082 destfile="$destdir/$destfile"
3085 # If the file is missing, and there is a .exe on the end, strip it
3086 # because it is most likely a libtool script we actually want to
3091 if test ! -f "$file"; then
3092 func_stripname '' '.exe' "$file"
3093 file=$func_stripname_result
3099 # Do a test to see if this is really a libtool program.
3102 if func_ltwrapper_executable_p "$file"; then
3103 func_ltwrapper_scriptname "$file"
3104 wrapper=$func_ltwrapper_scriptname_result
3106 func_stripname '' '.exe' "$file"
3107 wrapper=$func_stripname_result
3114 if func_ltwrapper_script_p "$wrapper"; then
3118 func_source "$wrapper"
3120 # Check the variables that should have been set.
3121 test -z "$generated_by_libtool_version" && \
3122 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3125 for lib in $notinst_deplibs; do
3126 # Check to see that each library is installed.
3128 if test -f "$lib"; then
3131 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3132 if test -n "$libdir" && test ! -f "$libfile"; then
3133 func_warning "\`$lib' has not been installed in \`$libdir'"
3139 func_source "$wrapper"
3142 if test "$fast_install" = no && test -n "$relink_command"; then
3144 if test "$finalize" = yes; then
3145 tmpdir=`func_mktempdir`
3146 func_basename "$file$stripped_ext"
3147 file="$func_basename_result"
3148 outputname="$tmpdir/$file"
3149 # Replace the output file specification.
3150 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3153 func_quote_for_expand "$relink_command"
3154 eval "func_echo $func_quote_for_expand_result"
3156 if eval "$relink_command"; then :
3158 func_error "error: relink \`$file' with the above command before installing it"
3159 $opt_dry_run || ${RM}r "$tmpdir"
3164 func_warning "cannot relink \`$file'"
3168 # Install the binary that we compiled earlier.
3169 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3173 # remove .exe since cygwin /usr/bin/install will append another
3175 case $install_prog,$host in
3176 */usr/bin/install*,*cygwin*)
3177 case $file:$destfile in
3182 destfile=$destfile.exe
3185 func_stripname '' '.exe' "$destfile"
3186 destfile=$func_stripname_result
3191 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3192 $opt_dry_run || if test -n "$outputname"; then
3199 for file in $staticlibs; do
3200 func_basename "$file"
3201 name="$func_basename_result"
3203 # Set up the ranlib parameters.
3204 oldlib="$destdir/$name"
3206 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3208 if test -n "$stripme" && test -n "$old_striplib"; then
3209 func_show_eval "$old_striplib $oldlib" 'exit $?'
3212 # Do each command in the postinstall commands.
3213 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3216 test -n "$future_libdirs" && \
3217 func_warning "remember to run \`$progname --finish$future_libdirs'"
3219 if test -n "$current_libdirs"; then
3220 # Maybe just do a dry run.
3221 $opt_dry_run && current_libdirs=" -n$current_libdirs"
3222 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3228 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3231 # func_generate_dlsyms outputname originator pic_p
3232 # Extract symbols from dlprefiles and create ${outputname}S.o with
3233 # a dlpreopen symbol table.
3234 func_generate_dlsyms ()
3240 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3243 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3244 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3245 my_dlsyms="${my_outputname}S.c"
3247 func_error "not configured to extract global symbols from dlpreopened files"
3251 if test -n "$my_dlsyms"; then
3255 # Discover the nlist of each of the dlfiles.
3256 nlist="$output_objdir/${my_outputname}.nm"
3258 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3260 # Parse the name list into a source file.
3261 func_verbose "creating $output_objdir/$my_dlsyms"
3263 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3264 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3265 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3271 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3272 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3275 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3276 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3277 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3278 relocations are performed -- see ld's documentation on pseudo-relocs. */
3279 # define LT_DLSYM_CONST
3280 #elif defined(__osf__)
3281 /* This system does not cope well with relocations in const data. */
3282 # define LT_DLSYM_CONST
3284 # define LT_DLSYM_CONST const
3287 /* External symbol declarations for the compiler. */\
3290 if test "$dlself" = yes; then
3291 func_verbose "generating symbol list for \`$output'"
3293 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3295 # Add our own program objects to the symbol list.
3296 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3297 for progfile in $progfiles; do
3298 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3299 func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3300 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3303 if test -n "$exclude_expsyms"; then
3305 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3306 eval '$MV "$nlist"T "$nlist"'
3310 if test -n "$export_symbols_regex"; then
3312 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3313 eval '$MV "$nlist"T "$nlist"'
3317 # Prepare the list of exported symbols
3318 if test -z "$export_symbols"; then
3319 export_symbols="$output_objdir/$outputname.exp"
3322 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3324 *cygwin* | *mingw* | *cegcc* )
3325 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3326 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3332 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3333 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3334 eval '$MV "$nlist"T "$nlist"'
3336 *cygwin* | *mingw* | *cegcc* )
3337 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3338 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3345 for dlprefile in $dlprefiles; do
3346 func_verbose "extracting global C symbols from \`$dlprefile'"
3347 func_basename "$dlprefile"
3348 name="$func_basename_result"
3350 *cygwin* | *mingw* | *cegcc* )
3351 # if an import library, we need to obtain dlname
3352 if func_win32_import_lib_p "$dlprefile"; then
3353 func_tr_sh "$dlprefile"
3354 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3355 dlprefile_dlbasename=""
3356 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3357 # Use subshell, to avoid clobbering current variable values
3358 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3359 if test -n "$dlprefile_dlname" ; then
3360 func_basename "$dlprefile_dlname"
3361 dlprefile_dlbasename="$func_basename_result"
3363 # no lafile. user explicitly requested -dlpreopen <import library>.
3364 $sharedlib_from_linklib_cmd "$dlprefile"
3365 dlprefile_dlbasename=$sharedlib_from_linklib_result
3369 if test -n "$dlprefile_dlbasename" ; then
3370 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3372 func_warning "Could not compute DLL name from $name"
3373 eval '$ECHO ": $name " >> "$nlist"'
3375 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3376 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3377 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3379 else # not an import lib
3381 eval '$ECHO ": $name " >> "$nlist"'
3382 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3383 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3389 eval '$ECHO ": $name " >> "$nlist"'
3390 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3391 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3398 # Make sure we have at least an empty file.
3399 test -f "$nlist" || : > "$nlist"
3401 if test -n "$exclude_expsyms"; then
3402 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3403 $MV "$nlist"T "$nlist"
3406 # Try sorting and uniquifying the output.
3407 if $GREP -v "^: " < "$nlist" |
3408 if sort -k 3 </dev/null >/dev/null 2>&1; then
3413 uniq > "$nlist"S; then
3416 $GREP -v "^: " < "$nlist" > "$nlist"S
3419 if test -f "$nlist"S; then
3420 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3422 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3425 echo >> "$output_objdir/$my_dlsyms" "\
3427 /* The mapping between symbol names and symbols. */
3432 extern LT_DLSYM_CONST lt_dlsymlist
3433 lt_${my_prefix}_LTX_preloaded_symbols[];
3434 LT_DLSYM_CONST lt_dlsymlist
3435 lt_${my_prefix}_LTX_preloaded_symbols[] =
3437 { \"$my_originator\", (void *) 0 },"
3439 case $need_lib_prefix in
3441 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3444 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3447 echo >> "$output_objdir/$my_dlsyms" "\
3451 /* This works around a problem in FreeBSD linker */
3452 #ifdef FREEBSD_WORKAROUND
3453 static const void *lt_preloaded_setup() {
3454 return lt_${my_prefix}_LTX_preloaded_symbols;
3464 pic_flag_for_symtable=
3465 case "$compile_command " in
3469 # compiling the symbol table file with pic_flag works around
3470 # a FreeBSD bug that causes programs to crash when -lm is
3471 # linked before any other PIC object. But we must not use
3472 # pic_flag when linking with -static. The problem exists in
3473 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3474 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3475 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3477 pic_flag_for_symtable=" $pic_flag" ;;
3479 if test "X$my_pic_p" != Xno; then
3480 pic_flag_for_symtable=" $pic_flag"
3487 for arg in $LTCFLAGS; do
3489 -pie | -fpie | -fPIE) ;;
3490 *) func_append symtab_cflags " $arg" ;;
3494 # Now compile the dynamic symbol file.
3495 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3497 # Clean up the generated files.
3498 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3500 # Transform the symbol file into the correct name.
3501 symfileobj="$output_objdir/${my_outputname}S.$objext"
3503 *cygwin* | *mingw* | *cegcc* )
3504 if test -f "$output_objdir/$my_outputname.def"; then
3505 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3506 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3509 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3514 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3519 func_fatal_error "unknown suffix for \`$my_dlsyms'"
3523 # We keep going just in case the user didn't refer to
3524 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3525 # really was required.
3527 # Nullify the symbol file.
3528 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3529 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3533 # func_win32_libid arg
3534 # return the library type of file 'arg'
3536 # Need a lot of goo to handle *both* DLLs and import libs
3537 # Has to be a shell function in order to 'eat' the argument
3538 # that is supplied when $file_magic_command is called.
3539 # Despite the name, also deal with 64 bit binaries.
3543 win32_libid_type="unknown"
3544 win32_fileres=`file -L $1 2>/dev/null`
3545 case $win32_fileres in
3546 *ar\ archive\ import\ library*) # definitely import
3547 win32_libid_type="x86 archive import"
3549 *ar\ archive*) # could be an import, or static
3550 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3551 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3552 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3553 func_to_tool_file "$1" func_convert_file_msys_to_w32
3554 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3563 case $win32_nmres in
3564 import*) win32_libid_type="x86 archive import";;
3565 *) win32_libid_type="x86 archive static";;
3570 win32_libid_type="x86 DLL"
3572 *executable*) # but shell scripts are "executable" too...
3573 case $win32_fileres in
3574 *MS\ Windows\ PE\ Intel*)
3575 win32_libid_type="x86 DLL"
3580 $ECHO "$win32_libid_type"
3583 # func_cygming_dll_for_implib ARG
3585 # Platform-specific function to extract the
3586 # name of the DLL associated with the specified
3587 # import library ARG.
3588 # Invoked by eval'ing the libtool variable
3589 # $sharedlib_from_linklib_cmd
3590 # Result is available in the variable
3591 # $sharedlib_from_linklib_result
3592 func_cygming_dll_for_implib ()
3595 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3598 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3600 # The is the core of a fallback implementation of a
3601 # platform-specific function to extract the name of the
3602 # DLL associated with the specified import library LIBNAME.
3604 # SECTION_NAME is either .idata$6 or .idata$7, depending
3605 # on the platform and compiler that created the implib.
3607 # Echos the name of the DLL associated with the
3608 # specified import library.
3609 func_cygming_dll_for_implib_fallback_core ()
3612 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3613 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3614 $SED '/^Contents of section '"$match_literal"':/{
3615 # Place marker at beginning of archive member dllname section
3620 # These lines can sometimes be longer than 43 characters, but
3621 # are always uninteresting
3622 /:[ ]*file format pe[i]\{,1\}-/d
3623 /^In archive [^:]*:/d
3624 # Ensure marker is printed
3626 # Remove all lines with less than 43 characters
3628 # From remaining lines, remove first 43 characters
3631 # Join marker and all lines until next marker into a single line
3632 /^====MARK====/ b para
3641 # Remove trailing dots and whitespace
3645 # we now have a list, one entry per line, of the stringified
3646 # contents of the appropriate section of all members of the
3647 # archive which possess that section. Heuristic: eliminate
3648 # all those which have a first or second character that is
3649 # a '.' (that is, objdump's representation of an unprintable
3650 # character.) This should work for all archives with less than
3651 # 0x302f exports -- but will fail for DLLs whose name actually
3652 # begins with a literal '.' or a single character followed by
3655 # Of those that remain, print the first one.
3656 $SED -e '/^\./d;/^.\./d;q'
3659 # func_cygming_gnu_implib_p ARG
3660 # This predicate returns with zero status (TRUE) if
3661 # ARG is a GNU/binutils-style import library. Returns
3662 # with nonzero status (FALSE) otherwise.
3663 func_cygming_gnu_implib_p ()
3666 func_to_tool_file "$1" func_convert_file_msys_to_w32
3667 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)$'`
3668 test -n "$func_cygming_gnu_implib_tmp"
3671 # func_cygming_ms_implib_p ARG
3672 # This predicate returns with zero status (TRUE) if
3673 # ARG is an MS-style import library. Returns
3674 # with nonzero status (FALSE) otherwise.
3675 func_cygming_ms_implib_p ()
3678 func_to_tool_file "$1" func_convert_file_msys_to_w32
3679 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3680 test -n "$func_cygming_ms_implib_tmp"
3683 # func_cygming_dll_for_implib_fallback ARG
3684 # Platform-specific function to extract the
3685 # name of the DLL associated with the specified
3686 # import library ARG.
3688 # This fallback implementation is for use when $DLLTOOL
3689 # does not support the --identify-strict option.
3690 # Invoked by eval'ing the libtool variable
3691 # $sharedlib_from_linklib_cmd
3692 # Result is available in the variable
3693 # $sharedlib_from_linklib_result
3694 func_cygming_dll_for_implib_fallback ()
3697 if func_cygming_gnu_implib_p "$1" ; then
3698 # binutils import library
3699 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3700 elif func_cygming_ms_implib_p "$1" ; then
3701 # ms-generated import library
3702 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3705 sharedlib_from_linklib_result=""
3710 # func_extract_an_archive dir oldlib
3711 func_extract_an_archive ()
3714 f_ex_an_ar_dir="$1"; shift
3715 f_ex_an_ar_oldlib="$1"
3716 if test "$lock_old_archive_extraction" = yes; then
3717 lockfile=$f_ex_an_ar_oldlib.lock
3718 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3719 func_echo "Waiting for $lockfile to be removed"
3723 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3724 'stat=$?; rm -f "$lockfile"; exit $stat'
3725 if test "$lock_old_archive_extraction" = yes; then
3726 $opt_dry_run || rm -f "$lockfile"
3728 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3731 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3736 # func_extract_archives gentop oldlib ...
3737 func_extract_archives ()
3740 my_gentop="$1"; shift
3741 my_oldlibs=${1+"$@"}
3747 for my_xlib in $my_oldlibs; do
3748 # Extract the objects.
3750 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3751 *) my_xabs=`pwd`"/$my_xlib" ;;
3753 func_basename "$my_xlib"
3754 my_xlib="$func_basename_result"
3757 case " $extracted_archives " in
3759 func_arith $extracted_serial + 1
3760 extracted_serial=$func_arith_result
3761 my_xlib_u=lt$extracted_serial-$my_xlib ;;
3765 extracted_archives="$extracted_archives $my_xlib_u"
3766 my_xdir="$my_gentop/$my_xlib_u"
3768 func_mkdir_p "$my_xdir"
3772 func_verbose "Extracting $my_xabs"
3773 # Do not bother doing anything if just a dry run
3775 darwin_orig_dir=`pwd`
3776 cd $my_xdir || exit $?
3777 darwin_archive=$my_xabs
3779 darwin_base_archive=`basename "$darwin_archive"`
3780 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3781 if test -n "$darwin_arches"; then
3782 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3784 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3785 for darwin_arch in $darwin_arches ; do
3786 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3787 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3788 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3791 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3792 done # $darwin_arches
3793 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3794 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3797 for darwin_file in $darwin_filelist; do
3798 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3799 $LIPO -create -output "$darwin_file" $darwin_files
3800 done # $darwin_filelist
3802 cd "$darwin_orig_dir"
3805 func_extract_an_archive "$my_xdir" "$my_xabs"
3810 func_extract_an_archive "$my_xdir" "$my_xabs"
3813 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3816 func_extract_archives_result="$my_oldobjs"
3820 # func_emit_wrapper [arg=no]
3822 # Emit a libtool wrapper script on stdout.
3823 # Don't directly open a file because we may want to
3824 # incorporate the script contents within a cygwin/mingw
3825 # wrapper executable. Must ONLY be called from within
3826 # func_mode_link because it depends on a number of variables
3829 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3830 # variable will take. If 'yes', then the emitted script
3831 # will assume that the directory in which it is stored is
3832 # the $objdir directory. This is a cygwin/mingw-specific
3834 func_emit_wrapper ()
3836 func_emit_wrapper_arg1=${1-no}
3841 # $output - temporary wrapper script for $objdir/$outputname
3842 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3844 # The $output program cannot be directly executed until all the libtool
3845 # libraries that it depends on are installed.
3847 # This wrapper script should never be moved out of the build directory.
3848 # If it is, it will not operate correctly.
3850 # Sed substitution that helps us do robust quoting. It backslashifies
3851 # metacharacters that are still active within double-quoted strings.
3852 sed_quote_subst='$sed_quote_subst'
3854 # Be Bourne compatible
3855 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3858 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3859 # is contrary to our usage. Disable this feature.
3860 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3861 setopt NO_GLOB_SUBST
3863 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3865 BIN_SH=xpg4; export BIN_SH # for Tru64
3866 DUALCASE=1; export DUALCASE # for MKS sh
3868 # The HP-UX ksh and POSIX shell print the target directory to stdout
3870 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3872 relink_command=\"$relink_command\"
3874 # This environment variable determines our operation mode.
3875 if test \"\$libtool_install_magic\" = \"$magic\"; then
3876 # install mode needs the following variables:
3877 generated_by_libtool_version='$macro_version'
3878 notinst_deplibs='$notinst_deplibs'
3880 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3881 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3884 qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3887 # A function that is used when there is no print builtin or printf.
3888 func_fallback_echo ()
3890 eval 'cat <<_LTECHO_EOF
3897 # Very basic option parsing. These options are (a) specific to
3898 # the libtool wrapper, (b) are identical between the wrapper
3899 # /script/ and the wrapper /executable/ which is used only on
3900 # windows platforms, and (c) all begin with the string "--lt-"
3901 # (application programs are unlikely to have options which match
3904 # There are only two supported options: --lt-debug and
3905 # --lt-dump-script. There is, deliberately, no --lt-help.
3907 # The first argument to this parsing function should be the
3908 # script's $0 value, followed by "$@".
3910 func_parse_lt_options ()
3916 case \"\$lt_opt\" in
3917 --lt-debug) lt_option_debug=1 ;;
3919 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3920 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3921 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3922 cat \"\$lt_dump_D/\$lt_dump_F\"
3926 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3932 # Print the debug banner immediately:
3933 if test -n \"\$lt_option_debug\"; then
3934 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3938 # Used when --lt-debug. Prints its arguments to stdout
3939 # (redirection is the responsibility of the caller)
3940 func_lt_dump_args ()
3945 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3946 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3950 # Core function for launching the target application
3951 func_exec_program_core ()
3955 # Backslashes separate directories on plain windows
3956 *-*-mingw | *-*-os2* | *-cegcc*)
3958 if test -n \"\$lt_option_debug\"; then
3959 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3960 func_lt_dump_args \${1+\"\$@\"} 1>&2
3962 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3968 if test -n \"\$lt_option_debug\"; then
3969 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3970 func_lt_dump_args \${1+\"\$@\"} 1>&2
3972 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3977 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3981 # A function to encapsulate launching the target application
3982 # Strips options in the --lt-* namespace from \$@ and
3983 # launches target application with the remaining arguments.
3984 func_exec_program ()
3990 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3994 func_exec_program_core \${1+\"\$@\"}
3998 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4000 # Find the directory that this script lives in.
4001 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4002 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4004 # Follow symbolic links until we get to the real thisdir.
4005 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4006 while test -n \"\$file\"; do
4007 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4009 # If there was a directory component, then change thisdir.
4010 if test \"x\$destdir\" != \"x\$file\"; then
4011 case \"\$destdir\" in
4012 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4013 *) thisdir=\"\$thisdir/\$destdir\" ;;
4017 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4018 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4021 # Usually 'no', except on cygwin/mingw when embedded into
4023 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4024 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4025 # special case for '.'
4026 if test \"\$thisdir\" = \".\"; then
4029 # remove .libs from thisdir
4030 case \"\$thisdir\" in
4031 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4032 $objdir ) thisdir=. ;;
4036 # Try to get the absolute directory name.
4037 absdir=\`cd \"\$thisdir\" && pwd\`
4038 test -n \"\$absdir\" && thisdir=\"\$absdir\"
4041 if test "$fast_install" = yes; then
4043 program=lt-'$outputname'$exeext
4044 progdir=\"\$thisdir/$objdir\"
4046 if test ! -f \"\$progdir/\$program\" ||
4047 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4048 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4050 file=\"\$\$-\$program\"
4052 if test ! -d \"\$progdir\"; then
4053 $MKDIR \"\$progdir\"
4055 $RM \"\$progdir/\$file\"
4060 # relink executable if necessary
4061 if test -n \"\$relink_command\"; then
4062 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4064 $ECHO \"\$relink_command_output\" >&2
4065 $RM \"\$progdir/\$file\"
4070 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4071 { $RM \"\$progdir/\$program\";
4072 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4073 $RM \"\$progdir/\$file\"
4077 program='$outputname'
4078 progdir=\"\$thisdir/$objdir\"
4084 if test -f \"\$progdir/\$program\"; then"
4086 # fixup the dll searchpath if we need to.
4088 # Fix the DLL searchpath if we need to. Do this before prepending
4089 # to shlibpath, because on Windows, both are PATH and uninstalled
4090 # libraries must come first.
4091 if test -n "$dllsearchpath"; then
4093 # Add the dll search path components to the executable PATH
4094 PATH=$dllsearchpath:\$PATH
4098 # Export our shlibpath_var if we have one.
4099 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4101 # Add our own library path to $shlibpath_var
4102 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4104 # Some systems cannot cope with colon-terminated $shlibpath_var
4105 # The second colon is a workaround for a bug in BeOS R4 sed
4106 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4108 export $shlibpath_var
4113 if test \"\$libtool_execute_magic\" != \"$magic\"; then
4114 # Run the actual program with our arguments.
4115 func_exec_program \${1+\"\$@\"}
4118 # The program doesn't exist.
4119 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4120 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4121 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4129 # func_emit_cwrapperexe_src
4130 # emit the source code for a wrapper executable on stdout
4131 # Must ONLY be called from within func_mode_link because
4132 # it depends on a number of variable set therein.
4133 func_emit_cwrapperexe_src ()
4137 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4138 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4140 The $output program cannot be directly executed until all the libtool
4141 libraries that it depends on are installed.
4143 This wrapper executable should never be moved out of the build directory.
4144 If it is, it will not operate correctly.
4149 # define _CRT_SECURE_NO_DEPRECATE 1
4154 # include <direct.h>
4155 # include <process.h>
4158 # include <unistd.h>
4159 # include <stdint.h>
4171 #include <sys/stat.h>
4173 /* declarations of non-ANSI functions */
4174 #if defined(__MINGW32__)
4175 # ifdef __STRICT_ANSI__
4176 int _putenv (const char *);
4178 #elif defined(__CYGWIN__)
4179 # ifdef __STRICT_ANSI__
4180 char *realpath (const char *, char *);
4181 int putenv (char *);
4182 int setenv (const char *, const char *, int);
4184 /* #elif defined (other platforms) ... */
4187 /* portability defines, excluding path handling macros */
4188 #if defined(_MSC_VER)
4189 # define setmode _setmode
4191 # define chmod _chmod
4192 # define getcwd _getcwd
4193 # define putenv _putenv
4194 # define S_IXUSR _S_IEXEC
4195 # ifndef _INTPTR_T_DEFINED
4196 # define _INTPTR_T_DEFINED
4197 # define intptr_t int
4199 #elif defined(__MINGW32__)
4200 # define setmode _setmode
4202 # define chmod _chmod
4203 # define getcwd _getcwd
4204 # define putenv _putenv
4205 #elif defined(__CYGWIN__)
4206 # define HAVE_SETENV
4207 # define FOPEN_WB "wb"
4208 /* #elif defined (other platforms) ... */
4211 #if defined(PATH_MAX)
4212 # define LT_PATHMAX PATH_MAX
4213 #elif defined(MAXPATHLEN)
4214 # define LT_PATHMAX MAXPATHLEN
4216 # define LT_PATHMAX 1024
4226 /* path handling portability macros */
4227 #ifndef DIR_SEPARATOR
4228 # define DIR_SEPARATOR '/'
4229 # define PATH_SEPARATOR ':'
4232 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4234 # define HAVE_DOS_BASED_FILE_SYSTEM
4235 # define FOPEN_WB "wb"
4236 # ifndef DIR_SEPARATOR_2
4237 # define DIR_SEPARATOR_2 '\\'
4239 # ifndef PATH_SEPARATOR_2
4240 # define PATH_SEPARATOR_2 ';'
4244 #ifndef DIR_SEPARATOR_2
4245 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4246 #else /* DIR_SEPARATOR_2 */
4247 # define IS_DIR_SEPARATOR(ch) \
4248 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4249 #endif /* DIR_SEPARATOR_2 */
4251 #ifndef PATH_SEPARATOR_2
4252 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4253 #else /* PATH_SEPARATOR_2 */
4254 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4255 #endif /* PATH_SEPARATOR_2 */
4258 # define FOPEN_WB "w"
4261 # define _O_BINARY 0
4264 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4265 #define XFREE(stale) do { \
4266 if (stale) { free ((void *) stale); stale = 0; } \
4269 #if defined(LT_DEBUGWRAPPER)
4270 static int lt_debug = 1;
4272 static int lt_debug = 0;
4275 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4277 void *xmalloc (size_t num);
4278 char *xstrdup (const char *string);
4279 const char *base_name (const char *name);
4280 char *find_executable (const char *wrapper);
4281 char *chase_symlinks (const char *pathspec);
4282 int make_executable (const char *path);
4283 int check_executable (const char *path);
4284 char *strendzap (char *str, const char *pat);
4285 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4286 void lt_fatal (const char *file, int line, const char *message, ...);
4287 static const char *nonnull (const char *s);
4288 static const char *nonempty (const char *s);
4289 void lt_setenv (const char *name, const char *value);
4290 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4291 void lt_update_exe_path (const char *name, const char *value);
4292 void lt_update_lib_path (const char *name, const char *value);
4293 char **prepare_spawn (char **argv);
4294 void lt_dump_script (FILE *f);
4298 volatile const char * MAGIC_EXE = "$magic_exe";
4299 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4302 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4303 func_to_host_path "$temp_rpath"
4305 const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4309 const char * LIB_PATH_VALUE = "";
4313 if test -n "$dllsearchpath"; then
4314 func_to_host_path "$dllsearchpath:"
4316 const char * EXE_PATH_VARNAME = "PATH";
4317 const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4321 const char * EXE_PATH_VARNAME = "";
4322 const char * EXE_PATH_VALUE = "";
4326 if test "$fast_install" = yes; then
4328 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4332 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4339 #define LTWRAPPER_OPTION_PREFIX "--lt-"
4341 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
4342 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
4343 static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
4346 main (int argc, char *argv[])
4351 char *actual_cwrapper_path;
4352 char *actual_cwrapper_name;
4355 intptr_t rval = 127;
4359 program_name = (char *) xstrdup (base_name (argv[0]));
4360 newargz = XMALLOC (char *, argc + 1);
4362 /* very simple arg parsing; don't want to rely on getopt
4363 * also, copy all non cwrapper options to newargz, except
4364 * argz[0], which is handled differently
4367 for (i = 1; i < argc; i++)
4369 if (strcmp (argv[i], dumpscript_opt) == 0)
4373 *mingw* | *cygwin* )
4374 # make stdout use "unix" line endings
4375 echo " setmode(1,_O_BINARY);"
4380 lt_dump_script (stdout);
4383 if (strcmp (argv[i], debug_opt) == 0)
4388 if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4390 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4391 namespace, but it is not one of the ones we know about and
4392 have already dealt with, above (inluding dump-script), then
4393 report an error. Otherwise, targets might begin to believe
4394 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4395 namespace. The first time any user complains about this, we'll
4396 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4397 or a configure.ac-settable value.
4399 lt_fatal (__FILE__, __LINE__,
4400 "unrecognized %s option: '%s'",
4401 ltwrapper_option_prefix, argv[i]);
4404 newargz[++newargc] = xstrdup (argv[i]);
4406 newargz[++newargc] = NULL;
4410 /* The GNU banner must be the first non-error debug message */
4411 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4414 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4415 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4417 tmp_pathspec = find_executable (argv[0]);
4418 if (tmp_pathspec == NULL)
4419 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4420 lt_debugprintf (__FILE__, __LINE__,
4421 "(main) found exe (before symlink chase) at: %s\n",
4424 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4425 lt_debugprintf (__FILE__, __LINE__,
4426 "(main) found exe (after symlink chase) at: %s\n",
4427 actual_cwrapper_path);
4428 XFREE (tmp_pathspec);
4430 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4431 strendzap (actual_cwrapper_path, actual_cwrapper_name);
4433 /* wrapper name transforms */
4434 strendzap (actual_cwrapper_name, ".exe");
4435 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4436 XFREE (actual_cwrapper_name);
4437 actual_cwrapper_name = tmp_pathspec;
4440 /* target_name transforms -- use actual target program name; might have lt- prefix */
4441 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4442 strendzap (target_name, ".exe");
4443 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4444 XFREE (target_name);
4445 target_name = tmp_pathspec;
4448 lt_debugprintf (__FILE__, __LINE__,
4449 "(main) libtool target name: %s\n",
4455 XMALLOC (char, (strlen (actual_cwrapper_path) +
4456 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4457 strcpy (newargz[0], actual_cwrapper_path);
4458 strcat (newargz[0], "$objdir");
4459 strcat (newargz[0], "/");
4463 /* stop here, and copy so we don't have to do this twice */
4464 tmp_pathspec = xstrdup (newargz[0]);
4466 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4467 strcat (newargz[0], actual_cwrapper_name);
4469 /* DO want the lt- prefix here if it exists, so use target_name */
4470 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4471 XFREE (tmp_pathspec);
4472 tmp_pathspec = NULL;
4480 while ((p = strchr (newargz[0], '\\')) != NULL)
4484 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4494 XFREE (target_name);
4495 XFREE (actual_cwrapper_path);
4496 XFREE (actual_cwrapper_name);
4498 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4499 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4500 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4501 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4502 because on Windows, both *_VARNAMEs are PATH but uninstalled
4503 libraries must come first. */
4504 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4505 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4507 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4508 nonnull (lt_argv_zero));
4509 for (i = 0; i < newargc; i++)
4511 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4512 i, nonnull (newargz[i]));
4520 /* execv doesn't actually work on mingw as expected on unix */
4521 newargz = prepare_spawn (newargz);
4522 rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4525 /* failed to start process */
4526 lt_debugprintf (__FILE__, __LINE__,
4527 "(main) failed to launch target \"%s\": %s\n",
4528 lt_argv_zero, nonnull (strerror (errno)));
4536 execv (lt_argv_zero, newargz);
4537 return rval; /* =127, but avoids unused variable warning */
4546 xmalloc (size_t num)
4548 void *p = (void *) malloc (num);
4550 lt_fatal (__FILE__, __LINE__, "memory exhausted");
4556 xstrdup (const char *string)
4558 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4563 base_name (const char *name)
4567 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4568 /* Skip over the disk name in MSDOS pathnames. */
4569 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4573 for (base = name; *name; name++)
4574 if (IS_DIR_SEPARATOR (*name))
4580 check_executable (const char *path)
4584 lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
4586 if ((!path) || (!*path))
4589 if ((stat (path, &st) >= 0)
4590 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4597 make_executable (const char *path)
4602 lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
4604 if ((!path) || (!*path))
4607 if (stat (path, &st) >= 0)
4609 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4614 /* Searches for the full path of the wrapper. Returns
4615 newly allocated full path name if found, NULL otherwise
4616 Does not chase symlinks, even on platforms that support them.
4619 find_executable (const char *wrapper)
4624 /* static buffer for getcwd */
4625 char tmp[LT_PATHMAX + 1];
4629 lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
4630 nonempty (wrapper));
4632 if ((wrapper == NULL) || (*wrapper == '\0'))
4635 /* Absolute path? */
4636 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4637 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4639 concat_name = xstrdup (wrapper);
4640 if (check_executable (concat_name))
4642 XFREE (concat_name);
4647 if (IS_DIR_SEPARATOR (wrapper[0]))
4649 concat_name = xstrdup (wrapper);
4650 if (check_executable (concat_name))
4652 XFREE (concat_name);
4654 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4658 for (p = wrapper; *p; p++)
4666 /* no slashes; search PATH */
4667 const char *path = getenv ("PATH");
4670 for (p = path; *p; p = p_next)
4674 for (q = p; *q; q++)
4675 if (IS_PATH_SEPARATOR (*q))
4678 p_next = (*q == '\0' ? q : q + 1);
4681 /* empty path: current directory */
4682 if (getcwd (tmp, LT_PATHMAX) == NULL)
4683 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4684 nonnull (strerror (errno)));
4685 tmp_len = strlen (tmp);
4687 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4688 memcpy (concat_name, tmp, tmp_len);
4689 concat_name[tmp_len] = '/';
4690 strcpy (concat_name + tmp_len + 1, wrapper);
4695 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4696 memcpy (concat_name, p, p_len);
4697 concat_name[p_len] = '/';
4698 strcpy (concat_name + p_len + 1, wrapper);
4700 if (check_executable (concat_name))
4702 XFREE (concat_name);
4705 /* not found in PATH; assume curdir */
4707 /* Relative path | not found in path: prepend cwd */
4708 if (getcwd (tmp, LT_PATHMAX) == NULL)
4709 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
4710 nonnull (strerror (errno)));
4711 tmp_len = strlen (tmp);
4712 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4713 memcpy (concat_name, tmp, tmp_len);
4714 concat_name[tmp_len] = '/';
4715 strcpy (concat_name + tmp_len + 1, wrapper);
4717 if (check_executable (concat_name))
4719 XFREE (concat_name);
4724 chase_symlinks (const char *pathspec)
4727 return xstrdup (pathspec);
4729 char buf[LT_PATHMAX];
4731 char *tmp_pathspec = xstrdup (pathspec);
4733 int has_symlinks = 0;
4734 while (strlen (tmp_pathspec) && !has_symlinks)
4736 lt_debugprintf (__FILE__, __LINE__,
4737 "checking path component for symlinks: %s\n",
4739 if (lstat (tmp_pathspec, &s) == 0)
4741 if (S_ISLNK (s.st_mode) != 0)
4747 /* search backwards for last DIR_SEPARATOR */
4748 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4749 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4751 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4753 /* no more DIR_SEPARATORS left */
4760 lt_fatal (__FILE__, __LINE__,
4761 "error accessing file \"%s\": %s",
4762 tmp_pathspec, nonnull (strerror (errno)));
4765 XFREE (tmp_pathspec);
4769 return xstrdup (pathspec);
4772 tmp_pathspec = realpath (pathspec, buf);
4773 if (tmp_pathspec == 0)
4775 lt_fatal (__FILE__, __LINE__,
4776 "could not follow symlinks for %s", pathspec);
4778 return xstrdup (tmp_pathspec);
4783 strendzap (char *str, const char *pat)
4787 assert (str != NULL);
4788 assert (pat != NULL);
4791 patlen = strlen (pat);
4795 str += len - patlen;
4796 if (strcmp (str, pat) == 0)
4803 lt_debugprintf (const char *file, int line, const char *fmt, ...)
4808 (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
4809 va_start (args, fmt);
4810 (void) vfprintf (stderr, fmt, args);
4816 lt_error_core (int exit_status, const char *file,
4817 int line, const char *mode,
4818 const char *message, va_list ap)
4820 fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
4821 vfprintf (stderr, message, ap);
4822 fprintf (stderr, ".\n");
4824 if (exit_status >= 0)
4829 lt_fatal (const char *file, int line, const char *message, ...)
4832 va_start (ap, message);
4833 lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
4838 nonnull (const char *s)
4840 return s ? s : "(null)";
4844 nonempty (const char *s)
4846 return (s && !*s) ? "(empty)" : nonnull (s);
4850 lt_setenv (const char *name, const char *value)
4852 lt_debugprintf (__FILE__, __LINE__,
4853 "(lt_setenv) setting '%s' to '%s'\n",
4854 nonnull (name), nonnull (value));
4857 /* always make a copy, for consistency with !HAVE_SETENV */
4858 char *str = xstrdup (value);
4859 setenv (name, str, 1);
4861 int len = strlen (name) + 1 + strlen (value) + 1;
4862 char *str = XMALLOC (char, len);
4863 sprintf (str, "%s=%s", name, value);
4864 if (putenv (str) != EXIT_SUCCESS)
4873 lt_extend_str (const char *orig_value, const char *add, int to_end)
4876 if (orig_value && *orig_value)
4878 int orig_value_len = strlen (orig_value);
4879 int add_len = strlen (add);
4880 new_value = XMALLOC (char, add_len + orig_value_len + 1);
4883 strcpy (new_value, orig_value);
4884 strcpy (new_value + orig_value_len, add);
4888 strcpy (new_value, add);
4889 strcpy (new_value + add_len, orig_value);
4894 new_value = xstrdup (add);
4900 lt_update_exe_path (const char *name, const char *value)
4902 lt_debugprintf (__FILE__, __LINE__,
4903 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4904 nonnull (name), nonnull (value));
4906 if (name && *name && value && *value)
4908 char *new_value = lt_extend_str (getenv (name), value, 0);
4909 /* some systems can't cope with a ':'-terminated path #' */
4910 int len = strlen (new_value);
4911 while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4913 new_value[len-1] = '\0';
4915 lt_setenv (name, new_value);
4921 lt_update_lib_path (const char *name, const char *value)
4923 lt_debugprintf (__FILE__, __LINE__,
4924 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4925 nonnull (name), nonnull (value));
4927 if (name && *name && value && *value)
4929 char *new_value = lt_extend_str (getenv (name), value, 0);
4930 lt_setenv (name, new_value);
4940 /* Prepares an argument vector before calling spawn().
4941 Note that spawn() does not by itself call the command interpreter
4942 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4943 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4945 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4946 }) ? "cmd.exe" : "command.com").
4947 Instead it simply concatenates the arguments, separated by ' ', and calls
4948 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4949 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4951 - Space and tab are interpreted as delimiters. They are not treated as
4952 delimiters if they are surrounded by double quotes: "...".
4953 - Unescaped double quotes are removed from the input. Their only effect is
4954 that within double quotes, space and tab are treated like normal
4956 - Backslashes not followed by double quotes are not special.
4957 - But 2*n+1 backslashes followed by a double quote become
4958 n backslashes followed by a double quote (n >= 0):
4963 #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"
4964 #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"
4966 prepare_spawn (char **argv)
4972 /* Count number of arguments. */
4973 for (argc = 0; argv[argc] != NULL; argc++)
4976 /* Allocate new argument vector. */
4977 new_argv = XMALLOC (char *, argc + 1);
4979 /* Put quoted arguments into the new argument vector. */
4980 for (i = 0; i < argc; i++)
4982 const char *string = argv[i];
4984 if (string[0] == '\0')
4985 new_argv[i] = xstrdup ("\"\"");
4986 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4988 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4990 unsigned int backslashes;
4992 char *quoted_string;
4999 for (s = string; *s != '\0'; s++)
5003 length += backslashes + 1;
5011 length += backslashes + 1;
5013 quoted_string = XMALLOC (char, length + 1);
5019 for (s = string; *s != '\0'; s++)
5025 for (j = backslashes + 1; j > 0; j--)
5037 for (j = backslashes; j > 0; j--)
5043 new_argv[i] = quoted_string;
5046 new_argv[i] = (char *) string;
5048 new_argv[argc] = NULL;
5057 void lt_dump_script (FILE* f)
5060 func_emit_wrapper yes |
5061 $SED -e 's/\([\\"]\)/\\\1/g' \
5062 -e 's/^/ fputs ("/' -e 's/$/\\n", f);/'
5068 # end: func_emit_cwrapperexe_src
5070 # func_win32_import_lib_p ARG
5071 # True if ARG is an import lib, as indicated by $file_magic_cmd
5072 func_win32_import_lib_p ()
5075 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5081 # func_mode_link arg...
5086 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5087 # It is impossible to link a dll without this setting, and
5088 # we shouldn't force the makefile maintainer to figure out
5089 # which system we are compiling for in order to pass an extra
5090 # flag for every libtool invocation.
5091 # allow_undefined=no
5093 # FIXME: Unfortunately, there are problems with the above when trying
5094 # to make a dll which has undefined symbols, in which case not
5095 # even a static library is built. For now, we need to specify
5096 # -no-undefined on the libtool link line when we can be certain
5097 # that all symbols are satisfied, otherwise we get a static library.
5104 libtool_args=$nonopt
5105 base_compile="$nonopt $@"
5106 compile_command=$nonopt
5107 finalize_command=$nonopt
5120 lib_search_path=`pwd`
5122 new_inherited_linker_flags=
5131 export_symbols_regex=
5139 precious_files_regex=
5140 prefer_static_libs=no
5153 single_module="${wl}-single_module"
5154 func_infer_tag $base_compile
5156 # We need to know -static, to get the right output filenames.
5161 test "$build_libtool_libs" != yes && \
5162 func_fatal_configuration "can not build a shared library"
5166 -all-static | -static | -static-libtool-libs)
5169 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5170 func_warning "complete static linking is impossible in this configuration"
5172 if test -n "$link_static_flag"; then
5173 dlopen_self=$dlopen_self_static
5175 prefer_static_libs=yes
5178 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5179 dlopen_self=$dlopen_self_static
5181 prefer_static_libs=built
5183 -static-libtool-libs)
5184 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5185 dlopen_self=$dlopen_self_static
5187 prefer_static_libs=yes
5190 build_libtool_libs=no
5197 # See if our shared archives depend on static archives.
5198 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5200 # Go through the arguments, transforming them on the way.
5201 while test "$#" -gt 0; do
5204 func_quote_for_eval "$arg"
5205 qarg=$func_quote_for_eval_unquoted_result
5206 func_append libtool_args " $func_quote_for_eval_result"
5208 # If the previous option needs an argument, assign it.
5209 if test -n "$prev"; then
5212 func_append compile_command " @OUTPUT@"
5213 func_append finalize_command " @OUTPUT@"
5224 if test "$preload" = no; then
5225 # Add the symbol object into the linking commands.
5226 func_append compile_command " @SYMFILE@"
5227 func_append finalize_command " @SYMFILE@"
5231 *.la | *.lo) ;; # We handle these cases below.
5233 if test "$dlself" = no; then
5241 if test "$prev" = dlprefiles; then
5243 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5253 if test "$prev" = dlfiles; then
5254 func_append dlfiles " $arg"
5256 func_append dlprefiles " $arg"
5264 export_symbols="$arg"
5266 || func_fatal_error "symbol file \`$arg' does not exist"
5271 export_symbols_regex="$arg"
5279 *" $qarg.ltframework "*) ;;
5280 *) func_append deplibs " $qarg.ltframework" # this is fixed later
5289 inst_prefix_dir="$arg"
5294 if test -f "$arg"; then
5297 for fil in `cat "$save_arg"`
5299 # func_append moreargs " $fil"
5301 # A libtool-controlled object.
5303 # Check to see that this really is a libtool object.
5304 if func_lalib_unsafe_p "$arg"; then
5311 if test -z "$pic_object" ||
5312 test -z "$non_pic_object" ||
5313 test "$pic_object" = none &&
5314 test "$non_pic_object" = none; then
5315 func_fatal_error "cannot find name of object for \`$arg'"
5318 # Extract subdirectory from the argument.
5319 func_dirname "$arg" "/" ""
5320 xdir="$func_dirname_result"
5322 if test "$pic_object" != none; then
5323 # Prepend the subdirectory the object is found in.
5324 pic_object="$xdir$pic_object"
5326 if test "$prev" = dlfiles; then
5327 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5328 func_append dlfiles " $pic_object"
5332 # If libtool objects are unsupported, then we need to preload.
5337 # CHECK ME: I think I busted this. -Ossama
5338 if test "$prev" = dlprefiles; then
5339 # Preload the old-style object.
5340 func_append dlprefiles " $pic_object"
5345 func_append libobjs " $pic_object"
5350 if test "$non_pic_object" != none; then
5351 # Prepend the subdirectory the object is found in.
5352 non_pic_object="$xdir$non_pic_object"
5354 # A standard non-PIC object
5355 func_append non_pic_objects " $non_pic_object"
5356 if test -z "$pic_object" || test "$pic_object" = none ; then
5357 arg="$non_pic_object"
5360 # If the PIC object exists, use it instead.
5361 # $xdir was prepended to $pic_object above.
5362 non_pic_object="$pic_object"
5363 func_append non_pic_objects " $non_pic_object"
5366 # Only an error if not doing a dry-run.
5367 if $opt_dry_run; then
5368 # Extract subdirectory from the argument.
5369 func_dirname "$arg" "/" ""
5370 xdir="$func_dirname_result"
5373 pic_object=$xdir$objdir/$func_lo2o_result
5374 non_pic_object=$xdir$func_lo2o_result
5375 func_append libobjs " $pic_object"
5376 func_append non_pic_objects " $non_pic_object"
5378 func_fatal_error "\`$arg' is not a valid libtool object"
5383 func_fatal_error "link input file \`$arg' does not exist"
5390 precious_files_regex="$arg"
5400 # We need an absolute path.
5402 [\\/]* | [A-Za-z]:[\\/]*) ;;
5404 func_fatal_error "only absolute run-paths are allowed"
5407 if test "$prev" = rpath; then
5410 *) func_append rpath " $arg" ;;
5415 *) func_append xrpath " $arg" ;;
5432 func_append weak_libs " $arg"
5437 func_append linker_flags " $qarg"
5438 func_append compiler_flags " $qarg"
5440 func_append compile_command " $qarg"
5441 func_append finalize_command " $qarg"
5445 func_append compiler_flags " $qarg"
5447 func_append compile_command " $qarg"
5448 func_append finalize_command " $qarg"
5452 func_append linker_flags " $qarg"
5453 func_append compiler_flags " $wl$qarg"
5455 func_append compile_command " $wl$qarg"
5456 func_append finalize_command " $wl$qarg"
5460 eval "$prev=\"\$arg\""
5465 fi # test -n "$prev"
5471 if test -n "$link_static_flag"; then
5472 # See comment for -static flag below, for more details.
5473 func_append compile_command " $link_static_flag"
5474 func_append finalize_command " $link_static_flag"
5480 # FIXME: remove this flag sometime in the future.
5481 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5509 -export-symbols | -export-symbols-regex)
5510 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5511 func_fatal_error "more than one -exported-symbols argument is not allowed"
5513 if test "X$arg" = "X-export-symbols"; then
5531 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5532 # so, if we see these flags be careful not to treat them like -L
5534 case $with_gcc/$host in
5535 no/*-*-irix* | /*-*-irix*)
5536 func_append compile_command " $arg"
5537 func_append finalize_command " $arg"
5544 func_stripname "-L" '' "$arg"
5545 if test -z "$func_stripname_result"; then
5546 if test "$#" -gt 0; then
5547 func_fatal_error "require no space between \`-L' and \`$1'"
5549 func_fatal_error "need path for \`-L' option"
5552 func_resolve_sysroot "$func_stripname_result"
5553 dir=$func_resolve_sysroot_result
5554 # We need an absolute path.
5556 [\\/]* | [A-Za-z]:[\\/]*) ;;
5558 absdir=`cd "$dir" && pwd`
5559 test -z "$absdir" && \
5560 func_fatal_error "cannot determine absolute directory name of \`$dir'"
5565 *" -L$dir "* | *" $arg "*)
5566 # Will only happen for absolute or sysroot arguments
5569 # Preserve sysroot, but never include relative directories
5571 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5572 *) func_append deplibs " -L$dir" ;;
5574 func_append lib_search_path " $dir"
5578 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5579 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5580 case :$dllsearchpath: in
5582 ::) dllsearchpath=$dir;;
5583 *) func_append dllsearchpath ":$dir";;
5585 case :$dllsearchpath: in
5586 *":$testbindir:"*) ;;
5587 ::) dllsearchpath=$testbindir;;
5588 *) func_append dllsearchpath ":$testbindir";;
5596 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5598 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5599 # These systems don't actually have a C or math library (as such)
5603 # These systems don't actually have a C library (as such)
5604 test "X$arg" = "X-lc" && continue
5606 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5607 # Do not include libc due to us having libc/libc_r.
5608 test "X$arg" = "X-lc" && continue
5610 *-*-rhapsody* | *-*-darwin1.[012])
5611 # Rhapsody C and math libraries are in the System framework
5612 func_append deplibs " System.ltframework"
5615 *-*-sco3.2v5* | *-*-sco5v6*)
5616 # Causes problems with __ctype
5617 test "X$arg" = "X-lc" && continue
5619 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5620 # Compiler inserts libc in the correct place for threads to work
5621 test "X$arg" = "X-lc" && continue
5624 elif test "X$arg" = "X-lc_r"; then
5626 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5627 # Do not include libc_r directly, use -pthread flag.
5632 func_append deplibs " $arg"
5641 # Tru64 UNIX uses -model [arg] to determine the layout of C++
5642 # classes, name mangling, and exception handling.
5643 # Darwin uses the -arch flag to determine output architecture.
5644 -model|-arch|-isysroot|--sysroot)
5645 func_append compiler_flags " $arg"
5646 func_append compile_command " $arg"
5647 func_append finalize_command " $arg"
5652 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5653 func_append compiler_flags " $arg"
5654 func_append compile_command " $arg"
5655 func_append finalize_command " $arg"
5656 case "$new_inherited_linker_flags " in
5658 * ) func_append new_inherited_linker_flags " $arg" ;;
5664 single_module="${wl}-multi_module"
5675 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5676 # The PATH hackery in wrapper scripts is required on Windows
5677 # and Darwin in order for the loader to find any dlls it needs.
5678 func_warning "\`-no-install' is ignored for $host"
5679 func_warning "assuming \`-no-fast-install' instead"
5682 *) no_install=yes ;;
5699 -precious-files-regex)
5720 func_stripname '-R' '' "$arg"
5721 dir=$func_stripname_result
5722 # We need an absolute path.
5724 [\\/]* | [A-Za-z]:[\\/]*) ;;
5726 func_stripname '=' '' "$dir"
5727 dir=$lt_sysroot$func_stripname_result
5730 func_fatal_error "only absolute run-paths are allowed"
5735 *) func_append xrpath " $dir" ;;
5741 # The effects of -shared are defined in a previous loop.
5755 -static | -static-libtool-libs)
5756 # The effects of -static are defined in a previous loop.
5757 # We used to do the same as -all-static on platforms that
5758 # didn't have a PIC flag, but the assumption that the effects
5759 # would be equivalent was wrong. It would break on at least
5760 # Digital Unix and AIX.
5786 func_stripname '-Wc,' '' "$arg"
5787 args=$func_stripname_result
5789 save_ifs="$IFS"; IFS=','
5790 for flag in $args; do
5792 func_quote_for_eval "$flag"
5793 func_append arg " $func_quote_for_eval_result"
5794 func_append compiler_flags " $func_quote_for_eval_result"
5797 func_stripname ' ' '' "$arg"
5798 arg=$func_stripname_result
5802 func_stripname '-Wl,' '' "$arg"
5803 args=$func_stripname_result
5805 save_ifs="$IFS"; IFS=','
5806 for flag in $args; do
5808 func_quote_for_eval "$flag"
5809 func_append arg " $wl$func_quote_for_eval_result"
5810 func_append compiler_flags " $wl$func_quote_for_eval_result"
5811 func_append linker_flags " $func_quote_for_eval_result"
5814 func_stripname ' ' '' "$arg"
5815 arg=$func_stripname_result
5835 func_quote_for_eval "$arg"
5836 arg="$func_quote_for_eval_result"
5839 # Flags to be passed through unchanged, with rationale:
5840 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5841 # -r[0-9][0-9]* specify processor for the SGI compiler
5842 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5843 # +DA*, +DD* enable 64-bit mode for the HP compiler
5844 # -q* compiler args for the IBM compiler
5845 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5846 # -F/path path to uninstalled frameworks, gcc on darwin
5847 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5848 # @file GCC response files
5849 # -tp=* Portland pgcc target processor selection
5850 # --sysroot=* for sysroot support
5851 # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5852 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5853 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5854 -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5855 func_quote_for_eval "$arg"
5856 arg="$func_quote_for_eval_result"
5857 func_append compile_command " $arg"
5858 func_append finalize_command " $arg"
5859 func_append compiler_flags " $arg"
5863 # Some other compiler flag.
5865 func_quote_for_eval "$arg"
5866 arg="$func_quote_for_eval_result"
5870 # A standard object.
5871 func_append objs " $arg"
5875 # A libtool-controlled object.
5877 # Check to see that this really is a libtool object.
5878 if func_lalib_unsafe_p "$arg"; then
5885 if test -z "$pic_object" ||
5886 test -z "$non_pic_object" ||
5887 test "$pic_object" = none &&
5888 test "$non_pic_object" = none; then
5889 func_fatal_error "cannot find name of object for \`$arg'"
5892 # Extract subdirectory from the argument.
5893 func_dirname "$arg" "/" ""
5894 xdir="$func_dirname_result"
5896 if test "$pic_object" != none; then
5897 # Prepend the subdirectory the object is found in.
5898 pic_object="$xdir$pic_object"
5900 if test "$prev" = dlfiles; then
5901 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5902 func_append dlfiles " $pic_object"
5906 # If libtool objects are unsupported, then we need to preload.
5911 # CHECK ME: I think I busted this. -Ossama
5912 if test "$prev" = dlprefiles; then
5913 # Preload the old-style object.
5914 func_append dlprefiles " $pic_object"
5919 func_append libobjs " $pic_object"
5924 if test "$non_pic_object" != none; then
5925 # Prepend the subdirectory the object is found in.
5926 non_pic_object="$xdir$non_pic_object"
5928 # A standard non-PIC object
5929 func_append non_pic_objects " $non_pic_object"
5930 if test -z "$pic_object" || test "$pic_object" = none ; then
5931 arg="$non_pic_object"
5934 # If the PIC object exists, use it instead.
5935 # $xdir was prepended to $pic_object above.
5936 non_pic_object="$pic_object"
5937 func_append non_pic_objects " $non_pic_object"
5940 # Only an error if not doing a dry-run.
5941 if $opt_dry_run; then
5942 # Extract subdirectory from the argument.
5943 func_dirname "$arg" "/" ""
5944 xdir="$func_dirname_result"
5947 pic_object=$xdir$objdir/$func_lo2o_result
5948 non_pic_object=$xdir$func_lo2o_result
5949 func_append libobjs " $pic_object"
5950 func_append non_pic_objects " $non_pic_object"
5952 func_fatal_error "\`$arg' is not a valid libtool object"
5959 func_append deplibs " $arg"
5960 func_append old_deplibs " $arg"
5965 # A libtool-controlled library.
5967 func_resolve_sysroot "$arg"
5968 if test "$prev" = dlfiles; then
5969 # This library was specified with -dlopen.
5970 func_append dlfiles " $func_resolve_sysroot_result"
5972 elif test "$prev" = dlprefiles; then
5973 # The library was specified with -dlpreopen.
5974 func_append dlprefiles " $func_resolve_sysroot_result"
5977 func_append deplibs " $func_resolve_sysroot_result"
5982 # Some other compiler argument.
5984 # Unknown arguments in both finalize_command and compile_command need
5985 # to be aesthetically quoted because they are evaled later.
5986 func_quote_for_eval "$arg"
5987 arg="$func_quote_for_eval_result"
5991 # Now actually substitute the argument into the commands.
5992 if test -n "$arg"; then
5993 func_append compile_command " $arg"
5994 func_append finalize_command " $arg"
5996 done # argument parsing loop
5998 test -n "$prev" && \
5999 func_fatal_help "the \`$prevarg' option requires an argument"
6001 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6002 eval arg=\"$export_dynamic_flag_spec\"
6003 func_append compile_command " $arg"
6004 func_append finalize_command " $arg"
6008 # calculate the name of the file, without its directory
6009 func_basename "$output"
6010 outputname="$func_basename_result"
6011 libobjs_save="$libobjs"
6013 if test -n "$shlibpath_var"; then
6014 # get the directories listed in $shlibpath_var
6015 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6019 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6020 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6022 func_dirname "$output" "/" ""
6023 output_objdir="$func_dirname_result$objdir"
6024 func_to_tool_file "$output_objdir/"
6025 tool_output_objdir=$func_to_tool_file_result
6026 # Create the object directory.
6027 func_mkdir_p "$output_objdir"
6029 # Determine the type of output
6032 func_fatal_help "you must specify an output file"
6034 *.$libext) linkmode=oldlib ;;
6035 *.lo | *.$objext) linkmode=obj ;;
6036 *.la) linkmode=lib ;;
6037 *) linkmode=prog ;; # Anything else should be a program.
6043 # Find all interdependent deplibs by searching for libraries
6044 # that are linked more than once (e.g. -la -lb -la)
6045 for deplib in $deplibs; do
6046 if $opt_preserve_dup_deps ; then
6048 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6051 func_append libs " $deplib"
6054 if test "$linkmode" = lib; then
6055 libs="$predeps $libs $compiler_lib_search_path $postdeps"
6057 # Compute libraries that are listed more than once in $predeps
6058 # $postdeps and mark them as special (i.e., whose duplicates are
6059 # not to be eliminated).
6061 if $opt_duplicate_compiler_generated_deps; then
6062 for pre_post_dep in $predeps $postdeps; do
6063 case "$pre_post_deps " in
6064 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6066 func_append pre_post_deps " $pre_post_dep"
6075 need_relink=no # whether we're linking any uninstalled libtool libraries
6076 notinst_deplibs= # not-installed libtool libraries
6077 notinst_path= # paths that contain not-installed libtool libraries
6081 passes="conv dlpreopen link"
6082 for file in $dlfiles $dlprefiles; do
6086 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6097 passes="conv scan dlopen dlpreopen link"
6103 for pass in $passes; do
6104 # The preopen pass in lib mode reverses $deplibs; put it back here
6105 # so that -L comes before libs that need it for instance...
6106 if test "$linkmode,$pass" = "lib,link"; then
6107 ## FIXME: Find the place where the list is rebuilt in the wrong
6108 ## order, and fix it there properly
6110 for deplib in $deplibs; do
6111 tmp_deplibs="$deplib $tmp_deplibs"
6113 deplibs="$tmp_deplibs"
6116 if test "$linkmode,$pass" = "lib,link" ||
6117 test "$linkmode,$pass" = "prog,scan"; then
6121 if test "$linkmode" = prog; then
6123 dlopen) libs="$dlfiles" ;;
6124 dlpreopen) libs="$dlprefiles" ;;
6125 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6128 if test "$linkmode,$pass" = "lib,dlpreopen"; then
6129 # Collect and forward deplibs of preopened libtool libs
6130 for lib in $dlprefiles; do
6131 # Ignore non-libtool-libs
6133 func_resolve_sysroot "$lib"
6135 *.la) func_source "$func_resolve_sysroot_result" ;;
6138 # Collect preopened libtool deplibs, except any this library
6139 # has declared as weak libs
6140 for deplib in $dependency_libs; do
6141 func_basename "$deplib"
6142 deplib_base=$func_basename_result
6143 case " $weak_libs " in
6144 *" $deplib_base "*) ;;
6145 *) func_append deplibs " $deplib" ;;
6151 if test "$pass" = dlopen; then
6152 # Collect dlpreopened libraries
6153 save_deplibs="$deplibs"
6157 for deplib in $libs; do
6161 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
6162 if test "$linkmode,$pass" = "prog,link"; then
6163 compile_deplibs="$deplib $compile_deplibs"
6164 finalize_deplibs="$deplib $finalize_deplibs"
6166 func_append compiler_flags " $deplib"
6167 if test "$linkmode" = lib ; then
6168 case "$new_inherited_linker_flags " in
6170 * ) func_append new_inherited_linker_flags " $deplib" ;;
6177 if test "$linkmode" != lib && test "$linkmode" != prog; then
6178 func_warning "\`-l' is ignored for archives/objects"
6181 func_stripname '-l' '' "$deplib"
6182 name=$func_stripname_result
6183 if test "$linkmode" = lib; then
6184 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6186 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6188 for searchdir in $searchdirs; do
6189 for search_ext in .la $std_shrext .so .a; do
6190 # Search the libtool library
6191 lib="$searchdir/lib${name}${search_ext}"
6192 if test -f "$lib"; then
6193 if test "$search_ext" = ".la"; then
6202 if test "$found" != yes; then
6203 # deplib doesn't seem to be a libtool library
6204 if test "$linkmode,$pass" = "prog,link"; then
6205 compile_deplibs="$deplib $compile_deplibs"
6206 finalize_deplibs="$deplib $finalize_deplibs"
6208 deplibs="$deplib $deplibs"
6209 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6212 else # deplib is a libtool library
6213 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6214 # We need to do some special things here, and not later.
6215 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6216 case " $predeps $postdeps " in
6218 if func_lalib_p "$lib"; then
6222 for l in $old_library $library_names; do
6225 if test "X$ll" = "X$old_library" ; then # only static version available
6227 func_dirname "$lib" "" "."
6228 ladir="$func_dirname_result"
6229 lib=$ladir/$old_library
6230 if test "$linkmode,$pass" = "prog,link"; then
6231 compile_deplibs="$deplib $compile_deplibs"
6232 finalize_deplibs="$deplib $finalize_deplibs"
6234 deplibs="$deplib $deplibs"
6235 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6247 if test "$linkmode,$pass" = "prog,link"; then
6248 compile_deplibs="$deplib $compile_deplibs"
6249 finalize_deplibs="$deplib $finalize_deplibs"
6251 deplibs="$deplib $deplibs"
6252 if test "$linkmode" = lib ; then
6253 case "$new_inherited_linker_flags " in
6255 * ) func_append new_inherited_linker_flags " $deplib" ;;
6264 deplibs="$deplib $deplibs"
6265 test "$pass" = conv && continue
6266 newdependency_libs="$deplib $newdependency_libs"
6267 func_stripname '-L' '' "$deplib"
6268 func_resolve_sysroot "$func_stripname_result"
6269 func_append newlib_search_path " $func_resolve_sysroot_result"
6272 if test "$pass" = conv; then
6273 deplibs="$deplib $deplibs"
6276 if test "$pass" = scan; then
6277 deplibs="$deplib $deplibs"
6279 compile_deplibs="$deplib $compile_deplibs"
6280 finalize_deplibs="$deplib $finalize_deplibs"
6282 func_stripname '-L' '' "$deplib"
6283 func_resolve_sysroot "$func_stripname_result"
6284 func_append newlib_search_path " $func_resolve_sysroot_result"
6287 func_warning "\`-L' is ignored for archives/objects"
6293 if test "$pass" = link; then
6294 func_stripname '-R' '' "$deplib"
6295 func_resolve_sysroot "$func_stripname_result"
6296 dir=$func_resolve_sysroot_result
6297 # Make sure the xrpath contains only unique directories.
6300 *) func_append xrpath " $dir" ;;
6303 deplibs="$deplib $deplibs"
6307 func_resolve_sysroot "$deplib"
6308 lib=$func_resolve_sysroot_result
6311 if test "$pass" = conv; then
6312 deplibs="$deplib $deplibs"
6317 # Linking convenience modules into shared libraries is allowed,
6318 # but linking other static libraries is non-portable.
6319 case " $dlpreconveniencelibs " in
6323 case $deplibs_check_method in
6325 set dummy $deplibs_check_method; shift
6326 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6327 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6328 | $EGREP "$match_pattern_regex" > /dev/null; then
6336 if test "$valid_a_lib" != yes; then
6338 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6339 echo "*** I have the capability to make that library automatically link in when"
6340 echo "*** you link to this library. But I can only do this if you have a"
6341 echo "*** shared version of the library, which you do not appear to have"
6342 echo "*** because the file extensions .$libext of this argument makes me believe"
6343 echo "*** that it is just a static archive that I should not use here."
6346 $ECHO "*** Warning: Linking the shared library $output against the"
6347 $ECHO "*** static library $deplib is not portable!"
6348 deplibs="$deplib $deplibs"
6355 if test "$pass" != link; then
6356 deplibs="$deplib $deplibs"
6358 compile_deplibs="$deplib $compile_deplibs"
6359 finalize_deplibs="$deplib $finalize_deplibs"
6366 if test "$pass" = conv; then
6367 deplibs="$deplib $deplibs"
6368 elif test "$linkmode" = prog; then
6369 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6370 # If there is no dlopen support or we're linking statically,
6371 # we need to preload.
6372 func_append newdlprefiles " $deplib"
6373 compile_deplibs="$deplib $compile_deplibs"
6374 finalize_deplibs="$deplib $finalize_deplibs"
6376 func_append newdlfiles " $deplib"
6387 if test "$found" = yes || test -f "$lib"; then :
6389 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6392 # Check to see that this really is a libtool archive.
6393 func_lalib_unsafe_p "$lib" \
6394 || func_fatal_error "\`$lib' is not a valid libtool archive"
6396 func_dirname "$lib" "" "."
6397 ladir="$func_dirname_result"
6405 inherited_linker_flags=
6406 # If the library was installed with an old release of libtool,
6407 # it will not redefine variables installed, or shouldnotlink
6416 # Convert "-framework foo" to "foo.ltframework"
6417 if test -n "$inherited_linker_flags"; then
6418 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6419 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6420 case " $new_inherited_linker_flags " in
6421 *" $tmp_inherited_linker_flag "*) ;;
6422 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6426 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6427 if test "$linkmode,$pass" = "lib,link" ||
6428 test "$linkmode,$pass" = "prog,scan" ||
6429 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6430 test -n "$dlopen" && func_append dlfiles " $dlopen"
6431 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6434 if test "$pass" = conv; then
6435 # Only check for convenience libraries
6436 deplibs="$lib $deplibs"
6437 if test -z "$libdir"; then
6438 if test -z "$old_library"; then
6439 func_fatal_error "cannot find name of link library for \`$lib'"
6441 # It is a libtool convenience library, so add in its objects.
6442 func_append convenience " $ladir/$objdir/$old_library"
6443 func_append old_convenience " $ladir/$objdir/$old_library"
6444 elif test "$linkmode" != prog && test "$linkmode" != lib; then
6445 func_fatal_error "\`$lib' is not a convenience library"
6448 for deplib in $dependency_libs; do
6449 deplibs="$deplib $deplibs"
6450 if $opt_preserve_dup_deps ; then
6451 case "$tmp_libs " in
6452 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6455 func_append tmp_libs " $deplib"
6461 # Get the name of the library we link against.
6463 if test -n "$old_library" &&
6464 { test "$prefer_static_libs" = yes ||
6465 test "$prefer_static_libs,$installed" = "built,no"; }; then
6466 linklib=$old_library
6468 for l in $old_library $library_names; do
6472 if test -z "$linklib"; then
6473 func_fatal_error "cannot find name of link library for \`$lib'"
6476 # This library was specified with -dlopen.
6477 if test "$pass" = dlopen; then
6478 if test -z "$libdir"; then
6479 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6481 if test -z "$dlname" ||
6482 test "$dlopen_support" != yes ||
6483 test "$build_libtool_libs" = no; then
6484 # If there is no dlname, no dlopen support or we're linking
6485 # statically, we need to preload. We also need to preload any
6486 # dependent libraries so libltdl's deplib preloader doesn't
6487 # bomb out in the load deplibs phase.
6488 func_append dlprefiles " $lib $dependency_libs"
6490 func_append newdlfiles " $lib"
6495 # We need an absolute path.
6497 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6499 abs_ladir=`cd "$ladir" && pwd`
6500 if test -z "$abs_ladir"; then
6501 func_warning "cannot determine absolute directory name of \`$ladir'"
6502 func_warning "passing it literally to the linker, although it might fail"
6507 func_basename "$lib"
6508 laname="$func_basename_result"
6510 # Find the relevant object directory and library name.
6511 if test "X$installed" = Xyes; then
6512 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6513 func_warning "library \`$lib' was moved."
6518 dir="$lt_sysroot$libdir"
6519 absdir="$lt_sysroot$libdir"
6521 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6523 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6526 # Remove this search path later
6527 func_append notinst_path " $abs_ladir"
6529 dir="$ladir/$objdir"
6530 absdir="$abs_ladir/$objdir"
6531 # Remove this search path later
6532 func_append notinst_path " $abs_ladir"
6534 fi # $installed = yes
6535 func_stripname 'lib' '.la' "$laname"
6536 name=$func_stripname_result
6538 # This library was specified with -dlpreopen.
6539 if test "$pass" = dlpreopen; then
6540 if test -z "$libdir" && test "$linkmode" = prog; then
6541 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6544 # special handling for platforms with PE-DLLs.
6545 *cygwin* | *mingw* | *cegcc* )
6546 # Linker will automatically link against shared library if both
6547 # static and shared are present. Therefore, ensure we extract
6548 # symbols from the import library if a shared library is present
6549 # (otherwise, the dlopen module name will be incorrect). We do
6550 # this by putting the import library name into $newdlprefiles.
6551 # We recover the dlopen module name by 'saving' the la file
6552 # name in a special purpose variable, and (later) extracting the
6553 # dlname from the la file.
6554 if test -n "$dlname"; then
6555 func_tr_sh "$dir/$linklib"
6556 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6557 func_append newdlprefiles " $dir/$linklib"
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"
6567 # Prefer using a static library (so that no silly _DYNAMIC symbols
6568 # are required to link).
6569 if test -n "$old_library"; then
6570 func_append newdlprefiles " $dir/$old_library"
6571 # Keep a list of preopened convenience libraries to check
6572 # that they are being used correctly in the link pass.
6573 test -z "$libdir" && \
6574 func_append dlpreconveniencelibs " $dir/$old_library"
6575 # Otherwise, use the dlname, so that lt_dlopen finds it.
6576 elif test -n "$dlname"; then
6577 func_append newdlprefiles " $dir/$dlname"
6579 func_append newdlprefiles " $dir/$linklib"
6583 fi # $pass = dlpreopen
6585 if test -z "$libdir"; then
6586 # Link the convenience library
6587 if test "$linkmode" = lib; then
6588 deplibs="$dir/$old_library $deplibs"
6589 elif test "$linkmode,$pass" = "prog,link"; then
6590 compile_deplibs="$dir/$old_library $compile_deplibs"
6591 finalize_deplibs="$dir/$old_library $finalize_deplibs"
6593 deplibs="$lib $deplibs" # used for prog,scan pass
6599 if test "$linkmode" = prog && test "$pass" != link; then
6600 func_append newlib_search_path " $ladir"
6601 deplibs="$lib $deplibs"
6604 if test "$link_all_deplibs" != no || test -z "$library_names" ||
6605 test "$build_libtool_libs" = no; then
6610 for deplib in $dependency_libs; do
6612 -L*) func_stripname '-L' '' "$deplib"
6613 func_resolve_sysroot "$func_stripname_result"
6614 func_append newlib_search_path " $func_resolve_sysroot_result"
6617 # Need to link against all dependency_libs?
6618 if test "$linkalldeplibs" = yes; then
6619 deplibs="$deplib $deplibs"
6621 # Need to hardcode shared library paths
6622 # or/and link against static libraries
6623 newdependency_libs="$deplib $newdependency_libs"
6625 if $opt_preserve_dup_deps ; then
6626 case "$tmp_libs " in
6627 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6630 func_append tmp_libs " $deplib"
6633 fi # $linkmode = prog...
6635 if test "$linkmode,$pass" = "prog,link"; then
6636 if test -n "$library_names" &&
6637 { { test "$prefer_static_libs" = no ||
6638 test "$prefer_static_libs,$installed" = "built,yes"; } ||
6639 test -z "$old_library"; }; then
6640 # We need to hardcode the library path
6641 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6642 # Make sure the rpath contains only unique directories.
6643 case "$temp_rpath:" in
6645 *) func_append temp_rpath "$absdir:" ;;
6649 # Hardcode the library path.
6650 # Skip directories that are in the system default run-time
6652 case " $sys_lib_dlsearch_path " in
6655 case "$compile_rpath " in
6657 *) func_append compile_rpath " $absdir" ;;
6661 case " $sys_lib_dlsearch_path " in
6664 case "$finalize_rpath " in
6666 *) func_append finalize_rpath " $libdir" ;;
6670 fi # $linkmode,$pass = prog,link...
6672 if test "$alldeplibs" = yes &&
6673 { test "$deplibs_check_method" = pass_all ||
6674 { test "$build_libtool_libs" = yes &&
6675 test -n "$library_names"; }; }; then
6676 # We only need to search for static libraries
6681 link_static=no # Whether the deplib will be linked statically
6682 use_static_libs=$prefer_static_libs
6683 if test "$use_static_libs" = built && test "$installed" = yes; then
6686 if test -n "$library_names" &&
6687 { test "$use_static_libs" = no || test -z "$old_library"; }; then
6689 *cygwin* | *mingw* | *cegcc*)
6690 # No point in relinking DLLs because paths are not encoded
6691 func_append notinst_deplibs " $lib"
6695 if test "$installed" = no; then
6696 func_append notinst_deplibs " $lib"
6701 # This is a shared library
6703 # Warn about portability, can't link against -module's on some
6704 # systems (darwin). Don't bleat about dlopened modules though!
6706 for dlpremoduletest in $dlprefiles; do
6707 if test "X$dlpremoduletest" = "X$lib"; then
6708 dlopenmodule="$dlpremoduletest"
6712 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6714 if test "$linkmode" = prog; then
6715 $ECHO "*** Warning: Linking the executable $output against the loadable module"
6717 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6719 $ECHO "*** $linklib is not portable!"
6721 if test "$linkmode" = lib &&
6722 test "$hardcode_into_libs" = yes; then
6723 # Hardcode the library path.
6724 # Skip directories that are in the system default run-time
6726 case " $sys_lib_dlsearch_path " in
6729 case "$compile_rpath " in
6731 *) func_append compile_rpath " $absdir" ;;
6735 case " $sys_lib_dlsearch_path " in
6738 case "$finalize_rpath " in
6740 *) func_append finalize_rpath " $libdir" ;;
6746 if test -n "$old_archive_from_expsyms_cmds"; then
6747 # figure out the soname
6748 set dummy $library_names
6752 libname=`eval "\\$ECHO \"$libname_spec\""`
6753 # use dlname if we got it. it's perfectly good, no?
6754 if test -n "$dlname"; then
6756 elif test -n "$soname_spec"; then
6759 *cygwin* | mingw* | *cegcc*)
6760 func_arith $current - $age
6761 major=$func_arith_result
6765 eval soname=\"$soname_spec\"
6770 # Make a new name for the extract_expsyms_cmds to use
6772 func_basename "$soroot"
6773 soname="$func_basename_result"
6774 func_stripname 'lib' '.dll' "$soname"
6775 newlib=libimp-$func_stripname_result.a
6777 # If the library has no export list, then create one now
6778 if test -f "$output_objdir/$soname-def"; then :
6780 func_verbose "extracting exported symbol list from \`$soname'"
6781 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6785 if test -f "$output_objdir/$newlib"; then :; else
6786 func_verbose "generating import library for \`$soname'"
6787 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6789 # make sure the library variables are pointing to the new library
6792 fi # test -n "$old_archive_from_expsyms_cmds"
6794 if test "$linkmode" = prog || test "$opt_mode" != relink; then
6799 case $hardcode_action in
6800 immediate | unsupported)
6801 if test "$hardcode_direct" = no; then
6804 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6805 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6806 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6807 *-*-unixware7*) add_dir="-L$dir" ;;
6809 # if the lib is a (non-dlopened) module then we can not
6810 # link against it, someone is ignoring the earlier warnings
6811 if /usr/bin/file -L $add 2> /dev/null |
6812 $GREP ": [^:]* bundle" >/dev/null ; then
6813 if test "X$dlopenmodule" != "X$lib"; then
6814 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6815 if test -z "$old_library" ; then
6817 echo "*** And there doesn't seem to be a static archive available"
6818 echo "*** The link will probably fail, sorry"
6820 add="$dir/$old_library"
6822 elif test -n "$old_library"; then
6823 add="$dir/$old_library"
6827 elif test "$hardcode_minus_L" = no; then
6829 *-*-sunos*) add_shlibpath="$dir" ;;
6833 elif test "$hardcode_shlibpath_var" = no; then
6834 add_shlibpath="$dir"
6841 if test "$hardcode_direct" = yes &&
6842 test "$hardcode_direct_absolute" = no; then
6844 elif test "$hardcode_minus_L" = yes; then
6846 # Try looking first in the location we're being installed to.
6847 if test -n "$inst_prefix_dir"; then
6850 func_append add_dir " -L$inst_prefix_dir$libdir"
6855 elif test "$hardcode_shlibpath_var" = yes; then
6856 add_shlibpath="$dir"
6865 if test "$lib_linked" != yes; then
6866 func_fatal_configuration "unsupported hardcode properties"
6869 if test -n "$add_shlibpath"; then
6870 case :$compile_shlibpath: in
6871 *":$add_shlibpath:"*) ;;
6872 *) func_append compile_shlibpath "$add_shlibpath:" ;;
6875 if test "$linkmode" = prog; then
6876 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6877 test -n "$add" && compile_deplibs="$add $compile_deplibs"
6879 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6880 test -n "$add" && deplibs="$add $deplibs"
6881 if test "$hardcode_direct" != yes &&
6882 test "$hardcode_minus_L" != yes &&
6883 test "$hardcode_shlibpath_var" = yes; then
6884 case :$finalize_shlibpath: in
6886 *) func_append finalize_shlibpath "$libdir:" ;;
6892 if test "$linkmode" = prog || test "$opt_mode" = relink; then
6896 # Finalize command for both is simple: just hardcode it.
6897 if test "$hardcode_direct" = yes &&
6898 test "$hardcode_direct_absolute" = no; then
6899 add="$libdir/$linklib"
6900 elif test "$hardcode_minus_L" = yes; then
6903 elif test "$hardcode_shlibpath_var" = yes; then
6904 case :$finalize_shlibpath: in
6906 *) func_append finalize_shlibpath "$libdir:" ;;
6909 elif test "$hardcode_automatic" = yes; then
6910 if test -n "$inst_prefix_dir" &&
6911 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6912 add="$inst_prefix_dir$libdir/$linklib"
6914 add="$libdir/$linklib"
6917 # We cannot seem to hardcode it, guess we'll fake it.
6919 # Try looking first in the location we're being installed to.
6920 if test -n "$inst_prefix_dir"; then
6923 func_append add_dir " -L$inst_prefix_dir$libdir"
6930 if test "$linkmode" = prog; then
6931 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6932 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6934 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6935 test -n "$add" && deplibs="$add $deplibs"
6938 elif test "$linkmode" = prog; then
6939 # Here we assume that one of hardcode_direct or hardcode_minus_L
6940 # is not unsupported. This is valid on all known static and
6942 if test "$hardcode_direct" != unsupported; then
6943 test -n "$old_library" && linklib="$old_library"
6944 compile_deplibs="$dir/$linklib $compile_deplibs"
6945 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6947 compile_deplibs="-l$name -L$dir $compile_deplibs"
6948 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6950 elif test "$build_libtool_libs" = yes; then
6951 # Not a shared library
6952 if test "$deplibs_check_method" != pass_all; then
6953 # We're trying link a shared library against a static one
6954 # but the system doesn't support it.
6956 # Just print a warning and add the library to dependency_libs so
6957 # that the program can be linked against the static library.
6959 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6960 echo "*** I have the capability to make that library automatically link in when"
6961 echo "*** you link to this library. But I can only do this if you have a"
6962 echo "*** shared version of the library, which you do not appear to have."
6963 if test "$module" = yes; then
6964 echo "*** But as you try to build a module library, libtool will still create "
6965 echo "*** a static module, that should work as long as the dlopening application"
6966 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6967 if test -z "$global_symbol_pipe"; then
6969 echo "*** However, this would only work if libtool was able to extract symbol"
6970 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6971 echo "*** not find such a program. So, this module is probably useless."
6972 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6974 if test "$build_old_libs" = no; then
6975 build_libtool_libs=module
6978 build_libtool_libs=no
6982 deplibs="$dir/$old_library $deplibs"
6985 fi # link shared/static library?
6987 if test "$linkmode" = lib; then
6988 if test -n "$dependency_libs" &&
6989 { test "$hardcode_into_libs" != yes ||
6990 test "$build_old_libs" = yes ||
6991 test "$link_static" = yes; }; then
6992 # Extract -R from dependency_libs
6994 for libdir in $dependency_libs; do
6996 -R*) func_stripname '-R' '' "$libdir"
6997 temp_xrpath=$func_stripname_result
6999 *" $temp_xrpath "*) ;;
7000 *) func_append xrpath " $temp_xrpath";;
7002 *) func_append temp_deplibs " $libdir";;
7005 dependency_libs="$temp_deplibs"
7008 func_append newlib_search_path " $absdir"
7009 # Link against this library
7010 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7011 # ... and its dependency_libs
7013 for deplib in $dependency_libs; do
7014 newdependency_libs="$deplib $newdependency_libs"
7016 -L*) func_stripname '-L' '' "$deplib"
7017 func_resolve_sysroot "$func_stripname_result";;
7018 *) func_resolve_sysroot "$deplib" ;;
7020 if $opt_preserve_dup_deps ; then
7021 case "$tmp_libs " in
7022 *" $func_resolve_sysroot_result "*)
7023 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7026 func_append tmp_libs " $func_resolve_sysroot_result"
7029 if test "$link_all_deplibs" != no; then
7030 # Add the search paths of all dependency libraries
7031 for deplib in $dependency_libs; do
7034 -L*) path="$deplib" ;;
7036 func_resolve_sysroot "$deplib"
7037 deplib=$func_resolve_sysroot_result
7038 func_dirname "$deplib" "" "."
7039 dir=$func_dirname_result
7040 # We need an absolute path.
7042 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7044 absdir=`cd "$dir" && pwd`
7045 if test -z "$absdir"; then
7046 func_warning "cannot determine absolute directory name of \`$dir'"
7051 if $GREP "^installed=no" $deplib > /dev/null; then
7055 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7056 if test -n "$deplibrary_names" ; then
7057 for tmp in $deplibrary_names ; do
7060 if test -f "$absdir/$objdir/$depdepl" ; then
7061 depdepl="$absdir/$objdir/$depdepl"
7062 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7063 if test -z "$darwin_install_name"; then
7064 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7066 func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7067 func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7073 path="-L$absdir/$objdir"
7077 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7078 test -z "$libdir" && \
7079 func_fatal_error "\`$deplib' is not a valid libtool archive"
7080 test "$absdir" != "$libdir" && \
7081 func_warning "\`$deplib' seems to be moved"
7087 case " $deplibs " in
7089 *) deplibs="$path $deplibs" ;;
7092 fi # link_all_deplibs != no
7094 done # for deplib in $libs
7095 if test "$pass" = link; then
7096 if test "$linkmode" = "prog"; then
7097 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7098 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7100 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7103 dependency_libs="$newdependency_libs"
7104 if test "$pass" = dlpreopen; then
7105 # Link the dlpreopened libraries before other libraries
7106 for deplib in $save_deplibs; do
7107 deplibs="$deplib $deplibs"
7110 if test "$pass" != dlopen; then
7111 if test "$pass" != conv; then
7112 # Make sure lib_search_path contains only unique directories.
7114 for dir in $newlib_search_path; do
7115 case "$lib_search_path " in
7117 *) func_append lib_search_path " $dir" ;;
7123 if test "$linkmode,$pass" != "prog,link"; then
7126 vars="compile_deplibs finalize_deplibs"
7128 for var in $vars dependency_libs; do
7129 # Add libraries to $var in reverse order
7130 eval tmp_libs=\"\$$var\"
7132 for deplib in $tmp_libs; do
7133 # FIXME: Pedantically, this is the right thing to do, so
7134 # that some nasty dependency loop isn't accidentally
7136 #new_libs="$deplib $new_libs"
7137 # Pragmatically, this seems to cause very few problems in
7140 -L*) new_libs="$deplib $new_libs" ;;
7143 # And here is the reason: when a library appears more
7144 # than once as an explicit dependence of a library, or
7145 # is implicitly linked in more than once by the
7146 # compiler, it is considered special, and multiple
7147 # occurrences thereof are not removed. Compare this
7148 # with having the same library being listed as a
7149 # dependency of multiple other libraries: in this case,
7150 # we know (pedantically, we assume) the library does not
7151 # need to be listed more than once, so we keep only the
7152 # last copy. This is not always right, but it is rare
7153 # enough that we require users that really mean to play
7154 # such unportable linking tricks to link the library
7155 # using -Wl,-lname, so that libtool does not consider it
7156 # for duplicate removal.
7157 case " $specialdeplibs " in
7158 *" $deplib "*) new_libs="$deplib $new_libs" ;;
7160 case " $new_libs " in
7162 *) new_libs="$deplib $new_libs" ;;
7170 for deplib in $new_libs; do
7173 case " $tmp_libs " in
7175 *) func_append tmp_libs " $deplib" ;;
7178 *) func_append tmp_libs " $deplib" ;;
7181 eval $var=\"$tmp_libs\"
7184 # Last step: remove runtime libs from dependency_libs
7185 # (they stay in deplibs)
7187 for i in $dependency_libs ; do
7188 case " $predeps $postdeps $compiler_lib_search_path " in
7193 if test -n "$i" ; then
7194 func_append tmp_libs " $i"
7197 dependency_libs=$tmp_libs
7199 if test "$linkmode" = prog; then
7200 dlfiles="$newdlfiles"
7202 if test "$linkmode" = prog || test "$linkmode" = lib; then
7203 dlprefiles="$newdlprefiles"
7208 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7209 func_warning "\`-dlopen' is ignored for archives"
7214 func_warning "\`-l' and \`-L' are ignored for archives" ;;
7217 test -n "$rpath" && \
7218 func_warning "\`-rpath' is ignored for archives"
7220 test -n "$xrpath" && \
7221 func_warning "\`-R' is ignored for archives"
7223 test -n "$vinfo" && \
7224 func_warning "\`-version-info/-version-number' is ignored for archives"
7226 test -n "$release" && \
7227 func_warning "\`-release' is ignored for archives"
7229 test -n "$export_symbols$export_symbols_regex" && \
7230 func_warning "\`-export-symbols' is ignored for archives"
7232 # Now set the variables for building old libraries.
7233 build_libtool_libs=no
7235 func_append objs "$old_deplibs"
7239 # Make sure we only generate libraries of the form `libNAME.la'.
7242 func_stripname 'lib' '.la' "$outputname"
7243 name=$func_stripname_result
7244 eval shared_ext=\"$shrext_cmds\"
7245 eval libname=\"$libname_spec\"
7248 test "$module" = no && \
7249 func_fatal_help "libtool library \`$output' must begin with \`lib'"
7251 if test "$need_lib_prefix" != no; then
7252 # Add the "lib" prefix for modules if required
7253 func_stripname '' '.la' "$outputname"
7254 name=$func_stripname_result
7255 eval shared_ext=\"$shrext_cmds\"
7256 eval libname=\"$libname_spec\"
7258 func_stripname '' '.la' "$outputname"
7259 libname=$func_stripname_result
7264 if test -n "$objs"; then
7265 if test "$deplibs_check_method" != pass_all; then
7266 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7269 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7270 $ECHO "*** objects $objs is not portable!"
7271 func_append libobjs " $objs"
7275 test "$dlself" != no && \
7276 func_warning "\`-dlopen self' is ignored for libtool libraries"
7280 test "$#" -gt 1 && \
7281 func_warning "ignoring multiple \`-rpath's for a libtool library"
7286 if test -z "$rpath"; then
7287 if test "$build_libtool_libs" = yes; then
7288 # Building a libtool convenience library.
7289 # Some compilers have problems with a `.al' extension so
7290 # convenience libraries should have the same extension an
7291 # archive normally would.
7292 oldlibs="$output_objdir/$libname.$libext $oldlibs"
7293 build_libtool_libs=convenience
7297 test -n "$vinfo" && \
7298 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7300 test -n "$release" && \
7301 func_warning "\`-release' is ignored for convenience libraries"
7304 # Parse the version information argument.
7305 save_ifs="$IFS"; IFS=':'
7306 set dummy $vinfo 0 0 0
7311 func_fatal_help "too many parameters to \`-version-info'"
7313 # convert absolute version numbers to libtool ages
7314 # this retains compatibility with .la files and attempts
7315 # to make the code below a bit more comprehensible
7317 case $vinfo_number in
7321 number_revision="$3"
7323 # There are really only two kinds -- those that
7324 # use the current revision as the major version
7325 # and those that subtract age and use age as
7326 # a minor version. But, then there is irix
7327 # which has an extra 1 added just for fun
7329 case $version_type in
7330 darwin|linux|osf|windows|none)
7331 func_arith $number_major + $number_minor
7332 current=$func_arith_result
7334 revision="$number_revision"
7336 freebsd-aout|freebsd-elf|qnx|sunos)
7337 current="$number_major"
7338 revision="$number_minor"
7342 func_arith $number_major + $number_minor
7343 current=$func_arith_result
7345 revision="$number_minor"
7346 lt_irix_increment=no
7357 # Check that each of the things are valid numbers.
7359 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]) ;;
7361 func_error "CURRENT \`$current' must be a nonnegative integer"
7362 func_fatal_error "\`$vinfo' is not valid version information"
7367 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]) ;;
7369 func_error "REVISION \`$revision' must be a nonnegative integer"
7370 func_fatal_error "\`$vinfo' is not valid version information"
7375 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]) ;;
7377 func_error "AGE \`$age' must be a nonnegative integer"
7378 func_fatal_error "\`$vinfo' is not valid version information"
7382 if test "$age" -gt "$current"; then
7383 func_error "AGE \`$age' is greater than the current interface number \`$current'"
7384 func_fatal_error "\`$vinfo' is not valid version information"
7387 # Calculate the version variables.
7391 case $version_type in
7395 # Like Linux, but with the current version available in
7396 # verstring for coding it into the library header
7397 func_arith $current - $age
7398 major=.$func_arith_result
7399 versuffix="$major.$age.$revision"
7400 # Darwin ld doesn't like 0 for these options...
7401 func_arith $current + 1
7402 minor_current=$func_arith_result
7403 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7404 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7409 versuffix=".$current.$revision";
7414 versuffix=".$current"
7418 if test "X$lt_irix_increment" = "Xno"; then
7419 func_arith $current - $age
7421 func_arith $current - $age + 1
7423 major=$func_arith_result
7425 case $version_type in
7426 nonstopux) verstring_prefix=nonstopux ;;
7427 *) verstring_prefix=sgi ;;
7429 verstring="$verstring_prefix$major.$revision"
7431 # Add in all the interfaces that we are compatible with.
7433 while test "$loop" -ne 0; do
7434 func_arith $revision - $loop
7435 iface=$func_arith_result
7436 func_arith $loop - 1
7437 loop=$func_arith_result
7438 verstring="$verstring_prefix$major.$iface:$verstring"
7441 # Before this point, $major must not contain `.'.
7443 versuffix="$major.$revision"
7447 func_arith $current - $age
7448 major=.$func_arith_result
7449 versuffix="$major.$age.$revision"
7453 func_arith $current - $age
7454 major=.$func_arith_result
7455 versuffix=".$current.$age.$revision"
7456 verstring="$current.$age.$revision"
7458 # Add in all the interfaces that we are compatible with.
7460 while test "$loop" -ne 0; do
7461 func_arith $current - $loop
7462 iface=$func_arith_result
7463 func_arith $loop - 1
7464 loop=$func_arith_result
7465 verstring="$verstring:${iface}.0"
7468 # Make executables depend on our current version.
7469 func_append verstring ":${current}.0"
7474 versuffix=".$current"
7479 versuffix=".$current.$revision"
7483 # Use '-' rather than '.', since we only want one
7484 # extension on DOS 8.3 filesystems.
7485 func_arith $current - $age
7486 major=$func_arith_result
7491 func_fatal_configuration "unknown library version type \`$version_type'"
7495 # Clear the version info if we defaulted, and they specified a release.
7496 if test -z "$vinfo" && test -n "$release"; then
7498 case $version_type in
7500 # we can't check for "0.0" in archive_cmds due to quoting
7501 # problems, so we reset it completely
7508 if test "$need_version" = no; then
7515 # Remove version info from name if versioning should be avoided
7516 if test "$avoid_version" = yes && test "$need_version" = no; then
7522 # Check to see if the archive will have undefined symbols.
7523 if test "$allow_undefined" = yes; then
7524 if test "$allow_undefined_flag" = unsupported; then
7525 func_warning "undefined symbols not allowed in $host shared libraries"
7526 build_libtool_libs=no
7530 # Don't allow undefined symbols.
7531 allow_undefined_flag="$no_undefined_flag"
7536 func_generate_dlsyms "$libname" "$libname" "yes"
7537 func_append libobjs " $symfileobj"
7538 test "X$libobjs" = "X " && libobjs=
7540 if test "$opt_mode" != relink; then
7541 # Remove our outputs, but don't remove object files since they
7542 # may have been created when compiling PIC objects.
7544 tempremovelist=`$ECHO "$output_objdir/*"`
7545 for p in $tempremovelist; do
7549 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7550 if test "X$precious_files_regex" != "X"; then
7551 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7556 func_append removelist " $p"
7561 test -n "$removelist" && \
7562 func_show_eval "${RM}r \$removelist"
7565 # Now set the variables for building old libraries.
7566 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7567 func_append oldlibs " $output_objdir/$libname.$libext"
7569 # Transform .lo files to .o files.
7570 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7573 # Eliminate all temporary directories.
7574 #for path in $notinst_path; do
7575 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7576 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7577 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7580 if test -n "$xrpath"; then
7581 # If the user specified any rpath flags, then add them.
7583 for libdir in $xrpath; do
7584 func_replace_sysroot "$libdir"
7585 func_append temp_xrpath " -R$func_replace_sysroot_result"
7586 case "$finalize_rpath " in
7588 *) func_append finalize_rpath " $libdir" ;;
7591 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7592 dependency_libs="$temp_xrpath $dependency_libs"
7596 # Make sure dlfiles contains only unique files that won't be dlpreopened
7597 old_dlfiles="$dlfiles"
7599 for lib in $old_dlfiles; do
7600 case " $dlprefiles $dlfiles " in
7602 *) func_append dlfiles " $lib" ;;
7606 # Make sure dlprefiles contains only unique files
7607 old_dlprefiles="$dlprefiles"
7609 for lib in $old_dlprefiles; do
7610 case "$dlprefiles " in
7612 *) func_append dlprefiles " $lib" ;;
7616 if test "$build_libtool_libs" = yes; then
7617 if test -n "$rpath"; then
7619 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7620 # these systems don't actually have a c library (as such)!
7622 *-*-rhapsody* | *-*-darwin1.[012])
7623 # Rhapsody C library is in the System framework
7624 func_append deplibs " System.ltframework"
7627 # Don't link with libc until the a.out ld.so is fixed.
7629 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7630 # Do not include libc due to us having libc/libc_r.
7632 *-*-sco3.2v5* | *-*-sco5v6*)
7633 # Causes problems with __ctype
7635 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7636 # Compiler inserts libc in the correct place for threads to work
7639 # Add libc to deplibs on all other systems if necessary.
7640 if test "$build_libtool_need_lc" = "yes"; then
7641 func_append deplibs " -lc"
7647 # Transform deplibs into only deplibs that can be linked in shared.
7649 libname_save=$libname
7650 release_save=$release
7651 versuffix_save=$versuffix
7653 # I'm not sure if I'm treating the release correctly. I think
7654 # release should show up in the -l (ie -lgmp5) so we don't want to
7655 # add it in twice. Is that correct?
7661 case $deplibs_check_method in
7663 # Don't check for shared/static. Everything works.
7664 # This might be a little naive. We might want to check
7665 # whether the library exists or not. But this is on
7666 # osf3 & osf4 and I'm not really sure... Just
7667 # implementing what was already the behavior.
7671 # This code stresses the "libraries are programs" paradigm to its
7672 # limits. Maybe even breaks it. We compile a program, linking it
7673 # against the deplibs as a proxy for the library. Then we can check
7674 # whether they linked in statically or dynamically with ldd.
7675 $opt_dry_run || $RM conftest.c
7676 cat > conftest.c <<EOF
7677 int main() { return 0; }
7679 $opt_dry_run || $RM conftest
7680 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7681 ldd_output=`ldd conftest`
7682 for i in $deplibs; do
7685 func_stripname -l '' "$i"
7686 name=$func_stripname_result
7687 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7688 case " $predeps $postdeps " in
7690 func_append newdeplibs " $i"
7695 if test -n "$i" ; then
7696 libname=`eval "\\$ECHO \"$libname_spec\""`
7697 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7698 set dummy $deplib_matches; shift
7700 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7701 func_append newdeplibs " $i"
7705 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7706 echo "*** I have the capability to make that library automatically link in when"
7707 echo "*** you link to this library. But I can only do this if you have a"
7708 echo "*** shared version of the library, which I believe you do not have"
7709 echo "*** because a test_compile did reveal that the linker did not use it for"
7710 echo "*** its dynamic dependency list that programs get resolved with at runtime."
7715 func_append newdeplibs " $i"
7720 # Error occurred in the first compile. Let's try to salvage
7721 # the situation: Compile a separate program for each library.
7722 for i in $deplibs; do
7725 func_stripname -l '' "$i"
7726 name=$func_stripname_result
7727 $opt_dry_run || $RM conftest
7728 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7729 ldd_output=`ldd conftest`
7730 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7731 case " $predeps $postdeps " in
7733 func_append newdeplibs " $i"
7738 if test -n "$i" ; then
7739 libname=`eval "\\$ECHO \"$libname_spec\""`
7740 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7741 set dummy $deplib_matches; shift
7743 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7744 func_append newdeplibs " $i"
7748 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7749 echo "*** I have the capability to make that library automatically link in when"
7750 echo "*** you link to this library. But I can only do this if you have a"
7751 echo "*** shared version of the library, which you do not appear to have"
7752 echo "*** because a test_compile did reveal that the linker did not use this one"
7753 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7759 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7760 echo "*** make it link in! You will probably need to install it or some"
7761 echo "*** library that it depends on before this library will be fully"
7762 echo "*** functional. Installing it before continuing would be even better."
7766 func_append newdeplibs " $i"
7773 set dummy $deplibs_check_method; shift
7774 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7775 for a_deplib in $deplibs; do
7778 func_stripname -l '' "$a_deplib"
7779 name=$func_stripname_result
7780 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7781 case " $predeps $postdeps " in
7783 func_append newdeplibs " $a_deplib"
7788 if test -n "$a_deplib" ; then
7789 libname=`eval "\\$ECHO \"$libname_spec\""`
7790 if test -n "$file_magic_glob"; then
7791 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7793 libnameglob=$libname
7795 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7796 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7797 if test "$want_nocaseglob" = yes; then
7799 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7802 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7804 for potent_lib in $potential_libs; do
7805 # Follow soft links.
7806 if ls -lLd "$potent_lib" 2>/dev/null |
7807 $GREP " -> " >/dev/null; then
7810 # The statement above tries to avoid entering an
7811 # endless loop below, in case of cyclic links.
7812 # We might still enter an endless loop, since a link
7813 # loop can be closed while we follow links,
7815 potlib="$potent_lib"
7816 while test -h "$potlib" 2>/dev/null; do
7817 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7819 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7820 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7823 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7825 $EGREP "$file_magic_regex" > /dev/null; then
7826 func_append newdeplibs " $a_deplib"
7833 if test -n "$a_deplib" ; then
7836 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7837 echo "*** I have the capability to make that library automatically link in when"
7838 echo "*** you link to this library. But I can only do this if you have a"
7839 echo "*** shared version of the library, which you do not appear to have"
7840 echo "*** because I did check the linker path looking for a file starting"
7841 if test -z "$potlib" ; then
7842 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7844 $ECHO "*** with $libname and none of the candidates passed a file format test"
7845 $ECHO "*** using a file magic. Last file checked: $potlib"
7850 # Add a -L argument.
7851 func_append newdeplibs " $a_deplib"
7854 done # Gone through all deplibs.
7857 set dummy $deplibs_check_method; shift
7858 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7859 for a_deplib in $deplibs; do
7862 func_stripname -l '' "$a_deplib"
7863 name=$func_stripname_result
7864 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7865 case " $predeps $postdeps " in
7867 func_append newdeplibs " $a_deplib"
7872 if test -n "$a_deplib" ; then
7873 libname=`eval "\\$ECHO \"$libname_spec\""`
7874 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7875 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7876 for potent_lib in $potential_libs; do
7877 potlib="$potent_lib" # see symlink-check above in file_magic test
7878 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7879 $EGREP "$match_pattern_regex" > /dev/null; then
7880 func_append newdeplibs " $a_deplib"
7887 if test -n "$a_deplib" ; then
7890 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7891 echo "*** I have the capability to make that library automatically link in when"
7892 echo "*** you link to this library. But I can only do this if you have a"
7893 echo "*** shared version of the library, which you do not appear to have"
7894 echo "*** because I did check the linker path looking for a file starting"
7895 if test -z "$potlib" ; then
7896 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7898 $ECHO "*** with $libname and none of the candidates passed a file format test"
7899 $ECHO "*** using a regex pattern. Last file checked: $potlib"
7904 # Add a -L argument.
7905 func_append newdeplibs " $a_deplib"
7908 done # Gone through all deplibs.
7912 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7913 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7914 for i in $predeps $postdeps ; do
7915 # can't use Xsed below, because $i might contain '/'
7916 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7919 case $tmp_deplibs in
7922 if test "X$deplibs_check_method" = "Xnone"; then
7923 echo "*** Warning: inter-library dependencies are not supported in this platform."
7925 echo "*** Warning: inter-library dependencies are not known to be supported."
7927 echo "*** All declared inter-library dependencies are being dropped."
7933 versuffix=$versuffix_save
7935 release=$release_save
7936 libname=$libname_save
7940 *-*-rhapsody* | *-*-darwin1.[012])
7941 # On Rhapsody replace the C library with the System framework
7942 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7946 if test "$droppeddeps" = yes; then
7947 if test "$module" = yes; then
7949 echo "*** Warning: libtool could not satisfy all declared inter-library"
7950 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7951 echo "*** a static module, that should work as long as the dlopening"
7952 echo "*** application is linked with the -dlopen flag."
7953 if test -z "$global_symbol_pipe"; then
7955 echo "*** However, this would only work if libtool was able to extract symbol"
7956 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7957 echo "*** not find such a program. So, this module is probably useless."
7958 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7960 if test "$build_old_libs" = no; then
7961 oldlibs="$output_objdir/$libname.$libext"
7962 build_libtool_libs=module
7965 build_libtool_libs=no
7968 echo "*** The inter-library dependencies that have been dropped here will be"
7969 echo "*** automatically added whenever a program is linked with this library"
7970 echo "*** or is declared to -dlopen it."
7972 if test "$allow_undefined" = no; then
7974 echo "*** Since this library must not contain undefined symbols,"
7975 echo "*** because either the platform does not support them or"
7976 echo "*** it was explicitly requested with -no-undefined,"
7977 echo "*** libtool will only create a static version of it."
7978 if test "$build_old_libs" = no; then
7979 oldlibs="$output_objdir/$libname.$libext"
7980 build_libtool_libs=module
7983 build_libtool_libs=no
7988 # Done checking deplibs!
7991 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7994 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7995 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7996 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8000 # move library search paths that coincide with paths to not yet
8001 # installed libraries to the beginning of the library search list
8003 for path in $notinst_path; do
8004 case " $new_libs " in
8005 *" -L$path/$objdir "*) ;;
8007 case " $deplibs " in
8008 *" -L$path/$objdir "*)
8009 func_append new_libs " -L$path/$objdir" ;;
8014 for deplib in $deplibs; do
8017 case " $new_libs " in
8019 *) func_append new_libs " $deplib" ;;
8022 *) func_append new_libs " $deplib" ;;
8027 # All the library-specific variables (install_libdir is set above).
8032 # Test again, we may have decided not to build it any more
8033 if test "$build_libtool_libs" = yes; then
8034 if test "$hardcode_into_libs" = yes; then
8035 # Hardcode the library paths
8038 rpath="$finalize_rpath"
8039 test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8040 for libdir in $rpath; do
8041 if test -n "$hardcode_libdir_flag_spec"; then
8042 if test -n "$hardcode_libdir_separator"; then
8043 func_replace_sysroot "$libdir"
8044 libdir=$func_replace_sysroot_result
8045 if test -z "$hardcode_libdirs"; then
8046 hardcode_libdirs="$libdir"
8048 # Just accumulate the unique libdirs.
8049 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8050 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8053 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8058 eval flag=\"$hardcode_libdir_flag_spec\"
8059 func_append dep_rpath " $flag"
8061 elif test -n "$runpath_var"; then
8062 case "$perm_rpath " in
8064 *) func_apped perm_rpath " $libdir" ;;
8068 # Substitute the hardcoded libdirs into the rpath.
8069 if test -n "$hardcode_libdir_separator" &&
8070 test -n "$hardcode_libdirs"; then
8071 libdir="$hardcode_libdirs"
8072 if test -n "$hardcode_libdir_flag_spec_ld"; then
8073 eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
8075 eval dep_rpath=\"$hardcode_libdir_flag_spec\"
8078 if test -n "$runpath_var" && test -n "$perm_rpath"; then
8079 # We should set the runpath_var.
8081 for dir in $perm_rpath; do
8082 func_append rpath "$dir:"
8084 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8086 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8089 shlibpath="$finalize_shlibpath"
8090 test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8091 if test -n "$shlibpath"; then
8092 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8095 # Get the real and link names of the library.
8096 eval shared_ext=\"$shrext_cmds\"
8097 eval library_names=\"$library_names_spec\"
8098 set dummy $library_names
8103 if test -n "$soname_spec"; then
8104 eval soname=\"$soname_spec\"
8108 if test -z "$dlname"; then
8112 lib="$output_objdir/$realname"
8116 func_append linknames " $link"
8119 # Use standard objects if they are pic
8120 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8121 test "X$libobjs" = "X " && libobjs=
8124 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8125 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8126 export_symbols="$output_objdir/$libname.uexp"
8127 func_append delfiles " $export_symbols"
8130 orig_export_symbols=
8132 cygwin* | mingw* | cegcc*)
8133 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8134 # exporting using user supplied symfile
8135 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8136 # and it's NOT already a .def file. Must figure out
8137 # which of the given symbols are data symbols and tag
8138 # them as such. So, trigger use of export_symbols_cmds.
8139 # export_symbols gets reassigned inside the "prepare
8140 # the list of exported symbols" if statement, so the
8141 # include_expsyms logic still works.
8142 orig_export_symbols="$export_symbols"
8144 always_export_symbols=yes
8150 # Prepare the list of exported symbols
8151 if test -z "$export_symbols"; then
8152 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8153 func_verbose "generating symbol list for \`$libname.la'"
8154 export_symbols="$output_objdir/$libname.exp"
8155 $opt_dry_run || $RM $export_symbols
8156 cmds=$export_symbols_cmds
8157 save_ifs="$IFS"; IFS='~'
8158 for cmd1 in $cmds; do
8160 # Take the normal branch if the nm_file_list_spec branch
8161 # doesn't work or if tool conversion is not needed.
8162 case $nm_file_list_spec~$to_tool_file_cmd in
8163 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8164 try_normal_branch=yes
8167 len=$func_len_result
8170 try_normal_branch=no
8173 if test "$try_normal_branch" = yes \
8174 && { test "$len" -lt "$max_cmd_len" \
8175 || test "$max_cmd_len" -le -1; }
8177 func_show_eval "$cmd" 'exit $?'
8178 skipped_export=false
8179 elif test -n "$nm_file_list_spec"; then
8180 func_basename "$output"
8181 output_la=$func_basename_result
8182 save_libobjs=$libobjs
8184 output=${output_objdir}/${output_la}.nm
8185 func_to_tool_file "$output"
8186 libobjs=$nm_file_list_spec$func_to_tool_file_result
8187 func_append delfiles " $output"
8188 func_verbose "creating $NM input file list: $output"
8189 for obj in $save_libobjs; do
8190 func_to_tool_file "$obj"
8191 $ECHO "$func_to_tool_file_result"
8194 func_show_eval "$cmd" 'exit $?'
8196 libobjs=$save_libobjs
8197 skipped_export=false
8199 # The command line is too long to execute in one step.
8200 func_verbose "using reloadable object file for export list..."
8202 # Break out early, otherwise skipped_export may be
8203 # set to false by a later but shorter cmd.
8208 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8209 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8210 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8215 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8216 tmp_export_symbols="$export_symbols"
8217 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8218 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8221 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8222 # The given exports_symbols file has to be filtered, so filter it.
8223 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8224 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8225 # 's' commands which not all seds can handle. GNU sed should be fine
8226 # though. Also, the filter scales superlinearly with the number of
8227 # global variables. join(1) would be nice here, but unfortunately
8228 # isn't a blessed tool.
8229 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8230 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8231 export_symbols=$output_objdir/$libname.def
8232 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8236 for test_deplib in $deplibs; do
8237 case " $convenience " in
8238 *" $test_deplib "*) ;;
8240 func_append tmp_deplibs " $test_deplib"
8244 deplibs="$tmp_deplibs"
8246 if test -n "$convenience"; then
8247 if test -n "$whole_archive_flag_spec" &&
8248 test "$compiler_needs_object" = yes &&
8249 test -z "$libobjs"; then
8250 # extract the archives, so we have objects to list.
8251 # TODO: could optimize this to just extract one archive.
8252 whole_archive_flag_spec=
8254 if test -n "$whole_archive_flag_spec"; then
8255 save_libobjs=$libobjs
8256 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8257 test "X$libobjs" = "X " && libobjs=
8259 gentop="$output_objdir/${outputname}x"
8260 func_append generated " $gentop"
8262 func_extract_archives $gentop $convenience
8263 func_append libobjs " $func_extract_archives_result"
8264 test "X$libobjs" = "X " && libobjs=
8268 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8269 eval flag=\"$thread_safe_flag_spec\"
8270 func_append linker_flags " $flag"
8273 # Make a backup of the uninstalled library when relinking
8274 if test "$opt_mode" = relink; then
8275 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8278 # Do each of the archive commands.
8279 if test "$module" = yes && test -n "$module_cmds" ; then
8280 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8281 eval test_cmds=\"$module_expsym_cmds\"
8282 cmds=$module_expsym_cmds
8284 eval test_cmds=\"$module_cmds\"
8288 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8289 eval test_cmds=\"$archive_expsym_cmds\"
8290 cmds=$archive_expsym_cmds
8292 eval test_cmds=\"$archive_cmds\"
8297 if test "X$skipped_export" != "X:" &&
8298 func_len " $test_cmds" &&
8299 len=$func_len_result &&
8300 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8303 # The command line is too long to link in one step, link piecewise
8304 # or, if using GNU ld and skipped_export is not :, use a linker
8307 # Save the value of $output and $libobjs because we want to
8308 # use them later. If we have whole_archive_flag_spec, we
8309 # want to use save_libobjs as it was before
8310 # whole_archive_flag_spec was expanded, because we can't
8311 # assume the linker understands whole_archive_flag_spec.
8312 # This may have to be revisited, in case too many
8313 # convenience libraries get linked in and end up exceeding
8315 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8316 save_libobjs=$libobjs
8319 func_basename "$output"
8320 output_la=$func_basename_result
8322 # Clear the reloadable object creation command queue and
8323 # initialize k to one.
8330 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8331 output=${output_objdir}/${output_la}.lnkscript
8332 func_verbose "creating GNU ld script: $output"
8333 echo 'INPUT (' > $output
8334 for obj in $save_libobjs
8336 func_to_tool_file "$obj"
8337 $ECHO "$func_to_tool_file_result" >> $output
8340 func_append delfiles " $output"
8341 func_to_tool_file "$output"
8342 output=$func_to_tool_file_result
8343 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8344 output=${output_objdir}/${output_la}.lnk
8345 func_verbose "creating linker input file list: $output"
8350 if test "$compiler_needs_object" = yes; then
8356 func_to_tool_file "$obj"
8357 $ECHO "$func_to_tool_file_result" >> $output
8359 func_append delfiles " $output"
8360 func_to_tool_file "$output"
8361 output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8363 if test -n "$save_libobjs"; then
8364 func_verbose "creating reloadable object files..."
8365 output=$output_objdir/$output_la-${k}.$objext
8366 eval test_cmds=\"$reload_cmds\"
8367 func_len " $test_cmds"
8368 len0=$func_len_result
8371 # Loop over the list of objects to be linked.
8372 for obj in $save_libobjs
8375 func_arith $len + $func_len_result
8376 len=$func_arith_result
8377 if test "X$objlist" = X ||
8378 test "$len" -lt "$max_cmd_len"; then
8379 func_append objlist " $obj"
8381 # The command $test_cmds is almost too long, add a
8382 # command to the queue.
8383 if test "$k" -eq 1 ; then
8384 # The first file doesn't have a previous command to add.
8385 reload_objs=$objlist
8386 eval concat_cmds=\"$reload_cmds\"
8388 # All subsequent reloadable object files will link in
8389 # the last one created.
8390 reload_objs="$objlist $last_robj"
8391 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8393 last_robj=$output_objdir/$output_la-${k}.$objext
8395 k=$func_arith_result
8396 output=$output_objdir/$output_la-${k}.$objext
8398 func_len " $last_robj"
8399 func_arith $len0 + $func_len_result
8400 len=$func_arith_result
8403 # Handle the remaining objects by creating one last
8404 # reloadable object file. All subsequent reloadable object
8405 # files will link in the last one created.
8406 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8407 reload_objs="$objlist $last_robj"
8408 eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8409 if test -n "$last_robj"; then
8410 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8412 func_append delfiles " $output"
8418 if ${skipped_export-false}; then
8419 func_verbose "generating symbol list for \`$libname.la'"
8420 export_symbols="$output_objdir/$libname.exp"
8421 $opt_dry_run || $RM $export_symbols
8423 # Append the command to create the export file.
8424 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8425 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8426 if test -n "$last_robj"; then
8427 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8431 test -n "$save_libobjs" &&
8432 func_verbose "creating a temporary reloadable object file: $output"
8434 # Loop through the commands generated above and execute them.
8435 save_ifs="$IFS"; IFS='~'
8436 for cmd in $concat_cmds; do
8439 func_quote_for_expand "$cmd"
8440 eval "func_echo $func_quote_for_expand_result"
8442 $opt_dry_run || eval "$cmd" || {
8445 # Restore the uninstalled library and exit
8446 if test "$opt_mode" = relink; then
8447 ( cd "$output_objdir" && \
8448 $RM "${realname}T" && \
8449 $MV "${realname}U" "$realname" )
8457 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8458 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8459 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8463 if ${skipped_export-false}; then
8464 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8465 tmp_export_symbols="$export_symbols"
8466 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8467 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8470 if test -n "$orig_export_symbols"; then
8471 # The given exports_symbols file has to be filtered, so filter it.
8472 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8473 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8474 # 's' commands which not all seds can handle. GNU sed should be fine
8475 # though. Also, the filter scales superlinearly with the number of
8476 # global variables. join(1) would be nice here, but unfortunately
8477 # isn't a blessed tool.
8478 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8479 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8480 export_symbols=$output_objdir/$libname.def
8481 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8486 # Restore the value of output.
8489 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8490 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8491 test "X$libobjs" = "X " && libobjs=
8493 # Expand the library linking commands again to reset the
8494 # value of $libobjs for piecewise linking.
8496 # Do each of the archive commands.
8497 if test "$module" = yes && test -n "$module_cmds" ; then
8498 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8499 cmds=$module_expsym_cmds
8504 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8505 cmds=$archive_expsym_cmds
8512 if test -n "$delfiles"; then
8513 # Append the command to remove temporary files to $cmds.
8514 eval cmds=\"\$cmds~\$RM $delfiles\"
8517 # Add any objects from preloaded convenience libraries
8518 if test -n "$dlprefiles"; then
8519 gentop="$output_objdir/${outputname}x"
8520 func_append generated " $gentop"
8522 func_extract_archives $gentop $dlprefiles
8523 func_append libobjs " $func_extract_archives_result"
8524 test "X$libobjs" = "X " && libobjs=
8527 save_ifs="$IFS"; IFS='~'
8528 for cmd in $cmds; do
8532 func_quote_for_expand "$cmd"
8533 eval "func_echo $func_quote_for_expand_result"
8535 $opt_dry_run || eval "$cmd" || {
8538 # Restore the uninstalled library and exit
8539 if test "$opt_mode" = relink; then
8540 ( cd "$output_objdir" && \
8541 $RM "${realname}T" && \
8542 $MV "${realname}U" "$realname" )
8550 # Restore the uninstalled library and exit
8551 if test "$opt_mode" = relink; then
8552 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8554 if test -n "$convenience"; then
8555 if test -z "$whole_archive_flag_spec"; then
8556 func_show_eval '${RM}r "$gentop"'
8563 # Create links to the real library.
8564 for linkname in $linknames; do
8565 if test "$realname" != "$linkname"; then
8566 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8570 # If -module or -export-dynamic was specified, set the dlname.
8571 if test "$module" = yes || test "$export_dynamic" = yes; then
8572 # On all known operating systems, these are identical.
8579 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8580 func_warning "\`-dlopen' is ignored for objects"
8585 func_warning "\`-l' and \`-L' are ignored for objects" ;;
8588 test -n "$rpath" && \
8589 func_warning "\`-rpath' is ignored for objects"
8591 test -n "$xrpath" && \
8592 func_warning "\`-R' is ignored for objects"
8594 test -n "$vinfo" && \
8595 func_warning "\`-version-info' is ignored for objects"
8597 test -n "$release" && \
8598 func_warning "\`-release' is ignored for objects"
8602 test -n "$objs$old_deplibs" && \
8603 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8607 obj=$func_lo2o_result
8615 # Delete the old objects.
8616 $opt_dry_run || $RM $obj $libobj
8618 # Objects from convenience libraries. This assumes
8619 # single-version convenience libraries. Whenever we create
8620 # different ones for PIC/non-PIC, this we'll have to duplicate
8624 # reload_cmds runs $LD directly, so let us get rid of
8625 # -Wl from whole_archive_flag_spec and hope we can get by with
8626 # turning comma into space..
8629 if test -n "$convenience"; then
8630 if test -n "$whole_archive_flag_spec"; then
8631 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8632 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8634 gentop="$output_objdir/${obj}x"
8635 func_append generated " $gentop"
8637 func_extract_archives $gentop $convenience
8638 reload_conv_objs="$reload_objs $func_extract_archives_result"
8642 # If we're not building shared, we need to use non_pic_objs
8643 test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8645 # Create the old-style object.
8646 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8649 func_execute_cmds "$reload_cmds" 'exit $?'
8651 # Exit if we aren't doing a library object file.
8652 if test -z "$libobj"; then
8653 if test -n "$gentop"; then
8654 func_show_eval '${RM}r "$gentop"'
8660 if test "$build_libtool_libs" != yes; then
8661 if test -n "$gentop"; then
8662 func_show_eval '${RM}r "$gentop"'
8665 # Create an invalid libtool object if no PIC, so that we don't
8666 # accidentally link it into a program.
8667 # $show "echo timestamp > $libobj"
8668 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8672 if test -n "$pic_flag" || test "$pic_mode" != default; then
8673 # Only do commands if we really have different PIC objects.
8674 reload_objs="$libobjs $reload_conv_objs"
8676 func_execute_cmds "$reload_cmds" 'exit $?'
8679 if test -n "$gentop"; then
8680 func_show_eval '${RM}r "$gentop"'
8688 *cygwin*) func_stripname '' '.exe' "$output"
8689 output=$func_stripname_result.exe;;
8691 test -n "$vinfo" && \
8692 func_warning "\`-version-info' is ignored for programs"
8694 test -n "$release" && \
8695 func_warning "\`-release' is ignored for programs"
8697 test "$preload" = yes \
8698 && test "$dlopen_support" = unknown \
8699 && test "$dlopen_self" = unknown \
8700 && test "$dlopen_self_static" = unknown && \
8701 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8704 *-*-rhapsody* | *-*-darwin1.[012])
8705 # On Rhapsody replace the C library is the System framework
8706 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8707 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8713 # Don't allow lazy linking, it breaks C++ global constructors
8714 # But is supposedly fixed on 10.4 or later (yay!).
8715 if test "$tagname" = CXX ; then
8716 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8718 func_append compile_command " ${wl}-bind_at_load"
8719 func_append finalize_command " ${wl}-bind_at_load"
8723 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8724 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8725 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730 # move library search paths that coincide with paths to not yet
8731 # installed libraries to the beginning of the library search list
8733 for path in $notinst_path; do
8734 case " $new_libs " in
8735 *" -L$path/$objdir "*) ;;
8737 case " $compile_deplibs " in
8738 *" -L$path/$objdir "*)
8739 func_append new_libs " -L$path/$objdir" ;;
8744 for deplib in $compile_deplibs; do
8747 case " $new_libs " in
8749 *) func_append new_libs " $deplib" ;;
8752 *) func_append new_libs " $deplib" ;;
8755 compile_deplibs="$new_libs"
8758 func_append compile_command " $compile_deplibs"
8759 func_append finalize_command " $finalize_deplibs"
8761 if test -n "$rpath$xrpath"; then
8762 # If the user specified any rpath flags, then add them.
8763 for libdir in $rpath $xrpath; do
8764 # This is the magic to use -rpath.
8765 case "$finalize_rpath " in
8767 *) func_append finalize_rpath " $libdir" ;;
8772 # Now hardcode the library paths
8775 for libdir in $compile_rpath $finalize_rpath; do
8776 if test -n "$hardcode_libdir_flag_spec"; then
8777 if test -n "$hardcode_libdir_separator"; then
8778 if test -z "$hardcode_libdirs"; then
8779 hardcode_libdirs="$libdir"
8781 # Just accumulate the unique libdirs.
8782 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8783 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8786 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8791 eval flag=\"$hardcode_libdir_flag_spec\"
8792 func_append rpath " $flag"
8794 elif test -n "$runpath_var"; then
8795 case "$perm_rpath " in
8797 *) func_append perm_rpath " $libdir" ;;
8801 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8802 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8803 case :$dllsearchpath: in
8805 ::) dllsearchpath=$libdir;;
8806 *) func_append dllsearchpath ":$libdir";;
8808 case :$dllsearchpath: in
8809 *":$testbindir:"*) ;;
8810 ::) dllsearchpath=$testbindir;;
8811 *) func_append dllsearchpath ":$testbindir";;
8816 # Substitute the hardcoded libdirs into the rpath.
8817 if test -n "$hardcode_libdir_separator" &&
8818 test -n "$hardcode_libdirs"; then
8819 libdir="$hardcode_libdirs"
8820 eval rpath=\" $hardcode_libdir_flag_spec\"
8822 compile_rpath="$rpath"
8826 for libdir in $finalize_rpath; do
8827 if test -n "$hardcode_libdir_flag_spec"; then
8828 if test -n "$hardcode_libdir_separator"; then
8829 if test -z "$hardcode_libdirs"; then
8830 hardcode_libdirs="$libdir"
8832 # Just accumulate the unique libdirs.
8833 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8834 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8837 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8842 eval flag=\"$hardcode_libdir_flag_spec\"
8843 func_append rpath " $flag"
8845 elif test -n "$runpath_var"; then
8846 case "$finalize_perm_rpath " in
8848 *) func_append finalize_perm_rpath " $libdir" ;;
8852 # Substitute the hardcoded libdirs into the rpath.
8853 if test -n "$hardcode_libdir_separator" &&
8854 test -n "$hardcode_libdirs"; then
8855 libdir="$hardcode_libdirs"
8856 eval rpath=\" $hardcode_libdir_flag_spec\"
8858 finalize_rpath="$rpath"
8860 if test -n "$libobjs" && test "$build_old_libs" = yes; then
8861 # Transform all the library objects into standard objects.
8862 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8863 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8866 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8868 # template prelinking step
8869 if test -n "$prelink_cmds"; then
8870 func_execute_cmds "$prelink_cmds" 'exit $?'
8873 wrappers_required=yes
8875 *cegcc* | *mingw32ce*)
8876 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8877 wrappers_required=no
8879 *cygwin* | *mingw* )
8880 if test "$build_libtool_libs" != yes; then
8881 wrappers_required=no
8885 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8886 wrappers_required=no
8890 if test "$wrappers_required" = no; then
8891 # Replace the output file specification.
8892 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8893 link_command="$compile_command$compile_rpath"
8895 # We have no uninstalled library dependencies, so finalize right now.
8897 func_show_eval "$link_command" 'exit_status=$?'
8899 if test -n "$postlink_cmds"; then
8900 func_to_tool_file "$output"
8901 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8902 func_execute_cmds "$postlink_cmds" 'exit $?'
8905 # Delete the generated files.
8906 if test -f "$output_objdir/${outputname}S.${objext}"; then
8907 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8913 if test -n "$compile_shlibpath$finalize_shlibpath"; then
8914 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8916 if test -n "$finalize_shlibpath"; then
8917 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8922 if test -n "$runpath_var"; then
8923 if test -n "$perm_rpath"; then
8924 # We should set the runpath_var.
8926 for dir in $perm_rpath; do
8927 func_append rpath "$dir:"
8929 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8931 if test -n "$finalize_perm_rpath"; then
8932 # We should set the runpath_var.
8934 for dir in $finalize_perm_rpath; do
8935 func_append rpath "$dir:"
8937 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8941 if test "$no_install" = yes; then
8942 # We don't need to create a wrapper script.
8943 link_command="$compile_var$compile_command$compile_rpath"
8944 # Replace the output file specification.
8945 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8946 # Delete the old output file.
8947 $opt_dry_run || $RM $output
8948 # Link the executable and exit
8949 func_show_eval "$link_command" 'exit $?'
8951 if test -n "$postlink_cmds"; then
8952 func_to_tool_file "$output"
8953 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8954 func_execute_cmds "$postlink_cmds" 'exit $?'
8960 if test "$hardcode_action" = relink; then
8961 # Fast installation is not supported
8962 link_command="$compile_var$compile_command$compile_rpath"
8963 relink_command="$finalize_var$finalize_command$finalize_rpath"
8965 func_warning "this platform does not like uninstalled shared libraries"
8966 func_warning "\`$output' will be relinked during installation"
8968 if test "$fast_install" != no; then
8969 link_command="$finalize_var$compile_command$finalize_rpath"
8970 if test "$fast_install" = yes; then
8971 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8973 # fast_install is set to needless
8977 link_command="$compile_var$compile_command$compile_rpath"
8978 relink_command="$finalize_var$finalize_command$finalize_rpath"
8982 # Replace the output file specification.
8983 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8985 # Delete the old output files.
8986 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8988 func_show_eval "$link_command" 'exit $?'
8990 if test -n "$postlink_cmds"; then
8991 func_to_tool_file "$output_objdir/$outputname"
8992 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'`
8993 func_execute_cmds "$postlink_cmds" 'exit $?'
8996 # Now create the wrapper script.
8997 func_verbose "creating $output"
8999 # Quote the relink command for shipping.
9000 if test -n "$relink_command"; then
9001 # Preserve any variables that may affect compiler behavior
9002 for var in $variables_saved_for_relink; do
9003 if eval test -z \"\${$var+set}\"; then
9004 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9005 elif eval var_value=\$$var; test -z "$var_value"; then
9006 relink_command="$var=; export $var; $relink_command"
9008 func_quote_for_eval "$var_value"
9009 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9012 relink_command="(cd `pwd`; $relink_command)"
9013 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9016 # Only actually do things if not in dry run mode.
9018 # win32 will think the script is a binary if it has
9019 # a .exe suffix, so we strip it off here.
9021 *.exe) func_stripname '' '.exe' "$output"
9022 output=$func_stripname_result ;;
9024 # test for cygwin because mv fails w/o .exe extensions
9028 func_stripname '' '.exe' "$outputname"
9029 outputname=$func_stripname_result ;;
9033 *cygwin* | *mingw* )
9034 func_dirname_and_basename "$output" "" "."
9035 output_name=$func_basename_result
9036 output_path=$func_dirname_result
9037 cwrappersource="$output_path/$objdir/lt-$output_name.c"
9038 cwrapper="$output_path/$output_name.exe"
9039 $RM $cwrappersource $cwrapper
9040 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9042 func_emit_cwrapperexe_src > $cwrappersource
9044 # The wrapper executable is built using the $host compiler,
9045 # because it contains $host paths and files. If cross-
9046 # compiling, it, like the target executable, must be
9047 # executed on the $host or under an emulation environment.
9049 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9053 # Now, create the wrapper script for func_source use:
9054 func_ltwrapper_scriptname $cwrapper
9055 $RM $func_ltwrapper_scriptname_result
9056 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9058 # note: this script will not be executed, so do not chmod.
9059 if test "x$build" = "x$host" ; then
9060 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9062 func_emit_wrapper no > $func_ltwrapper_scriptname_result
9068 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9070 func_emit_wrapper no > $output
9079 # See if we need to build an old-fashioned archive.
9080 for oldlib in $oldlibs; do
9082 if test "$build_libtool_libs" = convenience; then
9083 oldobjs="$libobjs_save $symfileobj"
9084 addlibs="$convenience"
9085 build_libtool_libs=no
9087 if test "$build_libtool_libs" = module; then
9088 oldobjs="$libobjs_save"
9089 build_libtool_libs=no
9091 oldobjs="$old_deplibs $non_pic_objects"
9092 if test "$preload" = yes && test -f "$symfileobj"; then
9093 func_append oldobjs " $symfileobj"
9096 addlibs="$old_convenience"
9099 if test -n "$addlibs"; then
9100 gentop="$output_objdir/${outputname}x"
9101 func_append generated " $gentop"
9103 func_extract_archives $gentop $addlibs
9104 func_append oldobjs " $func_extract_archives_result"
9107 # Do each command in the archive commands.
9108 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9109 cmds=$old_archive_from_new_cmds
9112 # Add any objects from preloaded convenience libraries
9113 if test -n "$dlprefiles"; then
9114 gentop="$output_objdir/${outputname}x"
9115 func_append generated " $gentop"
9117 func_extract_archives $gentop $dlprefiles
9118 func_append oldobjs " $func_extract_archives_result"
9121 # POSIX demands no paths to be encoded in archives. We have
9122 # to avoid creating archives with duplicate basenames if we
9123 # might have to extract them afterwards, e.g., when creating a
9124 # static archive out of a convenience library, or when linking
9125 # the entirety of a libtool archive into another (currently
9126 # not supported by libtool).
9127 if (for obj in $oldobjs
9129 func_basename "$obj"
9130 $ECHO "$func_basename_result"
9131 done | sort | sort -uc >/dev/null 2>&1); then
9134 echo "copying selected object files to avoid basename conflicts..."
9135 gentop="$output_objdir/${outputname}x"
9136 func_append generated " $gentop"
9137 func_mkdir_p "$gentop"
9138 save_oldobjs=$oldobjs
9141 for obj in $save_oldobjs
9143 func_basename "$obj"
9144 objbase="$func_basename_result"
9145 case " $oldobjs " in
9146 " ") oldobjs=$obj ;;
9149 # Make sure we don't pick an alternate name that also
9151 newobj=lt$counter-$objbase
9152 func_arith $counter + 1
9153 counter=$func_arith_result
9154 case " $oldobjs " in
9155 *[\ /]"$newobj "*) ;;
9156 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9159 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9160 func_append oldobjs " $gentop/$newobj"
9162 *) func_append oldobjs " $obj" ;;
9166 eval cmds=\"$old_archive_cmds\"
9169 len=$func_len_result
9170 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9171 cmds=$old_archive_cmds
9172 elif test -n "$archiver_list_spec"; then
9173 func_verbose "using command file archive linking..."
9176 func_to_tool_file "$obj"
9177 $ECHO "$func_to_tool_file_result"
9178 done > $output_objdir/$libname.libcmd
9179 func_to_tool_file "$output_objdir/$libname.libcmd"
9180 oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9181 cmds=$old_archive_cmds
9183 # the command line is too long to link in one step, link in parts
9184 func_verbose "using piecewise archive linking..."
9189 save_oldobjs=$oldobjs
9191 # Is there a better way of finding the last object in the list?
9192 for obj in $save_oldobjs
9196 eval test_cmds=\"$old_archive_cmds\"
9197 func_len " $test_cmds"
9198 len0=$func_len_result
9200 for obj in $save_oldobjs
9203 func_arith $len + $func_len_result
9204 len=$func_arith_result
9205 func_append objlist " $obj"
9206 if test "$len" -lt "$max_cmd_len"; then
9209 # the above command should be used before it gets too long
9211 if test "$obj" = "$last_oldobj" ; then
9214 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9215 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9222 if test "X$oldobjs" = "X" ; then
9223 eval cmds=\"\$concat_cmds\"
9225 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9229 func_execute_cmds "$cmds" 'exit $?'
9232 test -n "$generated" && \
9233 func_show_eval "${RM}r$generated"
9235 # Now create the libtool archive.
9239 test "$build_old_libs" = yes && old_library="$libname.$libext"
9240 func_verbose "creating $output"
9242 # Preserve any variables that may affect compiler behavior
9243 for var in $variables_saved_for_relink; do
9244 if eval test -z \"\${$var+set}\"; then
9245 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9246 elif eval var_value=\$$var; test -z "$var_value"; then
9247 relink_command="$var=; export $var; $relink_command"
9249 func_quote_for_eval "$var_value"
9250 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9253 # Quote the link command for shipping.
9254 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9255 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9256 if test "$hardcode_automatic" = yes ; then
9260 # Only create the output if not a dry run.
9262 for installed in no yes; do
9263 if test "$installed" = yes; then
9264 if test -z "$install_libdir"; then
9267 output="$output_objdir/$outputname"i
9268 # Replace all uninstalled libtool libraries with the installed ones
9270 for deplib in $dependency_libs; do
9273 func_basename "$deplib"
9274 name="$func_basename_result"
9275 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
9276 test -z "$libdir" && \
9277 func_fatal_error "\`$deplib' is not a valid libtool archive"
9278 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9281 func_stripname -L '' "$deplib"
9282 func_replace_sysroot "$func_stripname_result"
9283 func_append newdependency_libs " -L$func_replace_sysroot_result"
9286 func_stripname -R '' "$deplib"
9287 func_replace_sysroot "$func_stripname_result"
9288 func_append newdependency_libs " -R$func_replace_sysroot_result"
9290 *) func_append newdependency_libs " $deplib" ;;
9293 dependency_libs="$newdependency_libs"
9296 for lib in $dlfiles; do
9299 func_basename "$lib"
9300 name="$func_basename_result"
9301 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9302 test -z "$libdir" && \
9303 func_fatal_error "\`$lib' is not a valid libtool archive"
9304 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9306 *) func_append newdlfiles " $lib" ;;
9309 dlfiles="$newdlfiles"
9311 for lib in $dlprefiles; do
9314 # Only pass preopened files to the pseudo-archive (for
9315 # eventual linking with the app. that links it) if we
9316 # didn't already link the preopened objects directly into
9318 func_basename "$lib"
9319 name="$func_basename_result"
9320 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9321 test -z "$libdir" && \
9322 func_fatal_error "\`$lib' is not a valid libtool archive"
9323 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9327 dlprefiles="$newdlprefiles"
9330 for lib in $dlfiles; do
9332 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9333 *) abs=`pwd`"/$lib" ;;
9335 func_append newdlfiles " $abs"
9337 dlfiles="$newdlfiles"
9339 for lib in $dlprefiles; do
9341 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9342 *) abs=`pwd`"/$lib" ;;
9344 func_append newdlprefiles " $abs"
9346 dlprefiles="$newdlprefiles"
9349 # place dlname in correct position for cygwin
9350 # In fact, it would be nice if we could use this code for all target
9351 # systems that can't hard-code library paths into their executables
9352 # and that have no shared library path variable independent of PATH,
9353 # but it turns out we can't easily determine that from inspecting
9354 # libtool variables, so we have to hard-code the OSs to which it
9355 # applies here; at the moment, that means platforms that use the PE
9356 # object format with DLL files. See the long comment at the top of
9357 # tests/bindir.at for full details.
9359 case $host,$output,$installed,$module,$dlname in
9360 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9361 # If a -bindir argument was supplied, place the dll there.
9362 if test "x$bindir" != x ;
9364 func_relative_path "$install_libdir" "$bindir"
9365 tdlname=$func_relative_path_result$dlname
9367 # Otherwise fall back on heuristic.
9368 tdlname=../bin/$dlname
9373 # $outputname - a libtool library file
9374 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9376 # Please DO NOT delete this file!
9377 # It is necessary for linking the library.
9379 # The name that we can dlopen(3).
9382 # Names of this library.
9383 library_names='$library_names'
9385 # The name of the static archive.
9386 old_library='$old_library'
9388 # Linker flags that can not go in dependency_libs.
9389 inherited_linker_flags='$new_inherited_linker_flags'
9391 # Libraries that this one depends upon.
9392 dependency_libs='$dependency_libs'
9394 # Names of additional weak libraries provided by this library
9395 weak_library_names='$weak_libs'
9397 # Version information for $libname.
9402 # Is this an already installed library?
9403 installed=$installed
9405 # Should we warn about portability when linking against -modules?
9406 shouldnotlink=$module
9408 # Files to dlopen/dlpreopen
9410 dlpreopen='$dlprefiles'
9412 # Directory that this library needs to be installed in:
9413 libdir='$install_libdir'"
9414 if test "$installed" = no && test "$need_relink" = yes; then
9416 relink_command=\"$relink_command\""
9421 # Do a symbolic link so that the libtool archive can be found in
9422 # LD_LIBRARY_PATH before the program is installed.
9423 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9429 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9430 func_mode_link ${1+"$@"}
9433 # func_mode_uninstall arg...
9434 func_mode_uninstall ()
9442 # This variable tells wrapper scripts just to set variables rather
9443 # than running their programs.
9444 libtool_install_magic="$magic"
9449 -f) func_append RM " $arg"; rmforce=yes ;;
9450 -*) func_append RM " $arg" ;;
9451 *) func_append files " $arg" ;;
9456 func_fatal_help "you must specify an RM program"
9460 for file in $files; do
9461 func_dirname "$file" "" "."
9462 dir="$func_dirname_result"
9463 if test "X$dir" = X.; then
9468 func_basename "$file"
9469 name="$func_basename_result"
9470 test "$opt_mode" = uninstall && odir="$dir"
9472 # Remember odir for removal later, being careful to avoid duplicates
9473 if test "$opt_mode" = clean; then
9476 *) func_append rmdirs " $odir" ;;
9480 # Don't error if the file doesn't exist and rm -f was used.
9481 if { test -L "$file"; } >/dev/null 2>&1 ||
9482 { test -h "$file"; } >/dev/null 2>&1 ||
9483 test -f "$file"; then
9485 elif test -d "$file"; then
9488 elif test "$rmforce" = yes; then
9496 # Possibly a libtool archive, so verify it.
9497 if func_lalib_p "$file"; then
9498 func_source $dir/$name
9500 # Delete the libtool libraries and symlinks.
9501 for n in $library_names; do
9502 func_append rmfiles " $odir/$n"
9504 test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9508 case " $library_names " in
9510 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9512 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9515 if test -n "$library_names"; then
9516 # Do each command in the postuninstall commands.
9517 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9520 if test -n "$old_library"; then
9521 # Do each command in the old_postuninstall commands.
9522 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9524 # FIXME: should reinstall the best remaining shared library.
9531 # Possibly a libtool object, so verify it.
9532 if func_lalib_p "$file"; then
9535 func_source $dir/$name
9537 # Add PIC object to the list of files to remove.
9538 if test -n "$pic_object" &&
9539 test "$pic_object" != none; then
9540 func_append rmfiles " $dir/$pic_object"
9543 # Add non-PIC object to the list of files to remove.
9544 if test -n "$non_pic_object" &&
9545 test "$non_pic_object" != none; then
9546 func_append rmfiles " $dir/$non_pic_object"
9552 if test "$opt_mode" = clean ; then
9556 func_stripname '' '.exe' "$file"
9557 file=$func_stripname_result
9558 func_stripname '' '.exe' "$name"
9559 noexename=$func_stripname_result
9560 # $file with .exe has already been added to rmfiles,
9561 # add $file without .exe
9562 func_append rmfiles " $file"
9565 # Do a test to see if this is a libtool program.
9566 if func_ltwrapper_p "$file"; then
9567 if func_ltwrapper_executable_p "$file"; then
9568 func_ltwrapper_scriptname "$file"
9570 func_source $func_ltwrapper_scriptname_result
9571 func_append rmfiles " $func_ltwrapper_scriptname_result"
9574 func_source $dir/$noexename
9577 # note $name still contains .exe if it was in $file originally
9578 # as does the version of $file that was added into $rmfiles
9579 func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9580 if test "$fast_install" = yes && test -n "$relink_command"; then
9581 func_append rmfiles " $odir/lt-$name"
9583 if test "X$noexename" != "X$name" ; then
9584 func_append rmfiles " $odir/lt-${noexename}.c"
9590 func_show_eval "$RM $rmfiles" 'exit_status=1'
9593 # Try to remove the ${objdir}s in the directories where we deleted files
9594 for dir in $rmdirs; do
9595 if test -d "$dir"; then
9596 func_show_eval "rmdir $dir >/dev/null 2>&1"
9603 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9604 func_mode_uninstall ${1+"$@"}
9606 test -z "$opt_mode" && {
9607 help="$generic_help"
9608 func_fatal_help "you must specify a MODE"
9611 test -z "$exec_cmd" && \
9612 func_fatal_help "invalid operation mode \`$opt_mode'"
9614 if test -n "$exec_cmd"; then
9615 eval exec "$exec_cmd"
9622 # The TAGs below are defined such that we never get into a situation
9623 # in which we disable both kinds of libraries. Given conflicting
9624 # choices, we go for a static library, that is the most portable,
9625 # since we can't tell whether shared libraries were disabled because
9626 # the user asked for that or because the platform doesn't support
9627 # them. This is particularly important on AIX, because we don't
9628 # support having both static and shared libraries enabled at the same
9629 # time on that platform, so we default to a shared-only configuration.
9630 # If a disable-shared tag is given, we'll fallback to a static-only
9631 # configuration. But we'll never go from static-only to shared-only.
9633 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9634 build_libtool_libs=no
9636 # ### END LIBTOOL TAG CONFIG: disable-shared
9638 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9639 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9640 # ### END LIBTOOL TAG CONFIG: disable-static