2 # libtool (GNU libtool) 2.4
3 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
6 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
7 # This is free software; see the source for copying conditions. There is NO
8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10 # GNU Libtool is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
15 # As a special exception to the GNU General Public License,
16 # if you distribute this file as part of a program or library that
17 # is built using GNU Libtool, you may include this file under the
18 # same distribution terms that you use for the rest of that program.
20 # GNU Libtool is distributed in the hope that it will be useful, but
21 # WITHOUT ANY WARRANTY; without even the implied warranty of
22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 # General Public License for more details.
25 # You should have received a copy of the GNU General Public License
26 # along with GNU Libtool; see the file COPYING. If not, a copy
27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
28 # or obtained by writing to the Free Software Foundation, Inc.,
29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31 # Usage: $progname [OPTION]... [MODE-ARG]...
33 # Provide generalized library-building support services.
35 # --config show all configuration variables
36 # --debug enable verbose shell tracing
37 # -n, --dry-run display commands without modifying any files
38 # --features display basic configuration information and exit
39 # --mode=MODE use operation mode MODE
40 # --preserve-dup-deps don't remove duplicate dependency libraries
41 # --quiet, --silent don't print informational messages
42 # --no-quiet, --no-silent
43 # print informational messages (default)
44 # --tag=TAG use configuration variables from tag TAG
45 # -v, --verbose print more informational messages than default
46 # --no-verbose don't print the extra informational messages
47 # --version print version information
48 # -h, --help, --help-all print short, long, or detailed help message
50 # MODE must be one of the following:
52 # clean remove files from the build directory
53 # compile compile a source file into a libtool object
54 # execute automatically set library path, then run a program
55 # finish complete the installation of libtool libraries
56 # install install libraries or executables
57 # link create a library or an executable
58 # uninstall remove libraries from an installed directory
60 # MODE-ARGS vary depending on the MODE. When passed as first option,
61 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
62 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
64 # When reporting a bug, please describe a test case to reproduce it and
65 # include the following information:
70 # compiler flags: $LTCFLAGS
71 # linker: $LD (gnu? $with_gnu_ld)
72 # $progname: (GNU libtool) 2.4
73 # automake: $automake_version
74 # autoconf: $autoconf_version
76 # Report bugs to <bug-libtool@gnu.org>.
77 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
78 # General help using GNU software: <http://www.gnu.org/gethelp/>.
84 package_revision=1.3293
86 # Be Bourne compatible
87 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
90 # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
91 # is contrary to our usage. Disable this feature.
92 alias -g '${1+"$@"}'='"$@"'
95 case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
97 BIN_SH=xpg4; export BIN_SH # for Tru64
98 DUALCASE=1; export DUALCASE # for MKS sh
100 # A function that is used when there is no print builtin or printf.
101 func_fallback_echo ()
103 eval 'cat <<_LTECHO_EOF
108 # NLS nuisances: We save the old values to restore during execute mode.
111 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
113 eval "if test \"\${$lt_var+set}\" = set; then
114 save_$lt_var=\$$lt_var
117 lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
118 lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
123 export LANGUAGE LC_ALL
128 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
129 # is ksh but when the shell is invoked as "sh" and the current value of
130 # the _XPG environment variable is not equal to 1 (one), the special
131 # positional parameter $0, within a function call, is the name of the
138 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
148 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
149 : ${Xsed="$SED -e 1s/^X//"}
154 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
155 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
157 exit_status=$EXIT_SUCCESS
159 # Make sure IFS has a sensible default
164 dirname="s,/[^/]*$,,"
167 # func_dirname file append nondir_replacement
168 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
169 # otherwise set result to NONDIR_REPLACEMENT.
172 func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
173 if test "X$func_dirname_result" = "X${1}"; then
174 func_dirname_result="${3}"
176 func_dirname_result="$func_dirname_result${2}"
178 } # func_dirname may be replaced by extended shell implementation
184 func_basename_result=`$ECHO "${1}" | $SED "$basename"`
185 } # func_basename may be replaced by extended shell implementation
188 # func_dirname_and_basename file append nondir_replacement
189 # perform func_basename and func_dirname in a single function
191 # dirname: Compute the dirname of FILE. If nonempty,
192 # add APPEND to the result, otherwise set result
193 # to NONDIR_REPLACEMENT.
194 # value returned in "$func_dirname_result"
195 # basename: Compute filename of FILE.
196 # value retuned in "$func_basename_result"
197 # Implementation must be kept synchronized with func_dirname
198 # and func_basename. For efficiency, we do not delegate to
199 # those functions but instead duplicate the functionality here.
200 func_dirname_and_basename ()
202 # Extract subdirectory from the argument.
203 func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
204 if test "X$func_dirname_result" = "X${1}"; then
205 func_dirname_result="${3}"
207 func_dirname_result="$func_dirname_result${2}"
209 func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
210 } # func_dirname_and_basename may be replaced by extended shell implementation
213 # func_stripname prefix suffix name
214 # strip PREFIX and SUFFIX off of NAME.
215 # PREFIX and SUFFIX must not contain globbing or regex special
216 # characters, hashes, percent signs, but SUFFIX may contain a leading
217 # dot (in which case that matches only a dot).
218 # func_strip_suffix prefix name
222 .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
223 *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
225 } # func_stripname may be replaced by extended shell implementation
228 # These SED scripts presuppose an absolute path with a trailing slash.
229 pathcar='s,^/\([^/]*\).*$,\1,'
230 pathcdr='s,^/[^/]*,,'
231 removedotparts=':dotsl
235 collapseslashes='s@/\{1,\}@/@g'
236 finalslash='s,/*$,/,'
238 # func_normal_abspath PATH
239 # Remove doubled-up and trailing slashes, "." path components,
240 # and cancel out any ".." path components in PATH after making
241 # it an absolute path.
242 # value returned in "$func_normal_abspath_result"
243 func_normal_abspath ()
245 # Start from root dir and reassemble the path.
246 func_normal_abspath_result=
247 func_normal_abspath_tpath=$1
248 func_normal_abspath_altnamespace=
249 case $func_normal_abspath_tpath in
251 # Empty path, that just means $cwd.
252 func_stripname '' '/' "`pwd`"
253 func_normal_abspath_result=$func_stripname_result
256 # The next three entries are used to spot a run of precisely
257 # two leading slashes without using negated character classes;
258 # we take advantage of case's first-match behaviour.
260 # Unusual form of absolute path, do nothing.
263 # Not necessarily an ordinary path; POSIX reserves leading '//'
264 # and for example Cygwin uses it to access remote file shares
265 # over CIFS/SMB, so we conserve a leading double slash if found.
266 func_normal_abspath_altnamespace=/
269 # Absolute path, do nothing.
272 # Relative path, prepend $cwd.
273 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
276 # Cancel out all the simple stuff to save iterations. We also want
277 # the path to end with a slash for ease of parsing, so make sure
278 # there is one (and only one) here.
279 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
280 -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
282 # Processed it all yet?
283 if test "$func_normal_abspath_tpath" = / ; then
284 # If we ascended to the root using ".." the result may be empty now.
285 if test -z "$func_normal_abspath_result" ; then
286 func_normal_abspath_result=/
290 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
292 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
294 # Figure out what to do with it
295 case $func_normal_abspath_tcomponent in
297 # Trailing empty path component, ignore it.
300 # Parent dir; strip last assembled component from result.
301 func_dirname "$func_normal_abspath_result"
302 func_normal_abspath_result=$func_dirname_result
305 # Actual path component, append it.
306 func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
310 # Restore leading double-slash if one was found on entry.
311 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
314 # func_relative_path SRCDIR DSTDIR
315 # generates a relative path from SRCDIR to DSTDIR, with a trailing
316 # slash if non-empty, suitable for immediately appending a filename
317 # without needing to append a separator.
318 # value returned in "$func_relative_path_result"
319 func_relative_path ()
321 func_relative_path_result=
322 func_normal_abspath "$1"
323 func_relative_path_tlibdir=$func_normal_abspath_result
324 func_normal_abspath "$2"
325 func_relative_path_tbindir=$func_normal_abspath_result
327 # Ascend the tree starting from libdir
329 # check if we have found a prefix of bindir
330 case $func_relative_path_tbindir in
331 $func_relative_path_tlibdir)
332 # found an exact match
333 func_relative_path_tcancelled=
336 $func_relative_path_tlibdir*)
337 # found a matching prefix
338 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
339 func_relative_path_tcancelled=$func_stripname_result
340 if test -z "$func_relative_path_result"; then
341 func_relative_path_result=.
346 func_dirname $func_relative_path_tlibdir
347 func_relative_path_tlibdir=${func_dirname_result}
348 if test "x$func_relative_path_tlibdir" = x ; then
349 # Have to descend all the way to the root!
350 func_relative_path_result=../$func_relative_path_result
351 func_relative_path_tcancelled=$func_relative_path_tbindir
354 func_relative_path_result=../$func_relative_path_result
359 # Now calculate path; take care to avoid doubling-up slashes.
360 func_stripname '' '/' "$func_relative_path_result"
361 func_relative_path_result=$func_stripname_result
362 func_stripname '/' '/' "$func_relative_path_tcancelled"
363 if test "x$func_stripname_result" != x ; then
364 func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
367 # Normalisation. If bindir is libdir, return empty string,
368 # else relative path ending with a slash; either way, target
369 # file name can be directly appended.
370 if test ! -z "$func_relative_path_result"; then
371 func_stripname './' '' "$func_relative_path_result/"
372 func_relative_path_result=$func_stripname_result
376 # The name of this program:
377 func_dirname_and_basename "$progpath"
378 progname=$func_basename_result
380 # Make sure we have an absolute path for reexecution:
382 [\\/]*|[A-Za-z]:\\*) ;;
384 progdir=$func_dirname_result
385 progdir=`cd "$progdir" && pwd`
386 progpath="$progdir/$progname"
391 for progdir in $PATH; do
393 test -x "$progdir/$progname" && break
396 test -n "$progdir" || progdir=`pwd`
397 progpath="$progdir/$progname"
401 # Sed substitution that helps us do robust quoting. It backslashifies
402 # metacharacters that are still active within double-quoted strings.
403 Xsed="${SED}"' -e 1s/^X//'
404 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
406 # Same as above, but do not quote variable references.
407 double_quote_subst='s/\(["`\\]\)/\\\1/g'
409 # Sed substitution that turns a string into a regex matching for the
411 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
413 # Sed substitution that converts a w32 file name or path
414 # which contains forward slashes, into one that contains
415 # (escaped) backslashes. A very naive implementation.
416 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
418 # Re-`\' parameter expansions in output of double_quote_subst that were
419 # `\'-ed in input to the same. If an odd number of `\' preceded a '$'
420 # in input to double_quote_subst, that '$' was protected from expansion.
421 # Since each input `\' is now two `\'s, look for any number of runs of
422 # four `\'s followed by two `\'s and then a '$'. `\' that '$'.
427 sed_double_backslash="\
431 s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
442 # Echo program name prefixed message, along with the current mode
443 # name if it has been set yet.
446 $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
449 # func_verbose arg...
450 # Echo program name prefixed message in verbose mode only.
453 $opt_verbose && func_echo ${1+"$@"}
455 # A bug in bash halts the script if the last line of a function
456 # fails when set -e is in force, so we need another command to
461 # func_echo_all arg...
462 # Invoke $ECHO with all args, space-separated.
469 # Echo program name prefixed message to standard error.
472 $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
475 # func_warning arg...
476 # Echo program name prefixed warning message to standard error.
479 $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
485 # func_fatal_error arg...
486 # Echo program name prefixed message to standard error, and exit.
493 # func_fatal_help arg...
494 # Echo program name prefixed message to standard error, followed by
495 # a help hint, and exit.
499 func_fatal_error "$help"
501 help="Try \`$progname --help' for more information." ## default
504 # func_grep expression filename
505 # Check whether EXPRESSION matches any line of FILENAME, without output.
508 $GREP "$1" "$2" >/dev/null 2>&1
512 # func_mkdir_p directory-path
513 # Make sure the entire path to DIRECTORY-PATH is available.
516 my_directory_path="$1"
519 if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
521 # Protect directory names starting with `-'
522 case $my_directory_path in
523 -*) my_directory_path="./$my_directory_path" ;;
526 # While some portion of DIR does not yet exist...
527 while test ! -d "$my_directory_path"; do
528 # ...make a list in topmost first order. Use a colon delimited
529 # list incase some portion of path contains whitespace.
530 my_dir_list="$my_directory_path:$my_dir_list"
532 # If the last portion added has no slash in it, the list is done
533 case $my_directory_path in */*) ;; *) break ;; esac
535 # ...otherwise throw away the child directory and loop
536 my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
538 my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
540 save_mkdir_p_IFS="$IFS"; IFS=':'
541 for my_dir in $my_dir_list; do
542 IFS="$save_mkdir_p_IFS"
543 # mkdir can fail with a `File exist' error if two processes
544 # try to create one of the directories concurrently. Don't
546 $MKDIR "$my_dir" 2>/dev/null || :
548 IFS="$save_mkdir_p_IFS"
550 # Bail out if we (or some other process) failed to create a directory.
551 test -d "$my_directory_path" || \
552 func_fatal_error "Failed to create \`$1'"
557 # func_mktempdir [string]
558 # Make a temporary directory that won't clash with other running
559 # libtool processes, and avoids race conditions if possible. If
560 # given, STRING is the basename for that directory.
563 my_template="${TMPDIR-/tmp}/${1-$progname}"
565 if test "$opt_dry_run" = ":"; then
566 # Return a directory name, but don't create it in dry-run mode
567 my_tmpdir="${my_template}-$$"
570 # If mktemp works, use that first and foremost
571 my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
573 if test ! -d "$my_tmpdir"; then
574 # Failing that, at least try and use $RANDOM to avoid a race
575 my_tmpdir="${my_template}-${RANDOM-0}$$"
577 save_mktempdir_umask=`umask`
580 umask $save_mktempdir_umask
583 # If we're not in dry-run mode, bomb out on failure
584 test -d "$my_tmpdir" || \
585 func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
592 # func_quote_for_eval arg
593 # Aesthetically quote ARG to be evaled later.
594 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
595 # is double-quoted, suitable for a subsequent eval, whereas
596 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
597 # which are still active within double quotes backslashified.
598 func_quote_for_eval ()
602 func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
604 func_quote_for_eval_unquoted_result="$1" ;;
607 case $func_quote_for_eval_unquoted_result in
608 # Double-quote args containing shell metacharacters to delay
609 # word splitting, command substitution and and variable
610 # expansion for a subsequent eval.
611 # Many Bourne shells cannot handle close brackets correctly
612 # in scan sets, so we specify it separately.
613 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
614 func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
617 func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
622 # func_quote_for_expand arg
623 # Aesthetically quote ARG to be evaled later; same as above,
624 # but do not quote variable references.
625 func_quote_for_expand ()
629 my_arg=`$ECHO "$1" | $SED \
630 -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
636 # Double-quote args containing shell metacharacters to delay
637 # word splitting and command substitution for a subsequent eval.
638 # Many Bourne shells cannot handle close brackets correctly
639 # in scan sets, so we specify it separately.
640 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
645 func_quote_for_expand_result="$my_arg"
649 # func_show_eval cmd [fail_exp]
650 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
651 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
652 # is given, then evaluate it.
658 ${opt_silent-false} || {
659 func_quote_for_expand "$my_cmd"
660 eval "func_echo $func_quote_for_expand_result"
663 if ${opt_dry_run-false}; then :; else
666 if test "$my_status" -eq 0; then :; else
667 eval "(exit $my_status); $my_fail_exp"
673 # func_show_eval_locale cmd [fail_exp]
674 # Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
675 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
676 # is given, then evaluate it. Use the saved locale for evaluation.
677 func_show_eval_locale ()
682 ${opt_silent-false} || {
683 func_quote_for_expand "$my_cmd"
684 eval "func_echo $func_quote_for_expand_result"
687 if ${opt_dry_run-false}; then :; else
688 eval "$lt_user_locale
691 eval "$lt_safe_locale"
692 if test "$my_status" -eq 0; then :; else
693 eval "(exit $my_status); $my_fail_exp"
699 # Turn $1 into a string suitable for a shell variable name.
700 # Result is stored in $func_tr_sh_result. All characters
701 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
702 # if $1 begins with a digit, a '_' is prepended as well.
706 [0-9]* | *[!a-zA-Z0-9_]*)
707 func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
717 # Echo version message to standard output and exit.
730 /^# '$PROGRAM' (GNU /,/# warranty; / {
733 s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
740 # Echo short help message to standard output and exit.
745 $SED -n '/^# Usage:/,/^# *.*--help/ {
748 s/\$progname/'$progname'/
752 $ECHO "run \`$progname --help | more' for full usage"
757 # Echo long help message to standard output and exit,
758 # unless 'noexit' is passed as argument.
763 $SED -n '/^# Usage:/,/# Report bugs to/ {
767 s*\$progname*'$progname'*
769 s*\$SHELL*'"$SHELL"'*
771 s*\$LTCFLAGS*'"$LTCFLAGS"'*
773 s/\$with_gnu_ld/'"$with_gnu_ld"'/
774 s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
775 s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
779 /^# .* home page:/b print
780 /^# General help using/b print
783 if test -z "$1"; then
788 # func_missing_arg argname
789 # Echo program name prefixed message to standard error and set global
795 func_error "missing argument for $1."
800 # func_split_short_opt shortopt
801 # Set func_split_short_opt_name and func_split_short_opt_arg shell
802 # variables after splitting SHORTOPT after the 2nd character.
803 func_split_short_opt ()
805 my_sed_short_opt='1s/^\(..\).*$/\1/;q'
806 my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
808 func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
809 func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
810 } # func_split_short_opt may be replaced by extended shell implementation
813 # func_split_long_opt longopt
814 # Set func_split_long_opt_name and func_split_long_opt_arg shell
815 # variables after splitting LONGOPT at the `=' sign.
816 func_split_long_opt ()
818 my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
819 my_sed_long_arg='1s/^--[^=]*=//'
821 func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
822 func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
823 } # func_split_long_opt may be replaced by extended shell implementation
831 magic="%%%MAGIC variable%%%"
832 magic_exe="%%%MAGIC EXE variable%%%"
837 lo2o="s/\\.lo\$/.${objext}/"
838 o2lo="s/\\.${objext}\$/.lo/"
842 # If this variable is set in any of the actions, the command in it
843 # will be execed at the end. This prevents here-documents from being
844 # left over by shells.
847 # func_append var value
848 # Append VALUE to the end of shell variable VAR.
851 eval "${1}=\$${1}\${2}"
852 } # func_append may be replaced by extended shell implementation
854 # func_append_quoted var value
855 # Quote VALUE and append to the end of shell variable VAR, separated
857 func_append_quoted ()
859 func_quote_for_eval "${2}"
860 eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
861 } # func_append_quoted may be replaced by extended shell implementation
864 # func_arith arithmetic-term...
867 func_arith_result=`expr "${@}"`
868 } # func_arith may be replaced by extended shell implementation
872 # STRING may not start with a hyphen.
875 func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
876 } # func_len may be replaced by extended shell implementation
882 func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
883 } # func_lo2o may be replaced by extended shell implementation
886 # func_xform libobj-or-source
889 func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
890 } # func_xform may be replaced by extended shell implementation
893 # func_fatal_configuration arg...
894 # Echo program name prefixed message to standard error, followed by
895 # a configuration failure hint, and exit.
896 func_fatal_configuration ()
899 func_error "See the $PACKAGE documentation for more information."
900 func_fatal_error "Fatal configuration error."
905 # Display the configuration for all the tags in this script.
908 re_begincf='^# ### BEGIN LIBTOOL'
909 re_endcf='^# ### END LIBTOOL'
911 # Default configuration.
912 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
914 # Now print the configurations for the tags.
915 for tagname in $taglist; do
916 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
923 # Display the features supported by this script.
927 if test "$build_libtool_libs" = yes; then
928 echo "enable shared libraries"
930 echo "disable shared libraries"
932 if test "$build_old_libs" = yes; then
933 echo "enable static libraries"
935 echo "disable static libraries"
941 # func_enable_tag tagname
942 # Verify that TAGNAME is valid, and either flag an error and exit, or
943 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
950 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
951 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
952 sed_extractcf="/$re_begincf/,/$re_endcf/p"
957 func_fatal_error "invalid tag name: $tagname"
961 # Don't test for the "default" C tag, as we know it's
962 # there but not specially marked.
966 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
967 taglist="$taglist $tagname"
969 # Evaluate the configuration. Be careful to quote the path
970 # and the sed script, to avoid splitting on whitespace, but
971 # also don't use non-portable quotes within backquotes within
972 # quotes we have to do it in 2 steps:
973 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
976 func_error "ignoring unknown tag $tagname"
982 # func_check_version_match
983 # Ensure that we are using m4 macros, and libtool script from the same
984 # release of libtool.
985 func_check_version_match ()
987 if test "$package_revision" != "$macro_revision"; then
988 if test "$VERSION" != "$macro_version"; then
989 if test -z "$macro_version"; then
991 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
992 $progname: definition of this LT_INIT comes from an older release.
993 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
994 $progname: and run autoconf again.
998 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
999 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1000 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1001 $progname: and run autoconf again.
1006 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
1007 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1008 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1009 $progname: of $PACKAGE $VERSION and run autoconf again.
1018 # Shorthand for --mode=foo, only valid as the first argument
1021 shift; set dummy --mode clean ${1+"$@"}; shift
1023 compile|compil|compi|comp|com|co|c)
1024 shift; set dummy --mode compile ${1+"$@"}; shift
1026 execute|execut|execu|exec|exe|ex|e)
1027 shift; set dummy --mode execute ${1+"$@"}; shift
1029 finish|finis|fini|fin|fi|f)
1030 shift; set dummy --mode finish ${1+"$@"}; shift
1032 install|instal|insta|inst|ins|in|i)
1033 shift; set dummy --mode install ${1+"$@"}; shift
1036 shift; set dummy --mode link ${1+"$@"}; shift
1038 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1039 shift; set dummy --mode uninstall ${1+"$@"}; shift
1049 opt_preserve_dup_deps=false
1060 # Parse options once, thoroughly. This comes as soon as possible in the
1061 # script to make things like `--version' happen as quickly as we can.
1063 # this just eases exit handling
1064 while test $# -gt 0; do
1068 --debug|-x) opt_debug='set -x'
1069 func_echo "enabling shell trace mode"
1072 --dry-run|--dryrun|-n)
1081 opt_dlopen="${opt_dlopen+$opt_dlopen
1085 --preserve-dup-deps)
1086 opt_preserve_dup_deps=:
1094 set dummy --mode finish ${1+"$@"}; shift
1101 opt_help=': help-all'
1104 test $# = 0 && func_missing_arg $opt && break
1108 # Valid mode arguments:
1109 clean|compile|execute|finish|install|link|relink|uninstall) ;;
1111 # Catch anything else as an error
1112 *) func_error "invalid argument for $opt"
1119 --no-silent|--no-quiet)
1121 func_append preserve_args " $opt"
1125 func_append preserve_args " $opt"
1129 func_append preserve_args " $opt"
1134 func_append preserve_args " $opt"
1138 test $# = 0 && func_missing_arg $opt && break
1141 func_append preserve_args " $opt $optarg"
1142 func_enable_tag "$optarg"
1146 -\?|-h) func_usage ;;
1147 --help) func_help ;;
1148 --version) func_version ;;
1150 # Separate optargs to long options:
1152 func_split_long_opt "$opt"
1153 set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
1157 # Separate non-argument short options:
1159 func_split_short_opt "$opt"
1160 set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
1165 -*) func_fatal_help "unrecognized option \`$opt'" ;;
1166 *) set dummy "$opt" ${1+"$@"}; shift; break ;;
1172 # save first non-option argument
1173 if test "$#" -gt 0; then
1179 test "$opt_debug" = : || func_append preserve_args " --debug"
1182 *cygwin* | *mingw* | *pw32* | *cegcc*)
1183 # don't eliminate duplications in $postdeps and $predeps
1184 opt_duplicate_compiler_generated_deps=:
1187 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
1192 # Sanity checks first:
1193 func_check_version_match
1195 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1196 func_fatal_configuration "not configured to build any kind of library"
1200 eval std_shrext=\"$shrext_cmds\"
1202 # Only execute mode is allowed to have -dlopen flags.
1203 if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
1204 func_error "unrecognized option \`-dlopen'"
1209 # Change the help message to a mode-specific one.
1210 generic_help="$help"
1211 help="Try \`$progname --help --mode=$opt_mode' for more information."
1215 # Bail if the options were screwed
1216 $exit_cmd $EXIT_FAILURE
1227 # True iff FILE is a libtool `.la' library or `.lo' object file.
1228 # This function is only a basic sanity check; it will hardly flush out
1229 # determined imposters.
1233 $SED -e 4q "$1" 2>/dev/null \
1234 | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1237 # func_lalib_unsafe_p file
1238 # True iff FILE is a libtool `.la' library or `.lo' object file.
1239 # This function implements the same check as func_lalib_p without
1240 # resorting to external programs. To this end, it redirects stdin and
1241 # closes it afterwards, without saving the original file descriptor.
1242 # As a safety measure, use it only where a negative result would be
1243 # fatal anyway. Works if `file' does not exist.
1244 func_lalib_unsafe_p ()
1247 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1248 for lalib_p_l in 1 2 3 4
1251 case "$lalib_p_line" in
1252 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1257 test "$lalib_p" = yes
1260 # func_ltwrapper_script_p file
1261 # True iff FILE is a libtool wrapper script
1262 # This function is only a basic sanity check; it will hardly flush out
1263 # determined imposters.
1264 func_ltwrapper_script_p ()
1269 # func_ltwrapper_executable_p file
1270 # True iff FILE is a libtool wrapper executable
1271 # This function is only a basic sanity check; it will hardly flush out
1272 # determined imposters.
1273 func_ltwrapper_executable_p ()
1275 func_ltwrapper_exec_suffix=
1278 *) func_ltwrapper_exec_suffix=.exe ;;
1280 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1283 # func_ltwrapper_scriptname file
1284 # Assumes file is an ltwrapper_executable
1285 # uses $file to determine the appropriate filename for a
1286 # temporary ltwrapper_script.
1287 func_ltwrapper_scriptname ()
1289 func_dirname_and_basename "$1" "" "."
1290 func_stripname '' '.exe' "$func_basename_result"
1291 func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1294 # func_ltwrapper_p file
1295 # True iff FILE is a libtool wrapper script or wrapper executable
1296 # This function is only a basic sanity check; it will hardly flush out
1297 # determined imposters.
1300 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1304 # func_execute_cmds commands fail_cmd
1305 # Execute tilde-delimited COMMANDS.
1306 # If FAIL_CMD is given, eval that upon failure.
1307 # FAIL_CMD may read-access the current command in variable CMD!
1308 func_execute_cmds ()
1311 save_ifs=$IFS; IFS='~'
1315 func_show_eval "$cmd" "${2-:}"
1322 # Source FILE, adding directory component if necessary.
1323 # Note that it is not necessary on cygwin/mingw to append a dot to
1324 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1325 # behavior happens only for exec(3), not for open(2)! Also, sourcing
1326 # `FILE.' does not work on cygwin managed mounts.
1331 */* | *\\*) . "$1" ;;
1337 # func_resolve_sysroot PATH
1338 # Replace a leading = in PATH with a sysroot. Store the result into
1339 # func_resolve_sysroot_result
1340 func_resolve_sysroot ()
1342 func_resolve_sysroot_result=$1
1343 case $func_resolve_sysroot_result in
1345 func_stripname '=' '' "$func_resolve_sysroot_result"
1346 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
1351 # func_replace_sysroot PATH
1352 # If PATH begins with the sysroot, replace it with = and
1353 # store the result into func_replace_sysroot_result.
1354 func_replace_sysroot ()
1356 case "$lt_sysroot:$1" in
1358 func_stripname "$lt_sysroot" '' "$1"
1359 func_replace_sysroot_result="=$func_stripname_result"
1362 # Including no sysroot.
1363 func_replace_sysroot_result=$1
1368 # func_infer_tag arg
1369 # Infer tagged configuration to use if any are available and
1370 # if one wasn't chosen via the "--tag" command line option.
1371 # Only attempt this if the compiler in the base compile
1372 # command doesn't match the default compiler.
1373 # arg is usually of the form 'gcc ...'
1377 if test -n "$available_tags" && test -z "$tagname"; then
1380 func_append_quoted CC_quoted "$arg"
1382 CC_expanded=`func_echo_all $CC`
1383 CC_quoted_expanded=`func_echo_all $CC_quoted`
1385 # Blanks in the command may have been stripped by the calling shell,
1386 # but not from the CC environment variable when configure was run.
1387 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1388 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
1389 # Blanks at the start of $base_compile will cause this to fail
1390 # if we don't check for them as well.
1392 for z in $available_tags; do
1393 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1394 # Evaluate the configuration.
1395 eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1398 # Double-quote args containing other shell metacharacters.
1399 func_append_quoted CC_quoted "$arg"
1401 CC_expanded=`func_echo_all $CC`
1402 CC_quoted_expanded=`func_echo_all $CC_quoted`
1404 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
1405 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
1406 # The compiler in the base compile command matches
1407 # the one in the tagged configuration.
1408 # Assume this is the tagged configuration we want.
1415 # If $tagname still isn't set, then no tagged configuration
1416 # was found and let the user know that the "--tag" command
1417 # line option must be used.
1418 if test -z "$tagname"; then
1419 func_echo "unable to infer tagged configuration"
1420 func_fatal_error "specify a tag with \`--tag'"
1422 # func_verbose "using $tagname tagged configuration"
1431 # func_write_libtool_object output_name pic_name nonpic_name
1432 # Create a libtool object file (analogous to a ".la" file),
1433 # but don't create it if we're doing a dry run.
1434 func_write_libtool_object ()
1437 if test "$build_libtool_libs" = yes; then
1443 if test "$build_old_libs" = yes; then
1444 write_oldobj=\'${3}\'
1450 cat >${write_libobj}T <<EOF
1451 # $write_libobj - a libtool object file
1452 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1454 # Please DO NOT delete this file!
1455 # It is necessary for linking the library.
1457 # Name of the PIC object.
1458 pic_object=$write_lobj
1460 # Name of the non-PIC object
1461 non_pic_object=$write_oldobj
1464 $MV "${write_libobj}T" "${write_libobj}"
1469 ##################################################
1470 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
1471 ##################################################
1473 # func_convert_core_file_wine_to_w32 ARG
1474 # Helper function used by file name conversion functions when $build is *nix,
1475 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
1476 # correctly configured wine environment available, with the winepath program
1477 # in $build's $PATH.
1479 # ARG is the $build file name to be converted to w32 format.
1480 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
1481 # be empty on error (or when ARG is empty)
1482 func_convert_core_file_wine_to_w32 ()
1485 func_convert_core_file_wine_to_w32_result="$1"
1486 if test -n "$1"; then
1487 # Unfortunately, winepath does not exit with a non-zero error code, so we
1488 # are forced to check the contents of stdout. On the other hand, if the
1489 # command is not found, the shell will set an exit code of 127 and print
1490 # *an error message* to stdout. So we must check for both error code of
1491 # zero AND non-empty stdout, which explains the odd construction:
1492 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
1493 if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
1494 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
1495 $SED -e "$lt_sed_naive_backslashify"`
1497 func_convert_core_file_wine_to_w32_result=
1501 # end: func_convert_core_file_wine_to_w32
1504 # func_convert_core_path_wine_to_w32 ARG
1505 # Helper function used by path conversion functions when $build is *nix, and
1506 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
1507 # configured wine environment available, with the winepath program in $build's
1508 # $PATH. Assumes ARG has no leading or trailing path separator characters.
1510 # ARG is path to be converted from $build format to win32.
1511 # Result is available in $func_convert_core_path_wine_to_w32_result.
1512 # Unconvertible file (directory) names in ARG are skipped; if no directory names
1513 # are convertible, then the result may be empty.
1514 func_convert_core_path_wine_to_w32 ()
1517 # unfortunately, winepath doesn't convert paths, only file names
1518 func_convert_core_path_wine_to_w32_result=""
1519 if test -n "$1"; then
1522 for func_convert_core_path_wine_to_w32_f in $1; do
1524 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
1525 if test -n "$func_convert_core_file_wine_to_w32_result" ; then
1526 if test -z "$func_convert_core_path_wine_to_w32_result"; then
1527 func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
1529 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
1536 # end: func_convert_core_path_wine_to_w32
1539 # func_cygpath ARGS...
1540 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
1541 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
1542 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
1543 # (2), returns the Cygwin file name or path in func_cygpath_result (input
1544 # file name or path is assumed to be in w32 format, as previously converted
1545 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
1546 # or path in func_cygpath_result (input file name or path is assumed to be in
1547 # Cygwin format). Returns an empty string on error.
1549 # ARGS are passed to cygpath, with the last one being the file name or path to
1552 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
1553 # environment variable; do not put it in $PATH.
1557 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
1558 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
1559 if test "$?" -ne 0; then
1560 # on failure, ensure result is empty
1561 func_cygpath_result=
1564 func_cygpath_result=
1565 func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
1571 # func_convert_core_msys_to_w32 ARG
1572 # Convert file name or path ARG from MSYS format to w32 format. Return
1573 # result in func_convert_core_msys_to_w32_result.
1574 func_convert_core_msys_to_w32 ()
1577 # awkward: cmd appends spaces to result
1578 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
1579 $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
1581 #end: func_convert_core_msys_to_w32
1584 # func_convert_file_check ARG1 ARG2
1585 # Verify that ARG1 (a file name in $build format) was converted to $host
1586 # format in ARG2. Otherwise, emit an error message, but continue (resetting
1587 # func_to_host_file_result to ARG1).
1588 func_convert_file_check ()
1591 if test -z "$2" && test -n "$1" ; then
1592 func_error "Could not determine host file name corresponding to"
1594 func_error "Continuing, but uninstalled executables may not work."
1596 func_to_host_file_result="$1"
1599 # end func_convert_file_check
1602 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
1603 # Verify that FROM_PATH (a path in $build format) was converted to $host
1604 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
1605 # func_to_host_file_result to a simplistic fallback value (see below).
1606 func_convert_path_check ()
1609 if test -z "$4" && test -n "$3"; then
1610 func_error "Could not determine the host path corresponding to"
1612 func_error "Continuing, but uninstalled executables may not work."
1613 # Fallback. This is a deliberately simplistic "conversion" and
1614 # should not be "improved". See libtool.info.
1615 if test "x$1" != "x$2"; then
1616 lt_replace_pathsep_chars="s|$1|$2|g"
1617 func_to_host_path_result=`echo "$3" |
1618 $SED -e "$lt_replace_pathsep_chars"`
1620 func_to_host_path_result="$3"
1624 # end func_convert_path_check
1627 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
1628 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
1629 # and appending REPL if ORIG matches BACKPAT.
1630 func_convert_path_front_back_pathsep ()
1634 $1 ) func_to_host_path_result="$3$func_to_host_path_result"
1638 $2 ) func_append func_to_host_path_result "$3"
1642 # end func_convert_path_front_back_pathsep
1645 ##################################################
1646 # $build to $host FILE NAME CONVERSION FUNCTIONS #
1647 ##################################################
1648 # invoked via `$to_host_file_cmd ARG'
1650 # In each case, ARG is the path to be converted from $build to $host format.
1651 # Result will be available in $func_to_host_file_result.
1654 # func_to_host_file ARG
1655 # Converts the file name ARG from $build format to $host format. Return result
1656 # in func_to_host_file_result.
1657 func_to_host_file ()
1660 $to_host_file_cmd "$1"
1662 # end func_to_host_file
1665 # func_to_tool_file ARG LAZY
1666 # converts the file name ARG from $build format to toolchain format. Return
1667 # result in func_to_tool_file_result. If the conversion in use is listed
1668 # in (the comma separated) LAZY, no conversion takes place.
1669 func_to_tool_file ()
1673 *,"$to_tool_file_cmd",*)
1674 func_to_tool_file_result=$1
1677 $to_tool_file_cmd "$1"
1678 func_to_tool_file_result=$func_to_host_file_result
1682 # end func_to_tool_file
1685 # func_convert_file_noop ARG
1686 # Copy ARG to func_to_host_file_result.
1687 func_convert_file_noop ()
1689 func_to_host_file_result="$1"
1691 # end func_convert_file_noop
1694 # func_convert_file_msys_to_w32 ARG
1695 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
1696 # conversion to w32 is not available inside the cwrapper. Returns result in
1697 # func_to_host_file_result.
1698 func_convert_file_msys_to_w32 ()
1701 func_to_host_file_result="$1"
1702 if test -n "$1"; then
1703 func_convert_core_msys_to_w32 "$1"
1704 func_to_host_file_result="$func_convert_core_msys_to_w32_result"
1706 func_convert_file_check "$1" "$func_to_host_file_result"
1708 # end func_convert_file_msys_to_w32
1711 # func_convert_file_cygwin_to_w32 ARG
1712 # Convert file name ARG from Cygwin to w32 format. Returns result in
1713 # func_to_host_file_result.
1714 func_convert_file_cygwin_to_w32 ()
1717 func_to_host_file_result="$1"
1718 if test -n "$1"; then
1719 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
1720 # LT_CYGPATH in this case.
1721 func_to_host_file_result=`cygpath -m "$1"`
1723 func_convert_file_check "$1" "$func_to_host_file_result"
1725 # end func_convert_file_cygwin_to_w32
1728 # func_convert_file_nix_to_w32 ARG
1729 # Convert file name ARG from *nix to w32 format. Requires a wine environment
1730 # and a working winepath. Returns result in func_to_host_file_result.
1731 func_convert_file_nix_to_w32 ()
1734 func_to_host_file_result="$1"
1735 if test -n "$1"; then
1736 func_convert_core_file_wine_to_w32 "$1"
1737 func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
1739 func_convert_file_check "$1" "$func_to_host_file_result"
1741 # end func_convert_file_nix_to_w32
1744 # func_convert_file_msys_to_cygwin ARG
1745 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1746 # Returns result in func_to_host_file_result.
1747 func_convert_file_msys_to_cygwin ()
1750 func_to_host_file_result="$1"
1751 if test -n "$1"; then
1752 func_convert_core_msys_to_w32 "$1"
1753 func_cygpath -u "$func_convert_core_msys_to_w32_result"
1754 func_to_host_file_result="$func_cygpath_result"
1756 func_convert_file_check "$1" "$func_to_host_file_result"
1758 # end func_convert_file_msys_to_cygwin
1761 # func_convert_file_nix_to_cygwin ARG
1762 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
1763 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
1764 # in func_to_host_file_result.
1765 func_convert_file_nix_to_cygwin ()
1768 func_to_host_file_result="$1"
1769 if test -n "$1"; then
1770 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
1771 func_convert_core_file_wine_to_w32 "$1"
1772 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
1773 func_to_host_file_result="$func_cygpath_result"
1775 func_convert_file_check "$1" "$func_to_host_file_result"
1777 # end func_convert_file_nix_to_cygwin
1780 #############################################
1781 # $build to $host PATH CONVERSION FUNCTIONS #
1782 #############################################
1783 # invoked via `$to_host_path_cmd ARG'
1785 # In each case, ARG is the path to be converted from $build to $host format.
1786 # The result will be available in $func_to_host_path_result.
1788 # Path separators are also converted from $build format to $host format. If
1789 # ARG begins or ends with a path separator character, it is preserved (but
1790 # converted to $host format) on output.
1792 # All path conversion functions are named using the following convention:
1793 # file name conversion function : func_convert_file_X_to_Y ()
1794 # path conversion function : func_convert_path_X_to_Y ()
1795 # where, for any given $build/$host combination the 'X_to_Y' value is the
1796 # same. If conversion functions are added for new $build/$host combinations,
1797 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
1801 # func_init_to_host_path_cmd
1802 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
1803 # appropriate value, based on the value of $to_host_file_cmd.
1805 func_init_to_host_path_cmd ()
1808 if test -z "$to_host_path_cmd"; then
1809 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
1810 to_host_path_cmd="func_convert_path_${func_stripname_result}"
1815 # func_to_host_path ARG
1816 # Converts the path ARG from $build format to $host format. Return result
1817 # in func_to_host_path_result.
1818 func_to_host_path ()
1821 func_init_to_host_path_cmd
1822 $to_host_path_cmd "$1"
1824 # end func_to_host_path
1827 # func_convert_path_noop ARG
1828 # Copy ARG to func_to_host_path_result.
1829 func_convert_path_noop ()
1831 func_to_host_path_result="$1"
1833 # end func_convert_path_noop
1836 # func_convert_path_msys_to_w32 ARG
1837 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
1838 # conversion to w32 is not available inside the cwrapper. Returns result in
1839 # func_to_host_path_result.
1840 func_convert_path_msys_to_w32 ()
1843 func_to_host_path_result="$1"
1844 if test -n "$1"; then
1845 # Remove leading and trailing path separator characters from ARG. MSYS
1846 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
1847 # and winepath ignores them completely.
1848 func_stripname : : "$1"
1849 func_to_host_path_tmp1=$func_stripname_result
1850 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1851 func_to_host_path_result="$func_convert_core_msys_to_w32_result"
1852 func_convert_path_check : ";" \
1853 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1854 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1857 # end func_convert_path_msys_to_w32
1860 # func_convert_path_cygwin_to_w32 ARG
1861 # Convert path ARG from Cygwin to w32 format. Returns result in
1862 # func_to_host_file_result.
1863 func_convert_path_cygwin_to_w32 ()
1866 func_to_host_path_result="$1"
1867 if test -n "$1"; then
1868 # See func_convert_path_msys_to_w32:
1869 func_stripname : : "$1"
1870 func_to_host_path_tmp1=$func_stripname_result
1871 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
1872 func_convert_path_check : ";" \
1873 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1874 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1877 # end func_convert_path_cygwin_to_w32
1880 # func_convert_path_nix_to_w32 ARG
1881 # Convert path ARG from *nix to w32 format. Requires a wine environment and
1882 # a working winepath. Returns result in func_to_host_file_result.
1883 func_convert_path_nix_to_w32 ()
1886 func_to_host_path_result="$1"
1887 if test -n "$1"; then
1888 # See func_convert_path_msys_to_w32:
1889 func_stripname : : "$1"
1890 func_to_host_path_tmp1=$func_stripname_result
1891 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1892 func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
1893 func_convert_path_check : ";" \
1894 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1895 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
1898 # end func_convert_path_nix_to_w32
1901 # func_convert_path_msys_to_cygwin ARG
1902 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
1903 # Returns result in func_to_host_file_result.
1904 func_convert_path_msys_to_cygwin ()
1907 func_to_host_path_result="$1"
1908 if test -n "$1"; then
1909 # See func_convert_path_msys_to_w32:
1910 func_stripname : : "$1"
1911 func_to_host_path_tmp1=$func_stripname_result
1912 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
1913 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
1914 func_to_host_path_result="$func_cygpath_result"
1915 func_convert_path_check : : \
1916 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1917 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1920 # end func_convert_path_msys_to_cygwin
1923 # func_convert_path_nix_to_cygwin ARG
1924 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
1925 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
1926 # func_to_host_file_result.
1927 func_convert_path_nix_to_cygwin ()
1930 func_to_host_path_result="$1"
1931 if test -n "$1"; then
1932 # Remove leading and trailing path separator characters from
1933 # ARG. msys behavior is inconsistent here, cygpath turns them
1934 # into '.;' and ';.', and winepath ignores them completely.
1935 func_stripname : : "$1"
1936 func_to_host_path_tmp1=$func_stripname_result
1937 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
1938 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
1939 func_to_host_path_result="$func_cygpath_result"
1940 func_convert_path_check : : \
1941 "$func_to_host_path_tmp1" "$func_to_host_path_result"
1942 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
1945 # end func_convert_path_nix_to_cygwin
1948 # func_mode_compile arg...
1949 func_mode_compile ()
1952 # Get the compilation command and the source file.
1954 srcfile="$nonopt" # always keep a non-empty value in "srcfile"
1966 # do not "continue". Instead, add this to base_compile
1978 # Accept any command-line options.
1981 test -n "$libobj" && \
1982 func_fatal_error "you cannot specify \`-o' more than once"
1987 -pie | -fpie | -fPIE)
1988 func_append pie_flag " $arg"
1992 -shared | -static | -prefer-pic | -prefer-non-pic)
1993 func_append later " $arg"
2003 arg_mode=arg # the next one goes into the "base_compile" arg list
2004 continue # The current "srcfile" will either be retained or
2005 ;; # replaced later. I would guess that would be a bug.
2008 func_stripname '-Wc,' '' "$arg"
2009 args=$func_stripname_result
2011 save_ifs="$IFS"; IFS=','
2012 for arg in $args; do
2014 func_append_quoted lastarg "$arg"
2017 func_stripname ' ' '' "$lastarg"
2018 lastarg=$func_stripname_result
2020 # Add the arguments to base_compile.
2021 func_append base_compile " $lastarg"
2026 # Accept the current argument as the source file.
2027 # The previous "srcfile" becomes the current argument.
2034 esac # case $arg_mode
2036 # Aesthetically quote the previous argument.
2037 func_append_quoted base_compile "$lastarg"
2042 func_fatal_error "you must specify an argument for -Xcompile"
2045 func_fatal_error "you must specify a target with \`-o'"
2048 # Get the name of the library object.
2049 test -z "$libobj" && {
2050 func_basename "$srcfile"
2051 libobj="$func_basename_result"
2056 # Recognize several different file suffixes.
2057 # If the user specifies -o file.o, it is replaced with file.lo
2060 *.ada | *.adb | *.ads | *.asm | \
2061 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
2062 *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
2063 func_xform "$libobj"
2064 libobj=$func_xform_result
2069 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
2071 func_fatal_error "cannot determine name of library object from \`$libobj'"
2075 func_infer_tag $base_compile
2077 for arg in $later; do
2080 test "$build_libtool_libs" != yes && \
2081 func_fatal_configuration "can not build a shared library"
2087 build_libtool_libs=no
2104 func_quote_for_eval "$libobj"
2105 test "X$libobj" != "X$func_quote_for_eval_result" \
2106 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
2107 && func_warning "libobj name \`$libobj' may not contain shell special characters."
2108 func_dirname_and_basename "$obj" "/" ""
2109 objname="$func_basename_result"
2110 xdir="$func_dirname_result"
2111 lobj=${xdir}$objdir/$objname
2113 test -z "$base_compile" && \
2114 func_fatal_help "you must specify a compilation command"
2116 # Delete any leftover library objects.
2117 if test "$build_old_libs" = yes; then
2118 removelist="$obj $lobj $libobj ${libobj}T"
2120 removelist="$lobj $libobj ${libobj}T"
2123 # On Cygwin there's no "real" PIC flag so we must build both object types
2125 cygwin* | mingw* | pw32* | os2* | cegcc*)
2129 if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
2130 # non-PIC code in shared libraries is not supported
2134 # Calculate the filename of the output object if compiler does
2135 # not support -o with -c
2136 if test "$compiler_c_o" = no; then
2137 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
2138 lockfile="$output_obj.lock"
2145 # Lock this critical section if it is needed
2146 # We use this script file to make the link, it avoids creating a new file
2147 if test "$need_locks" = yes; then
2148 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
2149 func_echo "Waiting for $lockfile to be removed"
2152 elif test "$need_locks" = warn; then
2153 if test -f "$lockfile"; then
2155 *** ERROR, $lockfile exists and contains:
2156 `cat $lockfile 2>/dev/null`
2158 This indicates that another process is trying to use the same
2159 temporary object file, and libtool could not work around it because
2160 your compiler does not support \`-c' and \`-o' together. If you
2161 repeat this compilation, it may succeed, by chance, but you had better
2162 avoid parallel builds (make -j) in this platform, or get a better
2165 $opt_dry_run || $RM $removelist
2168 func_append removelist " $output_obj"
2169 $ECHO "$srcfile" > "$lockfile"
2172 $opt_dry_run || $RM $removelist
2173 func_append removelist " $lockfile"
2174 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
2176 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
2177 srcfile=$func_to_tool_file_result
2178 func_quote_for_eval "$srcfile"
2179 qsrcfile=$func_quote_for_eval_result
2181 # Only build a PIC object if we are building libtool libraries.
2182 if test "$build_libtool_libs" = yes; then
2183 # Without this assignment, base_compile gets emptied.
2184 fbsd_hideous_sh_bug=$base_compile
2186 if test "$pic_mode" != no; then
2187 command="$base_compile $qsrcfile $pic_flag"
2189 # Don't build PIC code
2190 command="$base_compile $qsrcfile"
2193 func_mkdir_p "$xdir$objdir"
2195 if test -z "$output_obj"; then
2196 # Place PIC objects in $objdir
2197 func_append command " -o $lobj"
2200 func_show_eval_locale "$command" \
2201 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
2203 if test "$need_locks" = warn &&
2204 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2206 *** ERROR, $lockfile contains:
2207 `cat $lockfile 2>/dev/null`
2209 but it should contain:
2212 This indicates that another process is trying to use the same
2213 temporary object file, and libtool could not work around it because
2214 your compiler does not support \`-c' and \`-o' together. If you
2215 repeat this compilation, it may succeed, by chance, but you had better
2216 avoid parallel builds (make -j) in this platform, or get a better
2219 $opt_dry_run || $RM $removelist
2223 # Just move the object if needed, then go on to compile the next one
2224 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
2225 func_show_eval '$MV "$output_obj" "$lobj"' \
2226 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2229 # Allow error messages only from the first compilation.
2230 if test "$suppress_opt" = yes; then
2231 suppress_output=' >/dev/null 2>&1'
2235 # Only build a position-dependent object if we build old libraries.
2236 if test "$build_old_libs" = yes; then
2237 if test "$pic_mode" != yes; then
2238 # Don't build PIC code
2239 command="$base_compile $qsrcfile$pie_flag"
2241 command="$base_compile $qsrcfile $pic_flag"
2243 if test "$compiler_c_o" = yes; then
2244 func_append command " -o $obj"
2247 # Suppress compiler output if we already did a PIC compilation.
2248 func_append command "$suppress_output"
2249 func_show_eval_locale "$command" \
2250 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
2252 if test "$need_locks" = warn &&
2253 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
2255 *** ERROR, $lockfile contains:
2256 `cat $lockfile 2>/dev/null`
2258 but it should contain:
2261 This indicates that another process is trying to use the same
2262 temporary object file, and libtool could not work around it because
2263 your compiler does not support \`-c' and \`-o' together. If you
2264 repeat this compilation, it may succeed, by chance, but you had better
2265 avoid parallel builds (make -j) in this platform, or get a better
2268 $opt_dry_run || $RM $removelist
2272 # Just move the object if needed
2273 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
2274 func_show_eval '$MV "$output_obj" "$obj"' \
2275 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
2280 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
2282 # Unlock the critical section if it was locked
2283 if test "$need_locks" != no; then
2284 removelist=$lockfile
2293 test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
2298 # We need to display help for each of the modes.
2301 # Generic help is extracted from the usage comments
2302 # at the start of this file.
2308 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
2310 Remove files from the build directory.
2312 RM is the name of the program to use to delete files associated with each FILE
2313 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2316 If FILE is a libtool library, object or program, all the files associated
2317 with it are deleted. Otherwise, only FILE itself is deleted using RM."
2322 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
2324 Compile a source file into a libtool library object.
2326 This mode accepts the following additional options:
2328 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
2329 -no-suppress do not suppress compiler output for multiple passes
2330 -prefer-pic try to build PIC objects only
2331 -prefer-non-pic try to build non-PIC objects only
2332 -shared do not build a \`.o' file suitable for static linking
2333 -static only build a \`.o' file suitable for static linking
2334 -Wc,FLAG pass FLAG directly to the compiler
2336 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
2337 from the given SOURCEFILE.
2339 The output file name is determined by removing the directory component from
2340 SOURCEFILE, then substituting the C source code suffix \`.c' with the
2341 library object suffix, \`.lo'."
2346 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
2348 Automatically set library path, then run a program.
2350 This mode accepts the following additional options:
2352 -dlopen FILE add the directory containing FILE to the library path
2354 This mode sets the library path environment variable according to \`-dlopen'
2357 If any of the ARGS are libtool executable wrappers, then they are translated
2358 into their corresponding uninstalled binary, and any of their required library
2359 directories are added to the library path.
2361 Then, COMMAND is executed, with ARGS as arguments."
2366 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2368 Complete the installation of libtool libraries.
2370 Each LIBDIR is a directory that contains libtool libraries.
2372 The commands that this mode executes may require superuser privileges. Use
2373 the \`--dry-run' option if you just want to see what would be executed."
2378 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2380 Install executables or libraries.
2382 INSTALL-COMMAND is the installation command. The first component should be
2383 either the \`install' or \`cp' program.
2385 The following components of INSTALL-COMMAND are treated specially:
2387 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
2389 The rest of the components are interpreted as arguments to that command (only
2390 BSD-compatible install options are recognized)."
2395 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2397 Link object files or libraries together to form another library, or to
2398 create an executable program.
2400 LINK-COMMAND is a command using the C compiler that you would use to create
2401 a program from several object files.
2403 The following components of LINK-COMMAND are treated specially:
2405 -all-static do not do any dynamic linking at all
2406 -avoid-version do not add a version suffix if possible
2407 -bindir BINDIR specify path to binaries directory (for systems where
2408 libraries must be found in the PATH setting at runtime)
2409 -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
2410 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
2411 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2412 -export-symbols SYMFILE
2413 try to export only the symbols listed in SYMFILE
2414 -export-symbols-regex REGEX
2415 try to export only the symbols matching REGEX
2416 -LLIBDIR search LIBDIR for required installed libraries
2417 -lNAME OUTPUT-FILE requires the installed library libNAME
2418 -module build a library that can dlopened
2419 -no-fast-install disable the fast-install mode
2420 -no-install link a not-installable executable
2421 -no-undefined declare that a library does not refer to external symbols
2422 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
2423 -objectlist FILE Use a list of object files found in FILE to specify objects
2424 -precious-files-regex REGEX
2425 don't remove output files matching REGEX
2426 -release RELEASE specify package release information
2427 -rpath LIBDIR the created library will eventually be installed in LIBDIR
2428 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
2429 -shared only do dynamic linking of libtool libraries
2430 -shrext SUFFIX override the standard shared library file extension
2431 -static do not do any dynamic linking of uninstalled libtool libraries
2432 -static-libtool-libs
2433 do not do any dynamic linking of libtool libraries
2434 -version-info CURRENT[:REVISION[:AGE]]
2435 specify library version info [each variable defaults to 0]
2436 -weak LIBNAME declare that the target provides the LIBNAME interface
2438 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
2440 -Xlinker FLAG pass linker-specific FLAG directly to the linker
2441 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
2443 All other options (arguments beginning with \`-') are ignored.
2445 Every other argument is treated as a filename. Files ending in \`.la' are
2446 treated as uninstalled libtool libraries, other files are standard or library
2449 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2450 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2451 required, except when creating a convenience library.
2453 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2454 using \`ar' and \`ranlib', or on Windows using \`lib'.
2456 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2457 is created, otherwise an executable program is created."
2462 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2464 Remove libraries from an installation directory.
2466 RM is the name of the program to use to delete files associated with each FILE
2467 (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
2470 If FILE is a libtool library, all the files associated with it are deleted.
2471 Otherwise, only FILE itself is deleted using RM."
2475 func_fatal_help "invalid operation mode \`$opt_mode'"
2480 $ECHO "Try \`$progname --help' for more information about other modes."
2483 # Now that we've collected a possible --mode arg, show help if necessary
2485 if test "$opt_help" = :; then
2490 for opt_mode in compile link execute install finish uninstall clean; do
2493 } | sed -n '1p; 2,$s/^Usage:/ or: /p'
2496 for opt_mode in compile link execute install finish uninstall clean; do
2502 /^When reporting/,/^Report/{
2507 /information about other modes/d
2508 /more detailed .*MODE/d
2509 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
2515 # func_mode_execute arg...
2516 func_mode_execute ()
2519 # The first argument is the command name.
2522 func_fatal_help "you must specify a COMMAND"
2524 # Handle -dlopen flags immediately.
2525 for file in $opt_dlopen; do
2527 || func_fatal_help "\`$file' is not a file"
2532 func_resolve_sysroot "$file"
2533 file=$func_resolve_sysroot_result
2535 # Check to see that this really is a libtool archive.
2536 func_lalib_unsafe_p "$file" \
2537 || func_fatal_help "\`$lib' is not a valid libtool archive"
2539 # Read the libtool library.
2544 # Skip this library if it cannot be dlopened.
2545 if test -z "$dlname"; then
2546 # Warn if it was a shared library.
2547 test -n "$library_names" && \
2548 func_warning "\`$file' was not linked with \`-export-dynamic'"
2552 func_dirname "$file" "" "."
2553 dir="$func_dirname_result"
2555 if test -f "$dir/$objdir/$dlname"; then
2556 func_append dir "/$objdir"
2558 if test ! -f "$dir/$dlname"; then
2559 func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2565 # Just add the directory containing the .lo file.
2566 func_dirname "$file" "" "."
2567 dir="$func_dirname_result"
2571 func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2576 # Get the absolute pathname.
2577 absdir=`cd "$dir" && pwd`
2578 test -n "$absdir" && dir="$absdir"
2580 # Now add the directory to shlibpath_var.
2581 if eval "test -z \"\$$shlibpath_var\""; then
2582 eval "$shlibpath_var=\"\$dir\""
2584 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2588 # This variable tells wrapper scripts just to set shlibpath_var
2589 # rather than running their programs.
2590 libtool_execute_magic="$magic"
2592 # Check if any of the arguments is a wrapper script.
2597 -* | *.la | *.lo ) ;;
2599 # Do a test to see if this is really a libtool program.
2600 if func_ltwrapper_script_p "$file"; then
2602 # Transform arg to wrapped name.
2603 file="$progdir/$program"
2604 elif func_ltwrapper_executable_p "$file"; then
2605 func_ltwrapper_scriptname "$file"
2606 func_source "$func_ltwrapper_scriptname_result"
2607 # Transform arg to wrapped name.
2608 file="$progdir/$program"
2612 # Quote arguments (to preserve shell metacharacters).
2613 func_append_quoted args "$file"
2616 if test "X$opt_dry_run" = Xfalse; then
2617 if test -n "$shlibpath_var"; then
2618 # Export the shlibpath_var.
2619 eval "export $shlibpath_var"
2622 # Restore saved environment variables
2623 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2625 eval "if test \"\${save_$lt_var+set}\" = set; then
2626 $lt_var=\$save_$lt_var; export $lt_var
2632 # Now prepare to actually exec the command.
2633 exec_cmd="\$cmd$args"
2635 # Display what would be done.
2636 if test -n "$shlibpath_var"; then
2637 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2638 echo "export $shlibpath_var"
2645 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
2648 # func_mode_finish arg...
2656 for opt in "$nonopt" ${1+"$@"}
2658 if test -d "$opt"; then
2659 func_append libdirs " $opt"
2661 elif test -f "$opt"; then
2662 if func_lalib_unsafe_p "$opt"; then
2663 func_append libs " $opt"
2665 func_warning "\`$opt' is not a valid libtool archive"
2669 func_fatal_error "invalid argument \`$opt'"
2673 if test -n "$libs"; then
2674 if test -n "$lt_sysroot"; then
2675 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
2676 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
2681 # Remove sysroot references
2682 if $opt_dry_run; then
2683 for lib in $libs; do
2684 echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
2687 tmpdir=`func_mktempdir`
2688 for lib in $libs; do
2689 sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
2691 mv -f $tmpdir/tmp-la $lib
2697 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2698 for libdir in $libdirs; do
2699 if test -n "$finish_cmds"; then
2700 # Do each command in the finish commands.
2701 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2704 if test -n "$finish_eval"; then
2705 # Do the single finish_eval.
2706 eval cmds=\"$finish_eval\"
2707 $opt_dry_run || eval "$cmds" || func_append admincmds "
2713 # Exit here if they wanted silent mode.
2714 $opt_silent && exit $EXIT_SUCCESS
2716 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2717 echo "----------------------------------------------------------------------"
2718 echo "Libraries have been installed in:"
2719 for libdir in $libdirs; do
2723 echo "If you ever happen to want to link against installed libraries"
2724 echo "in a given directory, LIBDIR, you must either use libtool, and"
2725 echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
2726 echo "flag during linking and do at least one of the following:"
2727 if test -n "$shlibpath_var"; then
2728 echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
2729 echo " during execution"
2731 if test -n "$runpath_var"; then
2732 echo " - add LIBDIR to the \`$runpath_var' environment variable"
2733 echo " during linking"
2735 if test -n "$hardcode_libdir_flag_spec"; then
2737 eval flag=\"$hardcode_libdir_flag_spec\"
2739 $ECHO " - use the \`$flag' linker flag"
2741 if test -n "$admincmds"; then
2742 $ECHO " - have your system administrator run these commands:$admincmds"
2744 if test -f /etc/ld.so.conf; then
2745 echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2749 echo "See any operating system documentation about shared libraries for"
2751 solaris2.[6789]|solaris2.1[0-9])
2752 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2756 echo "more information, such as the ld(1) and ld.so(8) manual pages."
2759 echo "----------------------------------------------------------------------"
2764 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
2767 # func_mode_install arg...
2768 func_mode_install ()
2771 # There may be an optional sh(1) argument at the beginning of
2772 # install_prog (especially on Windows NT).
2773 if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2774 # Allow the use of GNU shtool's install command.
2775 case $nonopt in *shtool*) :;; *) false;; esac; then
2776 # Aesthetically quote it.
2777 func_quote_for_eval "$nonopt"
2778 install_prog="$func_quote_for_eval_result "
2786 # The real first argument should be the name of the installation program.
2787 # Aesthetically quote it.
2788 func_quote_for_eval "$arg"
2789 func_append install_prog "$func_quote_for_eval_result"
2790 install_shared_prog=$install_prog
2791 case " $install_prog " in
2792 *[\\\ /]cp\ *) install_cp=: ;;
2793 *) install_cp=false ;;
2796 # We need to accept at least all the BSD install flags.
2808 if test -n "$dest"; then
2809 func_append files " $dest"
2817 if $install_cp; then :; else
2831 # If the previous option needed an argument, then skip it.
2832 if test -n "$prev"; then
2833 if test "x$prev" = x-m && test -n "$install_override_mode"; then
2834 arg2=$install_override_mode
2845 # Aesthetically quote the argument.
2846 func_quote_for_eval "$arg"
2847 func_append install_prog " $func_quote_for_eval_result"
2848 if test -n "$arg2"; then
2849 func_quote_for_eval "$arg2"
2851 func_append install_shared_prog " $func_quote_for_eval_result"
2854 test -z "$install_prog" && \
2855 func_fatal_help "you must specify an install program"
2857 test -n "$prev" && \
2858 func_fatal_help "the \`$prev' option requires an argument"
2860 if test -n "$install_override_mode" && $no_mode; then
2861 if $install_cp; then :; else
2862 func_quote_for_eval "$install_override_mode"
2863 func_append install_shared_prog " -m $func_quote_for_eval_result"
2867 if test -z "$files"; then
2868 if test -z "$dest"; then
2869 func_fatal_help "no file or destination specified"
2871 func_fatal_help "you must specify a destination"
2875 # Strip any trailing slash from the destination.
2876 func_stripname '' '/' "$dest"
2877 dest=$func_stripname_result
2879 # Check to see that the destination is a directory.
2880 test -d "$dest" && isdir=yes
2881 if test "$isdir" = yes; then
2885 func_dirname_and_basename "$dest" "" "."
2886 destdir="$func_dirname_result"
2887 destname="$func_basename_result"
2889 # Not a directory, so check to see that there is only one file specified.
2890 set dummy $files; shift
2891 test "$#" -gt 1 && \
2892 func_fatal_help "\`$dest' is not a directory"
2895 [\\/]* | [A-Za-z]:[\\/]*) ;;
2897 for file in $files; do
2901 func_fatal_help "\`$destdir' must be an absolute directory name"
2908 # This variable tells wrapper scripts just to set variables rather
2909 # than running their programs.
2910 libtool_install_magic="$magic"
2915 for file in $files; do
2917 # Do each installation.
2920 # Do the static libraries later.
2921 func_append staticlibs " $file"
2925 func_resolve_sysroot "$file"
2926 file=$func_resolve_sysroot_result
2928 # Check to see that this really is a libtool archive.
2929 func_lalib_unsafe_p "$file" \
2930 || func_fatal_help "\`$file' is not a valid libtool archive"
2937 # Add the libdir to current_libdirs if it is the destination.
2938 if test "X$destdir" = "X$libdir"; then
2939 case "$current_libdirs " in
2941 *) func_append current_libdirs " $libdir" ;;
2944 # Note the libdir as a future libdir.
2945 case "$future_libdirs " in
2947 *) func_append future_libdirs " $libdir" ;;
2951 func_dirname "$file" "/" ""
2952 dir="$func_dirname_result"
2953 func_append dir "$objdir"
2955 if test -n "$relink_command"; then
2956 # Determine the prefix the user has applied to our future dir.
2957 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
2959 # Don't allow the user to place us outside of our expected
2960 # location b/c this prevents finding dependent libraries that
2961 # are installed to the same prefix.
2962 # At present, this check doesn't affect windows .dll's that
2963 # are installed into $libdir/../bin (currently, that works fine)
2964 # but it's something to keep an eye on.
2965 test "$inst_prefix_dir" = "$destdir" && \
2966 func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2968 if test -n "$inst_prefix_dir"; then
2969 # Stick the inst_prefix_dir data into the link command.
2970 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2972 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
2975 func_warning "relinking \`$file'"
2976 func_show_eval "$relink_command" \
2977 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2980 # See the names of the shared library.
2981 set dummy $library_names; shift
2982 if test -n "$1"; then
2987 test -n "$relink_command" && srcname="$realname"T
2989 # Install the shared library and build the symlinks.
2990 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
2994 cygwin* | mingw* | pw32* | cegcc*)
3002 if test -n "$tstripme" && test -n "$striplib"; then
3003 func_show_eval "$striplib $destdir/$realname" 'exit $?'
3006 if test "$#" -gt 0; then
3007 # Delete the old symlinks, and create new ones.
3008 # Try `ln -sf' first, because the `ln' binary might depend on
3009 # the symlink we replace! Solaris /bin/ln does not understand -f,
3010 # so we also need to try rm && ln -s.
3013 test "$linkname" != "$realname" \
3014 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
3018 # Do each command in the postinstall commands.
3019 lib="$destdir/$realname"
3020 func_execute_cmds "$postinstall_cmds" 'exit $?'
3023 # Install the pseudo-library for information purposes.
3024 func_basename "$file"
3025 name="$func_basename_result"
3026 instname="$dir/$name"i
3027 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
3029 # Maybe install the static library, too.
3030 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
3034 # Install (i.e. copy) a libtool object.
3036 # Figure out destination file name, if it wasn't already specified.
3037 if test -n "$destname"; then
3038 destfile="$destdir/$destname"
3040 func_basename "$file"
3041 destfile="$func_basename_result"
3042 destfile="$destdir/$destfile"
3045 # Deduce the name of the destination old-style object file.
3048 func_lo2o "$destfile"
3049 staticdest=$func_lo2o_result
3052 staticdest="$destfile"
3056 func_fatal_help "cannot copy a libtool object to \`$destfile'"
3060 # Install the libtool object if requested.
3061 test -n "$destfile" && \
3062 func_show_eval "$install_prog $file $destfile" 'exit $?'
3064 # Install the old object if enabled.
3065 if test "$build_old_libs" = yes; then
3066 # Deduce the name of the old-style object file.
3068 staticobj=$func_lo2o_result
3069 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
3075 # Figure out destination file name, if it wasn't already specified.
3076 if test -n "$destname"; then
3077 destfile="$destdir/$destname"
3079 func_basename "$file"
3080 destfile="$func_basename_result"
3081 destfile="$destdir/$destfile"
3084 # If the file is missing, and there is a .exe on the end, strip it
3085 # because it is most likely a libtool script we actually want to
3090 if test ! -f "$file"; then
3091 func_stripname '' '.exe' "$file"
3092 file=$func_stripname_result
3098 # Do a test to see if this is really a libtool program.
3101 if func_ltwrapper_executable_p "$file"; then
3102 func_ltwrapper_scriptname "$file"
3103 wrapper=$func_ltwrapper_scriptname_result
3105 func_stripname '' '.exe' "$file"
3106 wrapper=$func_stripname_result
3113 if func_ltwrapper_script_p "$wrapper"; then
3117 func_source "$wrapper"
3119 # Check the variables that should have been set.
3120 test -z "$generated_by_libtool_version" && \
3121 func_fatal_error "invalid libtool wrapper script \`$wrapper'"
3124 for lib in $notinst_deplibs; do
3125 # Check to see that each library is installed.
3127 if test -f "$lib"; then
3130 libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
3131 if test -n "$libdir" && test ! -f "$libfile"; then
3132 func_warning "\`$lib' has not been installed in \`$libdir'"
3138 func_source "$wrapper"
3141 if test "$fast_install" = no && test -n "$relink_command"; then
3143 if test "$finalize" = yes; then
3144 tmpdir=`func_mktempdir`
3145 func_basename "$file$stripped_ext"
3146 file="$func_basename_result"
3147 outputname="$tmpdir/$file"
3148 # Replace the output file specification.
3149 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
3152 func_quote_for_expand "$relink_command"
3153 eval "func_echo $func_quote_for_expand_result"
3155 if eval "$relink_command"; then :
3157 func_error "error: relink \`$file' with the above command before installing it"
3158 $opt_dry_run || ${RM}r "$tmpdir"
3163 func_warning "cannot relink \`$file'"
3167 # Install the binary that we compiled earlier.
3168 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
3172 # remove .exe since cygwin /usr/bin/install will append another
3174 case $install_prog,$host in
3175 */usr/bin/install*,*cygwin*)
3176 case $file:$destfile in
3181 destfile=$destfile.exe
3184 func_stripname '' '.exe' "$destfile"
3185 destfile=$func_stripname_result
3190 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
3191 $opt_dry_run || if test -n "$outputname"; then
3198 for file in $staticlibs; do
3199 func_basename "$file"
3200 name="$func_basename_result"
3202 # Set up the ranlib parameters.
3203 oldlib="$destdir/$name"
3205 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
3207 if test -n "$stripme" && test -n "$old_striplib"; then
3208 func_show_eval "$old_striplib $oldlib" 'exit $?'
3211 # Do each command in the postinstall commands.
3212 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
3215 test -n "$future_libdirs" && \
3216 func_warning "remember to run \`$progname --finish$future_libdirs'"
3218 if test -n "$current_libdirs"; then
3219 # Maybe just do a dry run.
3220 $opt_dry_run && current_libdirs=" -n$current_libdirs"
3221 exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
3227 test "$opt_mode" = install && func_mode_install ${1+"$@"}
3230 # func_generate_dlsyms outputname originator pic_p
3231 # Extract symbols from dlprefiles and create ${outputname}S.o with
3232 # a dlpreopen symbol table.
3233 func_generate_dlsyms ()
3239 my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
3242 if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3243 if test -n "$NM" && test -n "$global_symbol_pipe"; then
3244 my_dlsyms="${my_outputname}S.c"
3246 func_error "not configured to extract global symbols from dlpreopened files"
3250 if test -n "$my_dlsyms"; then
3254 # Discover the nlist of each of the dlfiles.
3255 nlist="$output_objdir/${my_outputname}.nm"
3257 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
3259 # Parse the name list into a source file.
3260 func_verbose "creating $output_objdir/$my_dlsyms"
3262 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
3263 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
3264 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
3270 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
3271 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
3274 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
3275 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
3276 /* DATA imports from DLLs on WIN32 con't be const, because runtime
3277 relocations are performed -- see ld's documentation on pseudo-relocs. */
3278 # define LT_DLSYM_CONST
3279 #elif defined(__osf__)
3280 /* This system does not cope well with relocations in const data. */
3281 # define LT_DLSYM_CONST
3283 # define LT_DLSYM_CONST const
3286 /* External symbol declarations for the compiler. */\
3289 if test "$dlself" = yes; then
3290 func_verbose "generating symbol list for \`$output'"
3292 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
3294 # Add our own program objects to the symbol list.
3295 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
3296 for progfile in $progfiles; do
3297 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
3298 func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
3299 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
3302 if test -n "$exclude_expsyms"; then
3304 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3305 eval '$MV "$nlist"T "$nlist"'
3309 if test -n "$export_symbols_regex"; then
3311 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3312 eval '$MV "$nlist"T "$nlist"'
3316 # Prepare the list of exported symbols
3317 if test -z "$export_symbols"; then
3318 export_symbols="$output_objdir/$outputname.exp"
3321 eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3323 *cygwin* | *mingw* | *cegcc* )
3324 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3325 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
3331 eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
3332 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
3333 eval '$MV "$nlist"T "$nlist"'
3335 *cygwin* | *mingw* | *cegcc* )
3336 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
3337 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
3344 for dlprefile in $dlprefiles; do
3345 func_verbose "extracting global C symbols from \`$dlprefile'"
3346 func_basename "$dlprefile"
3347 name="$func_basename_result"
3349 *cygwin* | *mingw* | *cegcc* )
3350 # if an import library, we need to obtain dlname
3351 if func_win32_import_lib_p "$dlprefile"; then
3352 func_tr_sh "$dlprefile"
3353 eval "curr_lafile=\$libfile_$func_tr_sh_result"
3354 dlprefile_dlbasename=""
3355 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
3356 # Use subshell, to avoid clobbering current variable values
3357 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
3358 if test -n "$dlprefile_dlname" ; then
3359 func_basename "$dlprefile_dlname"
3360 dlprefile_dlbasename="$func_basename_result"
3362 # no lafile. user explicitly requested -dlpreopen <import library>.
3363 $sharedlib_from_linklib_cmd "$dlprefile"
3364 dlprefile_dlbasename=$sharedlib_from_linklib_result
3368 if test -n "$dlprefile_dlbasename" ; then
3369 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
3371 func_warning "Could not compute DLL name from $name"
3372 eval '$ECHO ": $name " >> "$nlist"'
3374 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3375 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
3376 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
3378 else # not an import lib
3380 eval '$ECHO ": $name " >> "$nlist"'
3381 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3382 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3388 eval '$ECHO ": $name " >> "$nlist"'
3389 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
3390 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
3397 # Make sure we have at least an empty file.
3398 test -f "$nlist" || : > "$nlist"
3400 if test -n "$exclude_expsyms"; then
3401 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3402 $MV "$nlist"T "$nlist"
3405 # Try sorting and uniquifying the output.
3406 if $GREP -v "^: " < "$nlist" |
3407 if sort -k 3 </dev/null >/dev/null 2>&1; then
3412 uniq > "$nlist"S; then
3415 $GREP -v "^: " < "$nlist" > "$nlist"S
3418 if test -f "$nlist"S; then
3419 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
3421 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
3424 echo >> "$output_objdir/$my_dlsyms" "\
3426 /* The mapping between symbol names and symbols. */
3431 extern LT_DLSYM_CONST lt_dlsymlist
3432 lt_${my_prefix}_LTX_preloaded_symbols[];
3433 LT_DLSYM_CONST lt_dlsymlist
3434 lt_${my_prefix}_LTX_preloaded_symbols[] =
3436 { \"$my_originator\", (void *) 0 },"
3438 case $need_lib_prefix in
3440 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
3443 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
3446 echo >> "$output_objdir/$my_dlsyms" "\
3450 /* This works around a problem in FreeBSD linker */
3451 #ifdef FREEBSD_WORKAROUND
3452 static const void *lt_preloaded_setup() {
3453 return lt_${my_prefix}_LTX_preloaded_symbols;
3463 pic_flag_for_symtable=
3464 case "$compile_command " in
3468 # compiling the symbol table file with pic_flag works around
3469 # a FreeBSD bug that causes programs to crash when -lm is
3470 # linked before any other PIC object. But we must not use
3471 # pic_flag when linking with -static. The problem exists in
3472 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3473 *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3474 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
3476 pic_flag_for_symtable=" $pic_flag" ;;
3478 if test "X$my_pic_p" != Xno; then
3479 pic_flag_for_symtable=" $pic_flag"
3486 for arg in $LTCFLAGS; do
3488 -pie | -fpie | -fPIE) ;;
3489 *) func_append symtab_cflags " $arg" ;;
3493 # Now compile the dynamic symbol file.
3494 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3496 # Clean up the generated files.
3497 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3499 # Transform the symbol file into the correct name.
3500 symfileobj="$output_objdir/${my_outputname}S.$objext"
3502 *cygwin* | *mingw* | *cegcc* )
3503 if test -f "$output_objdir/$my_outputname.def"; then
3504 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3505 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3507 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3508 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3512 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3513 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
3518 func_fatal_error "unknown suffix for \`$my_dlsyms'"
3522 # We keep going just in case the user didn't refer to
3523 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
3524 # really was required.
3526 # Nullify the symbol file.
3527 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
3528 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
3532 # func_win32_libid arg
3533 # return the library type of file 'arg'
3535 # Need a lot of goo to handle *both* DLLs and import libs
3536 # Has to be a shell function in order to 'eat' the argument
3537 # that is supplied when $file_magic_command is called.
3538 # Despite the name, also deal with 64 bit binaries.
3542 win32_libid_type="unknown"
3543 win32_fileres=`file -L $1 2>/dev/null`
3544 case $win32_fileres in
3545 *ar\ archive\ import\ library*) # definitely import
3546 win32_libid_type="x86 archive import"
3548 *ar\ archive*) # could be an import, or static
3549 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
3550 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3551 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
3552 func_to_tool_file "$1" func_convert_file_msys_to_w32
3553 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
3562 case $win32_nmres in
3563 import*) win32_libid_type="x86 archive import";;
3564 *) win32_libid_type="x86 archive static";;
3569 win32_libid_type="x86 DLL"
3571 *executable*) # but shell scripts are "executable" too...
3572 case $win32_fileres in
3573 *MS\ Windows\ PE\ Intel*)
3574 win32_libid_type="x86 DLL"
3579 $ECHO "$win32_libid_type"
3582 # func_cygming_dll_for_implib ARG
3584 # Platform-specific function to extract the
3585 # name of the DLL associated with the specified
3586 # import library ARG.
3587 # Invoked by eval'ing the libtool variable
3588 # $sharedlib_from_linklib_cmd
3589 # Result is available in the variable
3590 # $sharedlib_from_linklib_result
3591 func_cygming_dll_for_implib ()
3594 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
3597 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
3599 # The is the core of a fallback implementation of a
3600 # platform-specific function to extract the name of the
3601 # DLL associated with the specified import library LIBNAME.
3603 # SECTION_NAME is either .idata$6 or .idata$7, depending
3604 # on the platform and compiler that created the implib.
3606 # Echos the name of the DLL associated with the
3607 # specified import library.
3608 func_cygming_dll_for_implib_fallback_core ()
3611 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
3612 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
3613 $SED '/^Contents of section '"$match_literal"':/{
3614 # Place marker at beginning of archive member dllname section
3619 # These lines can sometimes be longer than 43 characters, but
3620 # are always uninteresting
3621 /:[ ]*file format pe[i]\{,1\}-/d
3622 /^In archive [^:]*:/d
3623 # Ensure marker is printed
3625 # Remove all lines with less than 43 characters
3627 # From remaining lines, remove first 43 characters
3630 # Join marker and all lines until next marker into a single line
3631 /^====MARK====/ b para
3640 # Remove trailing dots and whitespace
3644 # we now have a list, one entry per line, of the stringified
3645 # contents of the appropriate section of all members of the
3646 # archive which possess that section. Heuristic: eliminate
3647 # all those which have a first or second character that is
3648 # a '.' (that is, objdump's representation of an unprintable
3649 # character.) This should work for all archives with less than
3650 # 0x302f exports -- but will fail for DLLs whose name actually
3651 # begins with a literal '.' or a single character followed by
3654 # Of those that remain, print the first one.
3655 $SED -e '/^\./d;/^.\./d;q'
3658 # func_cygming_gnu_implib_p ARG
3659 # This predicate returns with zero status (TRUE) if
3660 # ARG is a GNU/binutils-style import library. Returns
3661 # with nonzero status (FALSE) otherwise.
3662 func_cygming_gnu_implib_p ()
3665 func_to_tool_file "$1" func_convert_file_msys_to_w32
3666 func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
3667 test -n "$func_cygming_gnu_implib_tmp"
3670 # func_cygming_ms_implib_p ARG
3671 # This predicate returns with zero status (TRUE) if
3672 # ARG is an MS-style import library. Returns
3673 # with nonzero status (FALSE) otherwise.
3674 func_cygming_ms_implib_p ()
3677 func_to_tool_file "$1" func_convert_file_msys_to_w32
3678 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
3679 test -n "$func_cygming_ms_implib_tmp"
3682 # func_cygming_dll_for_implib_fallback ARG
3683 # Platform-specific function to extract the
3684 # name of the DLL associated with the specified
3685 # import library ARG.
3687 # This fallback implementation is for use when $DLLTOOL
3688 # does not support the --identify-strict option.
3689 # Invoked by eval'ing the libtool variable
3690 # $sharedlib_from_linklib_cmd
3691 # Result is available in the variable
3692 # $sharedlib_from_linklib_result
3693 func_cygming_dll_for_implib_fallback ()
3696 if func_cygming_gnu_implib_p "$1" ; then
3697 # binutils import library
3698 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
3699 elif func_cygming_ms_implib_p "$1" ; then
3700 # ms-generated import library
3701 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
3704 sharedlib_from_linklib_result=""
3709 # func_extract_an_archive dir oldlib
3710 func_extract_an_archive ()
3713 f_ex_an_ar_dir="$1"; shift
3714 f_ex_an_ar_oldlib="$1"
3715 if test "$lock_old_archive_extraction" = yes; then
3716 lockfile=$f_ex_an_ar_oldlib.lock
3717 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3718 func_echo "Waiting for $lockfile to be removed"
3722 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
3723 'stat=$?; rm -f "$lockfile"; exit $stat'
3724 if test "$lock_old_archive_extraction" = yes; then
3725 $opt_dry_run || rm -f "$lockfile"
3727 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3730 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3735 # func_extract_archives gentop oldlib ...
3736 func_extract_archives ()
3739 my_gentop="$1"; shift
3740 my_oldlibs=${1+"$@"}
3746 for my_xlib in $my_oldlibs; do
3747 # Extract the objects.
3749 [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3750 *) my_xabs=`pwd`"/$my_xlib" ;;
3752 func_basename "$my_xlib"
3753 my_xlib="$func_basename_result"
3756 case " $extracted_archives " in
3758 func_arith $extracted_serial + 1
3759 extracted_serial=$func_arith_result
3760 my_xlib_u=lt$extracted_serial-$my_xlib ;;
3764 extracted_archives="$extracted_archives $my_xlib_u"
3765 my_xdir="$my_gentop/$my_xlib_u"
3767 func_mkdir_p "$my_xdir"
3771 func_verbose "Extracting $my_xabs"
3772 # Do not bother doing anything if just a dry run
3774 darwin_orig_dir=`pwd`
3775 cd $my_xdir || exit $?
3776 darwin_archive=$my_xabs
3778 darwin_base_archive=`basename "$darwin_archive"`
3779 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3780 if test -n "$darwin_arches"; then
3781 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3783 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3784 for darwin_arch in $darwin_arches ; do
3785 func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3786 $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3787 cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3788 func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3790 $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3791 done # $darwin_arches
3792 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3793 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3796 for darwin_file in $darwin_filelist; do
3797 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
3798 $LIPO -create -output "$darwin_file" $darwin_files
3799 done # $darwin_filelist
3801 cd "$darwin_orig_dir"
3804 func_extract_an_archive "$my_xdir" "$my_xabs"
3809 func_extract_an_archive "$my_xdir" "$my_xabs"
3812 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
3815 func_extract_archives_result="$my_oldobjs"