2 # libtool (GNU libtool) 2.4.2
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, 2011 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 # --no-warn don't display warning messages
45 # --tag=TAG use configuration variables from tag TAG
46 # -v, --verbose print more informational messages than default
47 # --no-verbose don't print the extra informational messages
48 # --version print version information
49 # -h, --help, --help-all print short, long, or detailed help message
51 # MODE must be one of the following:
53 # clean remove files from the build directory
54 # compile compile a source file into a libtool object
55 # execute automatically set library path, then run a program
56 # finish complete the installation of libtool libraries
57 # install install libraries or executables
58 # link create a library or an executable
59 # uninstall remove libraries from an installed directory
61 # MODE-ARGS vary depending on the MODE. When passed as first option,
62 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
63 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
65 # When reporting a bug, please describe a test case to reproduce it and
66 # include the following information:
71 # compiler flags: $LTCFLAGS
72 # linker: $LD (gnu? $with_gnu_ld)
73 # $progname: (GNU libtool) 2.4.2
74 # automake: $automake_version
75 # autoconf: $autoconf_version
77 # Report bugs to <bug-libtool@gnu.org>.
78 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
79 # General help using GNU software: <http://www.gnu.org/gethelp/>.
85 package_revision
=1.3337
87 # Be Bourne compatible
88 if test -n "${ZSH_VERSION+set}" && (emulate sh
) >/dev
/null
2>&1; then
91 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
92 # is contrary to our usage. Disable this feature.
93 alias -g '${1+"$@"}'='"$@"'
96 case `(set -o) 2>/dev/null` in *posix
*) set -o posix
;; esac
98 BIN_SH
=xpg4
; export BIN_SH
# for Tru64
99 DUALCASE
=1; export DUALCASE
# for MKS sh
101 # A function that is used when there is no print builtin or printf.
102 func_fallback_echo
()
104 eval 'cat <<_LTECHO_EOF
109 # NLS nuisances: We save the old values to restore during execute mode.
112 for lt_var
in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
114 eval "if test \"\${$lt_var+set}\" = set; then
115 save_$lt_var=\$$lt_var
118 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
119 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
124 export LANGUAGE LC_ALL
129 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
130 # is ksh but when the shell is invoked as "sh" and the current value of
131 # the _XPG environment variable is not equal to 1 (one), the special
132 # positional parameter $0, within a function call, is the name of the
139 test "${ECHO+set}" = set || ECHO
=${as_echo-'printf %s\n'}
144 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
145 : ${Xsed="$SED -e 1s/^X//"}
150 EXIT_MISMATCH
=63 # $? = 63 is used to indicate version mismatch to missing.
151 EXIT_SKIP
=77 # $? = 77 is used to indicate a skipped test to automake.
153 exit_status
=$EXIT_SUCCESS
155 # Make sure IFS has a sensible default
160 dirname="s,/[^/]*$,,"
163 # func_dirname file append nondir_replacement
164 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
165 # otherwise set result to NONDIR_REPLACEMENT.
168 func_dirname_result
=`$ECHO "${1}" | $SED "$dirname"`
169 if test "X$func_dirname_result" = "X${1}"; then
170 func_dirname_result
="${3}"
172 func_dirname_result
="$func_dirname_result${2}"
174 } # func_dirname may be replaced by extended shell implementation
180 func_basename_result
=`$ECHO "${1}" | $SED "$basename"`
181 } # func_basename may be replaced by extended shell implementation
184 # func_dirname_and_basename file append nondir_replacement
185 # perform func_basename and func_dirname in a single function
187 # dirname: Compute the dirname of FILE. If nonempty,
188 # add APPEND to the result, otherwise set result
189 # to NONDIR_REPLACEMENT.
190 # value returned in "$func_dirname_result"
191 # basename: Compute filename of FILE.
192 # value retuned in "$func_basename_result"
193 # Implementation must be kept synchronized with func_dirname
194 # and func_basename. For efficiency, we do not delegate to
195 # those functions but instead duplicate the functionality here.
196 func_dirname_and_basename
()
198 # Extract subdirectory from the argument.
199 func_dirname_result
=`$ECHO "${1}" | $SED -e "$dirname"`
200 if test "X$func_dirname_result" = "X${1}"; then
201 func_dirname_result
="${3}"
203 func_dirname_result
="$func_dirname_result${2}"
205 func_basename_result
=`$ECHO "${1}" | $SED -e "$basename"`
206 } # func_dirname_and_basename may be replaced by extended shell implementation
209 # func_stripname prefix suffix name
210 # strip PREFIX and SUFFIX off of NAME.
211 # PREFIX and SUFFIX must not contain globbing or regex special
212 # characters, hashes, percent signs, but SUFFIX may contain a leading
213 # dot (in which case that matches only a dot).
214 # func_strip_suffix prefix name
218 .
*) func_stripname_result
=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
219 *) func_stripname_result
=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
221 } # func_stripname may be replaced by extended shell implementation
224 # These SED scripts presuppose an absolute path with a trailing slash.
225 pathcar
='s,^/\([^/]*\).*$,\1,'
226 pathcdr
='s,^/[^/]*,,'
227 removedotparts
=':dotsl
231 collapseslashes
='s@/\{1,\}@/@g'
232 finalslash
='s,/*$,/,'
234 # func_normal_abspath PATH
235 # Remove doubled-up and trailing slashes, "." path components,
236 # and cancel out any ".." path components in PATH after making
237 # it an absolute path.
238 # value returned in "$func_normal_abspath_result"
239 func_normal_abspath
()
241 # Start from root dir and reassemble the path.
242 func_normal_abspath_result
=
243 func_normal_abspath_tpath
=$1
244 func_normal_abspath_altnamespace
=
245 case $func_normal_abspath_tpath in
247 # Empty path, that just means $cwd.
248 func_stripname
'' '/' "`pwd`"
249 func_normal_abspath_result
=$func_stripname_result
252 # The next three entries are used to spot a run of precisely
253 # two leading slashes without using negated character classes;
254 # we take advantage of case's first-match behaviour.
256 # Unusual form of absolute path, do nothing.
259 # Not necessarily an ordinary path; POSIX reserves leading '//'
260 # and for example Cygwin uses it to access remote file shares
261 # over CIFS/SMB, so we conserve a leading double slash if found.
262 func_normal_abspath_altnamespace
=/
265 # Absolute path, do nothing.
268 # Relative path, prepend $cwd.
269 func_normal_abspath_tpath
=`pwd`/$func_normal_abspath_tpath
272 # Cancel out all the simple stuff to save iterations. We also want
273 # the path to end with a slash for ease of parsing, so make sure
274 # there is one (and only one) here.
275 func_normal_abspath_tpath
=`$ECHO "$func_normal_abspath_tpath" | $SED \
276 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
278 # Processed it all yet?
279 if test "$func_normal_abspath_tpath" = / ; then
280 # If we ascended to the root using ".." the result may be empty now.
281 if test -z "$func_normal_abspath_result" ; then
282 func_normal_abspath_result
=/
286 func_normal_abspath_tcomponent
=`$ECHO "$func_normal_abspath_tpath" | $SED \
288 func_normal_abspath_tpath
=`$ECHO "$func_normal_abspath_tpath" | $SED \
290 # Figure out what to do with it
291 case $func_normal_abspath_tcomponent in
293 # Trailing empty path component, ignore it.
296 # Parent dir; strip last assembled component from result.
297 func_dirname
"$func_normal_abspath_result"
298 func_normal_abspath_result
=$func_dirname_result
301 # Actual path component, append it.
302 func_normal_abspath_result
=$func_normal_abspath_result/$func_normal_abspath_tcomponent
306 # Restore leading double-slash if one was found on entry.
307 func_normal_abspath_result
=$func_normal_abspath_altnamespace$func_normal_abspath_result
310 # func_relative_path SRCDIR DSTDIR
311 # generates a relative path from SRCDIR to DSTDIR, with a trailing
312 # slash if non-empty, suitable for immediately appending a filename
313 # without needing to append a separator.
314 # value returned in "$func_relative_path_result"
315 func_relative_path
()
317 func_relative_path_result
=
318 func_normal_abspath
"$1"
319 func_relative_path_tlibdir
=$func_normal_abspath_result
320 func_normal_abspath
"$2"
321 func_relative_path_tbindir
=$func_normal_abspath_result
323 # Ascend the tree starting from libdir
325 # check if we have found a prefix of bindir
326 case $func_relative_path_tbindir in
327 $func_relative_path_tlibdir)
328 # found an exact match
329 func_relative_path_tcancelled
=
332 $func_relative_path_tlibdir*)
333 # found a matching prefix
334 func_stripname
"$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
335 func_relative_path_tcancelled
=$func_stripname_result
336 if test -z "$func_relative_path_result"; then
337 func_relative_path_result
=.
342 func_dirname
$func_relative_path_tlibdir
343 func_relative_path_tlibdir
=${func_dirname_result}
344 if test "x$func_relative_path_tlibdir" = x
; then
345 # Have to descend all the way to the root!
346 func_relative_path_result
=..
/$func_relative_path_result
347 func_relative_path_tcancelled
=$func_relative_path_tbindir
350 func_relative_path_result
=..
/$func_relative_path_result
355 # Now calculate path; take care to avoid doubling-up slashes.
356 func_stripname
'' '/' "$func_relative_path_result"
357 func_relative_path_result
=$func_stripname_result
358 func_stripname
'/' '/' "$func_relative_path_tcancelled"
359 if test "x$func_stripname_result" != x
; then
360 func_relative_path_result
=${func_relative_path_result}/${func_stripname_result}
363 # Normalisation. If bindir is libdir, return empty string,
364 # else relative path ending with a slash; either way, target
365 # file name can be directly appended.
366 if test ! -z "$func_relative_path_result"; then
367 func_stripname
'./' '' "$func_relative_path_result/"
368 func_relative_path_result
=$func_stripname_result
372 # The name of this program:
373 func_dirname_and_basename
"$progpath"
374 progname
=$func_basename_result
376 # Make sure we have an absolute path for reexecution:
378 [\\/]*|
[A-Za-z
]:\\*) ;;
380 progdir
=$func_dirname_result
381 progdir
=`cd "$progdir" && pwd`
382 progpath
="$progdir/$progname"
386 IFS
=${PATH_SEPARATOR-:}
387 for progdir
in $PATH; do
389 test -x "$progdir/$progname" && break
392 test -n "$progdir" || progdir
=`pwd`
393 progpath
="$progdir/$progname"
397 # Sed substitution that helps us do robust quoting. It backslashifies
398 # metacharacters that are still active within double-quoted strings.
399 Xsed
="${SED}"' -e 1s/^X//'
400 sed_quote_subst
='s/\([`"$\\]\)/\\\1/g'
402 # Same as above, but do not quote variable references.
403 double_quote_subst
='s/\(["`\\]\)/\\\1/g'
405 # Sed substitution that turns a string into a regex matching for the
407 sed_make_literal_regex
='s,[].[^$\\*\/],\\&,g'
409 # Sed substitution that converts a w32 file name or path
410 # which contains forward slashes, into one that contains
411 # (escaped) backslashes. A very naive implementation.
412 lt_sed_naive_backslashify
='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
414 # Re-`\' parameter expansions in output of double_quote_subst that were
415 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
416 # in input to double_quote_subst, that '$' was protected from expansion.
417 # Since each input `\' is now two `\'s, look for any number of runs of
418 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
423 sed_double_backslash
="\
427 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
438 # Echo program name prefixed message, along with the current mode
439 # name if it has been set yet.
442 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
445 # func_verbose arg...
446 # Echo program name prefixed message in verbose mode only.
449 $opt_verbose && func_echo
${1+"$@"}
451 # A bug in bash halts the script if the last line of a function
452 # fails when set -e is in force, so we need another command to
457 # func_echo_all arg...
458 # Invoke $ECHO with all args, space-separated.
465 # Echo program name prefixed message to standard error.
468 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
471 # func_warning arg...
472 # Echo program name prefixed warning message to standard error.
475 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
481 # func_fatal_error arg...
482 # Echo program name prefixed message to standard error, and exit.
489 # func_fatal_help arg...
490 # Echo program name prefixed message to standard error, followed by
491 # a help hint, and exit.
495 func_fatal_error
"$help"
497 help="Try \`$progname --help' for more information." ## default
500 # func_grep expression filename
501 # Check whether EXPRESSION matches any line of FILENAME, without output.
504 $GREP "$1" "$2" >/dev
/null
2>&1
508 # func_mkdir_p directory-path
509 # Make sure the entire path to DIRECTORY-PATH is available.
512 my_directory_path
="$1"
515 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
517 # Protect directory names starting with `-'
518 case $my_directory_path in
519 -*) my_directory_path
="./$my_directory_path" ;;
522 # While some portion of DIR does not yet exist...
523 while test ! -d "$my_directory_path"; do
524 # ...make a list in topmost first order. Use a colon delimited
525 # list incase some portion of path contains whitespace.
526 my_dir_list
="$my_directory_path:$my_dir_list"
528 # If the last portion added has no slash in it, the list is done
529 case $my_directory_path in */*) ;; *) break ;; esac
531 # ...otherwise throw away the child directory and loop
532 my_directory_path
=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
534 my_dir_list
=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
536 save_mkdir_p_IFS
="$IFS"; IFS
=':'
537 for my_dir
in $my_dir_list; do
538 IFS
="$save_mkdir_p_IFS"
539 # mkdir can fail with a `File exist' error if two processes
540 # try to create one of the directories concurrently. Don't
542 $MKDIR "$my_dir" 2>/dev
/null ||
:
544 IFS
="$save_mkdir_p_IFS"
546 # Bail out if we (or some other process) failed to create a directory.
547 test -d "$my_directory_path" || \
548 func_fatal_error
"Failed to create \`$1'"
553 # func_mktempdir [string]
554 # Make a temporary directory that won't clash with other running
555 # libtool processes, and avoids race conditions if possible. If
556 # given, STRING is the basename for that directory.
559 my_template
="${TMPDIR-/tmp}/${1-$progname}"
561 if test "$opt_dry_run" = ":"; then
562 # Return a directory name, but don't create it in dry-run mode
563 my_tmpdir
="${my_template}-$$"
566 # If mktemp works, use that first and foremost
567 my_tmpdir
=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
569 if test ! -d "$my_tmpdir"; then
570 # Failing that, at least try and use $RANDOM to avoid a race
571 my_tmpdir
="${my_template}-${RANDOM-0}$$"
573 save_mktempdir_umask
=`umask`
576 umask $save_mktempdir_umask
579 # If we're not in dry-run mode, bomb out on failure
580 test -d "$my_tmpdir" || \
581 func_fatal_error
"cannot create temporary directory \`$my_tmpdir'"
588 # func_quote_for_eval arg
589 # Aesthetically quote ARG to be evaled later.
590 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
591 # is double-quoted, suitable for a subsequent eval, whereas
592 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
593 # which are still active within double quotes backslashified.
594 func_quote_for_eval
()
598 func_quote_for_eval_unquoted_result=`$ECHO "$1" |
$SED "$sed_quote_subst"` ;;
600 func_quote_for_eval_unquoted_result="$1" ;;
603 case $func_quote_for_eval_unquoted_result in
604 # Double-quote args containing shell metacharacters to delay
605 # word splitting, command substitution and and variable
606 # expansion for a subsequent eval.
607 # Many Bourne shells cannot handle close brackets correctly
608 # in scan sets, so we specify it separately.
609 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
610 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
613 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
618 # func_quote_for_expand arg
619 # Aesthetically quote ARG to be evaled later; same as above,
620 # but do not quote variable references.
621 func_quote_for_expand ()
625 my_arg
=`$ECHO "$1" | $SED \
626 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
632 # Double-quote args containing shell metacharacters to delay
633 # word splitting and command substitution for a subsequent eval.
634 # Many Bourne shells cannot handle close brackets correctly
635 # in scan sets, so we specify it separately.
636 *[\
[\~\
#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
641 func_quote_for_expand_result
="$my_arg"
645 # func_show_eval cmd [fail_exp]
646 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
647 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
648 # is given, then evaluate it.
654 ${opt_silent-false} ||
{
655 func_quote_for_expand
"$my_cmd"
656 eval "func_echo $func_quote_for_expand_result"
659 if ${opt_dry_run-false}; then :; else
662 if test "$my_status" -eq 0; then :; else
663 eval "(exit $my_status); $my_fail_exp"
669 # func_show_eval_locale cmd [fail_exp]
670 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
671 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
672 # is given, then evaluate it. Use the saved locale for evaluation.
673 func_show_eval_locale
()
678 ${opt_silent-false} ||
{
679 func_quote_for_expand
"$my_cmd"
680 eval "func_echo $func_quote_for_expand_result"
683 if ${opt_dry_run-false}; then :; else
684 eval "$lt_user_locale
687 eval "$lt_safe_locale"
688 if test "$my_status" -eq 0; then :; else
689 eval "(exit $my_status); $my_fail_exp"
695 # Turn $1 into a string suitable for a shell variable name.
696 # Result is stored in $func_tr_sh_result. All characters
697 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
698 # if $1 begins with a digit, a '_' is prepended as well.
702 [0-9]* |
*[!a-zA-Z0-9_
]*)
703 func_tr_sh_result
=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
713 # Echo version message to standard output and exit.
726 /^# '$PROGRAM' (GNU /,/# warranty; / {
729 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
736 # Echo short help message to standard output and exit.
741 $SED -n '/^# Usage:/,/^# *.*--help/ {
744 s/\$progname/'$progname'/
748 $ECHO "run \`$progname --help | more' for full usage"
753 # Echo long help message to standard output and exit,
754 # unless 'noexit' is passed as argument.
759 $SED -n '/^# Usage:/,/# Report bugs to/ {
763 s*\$progname*'$progname'*
765 s*\$SHELL*'"$SHELL"'*
767 s*\$LTCFLAGS*'"$LTCFLAGS"'*
769 s/\$with_gnu_ld/'"$with_gnu_ld"'/
770 s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
771 s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
775 /^# .* home page:/b print
776 /^# General help using/b print
779 if test -z "$1"; then
784 # func_missing_arg argname
785 # Echo program name prefixed message to standard error and set global
791 func_error
"missing argument for $1."
796 # func_split_short_opt shortopt
797 # Set func_split_short_opt_name and func_split_short_opt_arg shell
798 # variables after splitting SHORTOPT after the 2nd character.
799 func_split_short_opt
()
801 my_sed_short_opt
='1s/^\(..\).*$/\1/;q'
802 my_sed_short_rest
='1s/^..\(.*\)$/\1/;q'
804 func_split_short_opt_name
=`$ECHO "$1" | $SED "$my_sed_short_opt"`
805 func_split_short_opt_arg
=`$ECHO "$1" | $SED "$my_sed_short_rest"`
806 } # func_split_short_opt may be replaced by extended shell implementation
809 # func_split_long_opt longopt
810 # Set func_split_long_opt_name and func_split_long_opt_arg shell
811 # variables after splitting LONGOPT at the `=' sign.
812 func_split_long_opt
()
814 my_sed_long_opt
='1s/^\(--[^=]*\)=.*/\1/;q'
815 my_sed_long_arg
='1s/^--[^=]*=//'
817 func_split_long_opt_name
=`$ECHO "$1" | $SED "$my_sed_long_opt"`
818 func_split_long_opt_arg
=`$ECHO "$1" | $SED "$my_sed_long_arg"`
819 } # func_split_long_opt may be replaced by extended shell implementation
827 magic
="%%%MAGIC variable%%%"
828 magic_exe
="%%%MAGIC EXE variable%%%"
833 lo2o
="s/\\.lo\$/.${objext}/"
834 o2lo
="s/\\.${objext}\$/.lo/"
838 # If this variable is set in any of the actions, the command in it
839 # will be execed at the end. This prevents here-documents from being
840 # left over by shells.
843 # func_append var value
844 # Append VALUE to the end of shell variable VAR.
847 eval "${1}=\$${1}\${2}"
848 } # func_append may be replaced by extended shell implementation
850 # func_append_quoted var value
851 # Quote VALUE and append to the end of shell variable VAR, separated
853 func_append_quoted
()
855 func_quote_for_eval
"${2}"
856 eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
857 } # func_append_quoted may be replaced by extended shell implementation
860 # func_arith arithmetic-term...
863 func_arith_result
=`expr "${@}"`
864 } # func_arith may be replaced by extended shell implementation
868 # STRING may not start with a hyphen.
871 func_len_result
=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
872 } # func_len may be replaced by extended shell implementation
878 func_lo2o_result
=`$ECHO "${1}" | $SED "$lo2o"`
879 } # func_lo2o may be replaced by extended shell implementation
882 # func_xform libobj-or-source
885 func_xform_result
=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
886 } # func_xform may be replaced by extended shell implementation
889 # func_fatal_configuration arg...
890 # Echo program name prefixed message to standard error, followed by
891 # a configuration failure hint, and exit.
892 func_fatal_configuration
()
895 func_error
"See the $PACKAGE documentation for more information."
896 func_fatal_error
"Fatal configuration error."
901 # Display the configuration for all the tags in this script.
904 re_begincf
='^# ### BEGIN LIBTOOL'
905 re_endcf
='^# ### END LIBTOOL'
907 # Default configuration.
908 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
910 # Now print the configurations for the tags.
911 for tagname
in $taglist; do
912 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
919 # Display the features supported by this script.
923 if test "$build_libtool_libs" = yes; then
924 echo "enable shared libraries"
926 echo "disable shared libraries"
928 if test "$build_old_libs" = yes; then
929 echo "enable static libraries"
931 echo "disable static libraries"
937 # func_enable_tag tagname
938 # Verify that TAGNAME is valid, and either flag an error and exit, or
939 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
946 re_begincf
="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
947 re_endcf
="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
948 sed_extractcf
="/$re_begincf/,/$re_endcf/p"
953 func_fatal_error
"invalid tag name: $tagname"
957 # Don't test for the "default" C tag, as we know it's
958 # there but not specially marked.
962 if $GREP "$re_begincf" "$progpath" >/dev
/null
2>&1; then
963 taglist
="$taglist $tagname"
965 # Evaluate the configuration. Be careful to quote the path
966 # and the sed script, to avoid splitting on whitespace, but
967 # also don't use non-portable quotes within backquotes within
968 # quotes we have to do it in 2 steps:
969 extractedcf
=`$SED -n -e "$sed_extractcf" < "$progpath"`
972 func_error
"ignoring unknown tag $tagname"
978 # func_check_version_match
979 # Ensure that we are using m4 macros, and libtool script from the same
980 # release of libtool.
981 func_check_version_match
()
983 if test "$package_revision" != "$macro_revision"; then
984 if test "$VERSION" != "$macro_version"; then
985 if test -z "$macro_version"; then
987 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
988 $progname: definition of this LT_INIT comes from an older release.
989 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
990 $progname: and run autoconf again.
994 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
995 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
996 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
997 $progname: and run autoconf again.
1002 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1003 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1004 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1005 $progname: of $PACKAGE $VERSION and run autoconf again.
1014 # Shorthand for --mode=foo, only valid as the first argument
1017 shift; set dummy
--mode clean
${1+"$@"}; shift
1019 compile|compil|compi|comp|com|co|c
)
1020 shift; set dummy
--mode compile
${1+"$@"}; shift
1022 execute|execut|execu|
exec|exe|ex|e
)
1023 shift; set dummy
--mode execute
${1+"$@"}; shift
1025 finish|finis|fini|fin|
fi|f
)
1026 shift; set dummy
--mode finish
${1+"$@"}; shift
1028 install|instal|insta|inst|ins|
in|i
)
1029 shift; set dummy
--mode install ${1+"$@"}; shift
1032 shift; set dummy
--mode link
${1+"$@"}; shift
1034 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u
)
1035 shift; set dummy
--mode uninstall
${1+"$@"}; shift
1045 opt_preserve_dup_deps
=false
1057 # Parse options once, thoroughly. This comes as soon as possible in the
1058 # script to make things like `--version' happen as quickly as we can.
1060 # this just eases exit handling
1061 while test $# -gt 0; do
1065 --debug|
-x) opt_debug
='set -x'
1066 func_echo
"enabling shell trace mode"
1069 --dry-run|
--dryrun|
-n)
1078 opt_dlopen
="${opt_dlopen+$opt_dlopen
1082 --preserve-dup-deps)
1083 opt_preserve_dup_deps
=:
1091 set dummy
--mode finish
${1+"$@"}; shift
1098 opt_help
=': help-all'
1101 test $# = 0 && func_missing_arg
$opt && break
1105 # Valid mode arguments:
1106 clean|compile|execute|finish|
install|link|relink|uninstall
) ;;
1108 # Catch anything else as an error
1109 *) func_error
"invalid argument for $opt"
1116 --no-silent|
--no-quiet)
1118 func_append preserve_args
" $opt"
1120 --no-warning|
--no-warn)
1122 func_append preserve_args
" $opt"
1126 func_append preserve_args
" $opt"
1130 func_append preserve_args
" $opt"
1135 func_append preserve_args
" $opt"
1139 test $# = 0 && func_missing_arg
$opt && break
1142 func_append preserve_args
" $opt $optarg"
1143 func_enable_tag
"$optarg"
1147 -\?|
-h) func_usage
;;
1148 --help) func_help
;;
1149 --version) func_version
;;
1151 # Separate optargs to long options:
1153 func_split_long_opt
"$opt"
1154 set dummy
"$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1158 # Separate non-argument short options:
1160 func_split_short_opt
"$opt"
1161 set dummy
"$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1166 -*) func_fatal_help
"unrecognized option \`$opt'" ;;
1167 *) set dummy
"$opt" ${1+"$@"}; shift; break ;;
1173 # save first non-option argument
1174 if test "$#" -gt 0; then
1180 test "$opt_debug" = : || func_append preserve_args
" --debug"
1183 *cygwin
* |
*mingw
* |
*pw32
* |
*cegcc
*)
1184 # don't eliminate duplications in $postdeps and $predeps
1185 opt_duplicate_compiler_generated_deps
=:
1188 opt_duplicate_compiler_generated_deps
=$opt_preserve_dup_deps
1193 # Sanity checks first:
1194 func_check_version_match
1196 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1197 func_fatal_configuration
"not configured to build any kind of library"
1201 eval std_shrext
=\"$shrext_cmds\"
1203 # Only execute mode is allowed to have -dlopen flags.
1204 if test -n "$opt_dlopen" && test "$opt_mode" != execute
; then
1205 func_error
"unrecognized option \`-dlopen'"
1210 # Change the help message to a mode-specific one.
1211 generic_help
="$help"
1212 help="Try \`$progname --help --mode=$opt_mode' for more information."
1216 # Bail if the options were screwed
1217 $exit_cmd $EXIT_FAILURE
1228 # True iff FILE is a libtool `.la' library or `.lo' object file.
1229 # This function is only a basic sanity check; it will hardly flush out
1230 # determined imposters.
1234 $SED -e 4q
"$1" 2>/dev
/null \
1235 |
$GREP "^# Generated by .*$PACKAGE" > /dev
/null
2>&1
1238 # func_lalib_unsafe_p file
1239 # True iff FILE is a libtool `.la' library or `.lo' object file.
1240 # This function implements the same check as func_lalib_p without
1241 # resorting to external programs. To this end, it redirects stdin and
1242 # closes it afterwards, without saving the original file descriptor.
1243 # As a safety measure, use it only where a negative result would be
1244 # fatal anyway. Works if `file' does not exist.
1245 func_lalib_unsafe_p
()
1248 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1249 for lalib_p_l
in 1 2 3 4
1252 case "$lalib_p_line" in
1253 \
#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1258 test "$lalib_p" = yes
1261 # func_ltwrapper_script_p file
1262 # True iff FILE is a libtool wrapper script
1263 # This function is only a basic sanity check; it will hardly flush out
1264 # determined imposters.
1265 func_ltwrapper_script_p
()
1270 # func_ltwrapper_executable_p file
1271 # True iff FILE is a libtool wrapper executable
1272 # This function is only a basic sanity check; it will hardly flush out
1273 # determined imposters.
1274 func_ltwrapper_executable_p
()
1276 func_ltwrapper_exec_suffix
=
1279 *) func_ltwrapper_exec_suffix
=.exe
;;
1281 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev
/null
2>&1
1284 # func_ltwrapper_scriptname file
1285 # Assumes file is an ltwrapper_executable
1286 # uses $file to determine the appropriate filename for a
1287 # temporary ltwrapper_script.
1288 func_ltwrapper_scriptname
()
1290 func_dirname_and_basename
"$1" "" "."
1291 func_stripname
'' '.exe' "$func_basename_result"
1292 func_ltwrapper_scriptname_result
="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1295 # func_ltwrapper_p file
1296 # True iff FILE is a libtool wrapper script or wrapper executable
1297 # This function is only a basic sanity check; it will hardly flush out
1298 # determined imposters.
1301 func_ltwrapper_script_p
"$1" || func_ltwrapper_executable_p
"$1"
1305 # func_execute_cmds commands fail_cmd
1306 # Execute tilde-delimited COMMANDS.
1307 # If FAIL_CMD is given, eval that upon failure.
1308 # FAIL_CMD may read-access the current command in variable CMD!
1309 func_execute_cmds
()
1312 save_ifs
=$IFS; IFS
='~'
1316 func_show_eval
"$cmd" "${2-:}"
1323 # Source FILE, adding directory component if necessary.
1324 # Note that it is not necessary on cygwin/mingw to append a dot to
1325 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1326 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1327 # `FILE.' does not work on cygwin managed mounts.
1332 */* |
*\\*) .
"$1" ;;
1338 # func_resolve_sysroot PATH
1339 # Replace a leading = in PATH with a sysroot. Store the result into
1340 # func_resolve_sysroot_result
1341 func_resolve_sysroot
()
1343 func_resolve_sysroot_result
=$1
1344 case $func_resolve_sysroot_result in
1346 func_stripname
'=' '' "$func_resolve_sysroot_result"
1347 func_resolve_sysroot_result
=$lt_sysroot$func_stripname_result
1352 # func_replace_sysroot PATH
1353 # If PATH begins with the sysroot, replace it with = and
1354 # store the result into func_replace_sysroot_result.
1355 func_replace_sysroot
()
1357 case "$lt_sysroot:$1" in
1359 func_stripname
"$lt_sysroot" '' "$1"
1360 func_replace_sysroot_result
="=$func_stripname_result"
1363 # Including no sysroot.
1364 func_replace_sysroot_result
=$1
1369 # func_infer_tag arg
1370 # Infer tagged configuration to use if any are available and
1371 # if one wasn't chosen via the "--tag" command line option.
1372 # Only attempt this if the compiler in the base compile
1373 # command doesn't match the default compiler.
1374 # arg is usually of the form 'gcc ...'
1378 if test -n "$available_tags" && test -z "$tagname"; then
1381 func_append_quoted CC_quoted
"$arg"
1383 CC_expanded
=`func_echo_all $CC`
1384 CC_quoted_expanded
=`func_echo_all $CC_quoted`
1386 # Blanks in the command may have been stripped by the calling shell,
1387 # but not from the CC environment variable when configure was run.
1388 " $CC "* |
"$CC "* |
" $CC_expanded "* |
"$CC_expanded "* | \
1389 " $CC_quoted"* |
"$CC_quoted "* |
" $CC_quoted_expanded "* |
"$CC_quoted_expanded "*) ;;
1390 # Blanks at the start of $base_compile will cause this to fail
1391 # if we don't check for them as well.
1393 for z
in $available_tags; do
1394 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev
/null
; then
1395 # Evaluate the configuration.
1396 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1399 # Double-quote args containing other shell metacharacters.
1400 func_append_quoted CC_quoted
"$arg"
1402 CC_expanded
=`func_echo_all $CC`
1403 CC_quoted_expanded
=`func_echo_all $CC_quoted`
1405 " $CC "* |
"$CC "* |
" $CC_expanded "* |
"$CC_expanded "* | \
1406 " $CC_quoted"* |
"$CC_quoted "* |
" $CC_quoted_expanded "* |
"$CC_quoted_expanded "*)
1407 # The compiler in the base compile command matches
1408 # the one in the tagged configuration.
1409 # Assume this is the tagged configuration we want.
1416 # If $tagname still isn't set, then no tagged configuration
1417 # was found and let the user know that the "--tag" command
1418 # line option must be used.
1419 if test -z "$tagname"; then
1420 func_echo
"unable to infer tagged configuration"
1421 func_fatal_error
"specify a tag with \`--tag'"
1423 # func_verbose "using $tagname tagged configuration"
1432 # func_write_libtool_object output_name pic_name nonpic_name
1433 # Create a libtool object file (analogous to a ".la" file),
1434 # but don't create it if we're doing a dry run.
1435 func_write_libtool_object
()
1438 if test "$build_libtool_libs" = yes; then
1444 if test "$build_old_libs" = yes; then
1445 write_oldobj
=\'${3}\'
1451 cat >${write_libobj}T
<<EOF
1452 # $write_libobj - a libtool object file
1453 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1455 # Please DO NOT delete this file!
1456 # It is necessary for linking the library.
1458 # Name of the PIC object.
1459 pic_object=$write_lobj
1461 # Name of the non-PIC object
1462 non_pic_object=$write_oldobj
1465 $MV "${write_libobj}T" "${write_libobj}"
1470 ##################################################
1471 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1472 ##################################################
1474 # func_convert_core_file_wine_to_w32 ARG
1475 # Helper function used by file name conversion functions when $build is *nix,
1476 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1477 # correctly configured wine environment available, with the winepath program
1478 # in $build's $PATH.
1480 # ARG is the $build file name to be converted to w32 format.
1481 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1482 # be empty on error (or when ARG is empty)
1483 func_convert_core_file_wine_to_w32
()
1486 func_convert_core_file_wine_to_w32_result
="$1"
1487 if test -n "$1"; then
1488 # Unfortunately, winepath does not exit with a non-zero error code, so we
1489 # are forced to check the contents of stdout. On the other hand, if the
1490 # command is not found, the shell will set an exit code of 127 and print
1491 # *an error message* to stdout. So we must check for both error code of
1492 # zero AND non-empty stdout, which explains the odd construction:
1493 func_convert_core_file_wine_to_w32_tmp
=`winepath -w "$1" 2>/dev/null`
1494 if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1495 func_convert_core_file_wine_to_w32_result
=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1496 $SED -e "$lt_sed_naive_backslashify"`
1498 func_convert_core_file_wine_to_w32_result
=
1502 # end: func_convert_core_file_wine_to_w32
1505 # func_convert_core_path_wine_to_w32 ARG
1506 # Helper function used by path conversion functions when $build is *nix, and
1507 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1508 # configured wine environment available, with the winepath program in $build's
1509 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1511 # ARG is path to be converted from $build format to win32.
1512 # Result is available in $func_convert_core_path_wine_to_w32_result.
1513 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1514 # are convertible, then the result may be empty.
1515 func_convert_core_path_wine_to_w32
()
1518 # unfortunately, winepath doesn't convert paths, only file names
1519 func_convert_core_path_wine_to_w32_result
=""
1520 if test -n "$1"; then
1523 for func_convert_core_path_wine_to_w32_f
in $1; do
1525 func_convert_core_file_wine_to_w32
"$func_convert_core_path_wine_to_w32_f"
1526 if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1527 if test -z "$func_convert_core_path_wine_to_w32_result"; then
1528 func_convert_core_path_wine_to_w32_result
="$func_convert_core_file_wine_to_w32_result"
1530 func_append func_convert_core_path_wine_to_w32_result
";$func_convert_core_file_wine_to_w32_result"
1537 # end: func_convert_core_path_wine_to_w32
1540 # func_cygpath ARGS...
1541 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1542 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1543 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1544 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1545 # file name or path is assumed to be in w32 format, as previously converted
1546 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1547 # or path in func_cygpath_result (input file name or path is assumed to be in
1548 # Cygwin format). Returns an empty string on error.
1550 # ARGS are passed to cygpath, with the last one being the file name or path to
1553 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1554 # environment variable; do not put it in $PATH.
1558 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1559 func_cygpath_result
=`$LT_CYGPATH "$@" 2>/dev/null`
1560 if test "$?" -ne 0; then
1561 # on failure, ensure result is empty
1562 func_cygpath_result
=
1565 func_cygpath_result
=
1566 func_error
"LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1572 # func_convert_core_msys_to_w32 ARG
1573 # Convert file name or path ARG from MSYS format to w32 format. Return
1574 # result in func_convert_core_msys_to_w32_result.
1575 func_convert_core_msys_to_w32
()
1578 # awkward: cmd appends spaces to result
1579 func_convert_core_msys_to_w32_result
=`( cmd //c echo "$1" ) 2>/dev/null |
1580 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1582 #end: func_convert_core_msys_to_w32
1585 # func_convert_file_check ARG1 ARG2
1586 # Verify that ARG1 (a file name in $build format) was converted to $host
1587 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1588 # func_to_host_file_result to ARG1).
1589 func_convert_file_check
()
1592 if test -z "$2" && test -n "$1" ; then
1593 func_error
"Could not determine host file name corresponding to"
1595 func_error
"Continuing, but uninstalled executables may not work."
1597 func_to_host_file_result
="$1"
1600 # end func_convert_file_check
1603 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1604 # Verify that FROM_PATH (a path in $build format) was converted to $host
1605 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1606 # func_to_host_file_result to a simplistic fallback value (see below).
1607 func_convert_path_check
()
1610 if test -z "$4" && test -n "$3"; then
1611 func_error
"Could not determine the host path corresponding to"
1613 func_error
"Continuing, but uninstalled executables may not work."
1614 # Fallback. This is a deliberately simplistic "conversion" and
1615 # should not be "improved". See libtool.info.
1616 if test "x$1" != "x$2"; then
1617 lt_replace_pathsep_chars
="s|$1|$2|g"
1618 func_to_host_path_result
=`echo "$3" |
1619 $SED -e "$lt_replace_pathsep_chars"`
1621 func_to_host_path_result
="$3"
1625 # end func_convert_path_check
1628 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1629 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1630 # and appending REPL if ORIG matches BACKPAT.
1631 func_convert_path_front_back_pathsep
()
1635 $1 ) func_to_host_path_result
="$3$func_to_host_path_result"
1639 $2 ) func_append func_to_host_path_result
"$3"
1643 # end func_convert_path_front_back_pathsep
1646 ##################################################
1647 # $build to $host FILE NAME CONVERSION FUNCTIONS #
1648 ##################################################
1649 # invoked via `$to_host_file_cmd ARG'
1651 # In each case, ARG is the path to be converted from $build to $host format.
1652 # Result will be available in $func_to_host_file_result.
1655 # func_to_host_file ARG
1656 # Converts the file name ARG from $build format to $host format. Return result
1657 # in func_to_host_file_result.
1658 func_to_host_file
()
1661 $to_host_file_cmd "$1"
1663 # end func_to_host_file
1666 # func_to_tool_file ARG LAZY
1667 # converts the file name ARG from $build format to toolchain format. Return
1668 # result in func_to_tool_file_result. If the conversion in use is listed
1669 # in (the comma separated) LAZY, no conversion takes place.
1670 func_to_tool_file
()
1674 *,"$to_tool_file_cmd",*)
1675 func_to_tool_file_result
=$1
1678 $to_tool_file_cmd "$1"
1679 func_to_tool_file_result
=$func_to_host_file_result
1683 # end func_to_tool_file
1686 # func_convert_file_noop ARG
1687 # Copy ARG to func_to_host_file_result.
1688 func_convert_file_noop
()
1690 func_to_host_file_result
="$1"
1692 # end func_convert_file_noop
1695 # func_convert_file_msys_to_w32 ARG
1696 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1697 # conversion to w32 is not available inside the cwrapper. Returns result in
1698 # func_to_host_file_result.
1699 func_convert_file_msys_to_w32
()
1702 func_to_host_file_result
="$1"
1703 if test -n "$1"; then
1704 func_convert_core_msys_to_w32
"$1"
1705 func_to_host_file_result
="$func_convert_core_msys_to_w32_result"
1707 func_convert_file_check
"$1" "$func_to_host_file_result"
1709 # end func_convert_file_msys_to_w32
1712 # func_convert_file_cygwin_to_w32 ARG
1713 # Convert file name ARG from Cygwin to w32 format. Returns result in
1714 # func_to_host_file_result.
1715 func_convert_file_cygwin_to_w32
()
1718 func_to_host_file_result
="$1"
1719 if test -n "$1"; then
1720 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1721 # LT_CYGPATH in this case.
1722 func_to_host_file_result
=`cygpath -m "$1"`
1724 func_convert_file_check
"$1" "$func_to_host_file_result"
1726 # end func_convert_file_cygwin_to_w32
1729 # func_convert_file_nix_to_w32 ARG
1730 # Convert file name ARG from *nix to w32 format. Requires a wine environment
1731 # and a working winepath. Returns result in func_to_host_file_result.
1732 func_convert_file_nix_to_w32
()
1735 func_to_host_file_result
="$1"
1736 if test -n "$1"; then
1737 func_convert_core_file_wine_to_w32
"$1"
1738 func_to_host_file_result
="$func_convert_core_file_wine_to_w32_result"
1740 func_convert_file_check
"$1" "$func_to_host_file_result"
1742 # end func_convert_file_nix_to_w32
1745 # func_convert_file_msys_to_cygwin ARG
1746 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1747 # Returns result in func_to_host_file_result.
1748 func_convert_file_msys_to_cygwin
()
1751 func_to_host_file_result
="$1"
1752 if test -n "$1"; then
1753 func_convert_core_msys_to_w32
"$1"
1754 func_cygpath
-u "$func_convert_core_msys_to_w32_result"
1755 func_to_host_file_result
="$func_cygpath_result"
1757 func_convert_file_check
"$1" "$func_to_host_file_result"
1759 # end func_convert_file_msys_to_cygwin
1762 # func_convert_file_nix_to_cygwin ARG
1763 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1764 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1765 # in func_to_host_file_result.
1766 func_convert_file_nix_to_cygwin
()
1769 func_to_host_file_result
="$1"
1770 if test -n "$1"; then
1771 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1772 func_convert_core_file_wine_to_w32
"$1"
1773 func_cygpath
-u "$func_convert_core_file_wine_to_w32_result"
1774 func_to_host_file_result
="$func_cygpath_result"
1776 func_convert_file_check
"$1" "$func_to_host_file_result"
1778 # end func_convert_file_nix_to_cygwin
1781 #############################################
1782 # $build to $host PATH CONVERSION FUNCTIONS #
1783 #############################################
1784 # invoked via `$to_host_path_cmd ARG'
1786 # In each case, ARG is the path to be converted from $build to $host format.
1787 # The result will be available in $func_to_host_path_result.
1789 # Path separators are also converted from $build format to $host format. If
1790 # ARG begins or ends with a path separator character, it is preserved (but
1791 # converted to $host format) on output.
1793 # All path conversion functions are named using the following convention:
1794 # file name conversion function : func_convert_file_X_to_Y ()
1795 # path conversion function : func_convert_path_X_to_Y ()
1796 # where, for any given $build/$host combination the 'X_to_Y' value is the
1797 # same. If conversion functions are added for new $build/$host combinations,
1798 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1802 # func_init_to_host_path_cmd
1803 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1804 # appropriate value, based on the value of $to_host_file_cmd.
1806 func_init_to_host_path_cmd
()
1809 if test -z "$to_host_path_cmd"; then
1810 func_stripname
'func_convert_file_' '' "$to_host_file_cmd"
1811 to_host_path_cmd
="func_convert_path_${func_stripname_result}"
1816 # func_to_host_path ARG
1817 # Converts the path ARG from $build format to $host format. Return result
1818 # in func_to_host_path_result.
1819 func_to_host_path
()
1822 func_init_to_host_path_cmd
1823 $to_host_path_cmd "$1"
1825 # end func_to_host_path
1828 # func_convert_path_noop ARG
1829 # Copy ARG to func_to_host_path_result.
1830 func_convert_path_noop
()
1832 func_to_host_path_result
="$1"
1834 # end func_convert_path_noop
1837 # func_convert_path_msys_to_w32 ARG
1838 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1839 # conversion to w32 is not available inside the cwrapper. Returns result in
1840 # func_to_host_path_result.
1841 func_convert_path_msys_to_w32
()
1844 func_to_host_path_result
="$1"
1845 if test -n "$1"; then
1846 # Remove leading and trailing path separator characters from ARG. MSYS
1847 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1848 # and winepath ignores them completely.
1849 func_stripname
: : "$1"
1850 func_to_host_path_tmp1
=$func_stripname_result
1851 func_convert_core_msys_to_w32
"$func_to_host_path_tmp1"
1852 func_to_host_path_result
="$func_convert_core_msys_to_w32_result"
1853 func_convert_path_check
: ";" \
1854 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1855 func_convert_path_front_back_pathsep
":*" "*:" ";" "$1"
1858 # end func_convert_path_msys_to_w32
1861 # func_convert_path_cygwin_to_w32 ARG
1862 # Convert path ARG from Cygwin to w32 format. Returns result in
1863 # func_to_host_file_result.
1864 func_convert_path_cygwin_to_w32
()
1867 func_to_host_path_result
="$1"
1868 if test -n "$1"; then
1869 # See func_convert_path_msys_to_w32:
1870 func_stripname
: : "$1"
1871 func_to_host_path_tmp1
=$func_stripname_result
1872 func_to_host_path_result
=`cygpath -m -p "$func_to_host_path_tmp1"`
1873 func_convert_path_check
: ";" \
1874 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1875 func_convert_path_front_back_pathsep
":*" "*:" ";" "$1"
1878 # end func_convert_path_cygwin_to_w32
1881 # func_convert_path_nix_to_w32 ARG
1882 # Convert path ARG from *nix to w32 format. Requires a wine environment and
1883 # a working winepath. Returns result in func_to_host_file_result.
1884 func_convert_path_nix_to_w32
()
1887 func_to_host_path_result
="$1"
1888 if test -n "$1"; then
1889 # See func_convert_path_msys_to_w32:
1890 func_stripname
: : "$1"
1891 func_to_host_path_tmp1
=$func_stripname_result
1892 func_convert_core_path_wine_to_w32
"$func_to_host_path_tmp1"
1893 func_to_host_path_result
="$func_convert_core_path_wine_to_w32_result"
1894 func_convert_path_check
: ";" \
1895 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1896 func_convert_path_front_back_pathsep
":*" "*:" ";" "$1"
1899 # end func_convert_path_nix_to_w32
1902 # func_convert_path_msys_to_cygwin ARG
1903 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1904 # Returns result in func_to_host_file_result.
1905 func_convert_path_msys_to_cygwin
()
1908 func_to_host_path_result
="$1"
1909 if test -n "$1"; then
1910 # See func_convert_path_msys_to_w32:
1911 func_stripname
: : "$1"
1912 func_to_host_path_tmp1
=$func_stripname_result
1913 func_convert_core_msys_to_w32
"$func_to_host_path_tmp1"
1914 func_cygpath
-u -p "$func_convert_core_msys_to_w32_result"
1915 func_to_host_path_result
="$func_cygpath_result"
1916 func_convert_path_check
: : \
1917 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1918 func_convert_path_front_back_pathsep
":*" "*:" : "$1"
1921 # end func_convert_path_msys_to_cygwin
1924 # func_convert_path_nix_to_cygwin ARG
1925 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1926 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1927 # func_to_host_file_result.
1928 func_convert_path_nix_to_cygwin
()
1931 func_to_host_path_result
="$1"
1932 if test -n "$1"; then
1933 # Remove leading and trailing path separator characters from
1934 # ARG. msys behavior is inconsistent here, cygpath turns them
1935 # into '.;' and ';.', and winepath ignores them completely.
1936 func_stripname
: : "$1"
1937 func_to_host_path_tmp1
=$func_stripname_result
1938 func_convert_core_path_wine_to_w32
"$func_to_host_path_tmp1"
1939 func_cygpath
-u -p "$func_convert_core_path_wine_to_w32_result"
1940 func_to_host_path_result
="$func_cygpath_result"
1941 func_convert_path_check
: : \
1942 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1943 func_convert_path_front_back_pathsep
":*" "*:" : "$1"
1946 # end func_convert_path_nix_to_cygwin
1949 # func_mode_compile arg...
1950 func_mode_compile
()
1953 # Get the compilation command and the source file.
1955 srcfile
="$nonopt" # always keep a non-empty value in "srcfile"
1967 # do not "continue". Instead, add this to base_compile
1979 # Accept any command-line options.
1982 test -n "$libobj" && \
1983 func_fatal_error
"you cannot specify \`-o' more than once"
1988 -pie |
-fpie |
-fPIE)
1989 func_append pie_flag
" $arg"
1993 -shared |
-static |
-prefer-pic |
-prefer-non-pic)
1994 func_append later
" $arg"
2004 arg_mode
=arg
# the next one goes into the "base_compile" arg list
2005 continue # The current "srcfile" will either be retained or
2006 ;; # replaced later. I would guess that would be a bug.
2009 func_stripname
'-Wc,' '' "$arg"
2010 args
=$func_stripname_result
2012 save_ifs
="$IFS"; IFS
=','
2013 for arg
in $args; do
2015 func_append_quoted lastarg
"$arg"
2018 func_stripname
' ' '' "$lastarg"
2019 lastarg
=$func_stripname_result
2021 # Add the arguments to base_compile.
2022 func_append base_compile
" $lastarg"
2027 # Accept the current argument as the source file.
2028 # The previous "srcfile" becomes the current argument.
2035 esac # case $arg_mode
2037 # Aesthetically quote the previous argument.
2038 func_append_quoted base_compile
"$lastarg"
2043 func_fatal_error
"you must specify an argument for -Xcompile"
2046 func_fatal_error
"you must specify a target with \`-o'"
2049 # Get the name of the library object.
2050 test -z "$libobj" && {
2051 func_basename
"$srcfile"
2052 libobj
="$func_basename_result"
2057 # Recognize several different file suffixes.
2058 # If the user specifies -o file.o, it is replaced with file.lo
2061 *.ada |
*.adb |
*.ads |
*.asm | \
2062 *.c
++ |
*.cc |
*.ii |
*.class |
*.cpp |
*.cxx | \
2063 *.
[fF
][09]? |
*.
for |
*.java |
*.go |
*.obj |
*.sx |
*.cu |
*.cup
)
2064 func_xform
"$libobj"
2065 libobj
=$func_xform_result
2070 *.lo
) func_lo2o
"$libobj"; obj
=$func_lo2o_result ;;
2072 func_fatal_error
"cannot determine name of library object from \`$libobj'"
2076 func_infer_tag
$base_compile
2078 for arg
in $later; do
2081 test "$build_libtool_libs" != yes && \
2082 func_fatal_configuration
"can not build a shared library"
2088 build_libtool_libs
=no
2105 func_quote_for_eval
"$libobj"
2106 test "X$libobj" != "X$func_quote_for_eval_result" \
2107 && $ECHO "X$libobj" |
$GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2108 && func_warning
"libobj name \`$libobj' may not contain shell special characters."
2109 func_dirname_and_basename
"$obj" "/" ""
2110 objname
="$func_basename_result"
2111 xdir
="$func_dirname_result"
2112 lobj
=${xdir}$objdir/$objname
2114 test -z "$base_compile" && \
2115 func_fatal_help
"you must specify a compilation command"
2117 # Delete any leftover library objects.
2118 if test "$build_old_libs" = yes; then
2119 removelist
="$obj $lobj $libobj ${libobj}T"
2121 removelist
="$lobj $libobj ${libobj}T"
2124 # On Cygwin there's no "real" PIC flag so we must build both object types
2126 cygwin
* | mingw
* | pw32
* | os2
* | cegcc
*)
2130 if test "$pic_mode" = no
&& test "$deplibs_check_method" != pass_all
; then
2131 # non-PIC code in shared libraries is not supported
2135 # Calculate the filename of the output object if compiler does
2136 # not support -o with -c
2137 if test "$compiler_c_o" = no
; then
2138 output_obj
=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.
${objext}
2139 lockfile
="$output_obj.lock"
2146 # Lock this critical section if it is needed
2147 # We use this script file to make the link, it avoids creating a new file
2148 if test "$need_locks" = yes; then
2149 until $opt_dry_run ||
ln "$progpath" "$lockfile" 2>/dev
/null
; do
2150 func_echo
"Waiting for $lockfile to be removed"
2153 elif test "$need_locks" = warn
; then
2154 if test -f "$lockfile"; then
2156 *** ERROR, $lockfile exists and contains:
2157 `cat $lockfile 2>/dev/null`
2159 This indicates that another process is trying to use the same
2160 temporary object file, and libtool could not work around it because
2161 your compiler does not support \`-c' and \`-o' together. If you
2162 repeat this compilation, it may succeed, by chance, but you had better
2163 avoid parallel builds (make -j) in this platform, or get a better
2166 $opt_dry_run ||
$RM $removelist
2169 func_append removelist
" $output_obj"
2170 $ECHO "$srcfile" > "$lockfile"
2173 $opt_dry_run ||
$RM $removelist
2174 func_append removelist
" $lockfile"
2175 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2177 func_to_tool_file
"$srcfile" func_convert_file_msys_to_w32
2178 srcfile
=$func_to_tool_file_result
2179 func_quote_for_eval
"$srcfile"
2180 qsrcfile
=$func_quote_for_eval_result
2182 # Only build a PIC object if we are building libtool libraries.
2183 if test "$build_libtool_libs" = yes; then
2184 # Without this assignment, base_compile gets emptied.
2185 fbsd_hideous_sh_bug
=$base_compile
2187 if test "$pic_mode" != no
; then
2188 command="$base_compile $qsrcfile $pic_flag"
2190 # Don't build PIC code
2191 command="$base_compile $qsrcfile"
2194 func_mkdir_p
"$xdir$objdir"
2196 if test -z "$output_obj"; then
2197 # Place PIC objects in $objdir
2198 func_append
command " -o $lobj"
2201 func_show_eval_locale
"$command" \
2202 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2204 if test "$need_locks" = warn
&&
2205 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2207 *** ERROR, $lockfile contains:
2208 `cat $lockfile 2>/dev/null`
2210 but it should contain:
2213 This indicates that another process is trying to use the same
2214 temporary object file, and libtool could not work around it because
2215 your compiler does not support \`-c' and \`-o' together. If you
2216 repeat this compilation, it may succeed, by chance, but you had better
2217 avoid parallel builds (make -j) in this platform, or get a better
2220 $opt_dry_run ||
$RM $removelist
2224 # Just move the object if needed, then go on to compile the next one
2225 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2226 func_show_eval
'$MV "$output_obj" "$lobj"' \
2227 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2230 # Allow error messages only from the first compilation.
2231 if test "$suppress_opt" = yes; then
2232 suppress_output
=' >/dev/null 2>&1'
2236 # Only build a position-dependent object if we build old libraries.
2237 if test "$build_old_libs" = yes; then
2238 if test "$pic_mode" != yes; then
2239 # Don't build PIC code
2240 command="$base_compile $qsrcfile$pie_flag"
2242 command="$base_compile $qsrcfile $pic_flag"
2244 if test "$compiler_c_o" = yes; then
2245 func_append
command " -o $obj"
2248 # Suppress compiler output if we already did a PIC compilation.
2249 func_append
command "$suppress_output"
2250 func_show_eval_locale
"$command" \
2251 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2253 if test "$need_locks" = warn
&&
2254 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2256 *** ERROR, $lockfile contains:
2257 `cat $lockfile 2>/dev/null`
2259 but it should contain:
2262 This indicates that another process is trying to use the same
2263 temporary object file, and libtool could not work around it because
2264 your compiler does not support \`-c' and \`-o' together. If you
2265 repeat this compilation, it may succeed, by chance, but you had better
2266 avoid parallel builds (make -j) in this platform, or get a better
2269 $opt_dry_run ||
$RM $removelist
2273 # Just move the object if needed
2274 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2275 func_show_eval
'$MV "$output_obj" "$obj"' \
2276 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2281 func_write_libtool_object
"$libobj" "$objdir/$objname" "$objname"
2283 # Unlock the critical section if it was locked
2284 if test "$need_locks" != no
; then
2285 removelist
=$lockfile
2294 test "$opt_mode" = compile
&& func_mode_compile
${1+"$@"}
2299 # We need to display help for each of the modes.
2302 # Generic help is extracted from the usage comments
2303 # at the start of this file.
2309 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2311 Remove files from the build directory.
2313 RM is the name of the program to use to delete files associated with each FILE
2314 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2317 If FILE is a libtool library, object or program, all the files associated
2318 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2323 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2325 Compile a source file into a libtool library object.
2327 This mode accepts the following additional options:
2329 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
2330 -no-suppress do not suppress compiler output for multiple passes
2331 -prefer-pic try to build PIC objects only
2332 -prefer-non-pic try to build non-PIC objects only
2333 -shared do not build a \`.o' file suitable for static linking
2334 -static only build a \`.o' file suitable for static linking
2335 -Wc,FLAG pass FLAG directly to the compiler
2337 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2338 from the given SOURCEFILE.
2340 The output file name is determined by removing the directory component from
2341 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2342 library object suffix, \`.lo'."
2347 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2349 Automatically set library path, then run a program.
2351 This mode accepts the following additional options:
2353 -dlopen FILE add the directory containing FILE to the library path
2355 This mode sets the library path environment variable according to \`-dlopen'
2358 If any of the ARGS are libtool executable wrappers, then they are translated
2359 into their corresponding uninstalled binary, and any of their required library
2360 directories are added to the library path.
2362 Then, COMMAND is executed, with ARGS as arguments."
2367 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2369 Complete the installation of libtool libraries.
2371 Each LIBDIR is a directory that contains libtool libraries.
2373 The commands that this mode executes may require superuser privileges. Use
2374 the \`--dry-run' option if you just want to see what would be executed."
2379 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2381 Install executables or libraries.
2383 INSTALL-COMMAND is the installation command. The first component should be
2384 either the \`install' or \`cp' program.
2386 The following components of INSTALL-COMMAND are treated specially:
2388 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2390 The rest of the components are interpreted as arguments to that command (only
2391 BSD-compatible install options are recognized)."
2396 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2398 Link object files or libraries together to form another library, or to
2399 create an executable program.
2401 LINK-COMMAND is a command using the C compiler that you would use to create
2402 a program from several object files.
2404 The following components of LINK-COMMAND are treated specially:
2406 -all-static do not do any dynamic linking at all
2407 -avoid-version do not add a version suffix if possible
2408 -bindir BINDIR specify path to binaries directory (for systems where
2409 libraries must be found in the PATH setting at runtime)
2410 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2411 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2412 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2413 -export-symbols SYMFILE
2414 try to export only the symbols listed in SYMFILE
2415 -export-symbols-regex REGEX
2416 try to export only the symbols matching REGEX
2417 -LLIBDIR search LIBDIR for required installed libraries
2418 -lNAME OUTPUT-FILE requires the installed library libNAME
2419 -module build a library that can dlopened
2420 -no-fast-install disable the fast-install mode
2421 -no-install link a not-installable executable
2422 -no-undefined declare that a library does not refer to external symbols
2423 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2424 -objectlist FILE Use a list of object files found in FILE to specify objects
2425 -precious-files-regex REGEX
2426 don't remove output files matching REGEX
2427 -release RELEASE specify package release information
2428 -rpath LIBDIR the created library will eventually be installed in LIBDIR
2429 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2430 -shared only do dynamic linking of libtool libraries
2431 -shrext SUFFIX override the standard shared library file extension
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"
3205 func_to_tool_file
"$oldlib" func_convert_file_msys_to_w32
3206 tool_oldlib
=$func_to_tool_file_result
3208 func_show_eval
"$install_prog \$file \$oldlib" 'exit $?'
3210 if test -n "$stripme" && test -n "$old_striplib"; then
3211 func_show_eval
"$old_striplib $tool_oldlib" 'exit $?'
3214 # Do each command in the postinstall commands.
3215 func_execute_cmds
"$old_postinstall_cmds" 'exit $?'
3218 test -n "$future_libdirs" && \
3219 func_warning
"remember to run \`$progname --finish$future_libdirs'"
3221 if test -n "$current_libdirs"; then
3222 # Maybe just do a dry run.
3223 $opt_dry_run && current_libdirs
=" -n$current_libdirs"
3224 exec_cmd
='$SHELL $progpath $preserve_args --finish$current_libdirs'
3230 test "$opt_mode" = install && func_mode_install
${1+"$@"}
3233 # func_generate_dlsyms outputname originator pic_p
3234 # Extract symbols from dlprefiles and create ${outputname}S.o with
3235 # a dlpreopen symbol table.
3236 func_generate_dlsyms
()
3242 my_prefix
=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3245 if test -n "$dlfiles$dlprefiles" ||
test "$dlself" != no
; then
3246 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3247 my_dlsyms
="${my_outputname}S.c"
3249 func_error
"not configured to extract global symbols from dlpreopened files"
3253 if test -n "$my_dlsyms"; then
3257 # Discover the nlist of each of the dlfiles.
3258 nlist
="$output_objdir/${my_outputname}.nm"
3260 func_show_eval
"$RM $nlist ${nlist}S ${nlist}T"
3262 # Parse the name list into a source file.
3263 func_verbose
"creating $output_objdir/$my_dlsyms"
3265 $opt_dry_run ||
$ECHO > "$output_objdir/$my_dlsyms" "\
3266 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3267 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3273 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3274 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3277 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3278 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3279 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3280 relocations are performed -- see ld's documentation on pseudo-relocs. */
3281 # define LT_DLSYM_CONST
3282 #elif defined(__osf__)
3283 /* This system does not cope well with relocations in const data. */
3284 # define LT_DLSYM_CONST
3286 # define LT_DLSYM_CONST const
3289 /* External symbol declarations for the compiler. */\
3292 if test "$dlself" = yes; then
3293 func_verbose
"generating symbol list for \`$output'"
3295 $opt_dry_run ||
echo ': @PROGRAM@ ' > "$nlist"
3297 # Add our own program objects to the symbol list.
3298 progfiles
=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3299 for progfile
in $progfiles; do
3300 func_to_tool_file
"$progfile" func_convert_file_msys_to_w32
3301 func_verbose
"extracting global C symbols from \`$func_to_tool_file_result'"
3302 $opt_dry_run ||
eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3305 if test -n "$exclude_expsyms"; then
3307 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3308 eval '$MV "$nlist"T "$nlist"'
3312 if test -n "$export_symbols_regex"; then
3314 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3315 eval '$MV "$nlist"T "$nlist"'
3319 # Prepare the list of exported symbols
3320 if test -z "$export_symbols"; then
3321 export_symbols
="$output_objdir/$outputname.exp"
3324 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3326 *cygwin
* |
*mingw
* |
*cegcc
* )
3327 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3328 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3334 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3335 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3336 eval '$MV "$nlist"T "$nlist"'
3338 *cygwin
* |
*mingw
* |
*cegcc
* )
3339 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3340 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3347 for dlprefile
in $dlprefiles; do
3348 func_verbose
"extracting global C symbols from \`$dlprefile'"
3349 func_basename
"$dlprefile"
3350 name
="$func_basename_result"
3352 *cygwin
* |
*mingw
* |
*cegcc
* )
3353 # if an import library, we need to obtain dlname
3354 if func_win32_import_lib_p
"$dlprefile"; then
3355 func_tr_sh
"$dlprefile"
3356 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3357 dlprefile_dlbasename
=""
3358 if test -n "$curr_lafile" && func_lalib_p
"$curr_lafile"; then
3359 # Use subshell, to avoid clobbering current variable values
3360 dlprefile_dlname
=`source "$curr_lafile" && echo "$dlname"`
3361 if test -n "$dlprefile_dlname" ; then
3362 func_basename
"$dlprefile_dlname"
3363 dlprefile_dlbasename
="$func_basename_result"
3365 # no lafile. user explicitly requested -dlpreopen <import library>.
3366 $sharedlib_from_linklib_cmd "$dlprefile"
3367 dlprefile_dlbasename
=$sharedlib_from_linklib_result
3371 if test -n "$dlprefile_dlbasename" ; then
3372 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3374 func_warning
"Could not compute DLL name from $name"
3375 eval '$ECHO ": $name " >> "$nlist"'
3377 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3378 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3379 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3381 else # not an import lib
3383 eval '$ECHO ": $name " >> "$nlist"'
3384 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3385 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3391 eval '$ECHO ": $name " >> "$nlist"'
3392 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3393 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3400 # Make sure we have at least an empty file.
3401 test -f "$nlist" ||
: > "$nlist"
3403 if test -n "$exclude_expsyms"; then
3404 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3405 $MV "$nlist"T
"$nlist"
3408 # Try sorting and uniquifying the output.
3409 if $GREP -v "^: " < "$nlist" |
3410 if sort -k 3 </dev
/null
>/dev
/null
2>&1; then
3415 uniq > "$nlist"S
; then
3418 $GREP -v "^: " < "$nlist" > "$nlist"S
3421 if test -f "$nlist"S
; then
3422 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3424 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3427 echo >> "$output_objdir/$my_dlsyms" "\
3429 /* The mapping between symbol names and symbols. */
3434 extern LT_DLSYM_CONST lt_dlsymlist
3435 lt_${my_prefix}_LTX_preloaded_symbols[];
3436 LT_DLSYM_CONST lt_dlsymlist
3437 lt_${my_prefix}_LTX_preloaded_symbols[] =
3439 { \"$my_originator\", (void *) 0 },"
3441 case $need_lib_prefix in
3443 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3446 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3449 echo >> "$output_objdir/$my_dlsyms" "\
3453 /* This works around a problem in FreeBSD linker */
3454 #ifdef FREEBSD_WORKAROUND
3455 static const void *lt_preloaded_setup() {
3456 return lt_${my_prefix}_LTX_preloaded_symbols;
3466 pic_flag_for_symtable
=
3467 case "$compile_command " in
3471 # compiling the symbol table file with pic_flag works around
3472 # a FreeBSD bug that causes programs to crash when -lm is
3473 # linked before any other PIC object. But we must not use
3474 # pic_flag when linking with -static. The problem exists in
3475 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3476 *-*-freebsd2.
*|
*-*-freebsd3.0
*|
*-*-freebsdelf3.0
*)
3477 pic_flag_for_symtable
=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3479 pic_flag_for_symtable
=" $pic_flag" ;;
3481 if test "X$my_pic_p" != Xno
; then
3482 pic_flag_for_symtable
=" $pic_flag"
3489 for arg
in $LTCFLAGS; do
3491 -pie |
-fpie |
-fPIE) ;;
3492 *) func_append symtab_cflags
" $arg" ;;
3496 # Now compile the dynamic symbol file.
3497 func_show_eval
'(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3499 # Clean up the generated files.
3500 func_show_eval
'$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3502 # Transform the symbol file into the correct name.
3503 symfileobj
="$output_objdir/${my_outputname}S.$objext"
3505 *cygwin
* |
*mingw
* |
*cegcc
* )
3506 if test -f "$output_objdir/$my_outputname.def"; then
3507 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3508 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3510 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3511 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3515 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3516 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3521 func_fatal_error
"unknown suffix for \`$my_dlsyms'"
3525 # We keep going just in case the user didn't refer to
3526 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3527 # really was required.
3529 # Nullify the symbol file.
3530 compile_command
=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3531 finalize_command
=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3535 # func_win32_libid arg
3536 # return the library type of file 'arg'
3538 # Need a lot of goo to handle *both* DLLs and import libs
3539 # Has to be a shell function in order to 'eat' the argument
3540 # that is supplied when $file_magic_command is called.
3541 # Despite the name, also deal with 64 bit binaries.
3545 win32_libid_type
="unknown"
3546 win32_fileres
=`file -L $1 2>/dev/null`
3547 case $win32_fileres in
3548 *ar\ archive\ import\ library
*) # definitely import
3549 win32_libid_type
="x86 archive import"
3551 *ar\ archive
*) # could be an import, or static
3552 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3553 if eval $OBJDUMP -f $1 |
$SED -e '10q' 2>/dev
/null |
3554 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev
/null
; then
3555 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3556 win32_nmres
=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3565 case $win32_nmres in
3566 import
*) win32_libid_type
="x86 archive import";;
3567 *) win32_libid_type
="x86 archive static";;
3572 win32_libid_type
="x86 DLL"
3574 *executable
*) # but shell scripts are "executable" too...
3575 case $win32_fileres in
3576 *MS\ Windows\ PE\ Intel
*)
3577 win32_libid_type
="x86 DLL"
3582 $ECHO "$win32_libid_type"
3585 # func_cygming_dll_for_implib ARG
3587 # Platform-specific function to extract the
3588 # name of the DLL associated with the specified
3589 # import library ARG.
3590 # Invoked by eval'ing the libtool variable
3591 # $sharedlib_from_linklib_cmd
3592 # Result is available in the variable
3593 # $sharedlib_from_linklib_result
3594 func_cygming_dll_for_implib
()
3597 sharedlib_from_linklib_result
=`$DLLTOOL --identify-strict --identify "$1"`
3600 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3602 # The is the core of a fallback implementation of a
3603 # platform-specific function to extract the name of the
3604 # DLL associated with the specified import library LIBNAME.
3606 # SECTION_NAME is either .idata$6 or .idata$7, depending
3607 # on the platform and compiler that created the implib.
3609 # Echos the name of the DLL associated with the
3610 # specified import library.
3611 func_cygming_dll_for_implib_fallback_core
()
3614 match_literal
=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3615 $OBJDUMP -s --section "$1" "$2" 2>/dev
/null |
3616 $SED '/^Contents of section '"$match_literal"':/{
3617 # Place marker at beginning of archive member dllname section
3622 # These lines can sometimes be longer than 43 characters, but
3623 # are always uninteresting
3624 /:[ ]*file format pe[i]\{,1\}-/d
3625 /^In archive [^:]*:/d
3626 # Ensure marker is printed
3628 # Remove all lines with less than 43 characters
3630 # From remaining lines, remove first 43 characters
3633 # Join marker and all lines until next marker into a single line
3634 /^====MARK====/ b para
3643 # Remove trailing dots and whitespace
3647 # we now have a list, one entry per line, of the stringified
3648 # contents of the appropriate section of all members of the
3649 # archive which possess that section. Heuristic: eliminate
3650 # all those which have a first or second character that is
3651 # a '.' (that is, objdump's representation of an unprintable
3652 # character.) This should work for all archives with less than
3653 # 0x302f exports -- but will fail for DLLs whose name actually
3654 # begins with a literal '.' or a single character followed by
3657 # Of those that remain, print the first one.
3658 $SED -e '/^\./d;/^.\./d;q'
3661 # func_cygming_gnu_implib_p ARG
3662 # This predicate returns with zero status (TRUE) if
3663 # ARG is a GNU/binutils-style import library. Returns
3664 # with nonzero status (FALSE) otherwise.
3665 func_cygming_gnu_implib_p
()
3668 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3669 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)$'`
3670 test -n "$func_cygming_gnu_implib_tmp"
3673 # func_cygming_ms_implib_p ARG
3674 # This predicate returns with zero status (TRUE) if
3675 # ARG is an MS-style import library. Returns
3676 # with nonzero status (FALSE) otherwise.
3677 func_cygming_ms_implib_p
()
3680 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3681 func_cygming_ms_implib_tmp
=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3682 test -n "$func_cygming_ms_implib_tmp"
3685 # func_cygming_dll_for_implib_fallback ARG
3686 # Platform-specific function to extract the
3687 # name of the DLL associated with the specified
3688 # import library ARG.
3690 # This fallback implementation is for use when $DLLTOOL
3691 # does not support the --identify-strict option.
3692 # Invoked by eval'ing the libtool variable
3693 # $sharedlib_from_linklib_cmd
3694 # Result is available in the variable
3695 # $sharedlib_from_linklib_result
3696 func_cygming_dll_for_implib_fallback
()
3699 if func_cygming_gnu_implib_p
"$1" ; then
3700 # binutils import library
3701 sharedlib_from_linklib_result
=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3702 elif func_cygming_ms_implib_p
"$1" ; then
3703 # ms-generated import library
3704 sharedlib_from_linklib_result
=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3707 sharedlib_from_linklib_result
=""
3712 # func_extract_an_archive dir oldlib
3713 func_extract_an_archive
()
3716 f_ex_an_ar_dir
="$1"; shift
3717 f_ex_an_ar_oldlib
="$1"
3718 if test "$lock_old_archive_extraction" = yes; then
3719 lockfile
=$f_ex_an_ar_oldlib.lock
3720 until $opt_dry_run ||
ln "$progpath" "$lockfile" 2>/dev
/null
; do
3721 func_echo
"Waiting for $lockfile to be removed"
3725 func_show_eval
"(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3726 'stat=$?; rm -f "$lockfile"; exit $stat'
3727 if test "$lock_old_archive_extraction" = yes; then
3728 $opt_dry_run ||
rm -f "$lockfile"
3730 if ($AR t
"$f_ex_an_ar_oldlib" |
sort |
sort -uc >/dev
/null
2>&1); then
3733 func_fatal_error
"object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3738 # func_extract_archives gentop oldlib ...
3739 func_extract_archives
()
3742 my_gentop
="$1"; shift
3743 my_oldlibs
=${1+"$@"}
3749 for my_xlib
in $my_oldlibs; do
3750 # Extract the objects.
3752 [\\/]* |
[A-Za-z
]:[\\/]*) my_xabs
="$my_xlib" ;;
3753 *) my_xabs
=`pwd`"/$my_xlib" ;;
3755 func_basename
"$my_xlib"
3756 my_xlib
="$func_basename_result"
3759 case " $extracted_archives " in
3761 func_arith
$extracted_serial + 1
3762 extracted_serial
=$func_arith_result
3763 my_xlib_u
=lt
$extracted_serial-$my_xlib ;;
3767 extracted_archives
="$extracted_archives $my_xlib_u"
3768 my_xdir
="$my_gentop/$my_xlib_u"
3770 func_mkdir_p
"$my_xdir"
3774 func_verbose
"Extracting $my_xabs"
3775 # Do not bother doing anything if just a dry run
3777 darwin_orig_dir
=`pwd`
3778 cd $my_xdir ||
exit $?
3779 darwin_archive
=$my_xabs
3781 darwin_base_archive
=`basename "$darwin_archive"`
3782 darwin_arches
=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3783 if test -n "$darwin_arches"; then
3784 darwin_arches
=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3786 func_verbose
"$darwin_base_archive has multiple architectures $darwin_arches"
3787 for darwin_arch
in $darwin_arches ; do
3788 func_mkdir_p
"unfat-$$/${darwin_base_archive}-${darwin_arch}"
3789 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3790 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3791 func_extract_an_archive
"`pwd`" "${darwin_base_archive}"
3793 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3794 done # $darwin_arches
3795 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3796 darwin_filelist
=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3799 for darwin_file
in $darwin_filelist; do
3800 darwin_files
=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3801 $LIPO -create -output "$darwin_file" $darwin_files
3802 done # $darwin_filelist
3804 cd "$darwin_orig_dir"
3807 func_extract_an_archive
"$my_xdir" "$my_xabs"
3812 func_extract_an_archive
"$my_xdir" "$my_xabs"
3815 my_oldobjs
="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3818 func_extract_archives_result
="$my_oldobjs"
3822 # func_emit_wrapper [arg=no]
3824 # Emit a libtool wrapper script on stdout.
3825 # Don't directly open a file because we may want to
3826 # incorporate the script contents within a cygwin/mingw
3827 # wrapper executable. Must ONLY be called from within
3828 # func_mode_link because it depends on a number of variables
3831 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3832 # variable will take. If 'yes', then the emitted script
3833 # will assume that the directory in which it is stored is
3834 # the $objdir directory. This is a cygwin/mingw-specific
3836 func_emit_wrapper
()
3838 func_emit_wrapper_arg1
=${1-no}
3843 # $output - temporary wrapper script for $objdir/$outputname
3844 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3846 # The $output program cannot be directly executed until all the libtool
3847 # libraries that it depends on are installed.
3849 # This wrapper script should never be moved out of the build directory.
3850 # If it is, it will not operate correctly.
3852 # Sed substitution that helps us do robust quoting. It backslashifies
3853 # metacharacters that are still active within double-quoted strings.
3854 sed_quote_subst='$sed_quote_subst'
3856 # Be Bourne compatible
3857 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3860 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3861 # is contrary to our usage. Disable this feature.
3862 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3863 setopt NO_GLOB_SUBST
3865 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3867 BIN_SH=xpg4; export BIN_SH # for Tru64
3868 DUALCASE=1; export DUALCASE # for MKS sh
3870 # The HP-UX ksh and POSIX shell print the target directory to stdout
3872 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3874 relink_command=\"$relink_command\"
3876 # This environment variable determines our operation mode.
3877 if test \"\$libtool_install_magic\" = \"$magic\"; then
3878 # install mode needs the following variables:
3879 generated_by_libtool_version='$macro_version'
3880 notinst_deplibs='$notinst_deplibs'
3882 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3883 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3886 qECHO
=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3889 # A function that is used when there is no print builtin or printf.
3890 func_fallback_echo ()
3892 eval 'cat <<_LTECHO_EOF
3899 # Very basic option parsing. These options are (a) specific to
3900 # the libtool wrapper, (b) are identical between the wrapper
3901 # /script/ and the wrapper /executable/ which is used only on
3902 # windows platforms, and (c) all begin with the string "--lt-"
3903 # (application programs are unlikely to have options which match
3906 # There are only two supported options: --lt-debug and
3907 # --lt-dump-script. There is, deliberately, no --lt-help.
3909 # The first argument to this parsing function should be the
3910 # script's $0 value, followed by "$@
".
3912 func_parse_lt_options ()
3918 case \"\$lt_opt\" in
3919 --lt-debug) lt_option_debug=1 ;;
3921 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3922 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3923 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3924 cat \"\$lt_dump_D/\$lt_dump_F\"
3928 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3934 # Print the debug banner immediately:
3935 if test -n \"\$lt_option_debug\"; then
3936 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3940 # Used when --lt-debug. Prints its arguments to stdout
3941 # (redirection is the responsibility of the caller)
3942 func_lt_dump_args ()
3947 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3948 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3952 # Core function for launching the target application
3953 func_exec_program_core ()
3957 # Backslashes separate directories on plain windows
3958 *-*-mingw |
*-*-os2* |
*-cegcc*)
3960 if test -n \"\$lt_option_debug\"; then
3961 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3962 func_lt_dump_args \${1+\"\$@\"} 1>&2
3964 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3970 if test -n \"\$lt_option_debug\"; then
3971 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3972 func_lt_dump_args \${1+\"\$@\"} 1>&2
3974 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3979 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3983 # A function to encapsulate launching the target application
3984 # Strips options in the --lt-* namespace from \$@ and
3985 # launches target application with the remaining arguments.
3986 func_exec_program ()
3994 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3999 func_exec_program_core \${1+\"\$@\"}
4003 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
4005 # Find the directory that this script lives in.
4006 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
4007 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4009 # Follow symbolic links until we get to the real thisdir.
4010 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
4011 while test -n \"\$file\"; do
4012 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
4014 # If there was a directory component, then change thisdir.
4015 if test \"x\$destdir\" != \"x\$file\"; then
4016 case \"\$destdir\" in
4017 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4018 *) thisdir=\"\$thisdir/\$destdir\" ;;
4022 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
4023 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
4026 # Usually 'no', except on cygwin/mingw when embedded into
4028 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
4029 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
4030 # special case for '.'
4031 if test \"\$thisdir\" = \".\"; then
4034 # remove .libs from thisdir
4035 case \"\$thisdir\" in
4036 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
4037 $objdir ) thisdir=. ;;
4041 # Try to get the absolute directory name.
4042 absdir=\`cd \"\$thisdir\" && pwd\`
4043 test -n \"\$absdir\" && thisdir=\"\$absdir\"
4046 if test "$fast_install" = yes; then
4048 program=lt-'$outputname'$exeext
4049 progdir=\"\$thisdir/$objdir\"
4051 if test ! -f \"\$progdir/\$program\" ||
4052 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4053 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4055 file=\"\$\$-\$program\"
4057 if test ! -d \"\$progdir\"; then
4058 $MKDIR \"\$progdir\"
4060 $RM \"\$progdir/\$file\"
4065 # relink executable if necessary
4066 if test -n \"\$relink_command\"; then
4067 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4069 $ECHO \"\$relink_command_output\" >&2
4070 $RM \"\$progdir/\$file\"
4075 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4076 { $RM \"\$progdir/\$program\";
4077 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4078 $RM \"\$progdir/\$file\"
4082 program='$outputname'
4083 progdir=\"\$thisdir/$objdir\"
4089 if test -f \"\$progdir/\$program\"; then"
4091 # fixup the dll searchpath if we need to.
4093 # Fix the DLL searchpath if we need to. Do this before prepending
4094 # to shlibpath, because on Windows, both are PATH and uninstalled
4095 # libraries must come first.
4096 if test -n "$dllsearchpath"; then
4098 # Add the dll search path components to the executable PATH
4099 PATH=$dllsearchpath:\$PATH
4103 # Export our shlibpath_var if we have one.
4104 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4106 # Add our own library path to $shlibpath_var
4107 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4109 # Some systems cannot cope with colon-terminated $shlibpath_var
4110 # The second colon is a workaround for a bug in BeOS R4 sed
4111 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4113 export $shlibpath_var
4118 if test \"\$libtool_execute_magic\" != \"$magic\"; then
4119 # Run the actual program with our arguments.
4120 func_exec_program \${1+\"\$@\"}
4123 # The program doesn't exist.
4124 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4125 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4126 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4134 # func_emit_cwrapperexe_src
4135 # emit the source code for a wrapper executable on stdout
4136 # Must ONLY be called from within func_mode_link because
4137 # it depends on a number of variable set therein.
4138 func_emit_cwrapperexe_src
()
4142 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4143 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4145 The $output program cannot be directly executed until all the libtool
4146 libraries that it depends on are installed.
4148 This wrapper executable should never be moved out of the build directory.
4149 If it is, it will not operate correctly.
4154 # define _CRT_SECURE_NO_DEPRECATE 1
4159 # include <direct.h>
4160 # include <process.h>
4163 # include <unistd.h>
4164 # include <stdint.h>
4176 #include <sys/stat.h>
4178 /* declarations of non-ANSI functions */
4179 #if defined(__MINGW32__)
4180 # ifdef __STRICT_ANSI__
4181 int _putenv (const char *);
4183 #elif defined(__CYGWIN__)
4184 # ifdef __STRICT_ANSI__
4185 char *realpath (const char *, char *);
4186 int putenv (char *);
4187 int setenv (const char *, const char *, int);
4189 /* #elif defined (other platforms) ... */
4192 /* portability defines, excluding path handling macros */
4193 #if defined(_MSC_VER)
4194 # define setmode _setmode
4196 # define chmod _chmod
4197 # define getcwd _getcwd
4198 # define putenv _putenv
4199 # define S_IXUSR _S_IEXEC
4200 # ifndef _INTPTR_T_DEFINED
4201 # define _INTPTR_T_DEFINED
4202 # define intptr_t int
4204 #elif defined(__MINGW32__)
4205 # define setmode _setmode
4207 # define chmod _chmod
4208 # define getcwd _getcwd
4209 # define putenv _putenv
4210 #elif defined(__CYGWIN__)
4211 # define HAVE_SETENV
4212 # define FOPEN_WB "wb"
4213 /* #elif defined (other platforms) ... */
4216 #if defined(PATH_MAX)
4217 # define LT_PATHMAX PATH_MAX
4218 #elif defined(MAXPATHLEN)
4219 # define LT_PATHMAX MAXPATHLEN
4221 # define LT_PATHMAX 1024
4231 /* path handling portability macros */
4232 #ifndef DIR_SEPARATOR
4233 # define DIR_SEPARATOR '/'
4234 # define PATH_SEPARATOR ':'
4237 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4239 # define HAVE_DOS_BASED_FILE_SYSTEM
4240 # define FOPEN_WB "wb"
4241 # ifndef DIR_SEPARATOR_2
4242 # define DIR_SEPARATOR_2 '\\'
4244 # ifndef PATH_SEPARATOR_2
4245 # define PATH_SEPARATOR_2 ';'
4249 #ifndef DIR_SEPARATOR_2
4250 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4251 #else /* DIR_SEPARATOR_2 */
4252 # define IS_DIR_SEPARATOR(ch) \
4253 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4254 #endif /* DIR_SEPARATOR_2 */
4256 #ifndef PATH_SEPARATOR_2
4257 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4258 #else /* PATH_SEPARATOR_2 */
4259 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4260 #endif /* PATH_SEPARATOR_2 */
4263 # define FOPEN_WB "w"
4266 # define _O_BINARY 0
4269 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4270 #define XFREE(stale) do { \
4271 if (stale) { free ((void *) stale); stale = 0; } \
4272 } while (/*CONSTCOND*/0)
4274 #if defined(LT_DEBUGWRAPPER)
4275 static int lt_debug = 1;
4277 static int lt_debug = 0;
4280 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4282 void *xmalloc (size_t num);
4283 char *xstrdup (const char *string);
4284 const char *base_name (const char *name);
4285 char *find_executable (const char *wrapper);
4286 char *chase_symlinks (const char *pathspec);
4287 int make_executable (const char *path);
4288 int check_executable (const char *path);
4289 char *strendzap (char *str, const char *pat);
4290 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4291 void lt_fatal (const char *file, int line, const char *message, ...);
4292 static const char *nonnull (const char *s);
4293 static const char *nonempty (const char *s);
4294 void lt_setenv (const char *name, const char *value);
4295 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4296 void lt_update_exe_path (const char *name, const char *value);
4297 void lt_update_lib_path (const char *name, const char *value);
4298 char **prepare_spawn (char **argv);
4299 void lt_dump_script (FILE *f);
4303 volatile const char * MAGIC_EXE = "$magic_exe";
4304 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4307 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4308 func_to_host_path "$temp_rpath"
4310 const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4314 const char
* LIB_PATH_VALUE
= "";
4318 if test -n "$dllsearchpath"; then
4319 func_to_host_path
"$dllsearchpath:"
4321 const char * EXE_PATH_VARNAME = "PATH";
4322 const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4326 const char * EXE_PATH_VARNAME = "";
4327 const char * EXE_PATH_VALUE = "";
4331 if test "$fast_install" = yes; then
4333 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4337 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4344 #define LTWRAPPER_OPTION_PREFIX "--lt-"
4346 static const char
*ltwrapper_option_prefix
= LTWRAPPER_OPTION_PREFIX
;
4347 static const char
*dumpscript_opt
= LTWRAPPER_OPTION_PREFIX
"dump-script";
4348 static const char
*debug_opt
= LTWRAPPER_OPTION_PREFIX
"debug";
4351 main
(int argc
, char
*argv
[])
4356 char
*actual_cwrapper_path
;
4357 char
*actual_cwrapper_name
;
4360 intptr_t rval
= 127;
4364 program_name
= (char
*) xstrdup
(base_name
(argv
[0]));
4365 newargz
= XMALLOC
(char
*, argc
+ 1);
4367 /* very simple arg parsing
; don
't want to rely on getopt
4368 * also, copy all non cwrapper options to newargz, except
4369 * argz[0], which is handled differently
4372 for (i = 1; i < argc; i++)
4374 if (strcmp (argv[i], dumpscript_opt) == 0)
4378 *mingw* | *cygwin* )
4379 # make stdout use "unix" line endings
4380 echo " setmode(1,_O_BINARY);"
4385 lt_dump_script (stdout);
4388 if (strcmp (argv[i], debug_opt) == 0)
4393 if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4395 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4396 namespace, but it is not one of the ones we know about and
4397 have already dealt with, above (inluding dump-script), then
4398 report an error. Otherwise, targets might begin to believe
4399 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4400 namespace. The first time any user complains about this, we'll
4401 need to
make LTWRAPPER_OPTION_PREFIX a configure-time option
4402 or a configure.ac-settable value.
4404 lt_fatal
(__FILE__
, __LINE__
,
4405 "unrecognized %s option: '%s'",
4406 ltwrapper_option_prefix
, argv
[i
]);
4409 newargz
[++newargc
] = xstrdup
(argv
[i
]);
4411 newargz
[++newargc
] = NULL
;
4415 /* The GNU banner must be the first non-error debug message */
4416 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4419 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4420 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4422 tmp_pathspec = find_executable (argv[0]);
4423 if (tmp_pathspec == NULL)
4424 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4425 lt_debugprintf (__FILE__, __LINE__,
4426 "(main) found exe (before symlink chase) at: %s\n",
4429 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4430 lt_debugprintf (__FILE__, __LINE__,
4431 "(main) found exe (after symlink chase) at: %s\n",
4432 actual_cwrapper_path);
4433 XFREE (tmp_pathspec);
4435 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4436 strendzap (actual_cwrapper_path, actual_cwrapper_name);
4438 /* wrapper name transforms */
4439 strendzap (actual_cwrapper_name, ".exe");
4440 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4441 XFREE (actual_cwrapper_name);
4442 actual_cwrapper_name = tmp_pathspec;
4445 /* target_name transforms -- use actual target program name; might have lt- prefix */
4446 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4447 strendzap (target_name, ".exe");
4448 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4449 XFREE (target_name);
4450 target_name = tmp_pathspec;
4453 lt_debugprintf (__FILE__, __LINE__,
4454 "(main) libtool target name: %s\n",
4460 XMALLOC (char, (strlen (actual_cwrapper_path) +
4461 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4462 strcpy (newargz[0], actual_cwrapper_path);
4463 strcat (newargz[0], "$objdir");
4464 strcat (newargz[0], "/");
4468 /* stop here
, and copy so we don
't have to do this twice */
4469 tmp_pathspec = xstrdup (newargz[0]);
4471 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4472 strcat (newargz[0], actual_cwrapper_name);
4474 /* DO want the lt- prefix here if it exists, so use target_name */
4475 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4476 XFREE (tmp_pathspec);
4477 tmp_pathspec = NULL;
4485 while ((p = strchr (newargz[0], '\\')) != NULL)
4489 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4499 XFREE (target_name);
4500 XFREE (actual_cwrapper_path);
4501 XFREE (actual_cwrapper_name);
4503 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4504 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4505 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4506 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4507 because on Windows, both *_VARNAMEs are PATH but uninstalled
4508 libraries must come first. */
4509 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4510 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4512 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4513 nonnull (lt_argv_zero));
4514 for (i = 0; i < newargc; i++)
4516 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4517 i, nonnull (newargz[i]));
4525 /* execv doesn't actually work on mingw as expected on unix
*/
4526 newargz
= prepare_spawn
(newargz
);
4527 rval
= _spawnv
(_P_WAIT
, lt_argv_zero
, (const char
* const
*) newargz
);
4530 /* failed to start process
*/
4531 lt_debugprintf
(__FILE__
, __LINE__
,
4532 "(main) failed to launch target \"%s\": %s\n",
4533 lt_argv_zero
, nonnull
(strerror
(errno
)));
4541 execv (lt_argv_zero, newargz);
4542 return rval; /* =127, but avoids unused variable warning */
4551 xmalloc
(size_t num
)
4553 void
*p
= (void
*) malloc
(num
);
4555 lt_fatal
(__FILE__
, __LINE__
, "memory exhausted");
4561 xstrdup
(const char
*string
)
4563 return string ? strcpy
((char
*) xmalloc
(strlen
(string
) + 1),
4568 base_name
(const char
*name
)
4572 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4573 /* Skip over the disk name
in MSDOS pathnames.
*/
4574 if (isalpha
((unsigned char
) name
[0]) && name
[1] == ':')
4578 for (base
= name
; *name
; name
++)
4579 if (IS_DIR_SEPARATOR
(*name
))
4585 check_executable
(const char
*path
)
4589 lt_debugprintf
(__FILE__
, __LINE__
, "(check_executable): %s\n",
4591 if ((!path
) ||
(!*path
))
4594 if ((stat
(path
, &st
) >= 0)
4595 && (st.st_mode
& (S_IXUSR | S_IXGRP | S_IXOTH
)))
4602 make_executable
(const char
*path
)
4607 lt_debugprintf
(__FILE__
, __LINE__
, "(make_executable): %s\n",
4609 if ((!path
) ||
(!*path
))
4612 if (stat
(path
, &st
) >= 0)
4614 rval
= chmod (path
, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR
);
4619 /* Searches
for the full path of the wrapper. Returns
4620 newly allocated full path name
if found
, NULL otherwise
4621 Does not chase symlinks
, even on platforms that support them.
4624 find_executable
(const char
*wrapper
)
4629 /* static buffer
for getcwd
*/
4630 char tmp
[LT_PATHMAX
+ 1];
4634 lt_debugprintf
(__FILE__
, __LINE__
, "(find_executable): %s\n",
4635 nonempty
(wrapper
));
4637 if ((wrapper
== NULL
) ||
(*wrapper
== '\0'))
4640 /* Absolute path?
*/
4641 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4642 if (isalpha
((unsigned char
) wrapper
[0]) && wrapper
[1] == ':')
4644 concat_name
= xstrdup
(wrapper
);
4645 if (check_executable
(concat_name
))
4647 XFREE
(concat_name
);
4652 if (IS_DIR_SEPARATOR
(wrapper
[0]))
4654 concat_name
= xstrdup
(wrapper
);
4655 if (check_executable
(concat_name
))
4657 XFREE
(concat_name
);
4659 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4663 for (p
= wrapper
; *p
; p
++)
4671 /* no slashes
; search PATH
*/
4672 const char
*path
= getenv
("PATH");
4675 for (p
= path
; *p
; p
= p_next
)
4679 for (q
= p
; *q
; q
++)
4680 if (IS_PATH_SEPARATOR
(*q
))
4683 p_next
= (*q
== '\0' ? q
: q
+ 1);
4686 /* empty path
: current directory
*/
4687 if (getcwd
(tmp
, LT_PATHMAX
) == NULL
)
4688 lt_fatal
(__FILE__
, __LINE__
, "getcwd failed: %s",
4689 nonnull
(strerror
(errno
)));
4690 tmp_len
= strlen
(tmp
);
4692 XMALLOC
(char
, tmp_len
+ 1 + strlen
(wrapper
) + 1);
4693 memcpy
(concat_name
, tmp
, tmp_len
);
4694 concat_name
[tmp_len
] = '/';
4695 strcpy
(concat_name
+ tmp_len
+ 1, wrapper
);
4700 XMALLOC
(char
, p_len
+ 1 + strlen
(wrapper
) + 1);
4701 memcpy
(concat_name
, p
, p_len
);
4702 concat_name
[p_len
] = '/';
4703 strcpy
(concat_name
+ p_len
+ 1, wrapper
);
4705 if (check_executable
(concat_name
))
4707 XFREE
(concat_name
);
4710 /* not found
in PATH
; assume curdir
*/
4712 /* Relative path | not found
in path
: prepend cwd
*/
4713 if (getcwd
(tmp
, LT_PATHMAX
) == NULL
)
4714 lt_fatal
(__FILE__
, __LINE__
, "getcwd failed: %s",
4715 nonnull
(strerror
(errno
)));
4716 tmp_len
= strlen
(tmp
);
4717 concat_name
= XMALLOC
(char
, tmp_len
+ 1 + strlen
(wrapper
) + 1);
4718 memcpy
(concat_name
, tmp
, tmp_len
);
4719 concat_name
[tmp_len
] = '/';
4720 strcpy
(concat_name
+ tmp_len
+ 1, wrapper
);
4722 if (check_executable
(concat_name
))
4724 XFREE
(concat_name
);
4729 chase_symlinks
(const char
*pathspec
)
4732 return xstrdup
(pathspec
);
4734 char buf
[LT_PATHMAX
];
4736 char
*tmp_pathspec
= xstrdup
(pathspec
);
4738 int has_symlinks
= 0;
4739 while (strlen
(tmp_pathspec
) && !has_symlinks
)
4741 lt_debugprintf
(__FILE__
, __LINE__
,
4742 "checking path component for symlinks: %s\n",
4744 if (lstat
(tmp_pathspec
, &s
) == 0)
4746 if (S_ISLNK
(s.st_mode
) != 0)
4752 /* search backwards
for last DIR_SEPARATOR
*/
4753 p
= tmp_pathspec
+ strlen
(tmp_pathspec
) - 1;
4754 while ((p
> tmp_pathspec
) && (!IS_DIR_SEPARATOR
(*p
)))
4756 if ((p
== tmp_pathspec
) && (!IS_DIR_SEPARATOR
(*p
)))
4758 /* no
more DIR_SEPARATORS left
*/
4765 lt_fatal
(__FILE__
, __LINE__
,
4766 "error accessing file \"%s\": %s",
4767 tmp_pathspec
, nonnull
(strerror
(errno
)));
4770 XFREE
(tmp_pathspec
);
4774 return xstrdup
(pathspec
);
4777 tmp_pathspec
= realpath
(pathspec
, buf
);
4778 if (tmp_pathspec
== 0)
4780 lt_fatal
(__FILE__
, __LINE__
,
4781 "could not follow symlinks for %s", pathspec
);
4783 return xstrdup
(tmp_pathspec
);
4788 strendzap
(char
*str
, const char
*pat
)
4792 assert
(str
!= NULL
);
4793 assert
(pat
!= NULL
);
4796 patlen
= strlen
(pat
);
4800 str
+= len
- patlen
;
4801 if (strcmp
(str
, pat
) == 0)
4808 lt_debugprintf
(const char
*file, int line
, const char
*fmt, ...
)
4813 (void
) fprintf
(stderr
, "%s:%s:%d: ", program_name
, file, line
);
4814 va_start
(args
, fmt);
4815 (void
) vfprintf
(stderr
, fmt, args
);
4821 lt_error_core
(int exit_status
, const char
*file,
4822 int line
, const char
*mode
,
4823 const char
*message
, va_list ap
)
4825 fprintf
(stderr
, "%s:%s:%d: %s: ", program_name
, file, line
, mode
);
4826 vfprintf
(stderr
, message
, ap
);
4827 fprintf
(stderr
, ".\n");
4829 if (exit_status
>= 0)
4834 lt_fatal
(const char
*file, int line
, const char
*message
, ...
)
4837 va_start
(ap
, message
);
4838 lt_error_core
(EXIT_FAILURE
, file, line
, "FATAL", message
, ap
);
4843 nonnull
(const char
*s
)
4845 return s ? s
: "(null)";
4849 nonempty
(const char
*s
)
4851 return (s
&& !*s
) ?
"(empty)" : nonnull
(s
);
4855 lt_setenv
(const char
*name
, const char
*value
)
4857 lt_debugprintf
(__FILE__
, __LINE__
,
4858 "(lt_setenv) setting '%s' to '%s'\n",
4859 nonnull
(name
), nonnull
(value
));
4862 /* always
make a copy
, for consistency with
!HAVE_SETENV
*/
4863 char
*str
= xstrdup
(value
);
4864 setenv
(name
, str
, 1);
4866 int len
= strlen
(name
) + 1 + strlen
(value
) + 1;
4867 char
*str
= XMALLOC
(char
, len
);
4868 sprintf
(str
, "%s=%s", name
, value
);
4869 if (putenv
(str
) != EXIT_SUCCESS
)
4878 lt_extend_str
(const char
*orig_value
, const char
*add
, int to_end
)
4881 if (orig_value
&& *orig_value
)
4883 int orig_value_len
= strlen
(orig_value
);
4884 int add_len
= strlen
(add
);
4885 new_value
= XMALLOC
(char
, add_len
+ orig_value_len
+ 1);
4888 strcpy
(new_value
, orig_value
);
4889 strcpy
(new_value
+ orig_value_len
, add
);
4893 strcpy
(new_value
, add
);
4894 strcpy
(new_value
+ add_len
, orig_value
);
4899 new_value
= xstrdup
(add
);
4905 lt_update_exe_path
(const char
*name
, const char
*value
)
4907 lt_debugprintf
(__FILE__
, __LINE__
,
4908 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4909 nonnull
(name
), nonnull
(value
));
4911 if (name
&& *name
&& value
&& *value
)
4913 char
*new_value
= lt_extend_str
(getenv
(name
), value
, 0);
4914 /* some systems can
't cope with a ':'-terminated path #' */
4915 int len
= strlen
(new_value
);
4916 while (((len
= strlen
(new_value
)) > 0) && IS_PATH_SEPARATOR
(new_value
[len-1
]))
4918 new_value
[len-1
] = '\0';
4920 lt_setenv
(name
, new_value
);
4926 lt_update_lib_path
(const char
*name
, const char
*value
)
4928 lt_debugprintf
(__FILE__
, __LINE__
,
4929 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4930 nonnull
(name
), nonnull
(value
));
4932 if (name
&& *name
&& value
&& *value
)
4934 char
*new_value
= lt_extend_str
(getenv
(name
), value
, 0);
4935 lt_setenv
(name
, new_value
);
4945 /* Prepares an argument vector before calling spawn().
4946 Note that spawn() does not by itself call the command interpreter
4947 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4948 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4950 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4951 }) ? "cmd.exe" : "command.com").
4952 Instead it simply concatenates the arguments, separated by ' ', and calls
4953 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4954 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4956 - Space and tab are interpreted as delimiters. They are not treated as
4957 delimiters if they are surrounded by double quotes: "...".
4958 - Unescaped double quotes are removed from the input. Their only effect is
4959 that within double quotes, space and tab are treated like normal
4961 - Backslashes not followed by double quotes are not special.
4962 - But 2*n+1 backslashes followed by a double quote become
4963 n backslashes followed by a double quote (n >= 0):
4968 #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"
4969 #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"
4971 prepare_spawn (char **argv)
4977 /* Count number of arguments. */
4978 for (argc = 0; argv[argc] != NULL; argc++)
4981 /* Allocate new argument vector. */
4982 new_argv = XMALLOC (char *, argc + 1);
4984 /* Put quoted arguments into the new argument vector. */
4985 for (i = 0; i < argc; i++)
4987 const char *string = argv[i];
4989 if (string[0] == '\0')
4990 new_argv[i] = xstrdup ("\"\"");
4991 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4993 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4995 unsigned int backslashes;
4997 char *quoted_string;
5004 for (s = string; *s != '\0'; s++)
5008 length += backslashes + 1;
5016 length += backslashes + 1;
5018 quoted_string = XMALLOC (char, length + 1);
5024 for (s = string; *s != '\0'; s++)
5030 for (j = backslashes + 1; j > 0; j--)
5042 for (j = backslashes; j > 0; j--)
5048 new_argv[i] = quoted_string;
5051 new_argv[i] = (char *) string;
5053 new_argv[argc] = NULL;
5062 void lt_dump_script
(FILE
* f
)
5065 func_emit_wrapper
yes |
5067 s/^\(.\{79\}\)\(..*\)/\1\
5072 s/\([^\n]*\).*/ fputs ("\1", f);/p
5079 # end: func_emit_cwrapperexe_src
5081 # func_win32_import_lib_p ARG
5082 # True if ARG is an import lib, as indicated by $file_magic_cmd
5083 func_win32_import_lib_p ()
5086 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5092 # func_mode_link arg...
5097 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5098 # It is impossible to link a dll without this setting, and
5099 # we shouldn't force the makefile maintainer to figure out
5100 # which system we are compiling for in order to pass an extra
5101 # flag for every libtool invocation.
5102 # allow_undefined=no
5104 # FIXME: Unfortunately, there are problems with the above when trying
5105 # to make a dll which has undefined symbols, in which case not
5106 # even a static library is built. For now, we need to specify
5107 # -no-undefined on the libtool link line when we can be certain
5108 # that all symbols are satisfied, otherwise we get a static library.
5115 libtool_args=$nonopt
5116 base_compile="$nonopt $@"
5117 compile_command=$nonopt
5118 finalize_command=$nonopt
5131 lib_search_path=`pwd`
5133 new_inherited_linker_flags=
5142 export_symbols_regex=
5150 precious_files_regex=
5151 prefer_static_libs=no
5164 single_module="${wl}-single_module"
5165 func_infer_tag $base_compile
5167 # We need to know -static, to get the right output filenames.
5172 test "$build_libtool_libs" != yes && \
5173 func_fatal_configuration "can not build a shared library"
5177 -all-static | -static | -static-libtool-libs)
5180 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5181 func_warning "complete static linking is impossible in this configuration"
5183 if test -n "$link_static_flag"; then
5184 dlopen_self=$dlopen_self_static
5186 prefer_static_libs=yes
5189 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5190 dlopen_self=$dlopen_self_static
5192 prefer_static_libs=built
5194 -static-libtool-libs)
5195 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5196 dlopen_self=$dlopen_self_static
5198 prefer_static_libs=yes
5201 build_libtool_libs=no
5208 # See if our shared archives depend on static archives.
5209 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5211 # Go through the arguments, transforming them on the way.
5212 while test "$#" -gt 0; do
5215 func_quote_for_eval "$arg"
5216 qarg=$func_quote_for_eval_unquoted_result
5217 func_append libtool_args " $func_quote_for_eval_result"
5219 # If the previous option needs an argument, assign it.
5220 if test -n "$prev"; then
5223 func_append compile_command " @OUTPUT@"
5224 func_append finalize_command " @OUTPUT@"
5235 if test "$preload" = no; then
5236 # Add the symbol object into the linking commands.
5237 func_append compile_command " @SYMFILE@"
5238 func_append finalize_command " @SYMFILE@"
5242 *.la | *.lo) ;; # We handle these cases below.
5244 if test "$dlself" = no; then
5252 if test "$prev" = dlprefiles; then
5254 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5264 if test "$prev" = dlfiles; then
5265 func_append dlfiles " $arg"
5267 func_append dlprefiles " $arg"
5275 export_symbols="$arg"
5277 || func_fatal_error "symbol file \`$arg' does not exist"
5282 export_symbols_regex="$arg"
5290 *" $qarg.ltframework "*) ;;
5291 *) func_append deplibs " $qarg.ltframework" # this is fixed later
5300 inst_prefix_dir="$arg"
5305 if test -f "$arg"; then
5308 for fil in `cat "$save_arg"`
5310 # func_append moreargs " $fil"
5312 # A libtool-controlled object.
5314 # Check to see that this really is a libtool object.
5315 if func_lalib_unsafe_p "$arg"; then
5322 if test -z "$pic_object" ||
5323 test -z "$non_pic_object" ||
5324 test "$pic_object" = none &&
5325 test "$non_pic_object" = none; then
5326 func_fatal_error "cannot find name of object for \`$arg'"
5329 # Extract subdirectory from the argument.
5330 func_dirname "$arg" "/" ""
5331 xdir="$func_dirname_result"
5333 if test "$pic_object" != none; then
5334 # Prepend the subdirectory the object is found in.
5335 pic_object="$xdir$pic_object"
5337 if test "$prev" = dlfiles; then
5338 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5339 func_append dlfiles " $pic_object"
5343 # If libtool objects are unsupported, then we need to preload.
5348 # CHECK ME: I think I busted this. -Ossama
5349 if test "$prev" = dlprefiles; then
5350 # Preload the old-style object.
5351 func_append dlprefiles " $pic_object"
5356 func_append libobjs " $pic_object"
5361 if test "$non_pic_object" != none; then
5362 # Prepend the subdirectory the object is found in.
5363 non_pic_object="$xdir$non_pic_object"
5365 # A standard non-PIC object
5366 func_append non_pic_objects " $non_pic_object"
5367 if test -z "$pic_object" || test "$pic_object" = none ; then
5368 arg="$non_pic_object"
5371 # If the PIC object exists, use it instead.
5372 # $xdir was prepended to $pic_object above.
5373 non_pic_object="$pic_object"
5374 func_append non_pic_objects " $non_pic_object"
5377 # Only an error if not doing a dry-run.
5378 if $opt_dry_run; then
5379 # Extract subdirectory from the argument.
5380 func_dirname "$arg" "/" ""
5381 xdir="$func_dirname_result"
5384 pic_object=$xdir$objdir/$func_lo2o_result
5385 non_pic_object=$xdir$func_lo2o_result
5386 func_append libobjs " $pic_object"
5387 func_append non_pic_objects " $non_pic_object"
5389 func_fatal_error "\`$arg' is not a valid libtool object"
5394 func_fatal_error "link input file \`$arg' does not exist"
5401 precious_files_regex="$arg"
5411 # We need an absolute path.
5413 [\\/]* | [A-Za-z]:[\\/]*) ;;
5415 func_fatal_error "only absolute run-paths are allowed"
5418 if test "$prev" = rpath; then
5421 *) func_append rpath " $arg" ;;
5426 *) func_append xrpath " $arg" ;;
5438 func_append weak_libs " $arg"
5443 func_append linker_flags " $qarg"
5444 func_append compiler_flags " $qarg"
5446 func_append compile_command " $qarg"
5447 func_append finalize_command " $qarg"
5451 func_append compiler_flags " $qarg"
5453 func_append compile_command " $qarg"
5454 func_append finalize_command " $qarg"
5458 func_append linker_flags " $qarg"
5459 func_append compiler_flags " $wl$qarg"
5461 func_append compile_command " $wl$qarg"
5462 func_append finalize_command " $wl$qarg"
5466 eval "$prev=\"\$arg\""
5471 fi # test -n "$prev"
5477 if test -n "$link_static_flag"; then
5478 # See comment for -static flag below, for more details.
5479 func_append compile_command " $link_static_flag"
5480 func_append finalize_command " $link_static_flag"
5486 # FIXME: remove this flag sometime in the future.
5487 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5515 -export-symbols | -export-symbols-regex)
5516 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5517 func_fatal_error "more than one -exported-symbols argument is not allowed"
5519 if test "X$arg" = "X-export-symbols"; then
5537 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5538 # so, if we see these flags be careful not to treat them like -L
5540 case $with_gcc/$host in
5541 no/*-*-irix* | /*-*-irix*)
5542 func_append compile_command " $arg"
5543 func_append finalize_command " $arg"
5550 func_stripname "-L" '' "$arg"
5551 if test -z "$func_stripname_result"; then
5552 if test "$#" -gt 0; then
5553 func_fatal_error "require no space between \`-L' and \`$1'"
5555 func_fatal_error "need path for \`-L' option"
5558 func_resolve_sysroot "$func_stripname_result"
5559 dir=$func_resolve_sysroot_result
5560 # We need an absolute path.
5562 [\\/]* | [A-Za-z]:[\\/]*) ;;
5564 absdir=`cd "$dir" && pwd`
5565 test -z "$absdir" && \
5566 func_fatal_error "cannot determine absolute directory name of \`$dir'"
5571 *" -L$dir "* | *" $arg "*)
5572 # Will only happen for absolute or sysroot arguments
5575 # Preserve sysroot, but never include relative directories
5577 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5578 *) func_append deplibs " -L$dir" ;;
5580 func_append lib_search_path " $dir"
5584 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5585 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5586 case :$dllsearchpath: in
5588 ::) dllsearchpath=$dir;;
5589 *) func_append dllsearchpath ":$dir";;
5591 case :$dllsearchpath: in
5592 *":$testbindir:"*) ;;
5593 ::) dllsearchpath=$testbindir;;
5594 *) func_append dllsearchpath ":$testbindir";;
5602 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5604 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5605 # These systems don't actually have a C or math library (as such)
5609 # These systems don't actually have a C library (as such)
5610 test "X$arg" = "X-lc" && continue
5612 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5613 # Do not include libc due to us having libc/libc_r.
5614 test "X$arg" = "X-lc" && continue
5616 *-*-rhapsody* | *-*-darwin1.[012])
5617 # Rhapsody C and math libraries are in the System framework
5618 func_append deplibs " System.ltframework"
5621 *-*-sco3.2v5* | *-*-sco5v6*)
5622 # Causes problems with __ctype
5623 test "X$arg" = "X-lc" && continue
5625 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5626 # Compiler inserts libc in the correct place for threads to work
5627 test "X$arg" = "X-lc" && continue
5630 elif test "X$arg" = "X-lc_r"; then
5632 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5633 # Do not include libc_r directly, use -pthread flag.
5638 func_append deplibs " $arg"
5647 # Tru64 UNIX uses -model [arg] to determine the layout of C++
5648 # classes, name mangling, and exception handling.
5649 # Darwin uses the -arch flag to determine output architecture.
5650 -model|-arch|-isysroot|--sysroot)
5651 func_append compiler_flags " $arg"
5652 func_append compile_command " $arg"
5653 func_append finalize_command " $arg"
5658 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5659 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5660 func_append compiler_flags " $arg"
5661 func_append compile_command " $arg"
5662 func_append finalize_command " $arg"
5663 case "$new_inherited_linker_flags " in
5665 * ) func_append new_inherited_linker_flags " $arg" ;;
5671 single_module="${wl}-multi_module"
5682 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5683 # The PATH hackery in wrapper scripts is required on Windows
5684 # and Darwin in order for the loader to find any dlls it needs.
5685 func_warning "\`-no-install' is ignored for $host"
5686 func_warning "assuming \`-no-fast-install' instead"
5689 *) no_install=yes ;;
5706 -precious-files-regex)
5727 func_stripname '-R' '' "$arg"
5728 dir=$func_stripname_result
5729 # We need an absolute path.
5731 [\\/]* | [A-Za-z]:[\\/]*) ;;
5733 func_stripname '=' '' "$dir"
5734 dir=$lt_sysroot$func_stripname_result
5737 func_fatal_error "only absolute run-paths are allowed"
5742 *) func_append xrpath " $dir" ;;
5748 # The effects of -shared are defined in a previous loop.
5757 -static | -static-libtool-libs)
5758 # The effects of -static are defined in a previous loop.
5759 # We used to do the same as -all-static on platforms that
5760 # didn't have a PIC flag, but the assumption that the effects
5761 # would be equivalent was wrong. It would break on at least
5762 # Digital Unix and AIX.
5788 func_stripname '-Wc,' '' "$arg"
5789 args=$func_stripname_result
5791 save_ifs="$IFS"; IFS=','
5792 for flag in $args; do
5794 func_quote_for_eval "$flag"
5795 func_append arg " $func_quote_for_eval_result"
5796 func_append compiler_flags " $func_quote_for_eval_result"
5799 func_stripname ' ' '' "$arg"
5800 arg=$func_stripname_result
5804 func_stripname '-Wl,' '' "$arg"
5805 args=$func_stripname_result
5807 save_ifs="$IFS"; IFS=','
5808 for flag in $args; do
5810 func_quote_for_eval "$flag"
5811 func_append arg " $wl$func_quote_for_eval_result"
5812 func_append compiler_flags " $wl$func_quote_for_eval_result"
5813 func_append linker_flags " $func_quote_for_eval_result"
5816 func_stripname ' ' '' "$arg"
5817 arg=$func_stripname_result
5837 func_quote_for_eval "$arg"
5838 arg="$func_quote_for_eval_result"
5841 # Flags to be passed through unchanged, with rationale:
5842 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5843 # -r[0-9][0-9]* specify processor for the SGI compiler
5844 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5845 # +DA*, +DD* enable 64-bit mode for the HP compiler
5846 # -q* compiler args for the IBM compiler
5847 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5848 # -F/path path to uninstalled frameworks, gcc on darwin
5849 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5850 # @file GCC response files
5851 # -tp=* Portland pgcc target processor selection
5852 # --sysroot=* for sysroot support
5853 # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5854 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5855 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5856 -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5857 func_quote_for_eval "$arg"
5858 arg="$func_quote_for_eval_result"
5859 func_append compile_command " $arg"
5860 func_append finalize_command " $arg"
5861 func_append compiler_flags " $arg"
5865 # Some other compiler flag.
5867 func_quote_for_eval "$arg"
5868 arg="$func_quote_for_eval_result"
5872 # A standard object.
5873 func_append objs " $arg"
5877 # A libtool-controlled object.
5879 # Check to see that this really is a libtool object.
5880 if func_lalib_unsafe_p "$arg"; then
5887 if test -z "$pic_object" ||
5888 test -z "$non_pic_object" ||
5889 test "$pic_object" = none &&
5890 test "$non_pic_object" = none; then
5891 func_fatal_error "cannot find name of object for \`$arg'"
5894 # Extract subdirectory from the argument.
5895 func_dirname "$arg" "/" ""
5896 xdir="$func_dirname_result"
5898 if test "$pic_object" != none; then
5899 # Prepend the subdirectory the object is found in.
5900 pic_object="$xdir$pic_object"
5902 if test "$prev" = dlfiles; then
5903 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5904 func_append dlfiles " $pic_object"
5908 # If libtool objects are unsupported, then we need to preload.
5913 # CHECK ME: I think I busted this. -Ossama
5914 if test "$prev" = dlprefiles; then
5915 # Preload the old-style object.
5916 func_append dlprefiles " $pic_object"
5921 func_append libobjs " $pic_object"
5926 if test "$non_pic_object" != none; then
5927 # Prepend the subdirectory the object is found in.
5928 non_pic_object="$xdir$non_pic_object"
5930 # A standard non-PIC object
5931 func_append non_pic_objects " $non_pic_object"
5932 if test -z "$pic_object" || test "$pic_object" = none ; then
5933 arg="$non_pic_object"
5936 # If the PIC object exists, use it instead.
5937 # $xdir was prepended to $pic_object above.
5938 non_pic_object="$pic_object"
5939 func_append non_pic_objects " $non_pic_object"
5942 # Only an error if not doing a dry-run.
5943 if $opt_dry_run; then
5944 # Extract subdirectory from the argument.
5945 func_dirname "$arg" "/" ""
5946 xdir="$func_dirname_result"
5949 pic_object=$xdir$objdir/$func_lo2o_result
5950 non_pic_object=$xdir$func_lo2o_result
5951 func_append libobjs " $pic_object"
5952 func_append non_pic_objects " $non_pic_object"
5954 func_fatal_error "\`$arg' is not a valid libtool object"
5961 func_append deplibs " $arg"
5962 func_append old_deplibs " $arg"
5967 # A libtool-controlled library.
5969 func_resolve_sysroot "$arg"
5970 if test "$prev" = dlfiles; then
5971 # This library was specified with -dlopen.
5972 func_append dlfiles " $func_resolve_sysroot_result"
5974 elif test "$prev" = dlprefiles; then
5975 # The library was specified with -dlpreopen.
5976 func_append dlprefiles " $func_resolve_sysroot_result"
5979 func_append deplibs " $func_resolve_sysroot_result"
5984 # Some other compiler argument.
5986 # Unknown arguments in both finalize_command and compile_command need
5987 # to be aesthetically quoted because they are evaled later.
5988 func_quote_for_eval "$arg"
5989 arg="$func_quote_for_eval_result"
5993 # Now actually substitute the argument into the commands.
5994 if test -n "$arg"; then
5995 func_append compile_command " $arg"
5996 func_append finalize_command " $arg"
5998 done # argument parsing loop
6000 test -n "$prev" && \
6001 func_fatal_help "the \`$prevarg' option requires an argument"
6003 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
6004 eval arg=\"$export_dynamic_flag_spec\"
6005 func_append compile_command " $arg"
6006 func_append finalize_command " $arg"
6010 # calculate the name of the file, without its directory
6011 func_basename "$output"
6012 outputname="$func_basename_result"
6013 libobjs_save="$libobjs"
6015 if test -n "$shlibpath_var"; then
6016 # get the directories listed in $shlibpath_var
6017 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
6021 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
6022 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
6024 func_dirname "$output" "/" ""
6025 output_objdir="$func_dirname_result$objdir"
6026 func_to_tool_file "$output_objdir/"
6027 tool_output_objdir=$func_to_tool_file_result
6028 # Create the object directory.
6029 func_mkdir_p "$output_objdir"
6031 # Determine the type of output
6034 func_fatal_help "you must specify an output file"
6036 *.$libext) linkmode=oldlib ;;
6037 *.lo | *.$objext) linkmode=obj ;;
6038 *.la) linkmode=lib ;;
6039 *) linkmode=prog ;; # Anything else should be a program.
6045 # Find all interdependent deplibs by searching for libraries
6046 # that are linked more than once (e.g. -la -lb -la)
6047 for deplib in $deplibs; do
6048 if $opt_preserve_dup_deps ; then
6050 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6053 func_append libs " $deplib"
6056 if test "$linkmode" = lib; then
6057 libs="$predeps $libs $compiler_lib_search_path $postdeps"
6059 # Compute libraries that are listed more than once in $predeps
6060 # $postdeps and mark them as special (i.e., whose duplicates are
6061 # not to be eliminated).
6063 if $opt_duplicate_compiler_generated_deps; then
6064 for pre_post_dep in $predeps $postdeps; do
6065 case "$pre_post_deps " in
6066 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6068 func_append pre_post_deps " $pre_post_dep"
6077 need_relink=no # whether we're linking any uninstalled libtool libraries
6078 notinst_deplibs= # not-installed libtool libraries
6079 notinst_path= # paths that contain not-installed libtool libraries
6083 passes="conv dlpreopen link"
6084 for file in $dlfiles $dlprefiles; do
6088 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6099 passes="conv scan dlopen dlpreopen link"
6105 for pass in $passes; do
6106 # The preopen pass in lib mode reverses $deplibs; put it back here
6107 # so that -L comes before libs that need it for instance...
6108 if test "$linkmode,$pass" = "lib,link"; then
6109 ## FIXME: Find the place where the list is rebuilt in the wrong
6110 ## order, and fix it there properly
6112 for deplib in $deplibs; do
6113 tmp_deplibs="$deplib $tmp_deplibs"
6115 deplibs="$tmp_deplibs"
6118 if test "$linkmode,$pass" = "lib,link" ||
6119 test "$linkmode,$pass" = "prog,scan"; then
6123 if test "$linkmode" = prog; then
6125 dlopen) libs="$dlfiles" ;;
6126 dlpreopen) libs="$dlprefiles" ;;
6127 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6130 if test "$linkmode,$pass" = "lib,dlpreopen"; then
6131 # Collect and forward deplibs of preopened libtool libs
6132 for lib in $dlprefiles; do
6133 # Ignore non-libtool-libs
6135 func_resolve_sysroot "$lib"
6137 *.la) func_source "$func_resolve_sysroot_result" ;;
6140 # Collect preopened libtool deplibs, except any this library
6141 # has declared as weak libs
6142 for deplib in $dependency_libs; do
6143 func_basename "$deplib"
6144 deplib_base=$func_basename_result
6145 case " $weak_libs " in
6146 *" $deplib_base "*) ;;
6147 *) func_append deplibs " $deplib" ;;
6153 if test "$pass" = dlopen; then
6154 # Collect dlpreopened libraries
6155 save_deplibs="$deplibs"
6159 for deplib in $libs; do
6163 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6164 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6165 if test "$linkmode,$pass" = "prog,link"; then
6166 compile_deplibs="$deplib $compile_deplibs"
6167 finalize_deplibs="$deplib $finalize_deplibs"
6169 func_append compiler_flags " $deplib"
6170 if test "$linkmode" = lib ; then
6171 case "$new_inherited_linker_flags " in
6173 * ) func_append new_inherited_linker_flags " $deplib" ;;
6180 if test "$linkmode" != lib && test "$linkmode" != prog; then
6181 func_warning "\`-l' is ignored for archives/objects"
6184 func_stripname '-l' '' "$deplib"
6185 name=$func_stripname_result
6186 if test "$linkmode" = lib; then
6187 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6189 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6191 for searchdir in $searchdirs; do
6192 for search_ext in .la $std_shrext .so .a; do
6193 # Search the libtool library
6194 lib="$searchdir/lib${name}${search_ext}"
6195 if test -f "$lib"; then
6196 if test "$search_ext" = ".la"; then
6205 if test "$found" != yes; then
6206 # deplib doesn't seem to be a libtool library
6207 if test "$linkmode,$pass" = "prog,link"; then
6208 compile_deplibs="$deplib $compile_deplibs"
6209 finalize_deplibs="$deplib $finalize_deplibs"
6211 deplibs="$deplib $deplibs"
6212 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6215 else # deplib is a libtool library
6216 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6217 # We need to do some special things here, and not later.
6218 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6219 case " $predeps $postdeps " in
6221 if func_lalib_p "$lib"; then
6225 for l in $old_library $library_names; do
6228 if test "X$ll" = "X$old_library" ; then # only static version available
6230 func_dirname "$lib" "" "."
6231 ladir="$func_dirname_result"
6232 lib=$ladir/$old_library
6233 if test "$linkmode,$pass" = "prog,link"; then
6234 compile_deplibs="$deplib $compile_deplibs"
6235 finalize_deplibs="$deplib $finalize_deplibs"
6237 deplibs="$deplib $deplibs"
6238 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6250 if test "$linkmode,$pass" = "prog,link"; then
6251 compile_deplibs="$deplib $compile_deplibs"
6252 finalize_deplibs="$deplib $finalize_deplibs"
6254 deplibs="$deplib $deplibs"
6255 if test "$linkmode" = lib ; then
6256 case "$new_inherited_linker_flags " in
6258 * ) func_append new_inherited_linker_flags " $deplib" ;;
6267 deplibs="$deplib $deplibs"
6268 test "$pass" = conv && continue
6269 newdependency_libs="$deplib $newdependency_libs"
6270 func_stripname '-L' '' "$deplib"
6271 func_resolve_sysroot "$func_stripname_result"
6272 func_append newlib_search_path " $func_resolve_sysroot_result"
6275 if test "$pass" = conv; then
6276 deplibs="$deplib $deplibs"
6279 if test "$pass" = scan; then
6280 deplibs="$deplib $deplibs"
6282 compile_deplibs="$deplib $compile_deplibs"
6283 finalize_deplibs="$deplib $finalize_deplibs"
6285 func_stripname '-L' '' "$deplib"
6286 func_resolve_sysroot "$func_stripname_result"
6287 func_append newlib_search_path " $func_resolve_sysroot_result"
6290 func_warning "\`-L' is ignored for archives/objects"
6296 if test "$pass" = link; then
6297 func_stripname '-R' '' "$deplib"
6298 func_resolve_sysroot "$func_stripname_result"
6299 dir=$func_resolve_sysroot_result
6300 # Make sure the xrpath contains only unique directories.
6303 *) func_append xrpath " $dir" ;;
6306 deplibs="$deplib $deplibs"
6310 func_resolve_sysroot "$deplib"
6311 lib=$func_resolve_sysroot_result
6314 if test "$pass" = conv; then
6315 deplibs="$deplib $deplibs"
6320 # Linking convenience modules into shared libraries is allowed,
6321 # but linking other static libraries is non-portable.
6322 case " $dlpreconveniencelibs " in
6326 case $deplibs_check_method in
6328 set dummy $deplibs_check_method; shift
6329 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6330 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6331 | $EGREP "$match_pattern_regex" > /dev/null; then
6339 if test "$valid_a_lib" != yes; then
6341 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6342 echo "*** I have the capability to make that library automatically link in when"
6343 echo "*** you link to this library. But I can only do this if you have a"
6344 echo "*** shared version of the library, which you do not appear to have"
6345 echo "*** because the file extensions .$libext of this argument makes me believe"
6346 echo "*** that it is just a static archive that I should not use here."
6349 $ECHO "*** Warning: Linking the shared library $output against the"
6350 $ECHO "*** static library $deplib is not portable!"
6351 deplibs="$deplib $deplibs"
6358 if test "$pass" != link; then
6359 deplibs="$deplib $deplibs"
6361 compile_deplibs="$deplib $compile_deplibs"
6362 finalize_deplibs="$deplib $finalize_deplibs"
6369 if test "$pass" = conv; then
6370 deplibs="$deplib $deplibs"
6371 elif test "$linkmode" = prog; then
6372 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6373 # If there is no dlopen support or we're linking statically,
6374 # we need to preload.
6375 func_append newdlprefiles " $deplib"
6376 compile_deplibs="$deplib $compile_deplibs"
6377 finalize_deplibs="$deplib $finalize_deplibs"
6379 func_append newdlfiles " $deplib"
6390 if test "$found" = yes || test -f "$lib"; then :
6392 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6395 # Check to see that this really is a libtool archive.
6396 func_lalib_unsafe_p "$lib" \
6397 || func_fatal_error "\`$lib' is not a valid libtool archive"
6399 func_dirname "$lib" "" "."
6400 ladir="$func_dirname_result"
6408 inherited_linker_flags=
6409 # If the library was installed with an old release of libtool,
6410 # it will not redefine variables installed, or shouldnotlink
6419 # Convert "-framework foo" to "foo.ltframework"
6420 if test -n "$inherited_linker_flags"; then
6421 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6422 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6423 case " $new_inherited_linker_flags " in
6424 *" $tmp_inherited_linker_flag "*) ;;
6425 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6429 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6430 if test "$linkmode,$pass" = "lib,link" ||
6431 test "$linkmode,$pass" = "prog,scan" ||
6432 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6433 test -n "$dlopen" && func_append dlfiles " $dlopen"
6434 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6437 if test "$pass" = conv; then
6438 # Only check for convenience libraries
6439 deplibs="$lib $deplibs"
6440 if test -z "$libdir"; then
6441 if test -z "$old_library"; then
6442 func_fatal_error "cannot find name of link library for \`$lib'"
6444 # It is a libtool convenience library, so add in its objects.
6445 func_append convenience " $ladir/$objdir/$old_library"
6446 func_append old_convenience " $ladir/$objdir/$old_library"
6447 elif test "$linkmode" != prog && test "$linkmode" != lib; then
6448 func_fatal_error "\`$lib' is not a convenience library"
6451 for deplib in $dependency_libs; do
6452 deplibs="$deplib $deplibs"
6453 if $opt_preserve_dup_deps ; then
6454 case "$tmp_libs " in
6455 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6458 func_append tmp_libs " $deplib"
6464 # Get the name of the library we link against.
6466 if test -n "$old_library" &&
6467 { test "$prefer_static_libs" = yes ||
6468 test "$prefer_static_libs,$installed" = "built,no"; }; then
6469 linklib=$old_library
6471 for l in $old_library $library_names; do
6475 if test -z "$linklib"; then
6476 func_fatal_error "cannot find name of link library for \`$lib'"
6479 # This library was specified with -dlopen.
6480 if test "$pass" = dlopen; then
6481 if test -z "$libdir"; then
6482 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6484 if test -z "$dlname" ||
6485 test "$dlopen_support" != yes ||
6486 test "$build_libtool_libs" = no; then
6487 # If there is no dlname, no dlopen support or we're linking
6488 # statically, we need to preload. We also need to preload any
6489 # dependent libraries so libltdl's deplib preloader doesn't
6490 # bomb out in the load deplibs phase.
6491 func_append dlprefiles " $lib $dependency_libs"
6493 func_append newdlfiles " $lib"
6498 # We need an absolute path.
6500 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6502 abs_ladir=`cd "$ladir" && pwd`
6503 if test -z "$abs_ladir"; then
6504 func_warning "cannot determine absolute directory name of \`$ladir'"
6505 func_warning "passing it literally to the linker, although it might fail"
6510 func_basename "$lib"
6511 laname="$func_basename_result"
6513 # Find the relevant object directory and library name.
6514 if test "X$installed" = Xyes; then
6515 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6516 func_warning "library \`$lib' was moved."
6521 dir="$lt_sysroot$libdir"
6522 absdir="$lt_sysroot$libdir"
6524 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6526 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6529 # Remove this search path later
6530 func_append notinst_path " $abs_ladir"
6532 dir="$ladir/$objdir"
6533 absdir="$abs_ladir/$objdir"
6534 # Remove this search path later
6535 func_append notinst_path " $abs_ladir"
6537 fi # $installed = yes
6538 func_stripname 'lib' '.la' "$laname"
6539 name=$func_stripname_result
6541 # This library was specified with -dlpreopen.
6542 if test "$pass" = dlpreopen; then
6543 if test -z "$libdir" && test "$linkmode" = prog; then
6544 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6547 # special handling for platforms with PE-DLLs.
6548 *cygwin* | *mingw* | *cegcc* )
6549 # Linker will automatically link against shared library if both
6550 # static and shared are present. Therefore, ensure we extract
6551 # symbols from the import library if a shared library is present
6552 # (otherwise, the dlopen module name will be incorrect). We do
6553 # this by putting the import library name into $newdlprefiles.
6554 # We recover the dlopen module name by 'saving' the la file
6555 # name in a special purpose variable, and (later) extracting the
6556 # dlname from the la file.
6557 if test -n "$dlname"; then
6558 func_tr_sh "$dir/$linklib"
6559 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6560 func_append newdlprefiles " $dir/$linklib"
6562 func_append newdlprefiles " $dir/$old_library"
6563 # Keep a list of preopened convenience libraries to check
6564 # that they are being used correctly in the link pass.
6565 test -z "$libdir" && \
6566 func_append dlpreconveniencelibs " $dir/$old_library"
6570 # Prefer using a static library (so that no silly _DYNAMIC symbols
6571 # are required to link).
6572 if test -n "$old_library"; then
6573 func_append newdlprefiles " $dir/$old_library"
6574 # Keep a list of preopened convenience libraries to check
6575 # that they are being used correctly in the link pass.
6576 test -z "$libdir" && \
6577 func_append dlpreconveniencelibs " $dir/$old_library"
6578 # Otherwise, use the dlname, so that lt_dlopen finds it.
6579 elif test -n "$dlname"; then
6580 func_append newdlprefiles " $dir/$dlname"
6582 func_append newdlprefiles " $dir/$linklib"
6586 fi # $pass = dlpreopen
6588 if test -z "$libdir"; then
6589 # Link the convenience library
6590 if test "$linkmode" = lib; then
6591 deplibs="$dir/$old_library $deplibs"
6592 elif test "$linkmode,$pass" = "prog,link"; then
6593 compile_deplibs="$dir/$old_library $compile_deplibs"
6594 finalize_deplibs="$dir/$old_library $finalize_deplibs"
6596 deplibs="$lib $deplibs" # used for prog,scan pass
6602 if test "$linkmode" = prog && test "$pass" != link; then
6603 func_append newlib_search_path " $ladir"
6604 deplibs="$lib $deplibs"
6607 if test "$link_all_deplibs" != no || test -z "$library_names" ||
6608 test "$build_libtool_libs" = no; then
6613 for deplib in $dependency_libs; do
6615 -L*) func_stripname '-L' '' "$deplib"
6616 func_resolve_sysroot "$func_stripname_result"
6617 func_append newlib_search_path " $func_resolve_sysroot_result"
6620 # Need to link against all dependency_libs?
6621 if test "$linkalldeplibs" = yes; then
6622 deplibs="$deplib $deplibs"
6624 # Need to hardcode shared library paths
6625 # or/and link against static libraries
6626 newdependency_libs="$deplib $newdependency_libs"
6628 if $opt_preserve_dup_deps ; then
6629 case "$tmp_libs " in
6630 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6633 func_append tmp_libs " $deplib"
6636 fi # $linkmode = prog...
6638 if test "$linkmode,$pass" = "prog,link"; then
6639 if test -n "$library_names" &&
6640 { { test "$prefer_static_libs" = no ||
6641 test "$prefer_static_libs,$installed" = "built,yes"; } ||
6642 test -z "$old_library"; }; then
6643 # We need to hardcode the library path
6644 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6645 # Make sure the rpath contains only unique directories.
6646 case "$temp_rpath:" in
6648 *) func_append temp_rpath "$absdir:" ;;
6652 # Hardcode the library path.
6653 # Skip directories that are in the system default run-time
6655 case " $sys_lib_dlsearch_path " in
6658 case "$compile_rpath " in
6660 *) func_append compile_rpath " $absdir" ;;
6664 case " $sys_lib_dlsearch_path " in
6667 case "$finalize_rpath " in
6669 *) func_append finalize_rpath " $libdir" ;;
6673 fi # $linkmode,$pass = prog,link...
6675 if test "$alldeplibs" = yes &&
6676 { test "$deplibs_check_method" = pass_all ||
6677 { test "$build_libtool_libs" = yes &&
6678 test -n "$library_names"; }; }; then
6679 # We only need to search for static libraries
6684 link_static=no # Whether the deplib will be linked statically
6685 use_static_libs=$prefer_static_libs
6686 if test "$use_static_libs" = built && test "$installed" = yes; then
6689 if test -n "$library_names" &&
6690 { test "$use_static_libs" = no || test -z "$old_library"; }; then
6692 *cygwin* | *mingw* | *cegcc*)
6693 # No point in relinking DLLs because paths are not encoded
6694 func_append notinst_deplibs " $lib"
6698 if test "$installed" = no; then
6699 func_append notinst_deplibs " $lib"
6704 # This is a shared library
6706 # Warn about portability, can't link against -module's on some
6707 # systems (darwin). Don't bleat about dlopened modules though!
6709 for dlpremoduletest in $dlprefiles; do
6710 if test "X$dlpremoduletest" = "X$lib"; then
6711 dlopenmodule="$dlpremoduletest"
6715 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6717 if test "$linkmode" = prog; then
6718 $ECHO "*** Warning: Linking the executable $output against the loadable module"
6720 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6722 $ECHO "*** $linklib is not portable!"
6724 if test "$linkmode" = lib &&
6725 test "$hardcode_into_libs" = yes; then
6726 # Hardcode the library path.
6727 # Skip directories that are in the system default run-time
6729 case " $sys_lib_dlsearch_path " in
6732 case "$compile_rpath " in
6734 *) func_append compile_rpath " $absdir" ;;
6738 case " $sys_lib_dlsearch_path " in
6741 case "$finalize_rpath " in
6743 *) func_append finalize_rpath " $libdir" ;;
6749 if test -n "$old_archive_from_expsyms_cmds"; then
6750 # figure out the soname
6751 set dummy $library_names
6755 libname=`eval "\\$ECHO \"$libname_spec\""`
6756 # use dlname if we got it. it's perfectly good, no?
6757 if test -n "$dlname"; then
6759 elif test -n "$soname_spec"; then
6762 *cygwin* | mingw* | *cegcc*)
6763 func_arith $current - $age
6764 major=$func_arith_result
6768 eval soname=\"$soname_spec\"
6773 # Make a new name for the extract_expsyms_cmds to use
6775 func_basename "$soroot"
6776 soname="$func_basename_result"
6777 func_stripname 'lib' '.dll' "$soname"
6778 newlib=libimp-$func_stripname_result.a
6780 # If the library has no export list, then create one now
6781 if test -f "$output_objdir/$soname-def"; then :
6783 func_verbose "extracting exported symbol list from \`$soname'"
6784 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6788 if test -f "$output_objdir/$newlib"; then :; else
6789 func_verbose "generating import library for \`$soname'"
6790 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6792 # make sure the library variables are pointing to the new library
6795 fi # test -n "$old_archive_from_expsyms_cmds"
6797 if test "$linkmode" = prog || test "$opt_mode" != relink; then
6802 case $hardcode_action in
6803 immediate | unsupported)
6804 if test "$hardcode_direct" = no; then
6807 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6808 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6809 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6810 *-*-unixware7*) add_dir="-L$dir" ;;
6812 # if the lib is a (non-dlopened) module then we can not
6813 # link against it, someone is ignoring the earlier warnings
6814 if /usr/bin/file -L $add 2> /dev/null |
6815 $GREP ": [^:]* bundle" >/dev/null ; then
6816 if test "X$dlopenmodule" != "X$lib"; then
6817 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6818 if test -z "$old_library" ; then
6820 echo "*** And there doesn't seem to be a static archive available"
6821 echo "*** The link will probably fail, sorry"
6823 add="$dir/$old_library"
6825 elif test -n "$old_library"; then
6826 add="$dir/$old_library"
6830 elif test "$hardcode_minus_L" = no; then
6832 *-*-sunos*) add_shlibpath="$dir" ;;
6836 elif test "$hardcode_shlibpath_var" = no; then
6837 add_shlibpath="$dir"
6844 if test "$hardcode_direct" = yes &&
6845 test "$hardcode_direct_absolute" = no; then
6847 elif test "$hardcode_minus_L" = yes; then
6849 # Try looking first in the location we're being installed to.
6850 if test -n "$inst_prefix_dir"; then
6853 func_append add_dir " -L$inst_prefix_dir$libdir"
6858 elif test "$hardcode_shlibpath_var" = yes; then
6859 add_shlibpath="$dir"
6868 if test "$lib_linked" != yes; then
6869 func_fatal_configuration "unsupported hardcode properties"
6872 if test -n "$add_shlibpath"; then
6873 case :$compile_shlibpath: in
6874 *":$add_shlibpath:"*) ;;
6875 *) func_append compile_shlibpath "$add_shlibpath:" ;;
6878 if test "$linkmode" = prog; then
6879 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6880 test -n "$add" && compile_deplibs="$add $compile_deplibs"
6882 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6883 test -n "$add" && deplibs="$add $deplibs"
6884 if test "$hardcode_direct" != yes &&
6885 test "$hardcode_minus_L" != yes &&
6886 test "$hardcode_shlibpath_var" = yes; then
6887 case :$finalize_shlibpath: in
6889 *) func_append finalize_shlibpath "$libdir:" ;;
6895 if test "$linkmode" = prog || test "$opt_mode" = relink; then
6899 # Finalize command for both is simple: just hardcode it.
6900 if test "$hardcode_direct" = yes &&
6901 test "$hardcode_direct_absolute" = no; then
6902 add="$libdir/$linklib"
6903 elif test "$hardcode_minus_L" = yes; then
6906 elif test "$hardcode_shlibpath_var" = yes; then
6907 case :$finalize_shlibpath: in
6909 *) func_append finalize_shlibpath "$libdir:" ;;
6912 elif test "$hardcode_automatic" = yes; then
6913 if test -n "$inst_prefix_dir" &&
6914 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6915 add="$inst_prefix_dir$libdir/$linklib"
6917 add="$libdir/$linklib"
6920 # We cannot seem to hardcode it, guess we'll fake it.
6922 # Try looking first in the location we're being installed to.
6923 if test -n "$inst_prefix_dir"; then
6926 func_append add_dir " -L$inst_prefix_dir$libdir"
6933 if test "$linkmode" = prog; then
6934 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6935 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6937 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6938 test -n "$add" && deplibs="$add $deplibs"
6941 elif test "$linkmode" = prog; then
6942 # Here we assume that one of hardcode_direct or hardcode_minus_L
6943 # is not unsupported. This is valid on all known static and
6945 if test "$hardcode_direct" != unsupported; then
6946 test -n "$old_library" && linklib="$old_library"
6947 compile_deplibs="$dir/$linklib $compile_deplibs"
6948 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6950 compile_deplibs="-l$name -L$dir $compile_deplibs"
6951 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6953 elif test "$build_libtool_libs" = yes; then
6954 # Not a shared library
6955 if test "$deplibs_check_method" != pass_all; then
6956 # We're trying link a shared library against a static one
6957 # but the system doesn't support it.
6959 # Just print a warning and add the library to dependency_libs so
6960 # that the program can be linked against the static library.
6962 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6963 echo "*** I have the capability to make that library automatically link in when"
6964 echo "*** you link to this library. But I can only do this if you have a"
6965 echo "*** shared version of the library, which you do not appear to have."
6966 if test "$module" = yes; then
6967 echo "*** But as you try to build a module library, libtool will still create "
6968 echo "*** a static module, that should work as long as the dlopening application"
6969 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6970 if test -z "$global_symbol_pipe"; then
6972 echo "*** However, this would only work if libtool was able to extract symbol"
6973 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6974 echo "*** not find such a program. So, this module is probably useless."
6975 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6977 if test "$build_old_libs" = no; then
6978 build_libtool_libs=module
6981 build_libtool_libs=no
6985 deplibs="$dir/$old_library $deplibs"
6988 fi # link shared/static library?
6990 if test "$linkmode" = lib; then
6991 if test -n "$dependency_libs" &&
6992 { test "$hardcode_into_libs" != yes ||
6993 test "$build_old_libs" = yes ||
6994 test "$link_static" = yes; }; then
6995 # Extract -R from dependency_libs
6997 for libdir in $dependency_libs; do
6999 -R*) func_stripname '-R' '' "$libdir"
7000 temp_xrpath=$func_stripname_result
7002 *" $temp_xrpath "*) ;;
7003 *) func_append xrpath " $temp_xrpath";;
7005 *) func_append temp_deplibs " $libdir";;
7008 dependency_libs="$temp_deplibs"
7011 func_append newlib_search_path " $absdir"
7012 # Link against this library
7013 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
7014 # ... and its dependency_libs
7016 for deplib in $dependency_libs; do
7017 newdependency_libs="$deplib $newdependency_libs"
7019 -L*) func_stripname '-L' '' "$deplib"
7020 func_resolve_sysroot "$func_stripname_result";;
7021 *) func_resolve_sysroot "$deplib" ;;
7023 if $opt_preserve_dup_deps ; then
7024 case "$tmp_libs " in
7025 *" $func_resolve_sysroot_result "*)
7026 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
7029 func_append tmp_libs " $func_resolve_sysroot_result"
7032 if test "$link_all_deplibs" != no; then
7033 # Add the search paths of all dependency libraries
7034 for deplib in $dependency_libs; do
7037 -L*) path="$deplib" ;;
7039 func_resolve_sysroot "$deplib"
7040 deplib=$func_resolve_sysroot_result
7041 func_dirname "$deplib" "" "."
7042 dir=$func_dirname_result
7043 # We need an absolute path.
7045 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7047 absdir=`cd "$dir" && pwd`
7048 if test -z "$absdir"; then
7049 func_warning "cannot determine absolute directory name of \`$dir'"
7054 if $GREP "^installed=no" $deplib > /dev/null; then
7058 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7059 if test -n "$deplibrary_names" ; then
7060 for tmp in $deplibrary_names ; do
7063 if test -f "$absdir/$objdir/$depdepl" ; then
7064 depdepl="$absdir/$objdir/$depdepl"
7065 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7066 if test -z "$darwin_install_name"; then
7067 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7069 func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7070 func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7076 path="-L$absdir/$objdir"
7080 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7081 test -z "$libdir" && \
7082 func_fatal_error "\`$deplib' is not a valid libtool archive"
7083 test "$absdir" != "$libdir" && \
7084 func_warning "\`$deplib' seems to be moved"
7090 case " $deplibs " in
7092 *) deplibs="$path $deplibs" ;;
7095 fi # link_all_deplibs != no
7097 done # for deplib in $libs
7098 if test "$pass" = link; then
7099 if test "$linkmode" = "prog"; then
7100 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7101 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7103 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7106 dependency_libs="$newdependency_libs"
7107 if test "$pass" = dlpreopen; then
7108 # Link the dlpreopened libraries before other libraries
7109 for deplib in $save_deplibs; do
7110 deplibs="$deplib $deplibs"
7113 if test "$pass" != dlopen; then
7114 if test "$pass" != conv; then
7115 # Make sure lib_search_path contains only unique directories.
7117 for dir in $newlib_search_path; do
7118 case "$lib_search_path " in
7120 *) func_append lib_search_path " $dir" ;;
7126 if test "$linkmode,$pass" != "prog,link"; then
7129 vars="compile_deplibs finalize_deplibs"
7131 for var in $vars dependency_libs; do
7132 # Add libraries to $var in reverse order
7133 eval tmp_libs=\"\$$var\"
7135 for deplib in $tmp_libs; do
7136 # FIXME: Pedantically, this is the right thing to do, so
7137 # that some nasty dependency loop isn't accidentally
7139 #new_libs="$deplib $new_libs"
7140 # Pragmatically, this seems to cause very few problems in
7143 -L*) new_libs="$deplib $new_libs" ;;
7146 # And here is the reason: when a library appears more
7147 # than once as an explicit dependence of a library, or
7148 # is implicitly linked in more than once by the
7149 # compiler, it is considered special, and multiple
7150 # occurrences thereof are not removed. Compare this
7151 # with having the same library being listed as a
7152 # dependency of multiple other libraries: in this case,
7153 # we know (pedantically, we assume) the library does not
7154 # need to be listed more than once, so we keep only the
7155 # last copy. This is not always right, but it is rare
7156 # enough that we require users that really mean to play
7157 # such unportable linking tricks to link the library
7158 # using -Wl,-lname, so that libtool does not consider it
7159 # for duplicate removal.
7160 case " $specialdeplibs " in
7161 *" $deplib "*) new_libs="$deplib $new_libs" ;;
7163 case " $new_libs " in
7165 *) new_libs="$deplib $new_libs" ;;
7173 for deplib in $new_libs; do
7176 case " $tmp_libs " in
7178 *) func_append tmp_libs " $deplib" ;;
7181 *) func_append tmp_libs " $deplib" ;;
7184 eval $var=\"$tmp_libs\"
7187 # Last step: remove runtime libs from dependency_libs
7188 # (they stay in deplibs)
7190 for i in $dependency_libs ; do
7191 case " $predeps $postdeps $compiler_lib_search_path " in
7196 if test -n "$i" ; then
7197 func_append tmp_libs " $i"
7200 dependency_libs=$tmp_libs
7202 if test "$linkmode" = prog; then
7203 dlfiles="$newdlfiles"
7205 if test "$linkmode" = prog || test "$linkmode" = lib; then
7206 dlprefiles="$newdlprefiles"
7211 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7212 func_warning "\`-dlopen' is ignored for archives"
7217 func_warning "\`-l' and \`-L' are ignored for archives" ;;
7220 test -n "$rpath" && \
7221 func_warning "\`-rpath' is ignored for archives"
7223 test -n "$xrpath" && \
7224 func_warning "\`-R' is ignored for archives"
7226 test -n "$vinfo" && \
7227 func_warning "\`-version-info/-version-number' is ignored for archives"
7229 test -n "$release" && \
7230 func_warning "\`-release' is ignored for archives"
7232 test -n "$export_symbols$export_symbols_regex" && \
7233 func_warning "\`-export-symbols' is ignored for archives"
7235 # Now set the variables for building old libraries.
7236 build_libtool_libs=no
7238 func_append objs "$old_deplibs"
7242 # Make sure we only generate libraries of the form `libNAME.la'.
7245 func_stripname 'lib' '.la' "$outputname"
7246 name=$func_stripname_result
7247 eval shared_ext=\"$shrext_cmds\"
7248 eval libname=\"$libname_spec\"
7251 test "$module" = no && \
7252 func_fatal_help "libtool library \`$output' must begin with \`lib'"
7254 if test "$need_lib_prefix" != no; then
7255 # Add the "lib" prefix for modules if required
7256 func_stripname '' '.la' "$outputname"
7257 name=$func_stripname_result
7258 eval shared_ext=\"$shrext_cmds\"
7259 eval libname=\"$libname_spec\"
7261 func_stripname '' '.la' "$outputname"
7262 libname=$func_stripname_result
7267 if test -n "$objs"; then
7268 if test "$deplibs_check_method" != pass_all; then
7269 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7272 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7273 $ECHO "*** objects $objs is not portable!"
7274 func_append libobjs " $objs"
7278 test "$dlself" != no && \
7279 func_warning "\`-dlopen self' is ignored for libtool libraries"
7283 test "$#" -gt 1 && \
7284 func_warning "ignoring multiple \`-rpath's for a libtool library"
7289 if test -z "$rpath"; then
7290 if test "$build_libtool_libs" = yes; then
7291 # Building a libtool convenience library.
7292 # Some compilers have problems with a `.al' extension so
7293 # convenience libraries should have the same extension an
7294 # archive normally would.
7295 oldlibs="$output_objdir/$libname.$libext $oldlibs"
7296 build_libtool_libs=convenience
7300 test -n "$vinfo" && \
7301 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7303 test -n "$release" && \
7304 func_warning "\`-release' is ignored for convenience libraries"
7307 # Parse the version information argument.
7308 save_ifs="$IFS"; IFS=':'
7309 set dummy $vinfo 0 0 0
7314 func_fatal_help "too many parameters to \`-version-info'"
7316 # convert absolute version numbers to libtool ages
7317 # this retains compatibility with .la files and attempts
7318 # to make the code below a bit more comprehensible
7320 case $vinfo_number in
7324 number_revision="$3"
7326 # There are really only two kinds -- those that
7327 # use the current revision as the major version
7328 # and those that subtract age and use age as
7329 # a minor version. But, then there is irix
7330 # which has an extra 1 added just for fun
7332 case $version_type in
7333 # correct linux to gnu/linux during the next big refactor
7334 darwin|linux|osf|windows|none)
7335 func_arith $number_major + $number_minor
7336 current=$func_arith_result
7338 revision="$number_revision"
7340 freebsd-aout|freebsd-elf|qnx|sunos)
7341 current="$number_major"
7342 revision="$number_minor"
7346 func_arith $number_major + $number_minor
7347 current=$func_arith_result
7349 revision="$number_minor"
7350 lt_irix_increment=no
7361 # Check that each of the things are valid numbers.
7363 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]) ;;
7365 func_error "CURRENT \`$current' must be a nonnegative integer"
7366 func_fatal_error "\`$vinfo' is not valid version information"
7371 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]) ;;
7373 func_error "REVISION \`$revision' must be a nonnegative integer"
7374 func_fatal_error "\`$vinfo' is not valid version information"
7379 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]) ;;
7381 func_error "AGE \`$age' must be a nonnegative integer"
7382 func_fatal_error "\`$vinfo' is not valid version information"
7386 if test "$age" -gt "$current"; then
7387 func_error "AGE \`$age' is greater than the current interface number \`$current'"
7388 func_fatal_error "\`$vinfo' is not valid version information"
7391 # Calculate the version variables.
7395 case $version_type in
7399 # Like Linux, but with the current version available in
7400 # verstring for coding it into the library header
7401 func_arith $current - $age
7402 major=.$func_arith_result
7403 versuffix="$major.$age.$revision"
7404 # Darwin ld doesn't like 0 for these options...
7405 func_arith $current + 1
7406 minor_current=$func_arith_result
7407 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7408 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7413 versuffix=".$current.$revision";
7418 versuffix=".$current"
7422 if test "X$lt_irix_increment" = "Xno"; then
7423 func_arith $current - $age
7425 func_arith $current - $age + 1
7427 major=$func_arith_result
7429 case $version_type in
7430 nonstopux) verstring_prefix=nonstopux ;;
7431 *) verstring_prefix=sgi ;;
7433 verstring="$verstring_prefix$major.$revision"
7435 # Add in all the interfaces that we are compatible with.
7437 while test "$loop" -ne 0; do
7438 func_arith $revision - $loop
7439 iface=$func_arith_result
7440 func_arith $loop - 1
7441 loop=$func_arith_result
7442 verstring="$verstring_prefix$major.$iface:$verstring"
7445 # Before this point, $major must not contain `.'.
7447 versuffix="$major.$revision"
7450 linux) # correct to gnu/linux during the next big refactor
7451 func_arith $current - $age
7452 major=.$func_arith_result
7453 versuffix="$major.$age.$revision"
7457 func_arith $current - $age
7458 major=.$func_arith_result
7459 versuffix=".$current.$age.$revision"
7460 verstring="$current.$age.$revision"
7462 # Add in all the interfaces that we are compatible with.
7464 while test "$loop" -ne 0; do
7465 func_arith $current - $loop
7466 iface=$func_arith_result
7467 func_arith $loop - 1
7468 loop=$func_arith_result
7469 verstring="$verstring:${iface}.0"
7472 # Make executables depend on our current version.
7473 func_append verstring ":${current}.0"
7478 versuffix=".$current"
7483 versuffix=".$current.$revision"
7487 # Use '-' rather than '.', since we only want one
7488 # extension on DOS 8.3 filesystems.
7489 func_arith $current - $age
7490 major=$func_arith_result
7495 func_fatal_configuration "unknown library version type \`$version_type'"
7499 # Clear the version info if we defaulted, and they specified a release.
7500 if test -z "$vinfo" && test -n "$release"; then
7502 case $version_type in
7504 # we can't check for "0.0" in archive_cmds due to quoting
7505 # problems, so we reset it completely
7512 if test "$need_version" = no; then
7519 # Remove version info from name if versioning should be avoided
7520 if test "$avoid_version" = yes && test "$need_version" = no; then
7526 # Check to see if the archive will have undefined symbols.
7527 if test "$allow_undefined" = yes; then
7528 if test "$allow_undefined_flag" = unsupported; then
7529 func_warning "undefined symbols not allowed in $host shared libraries"
7530 build_libtool_libs=no
7534 # Don't allow undefined symbols.
7535 allow_undefined_flag="$no_undefined_flag"
7540 func_generate_dlsyms "$libname" "$libname" "yes"
7541 func_append libobjs " $symfileobj"
7542 test "X$libobjs" = "X " && libobjs=
7544 if test "$opt_mode" != relink; then
7545 # Remove our outputs, but don't remove object files since they
7546 # may have been created when compiling PIC objects.
7548 tempremovelist=`$ECHO "$output_objdir/*"`
7549 for p in $tempremovelist; do
7553 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7554 if test "X$precious_files_regex" != "X"; then
7555 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7560 func_append removelist " $p"
7565 test -n "$removelist" && \
7566 func_show_eval "${RM}r \$removelist"
7569 # Now set the variables for building old libraries.
7570 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7571 func_append oldlibs " $output_objdir/$libname.$libext"
7573 # Transform .lo files to .o files.
7574 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7577 # Eliminate all temporary directories.
7578 #for path in $notinst_path; do
7579 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7580 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7581 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7584 if test -n "$xrpath"; then
7585 # If the user specified any rpath flags, then add them.
7587 for libdir in $xrpath; do
7588 func_replace_sysroot "$libdir"
7589 func_append temp_xrpath " -R$func_replace_sysroot_result"
7590 case "$finalize_rpath " in
7592 *) func_append finalize_rpath " $libdir" ;;
7595 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7596 dependency_libs="$temp_xrpath $dependency_libs"
7600 # Make sure dlfiles contains only unique files that won't be dlpreopened
7601 old_dlfiles="$dlfiles"
7603 for lib in $old_dlfiles; do
7604 case " $dlprefiles $dlfiles " in
7606 *) func_append dlfiles " $lib" ;;
7610 # Make sure dlprefiles contains only unique files
7611 old_dlprefiles="$dlprefiles"
7613 for lib in $old_dlprefiles; do
7614 case "$dlprefiles " in
7616 *) func_append dlprefiles " $lib" ;;
7620 if test "$build_libtool_libs" = yes; then
7621 if test -n "$rpath"; then
7623 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7624 # these systems don't actually have a c library (as such)!
7626 *-*-rhapsody* | *-*-darwin1.[012])
7627 # Rhapsody C library is in the System framework
7628 func_append deplibs " System.ltframework"
7631 # Don't link with libc until the a.out ld.so is fixed.
7633 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
7634 # Do not include libc due to us having libc/libc_r.
7636 *-*-sco3.2v5* | *-*-sco5v6*)
7637 # Causes problems with __ctype
7639 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7640 # Compiler inserts libc in the correct place for threads to work
7643 # Add libc to deplibs on all other systems if necessary.
7644 if test "$build_libtool_need_lc" = "yes"; then
7645 func_append deplibs " -lc"
7651 # Transform deplibs into only deplibs that can be linked in shared.
7653 libname_save=$libname
7654 release_save=$release
7655 versuffix_save=$versuffix
7657 # I'm not sure if I'm treating the release correctly. I think
7658 # release should show up in the -l (ie -lgmp5) so we don't want to
7659 # add it in twice. Is that correct?
7665 case $deplibs_check_method in
7667 # Don't check for shared/static. Everything works.
7668 # This might be a little naive. We might want to check
7669 # whether the library exists or not. But this is on
7670 # osf3 & osf4 and I'm not really sure... Just
7671 # implementing what was already the behavior.
7675 # This code stresses the "libraries are programs" paradigm to its
7676 # limits. Maybe even breaks it. We compile a program, linking it
7677 # against the deplibs as a proxy for the library. Then we can check
7678 # whether they linked in statically or dynamically with ldd.
7679 $opt_dry_run || $RM conftest.c
7680 cat > conftest.c <<EOF
7681 int main() { return 0; }
7683 $opt_dry_run || $RM conftest
7684 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7685 ldd_output=`ldd conftest`
7686 for i in $deplibs; do
7689 func_stripname -l '' "$i"
7690 name=$func_stripname_result
7691 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7692 case " $predeps $postdeps " in
7694 func_append newdeplibs " $i"
7699 if test -n "$i" ; then
7700 libname=`eval "\\$ECHO \"$libname_spec\""`
7701 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7702 set dummy $deplib_matches; shift
7704 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7705 func_append newdeplibs " $i"
7709 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7710 echo "*** I have the capability to make that library automatically link in when"
7711 echo "*** you link to this library. But I can only do this if you have a"
7712 echo "*** shared version of the library, which I believe you do not have"
7713 echo "*** because a test_compile did reveal that the linker did not use it for"
7714 echo "*** its dynamic dependency list that programs get resolved with at runtime."
7719 func_append newdeplibs " $i"
7724 # Error occurred in the first compile. Let's try to salvage
7725 # the situation: Compile a separate program for each library.
7726 for i in $deplibs; do
7729 func_stripname -l '' "$i"
7730 name=$func_stripname_result
7731 $opt_dry_run || $RM conftest
7732 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7733 ldd_output=`ldd conftest`
7734 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7735 case " $predeps $postdeps " in
7737 func_append newdeplibs " $i"
7742 if test -n "$i" ; then
7743 libname=`eval "\\$ECHO \"$libname_spec\""`
7744 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7745 set dummy $deplib_matches; shift
7747 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7748 func_append newdeplibs " $i"
7752 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7753 echo "*** I have the capability to make that library automatically link in when"
7754 echo "*** you link to this library. But I can only do this if you have a"
7755 echo "*** shared version of the library, which you do not appear to have"
7756 echo "*** because a test_compile did reveal that the linker did not use this one"
7757 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7763 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7764 echo "*** make it link in! You will probably need to install it or some"
7765 echo "*** library that it depends on before this library will be fully"
7766 echo "*** functional. Installing it before continuing would be even better."
7770 func_append newdeplibs " $i"
7777 set dummy $deplibs_check_method; shift
7778 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7779 for a_deplib in $deplibs; do
7782 func_stripname -l '' "$a_deplib"
7783 name=$func_stripname_result
7784 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7785 case " $predeps $postdeps " in
7787 func_append newdeplibs " $a_deplib"
7792 if test -n "$a_deplib" ; then
7793 libname=`eval "\\$ECHO \"$libname_spec\""`
7794 if test -n "$file_magic_glob"; then
7795 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7797 libnameglob=$libname
7799 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7800 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7801 if test "$want_nocaseglob" = yes; then
7803 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7806 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7808 for potent_lib in $potential_libs; do
7809 # Follow soft links.
7810 if ls -lLd "$potent_lib" 2>/dev/null |
7811 $GREP " -> " >/dev/null; then
7814 # The statement above tries to avoid entering an
7815 # endless loop below, in case of cyclic links.
7816 # We might still enter an endless loop, since a link
7817 # loop can be closed while we follow links,
7819 potlib="$potent_lib"
7820 while test -h "$potlib" 2>/dev/null; do
7821 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7823 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7824 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7827 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7829 $EGREP "$file_magic_regex" > /dev/null; then
7830 func_append newdeplibs " $a_deplib"
7837 if test -n "$a_deplib" ; then
7840 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7841 echo "*** I have the capability to make that library automatically link in when"
7842 echo "*** you link to this library. But I can only do this if you have a"
7843 echo "*** shared version of the library, which you do not appear to have"
7844 echo "*** because I did check the linker path looking for a file starting"
7845 if test -z "$potlib" ; then
7846 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7848 $ECHO "*** with $libname and none of the candidates passed a file format test"
7849 $ECHO "*** using a file magic. Last file checked: $potlib"
7854 # Add a -L argument.
7855 func_append newdeplibs " $a_deplib"
7858 done # Gone through all deplibs.
7861 set dummy $deplibs_check_method; shift
7862 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7863 for a_deplib in $deplibs; do
7866 func_stripname -l '' "$a_deplib"
7867 name=$func_stripname_result
7868 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7869 case " $predeps $postdeps " in
7871 func_append newdeplibs " $a_deplib"
7876 if test -n "$a_deplib" ; then
7877 libname=`eval "\\$ECHO \"$libname_spec\""`
7878 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7879 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7880 for potent_lib in $potential_libs; do
7881 potlib="$potent_lib" # see symlink-check above in file_magic test
7882 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7883 $EGREP "$match_pattern_regex" > /dev/null; then
7884 func_append newdeplibs " $a_deplib"
7891 if test -n "$a_deplib" ; then
7894 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7895 echo "*** I have the capability to make that library automatically link in when"
7896 echo "*** you link to this library. But I can only do this if you have a"
7897 echo "*** shared version of the library, which you do not appear to have"
7898 echo "*** because I did check the linker path looking for a file starting"
7899 if test -z "$potlib" ; then
7900 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7902 $ECHO "*** with $libname and none of the candidates passed a file format test"
7903 $ECHO "*** using a regex pattern. Last file checked: $potlib"
7908 # Add a -L argument.
7909 func_append newdeplibs " $a_deplib"
7912 done # Gone through all deplibs.
7916 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7917 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7918 for i in $predeps $postdeps ; do
7919 # can't use Xsed below, because $i might contain '/'
7920 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7923 case $tmp_deplibs in
7926 if test "X$deplibs_check_method" = "Xnone"; then
7927 echo "*** Warning: inter-library dependencies are not supported in this platform."
7929 echo "*** Warning: inter-library dependencies are not known to be supported."
7931 echo "*** All declared inter-library dependencies are being dropped."
7937 versuffix=$versuffix_save
7939 release=$release_save
7940 libname=$libname_save
7944 *-*-rhapsody* | *-*-darwin1.[012])
7945 # On Rhapsody replace the C library with the System framework
7946 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7950 if test "$droppeddeps" = yes; then
7951 if test "$module" = yes; then
7953 echo "*** Warning: libtool could not satisfy all declared inter-library"
7954 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7955 echo "*** a static module, that should work as long as the dlopening"
7956 echo "*** application is linked with the -dlopen flag."
7957 if test -z "$global_symbol_pipe"; then
7959 echo "*** However, this would only work if libtool was able to extract symbol"
7960 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7961 echo "*** not find such a program. So, this module is probably useless."
7962 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7964 if test "$build_old_libs" = no; then
7965 oldlibs="$output_objdir/$libname.$libext"
7966 build_libtool_libs=module
7969 build_libtool_libs=no
7972 echo "*** The inter-library dependencies that have been dropped here will be"
7973 echo "*** automatically added whenever a program is linked with this library"
7974 echo "*** or is declared to -dlopen it."
7976 if test "$allow_undefined" = no; then
7978 echo "*** Since this library must not contain undefined symbols,"
7979 echo "*** because either the platform does not support them or"
7980 echo "*** it was explicitly requested with -no-undefined,"
7981 echo "*** libtool will only create a static version of it."
7982 if test "$build_old_libs" = no; then
7983 oldlibs="$output_objdir/$libname.$libext"
7984 build_libtool_libs=module
7987 build_libtool_libs=no
7992 # Done checking deplibs!
7995 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7998 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7999 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8000 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8004 # move library search paths that coincide with paths to not yet
8005 # installed libraries to the beginning of the library search list
8007 for path in $notinst_path; do
8008 case " $new_libs " in
8009 *" -L$path/$objdir "*) ;;
8011 case " $deplibs " in
8012 *" -L$path/$objdir "*)
8013 func_append new_libs " -L$path/$objdir" ;;
8018 for deplib in $deplibs; do
8021 case " $new_libs " in
8023 *) func_append new_libs " $deplib" ;;
8026 *) func_append new_libs " $deplib" ;;
8031 # All the library-specific variables (install_libdir is set above).
8036 # Test again, we may have decided not to build it any more
8037 if test "$build_libtool_libs" = yes; then
8038 # Remove ${wl} instances when linking with ld.
8039 # FIXME: should test the right _cmds variable.
8040 case $archive_cmds in
8043 if test "$hardcode_into_libs" = yes; then
8044 # Hardcode the library paths
8047 rpath="$finalize_rpath"
8048 test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8049 for libdir in $rpath; do
8050 if test -n "$hardcode_libdir_flag_spec"; then
8051 if test -n "$hardcode_libdir_separator"; then
8052 func_replace_sysroot "$libdir"
8053 libdir=$func_replace_sysroot_result
8054 if test -z "$hardcode_libdirs"; then
8055 hardcode_libdirs="$libdir"
8057 # Just accumulate the unique libdirs.
8058 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8059 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8062 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8067 eval flag=\"$hardcode_libdir_flag_spec\"
8068 func_append dep_rpath " $flag"
8070 elif test -n "$runpath_var"; then
8071 case "$perm_rpath " in
8073 *) func_append perm_rpath " $libdir" ;;
8077 # Substitute the hardcoded libdirs into the rpath.
8078 if test -n "$hardcode_libdir_separator" &&
8079 test -n "$hardcode_libdirs"; then
8080 libdir="$hardcode_libdirs"
8081 eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8083 if test -n "$runpath_var" && test -n "$perm_rpath"; then
8084 # We should set the runpath_var.
8086 for dir in $perm_rpath; do
8087 func_append rpath "$dir:"
8089 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8091 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8094 shlibpath="$finalize_shlibpath"
8095 test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8096 if test -n "$shlibpath"; then
8097 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8100 # Get the real and link names of the library.
8101 eval shared_ext=\"$shrext_cmds\"
8102 eval library_names=\"$library_names_spec\"
8103 set dummy $library_names
8108 if test -n "$soname_spec"; then
8109 eval soname=\"$soname_spec\"
8113 if test -z "$dlname"; then
8117 lib="$output_objdir/$realname"
8121 func_append linknames " $link"
8124 # Use standard objects if they are pic
8125 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8126 test "X$libobjs" = "X " && libobjs=
8129 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8130 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8131 export_symbols="$output_objdir/$libname.uexp"
8132 func_append delfiles " $export_symbols"
8135 orig_export_symbols=
8137 cygwin* | mingw* | cegcc*)
8138 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8139 # exporting using user supplied symfile
8140 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8141 # and it's NOT already a .def file. Must figure out
8142 # which of the given symbols are data symbols and tag
8143 # them as such. So, trigger use of export_symbols_cmds.
8144 # export_symbols gets reassigned inside the "prepare
8145 # the list of exported symbols" if statement, so the
8146 # include_expsyms logic still works.
8147 orig_export_symbols="$export_symbols"
8149 always_export_symbols=yes
8155 # Prepare the list of exported symbols
8156 if test -z "$export_symbols"; then
8157 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8158 func_verbose "generating symbol list for \`$libname.la'"
8159 export_symbols="$output_objdir/$libname.exp"
8160 $opt_dry_run || $RM $export_symbols
8161 cmds=$export_symbols_cmds
8162 save_ifs="$IFS"; IFS='~'
8163 for cmd1 in $cmds; do
8165 # Take the normal branch if the nm_file_list_spec branch
8166 # doesn't work or if tool conversion is not needed.
8167 case $nm_file_list_spec~$to_tool_file_cmd in
8168 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8169 try_normal_branch=yes
8172 len=$func_len_result
8175 try_normal_branch=no
8178 if test "$try_normal_branch" = yes \
8179 && { test "$len" -lt "$max_cmd_len" \
8180 || test "$max_cmd_len" -le -1; }
8182 func_show_eval "$cmd" 'exit $?'
8183 skipped_export=false
8184 elif test -n "$nm_file_list_spec"; then
8185 func_basename "$output"
8186 output_la=$func_basename_result
8187 save_libobjs=$libobjs
8189 output=${output_objdir}/${output_la}.nm
8190 func_to_tool_file "$output"
8191 libobjs=$nm_file_list_spec$func_to_tool_file_result
8192 func_append delfiles " $output"
8193 func_verbose "creating $NM input file list: $output"
8194 for obj in $save_libobjs; do
8195 func_to_tool_file "$obj"
8196 $ECHO "$func_to_tool_file_result"
8199 func_show_eval "$cmd" 'exit $?'
8201 libobjs=$save_libobjs
8202 skipped_export=false
8204 # The command line is too long to execute in one step.
8205 func_verbose "using reloadable object file for export list..."
8207 # Break out early, otherwise skipped_export may be
8208 # set to false by a later but shorter cmd.
8213 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8214 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8215 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8220 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8221 tmp_export_symbols="$export_symbols"
8222 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8223 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8226 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8227 # The given exports_symbols file has to be filtered, so filter it.
8228 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8229 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8230 # 's' commands which not all seds can handle. GNU sed should be fine
8231 # though. Also, the filter scales superlinearly with the number of
8232 # global variables. join(1) would be nice here, but unfortunately
8233 # isn't a blessed tool.
8234 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8235 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8236 export_symbols=$output_objdir/$libname.def
8237 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8241 for test_deplib in $deplibs; do
8242 case " $convenience " in
8243 *" $test_deplib "*) ;;
8245 func_append tmp_deplibs " $test_deplib"
8249 deplibs="$tmp_deplibs"
8251 if test -n "$convenience"; then
8252 if test -n "$whole_archive_flag_spec" &&
8253 test "$compiler_needs_object" = yes &&
8254 test -z "$libobjs"; then
8255 # extract the archives, so we have objects to list.
8256 # TODO: could optimize this to just extract one archive.
8257 whole_archive_flag_spec=
8259 if test -n "$whole_archive_flag_spec"; then
8260 save_libobjs=$libobjs
8261 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8262 test "X$libobjs" = "X " && libobjs=
8264 gentop="$output_objdir/${outputname}x"
8265 func_append generated " $gentop"
8267 func_extract_archives $gentop $convenience
8268 func_append libobjs " $func_extract_archives_result"
8269 test "X$libobjs" = "X " && libobjs=
8273 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8274 eval flag=\"$thread_safe_flag_spec\"
8275 func_append linker_flags " $flag"
8278 # Make a backup of the uninstalled library when relinking
8279 if test "$opt_mode" = relink; then
8280 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8283 # Do each of the archive commands.
8284 if test "$module" = yes && test -n "$module_cmds" ; then
8285 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8286 eval test_cmds=\"$module_expsym_cmds\"
8287 cmds=$module_expsym_cmds
8289 eval test_cmds=\"$module_cmds\"
8293 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8294 eval test_cmds=\"$archive_expsym_cmds\"
8295 cmds=$archive_expsym_cmds
8297 eval test_cmds=\"$archive_cmds\"
8302 if test "X$skipped_export" != "X:" &&
8303 func_len " $test_cmds" &&
8304 len=$func_len_result &&
8305 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8308 # The command line is too long to link in one step, link piecewise
8309 # or, if using GNU ld and skipped_export is not :, use a linker
8312 # Save the value of $output and $libobjs because we want to
8313 # use them later. If we have whole_archive_flag_spec, we
8314 # want to use save_libobjs as it was before
8315 # whole_archive_flag_spec was expanded, because we can't
8316 # assume the linker understands whole_archive_flag_spec.
8317 # This may have to be revisited, in case too many
8318 # convenience libraries get linked in and end up exceeding
8320 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8321 save_libobjs=$libobjs
8324 func_basename "$output"
8325 output_la=$func_basename_result
8327 # Clear the reloadable object creation command queue and
8328 # initialize k to one.
8335 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8336 output=${output_objdir}/${output_la}.lnkscript
8337 func_verbose "creating GNU ld script: $output"
8338 echo 'INPUT (' > $output
8339 for obj in $save_libobjs
8341 func_to_tool_file "$obj"
8342 $ECHO "$func_to_tool_file_result" >> $output
8345 func_append delfiles " $output"
8346 func_to_tool_file "$output"
8347 output=$func_to_tool_file_result
8348 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8349 output=${output_objdir}/${output_la}.lnk
8350 func_verbose "creating linker input file list: $output"
8355 if test "$compiler_needs_object" = yes; then
8361 func_to_tool_file "$obj"
8362 $ECHO "$func_to_tool_file_result" >> $output
8364 func_append delfiles " $output"
8365 func_to_tool_file "$output"
8366 output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8368 if test -n "$save_libobjs"; then
8369 func_verbose "creating reloadable object files..."
8370 output=$output_objdir/$output_la-${k}.$objext
8371 eval test_cmds=\"$reload_cmds\"
8372 func_len " $test_cmds"
8373 len0=$func_len_result
8376 # Loop over the list of objects to be linked.
8377 for obj in $save_libobjs
8380 func_arith $len + $func_len_result
8381 len=$func_arith_result
8382 if test "X$objlist" = X ||
8383 test "$len" -lt "$max_cmd_len"; then
8384 func_append objlist " $obj"
8386 # The command $test_cmds is almost too long, add a
8387 # command to the queue.
8388 if test "$k" -eq 1 ; then
8389 # The first file doesn't have a previous command to add.
8390 reload_objs=$objlist
8391 eval concat_cmds=\"$reload_cmds\"
8393 # All subsequent reloadable object files will link in
8394 # the last one created.
8395 reload_objs="$objlist $last_robj"
8396 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8398 last_robj=$output_objdir/$output_la-${k}.$objext
8400 k=$func_arith_result
8401 output=$output_objdir/$output_la-${k}.$objext
8403 func_len " $last_robj"
8404 func_arith $len0 + $func_len_result
8405 len=$func_arith_result
8408 # Handle the remaining objects by creating one last
8409 # reloadable object file. All subsequent reloadable object
8410 # files will link in the last one created.
8411 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8412 reload_objs="$objlist $last_robj"
8413 eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8414 if test -n "$last_robj"; then
8415 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8417 func_append delfiles " $output"
8423 if ${skipped_export-false}; then
8424 func_verbose "generating symbol list for \`$libname.la'"
8425 export_symbols="$output_objdir/$libname.exp"
8426 $opt_dry_run || $RM $export_symbols
8428 # Append the command to create the export file.
8429 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8430 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8431 if test -n "$last_robj"; then
8432 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8436 test -n "$save_libobjs" &&
8437 func_verbose "creating a temporary reloadable object file: $output"
8439 # Loop through the commands generated above and execute them.
8440 save_ifs="$IFS"; IFS='~'
8441 for cmd in $concat_cmds; do
8444 func_quote_for_expand "$cmd"
8445 eval "func_echo $func_quote_for_expand_result"
8447 $opt_dry_run || eval "$cmd" || {
8450 # Restore the uninstalled library and exit
8451 if test "$opt_mode" = relink; then
8452 ( cd "$output_objdir" && \
8453 $RM "${realname}T" && \
8454 $MV "${realname}U" "$realname" )
8462 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8463 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8464 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8468 if ${skipped_export-false}; then
8469 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8470 tmp_export_symbols="$export_symbols"
8471 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8472 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8475 if test -n "$orig_export_symbols"; then
8476 # The given exports_symbols file has to be filtered, so filter it.
8477 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8478 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8479 # 's' commands which not all seds can handle. GNU sed should be fine
8480 # though. Also, the filter scales superlinearly with the number of
8481 # global variables. join(1) would be nice here, but unfortunately
8482 # isn't a blessed tool.
8483 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8484 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8485 export_symbols=$output_objdir/$libname.def
8486 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8491 # Restore the value of output.
8494 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8495 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8496 test "X$libobjs" = "X " && libobjs=
8498 # Expand the library linking commands again to reset the
8499 # value of $libobjs for piecewise linking.
8501 # Do each of the archive commands.
8502 if test "$module" = yes && test -n "$module_cmds" ; then
8503 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8504 cmds=$module_expsym_cmds
8509 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8510 cmds=$archive_expsym_cmds
8517 if test -n "$delfiles"; then
8518 # Append the command to remove temporary files to $cmds.
8519 eval cmds=\"\$cmds~\$RM $delfiles\"
8522 # Add any objects from preloaded convenience libraries
8523 if test -n "$dlprefiles"; then
8524 gentop="$output_objdir/${outputname}x"
8525 func_append generated " $gentop"
8527 func_extract_archives $gentop $dlprefiles
8528 func_append libobjs " $func_extract_archives_result"
8529 test "X$libobjs" = "X " && libobjs=
8532 save_ifs="$IFS"; IFS='~'
8533 for cmd in $cmds; do
8537 func_quote_for_expand "$cmd"
8538 eval "func_echo $func_quote_for_expand_result"
8540 $opt_dry_run || eval "$cmd" || {
8543 # Restore the uninstalled library and exit
8544 if test "$opt_mode" = relink; then
8545 ( cd "$output_objdir" && \
8546 $RM "${realname}T" && \
8547 $MV "${realname}U" "$realname" )
8555 # Restore the uninstalled library and exit
8556 if test "$opt_mode" = relink; then
8557 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8559 if test -n "$convenience"; then
8560 if test -z "$whole_archive_flag_spec"; then
8561 func_show_eval '${RM}r "$gentop"'
8568 # Create links to the real library.
8569 for linkname in $linknames; do
8570 if test "$realname" != "$linkname"; then
8571 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8575 # If -module or -export-dynamic was specified, set the dlname.
8576 if test "$module" = yes || test "$export_dynamic" = yes; then
8577 # On all known operating systems, these are identical.
8584 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8585 func_warning "\`-dlopen' is ignored for objects"
8590 func_warning "\`-l' and \`-L' are ignored for objects" ;;
8593 test -n "$rpath" && \
8594 func_warning "\`-rpath' is ignored for objects"
8596 test -n "$xrpath" && \
8597 func_warning "\`-R' is ignored for objects"
8599 test -n "$vinfo" && \
8600 func_warning "\`-version-info' is ignored for objects"
8602 test -n "$release" && \
8603 func_warning "\`-release' is ignored for objects"
8607 test -n "$objs$old_deplibs" && \
8608 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8612 obj=$func_lo2o_result
8620 # Delete the old objects.
8621 $opt_dry_run || $RM $obj $libobj
8623 # Objects from convenience libraries. This assumes
8624 # single-version convenience libraries. Whenever we create
8625 # different ones for PIC/non-PIC, this we'll have to duplicate
8629 # reload_cmds runs $LD directly, so let us get rid of
8630 # -Wl from whole_archive_flag_spec and hope we can get by with
8631 # turning comma into space..
8634 if test -n "$convenience"; then
8635 if test -n "$whole_archive_flag_spec"; then
8636 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8637 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8639 gentop="$output_objdir/${obj}x"
8640 func_append generated " $gentop"
8642 func_extract_archives $gentop $convenience
8643 reload_conv_objs="$reload_objs $func_extract_archives_result"
8647 # If we're not building shared, we need to use non_pic_objs
8648 test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8650 # Create the old-style object.
8651 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8654 func_execute_cmds "$reload_cmds" 'exit $?'
8656 # Exit if we aren't doing a library object file.
8657 if test -z "$libobj"; then
8658 if test -n "$gentop"; then
8659 func_show_eval '${RM}r "$gentop"'
8665 if test "$build_libtool_libs" != yes; then
8666 if test -n "$gentop"; then
8667 func_show_eval '${RM}r "$gentop"'
8670 # Create an invalid libtool object if no PIC, so that we don't
8671 # accidentally link it into a program.
8672 # $show "echo timestamp > $libobj"
8673 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8677 if test -n "$pic_flag" || test "$pic_mode" != default; then
8678 # Only do commands if we really have different PIC objects.
8679 reload_objs="$libobjs $reload_conv_objs"
8681 func_execute_cmds "$reload_cmds" 'exit $?'
8684 if test -n "$gentop"; then
8685 func_show_eval '${RM}r "$gentop"'
8693 *cygwin*) func_stripname '' '.exe' "$output"
8694 output=$func_stripname_result.exe;;
8696 test -n "$vinfo" && \
8697 func_warning "\`-version-info' is ignored for programs"
8699 test -n "$release" && \
8700 func_warning "\`-release' is ignored for programs"
8702 test "$preload" = yes \
8703 && test "$dlopen_support" = unknown \
8704 && test "$dlopen_self" = unknown \
8705 && test "$dlopen_self_static" = unknown && \
8706 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8709 *-*-rhapsody* | *-*-darwin1.[012])
8710 # On Rhapsody replace the C library is the System framework
8711 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8712 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8718 # Don't allow lazy linking, it breaks C++ global constructors
8719 # But is supposedly fixed on 10.4 or later (yay!).
8720 if test "$tagname" = CXX ; then
8721 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8723 func_append compile_command " ${wl}-bind_at_load"
8724 func_append finalize_command " ${wl}-bind_at_load"
8728 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8729 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8730 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8735 # move library search paths that coincide with paths to not yet
8736 # installed libraries to the beginning of the library search list
8738 for path in $notinst_path; do
8739 case " $new_libs " in
8740 *" -L$path/$objdir "*) ;;
8742 case " $compile_deplibs " in
8743 *" -L$path/$objdir "*)
8744 func_append new_libs " -L$path/$objdir" ;;
8749 for deplib in $compile_deplibs; do
8752 case " $new_libs " in
8754 *) func_append new_libs " $deplib" ;;
8757 *) func_append new_libs " $deplib" ;;
8760 compile_deplibs="$new_libs"
8763 func_append compile_command " $compile_deplibs"
8764 func_append finalize_command " $finalize_deplibs"
8766 if test -n "$rpath$xrpath"; then
8767 # If the user specified any rpath flags, then add them.
8768 for libdir in $rpath $xrpath; do
8769 # This is the magic to use -rpath.
8770 case "$finalize_rpath " in
8772 *) func_append finalize_rpath " $libdir" ;;
8777 # Now hardcode the library paths
8780 for libdir in $compile_rpath $finalize_rpath; do
8781 if test -n "$hardcode_libdir_flag_spec"; then
8782 if test -n "$hardcode_libdir_separator"; then
8783 if test -z "$hardcode_libdirs"; then
8784 hardcode_libdirs="$libdir"
8786 # Just accumulate the unique libdirs.
8787 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8788 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8791 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8796 eval flag=\"$hardcode_libdir_flag_spec\"
8797 func_append rpath " $flag"
8799 elif test -n "$runpath_var"; then
8800 case "$perm_rpath " in
8802 *) func_append perm_rpath " $libdir" ;;
8806 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8807 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8808 case :$dllsearchpath: in
8810 ::) dllsearchpath=$libdir;;
8811 *) func_append dllsearchpath ":$libdir";;
8813 case :$dllsearchpath: in
8814 *":$testbindir:"*) ;;
8815 ::) dllsearchpath=$testbindir;;
8816 *) func_append dllsearchpath ":$testbindir";;
8821 # Substitute the hardcoded libdirs into the rpath.
8822 if test -n "$hardcode_libdir_separator" &&
8823 test -n "$hardcode_libdirs"; then
8824 libdir="$hardcode_libdirs"
8825 eval rpath=\" $hardcode_libdir_flag_spec\"
8827 compile_rpath="$rpath"
8831 for libdir in $finalize_rpath; do
8832 if test -n "$hardcode_libdir_flag_spec"; then
8833 if test -n "$hardcode_libdir_separator"; then
8834 if test -z "$hardcode_libdirs"; then
8835 hardcode_libdirs="$libdir"
8837 # Just accumulate the unique libdirs.
8838 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8839 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8842 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8847 eval flag=\"$hardcode_libdir_flag_spec\"
8848 func_append rpath " $flag"
8850 elif test -n "$runpath_var"; then
8851 case "$finalize_perm_rpath " in
8853 *) func_append finalize_perm_rpath " $libdir" ;;
8857 # Substitute the hardcoded libdirs into the rpath.
8858 if test -n "$hardcode_libdir_separator" &&
8859 test -n "$hardcode_libdirs"; then
8860 libdir="$hardcode_libdirs"
8861 eval rpath=\" $hardcode_libdir_flag_spec\"
8863 finalize_rpath="$rpath"
8865 if test -n "$libobjs" && test "$build_old_libs" = yes; then
8866 # Transform all the library objects into standard objects.
8867 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8868 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8871 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8873 # template prelinking step
8874 if test -n "$prelink_cmds"; then
8875 func_execute_cmds "$prelink_cmds" 'exit $?'
8878 wrappers_required=yes
8880 *cegcc* | *mingw32ce*)
8881 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8882 wrappers_required=no
8884 *cygwin* | *mingw* )
8885 if test "$build_libtool_libs" != yes; then
8886 wrappers_required=no
8890 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8891 wrappers_required=no
8895 if test "$wrappers_required" = no; then
8896 # Replace the output file specification.
8897 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8898 link_command="$compile_command$compile_rpath"
8900 # We have no uninstalled library dependencies, so finalize right now.
8902 func_show_eval "$link_command" 'exit_status=$?'
8904 if test -n "$postlink_cmds"; then
8905 func_to_tool_file "$output"
8906 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8907 func_execute_cmds "$postlink_cmds" 'exit $?'
8910 # Delete the generated files.
8911 if test -f "$output_objdir/${outputname}S.${objext}"; then
8912 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8918 if test -n "$compile_shlibpath$finalize_shlibpath"; then
8919 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8921 if test -n "$finalize_shlibpath"; then
8922 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8927 if test -n "$runpath_var"; then
8928 if test -n "$perm_rpath"; then
8929 # We should set the runpath_var.
8931 for dir in $perm_rpath; do
8932 func_append rpath "$dir:"
8934 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8936 if test -n "$finalize_perm_rpath"; then
8937 # We should set the runpath_var.
8939 for dir in $finalize_perm_rpath; do
8940 func_append rpath "$dir:"
8942 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8946 if test "$no_install" = yes; then
8947 # We don't need to create a wrapper script.
8948 link_command="$compile_var$compile_command$compile_rpath"
8949 # Replace the output file specification.
8950 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8951 # Delete the old output file.
8952 $opt_dry_run || $RM $output
8953 # Link the executable and exit
8954 func_show_eval "$link_command" 'exit $?'
8956 if test -n "$postlink_cmds"; then
8957 func_to_tool_file "$output"
8958 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8959 func_execute_cmds "$postlink_cmds" 'exit $?'
8965 if test "$hardcode_action" = relink; then
8966 # Fast installation is not supported
8967 link_command="$compile_var$compile_command$compile_rpath"
8968 relink_command="$finalize_var$finalize_command$finalize_rpath"
8970 func_warning "this platform does not like uninstalled shared libraries"
8971 func_warning "\`$output' will be relinked during installation"
8973 if test "$fast_install" != no; then
8974 link_command="$finalize_var$compile_command$finalize_rpath"
8975 if test "$fast_install" = yes; then
8976 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8978 # fast_install is set to needless
8982 link_command="$compile_var$compile_command$compile_rpath"
8983 relink_command="$finalize_var$finalize_command$finalize_rpath"
8987 # Replace the output file specification.
8988 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8990 # Delete the old output files.
8991 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8993 func_show_eval "$link_command" 'exit $?'
8995 if test -n "$postlink_cmds"; then
8996 func_to_tool_file "$output_objdir/$outputname"
8997 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'`
8998 func_execute_cmds "$postlink_cmds" 'exit $?'
9001 # Now create the wrapper script.
9002 func_verbose "creating $output"
9004 # Quote the relink command for shipping.
9005 if test -n "$relink_command"; then
9006 # Preserve any variables that may affect compiler behavior
9007 for var in $variables_saved_for_relink; do
9008 if eval test -z \"\${$var+set}\"; then
9009 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9010 elif eval var_value=\$$var; test -z "$var_value"; then
9011 relink_command="$var=; export $var; $relink_command"
9013 func_quote_for_eval "$var_value"
9014 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9017 relink_command="(cd `pwd`; $relink_command)"
9018 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9021 # Only actually do things if not in dry run mode.
9023 # win32 will think the script is a binary if it has
9024 # a .exe suffix, so we strip it off here.
9026 *.exe) func_stripname '' '.exe' "$output"
9027 output=$func_stripname_result ;;
9029 # test for cygwin because mv fails w/o .exe extensions
9033 func_stripname '' '.exe' "$outputname"
9034 outputname=$func_stripname_result ;;
9038 *cygwin* | *mingw* )
9039 func_dirname_and_basename "$output" "" "."
9040 output_name=$func_basename_result
9041 output_path=$func_dirname_result
9042 cwrappersource="$output_path/$objdir/lt-$output_name.c"
9043 cwrapper="$output_path/$output_name.exe"
9044 $RM $cwrappersource $cwrapper
9045 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9047 func_emit_cwrapperexe_src > $cwrappersource
9049 # The wrapper executable is built using the $host compiler,
9050 # because it contains $host paths and files. If cross-
9051 # compiling, it, like the target executable, must be
9052 # executed on the $host or under an emulation environment.
9054 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9058 # Now, create the wrapper script for func_source use:
9059 func_ltwrapper_scriptname $cwrapper
9060 $RM $func_ltwrapper_scriptname_result
9061 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9063 # note: this script will not be executed, so do not chmod.
9064 if test "x$build" = "x$host" ; then
9065 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9067 func_emit_wrapper no > $func_ltwrapper_scriptname_result
9073 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9075 func_emit_wrapper no > $output
9084 # See if we need to build an old-fashioned archive.
9085 for oldlib in $oldlibs; do
9087 if test "$build_libtool_libs" = convenience; then
9088 oldobjs="$libobjs_save $symfileobj"
9089 addlibs="$convenience"
9090 build_libtool_libs=no
9092 if test "$build_libtool_libs" = module; then
9093 oldobjs="$libobjs_save"
9094 build_libtool_libs=no
9096 oldobjs="$old_deplibs $non_pic_objects"
9097 if test "$preload" = yes && test -f "$symfileobj"; then
9098 func_append oldobjs " $symfileobj"
9101 addlibs="$old_convenience"
9104 if test -n "$addlibs"; then
9105 gentop="$output_objdir/${outputname}x"
9106 func_append generated " $gentop"
9108 func_extract_archives $gentop $addlibs
9109 func_append oldobjs " $func_extract_archives_result"
9112 # Do each command in the archive commands.
9113 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9114 cmds=$old_archive_from_new_cmds
9117 # Add any objects from preloaded convenience libraries
9118 if test -n "$dlprefiles"; then
9119 gentop="$output_objdir/${outputname}x"
9120 func_append generated " $gentop"
9122 func_extract_archives $gentop $dlprefiles
9123 func_append oldobjs " $func_extract_archives_result"
9126 # POSIX demands no paths to be encoded in archives. We have
9127 # to avoid creating archives with duplicate basenames if we
9128 # might have to extract them afterwards, e.g., when creating a
9129 # static archive out of a convenience library, or when linking
9130 # the entirety of a libtool archive into another (currently
9131 # not supported by libtool).
9132 if (for obj in $oldobjs
9134 func_basename "$obj"
9135 $ECHO "$func_basename_result"
9136 done | sort | sort -uc >/dev/null 2>&1); then
9139 echo "copying selected object files to avoid basename conflicts..."
9140 gentop="$output_objdir/${outputname}x"
9141 func_append generated " $gentop"
9142 func_mkdir_p "$gentop"
9143 save_oldobjs=$oldobjs
9146 for obj in $save_oldobjs
9148 func_basename "$obj"
9149 objbase="$func_basename_result"
9150 case " $oldobjs " in
9151 " ") oldobjs=$obj ;;
9154 # Make sure we don't pick an alternate name that also
9156 newobj=lt$counter-$objbase
9157 func_arith $counter + 1
9158 counter=$func_arith_result
9159 case " $oldobjs " in
9160 *[\ /]"$newobj "*) ;;
9161 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9164 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9165 func_append oldobjs " $gentop/$newobj"
9167 *) func_append oldobjs " $obj" ;;
9171 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9172 tool_oldlib=$func_to_tool_file_result
9173 eval cmds=\"$old_archive_cmds\"
9176 len=$func_len_result
9177 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9178 cmds=$old_archive_cmds
9179 elif test -n "$archiver_list_spec"; then
9180 func_verbose "using command file archive linking..."
9183 func_to_tool_file "$obj"
9184 $ECHO "$func_to_tool_file_result"
9185 done > $output_objdir/$libname.libcmd
9186 func_to_tool_file "$output_objdir/$libname.libcmd"
9187 oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9188 cmds=$old_archive_cmds
9190 # the command line is too long to link in one step, link in parts
9191 func_verbose "using piecewise archive linking..."
9196 save_oldobjs=$oldobjs
9198 # Is there a better way of finding the last object in the list?
9199 for obj in $save_oldobjs
9203 eval test_cmds=\"$old_archive_cmds\"
9204 func_len " $test_cmds"
9205 len0=$func_len_result
9207 for obj in $save_oldobjs
9210 func_arith $len + $func_len_result
9211 len=$func_arith_result
9212 func_append objlist " $obj"
9213 if test "$len" -lt "$max_cmd_len"; then
9216 # the above command should be used before it gets too long
9218 if test "$obj" = "$last_oldobj" ; then
9221 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9222 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9229 if test "X$oldobjs" = "X" ; then
9230 eval cmds=\"\$concat_cmds\"
9232 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9236 func_execute_cmds "$cmds" 'exit $?'
9239 test -n "$generated" && \
9240 func_show_eval "${RM}r$generated"
9242 # Now create the libtool archive.
9246 test "$build_old_libs" = yes && old_library="$libname.$libext"
9247 func_verbose "creating $output"
9249 # Preserve any variables that may affect compiler behavior
9250 for var in $variables_saved_for_relink; do
9251 if eval test -z \"\${$var+set}\"; then
9252 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9253 elif eval var_value=\$$var; test -z "$var_value"; then
9254 relink_command="$var=; export $var; $relink_command"
9256 func_quote_for_eval "$var_value"
9257 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9260 # Quote the link command for shipping.
9261 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9262 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9263 if test "$hardcode_automatic" = yes ; then
9267 # Only create the output if not a dry run.
9269 for installed in no yes; do
9270 if test "$installed" = yes; then
9271 if test -z "$install_libdir"; then
9274 output="$output_objdir/$outputname"i
9275 # Replace all uninstalled libtool libraries with the installed ones
9277 for deplib in $dependency_libs; do
9280 func_basename "$deplib"
9281 name="$func_basename_result"
9282 func_resolve_sysroot "$deplib"
9283 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9284 test -z "$libdir" && \
9285 func_fatal_error "\`$deplib' is not a valid libtool archive"
9286 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9289 func_stripname -L '' "$deplib"
9290 func_replace_sysroot "$func_stripname_result"
9291 func_append newdependency_libs " -L$func_replace_sysroot_result"
9294 func_stripname -R '' "$deplib"
9295 func_replace_sysroot "$func_stripname_result"
9296 func_append newdependency_libs " -R$func_replace_sysroot_result"
9298 *) func_append newdependency_libs " $deplib" ;;
9301 dependency_libs="$newdependency_libs"
9304 for lib in $dlfiles; do
9307 func_basename "$lib"
9308 name="$func_basename_result"
9309 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9310 test -z "$libdir" && \
9311 func_fatal_error "\`$lib' is not a valid libtool archive"
9312 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9314 *) func_append newdlfiles " $lib" ;;
9317 dlfiles="$newdlfiles"
9319 for lib in $dlprefiles; do
9322 # Only pass preopened files to the pseudo-archive (for
9323 # eventual linking with the app. that links it) if we
9324 # didn't already link the preopened objects directly into
9326 func_basename "$lib"
9327 name="$func_basename_result"
9328 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9329 test -z "$libdir" && \
9330 func_fatal_error "\`$lib' is not a valid libtool archive"
9331 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9335 dlprefiles="$newdlprefiles"
9338 for lib in $dlfiles; do
9340 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9341 *) abs=`pwd`"/$lib" ;;
9343 func_append newdlfiles " $abs"
9345 dlfiles="$newdlfiles"
9347 for lib in $dlprefiles; do
9349 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9350 *) abs=`pwd`"/$lib" ;;
9352 func_append newdlprefiles " $abs"
9354 dlprefiles="$newdlprefiles"
9357 # place dlname in correct position for cygwin
9358 # In fact, it would be nice if we could use this code for all target
9359 # systems that can't hard-code library paths into their executables
9360 # and that have no shared library path variable independent of PATH,
9361 # but it turns out we can't easily determine that from inspecting
9362 # libtool variables, so we have to hard-code the OSs to which it
9363 # applies here; at the moment, that means platforms that use the PE
9364 # object format with DLL files. See the long comment at the top of
9365 # tests/bindir.at for full details.
9367 case $host,$output,$installed,$module,$dlname in
9368 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9369 # If a -bindir argument was supplied, place the dll there.
9370 if test "x$bindir" != x ;
9372 func_relative_path "$install_libdir" "$bindir"
9373 tdlname=$func_relative_path_result$dlname
9375 # Otherwise fall back on heuristic.
9376 tdlname=../bin/$dlname
9381 # $outputname - a libtool library file
9382 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9384 # Please DO NOT delete this file!
9385 # It is necessary for linking the library.
9387 # The name that we can dlopen(3).
9390 # Names of this library.
9391 library_names='$library_names'
9393 # The name of the static archive.
9394 old_library='$old_library'
9396 # Linker flags that can not go in dependency_libs.
9397 inherited_linker_flags='$new_inherited_linker_flags'
9399 # Libraries that this one depends upon.
9400 dependency_libs='$dependency_libs'
9402 # Names of additional weak libraries provided by this library
9403 weak_library_names='$weak_libs'
9405 # Version information for $libname.
9410 # Is this an already installed library?
9411 installed=$installed
9413 # Should we warn about portability when linking against -modules?
9414 shouldnotlink=$module
9416 # Files to dlopen/dlpreopen
9418 dlpreopen='$dlprefiles'
9420 # Directory that this library needs to be installed in:
9421 libdir='$install_libdir'"
9422 if test "$installed" = no && test "$need_relink" = yes; then
9424 relink_command=\"$relink_command\""
9429 # Do a symbolic link so that the libtool archive can be found in
9430 # LD_LIBRARY_PATH before the program is installed.
9431 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9437 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9438 func_mode_link ${1+"$@"}
9441 # func_mode_uninstall arg...
9442 func_mode_uninstall ()
9450 # This variable tells wrapper scripts just to set variables rather
9451 # than running their programs.
9452 libtool_install_magic="$magic"
9457 -f) func_append RM " $arg"; rmforce=yes ;;
9458 -*) func_append RM " $arg" ;;
9459 *) func_append files " $arg" ;;
9464 func_fatal_help "you must specify an RM program"
9468 for file in $files; do
9469 func_dirname "$file" "" "."
9470 dir="$func_dirname_result"
9471 if test "X$dir" = X.; then
9476 func_basename "$file"
9477 name="$func_basename_result"
9478 test "$opt_mode" = uninstall && odir="$dir"
9480 # Remember odir for removal later, being careful to avoid duplicates
9481 if test "$opt_mode" = clean; then
9484 *) func_append rmdirs " $odir" ;;
9488 # Don't error if the file doesn't exist and rm -f was used.
9489 if { test -L "$file"; } >/dev/null 2>&1 ||
9490 { test -h "$file"; } >/dev/null 2>&1 ||
9491 test -f "$file"; then
9493 elif test -d "$file"; then
9496 elif test "$rmforce" = yes; then
9504 # Possibly a libtool archive, so verify it.
9505 if func_lalib_p "$file"; then
9506 func_source $dir/$name
9508 # Delete the libtool libraries and symlinks.
9509 for n in $library_names; do
9510 func_append rmfiles " $odir/$n"
9512 test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9516 case " $library_names " in
9518 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9520 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9523 if test -n "$library_names"; then
9524 # Do each command in the postuninstall commands.
9525 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9528 if test -n "$old_library"; then
9529 # Do each command in the old_postuninstall commands.
9530 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9532 # FIXME: should reinstall the best remaining shared library.
9539 # Possibly a libtool object, so verify it.
9540 if func_lalib_p "$file"; then
9543 func_source $dir/$name
9545 # Add PIC object to the list of files to remove.
9546 if test -n "$pic_object" &&
9547 test "$pic_object" != none; then
9548 func_append rmfiles " $dir/$pic_object"
9551 # Add non-PIC object to the list of files to remove.
9552 if test -n "$non_pic_object" &&
9553 test "$non_pic_object" != none; then
9554 func_append rmfiles " $dir/$non_pic_object"
9560 if test "$opt_mode" = clean ; then
9564 func_stripname '' '.exe' "$file"
9565 file=$func_stripname_result
9566 func_stripname '' '.exe' "$name"
9567 noexename=$func_stripname_result
9568 # $file with .exe has already been added to rmfiles,
9569 # add $file without .exe
9570 func_append rmfiles " $file"
9573 # Do a test to see if this is a libtool program.
9574 if func_ltwrapper_p "$file"; then
9575 if func_ltwrapper_executable_p "$file"; then
9576 func_ltwrapper_scriptname "$file"
9578 func_source $func_ltwrapper_scriptname_result
9579 func_append rmfiles " $func_ltwrapper_scriptname_result"
9582 func_source $dir/$noexename
9585 # note $name still contains .exe if it was in $file originally
9586 # as does the version of $file that was added into $rmfiles
9587 func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9588 if test "$fast_install" = yes && test -n "$relink_command"; then
9589 func_append rmfiles " $odir/lt-$name"
9591 if test "X$noexename" != "X$name" ; then
9592 func_append rmfiles " $odir/lt-${noexename}.c"
9598 func_show_eval "$RM $rmfiles" 'exit_status=1'
9601 # Try to remove the ${objdir}s in the directories where we deleted files
9602 for dir in $rmdirs; do
9603 if test -d "$dir"; then
9604 func_show_eval "rmdir $dir >/dev/null 2>&1"
9611 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9612 func_mode_uninstall ${1+"$@"}
9614 test -z "$opt_mode" && {
9615 help="$generic_help"
9616 func_fatal_help "you must specify a MODE"
9619 test -z "$exec_cmd" && \
9620 func_fatal_help "invalid operation mode \`$opt_mode'"
9622 if test -n "$exec_cmd"; then
9623 eval exec "$exec_cmd"
9630 # The TAGs below are defined such that we never get into a situation
9631 # in which we disable both kinds of libraries. Given conflicting
9632 # choices, we go for a static library, that is the most portable,
9633 # since we can't tell whether shared libraries were disabled because
9634 # the user asked for that or because the platform doesn't support
9635 # them. This is particularly important on AIX, because we don't
9636 # support having both static and shared libraries enabled at the same
9637 # time on that platform, so we default to a shared-only configuration.
9638 # If a disable-shared tag is given, we'll fallback to a static-only
9639 # configuration. But we'll never go from static-only to shared-only.
9641 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9642 build_libtool_libs=no
9644 # ### END LIBTOOL TAG CONFIG: disable-shared
9646 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9647 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9648 # ### END LIBTOOL TAG CONFIG: disable-static