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
2720 test "$opt_mode" = finish
&& func_mode_finish
${1+"$@"}
2723 # func_mode_install arg...
2724 func_mode_install
()
2727 # There may be an optional sh(1) argument at the beginning of
2728 # install_prog (especially on Windows NT).
2729 if test "$nonopt" = "$SHELL" ||
test "$nonopt" = /bin
/sh ||
2730 # Allow the use of GNU shtool's install command.
2731 case $nonopt in *shtool
*) :;; *) false
;; esac; then
2732 # Aesthetically quote it.
2733 func_quote_for_eval
"$nonopt"
2734 install_prog
="$func_quote_for_eval_result "
2742 # The real first argument should be the name of the installation program.
2743 # Aesthetically quote it.
2744 func_quote_for_eval
"$arg"
2745 func_append install_prog
"$func_quote_for_eval_result"
2746 install_shared_prog
=$install_prog
2747 case " $install_prog " in
2748 *[\\\
/]cp\
*) install_cp
=: ;;
2749 *) install_cp
=false
;;
2752 # We need to accept at least all the BSD install flags.
2764 if test -n "$dest"; then
2765 func_append files
" $dest"
2773 if $install_cp; then :; else
2787 # If the previous option needed an argument, then skip it.
2788 if test -n "$prev"; then
2789 if test "x$prev" = x-m
&& test -n "$install_override_mode"; then
2790 arg2
=$install_override_mode
2801 # Aesthetically quote the argument.
2802 func_quote_for_eval
"$arg"
2803 func_append install_prog
" $func_quote_for_eval_result"
2804 if test -n "$arg2"; then
2805 func_quote_for_eval
"$arg2"
2807 func_append install_shared_prog
" $func_quote_for_eval_result"
2809 case " $install_prog " in
2810 *[\\\
/]cp\
*) extra_mode
=;;
2811 *) extra_mode
='-m 644';;
2814 test -z "$install_prog" && \
2815 func_fatal_help
"you must specify an install program"
2817 test -n "$prev" && \
2818 func_fatal_help
"the \`$prev' option requires an argument"
2820 if test -n "$install_override_mode" && $no_mode; then
2821 if $install_cp; then :; else
2822 func_quote_for_eval
"$install_override_mode"
2823 func_append install_shared_prog
" -m $func_quote_for_eval_result"
2827 if test -z "$files"; then
2828 if test -z "$dest"; then
2829 func_fatal_help
"no file or destination specified"
2831 func_fatal_help
"you must specify a destination"
2835 # Strip any trailing slash from the destination.
2836 func_stripname
'' '/' "$dest"
2837 dest
=$func_stripname_result
2839 # Check to see that the destination is a directory.
2840 test -d "$dest" && isdir
=yes
2841 if test "$isdir" = yes; then
2845 func_dirname_and_basename
"$dest" "" "."
2846 destdir
="$func_dirname_result"
2847 destname
="$func_basename_result"
2849 # Not a directory, so check to see that there is only one file specified.
2850 set dummy
$files; shift
2851 test "$#" -gt 1 && \
2852 func_fatal_help
"\`$dest' is not a directory"
2855 [\\/]* |
[A-Za-z
]:[\\/]*) ;;
2857 for file in $files; do
2861 func_fatal_help
"\`$destdir' must be an absolute directory name"
2868 # This variable tells wrapper scripts just to set variables rather
2869 # than running their programs.
2870 libtool_install_magic
="$magic"
2875 for file in $files; do
2877 # Do each installation.
2880 # Do the static libraries later.
2881 func_append staticlibs
" $file"
2885 func_resolve_sysroot
"$file"
2886 file=$func_resolve_sysroot_result
2888 # Check to see that this really is a libtool archive.
2889 func_lalib_unsafe_p
"$file" \
2890 || func_fatal_help
"\`$file' is not a valid libtool archive"
2897 # Add the libdir to current_libdirs if it is the destination.
2898 if test "X$destdir" = "X$libdir"; then
2899 case "$current_libdirs " in
2901 *) func_append current_libdirs
" $libdir" ;;
2904 # Note the libdir as a future libdir.
2905 case "$future_libdirs " in
2907 *) func_append future_libdirs
" $libdir" ;;
2911 func_dirname
"$file" "/" ""
2912 dir
="$func_dirname_result"
2913 func_append dir
"$objdir"
2915 if test -n "$relink_command"; then
2916 # Determine the prefix the user has applied to our future dir.
2917 inst_prefix_dir
=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2919 # Don't allow the user to place us outside of our expected
2920 # location b/c this prevents finding dependent libraries that
2921 # are installed to the same prefix.
2922 # At present, this check doesn't affect windows .dll's that
2923 # are installed into $libdir/../bin (currently, that works fine)
2924 # but it's something to keep an eye on.
2925 test "$inst_prefix_dir" = "$destdir" && \
2926 func_fatal_error
"error: cannot install \`$file' to a directory not ending in $libdir"
2928 if test -n "$inst_prefix_dir"; then
2929 # Stick the inst_prefix_dir data into the link command.
2930 relink_command
=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2932 relink_command
=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2935 func_warning
"relinking \`$file'"
2936 func_show_eval
"$relink_command" \
2937 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2940 # See the names of the shared library.
2941 set dummy
$library_names; shift
2942 if test -n "$1"; then
2947 test -n "$relink_command" && srcname
="$realname"T
2949 # Install the shared library and build the symlinks.
2950 func_show_eval
"$install_shared_prog $extra_mode $dir/$srcname $destdir/$realname" \
2954 cygwin
* | mingw
* | pw32
* | cegcc
*)
2962 if test -n "$tstripme" && test -n "$striplib"; then
2963 func_show_eval
"$striplib $destdir/$realname" 'exit $?'
2966 if test "$#" -gt 0; then
2967 # Delete the old symlinks, and create new ones.
2968 # Try `ln -sf' first, because the `ln' binary might depend on
2969 # the symlink we replace! Solaris /bin/ln does not understand -f,
2970 # so we also need to try rm && ln -s.
2973 test "$linkname" != "$realname" \
2974 && func_show_eval
"(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2978 # Do each command in the postinstall commands.
2979 lib
="$destdir/$realname"
2980 func_execute_cmds
"$postinstall_cmds" 'exit $?'
2983 # Install the pseudo-library for information purposes.
2984 func_basename
"$file"
2985 name
="$func_basename_result"
2986 instname
="$dir/$name"i
2987 func_show_eval
"$install_prog $extra_mode $instname $destdir/$name" 'exit $?'
2989 # Maybe install the static library, too.
2990 test -n "$old_library" && func_append staticlibs
" $dir/$old_library"
2994 # Install (i.e. copy) a libtool object.
2996 # Figure out destination file name, if it wasn't already specified.
2997 if test -n "$destname"; then
2998 destfile
="$destdir/$destname"
3000 func_basename
"$file"
3001 destfile
="$func_basename_result"
3002 destfile
="$destdir/$destfile"
3005 # Deduce the name of the destination old-style object file.
3008 func_lo2o
"$destfile"
3009 staticdest
=$func_lo2o_result
3012 staticdest
="$destfile"
3016 func_fatal_help
"cannot copy a libtool object to \`$destfile'"
3020 # Install the libtool object if requested.
3021 test -n "$destfile" && \
3022 func_show_eval
"$install_prog $extra_mode $file $destfile" 'exit $?'
3024 # Install the old object if enabled.
3025 if test "$build_old_libs" = yes; then
3026 # Deduce the name of the old-style object file.
3028 staticobj
=$func_lo2o_result
3029 func_show_eval
"$install_prog $extra_mode \$staticobj \$staticdest" 'exit $?'
3035 # Figure out destination file name, if it wasn't already specified.
3036 if test -n "$destname"; then
3037 destfile
="$destdir/$destname"
3039 func_basename
"$file"
3040 destfile
="$func_basename_result"
3041 destfile
="$destdir/$destfile"
3044 # If the file is missing, and there is a .exe on the end, strip it
3045 # because it is most likely a libtool script we actually want to
3050 if test ! -f "$file"; then
3051 func_stripname
'' '.exe' "$file"
3052 file=$func_stripname_result
3058 # Do a test to see if this is really a libtool program.
3061 if func_ltwrapper_executable_p
"$file"; then
3062 func_ltwrapper_scriptname
"$file"
3063 wrapper
=$func_ltwrapper_scriptname_result
3065 func_stripname
'' '.exe' "$file"
3066 wrapper
=$func_stripname_result
3073 if func_ltwrapper_script_p
"$wrapper"; then
3077 func_source
"$wrapper"
3079 # Check the variables that should have been set.
3080 test -z "$generated_by_libtool_version" && \
3081 func_fatal_error
"invalid libtool wrapper script \`$wrapper'"
3084 for lib
in $notinst_deplibs; do
3085 # Check to see that each library is installed.
3087 if test -f "$lib"; then
3090 libfile
="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3091 if test -n "$libdir" && test ! -f "$libfile"; then
3092 func_warning
"\`$lib' has not been installed in \`$libdir'"
3098 func_source
"$wrapper"
3101 if test "$fast_install" = no
&& test -n "$relink_command"; then
3103 if test "$finalize" = yes; then
3104 tmpdir
=`func_mktempdir`
3105 func_basename
"$file$stripped_ext"
3106 file="$func_basename_result"
3107 outputname
="$tmpdir/$file"
3108 # Replace the output file specification.
3109 relink_command
=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3112 func_quote_for_expand
"$relink_command"
3113 eval "func_echo $func_quote_for_expand_result"
3115 if eval "$relink_command"; then :
3117 func_error
"error: relink \`$file' with the above command before installing it"
3118 $opt_dry_run ||
${RM}r
"$tmpdir"
3123 func_warning
"cannot relink \`$file'"
3127 # Install the binary that we compiled earlier.
3128 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3132 # remove .exe since cygwin /usr/bin/install will append another
3134 case $install_prog,$host in
3135 */usr
/bin
/install*,*cygwin
*)
3136 case $file:$destfile in
3141 destfile
=$destfile.exe
3144 func_stripname
'' '.exe' "$destfile"
3145 destfile
=$func_stripname_result
3150 func_show_eval
"$install_prog\$stripme \$file \$destfile" 'exit $?'
3151 $opt_dry_run ||
if test -n "$outputname"; then
3158 for file in $staticlibs; do
3159 func_basename
"$file"
3160 name
="$func_basename_result"
3162 # Set up the ranlib parameters.
3163 oldlib
="$destdir/$name"
3164 func_to_tool_file
"$oldlib" func_convert_file_msys_to_w32
3165 tool_oldlib
=$func_to_tool_file_result
3167 func_show_eval
"$install_prog \$file \$oldlib" 'exit $?'
3169 if test -n "$stripme" && test -n "$old_striplib"; then
3170 func_show_eval
"$old_striplib $tool_oldlib" 'exit $?'
3173 # Do each command in the postinstall commands.
3174 func_execute_cmds
"$old_postinstall_cmds" 'exit $?'
3177 test -n "$future_libdirs" && \
3178 func_warning
"remember to run \`$progname --finish$future_libdirs'"
3180 if test -n "$current_libdirs"; then
3181 # Maybe just do a dry run.
3182 $opt_dry_run && current_libdirs
=" -n$current_libdirs"
3183 exec_cmd
='$SHELL $progpath $preserve_args --finish$current_libdirs'
3189 test "$opt_mode" = install && func_mode_install
${1+"$@"}
3192 # func_generate_dlsyms outputname originator pic_p
3193 # Extract symbols from dlprefiles and create ${outputname}S.o with
3194 # a dlpreopen symbol table.
3195 func_generate_dlsyms
()
3201 my_prefix
=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3204 if test -n "$dlfiles$dlprefiles" ||
test "$dlself" != no
; then
3205 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3206 my_dlsyms
="${my_outputname}S.c"
3208 func_error
"not configured to extract global symbols from dlpreopened files"
3212 if test -n "$my_dlsyms"; then
3216 # Discover the nlist of each of the dlfiles.
3217 nlist
="$output_objdir/${my_outputname}.nm"
3219 func_show_eval
"$RM $nlist ${nlist}S ${nlist}T"
3221 # Parse the name list into a source file.
3222 func_verbose
"creating $output_objdir/$my_dlsyms"
3224 $opt_dry_run ||
$ECHO > "$output_objdir/$my_dlsyms" "\
3225 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3226 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3232 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3233 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3236 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3237 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3238 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3239 relocations are performed -- see ld's documentation on pseudo-relocs. */
3240 # define LT_DLSYM_CONST
3241 #elif defined(__osf__)
3242 /* This system does not cope well with relocations in const data. */
3243 # define LT_DLSYM_CONST
3245 # define LT_DLSYM_CONST const
3248 /* External symbol declarations for the compiler. */\
3251 if test "$dlself" = yes; then
3252 func_verbose
"generating symbol list for \`$output'"
3254 $opt_dry_run ||
echo ': @PROGRAM@ ' > "$nlist"
3256 # Add our own program objects to the symbol list.
3257 progfiles
=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3258 for progfile
in $progfiles; do
3259 func_to_tool_file
"$progfile" func_convert_file_msys_to_w32
3260 func_verbose
"extracting global C symbols from \`$func_to_tool_file_result'"
3261 $opt_dry_run ||
eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3264 if test -n "$exclude_expsyms"; then
3266 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3267 eval '$MV "$nlist"T "$nlist"'
3271 if test -n "$export_symbols_regex"; then
3273 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3274 eval '$MV "$nlist"T "$nlist"'
3278 # Prepare the list of exported symbols
3279 if test -z "$export_symbols"; then
3280 export_symbols
="$output_objdir/$outputname.exp"
3283 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3285 *cygwin
* |
*mingw
* |
*cegcc
* )
3286 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3287 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3293 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3294 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3295 eval '$MV "$nlist"T "$nlist"'
3297 *cygwin
* |
*mingw
* |
*cegcc
* )
3298 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3299 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3306 for dlprefile
in $dlprefiles; do
3307 func_verbose
"extracting global C symbols from \`$dlprefile'"
3308 func_basename
"$dlprefile"
3309 name
="$func_basename_result"
3311 *cygwin
* |
*mingw
* |
*cegcc
* )
3312 # if an import library, we need to obtain dlname
3313 if func_win32_import_lib_p
"$dlprefile"; then
3314 func_tr_sh
"$dlprefile"
3315 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3316 dlprefile_dlbasename
=""
3317 if test -n "$curr_lafile" && func_lalib_p
"$curr_lafile"; then
3318 # Use subshell, to avoid clobbering current variable values
3319 dlprefile_dlname
=`source "$curr_lafile" && echo "$dlname"`
3320 if test -n "$dlprefile_dlname" ; then
3321 func_basename
"$dlprefile_dlname"
3322 dlprefile_dlbasename
="$func_basename_result"
3324 # no lafile. user explicitly requested -dlpreopen <import library>.
3325 $sharedlib_from_linklib_cmd "$dlprefile"
3326 dlprefile_dlbasename
=$sharedlib_from_linklib_result
3330 if test -n "$dlprefile_dlbasename" ; then
3331 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3333 func_warning
"Could not compute DLL name from $name"
3334 eval '$ECHO ": $name " >> "$nlist"'
3336 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3337 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3338 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3340 else # not an import lib
3342 eval '$ECHO ": $name " >> "$nlist"'
3343 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3344 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3350 eval '$ECHO ": $name " >> "$nlist"'
3351 func_to_tool_file
"$dlprefile" func_convert_file_msys_to_w32
3352 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3359 # Make sure we have at least an empty file.
3360 test -f "$nlist" ||
: > "$nlist"
3362 if test -n "$exclude_expsyms"; then
3363 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3364 $MV "$nlist"T
"$nlist"
3367 # Try sorting and uniquifying the output.
3368 if $GREP -v "^: " < "$nlist" |
3369 if sort -k 3 </dev
/null
>/dev
/null
2>&1; then
3374 uniq > "$nlist"S
; then
3377 $GREP -v "^: " < "$nlist" > "$nlist"S
3380 if test -f "$nlist"S
; then
3381 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3383 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3386 echo >> "$output_objdir/$my_dlsyms" "\
3388 /* The mapping between symbol names and symbols. */
3393 extern LT_DLSYM_CONST lt_dlsymlist
3394 lt_${my_prefix}_LTX_preloaded_symbols[];
3395 LT_DLSYM_CONST lt_dlsymlist
3396 lt_${my_prefix}_LTX_preloaded_symbols[] =
3398 { \"$my_originator\", (void *) 0 },"
3400 case $need_lib_prefix in
3402 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3405 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3408 echo >> "$output_objdir/$my_dlsyms" "\
3412 /* This works around a problem in FreeBSD linker */
3413 #ifdef FREEBSD_WORKAROUND
3414 static const void *lt_preloaded_setup() {
3415 return lt_${my_prefix}_LTX_preloaded_symbols;
3425 pic_flag_for_symtable
=
3426 case "$compile_command " in
3430 # compiling the symbol table file with pic_flag works around
3431 # a FreeBSD bug that causes programs to crash when -lm is
3432 # linked before any other PIC object. But we must not use
3433 # pic_flag when linking with -static. The problem exists in
3434 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3435 *-*-freebsd2.
*|
*-*-freebsd3.0
*|
*-*-freebsdelf3.0
*)
3436 pic_flag_for_symtable
=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3438 pic_flag_for_symtable
=" $pic_flag" ;;
3440 if test "X$my_pic_p" != Xno
; then
3441 pic_flag_for_symtable
=" $pic_flag"
3448 for arg
in $LTCFLAGS; do
3450 -pie |
-fpie |
-fPIE) ;;
3451 *) func_append symtab_cflags
" $arg" ;;
3455 # Now compile the dynamic symbol file.
3456 func_show_eval
'(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3458 # Clean up the generated files.
3459 func_show_eval
'$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3461 # Transform the symbol file into the correct name.
3462 symfileobj
="$output_objdir/${my_outputname}S.$objext"
3464 *cygwin
* |
*mingw
* |
*cegcc
* )
3465 if test -f "$output_objdir/$my_outputname.def"; then
3466 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3467 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3469 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3470 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3474 compile_command
=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3475 finalize_command
=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3480 func_fatal_error
"unknown suffix for \`$my_dlsyms'"
3484 # We keep going just in case the user didn't refer to
3485 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3486 # really was required.
3488 # Nullify the symbol file.
3489 compile_command
=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3490 finalize_command
=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3494 # func_win32_libid arg
3495 # return the library type of file 'arg'
3497 # Need a lot of goo to handle *both* DLLs and import libs
3498 # Has to be a shell function in order to 'eat' the argument
3499 # that is supplied when $file_magic_command is called.
3500 # Despite the name, also deal with 64 bit binaries.
3504 win32_libid_type
="unknown"
3505 win32_fileres
=`file -L $1 2>/dev/null`
3506 case $win32_fileres in
3507 *ar\ archive\ import\ library
*) # definitely import
3508 win32_libid_type
="x86 archive import"
3510 *ar\ archive
*) # could be an import, or static
3511 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3512 if eval $OBJDUMP -f $1 |
$SED -e '10q' 2>/dev
/null |
3513 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev
/null
; then
3514 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3515 win32_nmres
=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3524 case $win32_nmres in
3525 import
*) win32_libid_type
="x86 archive import";;
3526 *) win32_libid_type
="x86 archive static";;
3531 win32_libid_type
="x86 DLL"
3533 *executable
*) # but shell scripts are "executable" too...
3534 case $win32_fileres in
3535 *MS\ Windows\ PE\ Intel
*)
3536 win32_libid_type
="x86 DLL"
3541 $ECHO "$win32_libid_type"
3544 # func_cygming_dll_for_implib ARG
3546 # Platform-specific function to extract the
3547 # name of the DLL associated with the specified
3548 # import library ARG.
3549 # Invoked by eval'ing the libtool variable
3550 # $sharedlib_from_linklib_cmd
3551 # Result is available in the variable
3552 # $sharedlib_from_linklib_result
3553 func_cygming_dll_for_implib
()
3556 sharedlib_from_linklib_result
=`$DLLTOOL --identify-strict --identify "$1"`
3559 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3561 # The is the core of a fallback implementation of a
3562 # platform-specific function to extract the name of the
3563 # DLL associated with the specified import library LIBNAME.
3565 # SECTION_NAME is either .idata$6 or .idata$7, depending
3566 # on the platform and compiler that created the implib.
3568 # Echos the name of the DLL associated with the
3569 # specified import library.
3570 func_cygming_dll_for_implib_fallback_core
()
3573 match_literal
=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3574 $OBJDUMP -s --section "$1" "$2" 2>/dev
/null |
3575 $SED '/^Contents of section '"$match_literal"':/{
3576 # Place marker at beginning of archive member dllname section
3581 # These lines can sometimes be longer than 43 characters, but
3582 # are always uninteresting
3583 /:[ ]*file format pe[i]\{,1\}-/d
3584 /^In archive [^:]*:/d
3585 # Ensure marker is printed
3587 # Remove all lines with less than 43 characters
3589 # From remaining lines, remove first 43 characters
3592 # Join marker and all lines until next marker into a single line
3593 /^====MARK====/ b para
3602 # Remove trailing dots and whitespace
3606 # we now have a list, one entry per line, of the stringified
3607 # contents of the appropriate section of all members of the
3608 # archive which possess that section. Heuristic: eliminate
3609 # all those which have a first or second character that is
3610 # a '.' (that is, objdump's representation of an unprintable
3611 # character.) This should work for all archives with less than
3612 # 0x302f exports -- but will fail for DLLs whose name actually
3613 # begins with a literal '.' or a single character followed by
3616 # Of those that remain, print the first one.
3617 $SED -e '/^\./d;/^.\./d;q'
3620 # func_cygming_gnu_implib_p ARG
3621 # This predicate returns with zero status (TRUE) if
3622 # ARG is a GNU/binutils-style import library. Returns
3623 # with nonzero status (FALSE) otherwise.
3624 func_cygming_gnu_implib_p
()
3627 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3628 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)$'`
3629 test -n "$func_cygming_gnu_implib_tmp"
3632 # func_cygming_ms_implib_p ARG
3633 # This predicate returns with zero status (TRUE) if
3634 # ARG is an MS-style import library. Returns
3635 # with nonzero status (FALSE) otherwise.
3636 func_cygming_ms_implib_p
()
3639 func_to_tool_file
"$1" func_convert_file_msys_to_w32
3640 func_cygming_ms_implib_tmp
=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3641 test -n "$func_cygming_ms_implib_tmp"
3644 # func_cygming_dll_for_implib_fallback ARG
3645 # Platform-specific function to extract the
3646 # name of the DLL associated with the specified
3647 # import library ARG.
3649 # This fallback implementation is for use when $DLLTOOL
3650 # does not support the --identify-strict option.
3651 # Invoked by eval'ing the libtool variable
3652 # $sharedlib_from_linklib_cmd
3653 # Result is available in the variable
3654 # $sharedlib_from_linklib_result
3655 func_cygming_dll_for_implib_fallback
()
3658 if func_cygming_gnu_implib_p
"$1" ; then
3659 # binutils import library
3660 sharedlib_from_linklib_result
=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3661 elif func_cygming_ms_implib_p
"$1" ; then
3662 # ms-generated import library
3663 sharedlib_from_linklib_result
=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3666 sharedlib_from_linklib_result
=""
3671 # func_extract_an_archive dir oldlib
3672 func_extract_an_archive
()
3675 f_ex_an_ar_dir
="$1"; shift
3676 f_ex_an_ar_oldlib
="$1"
3677 if test "$lock_old_archive_extraction" = yes; then
3678 lockfile
=$f_ex_an_ar_oldlib.lock
3679 until $opt_dry_run ||
ln "$progpath" "$lockfile" 2>/dev
/null
; do
3680 func_echo
"Waiting for $lockfile to be removed"
3684 func_show_eval
"(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3685 'stat=$?; rm -f "$lockfile"; exit $stat'
3686 if test "$lock_old_archive_extraction" = yes; then
3687 $opt_dry_run ||
rm -f "$lockfile"
3689 if ($AR t
"$f_ex_an_ar_oldlib" |
sort |
sort -uc >/dev
/null
2>&1); then
3692 func_fatal_error
"object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3697 # func_extract_archives gentop oldlib ...
3698 func_extract_archives
()
3701 my_gentop
="$1"; shift
3702 my_oldlibs
=${1+"$@"}
3708 for my_xlib
in $my_oldlibs; do
3709 # Extract the objects.
3711 [\\/]* |
[A-Za-z
]:[\\/]*) my_xabs
="$my_xlib" ;;
3712 *) my_xabs
=`pwd`"/$my_xlib" ;;
3714 func_basename
"$my_xlib"
3715 my_xlib
="$func_basename_result"
3718 case " $extracted_archives " in
3720 func_arith
$extracted_serial + 1
3721 extracted_serial
=$func_arith_result
3722 my_xlib_u
=lt
$extracted_serial-$my_xlib ;;
3726 extracted_archives
="$extracted_archives $my_xlib_u"
3727 my_xdir
="$my_gentop/$my_xlib_u"
3729 func_mkdir_p
"$my_xdir"
3733 func_verbose
"Extracting $my_xabs"
3734 # Do not bother doing anything if just a dry run
3736 darwin_orig_dir
=`pwd`
3737 cd $my_xdir ||
exit $?
3738 darwin_archive
=$my_xabs
3740 darwin_base_archive
=`basename "$darwin_archive"`
3741 darwin_arches
=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3742 if test -n "$darwin_arches"; then
3743 darwin_arches
=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3745 func_verbose
"$darwin_base_archive has multiple architectures $darwin_arches"
3746 for darwin_arch
in $darwin_arches ; do
3747 func_mkdir_p
"unfat-$$/${darwin_base_archive}-${darwin_arch}"
3748 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3749 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3750 func_extract_an_archive
"`pwd`" "${darwin_base_archive}"
3752 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3753 done # $darwin_arches
3754 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3755 darwin_filelist
=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3758 for darwin_file
in $darwin_filelist; do
3759 darwin_files
=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3760 $LIPO -create -output "$darwin_file" $darwin_files
3761 done # $darwin_filelist
3763 cd "$darwin_orig_dir"
3766 func_extract_an_archive
"$my_xdir" "$my_xabs"
3771 func_extract_an_archive
"$my_xdir" "$my_xabs"
3774 my_oldobjs
="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3777 func_extract_archives_result
="$my_oldobjs"
3781 # func_emit_wrapper [arg=no]
3783 # Emit a libtool wrapper script on stdout.
3784 # Don't directly open a file because we may want to
3785 # incorporate the script contents within a cygwin/mingw
3786 # wrapper executable. Must ONLY be called from within
3787 # func_mode_link because it depends on a number of variables
3790 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3791 # variable will take. If 'yes', then the emitted script
3792 # will assume that the directory in which it is stored is
3793 # the $objdir directory. This is a cygwin/mingw-specific
3795 func_emit_wrapper
()
3797 func_emit_wrapper_arg1
=${1-no}
3802 # $output - temporary wrapper script for $objdir/$outputname
3803 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3805 # The $output program cannot be directly executed until all the libtool
3806 # libraries that it depends on are installed.
3808 # This wrapper script should never be moved out of the build directory.
3809 # If it is, it will not operate correctly.
3811 # Sed substitution that helps us do robust quoting. It backslashifies
3812 # metacharacters that are still active within double-quoted strings.
3813 sed_quote_subst='$sed_quote_subst'
3815 # Be Bourne compatible
3816 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3819 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3820 # is contrary to our usage. Disable this feature.
3821 alias -g '\${1+\"\$@\"}'='\"\$@\"'
3822 setopt NO_GLOB_SUBST
3824 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3826 BIN_SH=xpg4; export BIN_SH # for Tru64
3827 DUALCASE=1; export DUALCASE # for MKS sh
3829 # The HP-UX ksh and POSIX shell print the target directory to stdout
3831 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3833 relink_command=\"$relink_command\"
3835 # This environment variable determines our operation mode.
3836 if test \"\$libtool_install_magic\" = \"$magic\"; then
3837 # install mode needs the following variables:
3838 generated_by_libtool_version='$macro_version'
3839 notinst_deplibs='$notinst_deplibs'
3841 # When we are sourced in execute mode, \$file and \$ECHO are already set.
3842 if test \"\$libtool_execute_magic\" != \"$magic\"; then
3845 qECHO
=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
3848 # A function that is used when there is no print builtin or printf.
3849 func_fallback_echo ()
3851 eval 'cat <<_LTECHO_EOF
3858 # Very basic option parsing. These options are (a) specific to
3859 # the libtool wrapper, (b) are identical between the wrapper
3860 # /script/ and the wrapper /executable/ which is used only on
3861 # windows platforms, and (c) all begin with the string "--lt-"
3862 # (application programs are unlikely to have options which match
3865 # There are only two supported options: --lt-debug and
3866 # --lt-dump-script. There is, deliberately, no --lt-help.
3868 # The first argument to this parsing function should be the
3869 # script's $0 value, followed by "$@
".
3871 func_parse_lt_options ()
3877 case \"\$lt_opt\" in
3878 --lt-debug) lt_option_debug=1 ;;
3880 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
3881 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
3882 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
3883 cat \"\$lt_dump_D/\$lt_dump_F\"
3887 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
3893 # Print the debug banner immediately:
3894 if test -n \"\$lt_option_debug\"; then
3895 echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
3899 # Used when --lt-debug. Prints its arguments to stdout
3900 # (redirection is the responsibility of the caller)
3901 func_lt_dump_args ()
3906 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
3907 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
3911 # Core function for launching the target application
3912 func_exec_program_core ()
3916 # Backslashes separate directories on plain windows
3917 *-*-mingw |
*-*-os2* |
*-cegcc*)
3919 if test -n \"\$lt_option_debug\"; then
3920 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
3921 func_lt_dump_args \${1+\"\$@\"} 1>&2
3923 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3929 if test -n \"\$lt_option_debug\"; then
3930 \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
3931 func_lt_dump_args \${1+\"\$@\"} 1>&2
3933 exec \"\$progdir/\$program\" \${1+\"\$@\"}
3938 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3942 # A function to encapsulate launching the target application
3943 # Strips options in the --lt-* namespace from \$@ and
3944 # launches target application with the remaining arguments.
3945 func_exec_program ()
3953 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
3958 func_exec_program_core \${1+\"\$@\"}
3962 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
3964 # Find the directory that this script lives in.
3965 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
3966 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3968 # Follow symbolic links until we get to the real thisdir.
3969 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
3970 while test -n \"\$file\"; do
3971 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
3973 # If there was a directory component, then change thisdir.
3974 if test \"x\$destdir\" != \"x\$file\"; then
3975 case \"\$destdir\" in
3976 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3977 *) thisdir=\"\$thisdir/\$destdir\" ;;
3981 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
3982 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
3985 # Usually 'no', except on cygwin/mingw when embedded into
3987 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
3988 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3989 # special case for '.'
3990 if test \"\$thisdir\" = \".\"; then
3993 # remove .libs from thisdir
3994 case \"\$thisdir\" in
3995 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
3996 $objdir ) thisdir=. ;;
4000 # Try to get the absolute directory name.
4001 absdir=\`cd \"\$thisdir\" && pwd\`
4002 test -n \"\$absdir\" && thisdir=\"\$absdir\"
4005 if test "$fast_install" = yes; then
4007 program=lt-'$outputname'$exeext
4008 progdir=\"\$thisdir/$objdir\"
4010 if test ! -f \"\$progdir/\$program\" ||
4011 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4012 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4014 file=\"\$\$-\$program\"
4016 if test ! -d \"\$progdir\"; then
4017 $MKDIR \"\$progdir\"
4019 $RM \"\$progdir/\$file\"
4024 # relink executable if necessary
4025 if test -n \"\$relink_command\"; then
4026 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4028 $ECHO \"\$relink_command_output\" >&2
4029 $RM \"\$progdir/\$file\"
4034 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4035 { $RM \"\$progdir/\$program\";
4036 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4037 $RM \"\$progdir/\$file\"
4041 program='$outputname'
4042 progdir=\"\$thisdir/$objdir\"
4048 if test -f \"\$progdir/\$program\"; then"
4050 # fixup the dll searchpath if we need to.
4052 # Fix the DLL searchpath if we need to. Do this before prepending
4053 # to shlibpath, because on Windows, both are PATH and uninstalled
4054 # libraries must come first.
4055 if test -n "$dllsearchpath"; then
4057 # Add the dll search path components to the executable PATH
4058 PATH=$dllsearchpath:\$PATH
4062 # Export our shlibpath_var if we have one.
4063 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4065 # Add our own library path to $shlibpath_var
4066 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4068 # Some systems cannot cope with colon-terminated $shlibpath_var
4069 # The second colon is a workaround for a bug in BeOS R4 sed
4070 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
4072 export $shlibpath_var
4077 if test \"\$libtool_execute_magic\" != \"$magic\"; then
4078 # Run the actual program with our arguments.
4079 func_exec_program \${1+\"\$@\"}
4082 # The program doesn't exist.
4083 \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
4084 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
4085 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
4093 # func_emit_cwrapperexe_src
4094 # emit the source code for a wrapper executable on stdout
4095 # Must ONLY be called from within func_mode_link because
4096 # it depends on a number of variable set therein.
4097 func_emit_cwrapperexe_src
()
4101 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4102 Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
4104 The $output program cannot be directly executed until all the libtool
4105 libraries that it depends on are installed.
4107 This wrapper executable should never be moved out of the build directory.
4108 If it is, it will not operate correctly.
4113 # define _CRT_SECURE_NO_DEPRECATE 1
4118 # include <direct.h>
4119 # include <process.h>
4122 # include <unistd.h>
4123 # include <stdint.h>
4135 #include <sys/stat.h>
4137 /* declarations of non-ANSI functions */
4138 #if defined(__MINGW32__)
4139 # ifdef __STRICT_ANSI__
4140 int _putenv (const char *);
4142 #elif defined(__CYGWIN__)
4143 # ifdef __STRICT_ANSI__
4144 char *realpath (const char *, char *);
4145 int putenv (char *);
4146 int setenv (const char *, const char *, int);
4148 /* #elif defined (other platforms) ... */
4151 /* portability defines, excluding path handling macros */
4152 #if defined(_MSC_VER)
4153 # define setmode _setmode
4155 # define chmod _chmod
4156 # define getcwd _getcwd
4157 # define putenv _putenv
4158 # define S_IXUSR _S_IEXEC
4159 # ifndef _INTPTR_T_DEFINED
4160 # define _INTPTR_T_DEFINED
4161 # define intptr_t int
4163 #elif defined(__MINGW32__)
4164 # define setmode _setmode
4166 # define chmod _chmod
4167 # define getcwd _getcwd
4168 # define putenv _putenv
4169 #elif defined(__CYGWIN__)
4170 # define HAVE_SETENV
4171 # define FOPEN_WB "wb"
4172 /* #elif defined (other platforms) ... */
4175 #if defined(PATH_MAX)
4176 # define LT_PATHMAX PATH_MAX
4177 #elif defined(MAXPATHLEN)
4178 # define LT_PATHMAX MAXPATHLEN
4180 # define LT_PATHMAX 1024
4190 /* path handling portability macros */
4191 #ifndef DIR_SEPARATOR
4192 # define DIR_SEPARATOR '/'
4193 # define PATH_SEPARATOR ':'
4196 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4198 # define HAVE_DOS_BASED_FILE_SYSTEM
4199 # define FOPEN_WB "wb"
4200 # ifndef DIR_SEPARATOR_2
4201 # define DIR_SEPARATOR_2 '\\'
4203 # ifndef PATH_SEPARATOR_2
4204 # define PATH_SEPARATOR_2 ';'
4208 #ifndef DIR_SEPARATOR_2
4209 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4210 #else /* DIR_SEPARATOR_2 */
4211 # define IS_DIR_SEPARATOR(ch) \
4212 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4213 #endif /* DIR_SEPARATOR_2 */
4215 #ifndef PATH_SEPARATOR_2
4216 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
4217 #else /* PATH_SEPARATOR_2 */
4218 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
4219 #endif /* PATH_SEPARATOR_2 */
4222 # define FOPEN_WB "w"
4225 # define _O_BINARY 0
4228 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
4229 #define XFREE(stale) do { \
4230 if (stale) { free ((void *) stale); stale = 0; } \
4233 #if defined(LT_DEBUGWRAPPER)
4234 static int lt_debug = 1;
4236 static int lt_debug = 0;
4239 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
4241 void *xmalloc (size_t num);
4242 char *xstrdup (const char *string);
4243 const char *base_name (const char *name);
4244 char *find_executable (const char *wrapper);
4245 char *chase_symlinks (const char *pathspec);
4246 int make_executable (const char *path);
4247 int check_executable (const char *path);
4248 char *strendzap (char *str, const char *pat);
4249 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
4250 void lt_fatal (const char *file, int line, const char *message, ...);
4251 static const char *nonnull (const char *s);
4252 static const char *nonempty (const char *s);
4253 void lt_setenv (const char *name, const char *value);
4254 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
4255 void lt_update_exe_path (const char *name, const char *value);
4256 void lt_update_lib_path (const char *name, const char *value);
4257 char **prepare_spawn (char **argv);
4258 void lt_dump_script (FILE *f);
4262 volatile const char * MAGIC_EXE = "$magic_exe";
4263 const char * LIB_PATH_VARNAME = "$shlibpath_var";
4266 if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4267 func_to_host_path "$temp_rpath"
4269 const char * LIB_PATH_VALUE = "$func_to_host_path_result";
4273 const char
* LIB_PATH_VALUE
= "";
4277 if test -n "$dllsearchpath"; then
4278 func_to_host_path
"$dllsearchpath:"
4280 const char * EXE_PATH_VARNAME = "PATH";
4281 const char * EXE_PATH_VALUE = "$func_to_host_path_result";
4285 const char * EXE_PATH_VARNAME = "";
4286 const char * EXE_PATH_VALUE = "";
4290 if test "$fast_install" = yes; then
4292 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
4296 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
4303 #define LTWRAPPER_OPTION_PREFIX "--lt-"
4305 static const char
*ltwrapper_option_prefix
= LTWRAPPER_OPTION_PREFIX
;
4306 static const char
*dumpscript_opt
= LTWRAPPER_OPTION_PREFIX
"dump-script";
4307 static const char
*debug_opt
= LTWRAPPER_OPTION_PREFIX
"debug";
4310 main
(int argc
, char
*argv
[])
4315 char
*actual_cwrapper_path
;
4316 char
*actual_cwrapper_name
;
4319 intptr_t rval
= 127;
4323 program_name
= (char
*) xstrdup
(base_name
(argv
[0]));
4324 newargz
= XMALLOC
(char
*, argc
+ 1);
4326 /* very simple arg parsing
; don
't want to rely on getopt
4327 * also, copy all non cwrapper options to newargz, except
4328 * argz[0], which is handled differently
4331 for (i = 1; i < argc; i++)
4333 if (strcmp (argv[i], dumpscript_opt) == 0)
4337 *mingw* | *cygwin* )
4338 # make stdout use "unix" line endings
4339 echo " setmode(1,_O_BINARY);"
4344 lt_dump_script (stdout);
4347 if (strcmp (argv[i], debug_opt) == 0)
4352 if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
4354 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4355 namespace, but it is not one of the ones we know about and
4356 have already dealt with, above (inluding dump-script), then
4357 report an error. Otherwise, targets might begin to believe
4358 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4359 namespace. The first time any user complains about this, we'll
4360 need to
make LTWRAPPER_OPTION_PREFIX a configure-time option
4361 or a configure.ac-settable value.
4363 lt_fatal
(__FILE__
, __LINE__
,
4364 "unrecognized %s option: '%s'",
4365 ltwrapper_option_prefix
, argv
[i
]);
4368 newargz
[++newargc
] = xstrdup
(argv
[i
]);
4370 newargz
[++newargc
] = NULL
;
4374 /* The GNU banner must be the first non-error debug message */
4375 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
4378 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
4379 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
4381 tmp_pathspec = find_executable (argv[0]);
4382 if (tmp_pathspec == NULL)
4383 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
4384 lt_debugprintf (__FILE__, __LINE__,
4385 "(main) found exe (before symlink chase) at: %s\n",
4388 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
4389 lt_debugprintf (__FILE__, __LINE__,
4390 "(main) found exe (after symlink chase) at: %s\n",
4391 actual_cwrapper_path);
4392 XFREE (tmp_pathspec);
4394 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
4395 strendzap (actual_cwrapper_path, actual_cwrapper_name);
4397 /* wrapper name transforms */
4398 strendzap (actual_cwrapper_name, ".exe");
4399 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
4400 XFREE (actual_cwrapper_name);
4401 actual_cwrapper_name = tmp_pathspec;
4404 /* target_name transforms -- use actual target program name; might have lt- prefix */
4405 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
4406 strendzap (target_name, ".exe");
4407 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
4408 XFREE (target_name);
4409 target_name = tmp_pathspec;
4412 lt_debugprintf (__FILE__, __LINE__,
4413 "(main) libtool target name: %s\n",
4419 XMALLOC (char, (strlen (actual_cwrapper_path) +
4420 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
4421 strcpy (newargz[0], actual_cwrapper_path);
4422 strcat (newargz[0], "$objdir");
4423 strcat (newargz[0], "/");
4427 /* stop here
, and copy so we don
't have to do this twice */
4428 tmp_pathspec = xstrdup (newargz[0]);
4430 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
4431 strcat (newargz[0], actual_cwrapper_name);
4433 /* DO want the lt- prefix here if it exists, so use target_name */
4434 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
4435 XFREE (tmp_pathspec);
4436 tmp_pathspec = NULL;
4444 while ((p = strchr (newargz[0], '\\')) != NULL)
4448 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
4458 XFREE (target_name);
4459 XFREE (actual_cwrapper_path);
4460 XFREE (actual_cwrapper_name);
4462 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
4463 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
4464 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
4465 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
4466 because on Windows, both *_VARNAMEs are PATH but uninstalled
4467 libraries must come first. */
4468 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
4469 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
4471 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
4472 nonnull (lt_argv_zero));
4473 for (i = 0; i < newargc; i++)
4475 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
4476 i, nonnull (newargz[i]));
4484 /* execv doesn't actually work on mingw as expected on unix
*/
4485 newargz
= prepare_spawn
(newargz
);
4486 rval
= _spawnv
(_P_WAIT
, lt_argv_zero
, (const char
* const
*) newargz
);
4489 /* failed to start process
*/
4490 lt_debugprintf
(__FILE__
, __LINE__
,
4491 "(main) failed to launch target \"%s\": %s\n",
4492 lt_argv_zero
, nonnull
(strerror
(errno
)));
4500 execv (lt_argv_zero, newargz);
4501 return rval; /* =127, but avoids unused variable warning */
4510 xmalloc
(size_t num
)
4512 void
*p
= (void
*) malloc
(num
);
4514 lt_fatal
(__FILE__
, __LINE__
, "memory exhausted");
4520 xstrdup
(const char
*string
)
4522 return string ? strcpy
((char
*) xmalloc
(strlen
(string
) + 1),
4527 base_name
(const char
*name
)
4531 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4532 /* Skip over the disk name
in MSDOS pathnames.
*/
4533 if (isalpha
((unsigned char
) name
[0]) && name
[1] == ':')
4537 for (base
= name
; *name
; name
++)
4538 if (IS_DIR_SEPARATOR
(*name
))
4544 check_executable
(const char
*path
)
4548 lt_debugprintf
(__FILE__
, __LINE__
, "(check_executable): %s\n",
4550 if ((!path
) ||
(!*path
))
4553 if ((stat
(path
, &st
) >= 0)
4554 && (st.st_mode
& (S_IXUSR | S_IXGRP | S_IXOTH
)))
4561 make_executable
(const char
*path
)
4566 lt_debugprintf
(__FILE__
, __LINE__
, "(make_executable): %s\n",
4568 if ((!path
) ||
(!*path
))
4571 if (stat
(path
, &st
) >= 0)
4573 rval
= chmod (path
, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR
);
4578 /* Searches
for the full path of the wrapper. Returns
4579 newly allocated full path name
if found
, NULL otherwise
4580 Does not chase symlinks
, even on platforms that support them.
4583 find_executable
(const char
*wrapper
)
4588 /* static buffer
for getcwd
*/
4589 char tmp
[LT_PATHMAX
+ 1];
4593 lt_debugprintf
(__FILE__
, __LINE__
, "(find_executable): %s\n",
4594 nonempty
(wrapper
));
4596 if ((wrapper
== NULL
) ||
(*wrapper
== '\0'))
4599 /* Absolute path?
*/
4600 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4601 if (isalpha
((unsigned char
) wrapper
[0]) && wrapper
[1] == ':')
4603 concat_name
= xstrdup
(wrapper
);
4604 if (check_executable
(concat_name
))
4606 XFREE
(concat_name
);
4611 if (IS_DIR_SEPARATOR
(wrapper
[0]))
4613 concat_name
= xstrdup
(wrapper
);
4614 if (check_executable
(concat_name
))
4616 XFREE
(concat_name
);
4618 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4622 for (p
= wrapper
; *p
; p
++)
4630 /* no slashes
; search PATH
*/
4631 const char
*path
= getenv
("PATH");
4634 for (p
= path
; *p
; p
= p_next
)
4638 for (q
= p
; *q
; q
++)
4639 if (IS_PATH_SEPARATOR
(*q
))
4642 p_next
= (*q
== '\0' ? q
: q
+ 1);
4645 /* empty path
: current directory
*/
4646 if (getcwd
(tmp
, LT_PATHMAX
) == NULL
)
4647 lt_fatal
(__FILE__
, __LINE__
, "getcwd failed: %s",
4648 nonnull
(strerror
(errno
)));
4649 tmp_len
= strlen
(tmp
);
4651 XMALLOC
(char
, tmp_len
+ 1 + strlen
(wrapper
) + 1);
4652 memcpy
(concat_name
, tmp
, tmp_len
);
4653 concat_name
[tmp_len
] = '/';
4654 strcpy
(concat_name
+ tmp_len
+ 1, wrapper
);
4659 XMALLOC
(char
, p_len
+ 1 + strlen
(wrapper
) + 1);
4660 memcpy
(concat_name
, p
, p_len
);
4661 concat_name
[p_len
] = '/';
4662 strcpy
(concat_name
+ p_len
+ 1, wrapper
);
4664 if (check_executable
(concat_name
))
4666 XFREE
(concat_name
);
4669 /* not found
in PATH
; assume curdir
*/
4671 /* Relative path | not found
in path
: prepend cwd
*/
4672 if (getcwd
(tmp
, LT_PATHMAX
) == NULL
)
4673 lt_fatal
(__FILE__
, __LINE__
, "getcwd failed: %s",
4674 nonnull
(strerror
(errno
)));
4675 tmp_len
= strlen
(tmp
);
4676 concat_name
= XMALLOC
(char
, tmp_len
+ 1 + strlen
(wrapper
) + 1);
4677 memcpy
(concat_name
, tmp
, tmp_len
);
4678 concat_name
[tmp_len
] = '/';
4679 strcpy
(concat_name
+ tmp_len
+ 1, wrapper
);
4681 if (check_executable
(concat_name
))
4683 XFREE
(concat_name
);
4688 chase_symlinks
(const char
*pathspec
)
4691 return xstrdup
(pathspec
);
4693 char buf
[LT_PATHMAX
];
4695 char
*tmp_pathspec
= xstrdup
(pathspec
);
4697 int has_symlinks
= 0;
4698 while (strlen
(tmp_pathspec
) && !has_symlinks
)
4700 lt_debugprintf
(__FILE__
, __LINE__
,
4701 "checking path component for symlinks: %s\n",
4703 if (lstat
(tmp_pathspec
, &s
) == 0)
4705 if (S_ISLNK
(s.st_mode
) != 0)
4711 /* search backwards
for last DIR_SEPARATOR
*/
4712 p
= tmp_pathspec
+ strlen
(tmp_pathspec
) - 1;
4713 while ((p
> tmp_pathspec
) && (!IS_DIR_SEPARATOR
(*p
)))
4715 if ((p
== tmp_pathspec
) && (!IS_DIR_SEPARATOR
(*p
)))
4717 /* no
more DIR_SEPARATORS left
*/
4724 lt_fatal
(__FILE__
, __LINE__
,
4725 "error accessing file \"%s\": %s",
4726 tmp_pathspec
, nonnull
(strerror
(errno
)));
4729 XFREE
(tmp_pathspec
);
4733 return xstrdup
(pathspec
);
4736 tmp_pathspec
= realpath
(pathspec
, buf
);
4737 if (tmp_pathspec
== 0)
4739 lt_fatal
(__FILE__
, __LINE__
,
4740 "could not follow symlinks for %s", pathspec
);
4742 return xstrdup
(tmp_pathspec
);
4747 strendzap
(char
*str
, const char
*pat
)
4751 assert
(str
!= NULL
);
4752 assert
(pat
!= NULL
);
4755 patlen
= strlen
(pat
);
4759 str
+= len
- patlen
;
4760 if (strcmp
(str
, pat
) == 0)
4767 lt_debugprintf
(const char
*file, int line
, const char
*fmt, ...
)
4772 (void
) fprintf
(stderr
, "%s:%s:%d: ", program_name
, file, line
);
4773 va_start
(args
, fmt);
4774 (void
) vfprintf
(stderr
, fmt, args
);
4780 lt_error_core
(int exit_status
, const char
*file,
4781 int line
, const char
*mode
,
4782 const char
*message
, va_list ap
)
4784 fprintf
(stderr
, "%s:%s:%d: %s: ", program_name
, file, line
, mode
);
4785 vfprintf
(stderr
, message
, ap
);
4786 fprintf
(stderr
, ".\n");
4788 if (exit_status
>= 0)
4793 lt_fatal
(const char
*file, int line
, const char
*message
, ...
)
4796 va_start
(ap
, message
);
4797 lt_error_core
(EXIT_FAILURE
, file, line
, "FATAL", message
, ap
);
4802 nonnull
(const char
*s
)
4804 return s ? s
: "(null)";
4808 nonempty
(const char
*s
)
4810 return (s
&& !*s
) ?
"(empty)" : nonnull
(s
);
4814 lt_setenv
(const char
*name
, const char
*value
)
4816 lt_debugprintf
(__FILE__
, __LINE__
,
4817 "(lt_setenv) setting '%s' to '%s'\n",
4818 nonnull
(name
), nonnull
(value
));
4821 /* always
make a copy
, for consistency with
!HAVE_SETENV
*/
4822 char
*str
= xstrdup
(value
);
4823 setenv
(name
, str
, 1);
4825 int len
= strlen
(name
) + 1 + strlen
(value
) + 1;
4826 char
*str
= XMALLOC
(char
, len
);
4827 sprintf
(str
, "%s=%s", name
, value
);
4828 if (putenv
(str
) != EXIT_SUCCESS
)
4837 lt_extend_str
(const char
*orig_value
, const char
*add
, int to_end
)
4840 if (orig_value
&& *orig_value
)
4842 int orig_value_len
= strlen
(orig_value
);
4843 int add_len
= strlen
(add
);
4844 new_value
= XMALLOC
(char
, add_len
+ orig_value_len
+ 1);
4847 strcpy
(new_value
, orig_value
);
4848 strcpy
(new_value
+ orig_value_len
, add
);
4852 strcpy
(new_value
, add
);
4853 strcpy
(new_value
+ add_len
, orig_value
);
4858 new_value
= xstrdup
(add
);
4864 lt_update_exe_path
(const char
*name
, const char
*value
)
4866 lt_debugprintf
(__FILE__
, __LINE__
,
4867 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4868 nonnull
(name
), nonnull
(value
));
4870 if (name
&& *name
&& value
&& *value
)
4872 char
*new_value
= lt_extend_str
(getenv
(name
), value
, 0);
4873 /* some systems can
't cope with a ':'-terminated path #' */
4874 int len
= strlen
(new_value
);
4875 while (((len
= strlen
(new_value
)) > 0) && IS_PATH_SEPARATOR
(new_value
[len-1
]))
4877 new_value
[len-1
] = '\0';
4879 lt_setenv
(name
, new_value
);
4885 lt_update_lib_path
(const char
*name
, const char
*value
)
4887 lt_debugprintf
(__FILE__
, __LINE__
,
4888 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4889 nonnull
(name
), nonnull
(value
));
4891 if (name
&& *name
&& value
&& *value
)
4893 char
*new_value
= lt_extend_str
(getenv
(name
), value
, 0);
4894 lt_setenv
(name
, new_value
);
4904 /* Prepares an argument vector before calling spawn().
4905 Note that spawn() does not by itself call the command interpreter
4906 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
4907 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
4909 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
4910 }) ? "cmd.exe" : "command.com").
4911 Instead it simply concatenates the arguments, separated by ' ', and calls
4912 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
4913 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
4915 - Space and tab are interpreted as delimiters. They are not treated as
4916 delimiters if they are surrounded by double quotes: "...".
4917 - Unescaped double quotes are removed from the input. Their only effect is
4918 that within double quotes, space and tab are treated like normal
4920 - Backslashes not followed by double quotes are not special.
4921 - But 2*n+1 backslashes followed by a double quote become
4922 n backslashes followed by a double quote (n >= 0):
4927 #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"
4928 #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"
4930 prepare_spawn (char **argv)
4936 /* Count number of arguments. */
4937 for (argc = 0; argv[argc] != NULL; argc++)
4940 /* Allocate new argument vector. */
4941 new_argv = XMALLOC (char *, argc + 1);
4943 /* Put quoted arguments into the new argument vector. */
4944 for (i = 0; i < argc; i++)
4946 const char *string = argv[i];
4948 if (string[0] == '\0')
4949 new_argv[i] = xstrdup ("\"\"");
4950 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
4952 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
4954 unsigned int backslashes;
4956 char *quoted_string;
4963 for (s = string; *s != '\0'; s++)
4967 length += backslashes + 1;
4975 length += backslashes + 1;
4977 quoted_string = XMALLOC (char, length + 1);
4983 for (s = string; *s != '\0'; s++)
4989 for (j = backslashes + 1; j > 0; j--)
5001 for (j = backslashes; j > 0; j--)
5007 new_argv[i] = quoted_string;
5010 new_argv[i] = (char *) string;
5012 new_argv[argc] = NULL;
5021 void lt_dump_script
(FILE
* f
)
5024 func_emit_wrapper
yes |
5026 s/^\(.\{79\}\)\(..*\)/\1\
5031 s/\([^\n]*\).*/ fputs ("\1", f);/p
5038 # end: func_emit_cwrapperexe_src
5040 # func_win32_import_lib_p ARG
5041 # True if ARG is an import lib, as indicated by $file_magic_cmd
5042 func_win32_import_lib_p ()
5045 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
5051 # func_mode_link arg...
5056 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5057 # It is impossible to link a dll without this setting, and
5058 # we shouldn't force the makefile maintainer to figure out
5059 # which system we are compiling for in order to pass an extra
5060 # flag for every libtool invocation.
5061 # allow_undefined=no
5063 # FIXME: Unfortunately, there are problems with the above when trying
5064 # to make a dll which has undefined symbols, in which case not
5065 # even a static library is built. For now, we need to specify
5066 # -no-undefined on the libtool link line when we can be certain
5067 # that all symbols are satisfied, otherwise we get a static library.
5074 libtool_args=$nonopt
5075 base_compile="$nonopt $@"
5076 compile_command=$nonopt
5077 finalize_command=$nonopt
5090 lib_search_path=`pwd`
5092 new_inherited_linker_flags=
5101 export_symbols_regex=
5109 precious_files_regex=
5110 prefer_static_libs=no
5123 single_module="${wl}-single_module"
5124 func_infer_tag $base_compile
5126 # We need to know -static, to get the right output filenames.
5131 test "$build_libtool_libs" != yes && \
5132 func_fatal_configuration "can not build a shared library"
5136 -all-static | -static | -static-libtool-libs)
5139 if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
5140 func_warning "complete static linking is impossible in this configuration"
5142 if test -n "$link_static_flag"; then
5143 dlopen_self=$dlopen_self_static
5145 prefer_static_libs=yes
5148 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5149 dlopen_self=$dlopen_self_static
5151 prefer_static_libs=built
5153 -static-libtool-libs)
5154 if test -z "$pic_flag" && test -n "$link_static_flag"; then
5155 dlopen_self=$dlopen_self_static
5157 prefer_static_libs=yes
5160 build_libtool_libs=no
5167 # See if our shared archives depend on static archives.
5168 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
5170 # Go through the arguments, transforming them on the way.
5171 while test "$#" -gt 0; do
5174 func_quote_for_eval "$arg"
5175 qarg=$func_quote_for_eval_unquoted_result
5176 func_append libtool_args " $func_quote_for_eval_result"
5178 # If the previous option needs an argument, assign it.
5179 if test -n "$prev"; then
5182 func_append compile_command " @OUTPUT@"
5183 func_append finalize_command " @OUTPUT@"
5194 if test "$preload" = no; then
5195 # Add the symbol object into the linking commands.
5196 func_append compile_command " @SYMFILE@"
5197 func_append finalize_command " @SYMFILE@"
5201 *.la | *.lo) ;; # We handle these cases below.
5203 if test "$dlself" = no; then
5211 if test "$prev" = dlprefiles; then
5213 elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
5223 if test "$prev" = dlfiles; then
5224 func_append dlfiles " $arg"
5226 func_append dlprefiles " $arg"
5234 export_symbols="$arg"
5236 || func_fatal_error "symbol file \`$arg' does not exist"
5241 export_symbols_regex="$arg"
5249 *" $qarg.ltframework "*) ;;
5250 *) func_append deplibs " $qarg.ltframework" # this is fixed later
5259 inst_prefix_dir="$arg"
5264 if test -f "$arg"; then
5267 for fil in `cat "$save_arg"`
5269 # func_append moreargs " $fil"
5271 # A libtool-controlled object.
5273 # Check to see that this really is a libtool object.
5274 if func_lalib_unsafe_p "$arg"; then
5281 if test -z "$pic_object" ||
5282 test -z "$non_pic_object" ||
5283 test "$pic_object" = none &&
5284 test "$non_pic_object" = none; then
5285 func_fatal_error "cannot find name of object for \`$arg'"
5288 # Extract subdirectory from the argument.
5289 func_dirname "$arg" "/" ""
5290 xdir="$func_dirname_result"
5292 if test "$pic_object" != none; then
5293 # Prepend the subdirectory the object is found in.
5294 pic_object="$xdir$pic_object"
5296 if test "$prev" = dlfiles; then
5297 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5298 func_append dlfiles " $pic_object"
5302 # If libtool objects are unsupported, then we need to preload.
5307 # CHECK ME: I think I busted this. -Ossama
5308 if test "$prev" = dlprefiles; then
5309 # Preload the old-style object.
5310 func_append dlprefiles " $pic_object"
5315 func_append libobjs " $pic_object"
5320 if test "$non_pic_object" != none; then
5321 # Prepend the subdirectory the object is found in.
5322 non_pic_object="$xdir$non_pic_object"
5324 # A standard non-PIC object
5325 func_append non_pic_objects " $non_pic_object"
5326 if test -z "$pic_object" || test "$pic_object" = none ; then
5327 arg="$non_pic_object"
5330 # If the PIC object exists, use it instead.
5331 # $xdir was prepended to $pic_object above.
5332 non_pic_object="$pic_object"
5333 func_append non_pic_objects " $non_pic_object"
5336 # Only an error if not doing a dry-run.
5337 if $opt_dry_run; then
5338 # Extract subdirectory from the argument.
5339 func_dirname "$arg" "/" ""
5340 xdir="$func_dirname_result"
5343 pic_object=$xdir$objdir/$func_lo2o_result
5344 non_pic_object=$xdir$func_lo2o_result
5345 func_append libobjs " $pic_object"
5346 func_append non_pic_objects " $non_pic_object"
5348 func_fatal_error "\`$arg' is not a valid libtool object"
5353 func_fatal_error "link input file \`$arg' does not exist"
5360 precious_files_regex="$arg"
5370 # We need an absolute path.
5372 [\\/]* | [A-Za-z]:[\\/]*) ;;
5374 func_fatal_error "only absolute run-paths are allowed"
5377 if test "$prev" = rpath; then
5380 *) func_append rpath " $arg" ;;
5385 *) func_append xrpath " $arg" ;;
5397 func_append weak_libs " $arg"
5402 func_append linker_flags " $qarg"
5403 func_append compiler_flags " $qarg"
5405 func_append compile_command " $qarg"
5406 func_append finalize_command " $qarg"
5410 func_append compiler_flags " $qarg"
5412 func_append compile_command " $qarg"
5413 func_append finalize_command " $qarg"
5417 func_append linker_flags " $qarg"
5418 func_append compiler_flags " $wl$qarg"
5420 func_append compile_command " $wl$qarg"
5421 func_append finalize_command " $wl$qarg"
5425 eval "$prev=\"\$arg\""
5430 fi # test -n "$prev"
5436 if test -n "$link_static_flag"; then
5437 # See comment for -static flag below, for more details.
5438 func_append compile_command " $link_static_flag"
5439 func_append finalize_command " $link_static_flag"
5445 # FIXME: remove this flag sometime in the future.
5446 func_fatal_error "\`-allow-undefined' must not be used because it is the default"
5474 -export-symbols | -export-symbols-regex)
5475 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
5476 func_fatal_error "more than one -exported-symbols argument is not allowed"
5478 if test "X$arg" = "X-export-symbols"; then
5496 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
5497 # so, if we see these flags be careful not to treat them like -L
5499 case $with_gcc/$host in
5500 no/*-*-irix* | /*-*-irix*)
5501 func_append compile_command " $arg"
5502 func_append finalize_command " $arg"
5509 func_stripname "-L" '' "$arg"
5510 if test -z "$func_stripname_result"; then
5511 if test "$#" -gt 0; then
5512 func_fatal_error "require no space between \`-L' and \`$1'"
5514 func_fatal_error "need path for \`-L' option"
5517 func_resolve_sysroot "$func_stripname_result"
5518 dir=$func_resolve_sysroot_result
5519 # We need an absolute path.
5521 [\\/]* | [A-Za-z]:[\\/]*) ;;
5523 absdir=`cd "$dir" && pwd`
5524 test -z "$absdir" && \
5525 func_fatal_error "cannot determine absolute directory name of \`$dir'"
5530 *" -L$dir "* | *" $arg "*)
5531 # Will only happen for absolute or sysroot arguments
5534 # Preserve sysroot, but never include relative directories
5536 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
5537 *) func_append deplibs " -L$dir" ;;
5539 func_append lib_search_path " $dir"
5543 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
5544 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
5545 case :$dllsearchpath: in
5547 ::) dllsearchpath=$dir;;
5548 *) func_append dllsearchpath ":$dir";;
5550 case :$dllsearchpath: in
5551 *":$testbindir:"*) ;;
5552 ::) dllsearchpath=$testbindir;;
5553 *) func_append dllsearchpath ":$testbindir";;
5561 if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5563 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
5564 # These systems don't actually have a C or math library (as such)
5568 # These systems don't actually have a C library (as such)
5569 test "X$arg" = "X-lc" && continue
5571 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
5572 # Do not include libc due to us having libc/libc_r.
5573 test "X$arg" = "X-lc" && continue
5575 *-*-rhapsody* | *-*-darwin1.[012])
5576 # Rhapsody C and math libraries are in the System framework
5577 func_append deplibs " System.ltframework"
5580 *-*-sco3.2v5* | *-*-sco5v6*)
5581 # Causes problems with __ctype
5582 test "X$arg" = "X-lc" && continue
5584 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5585 # Compiler inserts libc in the correct place for threads to work
5586 test "X$arg" = "X-lc" && continue
5589 elif test "X$arg" = "X-lc_r"; then
5591 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
5592 # Do not include libc_r directly, use -pthread flag.
5597 func_append deplibs " $arg"
5606 # Tru64 UNIX uses -model [arg] to determine the layout of C++
5607 # classes, name mangling, and exception handling.
5608 # Darwin uses the -arch flag to determine output architecture.
5609 -model|-arch|-isysroot|--sysroot)
5610 func_append compiler_flags " $arg"
5611 func_append compile_command " $arg"
5612 func_append finalize_command " $arg"
5617 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
5618 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
5619 func_append compiler_flags " $arg"
5620 func_append compile_command " $arg"
5621 func_append finalize_command " $arg"
5622 func_append deplibs " $arg"
5623 case "$new_inherited_linker_flags " in
5625 * ) func_append new_inherited_linker_flags " $arg" ;;
5631 single_module="${wl}-multi_module"
5642 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5643 # The PATH hackery in wrapper scripts is required on Windows
5644 # and Darwin in order for the loader to find any dlls it needs.
5645 func_warning "\`-no-install' is ignored for $host"
5646 func_warning "assuming \`-no-fast-install' instead"
5649 *) no_install=yes ;;
5666 -precious-files-regex)
5687 func_stripname '-R' '' "$arg"
5688 dir=$func_stripname_result
5689 # We need an absolute path.
5691 [\\/]* | [A-Za-z]:[\\/]*) ;;
5693 func_stripname '=' '' "$dir"
5694 dir=$lt_sysroot$func_stripname_result
5697 func_fatal_error "only absolute run-paths are allowed"
5702 *) func_append xrpath " $dir" ;;
5708 # The effects of -shared are defined in a previous loop.
5717 -static | -static-libtool-libs)
5718 # The effects of -static are defined in a previous loop.
5719 # We used to do the same as -all-static on platforms that
5720 # didn't have a PIC flag, but the assumption that the effects
5721 # would be equivalent was wrong. It would break on at least
5722 # Digital Unix and AIX.
5748 func_stripname '-Wc,' '' "$arg"
5749 args=$func_stripname_result
5751 save_ifs="$IFS"; IFS=','
5752 for flag in $args; do
5754 func_quote_for_eval "$flag"
5755 func_append arg " $func_quote_for_eval_result"
5756 func_append compiler_flags " $func_quote_for_eval_result"
5759 func_stripname ' ' '' "$arg"
5760 arg=$func_stripname_result
5764 func_stripname '-Wl,' '' "$arg"
5765 args=$func_stripname_result
5767 save_ifs="$IFS"; IFS=','
5768 for flag in $args; do
5770 func_quote_for_eval "$flag"
5771 func_append arg " $wl$func_quote_for_eval_result"
5772 func_append compiler_flags " $wl$func_quote_for_eval_result"
5773 func_append linker_flags " $func_quote_for_eval_result"
5776 func_stripname ' ' '' "$arg"
5777 arg=$func_stripname_result
5797 func_quote_for_eval "$arg"
5798 arg="$func_quote_for_eval_result"
5801 # Flags to be passed through unchanged, with rationale:
5802 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
5803 # -r[0-9][0-9]* specify processor for the SGI compiler
5804 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
5805 # +DA*, +DD* enable 64-bit mode for the HP compiler
5806 # -q* compiler args for the IBM compiler
5807 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
5808 # -F/path path to uninstalled frameworks, gcc on darwin
5809 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
5810 # @file GCC response files
5811 # -tp=* Portland pgcc target processor selection
5812 # --sysroot=* for sysroot support
5813 # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
5814 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5815 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
5816 -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
5817 func_quote_for_eval "$arg"
5818 arg="$func_quote_for_eval_result"
5819 func_append compile_command " $arg"
5820 func_append finalize_command " $arg"
5821 func_append compiler_flags " $arg"
5825 # Some other compiler flag.
5827 func_quote_for_eval "$arg"
5828 arg="$func_quote_for_eval_result"
5832 # A standard object.
5833 func_append objs " $arg"
5837 # A libtool-controlled object.
5839 # Check to see that this really is a libtool object.
5840 if func_lalib_unsafe_p "$arg"; then
5847 if test -z "$pic_object" ||
5848 test -z "$non_pic_object" ||
5849 test "$pic_object" = none &&
5850 test "$non_pic_object" = none; then
5851 func_fatal_error "cannot find name of object for \`$arg'"
5854 # Extract subdirectory from the argument.
5855 func_dirname "$arg" "/" ""
5856 xdir="$func_dirname_result"
5858 if test "$pic_object" != none; then
5859 # Prepend the subdirectory the object is found in.
5860 pic_object="$xdir$pic_object"
5862 if test "$prev" = dlfiles; then
5863 if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5864 func_append dlfiles " $pic_object"
5868 # If libtool objects are unsupported, then we need to preload.
5873 # CHECK ME: I think I busted this. -Ossama
5874 if test "$prev" = dlprefiles; then
5875 # Preload the old-style object.
5876 func_append dlprefiles " $pic_object"
5881 func_append libobjs " $pic_object"
5886 if test "$non_pic_object" != none; then
5887 # Prepend the subdirectory the object is found in.
5888 non_pic_object="$xdir$non_pic_object"
5890 # A standard non-PIC object
5891 func_append non_pic_objects " $non_pic_object"
5892 if test -z "$pic_object" || test "$pic_object" = none ; then
5893 arg="$non_pic_object"
5896 # If the PIC object exists, use it instead.
5897 # $xdir was prepended to $pic_object above.
5898 non_pic_object="$pic_object"
5899 func_append non_pic_objects " $non_pic_object"
5902 # Only an error if not doing a dry-run.
5903 if $opt_dry_run; then
5904 # Extract subdirectory from the argument.
5905 func_dirname "$arg" "/" ""
5906 xdir="$func_dirname_result"
5909 pic_object=$xdir$objdir/$func_lo2o_result
5910 non_pic_object=$xdir$func_lo2o_result
5911 func_append libobjs " $pic_object"
5912 func_append non_pic_objects " $non_pic_object"
5914 func_fatal_error "\`$arg' is not a valid libtool object"
5921 func_append deplibs " $arg"
5922 func_append old_deplibs " $arg"
5927 # A libtool-controlled library.
5929 func_resolve_sysroot "$arg"
5930 if test "$prev" = dlfiles; then
5931 # This library was specified with -dlopen.
5932 func_append dlfiles " $func_resolve_sysroot_result"
5934 elif test "$prev" = dlprefiles; then
5935 # The library was specified with -dlpreopen.
5936 func_append dlprefiles " $func_resolve_sysroot_result"
5939 func_append deplibs " $func_resolve_sysroot_result"
5944 # Some other compiler argument.
5946 # Unknown arguments in both finalize_command and compile_command need
5947 # to be aesthetically quoted because they are evaled later.
5948 func_quote_for_eval "$arg"
5949 arg="$func_quote_for_eval_result"
5953 # Now actually substitute the argument into the commands.
5954 if test -n "$arg"; then
5955 func_append compile_command " $arg"
5956 func_append finalize_command " $arg"
5958 done # argument parsing loop
5960 test -n "$prev" && \
5961 func_fatal_help "the \`$prevarg' option requires an argument"
5963 if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5964 eval arg=\"$export_dynamic_flag_spec\"
5965 func_append compile_command " $arg"
5966 func_append finalize_command " $arg"
5970 # calculate the name of the file, without its directory
5971 func_basename "$output"
5972 outputname="$func_basename_result"
5973 libobjs_save="$libobjs"
5975 if test -n "$shlibpath_var"; then
5976 # get the directories listed in $shlibpath_var
5977 eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
5981 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5982 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5984 func_dirname "$output" "/" ""
5985 output_objdir="$func_dirname_result$objdir"
5986 func_to_tool_file "$output_objdir/"
5987 tool_output_objdir=$func_to_tool_file_result
5988 # Create the object directory.
5989 func_mkdir_p "$output_objdir"
5991 # Determine the type of output
5994 func_fatal_help "you must specify an output file"
5996 *.$libext) linkmode=oldlib ;;
5997 *.lo | *.$objext) linkmode=obj ;;
5998 *.la) linkmode=lib ;;
5999 *) linkmode=prog ;; # Anything else should be a program.
6005 # Find all interdependent deplibs by searching for libraries
6006 # that are linked more than once (e.g. -la -lb -la)
6007 for deplib in $deplibs; do
6008 if $opt_preserve_dup_deps ; then
6010 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6013 func_append libs " $deplib"
6016 if test "$linkmode" = lib; then
6017 libs="$predeps $libs $compiler_lib_search_path $postdeps"
6019 # Compute libraries that are listed more than once in $predeps
6020 # $postdeps and mark them as special (i.e., whose duplicates are
6021 # not to be eliminated).
6023 if $opt_duplicate_compiler_generated_deps; then
6024 for pre_post_dep in $predeps $postdeps; do
6025 case "$pre_post_deps " in
6026 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
6028 func_append pre_post_deps " $pre_post_dep"
6037 need_relink=no # whether we're linking any uninstalled libtool libraries
6038 notinst_deplibs= # not-installed libtool libraries
6039 notinst_path= # paths that contain not-installed libtool libraries
6043 passes="conv dlpreopen link"
6044 for file in $dlfiles $dlprefiles; do
6048 func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
6059 passes="conv scan dlopen dlpreopen link"
6065 for pass in $passes; do
6066 # The preopen pass in lib mode reverses $deplibs; put it back here
6067 # so that -L comes before libs that need it for instance...
6068 if test "$linkmode,$pass" = "lib,link"; then
6069 ## FIXME: Find the place where the list is rebuilt in the wrong
6070 ## order, and fix it there properly
6072 for deplib in $deplibs; do
6073 tmp_deplibs="$deplib $tmp_deplibs"
6075 deplibs="$tmp_deplibs"
6078 if test "$linkmode,$pass" = "lib,link" ||
6079 test "$linkmode,$pass" = "prog,scan"; then
6083 if test "$linkmode" = prog; then
6085 dlopen) libs="$dlfiles" ;;
6086 dlpreopen) libs="$dlprefiles" ;;
6087 link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
6090 if test "$linkmode,$pass" = "lib,dlpreopen"; then
6091 # Collect and forward deplibs of preopened libtool libs
6092 for lib in $dlprefiles; do
6093 # Ignore non-libtool-libs
6095 func_resolve_sysroot "$lib"
6097 *.la) func_source "$func_resolve_sysroot_result" ;;
6100 # Collect preopened libtool deplibs, except any this library
6101 # has declared as weak libs
6102 for deplib in $dependency_libs; do
6103 func_basename "$deplib"
6104 deplib_base=$func_basename_result
6105 case " $weak_libs " in
6106 *" $deplib_base "*) ;;
6107 *) func_append deplibs " $deplib" ;;
6113 if test "$pass" = dlopen; then
6114 # Collect dlpreopened libraries
6115 save_deplibs="$deplibs"
6119 for deplib in $libs; do
6123 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
6124 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
6125 if test "$linkmode,$pass" = "prog,link"; then
6126 compile_deplibs="$deplib $compile_deplibs"
6127 finalize_deplibs="$deplib $finalize_deplibs"
6129 func_append compiler_flags " $deplib"
6130 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6131 if test "$linkmode" = lib ; then
6132 case "$new_inherited_linker_flags " in
6134 * ) func_append new_inherited_linker_flags " $deplib" ;;
6141 if test "$linkmode" != lib && test "$linkmode" != prog; then
6142 func_warning "\`-l' is ignored for archives/objects"
6145 func_stripname '-l' '' "$deplib"
6146 name=$func_stripname_result
6147 if test "$linkmode" = lib; then
6148 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
6150 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
6152 for searchdir in $searchdirs; do
6153 for search_ext in .la $std_shrext .so .a; do
6154 # Search the libtool library
6155 lib="$searchdir/lib${name}${search_ext}"
6156 if test -f "$lib"; then
6157 if test "$search_ext" = ".la"; then
6166 if test "$found" != yes; then
6167 # deplib doesn't seem to be a libtool library
6168 if test "$linkmode,$pass" = "prog,link"; then
6169 compile_deplibs="$deplib $compile_deplibs"
6170 finalize_deplibs="$deplib $finalize_deplibs"
6172 deplibs="$deplib $deplibs"
6173 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6176 else # deplib is a libtool library
6177 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
6178 # We need to do some special things here, and not later.
6179 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
6180 case " $predeps $postdeps " in
6182 if func_lalib_p "$lib"; then
6186 for l in $old_library $library_names; do
6189 if test "X$ll" = "X$old_library" ; then # only static version available
6191 func_dirname "$lib" "" "."
6192 ladir="$func_dirname_result"
6193 lib=$ladir/$old_library
6194 if test "$linkmode,$pass" = "prog,link"; then
6195 compile_deplibs="$deplib $compile_deplibs"
6196 finalize_deplibs="$deplib $finalize_deplibs"
6198 deplibs="$deplib $deplibs"
6199 test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
6211 if test "$linkmode,$pass" = "prog,link"; then
6212 compile_deplibs="$deplib $compile_deplibs"
6213 finalize_deplibs="$deplib $finalize_deplibs"
6215 deplibs="$deplib $deplibs"
6216 if test "$linkmode" = lib ; then
6217 case "$new_inherited_linker_flags " in
6219 * ) func_append new_inherited_linker_flags " $deplib" ;;
6228 deplibs="$deplib $deplibs"
6229 test "$pass" = conv && continue
6230 newdependency_libs="$deplib $newdependency_libs"
6231 func_stripname '-L' '' "$deplib"
6232 func_resolve_sysroot "$func_stripname_result"
6233 func_append newlib_search_path " $func_resolve_sysroot_result"
6236 if test "$pass" = conv; then
6237 deplibs="$deplib $deplibs"
6240 if test "$pass" = scan; then
6241 deplibs="$deplib $deplibs"
6243 compile_deplibs="$deplib $compile_deplibs"
6244 finalize_deplibs="$deplib $finalize_deplibs"
6246 func_stripname '-L' '' "$deplib"
6247 func_resolve_sysroot "$func_stripname_result"
6248 func_append newlib_search_path " $func_resolve_sysroot_result"
6251 func_warning "\`-L' is ignored for archives/objects"
6257 if test "$pass" = link; then
6258 func_stripname '-R' '' "$deplib"
6259 func_resolve_sysroot "$func_stripname_result"
6260 dir=$func_resolve_sysroot_result
6261 # Make sure the xrpath contains only unique directories.
6264 *) func_append xrpath " $dir" ;;
6267 deplibs="$deplib $deplibs"
6271 func_resolve_sysroot "$deplib"
6272 lib=$func_resolve_sysroot_result
6275 if test "$pass" = conv; then
6276 deplibs="$deplib $deplibs"
6281 # Linking convenience modules into shared libraries is allowed,
6282 # but linking other static libraries is non-portable.
6283 case " $dlpreconveniencelibs " in
6287 case $deplibs_check_method in
6289 set dummy $deplibs_check_method; shift
6290 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
6291 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
6292 | $EGREP "$match_pattern_regex" > /dev/null; then
6300 if test "$valid_a_lib" != yes; then
6302 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
6303 echo "*** I have the capability to make that library automatically link in when"
6304 echo "*** you link to this library. But I can only do this if you have a"
6305 echo "*** shared version of the library, which you do not appear to have"
6306 echo "*** because the file extensions .$libext of this argument makes me believe"
6307 echo "*** that it is just a static archive that I should not use here."
6310 $ECHO "*** Warning: Linking the shared library $output against the"
6311 $ECHO "*** static library $deplib is not portable!"
6312 deplibs="$deplib $deplibs"
6319 if test "$pass" != link; then
6320 deplibs="$deplib $deplibs"
6322 compile_deplibs="$deplib $compile_deplibs"
6323 finalize_deplibs="$deplib $finalize_deplibs"
6330 if test "$pass" = conv; then
6331 deplibs="$deplib $deplibs"
6332 elif test "$linkmode" = prog; then
6333 if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
6334 # If there is no dlopen support or we're linking statically,
6335 # we need to preload.
6336 func_append newdlprefiles " $deplib"
6337 compile_deplibs="$deplib $compile_deplibs"
6338 finalize_deplibs="$deplib $finalize_deplibs"
6340 func_append newdlfiles " $deplib"
6351 if test "$found" = yes || test -f "$lib"; then :
6353 func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
6356 # Check to see that this really is a libtool archive.
6357 func_lalib_unsafe_p "$lib" \
6358 || func_fatal_error "\`$lib' is not a valid libtool archive"
6360 func_dirname "$lib" "" "."
6361 ladir="$func_dirname_result"
6369 inherited_linker_flags=
6370 # If the library was installed with an old release of libtool,
6371 # it will not redefine variables installed, or shouldnotlink
6380 # Convert "-framework foo" to "foo.ltframework"
6381 if test -n "$inherited_linker_flags"; then
6382 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
6383 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
6384 case " $new_inherited_linker_flags " in
6385 *" $tmp_inherited_linker_flag "*) ;;
6386 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
6390 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
6391 if test "$linkmode,$pass" = "lib,link" ||
6392 test "$linkmode,$pass" = "prog,scan" ||
6393 { test "$linkmode" != prog && test "$linkmode" != lib; }; then
6394 test -n "$dlopen" && func_append dlfiles " $dlopen"
6395 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
6398 if test "$pass" = conv; then
6399 # Only check for convenience libraries
6400 deplibs="$lib $deplibs"
6401 if test -z "$libdir"; then
6402 if test -z "$old_library"; then
6403 func_fatal_error "cannot find name of link library for \`$lib'"
6405 # It is a libtool convenience library, so add in its objects.
6406 func_append convenience " $ladir/$objdir/$old_library"
6407 func_append old_convenience " $ladir/$objdir/$old_library"
6408 elif test "$linkmode" != prog && test "$linkmode" != lib; then
6409 func_fatal_error "\`$lib' is not a convenience library"
6412 for deplib in $dependency_libs; do
6413 deplibs="$deplib $deplibs"
6414 if $opt_preserve_dup_deps ; then
6415 case "$tmp_libs " in
6416 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6419 func_append tmp_libs " $deplib"
6425 # Get the name of the library we link against.
6427 if test -n "$old_library" &&
6428 { test "$prefer_static_libs" = yes ||
6429 test "$prefer_static_libs,$installed" = "built,no"; }; then
6430 linklib=$old_library
6432 for l in $old_library $library_names; do
6436 if test -z "$linklib"; then
6437 func_fatal_error "cannot find name of link library for \`$lib'"
6440 # This library was specified with -dlopen.
6441 if test "$pass" = dlopen; then
6442 if test -z "$libdir"; then
6443 func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
6445 if test -z "$dlname" ||
6446 test "$dlopen_support" != yes ||
6447 test "$build_libtool_libs" = no; then
6448 # If there is no dlname, no dlopen support or we're linking
6449 # statically, we need to preload. We also need to preload any
6450 # dependent libraries so libltdl's deplib preloader doesn't
6451 # bomb out in the load deplibs phase.
6452 func_append dlprefiles " $lib $dependency_libs"
6454 func_append newdlfiles " $lib"
6459 # We need an absolute path.
6461 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
6463 abs_ladir=`cd "$ladir" && pwd`
6464 if test -z "$abs_ladir"; then
6465 func_warning "cannot determine absolute directory name of \`$ladir'"
6466 func_warning "passing it literally to the linker, although it might fail"
6471 func_basename "$lib"
6472 laname="$func_basename_result"
6474 # Find the relevant object directory and library name.
6475 if test "X$installed" = Xyes; then
6476 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6477 func_warning "library \`$lib' was moved."
6482 dir="$lt_sysroot$libdir"
6483 absdir="$lt_sysroot$libdir"
6485 test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
6487 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
6490 # Remove this search path later
6491 func_append notinst_path " $abs_ladir"
6493 dir="$ladir/$objdir"
6494 absdir="$abs_ladir/$objdir"
6495 # Remove this search path later
6496 func_append notinst_path " $abs_ladir"
6498 fi # $installed = yes
6499 func_stripname 'lib' '.la' "$laname"
6500 name=$func_stripname_result
6502 # This library was specified with -dlpreopen.
6503 if test "$pass" = dlpreopen; then
6504 if test -z "$libdir" && test "$linkmode" = prog; then
6505 func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
6508 # special handling for platforms with PE-DLLs.
6509 *cygwin* | *mingw* | *cegcc* )
6510 # Linker will automatically link against shared library if both
6511 # static and shared are present. Therefore, ensure we extract
6512 # symbols from the import library if a shared library is present
6513 # (otherwise, the dlopen module name will be incorrect). We do
6514 # this by putting the import library name into $newdlprefiles.
6515 # We recover the dlopen module name by 'saving' the la file
6516 # name in a special purpose variable, and (later) extracting the
6517 # dlname from the la file.
6518 if test -n "$dlname"; then
6519 func_tr_sh "$dir/$linklib"
6520 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
6521 func_append newdlprefiles " $dir/$linklib"
6523 func_append newdlprefiles " $dir/$old_library"
6524 # Keep a list of preopened convenience libraries to check
6525 # that they are being used correctly in the link pass.
6526 test -z "$libdir" && \
6527 func_append dlpreconveniencelibs " $dir/$old_library"
6531 # Prefer using a static library (so that no silly _DYNAMIC symbols
6532 # are required to link).
6533 if test -n "$old_library"; then
6534 func_append newdlprefiles " $dir/$old_library"
6535 # Keep a list of preopened convenience libraries to check
6536 # that they are being used correctly in the link pass.
6537 test -z "$libdir" && \
6538 func_append dlpreconveniencelibs " $dir/$old_library"
6539 # Otherwise, use the dlname, so that lt_dlopen finds it.
6540 elif test -n "$dlname"; then
6541 func_append newdlprefiles " $dir/$dlname"
6543 func_append newdlprefiles " $dir/$linklib"
6547 fi # $pass = dlpreopen
6549 if test -z "$libdir"; then
6550 # Link the convenience library
6551 if test "$linkmode" = lib; then
6552 deplibs="$dir/$old_library $deplibs"
6553 elif test "$linkmode,$pass" = "prog,link"; then
6554 compile_deplibs="$dir/$old_library $compile_deplibs"
6555 finalize_deplibs="$dir/$old_library $finalize_deplibs"
6557 deplibs="$lib $deplibs" # used for prog,scan pass
6563 if test "$linkmode" = prog && test "$pass" != link; then
6564 func_append newlib_search_path " $ladir"
6565 deplibs="$lib $deplibs"
6568 if test "$link_all_deplibs" != no || test -z "$library_names" ||
6569 test "$build_libtool_libs" = no; then
6574 for deplib in $dependency_libs; do
6576 -L*) func_stripname '-L' '' "$deplib"
6577 func_resolve_sysroot "$func_stripname_result"
6578 func_append newlib_search_path " $func_resolve_sysroot_result"
6581 # Need to link against all dependency_libs?
6582 if test "$linkalldeplibs" = yes; then
6583 deplibs="$deplib $deplibs"
6585 # Need to hardcode shared library paths
6586 # or/and link against static libraries
6587 newdependency_libs="$deplib $newdependency_libs"
6589 if $opt_preserve_dup_deps ; then
6590 case "$tmp_libs " in
6591 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
6594 func_append tmp_libs " $deplib"
6597 fi # $linkmode = prog...
6599 if test "$linkmode,$pass" = "prog,link"; then
6600 if test -n "$library_names" &&
6601 { { test "$prefer_static_libs" = no ||
6602 test "$prefer_static_libs,$installed" = "built,yes"; } ||
6603 test -z "$old_library"; }; then
6604 # We need to hardcode the library path
6605 if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6606 # Make sure the rpath contains only unique directories.
6607 case "$temp_rpath:" in
6609 *) func_append temp_rpath "$absdir:" ;;
6613 # Hardcode the library path.
6614 # Skip directories that are in the system default run-time
6616 case " $sys_lib_dlsearch_path " in
6619 case "$compile_rpath " in
6621 *) func_append compile_rpath " $absdir" ;;
6625 case " $sys_lib_dlsearch_path " in
6628 case "$finalize_rpath " in
6630 *) func_append finalize_rpath " $libdir" ;;
6634 fi # $linkmode,$pass = prog,link...
6636 if test "$alldeplibs" = yes &&
6637 { test "$deplibs_check_method" = pass_all ||
6638 { test "$build_libtool_libs" = yes &&
6639 test -n "$library_names"; }; }; then
6640 # We only need to search for static libraries
6645 link_static=no # Whether the deplib will be linked statically
6646 use_static_libs=$prefer_static_libs
6647 if test "$use_static_libs" = built && test "$installed" = yes; then
6650 if test -n "$library_names" &&
6651 { test "$use_static_libs" = no || test -z "$old_library"; }; then
6653 *cygwin* | *mingw* | *cegcc*)
6654 # No point in relinking DLLs because paths are not encoded
6655 func_append notinst_deplibs " $lib"
6659 if test "$installed" = no; then
6660 func_append notinst_deplibs " $lib"
6661 test -z "$DESTDIR" && need_relink=yes
6665 # This is a shared library
6667 # Warn about portability, can't link against -module's on some
6668 # systems (darwin). Don't bleat about dlopened modules though!
6670 for dlpremoduletest in $dlprefiles; do
6671 if test "X$dlpremoduletest" = "X$lib"; then
6672 dlopenmodule="$dlpremoduletest"
6676 if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6678 if test "$linkmode" = prog; then
6679 $ECHO "*** Warning: Linking the executable $output against the loadable module"
6681 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6683 $ECHO "*** $linklib is not portable!"
6685 if test "$linkmode" = lib &&
6686 test "$hardcode_into_libs" = yes; then
6687 # Hardcode the library path.
6688 # Skip directories that are in the system default run-time
6690 case " $sys_lib_dlsearch_path " in
6693 case "$compile_rpath " in
6695 *) func_append compile_rpath " $absdir" ;;
6699 case " $sys_lib_dlsearch_path " in
6702 case "$finalize_rpath " in
6704 *) func_append finalize_rpath " $libdir" ;;
6710 if test -n "$old_archive_from_expsyms_cmds"; then
6711 # figure out the soname
6712 set dummy $library_names
6716 libname=`eval "\\$ECHO \"$libname_spec\""`
6717 # use dlname if we got it. it's perfectly good, no?
6718 if test -n "$dlname"; then
6720 elif test -n "$soname_spec"; then
6723 *cygwin* | mingw* | *cegcc*)
6724 func_arith $current - $age
6725 major=$func_arith_result
6729 eval soname=\"$soname_spec\"
6734 # Make a new name for the extract_expsyms_cmds to use
6736 func_basename "$soroot"
6737 soname="$func_basename_result"
6738 func_stripname 'lib' '.dll' "$soname"
6739 newlib=libimp-$func_stripname_result.a
6741 # If the library has no export list, then create one now
6742 if test -f "$output_objdir/$soname-def"; then :
6744 func_verbose "extracting exported symbol list from \`$soname'"
6745 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6749 if test -f "$output_objdir/$newlib"; then :; else
6750 func_verbose "generating import library for \`$soname'"
6751 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6753 # make sure the library variables are pointing to the new library
6756 fi # test -n "$old_archive_from_expsyms_cmds"
6758 if test "$linkmode" = prog || test "$opt_mode" != relink; then
6763 case $hardcode_action in
6764 immediate | unsupported)
6765 if test "$hardcode_direct" = no; then
6768 *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6769 *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6770 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6771 *-*-unixware7*) add_dir="-L$dir" ;;
6773 # if the lib is a (non-dlopened) module then we can not
6774 # link against it, someone is ignoring the earlier warnings
6775 if /usr/bin/file -L $add 2> /dev/null |
6776 $GREP ": [^:]* bundle" >/dev/null ; then
6777 if test "X$dlopenmodule" != "X$lib"; then
6778 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6779 if test -z "$old_library" ; then
6781 echo "*** And there doesn't seem to be a static archive available"
6782 echo "*** The link will probably fail, sorry"
6784 add="$dir/$old_library"
6786 elif test -n "$old_library"; then
6787 add="$dir/$old_library"
6791 elif test "$hardcode_minus_L" = no; then
6793 *-*-sunos*) add_shlibpath="$dir" ;;
6797 elif test "$hardcode_shlibpath_var" = no; then
6798 add_shlibpath="$dir"
6805 if test "$hardcode_direct" = yes &&
6806 test "$hardcode_direct_absolute" = no; then
6808 elif test "$hardcode_minus_L" = yes; then
6810 # Try looking first in the location we're being installed to.
6811 if test -n "$inst_prefix_dir"; then
6814 func_append add_dir " -L$inst_prefix_dir$libdir"
6819 elif test "$hardcode_shlibpath_var" = yes; then
6820 add_shlibpath="$dir"
6829 if test "$lib_linked" != yes; then
6830 func_fatal_configuration "unsupported hardcode properties"
6833 if test -n "$add_shlibpath"; then
6834 case :$compile_shlibpath: in
6835 *":$add_shlibpath:"*) ;;
6836 *) func_append compile_shlibpath "$add_shlibpath:" ;;
6839 if test "$linkmode" = prog; then
6840 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6841 test -n "$add" && compile_deplibs="$add $compile_deplibs"
6843 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6844 test -n "$add" && deplibs="$add $deplibs"
6845 if test "$hardcode_direct" != yes &&
6846 test "$hardcode_minus_L" != yes &&
6847 test "$hardcode_shlibpath_var" = yes; then
6848 case :$finalize_shlibpath: in
6850 *) func_append finalize_shlibpath "$libdir:" ;;
6856 if test "$linkmode" = prog || test "$opt_mode" = relink; then
6860 # Finalize command for both is simple: just hardcode it.
6861 if test "$hardcode_direct" = yes &&
6862 test "$hardcode_direct_absolute" = no; then
6863 add="$libdir/$linklib"
6864 elif test "$hardcode_minus_L" = yes; then
6867 elif test "$hardcode_shlibpath_var" = yes; then
6868 case :$finalize_shlibpath: in
6870 *) func_append finalize_shlibpath "$libdir:" ;;
6873 elif test "$hardcode_automatic" = yes; then
6874 if test -n "$inst_prefix_dir" &&
6875 test -f "$inst_prefix_dir$libdir/$linklib" ; then
6876 add="$inst_prefix_dir$libdir/$linklib"
6878 add="$libdir/$linklib"
6881 # We cannot seem to hardcode it, guess we'll fake it.
6883 # Try looking first in the location we're being installed to.
6884 if test -n "$inst_prefix_dir"; then
6887 func_append add_dir " -L$inst_prefix_dir$libdir"
6894 if test "$linkmode" = prog; then
6895 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6896 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6898 test -n "$add_dir" && deplibs="$add_dir $deplibs"
6899 test -n "$add" && deplibs="$add $deplibs"
6902 elif test "$linkmode" = prog; then
6903 # Here we assume that one of hardcode_direct or hardcode_minus_L
6904 # is not unsupported. This is valid on all known static and
6906 if test "$hardcode_direct" != unsupported; then
6907 test -n "$old_library" && linklib="$old_library"
6908 compile_deplibs="$dir/$linklib $compile_deplibs"
6909 finalize_deplibs="$dir/$linklib $finalize_deplibs"
6911 compile_deplibs="-l$name -L$dir $compile_deplibs"
6912 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6914 elif test "$build_libtool_libs" = yes; then
6915 # Not a shared library
6916 if test "$deplibs_check_method" != pass_all; then
6917 # We're trying link a shared library against a static one
6918 # but the system doesn't support it.
6920 # Just print a warning and add the library to dependency_libs so
6921 # that the program can be linked against the static library.
6923 $ECHO "*** Warning: This system can not link to static lib archive $lib."
6924 echo "*** I have the capability to make that library automatically link in when"
6925 echo "*** you link to this library. But I can only do this if you have a"
6926 echo "*** shared version of the library, which you do not appear to have."
6927 if test "$module" = yes; then
6928 echo "*** But as you try to build a module library, libtool will still create "
6929 echo "*** a static module, that should work as long as the dlopening application"
6930 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
6931 if test -z "$global_symbol_pipe"; then
6933 echo "*** However, this would only work if libtool was able to extract symbol"
6934 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
6935 echo "*** not find such a program. So, this module is probably useless."
6936 echo "*** \`nm' from GNU binutils and a full rebuild may help."
6938 if test "$build_old_libs" = no; then
6939 build_libtool_libs=module
6942 build_libtool_libs=no
6946 deplibs="$dir/$old_library $deplibs"
6949 fi # link shared/static library?
6951 if test "$linkmode" = lib; then
6952 if test -n "$dependency_libs" &&
6953 { test "$hardcode_into_libs" != yes ||
6954 test "$build_old_libs" = yes ||
6955 test "$link_static" = yes; }; then
6956 # Extract -R from dependency_libs
6958 for libdir in $dependency_libs; do
6960 -R*) func_stripname '-R' '' "$libdir"
6961 temp_xrpath=$func_stripname_result
6963 *" $temp_xrpath "*) ;;
6964 *) func_append xrpath " $temp_xrpath";;
6966 *) func_append temp_deplibs " $libdir";;
6969 dependency_libs="$temp_deplibs"
6972 func_append newlib_search_path " $absdir"
6973 # Link against this library
6974 test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6975 # ... and its dependency_libs
6977 for deplib in $dependency_libs; do
6978 newdependency_libs="$deplib $newdependency_libs"
6980 -L*) func_stripname '-L' '' "$deplib"
6981 func_resolve_sysroot "$func_stripname_result";;
6982 *) func_resolve_sysroot "$deplib" ;;
6984 if $opt_preserve_dup_deps ; then
6985 case "$tmp_libs " in
6986 *" $func_resolve_sysroot_result "*)
6987 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
6990 func_append tmp_libs " $func_resolve_sysroot_result"
6993 if test "$link_all_deplibs" != no; then
6994 # Add the search paths of all dependency libraries
6995 for deplib in $dependency_libs; do
6998 -L*) path="$deplib" ;;
7000 func_resolve_sysroot "$deplib"
7001 deplib=$func_resolve_sysroot_result
7002 func_dirname "$deplib" "" "."
7003 dir=$func_dirname_result
7004 # We need an absolute path.
7006 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
7008 absdir=`cd "$dir" && pwd`
7009 if test -z "$absdir"; then
7010 func_warning "cannot determine absolute directory name of \`$dir'"
7015 if $GREP "^installed=no" $deplib > /dev/null; then
7019 eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
7020 if test -n "$deplibrary_names" ; then
7021 for tmp in $deplibrary_names ; do
7024 if test -f "$absdir/$objdir/$depdepl" ; then
7025 depdepl="$absdir/$objdir/$depdepl"
7026 darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7027 if test -z "$darwin_install_name"; then
7028 darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
7030 func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
7031 func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
7037 path="-L$absdir/$objdir"
7041 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
7042 test -z "$libdir" && \
7043 func_fatal_error "\`$deplib' is not a valid libtool archive"
7044 test "$absdir" != "$libdir" && \
7045 func_warning "\`$deplib' seems to be moved"
7051 case " $deplibs " in
7053 *) deplibs="$path $deplibs" ;;
7056 fi # link_all_deplibs != no
7058 done # for deplib in $libs
7059 if test "$pass" = link; then
7060 if test "$linkmode" = "prog"; then
7061 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
7062 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
7064 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7067 dependency_libs="$newdependency_libs"
7068 if test "$pass" = dlpreopen; then
7069 # Link the dlpreopened libraries before other libraries
7070 for deplib in $save_deplibs; do
7071 deplibs="$deplib $deplibs"
7074 if test "$pass" != dlopen; then
7075 if test "$pass" != conv; then
7076 # Make sure lib_search_path contains only unique directories.
7078 for dir in $newlib_search_path; do
7079 case "$lib_search_path " in
7081 *) func_append lib_search_path " $dir" ;;
7087 if test "$linkmode,$pass" != "prog,link"; then
7090 vars="compile_deplibs finalize_deplibs"
7092 for var in $vars dependency_libs; do
7093 # Add libraries to $var in reverse order
7094 eval tmp_libs=\"\$$var\"
7096 for deplib in $tmp_libs; do
7097 # FIXME: Pedantically, this is the right thing to do, so
7098 # that some nasty dependency loop isn't accidentally
7100 #new_libs="$deplib $new_libs"
7101 # Pragmatically, this seems to cause very few problems in
7104 -L*) new_libs="$deplib $new_libs" ;;
7107 # And here is the reason: when a library appears more
7108 # than once as an explicit dependence of a library, or
7109 # is implicitly linked in more than once by the
7110 # compiler, it is considered special, and multiple
7111 # occurrences thereof are not removed. Compare this
7112 # with having the same library being listed as a
7113 # dependency of multiple other libraries: in this case,
7114 # we know (pedantically, we assume) the library does not
7115 # need to be listed more than once, so we keep only the
7116 # last copy. This is not always right, but it is rare
7117 # enough that we require users that really mean to play
7118 # such unportable linking tricks to link the library
7119 # using -Wl,-lname, so that libtool does not consider it
7120 # for duplicate removal.
7121 case " $specialdeplibs " in
7122 *" $deplib "*) new_libs="$deplib $new_libs" ;;
7124 case " $new_libs " in
7126 *) new_libs="$deplib $new_libs" ;;
7134 for deplib in $new_libs; do
7137 case " $tmp_libs " in
7139 *) func_append tmp_libs " $deplib" ;;
7142 *) func_append tmp_libs " $deplib" ;;
7145 eval $var=\"$tmp_libs\"
7148 # Last step: remove runtime libs from dependency_libs
7149 # (they stay in deplibs)
7151 for i in $dependency_libs ; do
7152 case " $predeps $postdeps $compiler_lib_search_path " in
7157 if test -n "$i" ; then
7158 func_append tmp_libs " $i"
7161 dependency_libs=$tmp_libs
7163 if test "$linkmode" = prog; then
7164 dlfiles="$newdlfiles"
7166 if test "$linkmode" = prog || test "$linkmode" = lib; then
7167 dlprefiles="$newdlprefiles"
7172 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7173 func_warning "\`-dlopen' is ignored for archives"
7178 func_warning "\`-l' and \`-L' are ignored for archives" ;;
7181 test -n "$rpath" && \
7182 func_warning "\`-rpath' is ignored for archives"
7184 test -n "$xrpath" && \
7185 func_warning "\`-R' is ignored for archives"
7187 test -n "$vinfo" && \
7188 func_warning "\`-version-info/-version-number' is ignored for archives"
7190 test -n "$release" && \
7191 func_warning "\`-release' is ignored for archives"
7193 test -n "$export_symbols$export_symbols_regex" && \
7194 func_warning "\`-export-symbols' is ignored for archives"
7196 # Now set the variables for building old libraries.
7197 build_libtool_libs=no
7199 func_append objs "$old_deplibs"
7203 # Make sure we only generate libraries of the form `libNAME.la'.
7206 func_stripname 'lib' '.la' "$outputname"
7207 name=$func_stripname_result
7208 eval shared_ext=\"$shrext_cmds\"
7209 eval libname=\"$libname_spec\"
7212 test "$module" = no && \
7213 func_fatal_help "libtool library \`$output' must begin with \`lib'"
7215 if test "$need_lib_prefix" != no; then
7216 # Add the "lib" prefix for modules if required
7217 func_stripname '' '.la' "$outputname"
7218 name=$func_stripname_result
7219 eval shared_ext=\"$shrext_cmds\"
7220 eval libname=\"$libname_spec\"
7222 func_stripname '' '.la' "$outputname"
7223 libname=$func_stripname_result
7228 if test -n "$objs"; then
7229 if test "$deplibs_check_method" != pass_all; then
7230 func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
7233 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
7234 $ECHO "*** objects $objs is not portable!"
7235 func_append libobjs " $objs"
7239 test "$dlself" != no && \
7240 func_warning "\`-dlopen self' is ignored for libtool libraries"
7244 test "$#" -gt 1 && \
7245 func_warning "ignoring multiple \`-rpath's for a libtool library"
7250 if test -z "$rpath"; then
7251 if test "$build_libtool_libs" = yes; then
7252 # Building a libtool convenience library.
7253 # Some compilers have problems with a `.al' extension so
7254 # convenience libraries should have the same extension an
7255 # archive normally would.
7256 oldlibs="$output_objdir/$libname.$libext $oldlibs"
7257 build_libtool_libs=convenience
7261 test -n "$vinfo" && \
7262 func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
7264 test -n "$release" && \
7265 func_warning "\`-release' is ignored for convenience libraries"
7268 # Parse the version information argument.
7269 save_ifs="$IFS"; IFS=':'
7270 set dummy $vinfo 0 0 0
7275 func_fatal_help "too many parameters to \`-version-info'"
7277 # convert absolute version numbers to libtool ages
7278 # this retains compatibility with .la files and attempts
7279 # to make the code below a bit more comprehensible
7281 case $vinfo_number in
7285 number_revision="$3"
7287 # There are really only two kinds -- those that
7288 # use the current revision as the major version
7289 # and those that subtract age and use age as
7290 # a minor version. But, then there is irix
7291 # which has an extra 1 added just for fun
7293 case $version_type in
7294 # correct linux to gnu/linux during the next big refactor
7295 darwin|linux|osf|windows|none)
7296 func_arith $number_major + $number_minor
7297 current=$func_arith_result
7299 revision="$number_revision"
7301 freebsd-aout|freebsd-elf|qnx|sunos)
7302 current="$number_major"
7303 revision="$number_minor"
7307 func_arith $number_major + $number_minor
7308 current=$func_arith_result
7310 revision="$number_minor"
7311 lt_irix_increment=no
7322 # Check that each of the things are valid numbers.
7324 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]) ;;
7326 func_error "CURRENT \`$current' must be a nonnegative integer"
7327 func_fatal_error "\`$vinfo' is not valid version information"
7332 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]) ;;
7334 func_error "REVISION \`$revision' must be a nonnegative integer"
7335 func_fatal_error "\`$vinfo' is not valid version information"
7340 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]) ;;
7342 func_error "AGE \`$age' must be a nonnegative integer"
7343 func_fatal_error "\`$vinfo' is not valid version information"
7347 if test "$age" -gt "$current"; then
7348 func_error "AGE \`$age' is greater than the current interface number \`$current'"
7349 func_fatal_error "\`$vinfo' is not valid version information"
7352 # Calculate the version variables.
7356 case $version_type in
7360 # Like Linux, but with the current version available in
7361 # verstring for coding it into the library header
7362 func_arith $current - $age
7363 major=.$func_arith_result
7364 versuffix="$major.$age.$revision"
7365 # Darwin ld doesn't like 0 for these options...
7366 func_arith $current + 1
7367 minor_current=$func_arith_result
7368 xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
7369 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
7374 versuffix=".$current.$revision";
7379 versuffix=".$current"
7383 if test "X$lt_irix_increment" = "Xno"; then
7384 func_arith $current - $age
7386 func_arith $current - $age + 1
7388 major=$func_arith_result
7390 case $version_type in
7391 nonstopux) verstring_prefix=nonstopux ;;
7392 *) verstring_prefix=sgi ;;
7394 verstring="$verstring_prefix$major.$revision"
7396 # Add in all the interfaces that we are compatible with.
7398 while test "$loop" -ne 0; do
7399 func_arith $revision - $loop
7400 iface=$func_arith_result
7401 func_arith $loop - 1
7402 loop=$func_arith_result
7403 verstring="$verstring_prefix$major.$iface:$verstring"
7406 # Before this point, $major must not contain `.'.
7408 versuffix="$major.$revision"
7411 linux) # correct to gnu/linux during the next big refactor
7412 func_arith $current - $age
7413 major=.$func_arith_result
7414 versuffix="$major.$age.$revision"
7418 func_arith $current - $age
7419 major=.$func_arith_result
7420 versuffix=".$current.$age.$revision"
7421 verstring="$current.$age.$revision"
7423 # Add in all the interfaces that we are compatible with.
7425 while test "$loop" -ne 0; do
7426 func_arith $current - $loop
7427 iface=$func_arith_result
7428 func_arith $loop - 1
7429 loop=$func_arith_result
7430 verstring="$verstring:${iface}.0"
7433 # Make executables depend on our current version.
7434 func_append verstring ":${current}.0"
7439 versuffix=".$current"
7444 versuffix=".$current.$revision"
7448 # Use '-' rather than '.', since we only want one
7449 # extension on DOS 8.3 filesystems.
7450 func_arith $current - $age
7451 major=$func_arith_result
7456 func_fatal_configuration "unknown library version type \`$version_type'"
7460 # Clear the version info if we defaulted, and they specified a release.
7461 if test -z "$vinfo" && test -n "$release"; then
7463 case $version_type in
7465 # we can't check for "0.0" in archive_cmds due to quoting
7466 # problems, so we reset it completely
7473 if test "$need_version" = no; then
7480 # Remove version info from name if versioning should be avoided
7481 if test "$avoid_version" = yes && test "$need_version" = no; then
7487 tmp=`echo $libname|sed -e 's,+,_,g' -e 's,-,_,g' -e 's,\.,_,g'`
7488 eval tmp2=\$${tmp}_ltversion
7489 if ! test -z "${SHARED_LIBS_LOG}"; then
7490 if ! test -f ${SHARED_LIBS_LOG}; then
7491 echo "# SHARED_LIBS+= <libname> <obsd version> # <orig version>" >${SHARED_LIBS_LOG}
7493 tmp4=`echo $libname|sed -e 's/^lib//'`
7494 printf "SHARED_LIBS +=\t%-20s %-8s # %s\n" "$tmp4" "$tmp2" "$versuffix" >>${SHARED_LIBS_LOG}
7496 if test -n "$versuffix" && test -n "$tmp2"; then
7501 # Check to see if the archive will have undefined symbols.
7502 if test "$allow_undefined" = yes; then
7503 if test "$allow_undefined_flag" = unsupported; then
7504 func_warning "undefined symbols not allowed in $host shared libraries"
7505 build_libtool_libs=no
7509 # Don't allow undefined symbols.
7510 allow_undefined_flag="$no_undefined_flag"
7515 func_generate_dlsyms "$libname" "$libname" "yes"
7516 func_append libobjs " $symfileobj"
7517 test "X$libobjs" = "X " && libobjs=
7519 if test "$opt_mode" != relink; then
7520 # Remove our outputs, but don't remove object files since they
7521 # may have been created when compiling PIC objects.
7523 tempremovelist=`$ECHO "$output_objdir/*"`
7524 for p in $tempremovelist; do
7528 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
7529 if test "X$precious_files_regex" != "X"; then
7530 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
7535 func_append removelist " $p"
7540 test -n "$removelist" && \
7541 func_show_eval "${RM}r \$removelist"
7544 # Now set the variables for building old libraries.
7545 if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
7546 func_append oldlibs " $output_objdir/$libname.$libext"
7548 # Transform .lo files to .o files.
7549 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
7552 # Eliminate all temporary directories.
7553 #for path in $notinst_path; do
7554 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
7555 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
7556 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
7559 if test -n "$xrpath"; then
7560 # If the user specified any rpath flags, then add them.
7562 for libdir in $xrpath; do
7563 func_replace_sysroot "$libdir"
7564 func_append temp_xrpath " -R$func_replace_sysroot_result"
7565 case "$finalize_rpath " in
7567 *) func_append finalize_rpath " $libdir" ;;
7570 if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
7571 dependency_libs="$temp_xrpath $dependency_libs"
7575 # Make sure dlfiles contains only unique files that won't be dlpreopened
7576 old_dlfiles="$dlfiles"
7578 for lib in $old_dlfiles; do
7579 case " $dlprefiles $dlfiles " in
7581 *) func_append dlfiles " $lib" ;;
7585 # Make sure dlprefiles contains only unique files
7586 old_dlprefiles="$dlprefiles"
7588 for lib in $old_dlprefiles; do
7589 case "$dlprefiles " in
7591 *) func_append dlprefiles " $lib" ;;
7595 if test "$build_libtool_libs" = yes; then
7596 if test -n "$rpath"; then
7598 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
7599 # these systems don't actually have a c library (as such)!
7601 *-*-rhapsody* | *-*-darwin1.[012])
7602 # Rhapsody C library is in the System framework
7603 func_append deplibs " System.ltframework"
7606 # Don't link with libc until the a.out ld.so is fixed.
7608 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
7609 # Do not include libc due to us having libc/libc_r.
7611 *-*-sco3.2v5* | *-*-sco5v6*)
7612 # Causes problems with __ctype
7614 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7615 # Compiler inserts libc in the correct place for threads to work
7618 # Add libc to deplibs on all other systems if necessary.
7619 if test "$build_libtool_need_lc" = "yes"; then
7620 func_append deplibs " -lc"
7626 # Transform deplibs into only deplibs that can be linked in shared.
7628 libname_save=$libname
7629 release_save=$release
7630 versuffix_save=$versuffix
7632 # I'm not sure if I'm treating the release correctly. I think
7633 # release should show up in the -l (ie -lgmp5) so we don't want to
7634 # add it in twice. Is that correct?
7640 case $deplibs_check_method in
7642 # Don't check for shared/static. Everything works.
7643 # This might be a little naive. We might want to check
7644 # whether the library exists or not. But this is on
7645 # osf3 & osf4 and I'm not really sure... Just
7646 # implementing what was already the behavior.
7650 # This code stresses the "libraries are programs" paradigm to its
7651 # limits. Maybe even breaks it. We compile a program, linking it
7652 # against the deplibs as a proxy for the library. Then we can check
7653 # whether they linked in statically or dynamically with ldd.
7654 $opt_dry_run || $RM conftest.c
7655 cat > conftest.c <<EOF
7656 int main() { return 0; }
7658 $opt_dry_run || $RM conftest
7659 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7660 ldd_output=`ldd conftest`
7661 for i in $deplibs; do
7664 func_stripname -l '' "$i"
7665 name=$func_stripname_result
7666 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7667 case " $predeps $postdeps " in
7669 func_append newdeplibs " $i"
7674 if test -n "$i" ; then
7675 libname=`eval "\\$ECHO \"$libname_spec\""`
7676 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7677 set dummy $deplib_matches; shift
7679 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7680 func_append newdeplibs " $i"
7684 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7685 echo "*** I have the capability to make that library automatically link in when"
7686 echo "*** you link to this library. But I can only do this if you have a"
7687 echo "*** shared version of the library, which I believe you do not have"
7688 echo "*** because a test_compile did reveal that the linker did not use it for"
7689 echo "*** its dynamic dependency list that programs get resolved with at runtime."
7694 func_append newdeplibs " $i"
7699 # Error occurred in the first compile. Let's try to salvage
7700 # the situation: Compile a separate program for each library.
7701 for i in $deplibs; do
7704 func_stripname -l '' "$i"
7705 name=$func_stripname_result
7706 $opt_dry_run || $RM conftest
7707 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7708 ldd_output=`ldd conftest`
7709 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7710 case " $predeps $postdeps " in
7712 func_append newdeplibs " $i"
7717 if test -n "$i" ; then
7718 libname=`eval "\\$ECHO \"$libname_spec\""`
7719 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7720 set dummy $deplib_matches; shift
7722 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7723 func_append newdeplibs " $i"
7727 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7728 echo "*** I have the capability to make that library automatically link in when"
7729 echo "*** you link to this library. But I can only do this if you have a"
7730 echo "*** shared version of the library, which you do not appear to have"
7731 echo "*** because a test_compile did reveal that the linker did not use this one"
7732 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
7738 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
7739 echo "*** make it link in! You will probably need to install it or some"
7740 echo "*** library that it depends on before this library will be fully"
7741 echo "*** functional. Installing it before continuing would be even better."
7745 func_append newdeplibs " $i"
7752 set dummy $deplibs_check_method; shift
7753 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7754 for a_deplib in $deplibs; do
7757 func_stripname -l '' "$a_deplib"
7758 name=$func_stripname_result
7759 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7760 case " $predeps $postdeps " in
7762 func_append newdeplibs " $a_deplib"
7767 if test -n "$a_deplib" ; then
7768 libname=`eval "\\$ECHO \"$libname_spec\""`
7769 if test -n "$file_magic_glob"; then
7770 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
7772 libnameglob=$libname
7774 test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
7775 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7776 if test "$want_nocaseglob" = yes; then
7778 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7781 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
7783 for potent_lib in $potential_libs; do
7784 # Follow soft links.
7785 if ls -lLd "$potent_lib" 2>/dev/null |
7786 $GREP " -> " >/dev/null; then
7789 # The statement above tries to avoid entering an
7790 # endless loop below, in case of cyclic links.
7791 # We might still enter an endless loop, since a link
7792 # loop can be closed while we follow links,
7794 potlib="$potent_lib"
7795 while test -h "$potlib" 2>/dev/null; do
7796 potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7798 [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7799 *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
7802 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7804 $EGREP "$file_magic_regex" > /dev/null; then
7805 func_append newdeplibs " $a_deplib"
7812 if test -n "$a_deplib" ; then
7815 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7816 echo "*** I have the capability to make that library automatically link in when"
7817 echo "*** you link to this library. But I can only do this if you have a"
7818 echo "*** shared version of the library, which you do not appear to have"
7819 echo "*** because I did check the linker path looking for a file starting"
7820 if test -z "$potlib" ; then
7821 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7823 $ECHO "*** with $libname and none of the candidates passed a file format test"
7824 $ECHO "*** using a file magic. Last file checked: $potlib"
7829 # Add a -L argument.
7830 func_append newdeplibs " $a_deplib"
7833 done # Gone through all deplibs.
7836 set dummy $deplibs_check_method; shift
7837 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7838 for a_deplib in $deplibs; do
7841 func_stripname -l '' "$a_deplib"
7842 name=$func_stripname_result
7843 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7844 case " $predeps $postdeps " in
7846 func_append newdeplibs " $a_deplib"
7851 if test -n "$a_deplib" ; then
7852 libname=`eval "\\$ECHO \"$libname_spec\""`
7853 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7854 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7855 for potent_lib in $potential_libs; do
7856 potlib="$potent_lib" # see symlink-check above in file_magic test
7857 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
7858 $EGREP "$match_pattern_regex" > /dev/null; then
7859 func_append newdeplibs " $a_deplib"
7866 if test -n "$a_deplib" ; then
7869 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7870 echo "*** I have the capability to make that library automatically link in when"
7871 echo "*** you link to this library. But I can only do this if you have a"
7872 echo "*** shared version of the library, which you do not appear to have"
7873 echo "*** because I did check the linker path looking for a file starting"
7874 if test -z "$potlib" ; then
7875 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7877 $ECHO "*** with $libname and none of the candidates passed a file format test"
7878 $ECHO "*** using a regex pattern. Last file checked: $potlib"
7883 # Add a -L argument.
7884 func_append newdeplibs " $a_deplib"
7887 done # Gone through all deplibs.
7891 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
7892 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7893 for i in $predeps $postdeps ; do
7894 # can't use Xsed below, because $i might contain '/'
7895 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
7898 case $tmp_deplibs in
7901 if test "X$deplibs_check_method" = "Xnone"; then
7902 echo "*** Warning: inter-library dependencies are not supported in this platform."
7904 echo "*** Warning: inter-library dependencies are not known to be supported."
7906 echo "*** All declared inter-library dependencies are being dropped."
7912 versuffix=$versuffix_save
7914 release=$release_save
7915 libname=$libname_save
7919 *-*-rhapsody* | *-*-darwin1.[012])
7920 # On Rhapsody replace the C library with the System framework
7921 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
7925 if test "$droppeddeps" = yes; then
7926 if test "$module" = yes; then
7928 echo "*** Warning: libtool could not satisfy all declared inter-library"
7929 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
7930 echo "*** a static module, that should work as long as the dlopening"
7931 echo "*** application is linked with the -dlopen flag."
7932 if test -z "$global_symbol_pipe"; then
7934 echo "*** However, this would only work if libtool was able to extract symbol"
7935 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
7936 echo "*** not find such a program. So, this module is probably useless."
7937 echo "*** \`nm' from GNU binutils and a full rebuild may help."
7939 if test "$build_old_libs" = no; then
7940 oldlibs="$output_objdir/$libname.$libext"
7941 build_libtool_libs=module
7944 build_libtool_libs=no
7947 echo "*** The inter-library dependencies that have been dropped here will be"
7948 echo "*** automatically added whenever a program is linked with this library"
7949 echo "*** or is declared to -dlopen it."
7951 if test "$allow_undefined" = no; then
7953 echo "*** Since this library must not contain undefined symbols,"
7954 echo "*** because either the platform does not support them or"
7955 echo "*** it was explicitly requested with -no-undefined,"
7956 echo "*** libtool will only create a static version of it."
7957 if test "$build_old_libs" = no; then
7958 oldlibs="$output_objdir/$libname.$libext"
7959 build_libtool_libs=module
7962 build_libtool_libs=no
7967 # Done checking deplibs!
7970 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7973 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7974 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7975 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
7979 # move library search paths that coincide with paths to not yet
7980 # installed libraries to the beginning of the library search list
7982 for path in $notinst_path; do
7983 case " $new_libs " in
7984 *" -L$path/$objdir "*) ;;
7986 case " $deplibs " in
7987 *" -L$path/$objdir "*)
7988 func_append new_libs " -L$path/$objdir" ;;
7993 for deplib in $deplibs; do
7996 case " $new_libs " in
7998 *) func_append new_libs " $deplib" ;;
8001 *) func_append new_libs " $deplib" ;;
8006 # All the library-specific variables (install_libdir is set above).
8011 # Test again, we may have decided not to build it any more
8012 if test "$build_libtool_libs" = yes; then
8013 # Remove ${wl} instances when linking with ld.
8014 # FIXME: should test the right _cmds variable.
8015 case $archive_cmds in
8018 if test "$hardcode_into_libs" = yes; then
8019 # Hardcode the library paths
8022 rpath="$finalize_rpath"
8023 test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
8024 for libdir in $rpath; do
8025 if test -n "$hardcode_libdir_flag_spec"; then
8026 if test -n "$hardcode_libdir_separator"; then
8027 func_replace_sysroot "$libdir"
8028 libdir=$func_replace_sysroot_result
8029 if test -z "$hardcode_libdirs"; then
8030 hardcode_libdirs="$libdir"
8032 # Just accumulate the unique libdirs.
8033 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8034 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8037 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8042 eval flag=\"$hardcode_libdir_flag_spec\"
8043 func_append dep_rpath " $flag"
8045 elif test -n "$runpath_var"; then
8046 case "$perm_rpath " in
8048 *) func_append perm_rpath " $libdir" ;;
8052 # Substitute the hardcoded libdirs into the rpath.
8053 if test -n "$hardcode_libdir_separator" &&
8054 test -n "$hardcode_libdirs"; then
8055 libdir="$hardcode_libdirs"
8056 eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
8058 if test -n "$runpath_var" && test -n "$perm_rpath"; then
8059 # We should set the runpath_var.
8061 for dir in $perm_rpath; do
8062 func_append rpath "$dir:"
8064 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
8066 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
8069 shlibpath="$finalize_shlibpath"
8070 test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
8071 if test -n "$shlibpath"; then
8072 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
8075 # Get the real and link names of the library.
8076 eval shared_ext=\"$shrext_cmds\"
8077 eval library_names=\"$library_names_spec\"
8078 set dummy $library_names
8083 if test -n "$soname_spec"; then
8084 eval soname=\"$soname_spec\"
8088 if test -z "$dlname"; then
8092 lib="$output_objdir/$realname"
8096 func_append linknames " $link"
8099 # Use standard objects if they are pic
8100 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
8101 test "X$libobjs" = "X " && libobjs=
8104 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8105 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
8106 export_symbols="$output_objdir/$libname.uexp"
8107 func_append delfiles " $export_symbols"
8110 orig_export_symbols=
8112 cygwin* | mingw* | cegcc*)
8113 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
8114 # exporting using user supplied symfile
8115 if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
8116 # and it's NOT already a .def file. Must figure out
8117 # which of the given symbols are data symbols and tag
8118 # them as such. So, trigger use of export_symbols_cmds.
8119 # export_symbols gets reassigned inside the "prepare
8120 # the list of exported symbols" if statement, so the
8121 # include_expsyms logic still works.
8122 orig_export_symbols="$export_symbols"
8124 always_export_symbols=yes
8130 # Prepare the list of exported symbols
8131 if test -z "$export_symbols"; then
8132 if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
8133 func_verbose "generating symbol list for \`$libname.la'"
8134 export_symbols="$output_objdir/$libname.exp"
8135 $opt_dry_run || $RM $export_symbols
8136 cmds=$export_symbols_cmds
8137 save_ifs="$IFS"; IFS='~'
8138 for cmd1 in $cmds; do
8140 # Take the normal branch if the nm_file_list_spec branch
8141 # doesn't work or if tool conversion is not needed.
8142 case $nm_file_list_spec~$to_tool_file_cmd in
8143 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
8144 try_normal_branch=yes
8147 len=$func_len_result
8150 try_normal_branch=no
8153 if test "$try_normal_branch" = yes \
8154 && { test "$len" -lt "$max_cmd_len" \
8155 || test "$max_cmd_len" -le -1; }
8157 func_show_eval "$cmd" 'exit $?'
8158 skipped_export=false
8159 elif test -n "$nm_file_list_spec"; then
8160 func_basename "$output"
8161 output_la=$func_basename_result
8162 save_libobjs=$libobjs
8164 output=${output_objdir}/${output_la}.nm
8165 func_to_tool_file "$output"
8166 libobjs=$nm_file_list_spec$func_to_tool_file_result
8167 func_append delfiles " $output"
8168 func_verbose "creating $NM input file list: $output"
8169 for obj in $save_libobjs; do
8170 func_to_tool_file "$obj"
8171 $ECHO "$func_to_tool_file_result"
8174 func_show_eval "$cmd" 'exit $?'
8176 libobjs=$save_libobjs
8177 skipped_export=false
8179 # The command line is too long to execute in one step.
8180 func_verbose "using reloadable object file for export list..."
8182 # Break out early, otherwise skipped_export may be
8183 # set to false by a later but shorter cmd.
8188 if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
8189 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8190 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8195 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8196 tmp_export_symbols="$export_symbols"
8197 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8198 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8201 if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
8202 # The given exports_symbols file has to be filtered, so filter it.
8203 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8204 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8205 # 's' commands which not all seds can handle. GNU sed should be fine
8206 # though. Also, the filter scales superlinearly with the number of
8207 # global variables. join(1) would be nice here, but unfortunately
8208 # isn't a blessed tool.
8209 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8210 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8211 export_symbols=$output_objdir/$libname.def
8212 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8216 for test_deplib in $deplibs; do
8217 case " $convenience " in
8218 *" $test_deplib "*) ;;
8220 func_append tmp_deplibs " $test_deplib"
8224 deplibs="$tmp_deplibs"
8226 if test -n "$convenience"; then
8227 if test -n "$whole_archive_flag_spec" &&
8228 test "$compiler_needs_object" = yes &&
8229 test -z "$libobjs"; then
8230 # extract the archives, so we have objects to list.
8231 # TODO: could optimize this to just extract one archive.
8232 whole_archive_flag_spec=
8234 if test -n "$whole_archive_flag_spec"; then
8235 save_libobjs=$libobjs
8236 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8237 test "X$libobjs" = "X " && libobjs=
8239 gentop="$output_objdir/${outputname}x"
8240 func_append generated " $gentop"
8242 func_extract_archives $gentop $convenience
8243 func_append libobjs " $func_extract_archives_result"
8244 test "X$libobjs" = "X " && libobjs=
8248 if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
8249 eval flag=\"$thread_safe_flag_spec\"
8250 func_append linker_flags " $flag"
8253 # Make a backup of the uninstalled library when relinking
8254 if test "$opt_mode" = relink; then
8255 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
8258 # Do each of the archive commands.
8259 if test "$module" = yes && test -n "$module_cmds" ; then
8260 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8261 eval test_cmds=\"$module_expsym_cmds\"
8262 cmds=$module_expsym_cmds
8264 eval test_cmds=\"$module_cmds\"
8268 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8269 eval test_cmds=\"$archive_expsym_cmds\"
8270 cmds=$archive_expsym_cmds
8272 eval test_cmds=\"$archive_cmds\"
8277 if test "X$skipped_export" != "X:" &&
8278 func_len " $test_cmds" &&
8279 len=$func_len_result &&
8280 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8283 # The command line is too long to link in one step, link piecewise
8284 # or, if using GNU ld and skipped_export is not :, use a linker
8287 # Save the value of $output and $libobjs because we want to
8288 # use them later. If we have whole_archive_flag_spec, we
8289 # want to use save_libobjs as it was before
8290 # whole_archive_flag_spec was expanded, because we can't
8291 # assume the linker understands whole_archive_flag_spec.
8292 # This may have to be revisited, in case too many
8293 # convenience libraries get linked in and end up exceeding
8295 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
8296 save_libobjs=$libobjs
8299 func_basename "$output"
8300 output_la=$func_basename_result
8302 # Clear the reloadable object creation command queue and
8303 # initialize k to one.
8310 if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
8311 output=${output_objdir}/${output_la}.lnkscript
8312 func_verbose "creating GNU ld script: $output"
8313 echo 'INPUT (' > $output
8314 for obj in $save_libobjs
8316 func_to_tool_file "$obj"
8317 $ECHO "$func_to_tool_file_result" >> $output
8320 func_append delfiles " $output"
8321 func_to_tool_file "$output"
8322 output=$func_to_tool_file_result
8323 elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
8324 output=${output_objdir}/${output_la}.lnk
8325 func_verbose "creating linker input file list: $output"
8330 if test "$compiler_needs_object" = yes; then
8336 func_to_tool_file "$obj"
8337 $ECHO "$func_to_tool_file_result" >> $output
8339 func_append delfiles " $output"
8340 func_to_tool_file "$output"
8341 output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
8343 if test -n "$save_libobjs"; then
8344 func_verbose "creating reloadable object files..."
8345 output=$output_objdir/$output_la-${k}.$objext
8346 eval test_cmds=\"$reload_cmds\"
8347 func_len " $test_cmds"
8348 len0=$func_len_result
8351 # Loop over the list of objects to be linked.
8352 for obj in $save_libobjs
8355 func_arith $len + $func_len_result
8356 len=$func_arith_result
8357 if test "X$objlist" = X ||
8358 test "$len" -lt "$max_cmd_len"; then
8359 func_append objlist " $obj"
8361 # The command $test_cmds is almost too long, add a
8362 # command to the queue.
8363 if test "$k" -eq 1 ; then
8364 # The first file doesn't have a previous command to add.
8365 reload_objs=$objlist
8366 eval concat_cmds=\"$reload_cmds\"
8368 # All subsequent reloadable object files will link in
8369 # the last one created.
8370 reload_objs="$objlist $last_robj"
8371 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
8373 last_robj=$output_objdir/$output_la-${k}.$objext
8375 k=$func_arith_result
8376 output=$output_objdir/$output_la-${k}.$objext
8378 func_len " $last_robj"
8379 func_arith $len0 + $func_len_result
8380 len=$func_arith_result
8383 # Handle the remaining objects by creating one last
8384 # reloadable object file. All subsequent reloadable object
8385 # files will link in the last one created.
8386 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8387 reload_objs="$objlist $last_robj"
8388 eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
8389 if test -n "$last_robj"; then
8390 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
8392 func_append delfiles " $output"
8398 if ${skipped_export-false}; then
8399 func_verbose "generating symbol list for \`$libname.la'"
8400 export_symbols="$output_objdir/$libname.exp"
8401 $opt_dry_run || $RM $export_symbols
8403 # Append the command to create the export file.
8404 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8405 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
8406 if test -n "$last_robj"; then
8407 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
8411 test -n "$save_libobjs" &&
8412 func_verbose "creating a temporary reloadable object file: $output"
8414 # Loop through the commands generated above and execute them.
8415 save_ifs="$IFS"; IFS='~'
8416 for cmd in $concat_cmds; do
8419 func_quote_for_expand "$cmd"
8420 eval "func_echo $func_quote_for_expand_result"
8422 $opt_dry_run || eval "$cmd" || {
8425 # Restore the uninstalled library and exit
8426 if test "$opt_mode" = relink; then
8427 ( cd "$output_objdir" && \
8428 $RM "${realname}T" && \
8429 $MV "${realname}U" "$realname" )
8437 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
8438 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
8439 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
8443 if ${skipped_export-false}; then
8444 if test -n "$export_symbols" && test -n "$include_expsyms"; then
8445 tmp_export_symbols="$export_symbols"
8446 test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
8447 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
8450 if test -n "$orig_export_symbols"; then
8451 # The given exports_symbols file has to be filtered, so filter it.
8452 func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
8453 # FIXME: $output_objdir/$libname.filter potentially contains lots of
8454 # 's' commands which not all seds can handle. GNU sed should be fine
8455 # though. Also, the filter scales superlinearly with the number of
8456 # global variables. join(1) would be nice here, but unfortunately
8457 # isn't a blessed tool.
8458 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
8459 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
8460 export_symbols=$output_objdir/$libname.def
8461 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
8466 # Restore the value of output.
8469 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
8470 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
8471 test "X$libobjs" = "X " && libobjs=
8473 # Expand the library linking commands again to reset the
8474 # value of $libobjs for piecewise linking.
8476 # Do each of the archive commands.
8477 if test "$module" = yes && test -n "$module_cmds" ; then
8478 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
8479 cmds=$module_expsym_cmds
8484 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
8485 cmds=$archive_expsym_cmds
8492 if test -n "$delfiles"; then
8493 # Append the command to remove temporary files to $cmds.
8494 eval cmds=\"\$cmds~\$RM $delfiles\"
8497 # Add any objects from preloaded convenience libraries
8498 if test -n "$dlprefiles"; then
8499 gentop="$output_objdir/${outputname}x"
8500 func_append generated " $gentop"
8502 func_extract_archives $gentop $dlprefiles
8503 func_append libobjs " $func_extract_archives_result"
8504 test "X$libobjs" = "X " && libobjs=
8507 save_ifs="$IFS"; IFS='~'
8508 for cmd in $cmds; do
8512 func_quote_for_expand "$cmd"
8513 eval "func_echo $func_quote_for_expand_result"
8515 $opt_dry_run || eval "$cmd" || {
8518 # Restore the uninstalled library and exit
8519 if test "$opt_mode" = relink; then
8520 ( cd "$output_objdir" && \
8521 $RM "${realname}T" && \
8522 $MV "${realname}U" "$realname" )
8530 # Restore the uninstalled library and exit
8531 if test "$opt_mode" = relink; then
8532 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
8534 if test -n "$convenience"; then
8535 if test -z "$whole_archive_flag_spec"; then
8536 func_show_eval '${RM}r "$gentop"'
8543 # Create links to the real library.
8544 for linkname in $linknames; do
8545 if test "$realname" != "$linkname"; then
8546 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
8550 # If -module or -export-dynamic was specified, set the dlname.
8551 if test "$module" = yes || test "$export_dynamic" = yes; then
8552 # On all known operating systems, these are identical.
8559 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
8560 func_warning "\`-dlopen' is ignored for objects"
8565 func_warning "\`-l' and \`-L' are ignored for objects" ;;
8568 test -n "$rpath" && \
8569 func_warning "\`-rpath' is ignored for objects"
8571 test -n "$xrpath" && \
8572 func_warning "\`-R' is ignored for objects"
8574 test -n "$vinfo" && \
8575 func_warning "\`-version-info' is ignored for objects"
8577 test -n "$release" && \
8578 func_warning "\`-release' is ignored for objects"
8582 test -n "$objs$old_deplibs" && \
8583 func_fatal_error "cannot build library object \`$output' from non-libtool objects"
8587 obj=$func_lo2o_result
8595 # Delete the old objects.
8596 $opt_dry_run || $RM $obj $libobj
8598 # Objects from convenience libraries. This assumes
8599 # single-version convenience libraries. Whenever we create
8600 # different ones for PIC/non-PIC, this we'll have to duplicate
8604 # reload_cmds runs $LD directly, so let us get rid of
8605 # -Wl from whole_archive_flag_spec and hope we can get by with
8606 # turning comma into space..
8609 if test -n "$convenience"; then
8610 if test -n "$whole_archive_flag_spec"; then
8611 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
8612 reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
8614 gentop="$output_objdir/${obj}x"
8615 func_append generated " $gentop"
8617 func_extract_archives $gentop $convenience
8618 reload_conv_objs="$reload_objs $func_extract_archives_result"
8622 # If we're not building shared, we need to use non_pic_objs
8623 test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
8625 # Create the old-style object.
8626 reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
8629 func_execute_cmds "$reload_cmds" 'exit $?'
8631 # Exit if we aren't doing a library object file.
8632 if test -z "$libobj"; then
8633 if test -n "$gentop"; then
8634 func_show_eval '${RM}r "$gentop"'
8640 if test "$build_libtool_libs" != yes; then
8641 if test -n "$gentop"; then
8642 func_show_eval '${RM}r "$gentop"'
8645 # Create an invalid libtool object if no PIC, so that we don't
8646 # accidentally link it into a program.
8647 # $show "echo timestamp > $libobj"
8648 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
8652 if test -n "$pic_flag" || test "$pic_mode" != default; then
8653 # Only do commands if we really have different PIC objects.
8654 reload_objs="$libobjs $reload_conv_objs"
8656 func_execute_cmds "$reload_cmds" 'exit $?'
8659 if test -n "$gentop"; then
8660 func_show_eval '${RM}r "$gentop"'
8668 *cygwin*) func_stripname '' '.exe' "$output"
8669 output=$func_stripname_result.exe;;
8671 test -n "$vinfo" && \
8672 func_warning "\`-version-info' is ignored for programs"
8674 test -n "$release" && \
8675 func_warning "\`-release' is ignored for programs"
8677 test "$preload" = yes \
8678 && test "$dlopen_support" = unknown \
8679 && test "$dlopen_self" = unknown \
8680 && test "$dlopen_self_static" = unknown && \
8681 func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
8684 *-*-rhapsody* | *-*-darwin1.[012])
8685 # On Rhapsody replace the C library is the System framework
8686 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
8687 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
8693 # Don't allow lazy linking, it breaks C++ global constructors
8694 # But is supposedly fixed on 10.4 or later (yay!).
8695 if test "$tagname" = CXX ; then
8696 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8698 func_append compile_command " ${wl}-bind_at_load"
8699 func_append finalize_command " ${wl}-bind_at_load"
8703 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8704 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8705 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8710 # move library search paths that coincide with paths to not yet
8711 # installed libraries to the beginning of the library search list
8713 for path in $notinst_path; do
8714 case " $new_libs " in
8715 *" -L$path/$objdir "*) ;;
8717 case " $compile_deplibs " in
8718 *" -L$path/$objdir "*)
8719 func_append new_libs " -L$path/$objdir" ;;
8724 for deplib in $compile_deplibs; do
8727 case " $new_libs " in
8729 *) func_append new_libs " $deplib" ;;
8732 *) func_append new_libs " $deplib" ;;
8735 compile_deplibs="$new_libs"
8738 func_append compile_command " $compile_deplibs"
8739 func_append finalize_command " $finalize_deplibs"
8741 if test -n "$rpath$xrpath"; then
8742 # If the user specified any rpath flags, then add them.
8743 for libdir in $rpath $xrpath; do
8744 # This is the magic to use -rpath.
8745 case "$finalize_rpath " in
8747 *) func_append finalize_rpath " $libdir" ;;
8752 # Now hardcode the library paths
8755 for libdir in $compile_rpath $finalize_rpath; do
8756 if test -n "$hardcode_libdir_flag_spec"; then
8757 if test -n "$hardcode_libdir_separator"; then
8758 if test -z "$hardcode_libdirs"; then
8759 hardcode_libdirs="$libdir"
8761 # Just accumulate the unique libdirs.
8762 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8763 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8766 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8771 eval flag=\"$hardcode_libdir_flag_spec\"
8772 func_append rpath " $flag"
8774 elif test -n "$runpath_var"; then
8775 case "$perm_rpath " in
8777 *) func_append perm_rpath " $libdir" ;;
8781 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8782 testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8783 case :$dllsearchpath: in
8785 ::) dllsearchpath=$libdir;;
8786 *) func_append dllsearchpath ":$libdir";;
8788 case :$dllsearchpath: in
8789 *":$testbindir:"*) ;;
8790 ::) dllsearchpath=$testbindir;;
8791 *) func_append dllsearchpath ":$testbindir";;
8796 # Substitute the hardcoded libdirs into the rpath.
8797 if test -n "$hardcode_libdir_separator" &&
8798 test -n "$hardcode_libdirs"; then
8799 libdir="$hardcode_libdirs"
8800 eval rpath=\" $hardcode_libdir_flag_spec\"
8802 compile_rpath="$rpath"
8806 for libdir in $finalize_rpath; do
8807 if test -n "$hardcode_libdir_flag_spec"; then
8808 if test -n "$hardcode_libdir_separator"; then
8809 if test -z "$hardcode_libdirs"; then
8810 hardcode_libdirs="$libdir"
8812 # Just accumulate the unique libdirs.
8813 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8814 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8817 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
8822 eval flag=\"$hardcode_libdir_flag_spec\"
8823 func_append rpath " $flag"
8825 elif test -n "$runpath_var"; then
8826 case "$finalize_perm_rpath " in
8828 *) func_append finalize_perm_rpath " $libdir" ;;
8832 # Substitute the hardcoded libdirs into the rpath.
8833 if test -n "$hardcode_libdir_separator" &&
8834 test -n "$hardcode_libdirs"; then
8835 libdir="$hardcode_libdirs"
8836 eval rpath=\" $hardcode_libdir_flag_spec\"
8838 finalize_rpath="$rpath"
8840 if test -n "$libobjs" && test "$build_old_libs" = yes; then
8841 # Transform all the library objects into standard objects.
8842 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8843 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
8846 func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8848 # template prelinking step
8849 if test -n "$prelink_cmds"; then
8850 func_execute_cmds "$prelink_cmds" 'exit $?'
8853 wrappers_required=yes
8855 *cegcc* | *mingw32ce*)
8856 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
8857 wrappers_required=no
8859 *cygwin* | *mingw* )
8860 if test "$build_libtool_libs" != yes; then
8861 wrappers_required=no
8865 if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8866 wrappers_required=no
8870 if test "$wrappers_required" = no; then
8871 # Replace the output file specification.
8872 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8873 link_command="$compile_command$compile_rpath"
8875 # We have no uninstalled library dependencies, so finalize right now.
8877 func_show_eval "$link_command" 'exit_status=$?'
8879 if test -n "$postlink_cmds"; then
8880 func_to_tool_file "$output"
8881 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8882 func_execute_cmds "$postlink_cmds" 'exit $?'
8885 # Delete the generated files.
8886 if test -f "$output_objdir/${outputname}S.${objext}"; then
8887 func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8893 if test -n "$compile_shlibpath$finalize_shlibpath"; then
8894 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8896 if test -n "$finalize_shlibpath"; then
8897 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8902 if test -n "$runpath_var"; then
8903 if test -n "$perm_rpath"; then
8904 # We should set the runpath_var.
8906 for dir in $perm_rpath; do
8907 func_append rpath "$dir:"
8909 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8911 if test -n "$finalize_perm_rpath"; then
8912 # We should set the runpath_var.
8914 for dir in $finalize_perm_rpath; do
8915 func_append rpath "$dir:"
8917 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8921 if test "$no_install" = yes; then
8922 # We don't need to create a wrapper script.
8923 link_command="$compile_var$compile_command$compile_rpath"
8924 # Replace the output file specification.
8925 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
8926 # Delete the old output file.
8927 $opt_dry_run || $RM $output
8928 # Link the executable and exit
8929 func_show_eval "$link_command" 'exit $?'
8931 if test -n "$postlink_cmds"; then
8932 func_to_tool_file "$output"
8933 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
8934 func_execute_cmds "$postlink_cmds" 'exit $?'
8940 if test "$hardcode_action" = relink; then
8941 # Fast installation is not supported
8942 link_command="$compile_var$compile_command$compile_rpath"
8943 relink_command="$finalize_var$finalize_command$finalize_rpath"
8945 func_warning "this platform does not like uninstalled shared libraries"
8946 func_warning "\`$output' will be relinked during installation"
8948 if test "$fast_install" != no; then
8949 link_command="$finalize_var$compile_command$finalize_rpath"
8950 if test "$fast_install" = yes; then
8951 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
8953 # fast_install is set to needless
8957 link_command="$compile_var$compile_command$compile_rpath"
8958 relink_command="$finalize_var$finalize_command$finalize_rpath"
8962 # Replace the output file specification.
8963 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8965 # Delete the old output files.
8966 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8968 func_show_eval "$link_command" 'exit $?'
8970 if test -n "$postlink_cmds"; then
8971 func_to_tool_file "$output_objdir/$outputname"
8972 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'`
8973 func_execute_cmds "$postlink_cmds" 'exit $?'
8976 # Now create the wrapper script.
8977 func_verbose "creating $output"
8979 # Quote the relink command for shipping.
8980 if test -n "$relink_command"; then
8981 # Preserve any variables that may affect compiler behavior
8982 for var in $variables_saved_for_relink; do
8983 if eval test -z \"\${$var+set}\"; then
8984 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8985 elif eval var_value=\$$var; test -z "$var_value"; then
8986 relink_command="$var=; export $var; $relink_command"
8988 func_quote_for_eval "$var_value"
8989 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8992 relink_command="(cd `pwd`; $relink_command)"
8993 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
8996 # Only actually do things if not in dry run mode.
8998 # win32 will think the script is a binary if it has
8999 # a .exe suffix, so we strip it off here.
9001 *.exe) func_stripname '' '.exe' "$output"
9002 output=$func_stripname_result ;;
9004 # test for cygwin because mv fails w/o .exe extensions
9008 func_stripname '' '.exe' "$outputname"
9009 outputname=$func_stripname_result ;;
9013 *cygwin* | *mingw* )
9014 func_dirname_and_basename "$output" "" "."
9015 output_name=$func_basename_result
9016 output_path=$func_dirname_result
9017 cwrappersource="$output_path/$objdir/lt-$output_name.c"
9018 cwrapper="$output_path/$output_name.exe"
9019 $RM $cwrappersource $cwrapper
9020 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
9022 func_emit_cwrapperexe_src > $cwrappersource
9024 # The wrapper executable is built using the $host compiler,
9025 # because it contains $host paths and files. If cross-
9026 # compiling, it, like the target executable, must be
9027 # executed on the $host or under an emulation environment.
9029 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
9033 # Now, create the wrapper script for func_source use:
9034 func_ltwrapper_scriptname $cwrapper
9035 $RM $func_ltwrapper_scriptname_result
9036 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
9038 # note: this script will not be executed, so do not chmod.
9039 if test "x$build" = "x$host" ; then
9040 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
9042 func_emit_wrapper no > $func_ltwrapper_scriptname_result
9048 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
9050 func_emit_wrapper no > $output
9059 # See if we need to build an old-fashioned archive.
9060 for oldlib in $oldlibs; do
9062 if test "$build_libtool_libs" = convenience; then
9063 oldobjs="$libobjs_save $symfileobj"
9064 addlibs="$convenience"
9065 build_libtool_libs=no
9067 if test "$build_libtool_libs" = module; then
9068 oldobjs="$libobjs_save"
9069 build_libtool_libs=no
9071 oldobjs="$old_deplibs $non_pic_objects"
9072 if test "$preload" = yes && test -f "$symfileobj"; then
9073 func_append oldobjs " $symfileobj"
9076 addlibs="$old_convenience"
9079 if test -n "$addlibs"; then
9080 gentop="$output_objdir/${outputname}x"
9081 func_append generated " $gentop"
9083 func_extract_archives $gentop $addlibs
9084 func_append oldobjs " $func_extract_archives_result"
9087 # Do each command in the archive commands.
9088 if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
9089 cmds=$old_archive_from_new_cmds
9092 # Add any objects from preloaded convenience libraries
9093 if test -n "$dlprefiles"; then
9094 gentop="$output_objdir/${outputname}x"
9095 func_append generated " $gentop"
9097 func_extract_archives $gentop $dlprefiles
9098 func_append oldobjs " $func_extract_archives_result"
9101 # POSIX demands no paths to be encoded in archives. We have
9102 # to avoid creating archives with duplicate basenames if we
9103 # might have to extract them afterwards, e.g., when creating a
9104 # static archive out of a convenience library, or when linking
9105 # the entirety of a libtool archive into another (currently
9106 # not supported by libtool).
9107 if (for obj in $oldobjs
9109 func_basename "$obj"
9110 $ECHO "$func_basename_result"
9111 done | sort | sort -uc >/dev/null 2>&1); then
9114 echo "copying selected object files to avoid basename conflicts..."
9115 gentop="$output_objdir/${outputname}x"
9116 func_append generated " $gentop"
9117 func_mkdir_p "$gentop"
9118 save_oldobjs=$oldobjs
9121 for obj in $save_oldobjs
9123 func_basename "$obj"
9124 objbase="$func_basename_result"
9125 case " $oldobjs " in
9126 " ") oldobjs=$obj ;;
9129 # Make sure we don't pick an alternate name that also
9131 newobj=lt$counter-$objbase
9132 func_arith $counter + 1
9133 counter=$func_arith_result
9134 case " $oldobjs " in
9135 *[\ /]"$newobj "*) ;;
9136 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
9139 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
9140 func_append oldobjs " $gentop/$newobj"
9142 *) func_append oldobjs " $obj" ;;
9146 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
9147 tool_oldlib=$func_to_tool_file_result
9148 eval cmds=\"$old_archive_cmds\"
9151 len=$func_len_result
9152 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
9153 cmds=$old_archive_cmds
9154 elif test -n "$archiver_list_spec"; then
9155 func_verbose "using command file archive linking..."
9158 func_to_tool_file "$obj"
9159 $ECHO "$func_to_tool_file_result"
9160 done > $output_objdir/$libname.libcmd
9161 func_to_tool_file "$output_objdir/$libname.libcmd"
9162 oldobjs=" $archiver_list_spec$func_to_tool_file_result"
9163 cmds=$old_archive_cmds
9165 # the command line is too long to link in one step, link in parts
9166 func_verbose "using piecewise archive linking..."
9171 save_oldobjs=$oldobjs
9173 # Is there a better way of finding the last object in the list?
9174 for obj in $save_oldobjs
9178 eval test_cmds=\"$old_archive_cmds\"
9179 func_len " $test_cmds"
9180 len0=$func_len_result
9182 for obj in $save_oldobjs
9185 func_arith $len + $func_len_result
9186 len=$func_arith_result
9187 func_append objlist " $obj"
9188 if test "$len" -lt "$max_cmd_len"; then
9191 # the above command should be used before it gets too long
9193 if test "$obj" = "$last_oldobj" ; then
9196 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
9197 eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
9204 if test "X$oldobjs" = "X" ; then
9205 eval cmds=\"\$concat_cmds\"
9207 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
9211 func_execute_cmds "$cmds" 'exit $?'
9214 test -n "$generated" && \
9215 func_show_eval "${RM}r$generated"
9217 # Now create the libtool archive.
9221 test "$build_old_libs" = yes && old_library="$libname.$libext"
9222 func_verbose "creating $output"
9224 # Preserve any variables that may affect compiler behavior
9225 for var in $variables_saved_for_relink; do
9226 if eval test -z \"\${$var+set}\"; then
9227 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
9228 elif eval var_value=\$$var; test -z "$var_value"; then
9229 relink_command="$var=; export $var; $relink_command"
9231 func_quote_for_eval "$var_value"
9232 relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
9235 # Quote the link command for shipping.
9236 relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
9237 relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
9238 if test "$hardcode_automatic" = yes ; then
9242 # Only create the output if not a dry run.
9244 for installed in no yes; do
9245 if test "$installed" = yes; then
9246 if test -z "$install_libdir"; then
9249 output="$output_objdir/$outputname"i
9250 # Replace all uninstalled libtool libraries with the installed ones
9252 for deplib in $dependency_libs; do
9255 func_basename "$deplib"
9256 name="$func_basename_result"
9257 func_resolve_sysroot "$deplib"
9258 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
9259 test -z "$libdir" && \
9260 func_fatal_error "\`$deplib' is not a valid libtool archive"
9261 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
9264 func_stripname -L '' "$deplib"
9265 func_replace_sysroot "$func_stripname_result"
9266 func_append newdependency_libs " -L$func_replace_sysroot_result"
9269 func_stripname -R '' "$deplib"
9270 func_replace_sysroot "$func_stripname_result"
9271 func_append newdependency_libs " -R$func_replace_sysroot_result"
9273 *) func_append newdependency_libs " $deplib" ;;
9276 dependency_libs="$newdependency_libs"
9279 for lib in $dlfiles; do
9282 func_basename "$lib"
9283 name="$func_basename_result"
9284 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9285 test -z "$libdir" && \
9286 func_fatal_error "\`$lib' is not a valid libtool archive"
9287 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
9289 *) func_append newdlfiles " $lib" ;;
9292 dlfiles="$newdlfiles"
9294 for lib in $dlprefiles; do
9297 # Only pass preopened files to the pseudo-archive (for
9298 # eventual linking with the app. that links it) if we
9299 # didn't already link the preopened objects directly into
9301 func_basename "$lib"
9302 name="$func_basename_result"
9303 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
9304 test -z "$libdir" && \
9305 func_fatal_error "\`$lib' is not a valid libtool archive"
9306 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
9310 dlprefiles="$newdlprefiles"
9313 for lib in $dlfiles; do
9315 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9316 *) abs=`pwd`"/$lib" ;;
9318 func_append newdlfiles " $abs"
9320 dlfiles="$newdlfiles"
9322 for lib in $dlprefiles; do
9324 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
9325 *) abs=`pwd`"/$lib" ;;
9327 func_append newdlprefiles " $abs"
9329 dlprefiles="$newdlprefiles"
9332 # place dlname in correct position for cygwin
9333 # In fact, it would be nice if we could use this code for all target
9334 # systems that can't hard-code library paths into their executables
9335 # and that have no shared library path variable independent of PATH,
9336 # but it turns out we can't easily determine that from inspecting
9337 # libtool variables, so we have to hard-code the OSs to which it
9338 # applies here; at the moment, that means platforms that use the PE
9339 # object format with DLL files. See the long comment at the top of
9340 # tests/bindir.at for full details.
9342 case $host,$output,$installed,$module,$dlname in
9343 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
9344 # If a -bindir argument was supplied, place the dll there.
9345 if test "x$bindir" != x ;
9347 func_relative_path "$install_libdir" "$bindir"
9348 tdlname=$func_relative_path_result$dlname
9350 # Otherwise fall back on heuristic.
9351 tdlname=../bin/$dlname
9356 # $outputname - a libtool library file
9357 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
9359 # Please DO NOT delete this file!
9360 # It is necessary for linking the library.
9362 # The name that we can dlopen(3).
9365 # Names of this library.
9366 library_names='$library_names'
9368 # The name of the static archive.
9369 old_library='$old_library'
9371 # Linker flags that can not go in dependency_libs.
9372 inherited_linker_flags='$new_inherited_linker_flags'
9374 # Libraries that this one depends upon.
9375 dependency_libs='$dependency_libs'
9377 # Names of additional weak libraries provided by this library
9378 weak_library_names='$weak_libs'
9380 # Version information for $libname.
9385 # Is this an already installed library?
9386 installed=$installed
9388 # Should we warn about portability when linking against -modules?
9389 shouldnotlink=$module
9391 # Files to dlopen/dlpreopen
9393 dlpreopen='$dlprefiles'
9395 # Directory that this library needs to be installed in:
9396 libdir='$install_libdir'"
9397 if test "$installed" = no && test "$need_relink" = yes; then
9399 relink_command=\"$relink_command\""
9404 # Do a symbolic link so that the libtool archive can be found in
9405 # LD_LIBRARY_PATH before the program is installed.
9406 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
9412 { test "$opt_mode" = link || test "$opt_mode" = relink; } &&
9413 func_mode_link ${1+"$@"}
9416 # func_mode_uninstall arg...
9417 func_mode_uninstall ()
9425 # This variable tells wrapper scripts just to set variables rather
9426 # than running their programs.
9427 libtool_install_magic="$magic"
9432 -f) func_append RM " $arg"; rmforce=yes ;;
9433 -*) func_append RM " $arg" ;;
9434 *) func_append files " $arg" ;;
9439 func_fatal_help "you must specify an RM program"
9443 for file in $files; do
9444 func_dirname "$file" "" "."
9445 dir="$func_dirname_result"
9446 if test "X$dir" = X.; then
9451 func_basename "$file"
9452 name="$func_basename_result"
9453 test "$opt_mode" = uninstall && odir="$dir"
9455 # Remember odir for removal later, being careful to avoid duplicates
9456 if test "$opt_mode" = clean; then
9459 *) func_append rmdirs " $odir" ;;
9463 # Don't error if the file doesn't exist and rm -f was used.
9464 if { test -L "$file"; } >/dev/null 2>&1 ||
9465 { test -h "$file"; } >/dev/null 2>&1 ||
9466 test -f "$file"; then
9468 elif test -d "$file"; then
9471 elif test "$rmforce" = yes; then
9479 # Possibly a libtool archive, so verify it.
9480 if func_lalib_p "$file"; then
9481 func_source $dir/$name
9483 # Delete the libtool libraries and symlinks.
9484 for n in $library_names; do
9485 func_append rmfiles " $odir/$n"
9487 test -n "$old_library" && func_append rmfiles " $odir/$old_library"
9491 case " $library_names " in
9493 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
9495 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
9498 if test -n "$library_names"; then
9499 # Do each command in the postuninstall commands.
9500 func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9503 if test -n "$old_library"; then
9504 # Do each command in the old_postuninstall commands.
9505 func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
9507 # FIXME: should reinstall the best remaining shared library.
9514 # Possibly a libtool object, so verify it.
9515 if func_lalib_p "$file"; then
9518 func_source $dir/$name
9520 # Add PIC object to the list of files to remove.
9521 if test -n "$pic_object" &&
9522 test "$pic_object" != none; then
9523 func_append rmfiles " $dir/$pic_object"
9526 # Add non-PIC object to the list of files to remove.
9527 if test -n "$non_pic_object" &&
9528 test "$non_pic_object" != none; then
9529 func_append rmfiles " $dir/$non_pic_object"
9535 if test "$opt_mode" = clean ; then
9539 func_stripname '' '.exe' "$file"
9540 file=$func_stripname_result
9541 func_stripname '' '.exe' "$name"
9542 noexename=$func_stripname_result
9543 # $file with .exe has already been added to rmfiles,
9544 # add $file without .exe
9545 func_append rmfiles " $file"
9548 # Do a test to see if this is a libtool program.
9549 if func_ltwrapper_p "$file"; then
9550 if func_ltwrapper_executable_p "$file"; then
9551 func_ltwrapper_scriptname "$file"
9553 func_source $func_ltwrapper_scriptname_result
9554 func_append rmfiles " $func_ltwrapper_scriptname_result"
9557 func_source $dir/$noexename
9560 # note $name still contains .exe if it was in $file originally
9561 # as does the version of $file that was added into $rmfiles
9562 func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
9563 if test "$fast_install" = yes && test -n "$relink_command"; then
9564 func_append rmfiles " $odir/lt-$name"
9566 if test "X$noexename" != "X$name" ; then
9567 func_append rmfiles " $odir/lt-${noexename}.c"
9573 func_show_eval "$RM $rmfiles" 'exit_status=1'
9576 # Try to remove the ${objdir}s in the directories where we deleted files
9577 for dir in $rmdirs; do
9578 if test -d "$dir"; then
9579 func_show_eval "rmdir $dir >/dev/null 2>&1"
9586 { test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
9587 func_mode_uninstall ${1+"$@"}
9589 test -z "$opt_mode" && {
9590 help="$generic_help"
9591 func_fatal_help "you must specify a MODE"
9594 test -z "$exec_cmd" && \
9595 func_fatal_help "invalid operation mode \`$opt_mode'"
9597 if test -n "$exec_cmd"; then
9598 eval exec "$exec_cmd"
9605 # The TAGs below are defined such that we never get into a situation
9606 # in which we disable both kinds of libraries. Given conflicting
9607 # choices, we go for a static library, that is the most portable,
9608 # since we can't tell whether shared libraries were disabled because
9609 # the user asked for that or because the platform doesn't support
9610 # them. This is particularly important on AIX, because we don't
9611 # support having both static and shared libraries enabled at the same
9612 # time on that platform, so we default to a shared-only configuration.
9613 # If a disable-shared tag is given, we'll fallback to a static-only
9614 # configuration. But we'll never go from static-only to shared-only.
9616 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
9617 build_libtool_libs=no
9619 # ### END LIBTOOL TAG CONFIG: disable-shared
9621 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
9622 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
9623 # ### END LIBTOOL TAG CONFIG: disable-static