2 ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
3 ## by inline-source v2019-02-19.15
5 # libtool (GNU libtool) 2.4.7
6 # Provide generalized library-building support services.
7 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
9 # Copyright (C) 1996-2019, 2021-2022 Free Software Foundation, Inc.
10 # This is free software; see the source for copying conditions. There is NO
11 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 # GNU Libtool is free software; you can redistribute it and/or modify
14 # it under the terms of the GNU General Public License as published by
15 # the Free Software Foundation; either version 2 of the License, or
16 # (at your option) any later version.
18 # As a special exception to the GNU General Public License,
19 # if you distribute this file as part of a program or library that
20 # is built using GNU Libtool, you may include this file under the
21 # same distribution terms that you use for the rest of that program.
23 # GNU Libtool is distributed in the hope that it will be useful, but
24 # WITHOUT ANY WARRANTY; without even the implied warranty of
25 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 # General Public License for more details.
28 # You should have received a copy of the GNU General Public License
29 # along with this program. If not, see <http://www.gnu.org/licenses/>.
34 VERSION="2.4.7 Debian-2.4.7-4"
35 package_revision=2.4.7
42 # Run './libtool --help' for help with using this script from the
46 ## ------------------------------- ##
47 ## User overridable command paths. ##
48 ## ------------------------------- ##
50 # After configure completes, it has a better idea of some of the
51 # shell tools we need than the defaults used by the functions shared
52 # with bootstrap, so set those here where they can still be over-
53 # ridden by the user, but otherwise take precedence.
55 : ${AUTOCONF="autoconf"}
56 : ${AUTOMAKE="automake"}
59 ## -------------------------- ##
60 ## Source external libraries. ##
61 ## -------------------------- ##
63 # Much of our low-level functionality needs to be sourced from external
64 # libraries, which are installed to $pkgauxdir.
66 # Set a version string for this script.
67 scriptversion=2019-02-19.15; # UTC
69 # General shell script boiler plate, and helper functions.
70 # Written by Gary V. Vaughan, 2004
72 # This is free software. There is NO warranty; not even for
73 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
75 # Copyright (C) 2004-2019, 2021 Bootstrap Authors
77 # This file is dual licensed under the terms of the MIT license
78 # <https://opensource.org/license/MIT>, and GPL version 2 or later
79 # <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of
80 # these licenses when using or redistributing this software or any of
81 # the files within it. See the URLs above, or the file `LICENSE`
82 # included in the Bootstrap distribution for the full license texts.
84 # Please report bugs or propose patches to:
85 # <https://github.com/gnulib-modules/bootstrap/issues>
92 # Evaluate this file near the top of your script to gain access to
93 # the functions and variables defined here:
95 # . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
97 # If you need to override any of the default environment variable
98 # settings, do that before evaluating this file.
101 ## -------------------- ##
102 ## Shell normalisation. ##
103 ## -------------------- ##
105 # Some shells need a little help to be as Bourne compatible as possible.
106 # Before doing anything else, make sure all that help has been provided!
108 DUALCASE=1; export DUALCASE # for MKS sh
109 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
112 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
113 # is contrary to our usage. Disable this feature.
114 alias -g '${1+"$@"}'='"$@"'
117 case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
120 # NLS nuisances: We save the old values in case they are required later.
123 for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
125 eval "if test set = \"\${$_G_var+set}\"; then
126 save_$_G_var=\$$_G_var
129 _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
130 _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
133 # These NLS vars are set unconditionally (bootstrap issue #24). Unset those
134 # in case the environment reset is needed later and the $save_* variant is not
135 # defined (see the code above).
138 export LANGUAGE LC_ALL
140 # Make sure IFS has a sensible default
146 # There are apparently some retarded systems that use ';' as a PATH separator!
147 if test "${PATH_SEPARATOR+set}" != set; then
149 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
150 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
158 # Portably unset VAR.
159 # In some shells, an 'unset VAR' statement leaves a non-zero return
160 # status if VAR is already unset, which might be problematic if the
161 # statement is used at the end of a function (thus poisoning its return
162 # value) or when 'set -e' is active (causing even a spurious abort of
163 # the script in this case).
166 { eval $1=; (eval unset $1) >/dev/null 2>&1 && eval unset $1 || : ; }
170 # Make sure CDPATH doesn't cause `cd` commands to output the target dir.
173 # Make sure ${,E,F}GREP behave sanely.
174 func_unset GREP_OPTIONS
177 ## ------------------------- ##
178 ## Locate command utilities. ##
179 ## ------------------------- ##
182 # func_executable_p FILE
183 # ----------------------
184 # Check that FILE is an executable regular file.
187 test -f "$1" && test -x "$1"
191 # func_path_progs PROGS_LIST CHECK_FUNC [PATH]
192 # --------------------------------------------
193 # Search for either a program that responds to --version with output
194 # containing "GNU", or else returned by CHECK_FUNC otherwise, by
195 # trying all the directories in PATH with each of the elements of
198 # CHECK_FUNC should accept the path to a candidate program, and
199 # set $func_check_prog_result if it truncates its output less than
200 # $_G_path_prog_max characters.
208 _G_path_prog_found=false
209 _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
210 for _G_dir in $_G_PATH; do
212 test -z "$_G_dir" && _G_dir=.
213 for _G_prog_name in $_G_progs_list; do
214 for _exeext in '' .EXE; do
215 _G_path_prog=$_G_dir/$_G_prog_name$_exeext
216 func_executable_p "$_G_path_prog" || continue
217 case `"$_G_path_prog" --version 2>&1` in
218 *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
219 *) $_G_check_func $_G_path_prog
220 func_path_progs_result=$func_check_prog_result
223 $_G_path_prog_found && break 3
228 test -z "$func_path_progs_result" && {
229 echo "no acceptable sed could be found in \$PATH" >&2
235 # We want to be able to use the functions in this file before configure
236 # has figured out where the best binaries are kept, which means we have
237 # to search for them ourselves - except when the results are already set
238 # where we skip the searches.
240 # Unless the user overrides by setting SED, search the path for either GNU
241 # sed, or the sed that truncates its output the least.
243 _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
244 for _G_i in 1 2 3 4 5 6 7; do
245 _G_sed_script=$_G_sed_script$nl$_G_sed_script
247 echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
250 func_check_prog_sed ()
255 printf 0123456789 >conftest.in
258 cat conftest.in conftest.in >conftest.tmp
259 mv conftest.tmp conftest.in
260 cp conftest.in conftest.nl
261 echo '' >> conftest.nl
262 "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
263 diff conftest.out conftest.nl >/dev/null 2>&1 || break
264 _G_count=`expr $_G_count + 1`
265 if test "$_G_count" -gt "$_G_path_prog_max"; then
266 # Best one so far, save it but keep looking for a better one
267 func_check_prog_result=$_G_path_prog
268 _G_path_prog_max=$_G_count
270 # 10*(2^10) chars as input seems more than enough
271 test 10 -lt "$_G_count" && break
273 rm -f conftest.in conftest.tmp conftest.nl conftest.out
276 func_path_progs "sed gsed" func_check_prog_sed "$PATH:/usr/xpg4/bin"
278 SED=$func_path_progs_result
282 # Unless the user overrides by setting GREP, search the path for either GNU
283 # grep, or the grep that truncates its output the least.
285 func_check_prog_grep ()
291 printf 0123456789 >conftest.in
294 cat conftest.in conftest.in >conftest.tmp
295 mv conftest.tmp conftest.in
296 cp conftest.in conftest.nl
297 echo 'GREP' >> conftest.nl
298 "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
299 diff conftest.out conftest.nl >/dev/null 2>&1 || break
300 _G_count=`expr $_G_count + 1`
301 if test "$_G_count" -gt "$_G_path_prog_max"; then
302 # Best one so far, save it but keep looking for a better one
303 func_check_prog_result=$_G_path_prog
304 _G_path_prog_max=$_G_count
306 # 10*(2^10) chars as input seems more than enough
307 test 10 -lt "$_G_count" && break
309 rm -f conftest.in conftest.tmp conftest.nl conftest.out
312 func_path_progs "grep ggrep" func_check_prog_grep "$PATH:/usr/xpg4/bin"
313 GREP=$func_path_progs_result
317 ## ------------------------------- ##
318 ## User overridable command paths. ##
319 ## ------------------------------- ##
321 # All uppercase variable names are used for environment variables. These
322 # variables can be overridden by the user before calling a script that
323 # uses them if a suitable command of that name is not already available
324 # in the command search PATH.
327 : ${ECHO="printf %s\n"}
328 : ${EGREP="$GREP -E"}
329 : ${FGREP="$GREP -F"}
335 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
338 ## -------------------- ##
339 ## Useful sed snippets. ##
340 ## -------------------- ##
342 sed_dirname='s|/[^/]*$||'
343 sed_basename='s|^.*/||'
345 # Sed substitution that helps us do robust quoting. It backslashifies
346 # metacharacters that are still active within double-quoted strings.
347 sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
349 # Same as above, but do not quote variable references.
350 sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
352 # Sed substitution that turns a string into a regex matching for the
354 sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
356 # Sed substitution that converts a w32 file name or path
357 # that contains forward slashes, into one that contains
358 # (escaped) backslashes. A very naive implementation.
359 sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
361 # Re-'\' parameter expansions in output of sed_double_quote_subst that
362 # were '\'-ed in input to the same. If an odd number of '\' preceded a
363 # '$' in input to sed_double_quote_subst, that '$' was protected from
364 # expansion. Since each input '\' is now two '\'s, look for any number
365 # of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'.
370 sed_double_backslash="\
373 s/^$_G_bs2$_G_dollar/$_G_bs&/
374 s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
377 # require_check_ifs_backslash
378 # ---------------------------
379 # Check if we can use backslash as IFS='\' separator, and set
380 # $check_ifs_backshlash_broken to ':' or 'false'.
381 require_check_ifs_backslash=func_require_check_ifs_backslash
382 func_require_check_ifs_backslash ()
386 _G_check_ifs_backshlash='a\\b'
387 for _G_i in $_G_check_ifs_backshlash
391 check_ifs_backshlash_broken=false
397 check_ifs_backshlash_broken=:
403 require_check_ifs_backslash=:
407 ## ----------------- ##
408 ## Global variables. ##
409 ## ----------------- ##
411 # Except for the global variables explicitly listed below, the following
412 # functions in the '^func_' namespace, and the '^require_' namespace
413 # variables initialised in the 'Resource management' section, sourcing
414 # this file will not pollute your global namespace with anything
415 # else. There's no portable way to scope variables in Bourne shell
416 # though, so actually running these functions will sometimes place
417 # results into a variable named after the function, and often use
418 # temporary variables in the '^_G_' namespace. If you are careful to
419 # avoid using those namespaces casually in your sourcing script, things
420 # should continue to work as you expect. And, of course, you can freely
421 # overwrite any of the functions or variables defined here before
422 # calling anything to customize them.
426 EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
427 EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
429 # Allow overriding, eg assuming that you follow the convention of
430 # putting '$debug_cmd' at the start of all your functions, you can get
431 # bash to show function call trace with:
433 # debug_cmd='echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
434 debug_cmd=${debug_cmd-":"}
437 # By convention, finish your script with:
441 # so that you can set exit_status to non-zero if you want to indicate
442 # something went wrong during execution without actually bailing out at
443 # the point of failure.
444 exit_status=$EXIT_SUCCESS
446 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
447 # is ksh but when the shell is invoked as "sh" and the current value of
448 # the _XPG environment variable is not equal to 1 (one), the special
449 # positional parameter $0, within a function call, is the name of the
453 # The name of this program.
454 progname=`$ECHO "$progpath" |$SED "$sed_basename"`
456 # Make sure we have an absolute progpath for reexecution:
458 [\\/]*|[A-Za-z]:\\*) ;;
460 progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
461 progdir=`cd "$progdir" && pwd`
462 progpath=$progdir/$progname
466 IFS=${PATH_SEPARATOR-:}
467 for progdir in $PATH; do
469 test -x "$progdir/$progname" && break
472 test -n "$progdir" || progdir=`pwd`
473 progpath=$progdir/$progname
478 ## ----------------- ##
479 ## Standard options. ##
480 ## ----------------- ##
482 # The following options affect the operation of the functions defined
483 # below, and should be set appropriately depending on run-time para-
484 # meters passed on the command line.
490 # Categories 'all' and 'none' are always available. Append any others
491 # you will pass as the first argument to func_warning from your own
495 # By default, display warnings according to 'opt_warning_types'. Set
496 # 'warning_func' to ':' to elide all warnings, or func_fatal_error to
497 # treat the next displayed warning as a fatal error.
498 warning_func=func_warn_and_continue
500 # Set to 'all' to display all warnings, 'none' to suppress all
501 # warnings, or a space delimited list of some subset of
502 # 'warning_categories' to display only the listed warnings.
503 opt_warning_types=all
506 ## -------------------- ##
507 ## Resource management. ##
508 ## -------------------- ##
510 # This section contains definitions for functions that each ensure a
511 # particular resource (a file, or a non-empty configuration variable for
512 # example) is available, and if appropriate to extract default values
513 # from pertinent package files. Call them using their associated
514 # 'require_*' variable to ensure that they are executed, at most, once.
516 # It's entirely deliberate that calling these functions can set
517 # variables that don't obey the namespace limitations obeyed by the rest
518 # of this file, in order that that they be as useful as possible to
522 # require_term_colors
523 # -------------------
524 # Allow display of bold text on terminals that support it.
525 require_term_colors=func_require_term_colors
526 func_require_term_colors ()
531 # COLORTERM and USE_ANSI_COLORS environment variables take
532 # precedence, because most terminfo databases neglect to describe
533 # whether color sequences are supported.
534 test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
536 if test 1 = "$USE_ANSI_COLORS"; then
537 # Standard ANSI escape sequences
539 tc_bold='
\e[1m'; tc_standout='
\e[7m'
540 tc_red='
\e[31m'; tc_green='
\e[32m'
541 tc_blue='
\e[34m'; tc_cyan='
\e[36m'
543 # Otherwise trust the terminfo database after all.
544 test -n "`tput sgr0 2>/dev/null`" && {
546 test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
548 test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
549 test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
550 test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
551 test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
552 test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
557 require_term_colors=:
561 ## ----------------- ##
562 ## Function library. ##
563 ## ----------------- ##
565 # This section contains a variety of useful functions to call in your
566 # scripts. Take note of the portable wrappers for features provided by
567 # some modern shells, which will fall back to slower equivalents on
568 # less featureful shells.
571 # func_append VAR VALUE
572 # ---------------------
573 # Append VALUE onto the existing contents of VAR.
575 # We should try to minimise forks, especially on Windows where they are
576 # unreasonably slow, so skip the feature probes when bash or zsh are
578 if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
579 : ${_G_HAVE_ARITH_OP="yes"}
580 : ${_G_HAVE_XSI_OPS="yes"}
581 # The += operator was introduced in bash 3.1
582 case $BASH_VERSION in
583 [12].* | 3.0 | 3.0*) ;;
585 : ${_G_HAVE_PLUSEQ_OP="yes"}
591 # Can be empty, in which case the shell is probed, "yes" if += is
592 # useable or anything else if it does not work.
593 test -z "$_G_HAVE_PLUSEQ_OP" \
594 && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
595 && _G_HAVE_PLUSEQ_OP=yes
597 if test yes = "$_G_HAVE_PLUSEQ_OP"
599 # This is an XSI compatible shell, allowing a faster implementation...
607 # ...otherwise fall back to using expr, which is often a shell builtin.
617 # func_append_quoted VAR VALUE
618 # ----------------------------
619 # Quote VALUE and append to the end of shell variable VAR, separated
621 if test yes = "$_G_HAVE_PLUSEQ_OP"; then
622 eval 'func_append_quoted ()
626 func_quote_arg pretty "$2"
627 eval "$1+=\\ \$func_quote_arg_result"
630 func_append_quoted ()
634 func_quote_arg pretty "$2"
635 eval "$1=\$$1\\ \$func_quote_arg_result"
640 # func_append_uniq VAR VALUE
641 # --------------------------
642 # Append unique VALUE onto the existing contents of VAR, assuming
643 # entries are delimited by the first character of VALUE. For example:
645 # func_append_uniq options " --another-option option-argument"
647 # will only append to $options if " --another-option option-argument "
648 # is not already present somewhere in $options already (note spaces at
649 # each end implied by leading space in second argument).
654 eval _G_current_value='`$ECHO $'$1'`'
655 _G_delim=`expr "$2" : '\(.\)'`
657 case $_G_delim$_G_current_value$_G_delim in
659 *) func_append "$@" ;;
666 # Set func_arith_result to the result of evaluating TERMs.
667 test -z "$_G_HAVE_ARITH_OP" \
668 && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
669 && _G_HAVE_ARITH_OP=yes
671 if test yes = "$_G_HAVE_ARITH_OP"; then
676 func_arith_result=$(( $* ))
683 func_arith_result=`expr "$@"`
690 # Set func_basename_result to FILE with everything up to and including
691 # the last / stripped.
692 if test yes = "$_G_HAVE_XSI_OPS"; then
693 # If this shell supports suffix pattern removal, then use it to avoid
694 # forking. Hide the definitions single quotes in case the shell chokes
695 # on unsupported syntax...
696 _b='func_basename_result=${1##*/}'
698 */*) func_dirname_result=${1%/*}$2 ;;
699 * ) func_dirname_result=$3 ;;
703 # ...otherwise fall back to using sed.
704 _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
705 _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"`
706 if test "X$func_dirname_result" = "X$1"; then
707 func_dirname_result=$3
709 func_append func_dirname_result "$2"
713 eval 'func_basename ()
721 # func_dirname FILE APPEND NONDIR_REPLACEMENT
722 # -------------------------------------------
723 # Compute the dirname of FILE. If nonempty, add APPEND to the result,
724 # otherwise set result to NONDIR_REPLACEMENT.
725 eval 'func_dirname ()
733 # func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
734 # --------------------------------------------------------
735 # Perform func_basename and func_dirname in a single function
737 # dirname: Compute the dirname of FILE. If nonempty,
738 # add APPEND to the result, otherwise set result
739 # to NONDIR_REPLACEMENT.
740 # value returned in "$func_dirname_result"
741 # basename: Compute filename of FILE.
742 # value retuned in "$func_basename_result"
743 # For efficiency, we do not delegate to the functions above but instead
744 # duplicate the functionality here.
745 eval 'func_dirname_and_basename ()
756 # Echo program name prefixed message.
765 for _G_line in $_G_message; do
767 $ECHO "$progname: $_G_line"
773 # func_echo_all ARG...
774 # --------------------
775 # Invoke $ECHO with all args, space-separated.
782 # func_echo_infix_1 INFIX ARG...
783 # ------------------------------
784 # Echo program name, followed by INFIX on the first line, with any
785 # additional lines not showing INFIX.
794 _G_prefix="$progname: $_G_infix: "
797 # Strip color escape sequences before counting printable length
798 for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
800 test -n "$_G_tc" && {
801 _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
802 _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
805 _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes
807 func_echo_infix_1_IFS=$IFS
809 for _G_line in $_G_message; do
810 IFS=$func_echo_infix_1_IFS
811 $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
814 IFS=$func_echo_infix_1_IFS
820 # Echo program name prefixed message to standard error.
827 func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2
831 # func_fatal_error ARG...
832 # -----------------------
833 # Echo program name prefixed message to standard error, and exit.
843 # func_grep EXPRESSION FILENAME
844 # -----------------------------
845 # Check whether EXPRESSION matches any line of FILENAME, without output.
850 $GREP "$1" "$2" >/dev/null 2>&1
856 # Set func_len_result to the length of STRING. STRING may not
857 # start with a hyphen.
858 test -z "$_G_HAVE_XSI_OPS" \
860 test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
861 && _G_HAVE_XSI_OPS=yes
863 if test yes = "$_G_HAVE_XSI_OPS"; then
868 func_len_result=${#1}
875 func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
880 # func_mkdir_p DIRECTORY-PATH
881 # ---------------------------
882 # Make sure the entire path to DIRECTORY-PATH is available.
890 if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
892 # Protect directory names starting with '-'
893 case $_G_directory_path in
894 -*) _G_directory_path=./$_G_directory_path ;;
897 # While some portion of DIR does not yet exist...
898 while test ! -d "$_G_directory_path"; do
899 # ...make a list in topmost first order. Use a colon delimited
900 # list incase some portion of path contains whitespace.
901 _G_dir_list=$_G_directory_path:$_G_dir_list
903 # If the last portion added has no slash in it, the list is done
904 case $_G_directory_path in */*) ;; *) break ;; esac
906 # ...otherwise throw away the child directory and loop
907 _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
909 _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
911 func_mkdir_p_IFS=$IFS; IFS=:
912 for _G_dir in $_G_dir_list; do
913 IFS=$func_mkdir_p_IFS
914 # mkdir can fail with a 'File exist' error if two processes
915 # try to create one of the directories concurrently. Don't
917 $MKDIR "$_G_dir" 2>/dev/null || :
919 IFS=$func_mkdir_p_IFS
921 # Bail out if we (or some other process) failed to create a directory.
922 test -d "$_G_directory_path" || \
923 func_fatal_error "Failed to create '$1'"
928 # func_mktempdir [BASENAME]
929 # -------------------------
930 # Make a temporary directory that won't clash with other running
931 # libtool processes, and avoids race conditions if possible. If
932 # given, BASENAME is the basename for that directory.
937 _G_template=${TMPDIR-/tmp}/${1-$progname}
939 if test : = "$opt_dry_run"; then
940 # Return a directory name, but don't create it in dry-run mode
941 _G_tmpdir=$_G_template-$$
944 # If mktemp works, use that first and foremost
945 _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
947 if test ! -d "$_G_tmpdir"; then
948 # Failing that, at least try and use $RANDOM to avoid a race
949 _G_tmpdir=$_G_template-${RANDOM-0}$$
951 func_mktempdir_umask=`umask`
954 umask $func_mktempdir_umask
957 # If we're not in dry-run mode, bomb out on failure
958 test -d "$_G_tmpdir" || \
959 func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
966 # func_normal_abspath PATH
967 # ------------------------
968 # Remove doubled-up and trailing slashes, "." path components,
969 # and cancel out any ".." path components in PATH after making
970 # it an absolute path.
971 func_normal_abspath ()
975 # These SED scripts presuppose an absolute path with a trailing slash.
976 _G_pathcar='s|^/\([^/]*\).*$|\1|'
977 _G_pathcdr='s|^/[^/]*||'
978 _G_removedotparts=':dotsl
982 _G_collapseslashes='s|/\{1,\}|/|g'
983 _G_finalslash='s|/*$|/|'
985 # Start from root dir and reassemble the path.
986 func_normal_abspath_result=
987 func_normal_abspath_tpath=$1
988 func_normal_abspath_altnamespace=
989 case $func_normal_abspath_tpath in
991 # Empty path, that just means $cwd.
992 func_stripname '' '/' "`pwd`"
993 func_normal_abspath_result=$func_stripname_result
996 # The next three entries are used to spot a run of precisely
997 # two leading slashes without using negated character classes;
998 # we take advantage of case's first-match behaviour.
1000 # Unusual form of absolute path, do nothing.
1003 # Not necessarily an ordinary path; POSIX reserves leading '//'
1004 # and for example Cygwin uses it to access remote file shares
1005 # over CIFS/SMB, so we conserve a leading double slash if found.
1006 func_normal_abspath_altnamespace=/
1009 # Absolute path, do nothing.
1012 # Relative path, prepend $cwd.
1013 func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
1017 # Cancel out all the simple stuff to save iterations. We also want
1018 # the path to end with a slash for ease of parsing, so make sure
1019 # there is one (and only one) here.
1020 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
1021 -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
1023 # Processed it all yet?
1024 if test / = "$func_normal_abspath_tpath"; then
1025 # If we ascended to the root using ".." the result may be empty now.
1026 if test -z "$func_normal_abspath_result"; then
1027 func_normal_abspath_result=/
1031 func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
1033 func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
1035 # Figure out what to do with it
1036 case $func_normal_abspath_tcomponent in
1038 # Trailing empty path component, ignore it.
1041 # Parent dir; strip last assembled component from result.
1042 func_dirname "$func_normal_abspath_result"
1043 func_normal_abspath_result=$func_dirname_result
1046 # Actual path component, append it.
1047 func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
1051 # Restore leading double-slash if one was found on entry.
1052 func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
1056 # func_notquiet ARG...
1057 # --------------------
1058 # Echo program name prefixed message only when not in quiet mode.
1063 $opt_quiet || func_echo ${1+"$@"}
1065 # A bug in bash halts the script if the last line of a function
1066 # fails when set -e is in force, so we need another command to
1072 # func_relative_path SRCDIR DSTDIR
1073 # --------------------------------
1074 # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
1075 func_relative_path ()
1079 func_relative_path_result=
1080 func_normal_abspath "$1"
1081 func_relative_path_tlibdir=$func_normal_abspath_result
1082 func_normal_abspath "$2"
1083 func_relative_path_tbindir=$func_normal_abspath_result
1085 # Ascend the tree starting from libdir
1087 # check if we have found a prefix of bindir
1088 case $func_relative_path_tbindir in
1089 $func_relative_path_tlibdir)
1090 # found an exact match
1091 func_relative_path_tcancelled=
1094 $func_relative_path_tlibdir*)
1095 # found a matching prefix
1096 func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
1097 func_relative_path_tcancelled=$func_stripname_result
1098 if test -z "$func_relative_path_result"; then
1099 func_relative_path_result=.
1104 func_dirname $func_relative_path_tlibdir
1105 func_relative_path_tlibdir=$func_dirname_result
1106 if test -z "$func_relative_path_tlibdir"; then
1107 # Have to descend all the way to the root!
1108 func_relative_path_result=../$func_relative_path_result
1109 func_relative_path_tcancelled=$func_relative_path_tbindir
1112 func_relative_path_result=../$func_relative_path_result
1117 # Now calculate path; take care to avoid doubling-up slashes.
1118 func_stripname '' '/' "$func_relative_path_result"
1119 func_relative_path_result=$func_stripname_result
1120 func_stripname '/' '/' "$func_relative_path_tcancelled"
1121 if test -n "$func_stripname_result"; then
1122 func_append func_relative_path_result "/$func_stripname_result"
1125 # Normalisation. If bindir is libdir, return '.' else relative path.
1126 if test -n "$func_relative_path_result"; then
1127 func_stripname './' '' "$func_relative_path_result"
1128 func_relative_path_result=$func_stripname_result
1131 test -n "$func_relative_path_result" || func_relative_path_result=.
1137 # func_quote_portable EVAL ARG
1138 # ----------------------------
1139 # Internal function to portably implement func_quote_arg. Note that we still
1140 # keep attention to performance here so we as much as possible try to avoid
1141 # calling sed binary (so far O(N) complexity as long as func_append is O(1)).
1142 func_quote_portable ()
1146 $require_check_ifs_backslash
1148 func_quote_portable_result=$2
1150 # one-time-loop (easy break)
1154 func_quote_portable_result=`$ECHO "$2" | $SED \
1155 -e "$sed_double_quote_subst" -e "$sed_double_backslash"`
1160 case $func_quote_portable_result in
1162 # Fallback to sed for $func_check_bs_ifs_broken=:, or when the string
1163 # contains the shell wildcard characters.
1164 case $check_ifs_backshlash_broken$func_quote_portable_result in
1166 func_quote_portable_result=`$ECHO "$func_quote_portable_result" \
1167 | $SED "$sed_quote_subst"`
1172 func_quote_portable_old_IFS=$IFS
1173 for _G_char in '\' '`' '"' '$'
1175 # STATE($1) PREV($2) SEPARATOR($3)
1177 func_quote_portable_result=dummy"$_G_char$func_quote_portable_result$_G_char"dummy
1179 for _G_part in $func_quote_portable_result
1183 func_append func_quote_portable_result "$3$2"
1184 set quote "$_G_part" "\\$_G_char"
1188 func_quote_portable_result=
1191 set quote "$_G_part" ""
1196 IFS=$func_quote_portable_old_IFS
1203 func_quote_portable_unquoted_result=$func_quote_portable_result
1204 case $func_quote_portable_result in
1205 # double-quote args containing shell metacharacters to delay
1206 # word splitting, command substitution and variable expansion
1207 # for a subsequent eval.
1208 # many bourne shells cannot handle close brackets correctly
1209 # in scan sets, so we specify it separately.
1210 *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
1211 func_quote_portable_result=\"$func_quote_portable_result\"
1217 # func_quotefast_eval ARG
1218 # -----------------------
1219 # Quote one ARG (internal). This is equivalent to 'func_quote_arg eval ARG',
1220 # but optimized for speed. Result is stored in $func_quotefast_eval.
1221 if test xyes = `(x=; printf -v x %q yes; echo x"$x") 2>/dev/null`; then
1222 printf -v _GL_test_printf_tilde %q '~'
1223 if test '\~' = "$_GL_test_printf_tilde"; then
1224 func_quotefast_eval ()
1226 printf -v func_quotefast_eval_result %q "$1"
1229 # Broken older Bash implementations. Make those faster too if possible.
1230 func_quotefast_eval ()
1234 func_quote_portable false "$1"
1235 func_quotefast_eval_result=$func_quote_portable_result
1238 printf -v func_quotefast_eval_result %q "$1"
1244 func_quotefast_eval ()
1246 func_quote_portable false "$1"
1247 func_quotefast_eval_result=$func_quote_portable_result
1252 # func_quote_arg MODEs ARG
1253 # ------------------------
1254 # Quote one ARG to be evaled later. MODEs argument may contain zero or more
1255 # specifiers listed below separated by ',' character. This function returns two
1257 # i) func_quote_arg_result
1258 # double-quoted (when needed), suitable for a subsequent eval
1259 # ii) func_quote_arg_unquoted_result
1260 # has all characters that are still active within double
1261 # quotes backslashified. Available only if 'unquoted' is specified.
1266 # - escape shell special characters
1268 # - the same as 'eval'; but do not quote variable references
1270 # - request aesthetic output, i.e. '"a b"' instead of 'a\ b'. This might
1271 # be used later in func_quote to get output like: 'echo "a b"' instead
1272 # of 'echo a\ b'. This is slower than default on some shells.
1274 # - produce also $func_quote_arg_unquoted_result which does not contain
1275 # wrapping double-quotes.
1277 # Examples for 'func_quote_arg pretty,unquoted string':
1279 # string | *_result | *_unquoted_result
1280 # ------------+-----------------------+-------------------
1283 # "a b" | "\"a b\"" | \"a b\"
1285 # z="${x-$y}" | "z=\"\${x-\$y}\"" | z=\"\${x-\$y}\"
1287 # Examples for 'func_quote_arg pretty,unquoted,expand string':
1289 # string | *_result | *_unquoted_result
1290 # --------------+---------------------+--------------------
1291 # z="${x-$y}" | "z=\"${x-$y}\"" | z=\"${x-$y}\"
1294 _G_quote_expand=false
1302 *,pretty,*|*,expand,*|*,unquoted,*)
1303 func_quote_portable $_G_quote_expand "$2"
1304 func_quote_arg_result=$func_quote_portable_result
1305 func_quote_arg_unquoted_result=$func_quote_portable_unquoted_result
1308 # Faster quote-for-eval for some shells.
1309 func_quotefast_eval "$2"
1310 func_quote_arg_result=$func_quotefast_eval_result
1316 # func_quote MODEs ARGs...
1317 # ------------------------
1318 # Quote all ARGs to be evaled later and join them into single command. See
1319 # func_quote_arg's description for more info.
1323 _G_func_quote_mode=$1 ; shift
1325 while test 0 -lt $#; do
1326 func_quote_arg "$_G_func_quote_mode" "$1"
1327 if test -n "$func_quote_result"; then
1328 func_append func_quote_result " $func_quote_arg_result"
1330 func_append func_quote_result "$func_quote_arg_result"
1337 # func_stripname PREFIX SUFFIX NAME
1338 # ---------------------------------
1339 # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
1340 # PREFIX and SUFFIX must not contain globbing or regex special
1341 # characters, hashes, percent signs, but SUFFIX may contain a leading
1342 # dot (in which case that matches only a dot).
1343 if test yes = "$_G_HAVE_XSI_OPS"; then
1344 eval 'func_stripname ()
1348 # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
1349 # positional parameters, so assign one to ordinary variable first.
1350 func_stripname_result=$3
1351 func_stripname_result=${func_stripname_result#"$1"}
1352 func_stripname_result=${func_stripname_result%"$2"}
1360 .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
1361 *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
1367 # func_show_eval CMD [FAIL_EXP]
1368 # -----------------------------
1369 # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
1370 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
1371 # is given, then evaluate it.
1377 _G_fail_exp=${2-':'}
1379 func_quote_arg pretty,expand "$_G_cmd"
1380 eval "func_notquiet $func_quote_arg_result"
1385 if test 0 -ne "$_G_status"; then
1386 eval "(exit $_G_status); $_G_fail_exp"
1392 # func_show_eval_locale CMD [FAIL_EXP]
1393 # ------------------------------------
1394 # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is
1395 # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
1396 # is given, then evaluate it. Use the saved locale for evaluation.
1397 func_show_eval_locale ()
1402 _G_fail_exp=${2-':'}
1405 func_quote_arg expand,pretty "$_G_cmd"
1406 eval "func_echo $func_quote_arg_result"
1410 eval "$_G_user_locale
1413 eval "$_G_safe_locale"
1414 if test 0 -ne "$_G_status"; then
1415 eval "(exit $_G_status); $_G_fail_exp"
1423 # Turn $1 into a string suitable for a shell variable name.
1424 # Result is stored in $func_tr_sh_result. All characters
1425 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
1426 # if $1 begins with a digit, a '_' is prepended as well.
1432 [0-9]* | *[!a-zA-Z0-9_]*)
1433 func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
1436 func_tr_sh_result=$1
1442 # func_verbose ARG...
1443 # -------------------
1444 # Echo program name prefixed message in verbose mode only.
1449 $opt_verbose && func_echo "$*"
1455 # func_warn_and_continue ARG...
1456 # -----------------------------
1457 # Echo program name prefixed warning message to standard error.
1458 func_warn_and_continue ()
1462 $require_term_colors
1464 func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
1468 # func_warning CATEGORY ARG...
1469 # ----------------------------
1470 # Echo program name prefixed warning message to standard error. Warning
1471 # messages can be filtered according to CATEGORY, where this function
1472 # elides messages where CATEGORY is not listed in the global variable
1473 # 'opt_warning_types'.
1478 # CATEGORY must be in the warning_categories list!
1479 case " $warning_categories " in
1481 *) func_internal_error "invalid warning category '$1'" ;;
1487 case " $opt_warning_types " in
1488 *" $_G_category "*) $warning_func ${1+"$@"} ;;
1493 # func_sort_ver VER1 VER2
1494 # -----------------------
1495 # 'sort -V' is not generally available.
1496 # Note this deviates from the version comparison in automake
1497 # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
1498 # but this should suffice as we won't be specifying old
1499 # version formats or redundant trailing .0 in bootstrap.conf.
1500 # If we did want full compatibility then we should probably
1501 # use m4_version_compare from autoconf.
1506 printf '%s\n%s\n' "$1" "$2" \
1507 | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
1510 # func_lt_ver PREV CURR
1511 # ---------------------
1512 # Return true if PREV and CURR are in the correct order according to
1513 # func_sort_ver, otherwise false. Use it like this:
1515 # func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
1520 test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
1525 # mode: shell-script
1527 # eval: (add-hook 'before-save-hook 'time-stamp)
1528 # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
1529 # time-stamp-time-zone: "UTC"
1533 # A portable, pluggable option parser for Bourne shell.
1534 # Written by Gary V. Vaughan, 2010
1536 # This is free software. There is NO warranty; not even for
1537 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
1539 # Copyright (C) 2010-2019, 2021 Bootstrap Authors
1541 # This file is dual licensed under the terms of the MIT license
1542 # <https://opensource.org/license/MIT>, and GPL version 2 or later
1543 # <http://www.gnu.org/licenses/gpl-2.0.html>. You must apply one of
1544 # these licenses when using or redistributing this software or any of
1545 # the files within it. See the URLs above, or the file `LICENSE`
1546 # included in the Bootstrap distribution for the full license texts.
1548 # Please report bugs or propose patches to:
1549 # <https://github.com/gnulib-modules/bootstrap/issues>
1551 # Set a version string for this script.
1552 scriptversion=2019-02-19.15; # UTC
1559 # This file is a library for parsing options in your shell scripts along
1560 # with assorted other useful supporting features that you can make use
1563 # For the simplest scripts you might need only:
1566 # . relative/path/to/funclib.sh
1567 # . relative/path/to/options-parser
1569 # func_options ${1+"$@"}
1570 # eval set dummy "$func_options_result"; shift
1571 # ...rest of your script...
1573 # In order for the '--version' option to work, you will need to have a
1574 # suitably formatted comment like the one at the top of this file
1575 # starting with '# Written by ' and ending with '# Copyright'.
1577 # For '-h' and '--help' to work, you will also need a one line
1578 # description of your script's purpose in a comment directly above the
1579 # '# Written by ' line, like the one at the top of this file.
1581 # The default options also support '--debug', which will turn on shell
1582 # execution tracing (see the comment above debug_cmd below for another
1583 # use), and '--verbose' and the func_verbose function to allow your script
1584 # to display verbose messages only when your user has specified
1587 # After sourcing this file, you can plug in processing for additional
1588 # options by amending the variables from the 'Configuration' section
1589 # below, and following the instructions in the 'Option parsing'
1590 # section further down.
1592 ## -------------- ##
1593 ## Configuration. ##
1594 ## -------------- ##
1596 # You should override these variables in your script after sourcing this
1597 # file so that they reflect the customisations you have added to the
1600 # The usage line for option parsing errors and the start of '-h' and
1601 # '--help' output messages. You can embed shell variables for delayed
1602 # expansion at the time the message is displayed, but you will need to
1603 # quote other shell meta-characters carefully to prevent them being
1604 # expanded when the contents are evaled.
1605 usage='$progpath [OPTION]...'
1607 # Short help message in response to '-h' and '--help'. Add to this or
1608 # override it after sourcing this library to reflect the full set of
1609 # options your script accepts.
1611 --debug enable verbose shell tracing
1612 -W, --warnings=CATEGORY
1613 report the warnings falling in CATEGORY [all]
1614 -v, --verbose verbosely report processing
1615 --version print version information and exit
1616 -h, --help print short or long help message and exit
1619 # Additional text appended to 'usage_message' in response to '--help'.
1621 Warning categories include:
1622 'all' show all warnings
1623 'none' turn off all the warnings
1624 'error' warnings are treated as fatal errors"
1626 # Help message printed before fatal option parsing errors.
1627 fatal_help="Try '\$progname --help' for more information."
1631 ## ------------------------- ##
1632 ## Hook function management. ##
1633 ## ------------------------- ##
1635 # This section contains functions for adding, removing, and running hooks
1636 # in the main code. A hook is just a list of function names that can be
1637 # run in order later on.
1639 # func_hookable FUNC_NAME
1640 # -----------------------
1641 # Declare that FUNC_NAME will run hooks added with
1642 # 'func_add_hook FUNC_NAME ...'.
1647 func_append hookable_fns " $1"
1651 # func_add_hook FUNC_NAME HOOK_FUNC
1652 # ---------------------------------
1653 # Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must
1654 # first have been declared "hookable" by a call to 'func_hookable'.
1659 case " $hookable_fns " in
1661 *) func_fatal_error "'$1' does not accept hook functions." ;;
1664 eval func_append ${1}_hooks '" $2"'
1668 # func_remove_hook FUNC_NAME HOOK_FUNC
1669 # ------------------------------------
1670 # Remove HOOK_FUNC from the list of hook functions to be called by
1676 eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
1680 # func_propagate_result FUNC_NAME_A FUNC_NAME_B
1681 # ---------------------------------------------
1682 # If the *_result variable of FUNC_NAME_A _is set_, assign its value to
1683 # *_result variable of FUNC_NAME_B.
1684 func_propagate_result ()
1688 func_propagate_result_result=:
1689 if eval "test \"\${${1}_result+set}\" = set"
1691 eval "${2}_result=\$${1}_result"
1693 func_propagate_result_result=false
1698 # func_run_hooks FUNC_NAME [ARG]...
1699 # ---------------------------------
1700 # Run all hook functions registered to FUNC_NAME.
1701 # It's assumed that the list of hook functions contains nothing more
1702 # than a whitespace-delimited list of legal shell function names, and
1703 # no effort is wasted trying to catch shell meta-characters or preserve
1709 _G_rc_run_hooks=false
1711 case " $hookable_fns " in
1713 *) func_fatal_error "'$1' does not support hook functions." ;;
1716 eval _G_hook_fns=\$$1_hooks; shift
1718 for _G_hook in $_G_hook_fns; do
1719 func_unset "${_G_hook}_result"
1720 eval $_G_hook '${1+"$@"}'
1721 func_propagate_result $_G_hook func_run_hooks
1722 if $func_propagate_result_result; then
1723 eval set dummy "$func_run_hooks_result"; shift
1730 ## --------------- ##
1731 ## Option parsing. ##
1732 ## --------------- ##
1734 # In order to add your own option parsing hooks, you must accept the
1735 # full positional parameter list from your hook function. You may remove
1736 # or edit any options that you action, and then pass back the remaining
1737 # unprocessed options in '<hooked_function_name>_result', escaped
1738 # suitably for 'eval'.
1740 # The '<hooked_function_name>_result' variable is automatically unset
1741 # before your hook gets called; for best performance, only set the
1742 # *_result variable when necessary (i.e. don't call the 'func_quote'
1743 # function unnecessarily because it can be an expensive operation on some
1748 # my_options_prep ()
1752 # # Extend the existing usage message.
1753 # usage_message=$usage_message'
1754 # -s, --silent don'\''t print informational messages
1756 # # No change in '$@' (ignored completely by this hook). Leave
1757 # # my_options_prep_result variable intact.
1759 # func_add_hook func_options_prep my_options_prep
1762 # my_silent_option ()
1766 # args_changed=false
1768 # # Note that, for efficiency, we parse as many options as we can
1769 # # recognise in a loop before passing the remainder back to the
1770 # # caller on the first unrecognised argument we encounter.
1771 # while test $# -gt 0; do
1774 # --silent|-s) opt_silent=:
1777 # # Separate non-argument short options:
1778 # -s*) func_split_short_opt "$_G_opt"
1779 # set dummy "$func_split_short_opt_name" \
1780 # "-$func_split_short_opt_arg" ${1+"$@"}
1784 # *) # Make sure the first unrecognised option "$_G_opt"
1785 # # is added back to "$@" in case we need it later,
1786 # # if $args_changed was set to 'true'.
1787 # set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
1791 # # Only call 'func_quote' here if we processed at least one argument.
1792 # if $args_changed; then
1793 # func_quote eval ${1+"$@"}
1794 # my_silent_option_result=$func_quote_result
1797 # func_add_hook func_parse_options my_silent_option
1800 # my_option_validation ()
1804 # $opt_silent && $opt_verbose && func_fatal_help "\
1805 # '--silent' and '--verbose' options are mutually exclusive."
1807 # func_add_hook func_validate_options my_option_validation
1809 # You'll also need to manually amend $usage_message to reflect the extra
1810 # options you parse. It's preferable to append if you can, so that
1811 # multiple option parsing hooks can be added safely.
1814 # func_options_finish [ARG]...
1815 # ----------------------------
1816 # Finishing the option parse loop (call 'func_options' hooks ATM).
1817 func_options_finish ()
1821 func_run_hooks func_options ${1+"$@"}
1822 func_propagate_result func_run_hooks func_options_finish
1826 # func_options [ARG]...
1827 # ---------------------
1828 # All the functions called inside func_options are hookable. See the
1829 # individual implementations for details.
1830 func_hookable func_options
1835 _G_options_quoted=false
1837 for my_func in options_prep parse_options validate_options options_finish
1839 func_unset func_${my_func}_result
1840 func_unset func_run_hooks_result
1841 eval func_$my_func '${1+"$@"}'
1842 func_propagate_result func_$my_func func_options
1843 if $func_propagate_result_result; then
1844 eval set dummy "$func_options_result"; shift
1849 $_G_options_quoted || {
1850 # As we (func_options) are top-level options-parser function and
1851 # nobody quoted "$@" for us yet, we need to do it explicitly for
1853 func_quote eval ${1+"$@"}
1854 func_options_result=$func_quote_result
1859 # func_options_prep [ARG]...
1860 # --------------------------
1861 # All initialisations required before starting the option parse loop.
1862 # Note that when calling hook functions, we pass through the list of
1863 # positional parameters. If a hook function modifies that list, and
1864 # needs to propagate that back to rest of this script, then the complete
1865 # modified list must be put in 'func_run_hooks_result' before returning.
1866 func_hookable func_options_prep
1867 func_options_prep ()
1875 func_run_hooks func_options_prep ${1+"$@"}
1876 func_propagate_result func_run_hooks func_options_prep
1880 # func_parse_options [ARG]...
1881 # ---------------------------
1882 # The main option parsing loop.
1883 func_hookable func_parse_options
1884 func_parse_options ()
1888 _G_parse_options_requote=false
1889 # this just eases exit handling
1890 while test $# -gt 0; do
1891 # Defer to hook functions for initial option parsing, so they
1892 # get priority in the event of reusing an option name.
1893 func_run_hooks func_parse_options ${1+"$@"}
1894 func_propagate_result func_run_hooks func_parse_options
1895 if $func_propagate_result_result; then
1896 eval set dummy "$func_parse_options_result"; shift
1897 # Even though we may have changed "$@", we passed the "$@" array
1898 # down into the hook and it quoted it for us (because we are in
1899 # this if-branch). No need to quote it again.
1900 _G_parse_options_requote=false
1903 # Break out of the loop if we already parsed every option.
1904 test $# -gt 0 || break
1906 # We expect that one of the options parsed in this function matches
1907 # and thus we remove _G_opt from "$@" and need to re-quote.
1908 _G_match_parse_options=:
1912 --debug|-x) debug_cmd='set -x'
1913 func_echo "enabling shell trace mode" >&2
1917 --no-warnings|--no-warning|--no-warn)
1918 set dummy --warnings none ${1+"$@"}
1922 --warnings|--warning|-W)
1923 if test $# = 0 && func_missing_arg $_G_opt; then
1924 _G_parse_options_requote=:
1927 case " $warning_categories $1" in
1929 # trailing space prevents matching last $1 above
1930 func_append_uniq opt_warning_types " $1"
1933 opt_warning_types=$warning_categories
1936 opt_warning_types=none
1940 opt_warning_types=$warning_categories
1941 warning_func=func_fatal_error
1945 "unsupported warning category: '$1'"
1951 --verbose|-v) opt_verbose=: ;;
1952 --version) func_version ;;
1953 -\?|-h) func_usage ;;
1954 --help) func_help ;;
1956 # Separate optargs to long options (plugins may need this):
1957 --*=*) func_split_equals "$_G_opt"
1958 set dummy "$func_split_equals_lhs" \
1959 "$func_split_equals_rhs" ${1+"$@"}
1963 # Separate optargs to short options:
1965 func_split_short_opt "$_G_opt"
1966 set dummy "$func_split_short_opt_name" \
1967 "$func_split_short_opt_arg" ${1+"$@"}
1971 # Separate non-argument short options:
1973 func_split_short_opt "$_G_opt"
1974 set dummy "$func_split_short_opt_name" \
1975 "-$func_split_short_opt_arg" ${1+"$@"}
1979 --) _G_parse_options_requote=: ; break ;;
1980 -*) func_fatal_help "unrecognised option: '$_G_opt'" ;;
1981 *) set dummy "$_G_opt" ${1+"$@"}; shift
1982 _G_match_parse_options=false
1987 if $_G_match_parse_options; then
1988 _G_parse_options_requote=:
1992 if $_G_parse_options_requote; then
1993 # save modified positional parameters for caller
1994 func_quote eval ${1+"$@"}
1995 func_parse_options_result=$func_quote_result
2000 # func_validate_options [ARG]...
2001 # ------------------------------
2002 # Perform any sanity checks on option settings and/or unconsumed
2004 func_hookable func_validate_options
2005 func_validate_options ()
2009 # Display all warnings if -W was not given.
2010 test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
2012 func_run_hooks func_validate_options ${1+"$@"}
2013 func_propagate_result func_run_hooks func_validate_options
2015 # Bail if the options were screwed!
2016 $exit_cmd $EXIT_FAILURE
2021 ## ----------------- ##
2022 ## Helper functions. ##
2023 ## ----------------- ##
2025 # This section contains the helper functions used by the rest of the
2026 # hookable option parser framework in ascii-betical order.
2029 # func_fatal_help ARG...
2030 # ----------------------
2031 # Echo program name prefixed message to standard error, followed by
2032 # a help hint, and exit.
2037 eval \$ECHO \""Usage: $usage"\"
2038 eval \$ECHO \""$fatal_help"\"
2039 func_error ${1+"$@"}
2046 # Echo long help message to standard output and exit.
2052 $ECHO "$long_help_message"
2057 # func_missing_arg ARGNAME
2058 # ------------------------
2059 # Echo program name prefixed message to standard error and set global
2065 func_error "Missing argument for '$1'."
2070 # func_split_equals STRING
2071 # ------------------------
2072 # Set func_split_equals_lhs and func_split_equals_rhs shell variables
2073 # after splitting STRING at the '=' sign.
2074 test -z "$_G_HAVE_XSI_OPS" \
2076 test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
2077 && _G_HAVE_XSI_OPS=yes
2079 if test yes = "$_G_HAVE_XSI_OPS"
2081 # This is an XSI compatible shell, allowing a faster implementation...
2082 eval 'func_split_equals ()
2086 func_split_equals_lhs=${1%%=*}
2087 func_split_equals_rhs=${1#*=}
2088 if test "x$func_split_equals_lhs" = "x$1"; then
2089 func_split_equals_rhs=
2093 # ...otherwise fall back to using expr, which is often a shell builtin.
2094 func_split_equals ()
2098 func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
2099 func_split_equals_rhs=
2100 test "x$func_split_equals_lhs=" = "x$1" \
2101 || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
2103 fi #func_split_equals
2106 # func_split_short_opt SHORTOPT
2107 # -----------------------------
2108 # Set func_split_short_opt_name and func_split_short_opt_arg shell
2109 # variables after splitting SHORTOPT after the 2nd character.
2110 if test yes = "$_G_HAVE_XSI_OPS"
2112 # This is an XSI compatible shell, allowing a faster implementation...
2113 eval 'func_split_short_opt ()
2117 func_split_short_opt_arg=${1#??}
2118 func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
2121 # ...otherwise fall back to using expr, which is often a shell builtin.
2122 func_split_short_opt ()
2126 func_split_short_opt_name=`expr "x$1" : 'x\(-.\)'`
2127 func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
2129 fi #func_split_short_opt
2134 # Echo short help message to standard output and exit.
2140 $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
2145 # func_usage_message
2146 # ------------------
2147 # Echo short help message to standard output.
2148 func_usage_message ()
2152 eval \$ECHO \""Usage: $usage"\"
2159 /^Written by/q' < "$progpath"
2161 eval \$ECHO \""$usage_message"\"
2167 # Echo version message to standard output and exit.
2168 # The version message is extracted from the calling file's header
2169 # comments, with leading '# ' stripped:
2170 # 1. First display the progname and version
2171 # 2. Followed by the header comment line matching /^# Written by /
2172 # 3. Then a blank line followed by the first following line matching
2174 # 4. Immediately followed by any lines between the previous matches,
2175 # except lines preceding the intervening completely blank line.
2176 # For example, see the header comments of this file.
2181 printf '%s\n' "$progname $scriptversion"
2202 s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
2212 # mode: shell-script
2214 # eval: (add-hook 'before-save-hook 'time-stamp)
2215 # time-stamp-pattern: "30/scriptversion=%:y-%02m-%02d.%02H; # UTC"
2216 # time-stamp-time-zone: "UTC"
2219 # Set a version string.
2220 scriptversion='(GNU libtool) 2.4.7'
2225 # Libtool also displays the current mode in messages, so override
2226 # funclib.sh func_echo with this custom definition.
2235 for _G_line in $_G_message; do
2237 $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
2243 # func_warning ARG...
2244 # -------------------
2245 # Libtool warnings are not categorized, so override funclib.sh
2246 # func_warning with this simpler definition.
2251 $warning_func ${1+"$@"}
2255 ## ---------------- ##
2256 ## Options parsing. ##
2257 ## ---------------- ##
2259 # Hook in the functions to make sure our own options are parsed during
2260 # the option parsing loop.
2262 usage='$progpath [OPTION]... [MODE-ARG]...'
2264 # Short help message in response to '-h'.
2265 usage_message="Options:
2266 --config show all configuration variables
2267 --debug enable verbose shell tracing
2268 -n, --dry-run display commands without modifying any files
2269 --features display basic configuration information and exit
2270 --mode=MODE use operation mode MODE
2271 --no-warnings equivalent to '-Wnone'
2272 --preserve-dup-deps don't remove duplicate dependency libraries
2273 --quiet, --silent don't print informational messages
2274 --tag=TAG use configuration variables from tag TAG
2275 -v, --verbose print more informational messages than default
2276 --version print version information
2277 -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all]
2278 -h, --help, --help-all print short, long, or detailed help message
2281 # Additional text appended to 'usage_message' in response to '--help'.
2287 $ECHO "$long_help_message
2289 MODE must be one of the following:
2291 clean remove files from the build directory
2292 compile compile a source file into a libtool object
2293 execute automatically set library path, then run a program
2294 finish complete the installation of libtool libraries
2295 install install libraries or executables
2296 link create a library or an executable
2297 uninstall remove libraries from an installed directory
2299 MODE-ARGS vary depending on the MODE. When passed as first option,
2300 '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
2301 Try '$progname --help --mode=MODE' for a more detailed description of MODE.
2303 When reporting a bug, please describe a test case to reproduce it and
2304 include the following information:
2309 compiler flags: $LTCFLAGS
2310 linker: $LD (gnu? $with_gnu_ld)
2311 version: $progname $scriptversion Debian-2.4.7-4
2312 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
2313 autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q`
2315 Report bugs to <bug-libtool@gnu.org>.
2316 GNU libtool home page: <http://www.gnu.org/s/libtool/>.
2317 General help using GNU software: <http://www.gnu.org/gethelp/>."
2322 # func_lo2o OBJECT-NAME
2323 # ---------------------
2324 # Transform OBJECT-NAME from a '.lo' suffix to the platform specific
2327 lo2o=s/\\.lo\$/.$objext/
2328 o2lo=s/\\.$objext\$/.lo/
2330 if test yes = "$_G_HAVE_XSI_OPS"; then
2334 *.lo) func_lo2o_result=${1%.lo}.$objext ;;
2335 * ) func_lo2o_result=$1 ;;
2339 # func_xform LIBOBJ-OR-SOURCE
2340 # ---------------------------
2341 # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
2342 # suffix to a '.lo' libtool-object suffix.
2345 func_xform_result=${1%.*}.lo
2348 # ...otherwise fall back to using sed.
2351 func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
2356 func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
2361 # func_fatal_configuration ARG...
2362 # -------------------------------
2363 # Echo program name prefixed message to standard error, followed by
2364 # a configuration failure hint, and exit.
2365 func_fatal_configuration ()
2367 func_fatal_error ${1+"$@"} \
2368 "See the $PACKAGE documentation for more information." \
2369 "Fatal configuration error."
2375 # Display the configuration for all the tags in this script.
2378 re_begincf='^# ### BEGIN LIBTOOL'
2379 re_endcf='^# ### END LIBTOOL'
2381 # Default configuration.
2382 $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
2384 # Now print the configurations for the tags.
2385 for tagname in $taglist; do
2386 $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
2395 # Display the features supported by this script.
2399 if test yes = "$build_libtool_libs"; then
2400 echo "enable shared libraries"
2402 echo "disable shared libraries"
2404 if test yes = "$build_old_libs"; then
2405 echo "enable static libraries"
2407 echo "disable static libraries"
2414 # func_enable_tag TAGNAME
2415 # -----------------------
2416 # Verify that TAGNAME is valid, and either flag an error and exit, or
2417 # enable the TAGNAME tag. We also add TAGNAME to the global $taglist
2424 re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
2425 re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
2426 sed_extractcf=/$re_begincf/,/$re_endcf/p
2431 func_fatal_error "invalid tag name: $tagname"
2435 # Don't test for the "default" C tag, as we know it's
2436 # there but not specially marked.
2440 if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
2441 taglist="$taglist $tagname"
2443 # Evaluate the configuration. Be careful to quote the path
2444 # and the sed script, to avoid splitting on whitespace, but
2445 # also don't use non-portable quotes within backquotes within
2446 # quotes we have to do it in 2 steps:
2447 extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
2450 func_error "ignoring unknown tag $tagname"
2457 # func_check_version_match
2458 # ------------------------
2459 # Ensure that we are using m4 macros, and libtool script from the same
2460 # release of libtool.
2461 func_check_version_match ()
2463 if test "$package_revision" != "$macro_revision"; then
2464 if test "$VERSION" != "$macro_version"; then
2465 if test -z "$macro_version"; then
2467 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2468 $progname: definition of this LT_INIT comes from an older release.
2469 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2470 $progname: and run autoconf again.
2474 $progname: Version mismatch error. This is $PACKAGE $VERSION, but the
2475 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
2476 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
2477 $progname: and run autoconf again.
2482 $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
2483 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
2484 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
2485 $progname: of $PACKAGE $VERSION and run autoconf again.
2494 # libtool_options_prep [ARG]...
2495 # -----------------------------
2496 # Preparation for options parsed by libtool.
2497 libtool_options_prep ()
2507 opt_preserve_dup_deps=false
2513 _G_rc_lt_options_prep=:
2515 _G_rc_lt_options_prep=:
2517 # Shorthand for --mode=foo, only valid as the first argument
2520 shift; set dummy --mode clean ${1+"$@"}; shift
2522 compile|compil|compi|comp|com|co|c)
2523 shift; set dummy --mode compile ${1+"$@"}; shift
2525 execute|execut|execu|exec|exe|ex|e)
2526 shift; set dummy --mode execute ${1+"$@"}; shift
2528 finish|finis|fini|fin|fi|f)
2529 shift; set dummy --mode finish ${1+"$@"}; shift
2531 install|instal|insta|inst|ins|in|i)
2532 shift; set dummy --mode install ${1+"$@"}; shift
2535 shift; set dummy --mode link ${1+"$@"}; shift
2537 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
2538 shift; set dummy --mode uninstall ${1+"$@"}; shift
2541 _G_rc_lt_options_prep=false
2545 if $_G_rc_lt_options_prep; then
2546 # Pass back the list of options.
2547 func_quote eval ${1+"$@"}
2548 libtool_options_prep_result=$func_quote_result
2551 func_add_hook func_options_prep libtool_options_prep
2554 # libtool_parse_options [ARG]...
2555 # ---------------------------------
2556 # Provide handling for libtool specific options.
2557 libtool_parse_options ()
2561 _G_rc_lt_parse_options=false
2563 # Perform our own loop to consume as many options as possible in
2565 while test $# -gt 0; do
2566 _G_match_lt_parse_options=:
2570 --dry-run|--dryrun|-n)
2574 --config) func_config ;;
2577 opt_dlopen="${opt_dlopen+$opt_dlopen
2582 --preserve-dup-deps)
2583 opt_preserve_dup_deps=: ;;
2585 --features) func_features ;;
2587 --finish) set dummy --mode finish ${1+"$@"}; shift ;;
2589 --help) opt_help=: ;;
2591 --help-all) opt_help=': help-all' ;;
2593 --mode) test $# = 0 && func_missing_arg $_G_opt && break
2596 # Valid mode arguments:
2597 clean|compile|execute|finish|install|link|relink|uninstall) ;;
2599 # Catch anything else as an error
2600 *) func_error "invalid argument for $_G_opt"
2608 --no-silent|--no-quiet)
2610 func_append preserve_args " $_G_opt"
2613 --no-warnings|--no-warning|--no-warn)
2615 func_append preserve_args " $_G_opt"
2620 func_append preserve_args " $_G_opt"
2626 func_append preserve_args " $_G_opt"
2629 --tag) test $# = 0 && func_missing_arg $_G_opt && break
2631 func_append preserve_args " $_G_opt $1"
2632 func_enable_tag "$1"
2636 --verbose|-v) opt_quiet=false
2638 func_append preserve_args " $_G_opt"
2641 # An option not handled by this hook function:
2642 *) set dummy "$_G_opt" ${1+"$@"} ; shift
2643 _G_match_lt_parse_options=false
2647 $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
2650 if $_G_rc_lt_parse_options; then
2651 # save modified positional parameters for caller
2652 func_quote eval ${1+"$@"}
2653 libtool_parse_options_result=$func_quote_result
2656 func_add_hook func_parse_options libtool_parse_options
2660 # libtool_validate_options [ARG]...
2661 # ---------------------------------
2662 # Perform any sanity checks on option settings and/or unconsumed
2664 libtool_validate_options ()
2666 # save first non-option argument
2667 if test 0 -lt $#; then
2673 test : = "$debug_cmd" || func_append preserve_args " --debug"
2676 # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
2677 # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
2678 *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
2679 # don't eliminate duplications in $postdeps and $predeps
2680 opt_duplicate_compiler_generated_deps=:
2683 opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
2688 # Sanity checks first:
2689 func_check_version_match
2691 test yes != "$build_libtool_libs" \
2692 && test yes != "$build_old_libs" \
2693 && func_fatal_configuration "not configured to build any kind of library"
2696 eval std_shrext=\"$shrext_cmds\"
2698 # Only execute mode is allowed to have -dlopen flags.
2699 if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
2700 func_error "unrecognized option '-dlopen'"
2705 # Change the help message to a mode-specific one.
2707 help="Try '$progname --help --mode=$opt_mode' for more information."
2710 # Pass back the unparsed argument list
2711 func_quote eval ${1+"$@"}
2712 libtool_validate_options_result=$func_quote_result
2714 func_add_hook func_validate_options libtool_validate_options
2717 # Process options as early as possible so that --help and --version
2718 # can return quickly.
2719 func_options ${1+"$@"}
2720 eval set dummy "$func_options_result"; shift
2728 magic='%%%MAGIC variable%%%'
2729 magic_exe='%%%MAGIC EXE variable%%%'
2735 # If this variable is set in any of the actions, the command in it
2736 # will be execed at the end. This prevents here-documents from being
2737 # left over by shells.
2741 # A function that is used when there is no print builtin or printf.
2742 func_fallback_echo ()
2744 eval 'cat <<_LTECHO_EOF
2749 # func_generated_by_libtool
2750 # True iff stdin has been generated by Libtool. This function is only
2751 # a basic sanity check; it will hardly flush out determined imposters.
2752 func_generated_by_libtool_p ()
2754 $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
2758 # True iff FILE is a libtool '.la' library or '.lo' object file.
2759 # This function is only a basic sanity check; it will hardly flush out
2760 # determined imposters.
2764 $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
2767 # func_lalib_unsafe_p file
2768 # True iff FILE is a libtool '.la' library or '.lo' object file.
2769 # This function implements the same check as func_lalib_p without
2770 # resorting to external programs. To this end, it redirects stdin and
2771 # closes it afterwards, without saving the original file descriptor.
2772 # As a safety measure, use it only where a negative result would be
2773 # fatal anyway. Works if 'file' does not exist.
2774 func_lalib_unsafe_p ()
2777 if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
2778 for lalib_p_l in 1 2 3 4
2781 case $lalib_p_line in
2782 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
2787 test yes = "$lalib_p"
2790 # func_ltwrapper_script_p file
2791 # True iff FILE is a libtool wrapper script
2792 # This function is only a basic sanity check; it will hardly flush out
2793 # determined imposters.
2794 func_ltwrapper_script_p ()
2797 $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
2800 # func_ltwrapper_executable_p file
2801 # True iff FILE is a libtool wrapper executable
2802 # This function is only a basic sanity check; it will hardly flush out
2803 # determined imposters.
2804 func_ltwrapper_executable_p ()
2806 func_ltwrapper_exec_suffix=
2809 *) func_ltwrapper_exec_suffix=.exe ;;
2811 $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
2814 # func_ltwrapper_scriptname file
2815 # Assumes file is an ltwrapper_executable
2816 # uses $file to determine the appropriate filename for a
2817 # temporary ltwrapper_script.
2818 func_ltwrapper_scriptname ()
2820 func_dirname_and_basename "$1" "" "."
2821 func_stripname '' '.exe' "$func_basename_result"
2822 func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
2825 # func_ltwrapper_p file
2826 # True iff FILE is a libtool wrapper script or wrapper executable
2827 # This function is only a basic sanity check; it will hardly flush out
2828 # determined imposters.
2831 func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
2835 # func_execute_cmds commands fail_cmd
2836 # Execute tilde-delimited COMMANDS.
2837 # If FAIL_CMD is given, eval that upon failure.
2838 # FAIL_CMD may read-access the current command in variable CMD!
2839 func_execute_cmds ()
2843 save_ifs=$IFS; IFS='~'
2848 func_show_eval "$cmd" "${2-:}"
2855 # Source FILE, adding directory component if necessary.
2856 # Note that it is not necessary on cygwin/mingw to append a dot to
2857 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
2858 # behavior happens only for exec(3), not for open(2)! Also, sourcing
2859 # 'FILE.' does not work on cygwin managed mounts.
2865 */* | *\\*) . "$1" ;;
2871 # func_resolve_sysroot PATH
2872 # Replace a leading = in PATH with a sysroot. Store the result into
2873 # func_resolve_sysroot_result
2874 func_resolve_sysroot ()
2876 func_resolve_sysroot_result=$1
2877 case $func_resolve_sysroot_result in
2879 func_stripname '=' '' "$func_resolve_sysroot_result"
2880 func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
2885 # func_replace_sysroot PATH
2886 # If PATH begins with the sysroot, replace it with = and
2887 # store the result into func_replace_sysroot_result.
2888 func_replace_sysroot ()
2890 case $lt_sysroot:$1 in
2892 func_stripname "$lt_sysroot" '' "$1"
2893 func_replace_sysroot_result='='$func_stripname_result
2896 # Including no sysroot.
2897 func_replace_sysroot_result=$1
2902 # func_infer_tag arg
2903 # Infer tagged configuration to use if any are available and
2904 # if one wasn't chosen via the "--tag" command line option.
2905 # Only attempt this if the compiler in the base compile
2906 # command doesn't match the default compiler.
2907 # arg is usually of the form 'gcc ...'
2912 if test -n "$available_tags" && test -z "$tagname"; then
2915 func_append_quoted CC_quoted "$arg"
2917 CC_expanded=`func_echo_all $CC`
2918 CC_quoted_expanded=`func_echo_all $CC_quoted`
2920 # Blanks in the command may have been stripped by the calling shell,
2921 # but not from the CC environment variable when configure was run.
2922 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2923 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
2924 # Blanks at the start of $base_compile will cause this to fail
2925 # if we don't check for them as well.
2927 for z in $available_tags; do
2928 if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
2929 # Evaluate the configuration.
2930 eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
2933 # Double-quote args containing other shell metacharacters.
2934 func_append_quoted CC_quoted "$arg"
2936 CC_expanded=`func_echo_all $CC`
2937 CC_quoted_expanded=`func_echo_all $CC_quoted`
2939 " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
2940 " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
2941 # The compiler in the base compile command matches
2942 # the one in the tagged configuration.
2943 # Assume this is the tagged configuration we want.
2950 # If $tagname still isn't set, then no tagged configuration
2951 # was found and let the user know that the "--tag" command
2952 # line option must be used.
2953 if test -z "$tagname"; then
2954 func_echo "unable to infer tagged configuration"
2955 func_fatal_error "specify a tag with '--tag'"
2957 # func_verbose "using $tagname tagged configuration"
2966 # func_write_libtool_object output_name pic_name nonpic_name
2967 # Create a libtool object file (analogous to a ".la" file),
2968 # but don't create it if we're doing a dry run.
2969 func_write_libtool_object ()
2972 if test yes = "$build_libtool_libs"; then
2978 if test yes = "$build_old_libs"; then
2985 cat >${write_libobj}T <<EOF
2986 # $write_libobj - a libtool object file
2987 # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
2989 # Please DO NOT delete this file!
2990 # It is necessary for linking the library.
2992 # Name of the PIC object.
2993 pic_object=$write_lobj
2995 # Name of the non-PIC object
2996 non_pic_object=$write_oldobj
2999 $MV "${write_libobj}T" "$write_libobj"
3004 ##################################################
3005 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
3006 ##################################################
3008 # func_convert_core_file_wine_to_w32 ARG
3009 # Helper function used by file name conversion functions when $build is *nix,
3010 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
3011 # correctly configured wine environment available, with the winepath program
3012 # in $build's $PATH.
3014 # ARG is the $build file name to be converted to w32 format.
3015 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
3016 # be empty on error (or when ARG is empty)
3017 func_convert_core_file_wine_to_w32 ()
3021 func_convert_core_file_wine_to_w32_result=$1
3022 if test -n "$1"; then
3023 # Unfortunately, winepath does not exit with a non-zero error code, so we
3024 # are forced to check the contents of stdout. On the other hand, if the
3025 # command is not found, the shell will set an exit code of 127 and print
3026 # *an error message* to stdout. So we must check for both error code of
3027 # zero AND non-empty stdout, which explains the odd construction:
3028 func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
3029 if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
3030 func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
3031 $SED -e "$sed_naive_backslashify"`
3033 func_convert_core_file_wine_to_w32_result=
3037 # end: func_convert_core_file_wine_to_w32
3040 # func_convert_core_path_wine_to_w32 ARG
3041 # Helper function used by path conversion functions when $build is *nix, and
3042 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
3043 # configured wine environment available, with the winepath program in $build's
3044 # $PATH. Assumes ARG has no leading or trailing path separator characters.
3046 # ARG is path to be converted from $build format to win32.
3047 # Result is available in $func_convert_core_path_wine_to_w32_result.
3048 # Unconvertible file (directory) names in ARG are skipped; if no directory names
3049 # are convertible, then the result may be empty.
3050 func_convert_core_path_wine_to_w32 ()
3054 # unfortunately, winepath doesn't convert paths, only file names
3055 func_convert_core_path_wine_to_w32_result=
3056 if test -n "$1"; then
3059 for func_convert_core_path_wine_to_w32_f in $1; do
3061 func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
3062 if test -n "$func_convert_core_file_wine_to_w32_result"; then
3063 if test -z "$func_convert_core_path_wine_to_w32_result"; then
3064 func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
3066 func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
3073 # end: func_convert_core_path_wine_to_w32
3076 # func_cygpath ARGS...
3077 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
3078 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
3079 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
3080 # (2), returns the Cygwin file name or path in func_cygpath_result (input
3081 # file name or path is assumed to be in w32 format, as previously converted
3082 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
3083 # or path in func_cygpath_result (input file name or path is assumed to be in
3084 # Cygwin format). Returns an empty string on error.
3086 # ARGS are passed to cygpath, with the last one being the file name or path to
3089 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
3090 # environment variable; do not put it in $PATH.
3095 if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
3096 func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
3097 if test "$?" -ne 0; then
3098 # on failure, ensure result is empty
3099 func_cygpath_result=
3102 func_cygpath_result=
3103 func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
3109 # func_convert_core_msys_to_w32 ARG
3110 # Convert file name or path ARG from MSYS format to w32 format. Return
3111 # result in func_convert_core_msys_to_w32_result.
3112 func_convert_core_msys_to_w32 ()
3116 # awkward: cmd appends spaces to result
3117 func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
3118 $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
3120 #end: func_convert_core_msys_to_w32
3123 # func_convert_file_check ARG1 ARG2
3124 # Verify that ARG1 (a file name in $build format) was converted to $host
3125 # format in ARG2. Otherwise, emit an error message, but continue (resetting
3126 # func_to_host_file_result to ARG1).
3127 func_convert_file_check ()
3131 if test -z "$2" && test -n "$1"; then
3132 func_error "Could not determine host file name corresponding to"
3134 func_error "Continuing, but uninstalled executables may not work."
3136 func_to_host_file_result=$1
3139 # end func_convert_file_check
3142 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
3143 # Verify that FROM_PATH (a path in $build format) was converted to $host
3144 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
3145 # func_to_host_file_result to a simplistic fallback value (see below).
3146 func_convert_path_check ()
3150 if test -z "$4" && test -n "$3"; then
3151 func_error "Could not determine the host path corresponding to"
3153 func_error "Continuing, but uninstalled executables may not work."
3154 # Fallback. This is a deliberately simplistic "conversion" and
3155 # should not be "improved". See libtool.info.
3156 if test "x$1" != "x$2"; then
3157 lt_replace_pathsep_chars="s|$1|$2|g"
3158 func_to_host_path_result=`echo "$3" |
3159 $SED -e "$lt_replace_pathsep_chars"`
3161 func_to_host_path_result=$3
3165 # end func_convert_path_check
3168 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
3169 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
3170 # and appending REPL if ORIG matches BACKPAT.
3171 func_convert_path_front_back_pathsep ()
3176 $1 ) func_to_host_path_result=$3$func_to_host_path_result
3180 $2 ) func_append func_to_host_path_result "$3"
3184 # end func_convert_path_front_back_pathsep
3187 ##################################################
3188 # $build to $host FILE NAME CONVERSION FUNCTIONS #
3189 ##################################################
3190 # invoked via '$to_host_file_cmd ARG'
3192 # In each case, ARG is the path to be converted from $build to $host format.
3193 # Result will be available in $func_to_host_file_result.
3196 # func_to_host_file ARG
3197 # Converts the file name ARG from $build format to $host format. Return result
3198 # in func_to_host_file_result.
3199 func_to_host_file ()
3203 $to_host_file_cmd "$1"
3205 # end func_to_host_file
3208 # func_to_tool_file ARG LAZY
3209 # converts the file name ARG from $build format to toolchain format. Return
3210 # result in func_to_tool_file_result. If the conversion in use is listed
3211 # in (the comma separated) LAZY, no conversion takes place.
3212 func_to_tool_file ()
3217 *,"$to_tool_file_cmd",*)
3218 func_to_tool_file_result=$1
3221 $to_tool_file_cmd "$1"
3222 func_to_tool_file_result=$func_to_host_file_result
3226 # end func_to_tool_file
3229 # func_convert_file_noop ARG
3230 # Copy ARG to func_to_host_file_result.
3231 func_convert_file_noop ()
3233 func_to_host_file_result=$1
3235 # end func_convert_file_noop
3238 # func_convert_file_msys_to_w32 ARG
3239 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
3240 # conversion to w32 is not available inside the cwrapper. Returns result in
3241 # func_to_host_file_result.
3242 func_convert_file_msys_to_w32 ()
3246 func_to_host_file_result=$1
3247 if test -n "$1"; then
3248 func_convert_core_msys_to_w32 "$1"
3249 func_to_host_file_result=$func_convert_core_msys_to_w32_result
3251 func_convert_file_check "$1" "$func_to_host_file_result"
3253 # end func_convert_file_msys_to_w32
3256 # func_convert_file_cygwin_to_w32 ARG
3257 # Convert file name ARG from Cygwin to w32 format. Returns result in
3258 # func_to_host_file_result.
3259 func_convert_file_cygwin_to_w32 ()
3263 func_to_host_file_result=$1
3264 if test -n "$1"; then
3265 # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
3266 # LT_CYGPATH in this case.
3267 func_to_host_file_result=`cygpath -m "$1"`
3269 func_convert_file_check "$1" "$func_to_host_file_result"
3271 # end func_convert_file_cygwin_to_w32
3274 # func_convert_file_nix_to_w32 ARG
3275 # Convert file name ARG from *nix to w32 format. Requires a wine environment
3276 # and a working winepath. Returns result in func_to_host_file_result.
3277 func_convert_file_nix_to_w32 ()
3281 func_to_host_file_result=$1
3282 if test -n "$1"; then
3283 func_convert_core_file_wine_to_w32 "$1"
3284 func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
3286 func_convert_file_check "$1" "$func_to_host_file_result"
3288 # end func_convert_file_nix_to_w32
3291 # func_convert_file_msys_to_cygwin ARG
3292 # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3293 # Returns result in func_to_host_file_result.
3294 func_convert_file_msys_to_cygwin ()
3298 func_to_host_file_result=$1
3299 if test -n "$1"; then
3300 func_convert_core_msys_to_w32 "$1"
3301 func_cygpath -u "$func_convert_core_msys_to_w32_result"
3302 func_to_host_file_result=$func_cygpath_result
3304 func_convert_file_check "$1" "$func_to_host_file_result"
3306 # end func_convert_file_msys_to_cygwin
3309 # func_convert_file_nix_to_cygwin ARG
3310 # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
3311 # in a wine environment, working winepath, and LT_CYGPATH set. Returns result
3312 # in func_to_host_file_result.
3313 func_convert_file_nix_to_cygwin ()
3317 func_to_host_file_result=$1
3318 if test -n "$1"; then
3319 # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
3320 func_convert_core_file_wine_to_w32 "$1"
3321 func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
3322 func_to_host_file_result=$func_cygpath_result
3324 func_convert_file_check "$1" "$func_to_host_file_result"
3326 # end func_convert_file_nix_to_cygwin
3329 #############################################
3330 # $build to $host PATH CONVERSION FUNCTIONS #
3331 #############################################
3332 # invoked via '$to_host_path_cmd ARG'
3334 # In each case, ARG is the path to be converted from $build to $host format.
3335 # The result will be available in $func_to_host_path_result.
3337 # Path separators are also converted from $build format to $host format. If
3338 # ARG begins or ends with a path separator character, it is preserved (but
3339 # converted to $host format) on output.
3341 # All path conversion functions are named using the following convention:
3342 # file name conversion function : func_convert_file_X_to_Y ()
3343 # path conversion function : func_convert_path_X_to_Y ()
3344 # where, for any given $build/$host combination the 'X_to_Y' value is the
3345 # same. If conversion functions are added for new $build/$host combinations,
3346 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
3350 # func_init_to_host_path_cmd
3351 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
3352 # appropriate value, based on the value of $to_host_file_cmd.
3354 func_init_to_host_path_cmd ()
3358 if test -z "$to_host_path_cmd"; then
3359 func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
3360 to_host_path_cmd=func_convert_path_$func_stripname_result
3365 # func_to_host_path ARG
3366 # Converts the path ARG from $build format to $host format. Return result
3367 # in func_to_host_path_result.
3368 func_to_host_path ()
3372 func_init_to_host_path_cmd
3373 $to_host_path_cmd "$1"
3375 # end func_to_host_path
3378 # func_convert_path_noop ARG
3379 # Copy ARG to func_to_host_path_result.
3380 func_convert_path_noop ()
3382 func_to_host_path_result=$1
3384 # end func_convert_path_noop
3387 # func_convert_path_msys_to_w32 ARG
3388 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
3389 # conversion to w32 is not available inside the cwrapper. Returns result in
3390 # func_to_host_path_result.
3391 func_convert_path_msys_to_w32 ()
3395 func_to_host_path_result=$1
3396 if test -n "$1"; then
3397 # Remove leading and trailing path separator characters from ARG. MSYS
3398 # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
3399 # and winepath ignores them completely.
3400 func_stripname : : "$1"
3401 func_to_host_path_tmp1=$func_stripname_result
3402 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3403 func_to_host_path_result=$func_convert_core_msys_to_w32_result
3404 func_convert_path_check : ";" \
3405 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3406 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3409 # end func_convert_path_msys_to_w32
3412 # func_convert_path_cygwin_to_w32 ARG
3413 # Convert path ARG from Cygwin to w32 format. Returns result in
3414 # func_to_host_file_result.
3415 func_convert_path_cygwin_to_w32 ()
3419 func_to_host_path_result=$1
3420 if test -n "$1"; then
3421 # See func_convert_path_msys_to_w32:
3422 func_stripname : : "$1"
3423 func_to_host_path_tmp1=$func_stripname_result
3424 func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
3425 func_convert_path_check : ";" \
3426 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3427 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3430 # end func_convert_path_cygwin_to_w32
3433 # func_convert_path_nix_to_w32 ARG
3434 # Convert path ARG from *nix to w32 format. Requires a wine environment and
3435 # a working winepath. Returns result in func_to_host_file_result.
3436 func_convert_path_nix_to_w32 ()
3440 func_to_host_path_result=$1
3441 if test -n "$1"; then
3442 # See func_convert_path_msys_to_w32:
3443 func_stripname : : "$1"
3444 func_to_host_path_tmp1=$func_stripname_result
3445 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3446 func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
3447 func_convert_path_check : ";" \
3448 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3449 func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
3452 # end func_convert_path_nix_to_w32
3455 # func_convert_path_msys_to_cygwin ARG
3456 # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
3457 # Returns result in func_to_host_file_result.
3458 func_convert_path_msys_to_cygwin ()
3462 func_to_host_path_result=$1
3463 if test -n "$1"; then
3464 # See func_convert_path_msys_to_w32:
3465 func_stripname : : "$1"
3466 func_to_host_path_tmp1=$func_stripname_result
3467 func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
3468 func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
3469 func_to_host_path_result=$func_cygpath_result
3470 func_convert_path_check : : \
3471 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3472 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3475 # end func_convert_path_msys_to_cygwin
3478 # func_convert_path_nix_to_cygwin ARG
3479 # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
3480 # a wine environment, working winepath, and LT_CYGPATH set. Returns result in
3481 # func_to_host_file_result.
3482 func_convert_path_nix_to_cygwin ()
3486 func_to_host_path_result=$1
3487 if test -n "$1"; then
3488 # Remove leading and trailing path separator characters from
3489 # ARG. msys behavior is inconsistent here, cygpath turns them
3490 # into '.;' and ';.', and winepath ignores them completely.
3491 func_stripname : : "$1"
3492 func_to_host_path_tmp1=$func_stripname_result
3493 func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
3494 func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
3495 func_to_host_path_result=$func_cygpath_result
3496 func_convert_path_check : : \
3497 "$func_to_host_path_tmp1" "$func_to_host_path_result"
3498 func_convert_path_front_back_pathsep ":*" "*:" : "$1"
3501 # end func_convert_path_nix_to_cygwin
3504 # func_dll_def_p FILE
3505 # True iff FILE is a Windows DLL '.def' file.
3506 # Keep in sync with _LT_DLL_DEF_P in libtool.m4
3511 func_dll_def_p_tmp=`$SED -n \
3513 -e '/^\(;.*\)*$/d' \
3514 -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \
3517 test DEF = "$func_dll_def_p_tmp"
3521 # func_mode_compile arg...
3522 func_mode_compile ()
3526 # Get the compilation command and the source file.
3528 srcfile=$nonopt # always keep a non-empty value in "srcfile"
3540 # do not "continue". Instead, add this to base_compile
3552 # Accept any command-line options.
3555 test -n "$libobj" && \
3556 func_fatal_error "you cannot specify '-o' more than once"
3561 -pie | -fpie | -fPIE)
3562 func_append pie_flag " $arg"
3566 -shared | -static | -prefer-pic | -prefer-non-pic)
3567 func_append later " $arg"
3577 arg_mode=arg # the next one goes into the "base_compile" arg list
3578 continue # The current "srcfile" will either be retained or
3579 ;; # replaced later. I would guess that would be a bug.
3582 func_stripname '-Wc,' '' "$arg"
3583 args=$func_stripname_result
3585 save_ifs=$IFS; IFS=,
3586 for arg in $args; do
3588 func_append_quoted lastarg "$arg"
3591 func_stripname ' ' '' "$lastarg"
3592 lastarg=$func_stripname_result
3594 # Add the arguments to base_compile.
3595 func_append base_compile " $lastarg"
3600 # Accept the current argument as the source file.
3601 # The previous "srcfile" becomes the current argument.
3608 esac # case $arg_mode
3610 # Aesthetically quote the previous argument.
3611 func_append_quoted base_compile "$lastarg"
3616 func_fatal_error "you must specify an argument for -Xcompile"
3619 func_fatal_error "you must specify a target with '-o'"
3622 # Get the name of the library object.
3623 test -z "$libobj" && {
3624 func_basename "$srcfile"
3625 libobj=$func_basename_result
3630 # Recognize several different file suffixes.
3631 # If the user specifies -o file.o, it is replaced with file.lo
3634 *.ada | *.adb | *.ads | *.asm | \
3635 *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
3636 *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
3637 func_xform "$libobj"
3638 libobj=$func_xform_result
3643 *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
3645 func_fatal_error "cannot determine name of library object from '$libobj'"
3649 func_infer_tag $base_compile
3651 for arg in $later; do
3654 test yes = "$build_libtool_libs" \
3655 || func_fatal_configuration "cannot build a shared library"
3661 build_libtool_libs=no
3678 func_quote_arg pretty "$libobj"
3679 test "X$libobj" != "X$func_quote_arg_result" \
3680 && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
3681 && func_warning "libobj name '$libobj' may not contain shell special characters."
3682 func_dirname_and_basename "$obj" "/" ""
3683 objname=$func_basename_result
3684 xdir=$func_dirname_result
3685 lobj=$xdir$objdir/$objname
3687 test -z "$base_compile" && \
3688 func_fatal_help "you must specify a compilation command"
3690 # Delete any leftover library objects.
3691 if test yes = "$build_old_libs"; then
3692 removelist="$obj $lobj $libobj ${libobj}T"
3694 removelist="$lobj $libobj ${libobj}T"
3697 # On Cygwin there's no "real" PIC flag so we must build both object types
3699 cygwin* | mingw* | pw32* | os2* | cegcc*)
3703 if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
3704 # non-PIC code in shared libraries is not supported
3708 # Calculate the filename of the output object if compiler does
3709 # not support -o with -c
3710 if test no = "$compiler_c_o"; then
3711 output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
3712 lockfile=$output_obj.lock
3719 # Lock this critical section if it is needed
3720 # We use this script file to make the link, it avoids creating a new file
3721 if test yes = "$need_locks"; then
3722 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
3723 func_echo "Waiting for $lockfile to be removed"
3726 elif test warn = "$need_locks"; then
3727 if test -f "$lockfile"; then
3729 *** ERROR, $lockfile exists and contains:
3730 `cat $lockfile 2>/dev/null`
3732 This indicates that another process is trying to use the same
3733 temporary object file, and libtool could not work around it because
3734 your compiler does not support '-c' and '-o' together. If you
3735 repeat this compilation, it may succeed, by chance, but you had better
3736 avoid parallel builds (make -j) in this platform, or get a better
3739 $opt_dry_run || $RM $removelist
3742 func_append removelist " $output_obj"
3743 $ECHO "$srcfile" > "$lockfile"
3746 $opt_dry_run || $RM $removelist
3747 func_append removelist " $lockfile"
3748 trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
3750 func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
3751 srcfile=$func_to_tool_file_result
3752 func_quote_arg pretty "$srcfile"
3753 qsrcfile=$func_quote_arg_result
3755 # Only build a PIC object if we are building libtool libraries.
3756 if test yes = "$build_libtool_libs"; then
3757 # Without this assignment, base_compile gets emptied.
3758 fbsd_hideous_sh_bug=$base_compile
3760 if test no != "$pic_mode"; then
3761 command="$base_compile $qsrcfile $pic_flag"
3763 # Don't build PIC code
3764 command="$base_compile $qsrcfile"
3767 func_mkdir_p "$xdir$objdir"
3769 if test -z "$output_obj"; then
3770 # Place PIC objects in $objdir
3771 func_append command " -o $lobj"
3774 func_show_eval_locale "$command" \
3775 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
3777 if test warn = "$need_locks" &&
3778 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3780 *** ERROR, $lockfile contains:
3781 `cat $lockfile 2>/dev/null`
3783 but it should contain:
3786 This indicates that another process is trying to use the same
3787 temporary object file, and libtool could not work around it because
3788 your compiler does not support '-c' and '-o' together. If you
3789 repeat this compilation, it may succeed, by chance, but you had better
3790 avoid parallel builds (make -j) in this platform, or get a better
3793 $opt_dry_run || $RM $removelist
3797 # Just move the object if needed, then go on to compile the next one
3798 if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
3799 func_show_eval '$MV "$output_obj" "$lobj"' \
3800 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3803 # Allow error messages only from the first compilation.
3804 if test yes = "$suppress_opt"; then
3805 suppress_output=' >/dev/null 2>&1'
3809 # Only build a position-dependent object if we build old libraries.
3810 if test yes = "$build_old_libs"; then
3811 if test yes != "$pic_mode"; then
3812 # Don't build PIC code
3813 command="$base_compile $qsrcfile$pie_flag"
3815 command="$base_compile $qsrcfile $pic_flag"
3817 if test yes = "$compiler_c_o"; then
3818 func_append command " -o $obj"
3821 # Suppress compiler output if we already did a PIC compilation.
3822 func_append command "$suppress_output"
3823 func_show_eval_locale "$command" \
3824 '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
3826 if test warn = "$need_locks" &&
3827 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
3829 *** ERROR, $lockfile contains:
3830 `cat $lockfile 2>/dev/null`
3832 but it should contain:
3835 This indicates that another process is trying to use the same
3836 temporary object file, and libtool could not work around it because
3837 your compiler does not support '-c' and '-o' together. If you
3838 repeat this compilation, it may succeed, by chance, but you had better
3839 avoid parallel builds (make -j) in this platform, or get a better
3842 $opt_dry_run || $RM $removelist
3846 # Just move the object if needed
3847 if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
3848 func_show_eval '$MV "$output_obj" "$obj"' \
3849 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
3854 func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
3856 # Unlock the critical section if it was locked
3857 if test no != "$need_locks"; then
3858 removelist=$lockfile
3867 test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
3872 # We need to display help for each of the modes.
3875 # Generic help is extracted from the usage comments
3876 # at the start of this file.
3882 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
3884 Remove files from the build directory.
3886 RM is the name of the program to use to delete files associated with each FILE
3887 (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
3890 If FILE is a libtool library, object or program, all the files associated
3891 with it are deleted. Otherwise, only FILE itself is deleted using RM."
3896 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
3898 Compile a source file into a libtool library object.
3900 This mode accepts the following additional options:
3902 -o OUTPUT-FILE set the output file name to OUTPUT-FILE
3903 -no-suppress do not suppress compiler output for multiple passes
3904 -prefer-pic try to build PIC objects only
3905 -prefer-non-pic try to build non-PIC objects only
3906 -shared do not build a '.o' file suitable for static linking
3907 -static only build a '.o' file suitable for static linking
3909 -Xcompiler FLAG pass FLAG directly to the compiler
3911 COMPILE-COMMAND is a command to be used in creating a 'standard' object file
3912 from the given SOURCEFILE.
3914 The output file name is determined by removing the directory component from
3915 SOURCEFILE, then substituting the C source code suffix '.c' with the
3916 library object suffix, '.lo'."
3921 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
3923 Automatically set library path, then run a program.
3925 This mode accepts the following additional options:
3927 -dlopen FILE add the directory containing FILE to the library path
3929 This mode sets the library path environment variable according to '-dlopen'
3932 If any of the ARGS are libtool executable wrappers, then they are translated
3933 into their corresponding uninstalled binary, and any of their required library
3934 directories are added to the library path.
3936 Then, COMMAND is executed, with ARGS as arguments."
3941 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
3943 Complete the installation of libtool libraries.
3945 Each LIBDIR is a directory that contains libtool libraries.
3947 The commands that this mode executes may require superuser privileges. Use
3948 the '--dry-run' option if you just want to see what would be executed."
3953 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
3955 Install executables or libraries.
3957 INSTALL-COMMAND is the installation command. The first component should be
3958 either the 'install' or 'cp' program.
3960 The following components of INSTALL-COMMAND are treated specially:
3962 -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
3964 The rest of the components are interpreted as arguments to that command (only
3965 BSD-compatible install options are recognized)."
3970 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
3972 Link object files or libraries together to form another library, or to
3973 create an executable program.
3975 LINK-COMMAND is a command using the C compiler that you would use to create
3976 a program from several object files.
3978 The following components of LINK-COMMAND are treated specially:
3980 -all-static do not do any dynamic linking at all
3981 -avoid-version do not add a version suffix if possible
3982 -bindir BINDIR specify path to binaries directory (for systems where
3983 libraries must be found in the PATH setting at runtime)
3984 -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime
3985 -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
3986 -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
3987 -export-symbols SYMFILE
3988 try to export only the symbols listed in SYMFILE
3989 -export-symbols-regex REGEX
3990 try to export only the symbols matching REGEX
3991 -LLIBDIR search LIBDIR for required installed libraries
3992 -lNAME OUTPUT-FILE requires the installed library libNAME
3993 -module build a library that can dlopened
3994 -no-fast-install disable the fast-install mode
3995 -no-install link a not-installable executable
3996 -no-undefined declare that a library does not refer to external symbols
3997 -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
3998 -objectlist FILE use a list of object files found in FILE to specify objects
3999 -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes)
4000 -precious-files-regex REGEX
4001 don't remove output files matching REGEX
4002 -release RELEASE specify package release information
4003 -rpath LIBDIR the created library will eventually be installed in LIBDIR
4004 -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
4005 -shared only do dynamic linking of libtool libraries
4006 -shrext SUFFIX override the standard shared library file extension
4007 -static do not do any dynamic linking of uninstalled libtool libraries
4008 -static-libtool-libs
4009 do not do any dynamic linking of libtool libraries
4010 -version-info CURRENT[:REVISION[:AGE]]
4011 specify library version info [each variable defaults to 0]
4012 -weak LIBNAME declare that the target provides the LIBNAME interface
4014 -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
4016 -Xassembler FLAG pass linker-specific FLAG directly to the assembler
4018 -Xlinker FLAG pass linker-specific FLAG directly to the linker
4019 -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
4021 All other options (arguments beginning with '-') are ignored.
4023 Every other argument is treated as a filename. Files ending in '.la' are
4024 treated as uninstalled libtool libraries, other files are standard or library
4027 If the OUTPUT-FILE ends in '.la', then a libtool library is created,
4028 only library objects ('.lo' files) may be specified, and '-rpath' is
4029 required, except when creating a convenience library.
4031 If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
4032 using 'ar' and 'ranlib', or on Windows using 'lib'.
4034 If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
4035 is created, otherwise an executable program is created."
4040 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
4042 Remove libraries from an installation directory.
4044 RM is the name of the program to use to delete files associated with each FILE
4045 (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed
4048 If FILE is a libtool library, all the files associated with it are deleted.
4049 Otherwise, only FILE itself is deleted using RM."
4053 func_fatal_help "invalid operation mode '$opt_mode'"
4058 $ECHO "Try '$progname --help' for more information about other modes."
4061 # Now that we've collected a possible --mode arg, show help if necessary
4063 if test : = "$opt_help"; then
4068 for opt_mode in compile link execute install finish uninstall clean; do
4071 } | $SED -n '1p; 2,$s/^Usage:/ or: /p'
4074 for opt_mode in compile link execute install finish uninstall clean; do
4080 /^When reporting/,/^Report/{
4085 /information about other modes/d
4086 /more detailed .*MODE/d
4087 s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
4093 # func_mode_execute arg...
4094 func_mode_execute ()
4098 # The first argument is the command name.
4101 func_fatal_help "you must specify a COMMAND"
4103 # Handle -dlopen flags immediately.
4104 for file in $opt_dlopen; do
4106 || func_fatal_help "'$file' is not a file"
4111 func_resolve_sysroot "$file"
4112 file=$func_resolve_sysroot_result
4114 # Check to see that this really is a libtool archive.
4115 func_lalib_unsafe_p "$file" \
4116 || func_fatal_help "'$lib' is not a valid libtool archive"
4118 # Read the libtool library.
4123 # Skip this library if it cannot be dlopened.
4124 if test -z "$dlname"; then
4125 # Warn if it was a shared library.
4126 test -n "$library_names" && \
4127 func_warning "'$file' was not linked with '-export-dynamic'"
4131 func_dirname "$file" "" "."
4132 dir=$func_dirname_result
4134 if test -f "$dir/$objdir/$dlname"; then
4135 func_append dir "/$objdir"
4137 if test ! -f "$dir/$dlname"; then
4138 func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
4144 # Just add the directory containing the .lo file.
4145 func_dirname "$file" "" "."
4146 dir=$func_dirname_result
4150 func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
4155 # Get the absolute pathname.
4156 absdir=`cd "$dir" && pwd`
4157 test -n "$absdir" && dir=$absdir
4159 # Now add the directory to shlibpath_var.
4160 if eval "test -z \"\$$shlibpath_var\""; then
4161 eval "$shlibpath_var=\"\$dir\""
4163 eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
4167 # This variable tells wrapper scripts just to set shlibpath_var
4168 # rather than running their programs.
4169 libtool_execute_magic=$magic
4171 # Check if any of the arguments is a wrapper script.
4176 -* | *.la | *.lo ) ;;
4178 # Do a test to see if this is really a libtool program.
4179 if func_ltwrapper_script_p "$file"; then
4181 # Transform arg to wrapped name.
4182 file=$progdir/$program
4183 elif func_ltwrapper_executable_p "$file"; then
4184 func_ltwrapper_scriptname "$file"
4185 func_source "$func_ltwrapper_scriptname_result"
4186 # Transform arg to wrapped name.
4187 file=$progdir/$program
4191 # Quote arguments (to preserve shell metacharacters).
4192 func_append_quoted args "$file"
4195 if $opt_dry_run; then
4196 # Display what would be done.
4197 if test -n "$shlibpath_var"; then
4198 eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
4199 echo "export $shlibpath_var"
4204 if test -n "$shlibpath_var"; then
4205 # Export the shlibpath_var.
4206 eval "export $shlibpath_var"
4209 # Restore saved environment variables
4210 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
4212 eval "if test \"\${save_$lt_var+set}\" = set; then
4213 $lt_var=\$save_$lt_var; export $lt_var
4219 # Now prepare to actually exec the command.
4224 test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
4227 # func_mode_finish arg...
4236 for opt in "$nonopt" ${1+"$@"}
4238 if test -d "$opt"; then
4239 func_append libdirs " $opt"
4241 elif test -f "$opt"; then
4242 if func_lalib_unsafe_p "$opt"; then
4243 func_append libs " $opt"
4245 func_warning "'$opt' is not a valid libtool archive"
4249 func_fatal_error "invalid argument '$opt'"
4253 if test -n "$libs"; then
4254 if test -n "$lt_sysroot"; then
4255 sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
4256 sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
4261 # Remove sysroot references
4262 if $opt_dry_run; then
4263 for lib in $libs; do
4264 echo "removing references to $lt_sysroot and '=' prefixes from $lib"
4267 tmpdir=`func_mktempdir`
4268 for lib in $libs; do
4269 $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
4271 mv -f $tmpdir/tmp-la $lib
4277 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4278 for libdir in $libdirs; do
4279 if test -n "$finish_cmds"; then
4280 # Do each command in the finish commands.
4281 func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
4284 if test -n "$finish_eval"; then
4285 # Do the single finish_eval.
4286 eval cmds=\"$finish_eval\"
4287 $opt_dry_run || eval "$cmds" || func_append admincmds "
4293 # Exit here if they wanted silent mode.
4294 $opt_quiet && exit $EXIT_SUCCESS
4296 if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4297 echo "----------------------------------------------------------------------"
4298 echo "Libraries have been installed in:"
4299 for libdir in $libdirs; do
4303 echo "If you ever happen to want to link against installed libraries"
4304 echo "in a given directory, LIBDIR, you must either use libtool, and"
4305 echo "specify the full pathname of the library, or use the '-LLIBDIR'"
4306 echo "flag during linking and do at least one of the following:"
4307 if test -n "$shlibpath_var"; then
4308 echo " - add LIBDIR to the '$shlibpath_var' environment variable"
4309 echo " during execution"
4311 if test -n "$runpath_var"; then
4312 echo " - add LIBDIR to the '$runpath_var' environment variable"
4313 echo " during linking"
4315 if test -n "$hardcode_libdir_flag_spec"; then
4317 eval flag=\"$hardcode_libdir_flag_spec\"
4319 $ECHO " - use the '$flag' linker flag"
4321 if test -n "$admincmds"; then
4322 $ECHO " - have your system administrator run these commands:$admincmds"
4324 if test -f /etc/ld.so.conf; then
4325 echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
4329 echo "See any operating system documentation about shared libraries for"
4331 solaris2.[6789]|solaris2.1[0-9])
4332 echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
4336 echo "more information, such as the ld(1) and ld.so(8) manual pages."
4339 echo "----------------------------------------------------------------------"
4344 test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
4347 # func_mode_install arg...
4348 func_mode_install ()
4352 # There may be an optional sh(1) argument at the beginning of
4353 # install_prog (especially on Windows NT).
4354 if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
4355 # Allow the use of GNU shtool's install command.
4356 case $nonopt in *shtool*) :;; *) false;; esac
4358 # Aesthetically quote it.
4359 func_quote_arg pretty "$nonopt"
4360 install_prog="$func_quote_arg_result "
4368 # The real first argument should be the name of the installation program.
4369 # Aesthetically quote it.
4370 func_quote_arg pretty "$arg"
4371 func_append install_prog "$func_quote_arg_result"
4372 install_shared_prog=$install_prog
4373 case " $install_prog " in
4374 *[\\\ /]cp\ *) install_cp=: ;;
4375 *) install_cp=false ;;
4378 # We need to accept at least all the BSD install flags.
4390 if test -n "$dest"; then
4391 func_append files " $dest"
4399 if $install_cp; then :; else
4413 # If the previous option needed an argument, then skip it.
4414 if test -n "$prev"; then
4415 if test X-m = "X$prev" && test -n "$install_override_mode"; then
4416 arg2=$install_override_mode
4427 # Aesthetically quote the argument.
4428 func_quote_arg pretty "$arg"
4429 func_append install_prog " $func_quote_arg_result"
4430 if test -n "$arg2"; then
4431 func_quote_arg pretty "$arg2"
4433 func_append install_shared_prog " $func_quote_arg_result"
4436 test -z "$install_prog" && \
4437 func_fatal_help "you must specify an install program"
4439 test -n "$prev" && \
4440 func_fatal_help "the '$prev' option requires an argument"
4442 if test -n "$install_override_mode" && $no_mode; then
4443 if $install_cp; then :; else
4444 func_quote_arg pretty "$install_override_mode"
4445 func_append install_shared_prog " -m $func_quote_arg_result"
4449 if test -z "$files"; then
4450 if test -z "$dest"; then
4451 func_fatal_help "no file or destination specified"
4453 func_fatal_help "you must specify a destination"
4457 # Strip any trailing slash from the destination.
4458 func_stripname '' '/' "$dest"
4459 dest=$func_stripname_result
4461 # Check to see that the destination is a directory.
4462 test -d "$dest" && isdir=:
4467 func_dirname_and_basename "$dest" "" "."
4468 destdir=$func_dirname_result
4469 destname=$func_basename_result
4471 # Not a directory, so check to see that there is only one file specified.
4472 set dummy $files; shift
4473 test "$#" -gt 1 && \
4474 func_fatal_help "'$dest' is not a directory"
4477 [\\/]* | [A-Za-z]:[\\/]*) ;;
4479 for file in $files; do
4483 func_fatal_help "'$destdir' must be an absolute directory name"
4490 # This variable tells wrapper scripts just to set variables rather
4491 # than running their programs.
4492 libtool_install_magic=$magic
4497 for file in $files; do
4499 # Do each installation.
4502 # Do the static libraries later.
4503 func_append staticlibs " $file"
4507 func_resolve_sysroot "$file"
4508 file=$func_resolve_sysroot_result
4510 # Check to see that this really is a libtool archive.
4511 func_lalib_unsafe_p "$file" \
4512 || func_fatal_help "'$file' is not a valid libtool archive"
4519 # Add the libdir to current_libdirs if it is the destination.
4520 if test "X$destdir" = "X$libdir"; then
4521 case "$current_libdirs " in
4523 *) func_append current_libdirs " $libdir" ;;
4526 # Note the libdir as a future libdir.
4527 case "$future_libdirs " in
4529 *) func_append future_libdirs " $libdir" ;;
4533 func_dirname "$file" "/" ""
4534 dir=$func_dirname_result
4535 func_append dir "$objdir"
4537 if test -n "$relink_command"; then
4538 # Determine the prefix the user has applied to our future dir.
4539 inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
4541 # Don't allow the user to place us outside of our expected
4542 # location b/c this prevents finding dependent libraries that
4543 # are installed to the same prefix.
4544 # At present, this check doesn't affect windows .dll's that
4545 # are installed into $libdir/../bin (currently, that works fine)
4546 # but it's something to keep an eye on.
4547 test "$inst_prefix_dir" = "$destdir" && \
4548 func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
4550 if test -n "$inst_prefix_dir"; then
4551 # Stick the inst_prefix_dir data into the link command.
4552 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
4554 relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
4557 func_warning "relinking '$file'"
4558 func_show_eval "$relink_command" \
4559 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
4562 # See the names of the shared library.
4563 set dummy $library_names; shift
4564 if test -n "$1"; then
4569 test -n "$relink_command" && srcname=${realname}T
4571 # Install the shared library and build the symlinks.
4572 func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
4576 cygwin* | mingw* | pw32* | cegcc*)
4591 if test -n "$tstripme" && test -n "$striplib"; then
4592 func_show_eval "$striplib $destdir/$realname" 'exit $?'
4595 if test "$#" -gt 0; then
4596 # Delete the old symlinks, and create new ones.
4597 # Try 'ln -sf' first, because the 'ln' binary might depend on
4598 # the symlink we replace! Solaris /bin/ln does not understand -f,
4599 # so we also need to try rm && ln -s.
4602 test "$linkname" != "$realname" \
4603 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
4607 # Do each command in the postinstall commands.
4608 lib=$destdir/$realname
4609 func_execute_cmds "$postinstall_cmds" 'exit $?'
4612 # Install the pseudo-library for information purposes.
4613 func_basename "$file"
4614 name=$func_basename_result
4615 instname=$dir/${name}i
4616 func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
4618 # Maybe install the static library, too.
4619 test -n "$old_library" && func_append staticlibs " $dir/$old_library"
4623 # Install (i.e. copy) a libtool object.
4625 # Figure out destination file name, if it wasn't already specified.
4626 if test -n "$destname"; then
4627 destfile=$destdir/$destname
4629 func_basename "$file"
4630 destfile=$func_basename_result
4631 destfile=$destdir/$destfile
4634 # Deduce the name of the destination old-style object file.
4637 func_lo2o "$destfile"
4638 staticdest=$func_lo2o_result
4641 staticdest=$destfile
4645 func_fatal_help "cannot copy a libtool object to '$destfile'"
4649 # Install the libtool object if requested.
4650 test -n "$destfile" && \
4651 func_show_eval "$install_prog $file $destfile" 'exit $?'
4653 # Install the old object if enabled.
4654 if test yes = "$build_old_libs"; then
4655 # Deduce the name of the old-style object file.
4657 staticobj=$func_lo2o_result
4658 func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
4664 # Figure out destination file name, if it wasn't already specified.
4665 if test -n "$destname"; then
4666 destfile=$destdir/$destname
4668 func_basename "$file"
4669 destfile=$func_basename_result
4670 destfile=$destdir/$destfile
4673 # If the file is missing, and there is a .exe on the end, strip it
4674 # because it is most likely a libtool script we actually want to
4679 if test ! -f "$file"; then
4680 func_stripname '' '.exe' "$file"
4681 file=$func_stripname_result
4687 # Do a test to see if this is really a libtool program.
4690 if func_ltwrapper_executable_p "$file"; then
4691 func_ltwrapper_scriptname "$file"
4692 wrapper=$func_ltwrapper_scriptname_result
4694 func_stripname '' '.exe' "$file"
4695 wrapper=$func_stripname_result
4702 if func_ltwrapper_script_p "$wrapper"; then
4706 func_source "$wrapper"
4708 # Check the variables that should have been set.
4709 test -z "$generated_by_libtool_version" && \
4710 func_fatal_error "invalid libtool wrapper script '$wrapper'"
4713 for lib in $notinst_deplibs; do
4714 # Check to see that each library is installed.
4716 if test -f "$lib"; then
4719 libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
4720 if test -n "$libdir" && test ! -f "$libfile"; then
4721 func_warning "'$lib' has not been installed in '$libdir'"
4727 func_source "$wrapper"
4730 if test no = "$fast_install" && test -n "$relink_command"; then
4733 tmpdir=`func_mktempdir`
4734 func_basename "$file$stripped_ext"
4735 file=$func_basename_result
4736 outputname=$tmpdir/$file
4737 # Replace the output file specification.
4738 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
4741 func_quote_arg expand,pretty "$relink_command"
4742 eval "func_echo $func_quote_arg_result"
4744 if eval "$relink_command"; then :
4746 func_error "error: relink '$file' with the above command before installing it"
4747 $opt_dry_run || ${RM}r "$tmpdir"
4752 func_warning "cannot relink '$file'"
4756 # Install the binary that we compiled earlier.
4757 file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
4761 # remove .exe since cygwin /usr/bin/install will append another
4763 case $install_prog,$host in
4764 */usr/bin/install*,*cygwin*)
4765 case $file:$destfile in
4770 destfile=$destfile.exe
4773 func_stripname '' '.exe' "$destfile"
4774 destfile=$func_stripname_result
4779 func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
4780 $opt_dry_run || if test -n "$outputname"; then
4787 for file in $staticlibs; do
4788 func_basename "$file"
4789 name=$func_basename_result
4791 # Set up the ranlib parameters.
4792 oldlib=$destdir/$name
4793 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
4794 tool_oldlib=$func_to_tool_file_result
4796 func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
4798 if test -n "$stripme" && test -n "$old_striplib"; then
4799 func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
4802 # Do each command in the postinstall commands.
4803 func_execute_cmds "$old_postinstall_cmds" 'exit $?'
4806 test -n "$future_libdirs" && \
4807 func_warning "remember to run '$progname --finish$future_libdirs'"
4809 if test -n "$current_libdirs"; then
4810 # Maybe just do a dry run.
4811 $opt_dry_run && current_libdirs=" -n$current_libdirs"
4812 exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
4818 test install = "$opt_mode" && func_mode_install ${1+"$@"}
4821 # func_generate_dlsyms outputname originator pic_p
4822 # Extract symbols from dlprefiles and create ${outputname}S.o with
4823 # a dlpreopen symbol table.
4824 func_generate_dlsyms ()
4831 my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
4834 if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
4835 if test -n "$NM" && test -n "$global_symbol_pipe"; then
4836 my_dlsyms=${my_outputname}S.c
4838 func_error "not configured to extract global symbols from dlpreopened files"
4842 if test -n "$my_dlsyms"; then
4846 # Discover the nlist of each of the dlfiles.
4847 nlist=$output_objdir/$my_outputname.nm
4849 func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
4851 # Parse the name list into a source file.
4852 func_verbose "creating $output_objdir/$my_dlsyms"
4854 $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
4855 /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
4856 /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
4862 #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
4863 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
4866 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
4867 #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
4868 /* DATA imports from DLLs on WIN32 can't be const, because runtime
4869 relocations are performed -- see ld's documentation on pseudo-relocs. */
4870 # define LT_DLSYM_CONST
4871 #elif defined __osf__
4872 /* This system does not cope well with relocations in const data. */
4873 # define LT_DLSYM_CONST
4875 # define LT_DLSYM_CONST const
4878 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
4880 /* External symbol declarations for the compiler. */\
4883 if test yes = "$dlself"; then
4884 func_verbose "generating symbol list for '$output'"
4886 $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
4888 # Add our own program objects to the symbol list.
4889 progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
4890 for progfile in $progfiles; do
4891 func_to_tool_file "$progfile" func_convert_file_msys_to_w32
4892 func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
4893 $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
4896 if test -n "$exclude_expsyms"; then
4898 eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4899 eval '$MV "$nlist"T "$nlist"'
4903 if test -n "$export_symbols_regex"; then
4905 eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4906 eval '$MV "$nlist"T "$nlist"'
4910 # Prepare the list of exported symbols
4911 if test -z "$export_symbols"; then
4912 export_symbols=$output_objdir/$outputname.exp
4915 eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4917 *cygwin* | *mingw* | *cegcc* )
4918 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4919 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4925 eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4926 eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4927 eval '$MV "$nlist"T "$nlist"'
4929 *cygwin* | *mingw* | *cegcc* )
4930 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4931 eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4938 for dlprefile in $dlprefiles; do
4939 func_verbose "extracting global C symbols from '$dlprefile'"
4940 func_basename "$dlprefile"
4941 name=$func_basename_result
4943 *cygwin* | *mingw* | *cegcc* )
4944 # if an import library, we need to obtain dlname
4945 if func_win32_import_lib_p "$dlprefile"; then
4946 func_tr_sh "$dlprefile"
4947 eval "curr_lafile=\$libfile_$func_tr_sh_result"
4948 dlprefile_dlbasename=
4949 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
4950 # Use subshell, to avoid clobbering current variable values
4951 dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
4952 if test -n "$dlprefile_dlname"; then
4953 func_basename "$dlprefile_dlname"
4954 dlprefile_dlbasename=$func_basename_result
4956 # no lafile. user explicitly requested -dlpreopen <import library>.
4957 $sharedlib_from_linklib_cmd "$dlprefile"
4958 dlprefile_dlbasename=$sharedlib_from_linklib_result
4962 if test -n "$dlprefile_dlbasename"; then
4963 eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
4965 func_warning "Could not compute DLL name from $name"
4966 eval '$ECHO ": $name " >> "$nlist"'
4968 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4969 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
4970 $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
4972 else # not an import lib
4974 eval '$ECHO ": $name " >> "$nlist"'
4975 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4976 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4982 eval '$ECHO ": $name " >> "$nlist"'
4983 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
4984 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
4991 # Make sure we have at least an empty file.
4992 test -f "$nlist" || : > "$nlist"
4994 if test -n "$exclude_expsyms"; then
4995 $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4996 $MV "$nlist"T "$nlist"
4999 # Try sorting and uniquifying the output.
5000 if $GREP -v "^: " < "$nlist" |
5001 if sort -k 3 </dev/null >/dev/null 2>&1; then
5006 uniq > "$nlist"S; then
5009 $GREP -v "^: " < "$nlist" > "$nlist"S
5012 if test -f "$nlist"S; then
5013 eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
5015 echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
5018 func_show_eval '$RM "${nlist}I"'
5019 if test -n "$global_symbol_to_import"; then
5020 eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
5023 echo >> "$output_objdir/$my_dlsyms" "\
5025 /* The mapping between symbol names and symbols. */
5030 extern LT_DLSYM_CONST lt_dlsymlist
5031 lt_${my_prefix}_LTX_preloaded_symbols[];\
5034 if test -s "$nlist"I; then
5035 echo >> "$output_objdir/$my_dlsyms" "\
5036 static void lt_syminit(void)
5038 LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
5039 for (; symbol->name; ++symbol)
5041 $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
5042 echo >> "$output_objdir/$my_dlsyms" "\
5046 echo >> "$output_objdir/$my_dlsyms" "\
5047 LT_DLSYM_CONST lt_dlsymlist
5048 lt_${my_prefix}_LTX_preloaded_symbols[] =
5049 { {\"$my_originator\", (void *) 0},"
5051 if test -s "$nlist"I; then
5052 echo >> "$output_objdir/$my_dlsyms" "\
5053 {\"@INIT@\", (void *) <_syminit},"
5056 case $need_lib_prefix in
5058 eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
5061 eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
5064 echo >> "$output_objdir/$my_dlsyms" "\
5068 /* This works around a problem in FreeBSD linker */
5069 #ifdef FREEBSD_WORKAROUND
5070 static const void *lt_preloaded_setup() {
5071 return lt_${my_prefix}_LTX_preloaded_symbols;
5081 pic_flag_for_symtable=
5082 case "$compile_command " in
5086 # compiling the symbol table file with pic_flag works around
5087 # a FreeBSD bug that causes programs to crash when -lm is
5088 # linked before any other PIC object. But we must not use
5089 # pic_flag when linking with -static. The problem exists in
5090 # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
5091 *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
5092 pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
5094 pic_flag_for_symtable=" $pic_flag" ;;
5096 $my_pic_p && pic_flag_for_symtable=" $pic_flag"
5102 for arg in $LTCFLAGS; do
5104 -pie | -fpie | -fPIE) ;;
5105 *) func_append symtab_cflags " $arg" ;;
5109 # Now compile the dynamic symbol file.
5110 func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
5112 # Clean up the generated files.
5113 func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
5115 # Transform the symbol file into the correct name.
5116 symfileobj=$output_objdir/${my_outputname}S.$objext
5118 *cygwin* | *mingw* | *cegcc* )
5119 if test -f "$output_objdir/$my_outputname.def"; then
5120 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
5121 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
5123 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5124 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5128 compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5129 finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
5134 func_fatal_error "unknown suffix for '$my_dlsyms'"
5138 # We keep going just in case the user didn't refer to
5139 # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
5140 # really was required.
5142 # Nullify the symbol file.
5143 compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
5144 finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
5148 # func_cygming_gnu_implib_p ARG
5149 # This predicate returns with zero status (TRUE) if
5150 # ARG is a GNU/binutils-style import library. Returns
5151 # with nonzero status (FALSE) otherwise.
5152 func_cygming_gnu_implib_p ()
5156 func_to_tool_file "$1" func_convert_file_msys_to_w32
5157 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)$'`
5158 test -n "$func_cygming_gnu_implib_tmp"
5161 # func_cygming_ms_implib_p ARG
5162 # This predicate returns with zero status (TRUE) if
5163 # ARG is an MS-style import library. Returns
5164 # with nonzero status (FALSE) otherwise.
5165 func_cygming_ms_implib_p ()
5169 func_to_tool_file "$1" func_convert_file_msys_to_w32
5170 func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
5171 test -n "$func_cygming_ms_implib_tmp"
5174 # func_win32_libid arg
5175 # return the library type of file 'arg'
5177 # Need a lot of goo to handle *both* DLLs and import libs
5178 # Has to be a shell function in order to 'eat' the argument
5179 # that is supplied when $file_magic_command is called.
5180 # Despite the name, also deal with 64 bit binaries.
5185 win32_libid_type=unknown
5186 win32_fileres=`file -L $1 2>/dev/null`
5187 case $win32_fileres in
5188 *ar\ archive\ import\ library*) # definitely import
5189 win32_libid_type="x86 archive import"
5191 *ar\ archive*) # could be an import, or static
5192 # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
5193 if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
5194 $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
5195 case $nm_interface in
5197 if func_cygming_ms_implib_p "$1" ||
5198 func_cygming_gnu_implib_p "$1"
5206 func_to_tool_file "$1" func_convert_file_msys_to_w32
5207 win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
5218 case $win32_nmres in
5219 import*) win32_libid_type="x86 archive import";;
5220 *) win32_libid_type="x86 archive static";;
5225 win32_libid_type="x86 DLL"
5227 *executable*) # but shell scripts are "executable" too...
5228 case $win32_fileres in
5229 *MS\ Windows\ PE\ Intel*)
5230 win32_libid_type="x86 DLL"
5235 $ECHO "$win32_libid_type"
5238 # func_cygming_dll_for_implib ARG
5240 # Platform-specific function to extract the
5241 # name of the DLL associated with the specified
5242 # import library ARG.
5243 # Invoked by eval'ing the libtool variable
5244 # $sharedlib_from_linklib_cmd
5245 # Result is available in the variable
5246 # $sharedlib_from_linklib_result
5247 func_cygming_dll_for_implib ()
5251 sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
5254 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
5256 # The is the core of a fallback implementation of a
5257 # platform-specific function to extract the name of the
5258 # DLL associated with the specified import library LIBNAME.
5260 # SECTION_NAME is either .idata$6 or .idata$7, depending
5261 # on the platform and compiler that created the implib.
5263 # Echos the name of the DLL associated with the
5264 # specified import library.
5265 func_cygming_dll_for_implib_fallback_core ()
5269 match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
5270 $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
5271 $SED '/^Contents of section '"$match_literal"':/{
5272 # Place marker at beginning of archive member dllname section
5277 # These lines can sometimes be longer than 43 characters, but
5278 # are always uninteresting
5279 /:[ ]*file format pe[i]\{,1\}-/d
5280 /^In archive [^:]*:/d
5281 # Ensure marker is printed
5283 # Remove all lines with less than 43 characters
5285 # From remaining lines, remove first 43 characters
5288 # Join marker and all lines until next marker into a single line
5289 /^====MARK====/ b para
5298 # Remove trailing dots and whitespace
5302 # we now have a list, one entry per line, of the stringified
5303 # contents of the appropriate section of all members of the
5304 # archive that possess that section. Heuristic: eliminate
5305 # all those that have a first or second character that is
5306 # a '.' (that is, objdump's representation of an unprintable
5307 # character.) This should work for all archives with less than
5308 # 0x302f exports -- but will fail for DLLs whose name actually
5309 # begins with a literal '.' or a single character followed by
5312 # Of those that remain, print the first one.
5313 $SED -e '/^\./d;/^.\./d;q'
5316 # func_cygming_dll_for_implib_fallback ARG
5317 # Platform-specific function to extract the
5318 # name of the DLL associated with the specified
5319 # import library ARG.
5321 # This fallback implementation is for use when $DLLTOOL
5322 # does not support the --identify-strict option.
5323 # Invoked by eval'ing the libtool variable
5324 # $sharedlib_from_linklib_cmd
5325 # Result is available in the variable
5326 # $sharedlib_from_linklib_result
5327 func_cygming_dll_for_implib_fallback ()
5331 if func_cygming_gnu_implib_p "$1"; then
5332 # binutils import library
5333 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
5334 elif func_cygming_ms_implib_p "$1"; then
5335 # ms-generated import library
5336 sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
5339 sharedlib_from_linklib_result=
5344 # func_extract_an_archive dir oldlib
5345 func_extract_an_archive ()
5349 f_ex_an_ar_dir=$1; shift
5350 f_ex_an_ar_oldlib=$1
5351 if test yes = "$lock_old_archive_extraction"; then
5352 lockfile=$f_ex_an_ar_oldlib.lock
5353 until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
5354 func_echo "Waiting for $lockfile to be removed"
5358 func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
5359 'stat=$?; rm -f "$lockfile"; exit $stat'
5360 if test yes = "$lock_old_archive_extraction"; then
5361 $opt_dry_run || rm -f "$lockfile"
5363 if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
5366 func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
5371 # func_extract_archives gentop oldlib ...
5372 func_extract_archives ()
5377 my_oldlibs=${1+"$@"}
5383 for my_xlib in $my_oldlibs; do
5384 # Extract the objects.
5386 [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
5387 *) my_xabs=`pwd`"/$my_xlib" ;;
5389 func_basename "$my_xlib"
5390 my_xlib=$func_basename_result
5393 case " $extracted_archives " in
5395 func_arith $extracted_serial + 1
5396 extracted_serial=$func_arith_result
5397 my_xlib_u=lt$extracted_serial-$my_xlib ;;
5401 extracted_archives="$extracted_archives $my_xlib_u"
5402 my_xdir=$my_gentop/$my_xlib_u
5404 func_mkdir_p "$my_xdir"
5408 func_verbose "Extracting $my_xabs"
5409 # Do not bother doing anything if just a dry run
5411 darwin_orig_dir=`pwd`
5412 cd $my_xdir || exit $?
5413 darwin_archive=$my_xabs
5415 func_basename "$darwin_archive"
5416 darwin_base_archive=$func_basename_result
5417 darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
5418 if test -n "$darwin_arches"; then
5419 darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
5421 func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
5422 for darwin_arch in $darwin_arches; do
5423 func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
5424 $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
5425 cd "unfat-$$/$darwin_base_archive-$darwin_arch"
5426 func_extract_an_archive "`pwd`" "$darwin_base_archive"
5428 $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
5429 done # $darwin_arches
5430 ## Okay now we've a bunch of thin objects, gotta fatten them up :)
5431 darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
5434 for darwin_file in $darwin_filelist; do
5435 darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
5436 $LIPO -create -output "$darwin_file" $darwin_files
5437 done # $darwin_filelist
5439 cd "$darwin_orig_dir"
5442 func_extract_an_archive "$my_xdir" "$my_xabs"
5447 func_extract_an_archive "$my_xdir" "$my_xabs"
5450 my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
5453 func_extract_archives_result=$my_oldobjs
5457 # func_emit_wrapper [arg=no]
5459 # Emit a libtool wrapper script on stdout.
5460 # Don't directly open a file because we may want to
5461 # incorporate the script contents within a cygwin/mingw
5462 # wrapper executable. Must ONLY be called from within
5463 # func_mode_link because it depends on a number of variables
5466 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
5467 # variable will take. If 'yes', then the emitted script
5468 # will assume that the directory where it is stored is
5469 # the $objdir directory. This is a cygwin/mingw-specific
5471 func_emit_wrapper ()
5473 func_emit_wrapper_arg1=${1-no}
5478 # $output - temporary wrapper script for $objdir/$outputname
5479 # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5481 # The $output program cannot be directly executed until all the libtool
5482 # libraries that it depends on are installed.
5484 # This wrapper script should never be moved out of the build directory.
5485 # If it is, it will not operate correctly.
5487 # Sed substitution that helps us do robust quoting. It backslashifies
5488 # metacharacters that are still active within double-quoted strings.
5489 sed_quote_subst='$sed_quote_subst'
5491 # Be Bourne compatible
5492 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5495 # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5496 # is contrary to our usage. Disable this feature.
5497 alias -g '\${1+\"\$@\"}'='\"\$@\"'
5498 setopt NO_GLOB_SUBST
5500 case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5502 BIN_SH=xpg4; export BIN_SH # for Tru64
5503 DUALCASE=1; export DUALCASE # for MKS sh
5505 # The HP-UX ksh and POSIX shell print the target directory to stdout
5507 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5509 relink_command=\"$relink_command\"
5511 # This environment variable determines our operation mode.
5512 if test \"\$libtool_install_magic\" = \"$magic\"; then
5513 # install mode needs the following variables:
5514 generated_by_libtool_version='$macro_version'
5515 notinst_deplibs='$notinst_deplibs'
5517 # When we are sourced in execute mode, \$file and \$ECHO are already set.
5518 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5521 func_quote_arg pretty "$ECHO"
5522 qECHO=$func_quote_arg_result
5525 # A function that is used when there is no print builtin or printf.
5526 func_fallback_echo ()
5528 eval 'cat <<_LTECHO_EOF
5535 # Very basic option parsing. These options are (a) specific to
5536 # the libtool wrapper, (b) are identical between the wrapper
5537 # /script/ and the wrapper /executable/ that is used only on
5538 # windows platforms, and (c) all begin with the string "--lt-"
5539 # (application programs are unlikely to have options that match
5542 # There are only two supported options: --lt-debug and
5543 # --lt-dump-script. There is, deliberately, no --lt-help.
5545 # The first argument to this parsing function should be the
5546 # script's $0 value, followed by "$@".
5548 func_parse_lt_options ()
5554 case \"\$lt_opt\" in
5555 --lt-debug) lt_option_debug=1 ;;
5557 lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
5558 test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
5559 lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
5560 cat \"\$lt_dump_D/\$lt_dump_F\"
5564 \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
5570 # Print the debug banner immediately:
5571 if test -n \"\$lt_option_debug\"; then
5572 echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
5576 # Used when --lt-debug. Prints its arguments to stdout
5577 # (redirection is the responsibility of the caller)
5578 func_lt_dump_args ()
5583 \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
5584 lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
5588 # Core function for launching the target application
5589 func_exec_program_core ()
5593 # Backslashes separate directories on plain windows
5594 *-*-mingw | *-*-os2* | *-cegcc*)
5596 if test -n \"\$lt_option_debug\"; then
5597 \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
5598 func_lt_dump_args \${1+\"\$@\"} 1>&2
5600 exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5606 if test -n \"\$lt_option_debug\"; then
5607 \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
5608 func_lt_dump_args \${1+\"\$@\"} 1>&2
5610 exec \"\$progdir/\$program\" \${1+\"\$@\"}
5615 \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
5619 # A function to encapsulate launching the target application
5620 # Strips options in the --lt-* namespace from \$@ and
5621 # launches target application with the remaining arguments.
5622 func_exec_program ()
5630 *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
5635 func_exec_program_core \${1+\"\$@\"}
5639 func_parse_lt_options \"\$0\" \${1+\"\$@\"}
5641 # Find the directory that this script lives in.
5642 thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
5643 test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5645 # Follow symbolic links until we get to the real thisdir.
5646 file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
5647 while test -n \"\$file\"; do
5648 destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
5650 # If there was a directory component, then change thisdir.
5651 if test \"x\$destdir\" != \"x\$file\"; then
5652 case \"\$destdir\" in
5653 [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5654 *) thisdir=\"\$thisdir/\$destdir\" ;;
5658 file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
5659 file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
5662 # Usually 'no', except on cygwin/mingw when embedded into
5664 WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
5665 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
5666 # special case for '.'
5667 if test \"\$thisdir\" = \".\"; then
5670 # remove .libs from thisdir
5671 case \"\$thisdir\" in
5672 *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
5673 $objdir ) thisdir=. ;;
5677 # Try to get the absolute directory name.
5678 absdir=\`cd \"\$thisdir\" && pwd\`
5679 test -n \"\$absdir\" && thisdir=\"\$absdir\"
5682 if test yes = "$fast_install"; then
5684 program=lt-'$outputname'$exeext
5685 progdir=\"\$thisdir/$objdir\"
5687 if test ! -f \"\$progdir/\$program\" ||
5688 { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
5689 test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5691 file=\"\$\$-\$program\"
5693 if test ! -d \"\$progdir\"; then
5694 $MKDIR \"\$progdir\"
5696 $RM \"\$progdir/\$file\"
5701 # relink executable if necessary
5702 if test -n \"\$relink_command\"; then
5703 if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5705 \$ECHO \"\$relink_command_output\" >&2
5706 $RM \"\$progdir/\$file\"
5711 $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5712 { $RM \"\$progdir/\$program\";
5713 $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5714 $RM \"\$progdir/\$file\"
5718 program='$outputname'
5719 progdir=\"\$thisdir/$objdir\"
5725 if test -f \"\$progdir/\$program\"; then"
5727 # fixup the dll searchpath if we need to.
5729 # Fix the DLL searchpath if we need to. Do this before prepending
5730 # to shlibpath, because on Windows, both are PATH and uninstalled
5731 # libraries must come first.
5732 if test -n "$dllsearchpath"; then
5734 # Add the dll search path components to the executable PATH
5735 PATH=$dllsearchpath:\$PATH
5739 # Export our shlibpath_var if we have one.
5740 if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5742 # Add our own library path to $shlibpath_var
5743 $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5745 # Some systems cannot cope with colon-terminated $shlibpath_var
5746 # The second colon is a workaround for a bug in BeOS R4 sed
5747 $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
5749 export $shlibpath_var
5754 if test \"\$libtool_execute_magic\" != \"$magic\"; then
5755 # Run the actual program with our arguments.
5756 func_exec_program \${1+\"\$@\"}
5759 # The program doesn't exist.
5760 \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
5761 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
5762 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
5770 # func_emit_cwrapperexe_src
5771 # emit the source code for a wrapper executable on stdout
5772 # Must ONLY be called from within func_mode_link because
5773 # it depends on a number of variable set therein.
5774 func_emit_cwrapperexe_src ()
5778 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
5779 Generated by $PROGRAM (GNU $PACKAGE) $VERSION
5781 The $output program cannot be directly executed until all the libtool
5782 libraries that it depends on are installed.
5784 This wrapper executable should never be moved out of the build directory.
5785 If it is, it will not operate correctly.
5790 # define _CRT_SECURE_NO_DEPRECATE 1
5795 # include <direct.h>
5796 # include <process.h>
5799 # include <unistd.h>
5800 # include <stdint.h>
5812 #include <sys/stat.h>
5814 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
5816 /* declarations of non-ANSI functions */
5817 #if defined __MINGW32__
5818 # ifdef __STRICT_ANSI__
5819 int _putenv (const char *);
5821 #elif defined __CYGWIN__
5822 # ifdef __STRICT_ANSI__
5823 char *realpath (const char *, char *);
5824 int putenv (char *);
5825 int setenv (const char *, const char *, int);
5827 /* #elif defined other_platform || defined ... */
5830 /* portability defines, excluding path handling macros */
5831 #if defined _MSC_VER
5832 # define setmode _setmode
5834 # define chmod _chmod
5835 # define getcwd _getcwd
5836 # define putenv _putenv
5837 # define S_IXUSR _S_IEXEC
5838 #elif defined __MINGW32__
5839 # define setmode _setmode
5841 # define chmod _chmod
5842 # define getcwd _getcwd
5843 # define putenv _putenv
5844 #elif defined __CYGWIN__
5845 # define HAVE_SETENV
5846 # define FOPEN_WB "wb"
5847 /* #elif defined other platforms ... */
5850 #if defined PATH_MAX
5851 # define LT_PATHMAX PATH_MAX
5852 #elif defined MAXPATHLEN
5853 # define LT_PATHMAX MAXPATHLEN
5855 # define LT_PATHMAX 1024
5865 /* path handling portability macros */
5866 #ifndef DIR_SEPARATOR
5867 # define DIR_SEPARATOR '/'
5868 # define PATH_SEPARATOR ':'
5871 #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
5873 # define HAVE_DOS_BASED_FILE_SYSTEM
5874 # define FOPEN_WB "wb"
5875 # ifndef DIR_SEPARATOR_2
5876 # define DIR_SEPARATOR_2 '\\'
5878 # ifndef PATH_SEPARATOR_2
5879 # define PATH_SEPARATOR_2 ';'
5883 #ifndef DIR_SEPARATOR_2
5884 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5885 #else /* DIR_SEPARATOR_2 */
5886 # define IS_DIR_SEPARATOR(ch) \
5887 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
5888 #endif /* DIR_SEPARATOR_2 */
5890 #ifndef PATH_SEPARATOR_2
5891 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5892 #else /* PATH_SEPARATOR_2 */
5893 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5894 #endif /* PATH_SEPARATOR_2 */
5897 # define FOPEN_WB "w"
5900 # define _O_BINARY 0
5903 #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
5904 #define XFREE(stale) do { \
5905 if (stale) { free (stale); stale = 0; } \
5908 #if defined LT_DEBUGWRAPPER
5909 static int lt_debug = 1;
5911 static int lt_debug = 0;
5914 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
5916 void *xmalloc (size_t num);
5917 char *xstrdup (const char *string);
5918 const char *base_name (const char *name);
5919 char *find_executable (const char *wrapper);
5920 char *chase_symlinks (const char *pathspec);
5921 int make_executable (const char *path);
5922 int check_executable (const char *path);
5923 char *strendzap (char *str, const char *pat);
5924 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
5925 void lt_fatal (const char *file, int line, const char *message, ...);
5926 static const char *nonnull (const char *s);
5927 static const char *nonempty (const char *s);
5928 void lt_setenv (const char *name, const char *value);
5929 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
5930 void lt_update_exe_path (const char *name, const char *value);
5931 void lt_update_lib_path (const char *name, const char *value);
5932 char **prepare_spawn (char **argv);
5933 void lt_dump_script (FILE *f);
5937 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
5938 # define externally_visible volatile
5940 # define externally_visible __attribute__((externally_visible)) volatile
5942 externally_visible const char * MAGIC_EXE = "$magic_exe";
5943 const char * LIB_PATH_VARNAME = "$shlibpath_var";
5946 if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5947 func_to_host_path "$temp_rpath"
5949 const char * LIB_PATH_VALUE = "$func_to_host_path_result";
5953 const char * LIB_PATH_VALUE = "";
5957 if test -n "$dllsearchpath"; then
5958 func_to_host_path "$dllsearchpath:"
5960 const char * EXE_PATH_VARNAME = "PATH";
5961 const char * EXE_PATH_VALUE = "$func_to_host_path_result";
5965 const char * EXE_PATH_VARNAME = "";
5966 const char * EXE_PATH_VALUE = "";
5970 if test yes = "$fast_install"; then
5972 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
5976 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
5983 #define LTWRAPPER_OPTION_PREFIX "--lt-"
5985 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
5986 static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
5987 static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
5990 main (int argc, char *argv[])
5995 char *actual_cwrapper_path;
5996 char *actual_cwrapper_name;
6003 program_name = (char *) xstrdup (base_name (argv[0]));
6004 newargz = XMALLOC (char *, (size_t) argc + 1);
6006 /* very simple arg parsing; don't want to rely on getopt
6007 * also, copy all non cwrapper options to newargz, except
6008 * argz[0], which is handled differently
6011 for (i = 1; i < argc; i++)
6013 if (STREQ (argv[i], dumpscript_opt))
6017 *mingw* | *cygwin* )
6018 # make stdout use "unix" line endings
6019 echo " setmode(1,_O_BINARY);"
6024 lt_dump_script (stdout);
6027 if (STREQ (argv[i], debug_opt))
6032 if (STREQ (argv[i], ltwrapper_option_prefix))
6034 /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
6035 namespace, but it is not one of the ones we know about and
6036 have already dealt with, above (inluding dump-script), then
6037 report an error. Otherwise, targets might begin to believe
6038 they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
6039 namespace. The first time any user complains about this, we'll
6040 need to make LTWRAPPER_OPTION_PREFIX a configure-time option
6041 or a configure.ac-settable value.
6043 lt_fatal (__FILE__, __LINE__,
6044 "unrecognized %s option: '%s'",
6045 ltwrapper_option_prefix, argv[i]);
6048 newargz[++newargc] = xstrdup (argv[i]);
6050 newargz[++newargc] = NULL;
6054 /* The GNU banner must be the first non-error debug message */
6055 lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
6058 lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
6059 lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
6061 tmp_pathspec = find_executable (argv[0]);
6062 if (tmp_pathspec == NULL)
6063 lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
6064 lt_debugprintf (__FILE__, __LINE__,
6065 "(main) found exe (before symlink chase) at: %s\n",
6068 actual_cwrapper_path = chase_symlinks (tmp_pathspec);
6069 lt_debugprintf (__FILE__, __LINE__,
6070 "(main) found exe (after symlink chase) at: %s\n",
6071 actual_cwrapper_path);
6072 XFREE (tmp_pathspec);
6074 actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
6075 strendzap (actual_cwrapper_path, actual_cwrapper_name);
6077 /* wrapper name transforms */
6078 strendzap (actual_cwrapper_name, ".exe");
6079 tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
6080 XFREE (actual_cwrapper_name);
6081 actual_cwrapper_name = tmp_pathspec;
6084 /* target_name transforms -- use actual target program name; might have lt- prefix */
6085 target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
6086 strendzap (target_name, ".exe");
6087 tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
6088 XFREE (target_name);
6089 target_name = tmp_pathspec;
6092 lt_debugprintf (__FILE__, __LINE__,
6093 "(main) libtool target name: %s\n",
6099 XMALLOC (char, (strlen (actual_cwrapper_path) +
6100 strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
6101 strcpy (newargz[0], actual_cwrapper_path);
6102 strcat (newargz[0], "$objdir");
6103 strcat (newargz[0], "/");
6107 /* stop here, and copy so we don't have to do this twice */
6108 tmp_pathspec = xstrdup (newargz[0]);
6110 /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
6111 strcat (newargz[0], actual_cwrapper_name);
6113 /* DO want the lt- prefix here if it exists, so use target_name */
6114 lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
6115 XFREE (tmp_pathspec);
6116 tmp_pathspec = NULL;
6124 while ((p = strchr (newargz[0], '\\')) != NULL)
6128 while ((p = strchr (lt_argv_zero, '\\')) != NULL)
6138 XFREE (target_name);
6139 XFREE (actual_cwrapper_path);
6140 XFREE (actual_cwrapper_name);
6142 lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
6143 lt_setenv ("DUALCASE", "1"); /* for MSK sh */
6144 /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
6145 be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
6146 because on Windows, both *_VARNAMEs are PATH but uninstalled
6147 libraries must come first. */
6148 lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
6149 lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
6151 lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
6152 nonnull (lt_argv_zero));
6153 for (i = 0; i < newargc; i++)
6155 lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
6156 i, nonnull (newargz[i]));
6164 /* execv doesn't actually work on mingw as expected on unix */
6165 newargz = prepare_spawn (newargz);
6166 rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
6169 /* failed to start process */
6170 lt_debugprintf (__FILE__, __LINE__,
6171 "(main) failed to launch target \"%s\": %s\n",
6172 lt_argv_zero, nonnull (strerror (errno)));
6180 execv (lt_argv_zero, newargz);
6181 return rval; /* =127, but avoids unused variable warning */
6190 xmalloc (size_t num)
6192 void *p = (void *) malloc (num);
6194 lt_fatal (__FILE__, __LINE__, "memory exhausted");
6200 xstrdup (const char *string)
6202 return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
6207 base_name (const char *name)
6211 #if defined HAVE_DOS_BASED_FILE_SYSTEM
6212 /* Skip over the disk name in MSDOS pathnames. */
6213 if (isalpha ((unsigned char) name[0]) && name[1] == ':')
6217 for (base = name; *name; name++)
6218 if (IS_DIR_SEPARATOR (*name))
6224 check_executable (const char *path)
6228 lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
6230 if ((!path) || (!*path))
6233 if ((stat (path, &st) >= 0)
6234 && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
6241 make_executable (const char *path)
6246 lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
6248 if ((!path) || (!*path))
6251 if (stat (path, &st) >= 0)
6253 rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
6258 /* Searches for the full path of the wrapper. Returns
6259 newly allocated full path name if found, NULL otherwise
6260 Does not chase symlinks, even on platforms that support them.
6263 find_executable (const char *wrapper)
6268 /* static buffer for getcwd */
6269 char tmp[LT_PATHMAX + 1];
6273 lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
6274 nonempty (wrapper));
6276 if ((wrapper == NULL) || (*wrapper == '\0'))
6279 /* Absolute path? */
6280 #if defined HAVE_DOS_BASED_FILE_SYSTEM
6281 if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
6283 concat_name = xstrdup (wrapper);
6284 if (check_executable (concat_name))
6286 XFREE (concat_name);
6291 if (IS_DIR_SEPARATOR (wrapper[0]))
6293 concat_name = xstrdup (wrapper);
6294 if (check_executable (concat_name))
6296 XFREE (concat_name);
6298 #if defined HAVE_DOS_BASED_FILE_SYSTEM
6302 for (p = wrapper; *p; p++)
6310 /* no slashes; search PATH */
6311 const char *path = getenv ("PATH");
6314 for (p = path; *p; p = p_next)
6318 for (q = p; *q; q++)
6319 if (IS_PATH_SEPARATOR (*q))
6321 p_len = (size_t) (q - p);
6322 p_next = (*q == '\0' ? q : q + 1);
6325 /* empty path: current directory */
6326 if (getcwd (tmp, LT_PATHMAX) == NULL)
6327 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6328 nonnull (strerror (errno)));
6329 tmp_len = strlen (tmp);
6331 XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6332 memcpy (concat_name, tmp, tmp_len);
6333 concat_name[tmp_len] = '/';
6334 strcpy (concat_name + tmp_len + 1, wrapper);
6339 XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
6340 memcpy (concat_name, p, p_len);
6341 concat_name[p_len] = '/';
6342 strcpy (concat_name + p_len + 1, wrapper);
6344 if (check_executable (concat_name))
6346 XFREE (concat_name);
6349 /* not found in PATH; assume curdir */
6351 /* Relative path | not found in path: prepend cwd */
6352 if (getcwd (tmp, LT_PATHMAX) == NULL)
6353 lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
6354 nonnull (strerror (errno)));
6355 tmp_len = strlen (tmp);
6356 concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
6357 memcpy (concat_name, tmp, tmp_len);
6358 concat_name[tmp_len] = '/';
6359 strcpy (concat_name + tmp_len + 1, wrapper);
6361 if (check_executable (concat_name))
6363 XFREE (concat_name);
6368 chase_symlinks (const char *pathspec)
6371 return xstrdup (pathspec);
6373 char buf[LT_PATHMAX];
6375 char *tmp_pathspec = xstrdup (pathspec);
6377 int has_symlinks = 0;
6378 while (strlen (tmp_pathspec) && !has_symlinks)
6380 lt_debugprintf (__FILE__, __LINE__,
6381 "checking path component for symlinks: %s\n",
6383 if (lstat (tmp_pathspec, &s) == 0)
6385 if (S_ISLNK (s.st_mode) != 0)
6391 /* search backwards for last DIR_SEPARATOR */
6392 p = tmp_pathspec + strlen (tmp_pathspec) - 1;
6393 while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6395 if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
6397 /* no more DIR_SEPARATORS left */
6404 lt_fatal (__FILE__, __LINE__,
6405 "error accessing file \"%s\": %s",
6406 tmp_pathspec, nonnull (strerror (errno)));
6409 XFREE (tmp_pathspec);
6413 return xstrdup (pathspec);
6416 tmp_pathspec = realpath (pathspec, buf);
6417 if (tmp_pathspec == 0)
6419 lt_fatal (__FILE__, __LINE__,
6420 "could not follow symlinks for %s", pathspec);
6422 return xstrdup (tmp_pathspec);
6427 strendzap (char *str, const char *pat)
6431 assert (str != NULL);
6432 assert (pat != NULL);
6435 patlen = strlen (pat);
6439 str += len - patlen;
6440 if (STREQ (str, pat))
6447 lt_debugprintf (const char *file, int line, const char *fmt, ...)
6452 (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
6453 va_start (args, fmt);
6454 (void) vfprintf (stderr, fmt, args);
6460 lt_error_core (int exit_status, const char *file,
6461 int line, const char *mode,
6462 const char *message, va_list ap)
6464 fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
6465 vfprintf (stderr, message, ap);
6466 fprintf (stderr, ".\n");
6468 if (exit_status >= 0)
6473 lt_fatal (const char *file, int line, const char *message, ...)
6476 va_start (ap, message);
6477 lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
6482 nonnull (const char *s)
6484 return s ? s : "(null)";
6488 nonempty (const char *s)
6490 return (s && !*s) ? "(empty)" : nonnull (s);
6494 lt_setenv (const char *name, const char *value)
6496 lt_debugprintf (__FILE__, __LINE__,
6497 "(lt_setenv) setting '%s' to '%s'\n",
6498 nonnull (name), nonnull (value));
6501 /* always make a copy, for consistency with !HAVE_SETENV */
6502 char *str = xstrdup (value);
6503 setenv (name, str, 1);
6505 size_t len = strlen (name) + 1 + strlen (value) + 1;
6506 char *str = XMALLOC (char, len);
6507 sprintf (str, "%s=%s", name, value);
6508 if (putenv (str) != EXIT_SUCCESS)
6517 lt_extend_str (const char *orig_value, const char *add, int to_end)
6520 if (orig_value && *orig_value)
6522 size_t orig_value_len = strlen (orig_value);
6523 size_t add_len = strlen (add);
6524 new_value = XMALLOC (char, add_len + orig_value_len + 1);
6527 strcpy (new_value, orig_value);
6528 strcpy (new_value + orig_value_len, add);
6532 strcpy (new_value, add);
6533 strcpy (new_value + add_len, orig_value);
6538 new_value = xstrdup (add);
6544 lt_update_exe_path (const char *name, const char *value)
6546 lt_debugprintf (__FILE__, __LINE__,
6547 "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
6548 nonnull (name), nonnull (value));
6550 if (name && *name && value && *value)
6552 char *new_value = lt_extend_str (getenv (name), value, 0);
6553 /* some systems can't cope with a ':'-terminated path #' */
6554 size_t len = strlen (new_value);
6555 while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
6557 new_value[--len] = '\0';
6559 lt_setenv (name, new_value);
6565 lt_update_lib_path (const char *name, const char *value)
6567 lt_debugprintf (__FILE__, __LINE__,
6568 "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
6569 nonnull (name), nonnull (value));
6571 if (name && *name && value && *value)
6573 char *new_value = lt_extend_str (getenv (name), value, 0);
6574 lt_setenv (name, new_value);
6584 /* Prepares an argument vector before calling spawn().
6585 Note that spawn() does not by itself call the command interpreter
6586 (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
6587 ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
6589 v.dwPlatformId == VER_PLATFORM_WIN32_NT;
6590 }) ? "cmd.exe" : "command.com").
6591 Instead it simply concatenates the arguments, separated by ' ', and calls
6592 CreateProcess(). We must quote the arguments since Win32 CreateProcess()
6593 interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
6595 - Space and tab are interpreted as delimiters. They are not treated as
6596 delimiters if they are surrounded by double quotes: "...".
6597 - Unescaped double quotes are removed from the input. Their only effect is
6598 that within double quotes, space and tab are treated like normal
6600 - Backslashes not followed by double quotes are not special.
6601 - But 2*n+1 backslashes followed by a double quote become
6602 n backslashes followed by a double quote (n >= 0):
6607 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
6608 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
6610 prepare_spawn (char **argv)
6616 /* Count number of arguments. */
6617 for (argc = 0; argv[argc] != NULL; argc++)
6620 /* Allocate new argument vector. */
6621 new_argv = XMALLOC (char *, argc + 1);
6623 /* Put quoted arguments into the new argument vector. */
6624 for (i = 0; i < argc; i++)
6626 const char *string = argv[i];
6628 if (string[0] == '\0')
6629 new_argv[i] = xstrdup ("\"\"");
6630 else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
6632 int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
6634 unsigned int backslashes;
6636 char *quoted_string;
6643 for (s = string; *s != '\0'; s++)
6647 length += backslashes + 1;
6655 length += backslashes + 1;
6657 quoted_string = XMALLOC (char, length + 1);
6663 for (s = string; *s != '\0'; s++)
6669 for (j = backslashes + 1; j > 0; j--)
6681 for (j = backslashes; j > 0; j--)
6687 new_argv[i] = quoted_string;
6690 new_argv[i] = (char *) string;
6692 new_argv[argc] = NULL;
6701 void lt_dump_script (FILE* f)
6704 func_emit_wrapper yes |
6706 s/^\(.\{79\}\)\(..*\)/\1\
6711 s/\([^\n]*\).*/ fputs ("\1", f);/p
6718 # end: func_emit_cwrapperexe_src
6720 # func_win32_import_lib_p ARG
6721 # True if ARG is an import lib, as indicated by $file_magic_cmd
6722 func_win32_import_lib_p ()
6726 case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
6732 # func_suncc_cstd_abi
6733 # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
6734 # Several compiler flags select an ABI that is incompatible with the
6735 # Cstd library. Avoid specifying it if any are in CXXFLAGS.
6736 func_suncc_cstd_abi ()
6740 case " $compile_command " in
6741 *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
6742 suncc_use_cstd_abi=no
6745 suncc_use_cstd_abi=yes
6750 # func_mode_link arg...
6756 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
6757 # It is impossible to link a dll without this setting, and
6758 # we shouldn't force the makefile maintainer to figure out
6759 # what system we are compiling for in order to pass an extra
6760 # flag for every libtool invocation.
6761 # allow_undefined=no
6763 # FIXME: Unfortunately, there are problems with the above when trying
6764 # to make a dll that has undefined symbols, in which case not
6765 # even a static library is built. For now, we need to specify
6766 # -no-undefined on the libtool link line when we can be certain
6767 # that all symbols are satisfied, otherwise we get a static library.
6774 libtool_args=$nonopt
6775 base_compile="$nonopt $@"
6776 compile_command=$nonopt
6777 finalize_command=$nonopt
6790 lib_search_path=`pwd`
6792 new_inherited_linker_flags=
6801 export_symbols_regex=
6810 precious_files_regex=
6811 prefer_static_libs=no
6824 single_module=$wl-single_module
6825 func_infer_tag $base_compile
6827 # We need to know -static, to get the right output filenames.
6832 test yes != "$build_libtool_libs" \
6833 && func_fatal_configuration "cannot build a shared library"
6837 -all-static | -static | -static-libtool-libs)
6840 if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
6841 func_warning "complete static linking is impossible in this configuration"
6843 if test -n "$link_static_flag"; then
6844 dlopen_self=$dlopen_self_static
6846 prefer_static_libs=yes
6849 if test -z "$pic_flag" && test -n "$link_static_flag"; then
6850 dlopen_self=$dlopen_self_static
6852 prefer_static_libs=built
6854 -static-libtool-libs)
6855 if test -z "$pic_flag" && test -n "$link_static_flag"; then
6856 dlopen_self=$dlopen_self_static
6858 prefer_static_libs=yes
6861 build_libtool_libs=no
6868 # See if our shared archives depend on static archives.
6869 test -n "$old_archive_from_new_cmds" && build_old_libs=yes
6871 # Go through the arguments, transforming them on the way.
6872 while test "$#" -gt 0; do
6875 func_quote_arg pretty,unquoted "$arg"
6876 qarg=$func_quote_arg_unquoted_result
6877 func_append libtool_args " $func_quote_arg_result"
6879 # If the previous option needs an argument, assign it.
6880 if test -n "$prev"; then
6883 func_append compile_command " @OUTPUT@"
6884 func_append finalize_command " @OUTPUT@"
6896 # Add the symbol object into the linking commands.
6897 func_append compile_command " @SYMFILE@"
6898 func_append finalize_command " @SYMFILE@"
6902 *.la | *.lo) ;; # We handle these cases below.
6904 if test no = "$dlself"; then
6912 if test dlprefiles = "$prev"; then
6914 elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
6924 if test dlfiles = "$prev"; then
6925 func_append dlfiles " $arg"
6927 func_append dlprefiles " $arg"
6937 || func_fatal_error "symbol file '$arg' does not exist"
6942 export_symbols_regex=$arg
6950 *" $qarg.ltframework "*) ;;
6951 *) func_append deplibs " $qarg.ltframework" # this is fixed later
6960 inst_prefix_dir=$arg
6965 # Clang does not use LLVM to link, so we can simply discard any
6966 # '-mllvm $arg' options when doing the link step.
6971 if test -f "$arg"; then
6974 for fil in `cat "$save_arg"`
6976 # func_append moreargs " $fil"
6978 # A libtool-controlled object.
6980 # Check to see that this really is a libtool object.
6981 if func_lalib_unsafe_p "$arg"; then
6988 if test -z "$pic_object" ||
6989 test -z "$non_pic_object" ||
6990 test none = "$pic_object" &&
6991 test none = "$non_pic_object"; then
6992 func_fatal_error "cannot find name of object for '$arg'"
6995 # Extract subdirectory from the argument.
6996 func_dirname "$arg" "/" ""
6997 xdir=$func_dirname_result
6999 if test none != "$pic_object"; then
7000 # Prepend the subdirectory the object is found in.
7001 pic_object=$xdir$pic_object
7003 if test dlfiles = "$prev"; then
7004 if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7005 func_append dlfiles " $pic_object"
7009 # If libtool objects are unsupported, then we need to preload.
7014 # CHECK ME: I think I busted this. -Ossama
7015 if test dlprefiles = "$prev"; then
7016 # Preload the old-style object.
7017 func_append dlprefiles " $pic_object"
7022 func_append libobjs " $pic_object"
7027 if test none != "$non_pic_object"; then
7028 # Prepend the subdirectory the object is found in.
7029 non_pic_object=$xdir$non_pic_object
7031 # A standard non-PIC object
7032 func_append non_pic_objects " $non_pic_object"
7033 if test -z "$pic_object" || test none = "$pic_object"; then
7037 # If the PIC object exists, use it instead.
7038 # $xdir was prepended to $pic_object above.
7039 non_pic_object=$pic_object
7040 func_append non_pic_objects " $non_pic_object"
7043 # Only an error if not doing a dry-run.
7044 if $opt_dry_run; then
7045 # Extract subdirectory from the argument.
7046 func_dirname "$arg" "/" ""
7047 xdir=$func_dirname_result
7050 pic_object=$xdir$objdir/$func_lo2o_result
7051 non_pic_object=$xdir$func_lo2o_result
7052 func_append libobjs " $pic_object"
7053 func_append non_pic_objects " $non_pic_object"
7055 func_fatal_error "'$arg' is not a valid libtool object"
7060 func_fatal_error "link input file '$arg' does not exist"
7072 precious_files_regex=$arg
7082 # We need an absolute path.
7084 [\\/]* | [A-Za-z]:[\\/]*) ;;
7086 func_fatal_error "only absolute run-paths are allowed"
7089 if test rpath = "$prev"; then
7092 *) func_append rpath " $arg" ;;
7097 *) func_append xrpath " $arg" ;;
7109 func_append weak_libs " $arg"
7114 func_append compiler_flags " -Xassembler $qarg"
7116 func_append compile_command " -Xassembler $qarg"
7117 func_append finalize_command " -Xassembler $qarg"
7121 func_append linker_flags " $qarg"
7122 func_append compiler_flags " $qarg"
7124 func_append compile_command " $qarg"
7125 func_append finalize_command " $qarg"
7129 func_append compiler_flags " $qarg"
7131 func_append compile_command " $qarg"
7132 func_append finalize_command " $qarg"
7136 func_append linker_flags " $qarg"
7137 func_append compiler_flags " $wl$qarg"
7139 func_append compile_command " $wl$qarg"
7140 func_append finalize_command " $wl$qarg"
7144 eval "$prev=\"\$arg\""
7149 fi # test -n "$prev"
7155 if test -n "$link_static_flag"; then
7156 # See comment for -static flag below, for more details.
7157 func_append compile_command " $link_static_flag"
7158 func_append finalize_command " $link_static_flag"
7164 # FIXME: remove this flag sometime in the future.
7165 func_fatal_error "'-allow-undefined' must not be used because it is the default"
7193 -export-symbols | -export-symbols-regex)
7194 if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
7195 func_fatal_error "more than one -exported-symbols argument is not allowed"
7197 if test X-export-symbols = "X$arg"; then
7215 # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
7216 # so, if we see these flags be careful not to treat them like -L
7218 case $with_gcc/$host in
7219 no/*-*-irix* | /*-*-irix*)
7220 func_append compile_command " $arg"
7221 func_append finalize_command " $arg"
7228 func_stripname "-L" '' "$arg"
7229 if test -z "$func_stripname_result"; then
7230 if test "$#" -gt 0; then
7231 func_fatal_error "require no space between '-L' and '$1'"
7233 func_fatal_error "need path for '-L' option"
7236 func_resolve_sysroot "$func_stripname_result"
7237 dir=$func_resolve_sysroot_result
7238 # We need an absolute path.
7240 [\\/]* | [A-Za-z]:[\\/]*) ;;
7242 absdir=`cd "$dir" && pwd`
7243 test -z "$absdir" && \
7244 func_fatal_error "cannot determine absolute directory name of '$dir'"
7249 *" -L$dir "* | *" $arg "*)
7250 # Will only happen for absolute or sysroot arguments
7253 # Preserve sysroot, but never include relative directories
7255 [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
7256 *) func_append deplibs " -L$dir" ;;
7258 func_append lib_search_path " $dir"
7262 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
7263 testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
7264 case :$dllsearchpath: in
7266 ::) dllsearchpath=$dir;;
7267 *) func_append dllsearchpath ":$dir";;
7269 case :$dllsearchpath: in
7270 *":$testbindir:"*) ;;
7271 ::) dllsearchpath=$testbindir;;
7272 *) func_append dllsearchpath ":$testbindir";;
7280 if test X-lc = "X$arg" || test X-lm = "X$arg"; then
7282 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
7283 # These systems don't actually have a C or math library (as such)
7287 # These systems don't actually have a C library (as such)
7288 test X-lc = "X$arg" && continue
7290 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
7291 # Do not include libc due to us having libc/libc_r.
7292 test X-lc = "X$arg" && continue
7294 *-*-rhapsody* | *-*-darwin1.[012])
7295 # Rhapsody C and math libraries are in the System framework
7296 func_append deplibs " System.ltframework"
7299 *-*-sco3.2v5* | *-*-sco5v6*)
7300 # Causes problems with __ctype
7301 test X-lc = "X$arg" && continue
7303 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
7304 # Compiler inserts libc in the correct place for threads to work
7305 test X-lc = "X$arg" && continue
7308 elif test X-lc_r = "X$arg"; then
7310 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
7311 # Do not include libc_r directly, use -pthread flag.
7316 func_append deplibs " $arg"
7330 # Tru64 UNIX uses -model [arg] to determine the layout of C++
7331 # classes, name mangling, and exception handling.
7332 # Darwin uses the -arch flag to determine output architecture.
7333 -model|-arch|-isysroot|--sysroot)
7334 func_append compiler_flags " $arg"
7335 func_append compile_command " $arg"
7336 func_append finalize_command " $arg"
7340 # Solaris ld rejects as of 11.4. Refer to Oracle bug 22985199.
7345 case "$new_inherited_linker_flags " in
7347 * ) func_append new_inherited_linker_flags " $arg" ;;
7353 -mt|-mthreads|-kthread|-Kthread|-pthreads|--thread-safe \
7354 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7355 func_append compiler_flags " $arg"
7356 func_append compile_command " $arg"
7357 func_append finalize_command " $arg"
7358 case "$new_inherited_linker_flags " in
7360 * ) func_append new_inherited_linker_flags " $arg" ;;
7366 single_module=$wl-multi_module
7377 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
7378 # The PATH hackery in wrapper scripts is required on Windows
7379 # and Darwin in order for the loader to find any dlls it needs.
7380 func_warning "'-no-install' is ignored for $host"
7381 func_warning "assuming '-no-fast-install' instead"
7384 *) no_install=yes ;;
7406 -precious-files-regex)
7427 func_stripname '-R' '' "$arg"
7428 dir=$func_stripname_result
7429 # We need an absolute path.
7431 [\\/]* | [A-Za-z]:[\\/]*) ;;
7433 func_stripname '=' '' "$dir"
7434 dir=$lt_sysroot$func_stripname_result
7437 func_fatal_error "only absolute run-paths are allowed"
7442 *) func_append xrpath " $dir" ;;
7448 # The effects of -shared are defined in a previous loop.
7457 -static | -static-libtool-libs)
7458 # The effects of -static are defined in a previous loop.
7459 # We used to do the same as -all-static on platforms that
7460 # didn't have a PIC flag, but the assumption that the effects
7461 # would be equivalent was wrong. It would break on at least
7462 # Digital Unix and AIX.
7488 func_stripname '-Wc,' '' "$arg"
7489 args=$func_stripname_result
7491 save_ifs=$IFS; IFS=,
7492 for flag in $args; do
7494 func_quote_arg pretty "$flag"
7495 func_append arg " $func_quote_arg_result"
7496 func_append compiler_flags " $func_quote_arg_result"
7499 func_stripname ' ' '' "$arg"
7500 arg=$func_stripname_result
7504 func_stripname '-Wl,' '' "$arg"
7505 args=$func_stripname_result
7507 save_ifs=$IFS; IFS=,
7508 for flag in $args; do
7510 func_quote_arg pretty "$flag"
7511 func_append arg " $wl$func_quote_arg_result"
7512 func_append compiler_flags " $wl$func_quote_arg_result"
7513 func_append linker_flags " $func_quote_arg_result"
7516 func_stripname ' ' '' "$arg"
7517 arg=$func_stripname_result
7542 func_quote_arg pretty "$arg"
7543 arg=$func_quote_arg_result
7546 # Flags to be passed through unchanged, with rationale:
7547 # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
7548 # -r[0-9][0-9]* specify processor for the SGI compiler
7549 # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
7550 # +DA*, +DD* enable 64-bit mode for the HP compiler
7551 # -q* compiler args for the IBM compiler
7552 # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
7553 # -F/path path to uninstalled frameworks, gcc on darwin
7554 # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
7555 # -fstack-protector* stack protector flags for GCC
7556 # @file GCC response files
7557 # -tp=* Portland pgcc target processor selection
7558 # --sysroot=* for sysroot support
7559 # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
7560 # -specs=* GCC specs files
7561 # -stdlib=* select c++ std lib with clang
7562 # -fsanitize=* Clang/GCC memory and address sanitizer
7563 # -fuse-ld=* Linker select flags for GCC
7564 # -static-* direct GCC to link specific libraries statically
7565 # -fcilkplus Cilk Plus language extension features for C/C++
7566 # -Wa,* Pass flags directly to the assembler
7567 -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
7568 -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
7569 -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
7570 -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus|-Wa,*)
7571 func_quote_arg pretty "$arg"
7572 arg=$func_quote_arg_result
7573 func_append compile_command " $arg"
7574 func_append finalize_command " $arg"
7575 func_append compiler_flags " $arg"
7580 if test os2 = "`expr $host : '.*\(os2\)'`"; then
7581 # OS/2 uses -Zxxx to specify OS/2-specific options
7582 compiler_flags="$compiler_flags $arg"
7583 func_append compile_command " $arg"
7584 func_append finalize_command " $arg"
7592 # Otherwise treat like 'Some other compiler flag' below
7593 func_quote_arg pretty "$arg"
7594 arg=$func_quote_arg_result
7598 # Some other compiler flag.
7600 func_quote_arg pretty "$arg"
7601 arg=$func_quote_arg_result
7605 # A standard object.
7606 func_append objs " $arg"
7610 # A libtool-controlled object.
7612 # Check to see that this really is a libtool object.
7613 if func_lalib_unsafe_p "$arg"; then
7620 if test -z "$pic_object" ||
7621 test -z "$non_pic_object" ||
7622 test none = "$pic_object" &&
7623 test none = "$non_pic_object"; then
7624 func_fatal_error "cannot find name of object for '$arg'"
7627 # Extract subdirectory from the argument.
7628 func_dirname "$arg" "/" ""
7629 xdir=$func_dirname_result
7631 test none = "$pic_object" || {
7632 # Prepend the subdirectory the object is found in.
7633 pic_object=$xdir$pic_object
7635 if test dlfiles = "$prev"; then
7636 if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
7637 func_append dlfiles " $pic_object"
7641 # If libtool objects are unsupported, then we need to preload.
7646 # CHECK ME: I think I busted this. -Ossama
7647 if test dlprefiles = "$prev"; then
7648 # Preload the old-style object.
7649 func_append dlprefiles " $pic_object"
7654 func_append libobjs " $pic_object"
7659 if test none != "$non_pic_object"; then
7660 # Prepend the subdirectory the object is found in.
7661 non_pic_object=$xdir$non_pic_object
7663 # A standard non-PIC object
7664 func_append non_pic_objects " $non_pic_object"
7665 if test -z "$pic_object" || test none = "$pic_object"; then
7669 # If the PIC object exists, use it instead.
7670 # $xdir was prepended to $pic_object above.
7671 non_pic_object=$pic_object
7672 func_append non_pic_objects " $non_pic_object"
7675 # Only an error if not doing a dry-run.
7676 if $opt_dry_run; then
7677 # Extract subdirectory from the argument.
7678 func_dirname "$arg" "/" ""
7679 xdir=$func_dirname_result
7682 pic_object=$xdir$objdir/$func_lo2o_result
7683 non_pic_object=$xdir$func_lo2o_result
7684 func_append libobjs " $pic_object"
7685 func_append non_pic_objects " $non_pic_object"
7687 func_fatal_error "'$arg' is not a valid libtool object"
7694 func_append deplibs " $arg"
7695 func_append old_deplibs " $arg"
7700 # A libtool-controlled library.
7702 func_resolve_sysroot "$arg"
7703 if test dlfiles = "$prev"; then
7704 # This library was specified with -dlopen.
7705 func_append dlfiles " $func_resolve_sysroot_result"
7707 elif test dlprefiles = "$prev"; then
7708 # The library was specified with -dlpreopen.
7709 func_append dlprefiles " $func_resolve_sysroot_result"
7712 func_append deplibs " $func_resolve_sysroot_result"
7717 # Some other compiler argument.
7719 # Unknown arguments in both finalize_command and compile_command need
7720 # to be aesthetically quoted because they are evaled later.
7721 func_quote_arg pretty "$arg"
7722 arg=$func_quote_arg_result
7726 # Now actually substitute the argument into the commands.
7727 if test -n "$arg"; then
7728 func_append compile_command " $arg"
7729 func_append finalize_command " $arg"
7731 done # argument parsing loop
7733 test -n "$prev" && \
7734 func_fatal_help "the '$prevarg' option requires an argument"
7736 if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
7737 eval arg=\"$export_dynamic_flag_spec\"
7738 func_append compile_command " $arg"
7739 func_append finalize_command " $arg"
7743 # calculate the name of the file, without its directory
7744 func_basename "$output"
7745 outputname=$func_basename_result
7746 libobjs_save=$libobjs
7748 if test -n "$shlibpath_var"; then
7749 # get the directories listed in $shlibpath_var
7750 eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
7754 eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
7755 eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
7757 # Definition is injected by LT_CONFIG during libtool generation.
7758 func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
7760 func_dirname "$output" "/" ""
7761 output_objdir=$func_dirname_result$objdir
7762 func_to_tool_file "$output_objdir/"
7763 tool_output_objdir=$func_to_tool_file_result
7764 # Create the object directory.
7765 func_mkdir_p "$output_objdir"
7767 # Determine the type of output
7770 func_fatal_help "you must specify an output file"
7772 *.$libext) linkmode=oldlib ;;
7773 *.lo | *.$objext) linkmode=obj ;;
7774 *.la) linkmode=lib ;;
7775 *) linkmode=prog ;; # Anything else should be a program.
7781 # Find all interdependent deplibs by searching for libraries
7782 # that are linked more than once (e.g. -la -lb -la)
7783 for deplib in $deplibs; do
7784 if $opt_preserve_dup_deps; then
7786 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
7789 func_append libs " $deplib"
7792 if test lib = "$linkmode"; then
7793 libs="$predeps $libs $compiler_lib_search_path $postdeps"
7795 # Compute libraries that are listed more than once in $predeps
7796 # $postdeps and mark them as special (i.e., whose duplicates are
7797 # not to be eliminated).
7799 if $opt_duplicate_compiler_generated_deps; then
7800 for pre_post_dep in $predeps $postdeps; do
7801 case "$pre_post_deps " in
7802 *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
7804 func_append pre_post_deps " $pre_post_dep"
7813 need_relink=no # whether we're linking any uninstalled libtool libraries
7814 notinst_deplibs= # not-installed libtool libraries
7815 notinst_path= # paths that contain not-installed libtool libraries
7819 passes="conv dlpreopen link"
7820 for file in $dlfiles $dlprefiles; do
7824 func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
7835 passes="conv scan dlopen dlpreopen link"
7841 for pass in $passes; do
7842 # The preopen pass in lib mode reverses $deplibs; put it back here
7843 # so that -L comes before libs that need it for instance...
7844 if test lib,link = "$linkmode,$pass"; then
7845 ## FIXME: Find the place where the list is rebuilt in the wrong
7846 ## order, and fix it there properly
7848 for deplib in $deplibs; do
7849 tmp_deplibs="$deplib $tmp_deplibs"
7851 deplibs=$tmp_deplibs
7854 if test lib,link = "$linkmode,$pass" ||
7855 test prog,scan = "$linkmode,$pass"; then
7859 if test prog = "$linkmode"; then
7861 dlopen) libs=$dlfiles ;;
7862 dlpreopen) libs=$dlprefiles ;;
7864 libs="$deplibs %DEPLIBS%"
7865 test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
7869 if test lib,dlpreopen = "$linkmode,$pass"; then
7870 # Collect and forward deplibs of preopened libtool libs
7871 for lib in $dlprefiles; do
7872 # Ignore non-libtool-libs
7874 func_resolve_sysroot "$lib"
7876 *.la) func_source "$func_resolve_sysroot_result" ;;
7879 # Collect preopened libtool deplibs, except any this library
7880 # has declared as weak libs
7881 for deplib in $dependency_libs; do
7882 func_basename "$deplib"
7883 deplib_base=$func_basename_result
7884 case " $weak_libs " in
7885 *" $deplib_base "*) ;;
7886 *) func_append deplibs " $deplib" ;;
7892 if test dlopen = "$pass"; then
7893 # Collect dlpreopened libraries
7894 save_deplibs=$deplibs
7898 for deplib in $libs; do
7902 -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
7903 |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
7904 if test prog,link = "$linkmode,$pass"; then
7905 compile_deplibs="$deplib $compile_deplibs"
7906 finalize_deplibs="$deplib $finalize_deplibs"
7908 func_append compiler_flags " $deplib"
7909 if test lib = "$linkmode"; then
7910 case "$new_inherited_linker_flags " in
7912 * ) func_append new_inherited_linker_flags " $deplib" ;;
7919 if test lib != "$linkmode" && test prog != "$linkmode"; then
7920 func_warning "'-l' is ignored for archives/objects"
7923 func_stripname '-l' '' "$deplib"
7924 name=$func_stripname_result
7925 if test lib = "$linkmode"; then
7926 searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
7928 searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
7930 for searchdir in $searchdirs; do
7931 for search_ext in .la $std_shrext .so .a; do
7932 # Search the libtool library
7933 lib=$searchdir/lib$name$search_ext
7934 if test -f "$lib"; then
7935 if test .la = "$search_ext"; then
7945 # deplib is a libtool library
7946 # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
7947 # We need to do some special things here, and not later.
7948 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
7949 case " $predeps $postdeps " in
7951 if func_lalib_p "$lib"; then
7955 for l in $old_library $library_names; do
7958 if test "X$ll" = "X$old_library"; then # only static version available
7960 func_dirname "$lib" "" "."
7961 ladir=$func_dirname_result
7962 lib=$ladir/$old_library
7963 if test prog,link = "$linkmode,$pass"; then
7964 compile_deplibs="$deplib $compile_deplibs"
7965 finalize_deplibs="$deplib $finalize_deplibs"
7967 deplibs="$deplib $deplibs"
7968 test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7978 # deplib doesn't seem to be a libtool library
7979 if test prog,link = "$linkmode,$pass"; then
7980 compile_deplibs="$deplib $compile_deplibs"
7981 finalize_deplibs="$deplib $finalize_deplibs"
7983 deplibs="$deplib $deplibs"
7984 test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
7990 if test prog,link = "$linkmode,$pass"; then
7991 compile_deplibs="$deplib $compile_deplibs"
7992 finalize_deplibs="$deplib $finalize_deplibs"
7994 deplibs="$deplib $deplibs"
7995 if test lib = "$linkmode"; then
7996 case "$new_inherited_linker_flags " in
7998 * ) func_append new_inherited_linker_flags " $deplib" ;;
8007 deplibs="$deplib $deplibs"
8008 test conv = "$pass" && continue
8009 newdependency_libs="$deplib $newdependency_libs"
8010 func_stripname '-L' '' "$deplib"
8011 func_resolve_sysroot "$func_stripname_result"
8012 func_append newlib_search_path " $func_resolve_sysroot_result"
8015 if test conv = "$pass"; then
8016 deplibs="$deplib $deplibs"
8019 if test scan = "$pass"; then
8020 deplibs="$deplib $deplibs"
8022 compile_deplibs="$deplib $compile_deplibs"
8023 finalize_deplibs="$deplib $finalize_deplibs"
8025 func_stripname '-L' '' "$deplib"
8026 func_resolve_sysroot "$func_stripname_result"
8027 func_append newlib_search_path " $func_resolve_sysroot_result"
8030 func_warning "'-L' is ignored for archives/objects"
8036 if test link = "$pass"; then
8037 func_stripname '-R' '' "$deplib"
8038 func_resolve_sysroot "$func_stripname_result"
8039 dir=$func_resolve_sysroot_result
8040 # Make sure the xrpath contains only unique directories.
8043 *) func_append xrpath " $dir" ;;
8046 deplibs="$deplib $deplibs"
8050 func_resolve_sysroot "$deplib"
8051 lib=$func_resolve_sysroot_result
8054 if test conv = "$pass"; then
8055 deplibs="$deplib $deplibs"
8060 # Linking convenience modules into shared libraries is allowed,
8061 # but linking other static libraries is non-portable.
8062 case " $dlpreconveniencelibs " in
8066 case $deplibs_check_method in
8068 set dummy $deplibs_check_method; shift
8069 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
8070 if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
8071 | $EGREP "$match_pattern_regex" > /dev/null; then
8079 if $valid_a_lib; then
8081 $ECHO "*** Warning: Linking the shared library $output against the"
8082 $ECHO "*** static library $deplib is not portable!"
8083 deplibs="$deplib $deplibs"
8086 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
8087 echo "*** I have the capability to make that library automatically link in when"
8088 echo "*** you link to this library. But I can only do this if you have a"
8089 echo "*** shared version of the library, which you do not appear to have"
8090 echo "*** because the file extensions .$libext of this argument makes me believe"
8091 echo "*** that it is just a static archive that I should not use here."
8098 if test link != "$pass"; then
8099 deplibs="$deplib $deplibs"
8101 compile_deplibs="$deplib $compile_deplibs"
8102 finalize_deplibs="$deplib $finalize_deplibs"
8109 if test conv = "$pass"; then
8110 deplibs="$deplib $deplibs"
8111 elif test prog = "$linkmode"; then
8112 if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
8113 # If there is no dlopen support or we're linking statically,
8114 # we need to preload.
8115 func_append newdlprefiles " $deplib"
8116 compile_deplibs="$deplib $compile_deplibs"
8117 finalize_deplibs="$deplib $finalize_deplibs"
8119 func_append newdlfiles " $deplib"
8130 $found || test -f "$lib" \
8131 || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
8133 # Check to see that this really is a libtool archive.
8134 func_lalib_unsafe_p "$lib" \
8135 || func_fatal_error "'$lib' is not a valid libtool archive"
8137 func_dirname "$lib" "" "."
8138 ladir=$func_dirname_result
8146 inherited_linker_flags=
8147 # If the library was installed with an old release of libtool,
8148 # it will not redefine variables installed, or shouldnotlink
8157 # Convert "-framework foo" to "foo.ltframework"
8158 if test -n "$inherited_linker_flags"; then
8159 tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
8160 for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
8161 case " $new_inherited_linker_flags " in
8162 *" $tmp_inherited_linker_flag "*) ;;
8163 *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
8167 dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8168 if test lib,link = "$linkmode,$pass" ||
8169 test prog,scan = "$linkmode,$pass" ||
8170 { test prog != "$linkmode" && test lib != "$linkmode"; }; then
8171 test -n "$dlopen" && func_append dlfiles " $dlopen"
8172 test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
8175 if test conv = "$pass"; then
8176 # Only check for convenience libraries
8177 deplibs="$lib $deplibs"
8178 if test -z "$libdir"; then
8179 if test -z "$old_library"; then
8180 func_fatal_error "cannot find name of link library for '$lib'"
8182 # It is a libtool convenience library, so add in its objects.
8183 func_append convenience " $ladir/$objdir/$old_library"
8184 func_append old_convenience " $ladir/$objdir/$old_library"
8186 for deplib in $dependency_libs; do
8187 deplibs="$deplib $deplibs"
8188 if $opt_preserve_dup_deps; then
8189 case "$tmp_libs " in
8190 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
8193 func_append tmp_libs " $deplib"
8195 elif test prog != "$linkmode" && test lib != "$linkmode"; then
8196 func_fatal_error "'$lib' is not a convenience library"
8202 # Get the name of the library we link against.
8204 if test -n "$old_library" &&
8205 { test yes = "$prefer_static_libs" ||
8206 test built,no = "$prefer_static_libs,$installed"; }; then
8207 linklib=$old_library
8209 for l in $old_library $library_names; do
8213 if test -z "$linklib"; then
8214 func_fatal_error "cannot find name of link library for '$lib'"
8217 # This library was specified with -dlopen.
8218 if test dlopen = "$pass"; then
8220 && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
8221 if test -z "$dlname" ||
8222 test yes != "$dlopen_support" ||
8223 test no = "$build_libtool_libs"
8225 # If there is no dlname, no dlopen support or we're linking
8226 # statically, we need to preload. We also need to preload any
8227 # dependent libraries so libltdl's deplib preloader doesn't
8228 # bomb out in the load deplibs phase.
8229 func_append dlprefiles " $lib $dependency_libs"
8231 func_append newdlfiles " $lib"
8236 # We need an absolute path.
8238 [\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
8240 abs_ladir=`cd "$ladir" && pwd`
8241 if test -z "$abs_ladir"; then
8242 func_warning "cannot determine absolute directory name of '$ladir'"
8243 func_warning "passing it literally to the linker, although it might fail"
8248 func_basename "$lib"
8249 laname=$func_basename_result
8251 # Find the relevant object directory and library name.
8252 if test yes = "$installed"; then
8253 if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
8254 func_warning "library '$lib' was moved."
8259 dir=$lt_sysroot$libdir
8260 absdir=$lt_sysroot$libdir
8262 test yes = "$hardcode_automatic" && avoidtemprpath=yes
8264 if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
8267 # Remove this search path later
8268 func_append notinst_path " $abs_ladir"
8271 absdir=$abs_ladir/$objdir
8272 # Remove this search path later
8273 func_append notinst_path " $abs_ladir"
8275 fi # $installed = yes
8276 func_stripname 'lib' '.la' "$laname"
8277 name=$func_stripname_result
8279 # This library was specified with -dlpreopen.
8280 if test dlpreopen = "$pass"; then
8281 if test -z "$libdir" && test prog = "$linkmode"; then
8282 func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
8285 # special handling for platforms with PE-DLLs.
8286 *cygwin* | *mingw* | *cegcc* )
8287 # Linker will automatically link against shared library if both
8288 # static and shared are present. Therefore, ensure we extract
8289 # symbols from the import library if a shared library is present
8290 # (otherwise, the dlopen module name will be incorrect). We do
8291 # this by putting the import library name into $newdlprefiles.
8292 # We recover the dlopen module name by 'saving' the la file
8293 # name in a special purpose variable, and (later) extracting the
8294 # dlname from the la file.
8295 if test -n "$dlname"; then
8296 func_tr_sh "$dir/$linklib"
8297 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
8298 func_append newdlprefiles " $dir/$linklib"
8300 func_append newdlprefiles " $dir/$old_library"
8301 # Keep a list of preopened convenience libraries to check
8302 # that they are being used correctly in the link pass.
8303 test -z "$libdir" && \
8304 func_append dlpreconveniencelibs " $dir/$old_library"
8308 # Prefer using a static library (so that no silly _DYNAMIC symbols
8309 # are required to link).
8310 if test -n "$old_library"; then
8311 func_append newdlprefiles " $dir/$old_library"
8312 # Keep a list of preopened convenience libraries to check
8313 # that they are being used correctly in the link pass.
8314 test -z "$libdir" && \
8315 func_append dlpreconveniencelibs " $dir/$old_library"
8316 # Otherwise, use the dlname, so that lt_dlopen finds it.
8317 elif test -n "$dlname"; then
8318 func_append newdlprefiles " $dir/$dlname"
8320 func_append newdlprefiles " $dir/$linklib"
8324 fi # $pass = dlpreopen
8326 if test -z "$libdir"; then
8327 # Link the convenience library
8328 if test lib = "$linkmode"; then
8329 deplibs="$dir/$old_library $deplibs"
8330 elif test prog,link = "$linkmode,$pass"; then
8331 compile_deplibs="$dir/$old_library $compile_deplibs"
8332 finalize_deplibs="$dir/$old_library $finalize_deplibs"
8334 deplibs="$lib $deplibs" # used for prog,scan pass
8340 if test prog = "$linkmode" && test link != "$pass"; then
8341 func_append newlib_search_path " $ladir"
8342 deplibs="$lib $deplibs"
8344 linkalldeplibs=false
8345 if test no != "$link_all_deplibs" || test -z "$library_names" ||
8346 test no = "$build_libtool_libs"; then
8351 for deplib in $dependency_libs; do
8353 -L*) func_stripname '-L' '' "$deplib"
8354 func_resolve_sysroot "$func_stripname_result"
8355 func_append newlib_search_path " $func_resolve_sysroot_result"
8358 # Need to link against all dependency_libs?
8359 if $linkalldeplibs; then
8360 deplibs="$deplib $deplibs"
8362 # Need to hardcode shared library paths
8363 # or/and link against static libraries
8364 newdependency_libs="$deplib $newdependency_libs"
8366 if $opt_preserve_dup_deps; then
8367 case "$tmp_libs " in
8368 *" $deplib "*) func_append specialdeplibs " $deplib" ;;
8371 func_append tmp_libs " $deplib"
8374 fi # $linkmode = prog...
8376 if test prog,link = "$linkmode,$pass"; then
8377 if test -n "$library_names" &&
8378 { { test no = "$prefer_static_libs" ||
8379 test built,yes = "$prefer_static_libs,$installed"; } ||
8380 test -z "$old_library"; }; then
8381 # We need to hardcode the library path
8382 if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
8383 # Make sure the rpath contains only unique directories.
8384 case $temp_rpath: in
8386 *) func_append temp_rpath "$absdir:" ;;
8390 # Hardcode the library path.
8391 # Skip directories that are in the system default run-time
8393 case " $sys_lib_dlsearch_path " in
8396 case "$compile_rpath " in
8398 *) func_append compile_rpath " $absdir" ;;
8402 case " $sys_lib_dlsearch_path " in
8405 case "$finalize_rpath " in
8407 *) func_append finalize_rpath " $libdir" ;;
8411 fi # $linkmode,$pass = prog,link...
8414 { test pass_all = "$deplibs_check_method" ||
8415 { test yes = "$build_libtool_libs" &&
8416 test -n "$library_names"; }; }; then
8417 # We only need to search for static libraries
8422 link_static=no # Whether the deplib will be linked statically
8423 use_static_libs=$prefer_static_libs
8424 if test built = "$use_static_libs" && test yes = "$installed"; then
8427 if test -n "$library_names" &&
8428 { test no = "$use_static_libs" || test -z "$old_library"; }; then
8430 *cygwin* | *mingw* | *cegcc* | *os2*)
8431 # No point in relinking DLLs because paths are not encoded
8432 func_append notinst_deplibs " $lib"
8436 if test no = "$installed"; then
8437 func_append notinst_deplibs " $lib"
8442 # This is a shared library
8444 # Warn about portability, can't link against -module's on some
8445 # systems (darwin). Don't bleat about dlopened modules though!
8447 for dlpremoduletest in $dlprefiles; do
8448 if test "X$dlpremoduletest" = "X$lib"; then
8449 dlopenmodule=$dlpremoduletest
8453 if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
8455 if test prog = "$linkmode"; then
8456 $ECHO "*** Warning: Linking the executable $output against the loadable module"
8458 $ECHO "*** Warning: Linking the shared library $output against the loadable module"
8460 $ECHO "*** $linklib is not portable!"
8462 if test lib = "$linkmode" &&
8463 test yes = "$hardcode_into_libs"; then
8464 # Hardcode the library path.
8465 # Skip directories that are in the system default run-time
8467 case " $sys_lib_dlsearch_path " in
8470 case "$compile_rpath " in
8472 *) func_append compile_rpath " $absdir" ;;
8476 case " $sys_lib_dlsearch_path " in
8479 case "$finalize_rpath " in
8481 *) func_append finalize_rpath " $libdir" ;;
8487 if test -n "$old_archive_from_expsyms_cmds"; then
8488 # figure out the soname
8489 set dummy $library_names
8493 libname=`eval "\\$ECHO \"$libname_spec\""`
8494 # use dlname if we got it. it's perfectly good, no?
8495 if test -n "$dlname"; then
8497 elif test -n "$soname_spec"; then
8500 *cygwin* | mingw* | *cegcc* | *os2*)
8501 func_arith $current - $age
8502 major=$func_arith_result
8506 eval soname=\"$soname_spec\"
8511 # Make a new name for the extract_expsyms_cmds to use
8513 func_basename "$soroot"
8514 soname=$func_basename_result
8515 func_stripname 'lib' '.dll' "$soname"
8516 newlib=libimp-$func_stripname_result.a
8518 # If the library has no export list, then create one now
8519 if test -f "$output_objdir/$soname-def"; then :
8521 func_verbose "extracting exported symbol list from '$soname'"
8522 func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
8526 if test -f "$output_objdir/$newlib"; then :; else
8527 func_verbose "generating import library for '$soname'"
8528 func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
8530 # make sure the library variables are pointing to the new library
8533 fi # test -n "$old_archive_from_expsyms_cmds"
8535 if test prog = "$linkmode" || test relink != "$opt_mode"; then
8540 case $hardcode_action in
8541 immediate | unsupported)
8542 if test no = "$hardcode_direct"; then
8545 *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
8546 *-*-sysv4*uw2*) add_dir=-L$dir ;;
8547 *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
8548 *-*-unixware7*) add_dir=-L$dir ;;
8550 # if the lib is a (non-dlopened) module then we cannot
8551 # link against it, someone is ignoring the earlier warnings
8552 if /usr/bin/file -L $add 2> /dev/null |
8553 $GREP ": [^:]* bundle" >/dev/null; then
8554 if test "X$dlopenmodule" != "X$lib"; then
8555 $ECHO "*** Warning: lib $linklib is a module, not a shared library"
8556 if test -z "$old_library"; then
8558 echo "*** And there doesn't seem to be a static archive available"
8559 echo "*** The link will probably fail, sorry"
8561 add=$dir/$old_library
8563 elif test -n "$old_library"; then
8564 add=$dir/$old_library
8568 elif test no = "$hardcode_minus_L"; then
8570 *-*-sunos*) add_shlibpath=$dir ;;
8574 elif test no = "$hardcode_shlibpath_var"; then
8582 if test yes = "$hardcode_direct" &&
8583 test no = "$hardcode_direct_absolute"; then
8585 elif test yes = "$hardcode_minus_L"; then
8587 # Try looking first in the location we're being installed to.
8588 if test -n "$inst_prefix_dir"; then
8591 func_append add_dir " -L$inst_prefix_dir$libdir"
8596 elif test yes = "$hardcode_shlibpath_var"; then
8606 if test yes != "$lib_linked"; then
8607 func_fatal_configuration "unsupported hardcode properties"
8610 if test -n "$add_shlibpath"; then
8611 case :$compile_shlibpath: in
8612 *":$add_shlibpath:"*) ;;
8613 *) func_append compile_shlibpath "$add_shlibpath:" ;;
8616 if test prog = "$linkmode"; then
8617 test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
8618 test -n "$add" && compile_deplibs="$add $compile_deplibs"
8620 test -n "$add_dir" && deplibs="$add_dir $deplibs"
8621 test -n "$add" && deplibs="$add $deplibs"
8622 if test yes != "$hardcode_direct" &&
8623 test yes != "$hardcode_minus_L" &&
8624 test yes = "$hardcode_shlibpath_var"; then
8625 case :$finalize_shlibpath: in
8627 *) func_append finalize_shlibpath "$libdir:" ;;
8633 if test prog = "$linkmode" || test relink = "$opt_mode"; then
8637 # Finalize command for both is simple: just hardcode it.
8638 if test yes = "$hardcode_direct" &&
8639 test no = "$hardcode_direct_absolute"; then
8640 add=$libdir/$linklib
8641 elif test yes = "$hardcode_minus_L"; then
8644 elif test yes = "$hardcode_shlibpath_var"; then
8645 case :$finalize_shlibpath: in
8647 *) func_append finalize_shlibpath "$libdir:" ;;
8650 elif test yes = "$hardcode_automatic"; then
8651 if test -n "$inst_prefix_dir" &&
8652 test -f "$inst_prefix_dir$libdir/$linklib"; then
8653 add=$inst_prefix_dir$libdir/$linklib
8655 add=$libdir/$linklib
8658 # We cannot seem to hardcode it, guess we'll fake it.
8660 # Try looking first in the location we're being installed to.
8661 if test -n "$inst_prefix_dir"; then
8664 func_append add_dir " -L$inst_prefix_dir$libdir"
8671 if test prog = "$linkmode"; then
8672 test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
8673 test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
8675 test -n "$add_dir" && deplibs="$add_dir $deplibs"
8676 test -n "$add" && deplibs="$add $deplibs"
8679 elif test prog = "$linkmode"; then
8680 # Here we assume that one of hardcode_direct or hardcode_minus_L
8681 # is not unsupported. This is valid on all known static and
8683 if test unsupported != "$hardcode_direct"; then
8684 test -n "$old_library" && linklib=$old_library
8685 compile_deplibs="$dir/$linklib $compile_deplibs"
8686 finalize_deplibs="$dir/$linklib $finalize_deplibs"
8688 compile_deplibs="-l$name -L$dir $compile_deplibs"
8689 finalize_deplibs="-l$name -L$dir $finalize_deplibs"
8691 elif test yes = "$build_libtool_libs"; then
8692 # Not a shared library
8693 if test pass_all != "$deplibs_check_method"; then
8694 # We're trying link a shared library against a static one
8695 # but the system doesn't support it.
8697 # Just print a warning and add the library to dependency_libs so
8698 # that the program can be linked against the static library.
8700 $ECHO "*** Warning: This system cannot link to static lib archive $lib."
8701 echo "*** I have the capability to make that library automatically link in when"
8702 echo "*** you link to this library. But I can only do this if you have a"
8703 echo "*** shared version of the library, which you do not appear to have."
8704 if test yes = "$module"; then
8705 echo "*** But as you try to build a module library, libtool will still create "
8706 echo "*** a static module, that should work as long as the dlopening application"
8707 echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
8708 if test -z "$global_symbol_pipe"; then
8710 echo "*** However, this would only work if libtool was able to extract symbol"
8711 echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
8712 echo "*** not find such a program. So, this module is probably useless."
8713 echo "*** 'nm' from GNU binutils and a full rebuild may help."
8715 if test no = "$build_old_libs"; then
8716 build_libtool_libs=module
8719 build_libtool_libs=no
8723 deplibs="$dir/$old_library $deplibs"
8726 fi # link shared/static library?
8728 if test lib = "$linkmode"; then
8729 if test -n "$dependency_libs" &&
8730 { test yes != "$hardcode_into_libs" ||
8731 test yes = "$build_old_libs" ||
8732 test yes = "$link_static"; }; then
8733 # Extract -R from dependency_libs
8735 for libdir in $dependency_libs; do
8737 -R*) func_stripname '-R' '' "$libdir"
8738 temp_xrpath=$func_stripname_result
8740 *" $temp_xrpath "*) ;;
8741 *) func_append xrpath " $temp_xrpath";;
8743 *) func_append temp_deplibs " $libdir";;
8746 dependency_libs=$temp_deplibs
8749 func_append newlib_search_path " $absdir"
8750 # Link against this library
8751 test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
8752 # ... and its dependency_libs
8754 for deplib in $dependency_libs; do
8755 newdependency_libs="$deplib $newdependency_libs"
8757 -L*) func_stripname '-L' '' "$deplib"
8758 func_resolve_sysroot "$func_stripname_result";;
8759 *) func_resolve_sysroot "$deplib" ;;
8761 if $opt_preserve_dup_deps; then
8762 case "$tmp_libs " in
8763 *" $func_resolve_sysroot_result "*)
8764 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
8767 func_append tmp_libs " $func_resolve_sysroot_result"
8770 if test no != "$link_all_deplibs"; then
8771 # Add the search paths of all dependency libraries
8772 for deplib in $dependency_libs; do
8775 -L*) path=$deplib ;;
8777 func_resolve_sysroot "$deplib"
8778 deplib=$func_resolve_sysroot_result
8779 func_dirname "$deplib" "" "."
8780 dir=$func_dirname_result
8781 # We need an absolute path.
8783 [\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
8785 absdir=`cd "$dir" && pwd`
8786 if test -z "$absdir"; then
8787 func_warning "cannot determine absolute directory name of '$dir'"
8792 if $GREP "^installed=no" $deplib > /dev/null; then
8796 eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
8797 if test -n "$deplibrary_names"; then
8798 for tmp in $deplibrary_names; do
8801 if test -f "$absdir/$objdir/$depdepl"; then
8802 depdepl=$absdir/$objdir/$depdepl
8803 darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
8804 if test -z "$darwin_install_name"; then
8805 darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
8807 func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
8808 func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
8814 path=-L$absdir/$objdir
8818 eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8819 test -z "$libdir" && \
8820 func_fatal_error "'$deplib' is not a valid libtool archive"
8821 test "$absdir" != "$libdir" && \
8822 func_warning "'$deplib' seems to be moved"
8828 case " $deplibs " in
8830 *) deplibs="$path $deplibs" ;;
8833 fi # link_all_deplibs != no
8835 done # for deplib in $libs
8836 if test link = "$pass"; then
8837 if test prog = "$linkmode"; then
8838 compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
8839 finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
8841 compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
8844 dependency_libs=$newdependency_libs
8845 if test dlpreopen = "$pass"; then
8846 # Link the dlpreopened libraries before other libraries
8847 for deplib in $save_deplibs; do
8848 deplibs="$deplib $deplibs"
8851 if test dlopen != "$pass"; then
8852 test conv = "$pass" || {
8853 # Make sure lib_search_path contains only unique directories.
8855 for dir in $newlib_search_path; do
8856 case "$lib_search_path " in
8858 *) func_append lib_search_path " $dir" ;;
8864 if test prog,link = "$linkmode,$pass"; then
8865 vars="compile_deplibs finalize_deplibs"
8869 for var in $vars dependency_libs; do
8870 # Add libraries to $var in reverse order
8871 eval tmp_libs=\"\$$var\"
8873 for deplib in $tmp_libs; do
8874 # FIXME: Pedantically, this is the right thing to do, so
8875 # that some nasty dependency loop isn't accidentally
8877 #new_libs="$deplib $new_libs"
8878 # Pragmatically, this seems to cause very few problems in
8881 -L*) new_libs="$deplib $new_libs" ;;
8884 # And here is the reason: when a library appears more
8885 # than once as an explicit dependence of a library, or
8886 # is implicitly linked in more than once by the
8887 # compiler, it is considered special, and multiple
8888 # occurrences thereof are not removed. Compare this
8889 # with having the same library being listed as a
8890 # dependency of multiple other libraries: in this case,
8891 # we know (pedantically, we assume) the library does not
8892 # need to be listed more than once, so we keep only the
8893 # last copy. This is not always right, but it is rare
8894 # enough that we require users that really mean to play
8895 # such unportable linking tricks to link the library
8896 # using -Wl,-lname, so that libtool does not consider it
8897 # for duplicate removal.
8898 case " $specialdeplibs " in
8899 *" $deplib "*) new_libs="$deplib $new_libs" ;;
8901 case " $new_libs " in
8903 *) new_libs="$deplib $new_libs" ;;
8911 for deplib in $new_libs; do
8914 case " $tmp_libs " in
8916 *) func_append tmp_libs " $deplib" ;;
8919 *) func_append tmp_libs " $deplib" ;;
8922 eval $var=\"$tmp_libs\"
8926 # Add Sun CC postdeps if required:
8927 test CXX = "$tagname" && {
8930 case `$CC -V 2>&1 | $SED 5q` in
8931 *Sun\ C*) # Sun C++ 5.9
8934 if test no != "$suncc_use_cstd_abi"; then
8935 func_append postdeps ' -library=Cstd -library=Crun'
8942 func_cc_basename "$CC"
8943 case $func_cc_basename_result in
8947 if test no != "$suncc_use_cstd_abi"; then
8948 func_append postdeps ' -library=Cstd -library=Crun'
8956 # Last step: remove runtime libs from dependency_libs
8957 # (they stay in deplibs)
8959 for i in $dependency_libs; do
8960 case " $predeps $postdeps $compiler_lib_search_path " in
8965 if test -n "$i"; then
8966 func_append tmp_libs " $i"
8969 dependency_libs=$tmp_libs
8971 if test prog = "$linkmode"; then
8974 if test prog = "$linkmode" || test lib = "$linkmode"; then
8975 dlprefiles=$newdlprefiles
8980 if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
8981 func_warning "'-dlopen' is ignored for archives"
8986 func_warning "'-l' and '-L' are ignored for archives" ;;
8989 test -n "$rpath" && \
8990 func_warning "'-rpath' is ignored for archives"
8992 test -n "$xrpath" && \
8993 func_warning "'-R' is ignored for archives"
8995 test -n "$vinfo" && \
8996 func_warning "'-version-info/-version-number' is ignored for archives"
8998 test -n "$release" && \
8999 func_warning "'-release' is ignored for archives"
9001 test -n "$export_symbols$export_symbols_regex" && \
9002 func_warning "'-export-symbols' is ignored for archives"
9004 # Now set the variables for building old libraries.
9005 build_libtool_libs=no
9007 func_append objs "$old_deplibs"
9011 # Make sure we only generate libraries of the form 'libNAME.la'.
9014 func_stripname 'lib' '.la' "$outputname"
9015 name=$func_stripname_result
9016 eval shared_ext=\"$shrext_cmds\"
9017 eval libname=\"$libname_spec\"
9020 test no = "$module" \
9021 && func_fatal_help "libtool library '$output' must begin with 'lib'"
9023 if test no != "$need_lib_prefix"; then
9024 # Add the "lib" prefix for modules if required
9025 func_stripname '' '.la' "$outputname"
9026 name=$func_stripname_result
9027 eval shared_ext=\"$shrext_cmds\"
9028 eval libname=\"$libname_spec\"
9030 func_stripname '' '.la' "$outputname"
9031 libname=$func_stripname_result
9036 if test -n "$objs"; then
9037 if test pass_all != "$deplibs_check_method"; then
9038 func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
9041 $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
9042 $ECHO "*** objects $objs is not portable!"
9043 func_append libobjs " $objs"
9047 test no = "$dlself" \
9048 || func_warning "'-dlopen self' is ignored for libtool libraries"
9053 && func_warning "ignoring multiple '-rpath's for a libtool library"
9058 if test -z "$rpath"; then
9059 if test yes = "$build_libtool_libs"; then
9060 # Building a libtool convenience library.
9061 # Some compilers have problems with a '.al' extension so
9062 # convenience libraries should have the same extension an
9063 # archive normally would.
9064 oldlibs="$output_objdir/$libname.$libext $oldlibs"
9065 build_libtool_libs=convenience
9069 test -n "$vinfo" && \
9070 func_warning "'-version-info/-version-number' is ignored for convenience libraries"
9072 test -n "$release" && \
9073 func_warning "'-release' is ignored for convenience libraries"
9076 # Parse the version information argument.
9077 save_ifs=$IFS; IFS=:
9078 set dummy $vinfo 0 0 0
9083 func_fatal_help "too many parameters to '-version-info'"
9085 # convert absolute version numbers to libtool ages
9086 # this retains compatibility with .la files and attempts
9087 # to make the code below a bit more comprehensible
9089 case $vinfo_number in
9095 # There are really only two kinds -- those that
9096 # use the current revision as the major version
9097 # and those that subtract age and use age as
9098 # a minor version. But, then there is irix
9099 # that has an extra 1 added just for fun
9101 case $version_type in
9102 # correct linux to gnu/linux during the next big refactor
9103 darwin|freebsd-elf|linux|midnightbsd-elf|osf|windows|none)
9104 func_arith $number_major + $number_minor
9105 current=$func_arith_result
9107 revision=$number_revision
9109 freebsd-aout|qnx|sunos)
9110 current=$number_major
9111 revision=$number_minor
9115 func_arith $number_major + $number_minor
9116 current=$func_arith_result
9118 revision=$number_minor
9119 lt_irix_increment=no
9122 func_fatal_configuration "$modename: unknown library version type '$version_type'"
9133 # Check that each of the things are valid numbers.
9135 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9137 func_error "CURRENT '$current' must be a nonnegative integer"
9138 func_fatal_error "'$vinfo' is not valid version information"
9143 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9145 func_error "REVISION '$revision' must be a nonnegative integer"
9146 func_fatal_error "'$vinfo' is not valid version information"
9151 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
9153 func_error "AGE '$age' must be a nonnegative integer"
9154 func_fatal_error "'$vinfo' is not valid version information"
9158 if test "$age" -gt "$current"; then
9159 func_error "AGE '$age' is greater than the current interface number '$current'"
9160 func_fatal_error "'$vinfo' is not valid version information"
9163 # Calculate the version variables.
9167 case $version_type in
9171 # Like Linux, but with the current version available in
9172 # verstring for coding it into the library header
9173 func_arith $current - $age
9174 major=.$func_arith_result
9175 versuffix=$major.$age.$revision
9176 # Darwin ld doesn't like 0 for these options...
9177 func_arith $current + 1
9178 minor_current=$func_arith_result
9179 xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
9180 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
9181 # On Darwin other compilers
9184 verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
9187 verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
9194 versuffix=.$current.$revision
9197 freebsd-elf | midnightbsd-elf)
9198 func_arith $current - $age
9199 major=.$func_arith_result
9200 versuffix=$major.$age.$revision
9204 if test no = "$lt_irix_increment"; then
9205 func_arith $current - $age
9207 func_arith $current - $age + 1
9209 major=$func_arith_result
9211 case $version_type in
9212 nonstopux) verstring_prefix=nonstopux ;;
9213 *) verstring_prefix=sgi ;;
9215 verstring=$verstring_prefix$major.$revision
9217 # Add in all the interfaces that we are compatible with.
9219 while test 0 -ne "$loop"; do
9220 func_arith $revision - $loop
9221 iface=$func_arith_result
9222 func_arith $loop - 1
9223 loop=$func_arith_result
9224 verstring=$verstring_prefix$major.$iface:$verstring
9227 # Before this point, $major must not contain '.'.
9229 versuffix=$major.$revision
9232 linux) # correct to gnu/linux during the next big refactor
9233 func_arith $current - $age
9234 major=.$func_arith_result
9235 versuffix=$major.$age.$revision
9239 func_arith $current - $age
9240 major=.$func_arith_result
9241 versuffix=.$current.$age.$revision
9242 verstring=$current.$age.$revision
9244 # Add in all the interfaces that we are compatible with.
9246 while test 0 -ne "$loop"; do
9247 func_arith $current - $loop
9248 iface=$func_arith_result
9249 func_arith $loop - 1
9250 loop=$func_arith_result
9251 verstring=$verstring:$iface.0
9254 # Make executables depend on our current version.
9255 func_append verstring ":$current.0"
9270 versuffix=.$current.$revision
9274 # Use '-' rather than '.', since we only want one
9275 # extension on DOS 8.3 file systems.
9276 func_arith $current - $age
9277 major=$func_arith_result
9282 func_fatal_configuration "unknown library version type '$version_type'"
9286 # Clear the version info if we defaulted, and they specified a release.
9287 if test -z "$vinfo" && test -n "$release"; then
9289 case $version_type in
9291 # we can't check for "0.0" in archive_cmds due to quoting
9292 # problems, so we reset it completely
9299 if test no = "$need_version"; then
9306 # Remove version info from name if versioning should be avoided
9307 if test yes,no = "$avoid_version,$need_version"; then
9313 # Check to see if the archive will have undefined symbols.
9314 if test yes = "$allow_undefined"; then
9315 if test unsupported = "$allow_undefined_flag"; then
9316 if test yes = "$build_old_libs"; then
9317 func_warning "undefined symbols not allowed in $host shared libraries; building static only"
9318 build_libtool_libs=no
9320 func_fatal_error "can't build $host shared library unless -no-undefined is specified"
9324 # Don't allow undefined symbols.
9325 allow_undefined_flag=$no_undefined_flag
9330 func_generate_dlsyms "$libname" "$libname" :
9331 func_append libobjs " $symfileobj"
9332 test " " = "$libobjs" && libobjs=
9334 if test relink != "$opt_mode"; then
9335 # Remove our outputs, but don't remove object files since they
9336 # may have been created when compiling PIC objects.
9338 tempremovelist=`$ECHO "$output_objdir/*"`
9339 for p in $tempremovelist; do
9343 $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
9344 if test -n "$precious_files_regex"; then
9345 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
9350 func_append removelist " $p"
9355 test -n "$removelist" && \
9356 func_show_eval "${RM}r \$removelist"
9359 # Now set the variables for building old libraries.
9360 if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
9361 func_append oldlibs " $output_objdir/$libname.$libext"
9363 # Transform .lo files to .o files.
9364 oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
9367 # Eliminate all temporary directories.
9368 #for path in $notinst_path; do
9369 # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
9370 # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
9371 # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
9374 if test -n "$xrpath"; then
9375 # If the user specified any rpath flags, then add them.
9377 for libdir in $xrpath; do
9378 func_replace_sysroot "$libdir"
9379 func_append temp_xrpath " -R$func_replace_sysroot_result"
9380 case "$finalize_rpath " in
9382 *) func_append finalize_rpath " $libdir" ;;
9385 if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
9386 dependency_libs="$temp_xrpath $dependency_libs"
9390 # Make sure dlfiles contains only unique files that won't be dlpreopened
9391 old_dlfiles=$dlfiles
9393 for lib in $old_dlfiles; do
9394 case " $dlprefiles $dlfiles " in
9396 *) func_append dlfiles " $lib" ;;
9400 # Make sure dlprefiles contains only unique files
9401 old_dlprefiles=$dlprefiles
9403 for lib in $old_dlprefiles; do
9404 case "$dlprefiles " in
9406 *) func_append dlprefiles " $lib" ;;
9410 if test yes = "$build_libtool_libs"; then
9411 if test -n "$rpath"; then
9413 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
9414 # these systems don't actually have a c library (as such)!
9416 *-*-rhapsody* | *-*-darwin1.[012])
9417 # Rhapsody C library is in the System framework
9418 func_append deplibs " System.ltframework"
9421 # Don't link with libc until the a.out ld.so is fixed.
9423 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-midnightbsd*)
9424 # Do not include libc due to us having libc/libc_r.
9426 *-*-sco3.2v5* | *-*-sco5v6*)
9427 # Causes problems with __ctype
9429 *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
9430 # Compiler inserts libc in the correct place for threads to work
9433 # Add libc to deplibs on all other systems if necessary.
9434 if test yes = "$build_libtool_need_lc"; then
9435 func_append deplibs " -lc"
9441 # Transform deplibs into only deplibs that can be linked in shared.
9443 libname_save=$libname
9444 release_save=$release
9445 versuffix_save=$versuffix
9447 # I'm not sure if I'm treating the release correctly. I think
9448 # release should show up in the -l (ie -lgmp5) so we don't want to
9449 # add it in twice. Is that correct?
9455 case $deplibs_check_method in
9457 # Don't check for shared/static. Everything works.
9458 # This might be a little naive. We might want to check
9459 # whether the library exists or not. But this is on
9460 # osf3 & osf4 and I'm not really sure... Just
9461 # implementing what was already the behavior.
9465 # This code stresses the "libraries are programs" paradigm to its
9466 # limits. Maybe even breaks it. We compile a program, linking it
9467 # against the deplibs as a proxy for the library. Then we can check
9468 # whether they linked in statically or dynamically with ldd.
9469 $opt_dry_run || $RM conftest.c
9470 cat > conftest.c <<EOF
9471 int main() { return 0; }
9473 $opt_dry_run || $RM conftest
9474 if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
9475 ldd_output=`ldd conftest`
9476 for i in $deplibs; do
9479 func_stripname -l '' "$i"
9480 name=$func_stripname_result
9481 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9482 case " $predeps $postdeps " in
9484 func_append newdeplibs " $i"
9489 if test -n "$i"; then
9490 libname=`eval "\\$ECHO \"$libname_spec\""`
9491 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
9492 set dummy $deplib_matches; shift
9494 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
9495 func_append newdeplibs " $i"
9499 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
9500 echo "*** I have the capability to make that library automatically link in when"
9501 echo "*** you link to this library. But I can only do this if you have a"
9502 echo "*** shared version of the library, which I believe you do not have"
9503 echo "*** because a test_compile did reveal that the linker did not use it for"
9504 echo "*** its dynamic dependency list that programs get resolved with at runtime."
9509 func_append newdeplibs " $i"
9514 # Error occurred in the first compile. Let's try to salvage
9515 # the situation: Compile a separate program for each library.
9516 for i in $deplibs; do
9519 func_stripname -l '' "$i"
9520 name=$func_stripname_result
9521 $opt_dry_run || $RM conftest
9522 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
9523 ldd_output=`ldd conftest`
9524 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9525 case " $predeps $postdeps " in
9527 func_append newdeplibs " $i"
9532 if test -n "$i"; then
9533 libname=`eval "\\$ECHO \"$libname_spec\""`
9534 deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
9535 set dummy $deplib_matches; shift
9537 if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
9538 func_append newdeplibs " $i"
9542 $ECHO "*** Warning: dynamic linker does not accept needed library $i."
9543 echo "*** I have the capability to make that library automatically link in when"
9544 echo "*** you link to this library. But I can only do this if you have a"
9545 echo "*** shared version of the library, which you do not appear to have"
9546 echo "*** because a test_compile did reveal that the linker did not use this one"
9547 echo "*** as a dynamic dependency that programs can get resolved with at runtime."
9553 $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
9554 echo "*** make it link in! You will probably need to install it or some"
9555 echo "*** library that it depends on before this library will be fully"
9556 echo "*** functional. Installing it before continuing would be even better."
9560 func_append newdeplibs " $i"
9567 set dummy $deplibs_check_method; shift
9568 file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
9569 for a_deplib in $deplibs; do
9572 func_stripname -l '' "$a_deplib"
9573 name=$func_stripname_result
9574 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9575 case " $predeps $postdeps " in
9577 func_append newdeplibs " $a_deplib"
9582 if test -n "$a_deplib"; then
9583 libname=`eval "\\$ECHO \"$libname_spec\""`
9584 if test -n "$file_magic_glob"; then
9585 libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
9587 libnameglob=$libname
9589 test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
9590 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9591 if test yes = "$want_nocaseglob"; then
9593 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9596 potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
9598 for potent_lib in $potential_libs; do
9599 # Follow soft links.
9600 if ls -lLd "$potent_lib" 2>/dev/null |
9601 $GREP " -> " >/dev/null; then
9604 # The statement above tries to avoid entering an
9605 # endless loop below, in case of cyclic links.
9606 # We might still enter an endless loop, since a link
9607 # loop can be closed while we follow links,
9610 while test -h "$potlib" 2>/dev/null; do
9611 potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
9613 [\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
9614 *) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
9617 if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
9619 $EGREP "$file_magic_regex" > /dev/null; then
9620 func_append newdeplibs " $a_deplib"
9627 if test -n "$a_deplib"; then
9630 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9631 echo "*** I have the capability to make that library automatically link in when"
9632 echo "*** you link to this library. But I can only do this if you have a"
9633 echo "*** shared version of the library, which you do not appear to have"
9634 echo "*** because I did check the linker path looking for a file starting"
9635 if test -z "$potlib"; then
9636 $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
9638 $ECHO "*** with $libname and none of the candidates passed a file format test"
9639 $ECHO "*** using a file magic. Last file checked: $potlib"
9644 # Add a -L argument.
9645 func_append newdeplibs " $a_deplib"
9648 done # Gone through all deplibs.
9651 set dummy $deplibs_check_method; shift
9652 match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
9653 for a_deplib in $deplibs; do
9656 func_stripname -l '' "$a_deplib"
9657 name=$func_stripname_result
9658 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9659 case " $predeps $postdeps " in
9661 func_append newdeplibs " $a_deplib"
9666 if test -n "$a_deplib"; then
9667 libname=`eval "\\$ECHO \"$libname_spec\""`
9668 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
9669 potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
9670 for potent_lib in $potential_libs; do
9671 potlib=$potent_lib # see symlink-check above in file_magic test
9672 if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
9673 $EGREP "$match_pattern_regex" > /dev/null; then
9674 func_append newdeplibs " $a_deplib"
9681 if test -n "$a_deplib"; then
9684 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
9685 echo "*** I have the capability to make that library automatically link in when"
9686 echo "*** you link to this library. But I can only do this if you have a"
9687 echo "*** shared version of the library, which you do not appear to have"
9688 echo "*** because I did check the linker path looking for a file starting"
9689 if test -z "$potlib"; then
9690 $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
9692 $ECHO "*** with $libname and none of the candidates passed a file format test"
9693 $ECHO "*** using a regex pattern. Last file checked: $potlib"
9698 # Add a -L argument.
9699 func_append newdeplibs " $a_deplib"
9702 done # Gone through all deplibs.
9706 tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
9707 if test yes = "$allow_libtool_libs_with_static_runtimes"; then
9708 for i in $predeps $postdeps; do
9709 # can't use Xsed below, because $i might contain '/'
9710 tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
9713 case $tmp_deplibs in
9716 if test none = "$deplibs_check_method"; then
9717 echo "*** Warning: inter-library dependencies are not supported in this platform."
9719 echo "*** Warning: inter-library dependencies are not known to be supported."
9721 echo "*** All declared inter-library dependencies are being dropped."
9727 versuffix=$versuffix_save
9729 release=$release_save
9730 libname=$libname_save
9734 *-*-rhapsody* | *-*-darwin1.[012])
9735 # On Rhapsody replace the C library with the System framework
9736 newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
9740 if test yes = "$droppeddeps"; then
9741 if test yes = "$module"; then
9743 echo "*** Warning: libtool could not satisfy all declared inter-library"
9744 $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
9745 echo "*** a static module, that should work as long as the dlopening"
9746 echo "*** application is linked with the -dlopen flag."
9747 if test -z "$global_symbol_pipe"; then
9749 echo "*** However, this would only work if libtool was able to extract symbol"
9750 echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
9751 echo "*** not find such a program. So, this module is probably useless."
9752 echo "*** 'nm' from GNU binutils and a full rebuild may help."
9754 if test no = "$build_old_libs"; then
9755 oldlibs=$output_objdir/$libname.$libext
9756 build_libtool_libs=module
9759 build_libtool_libs=no
9762 echo "*** The inter-library dependencies that have been dropped here will be"
9763 echo "*** automatically added whenever a program is linked with this library"
9764 echo "*** or is declared to -dlopen it."
9766 if test no = "$allow_undefined"; then
9768 echo "*** Since this library must not contain undefined symbols,"
9769 echo "*** because either the platform does not support them or"
9770 echo "*** it was explicitly requested with -no-undefined,"
9771 echo "*** libtool will only create a static version of it."
9772 if test no = "$build_old_libs"; then
9773 oldlibs=$output_objdir/$libname.$libext
9774 build_libtool_libs=module
9777 build_libtool_libs=no
9782 # Done checking deplibs!
9785 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
9788 newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9789 new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9790 deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
9794 # move library search paths that coincide with paths to not yet
9795 # installed libraries to the beginning of the library search list
9797 for path in $notinst_path; do
9798 case " $new_libs " in
9799 *" -L$path/$objdir "*) ;;
9801 case " $deplibs " in
9802 *" -L$path/$objdir "*)
9803 func_append new_libs " -L$path/$objdir" ;;
9808 for deplib in $deplibs; do
9811 case " $new_libs " in
9813 *) func_append new_libs " $deplib" ;;
9816 *) func_append new_libs " $deplib" ;;
9821 # All the library-specific variables (install_libdir is set above).
9826 # Test again, we may have decided not to build it any more
9827 if test yes = "$build_libtool_libs"; then
9828 # Remove $wl instances when linking with ld.
9829 # FIXME: should test the right _cmds variable.
9830 case $archive_cmds in
9833 if test yes = "$hardcode_into_libs"; then
9834 # Hardcode the library paths
9837 rpath=$finalize_rpath
9838 test relink = "$opt_mode" || rpath=$compile_rpath$rpath
9839 for libdir in $rpath; do
9840 if test -n "$hardcode_libdir_flag_spec"; then
9841 if test -n "$hardcode_libdir_separator"; then
9842 func_replace_sysroot "$libdir"
9843 libdir=$func_replace_sysroot_result
9844 if test -z "$hardcode_libdirs"; then
9845 hardcode_libdirs=$libdir
9847 # Just accumulate the unique libdirs.
9848 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
9849 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
9852 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
9857 eval flag=\"$hardcode_libdir_flag_spec\"
9858 func_append dep_rpath " $flag"
9860 elif test -n "$runpath_var"; then
9861 case "$perm_rpath " in
9863 *) func_append perm_rpath " $libdir" ;;
9867 # Substitute the hardcoded libdirs into the rpath.
9868 if test -n "$hardcode_libdir_separator" &&
9869 test -n "$hardcode_libdirs"; then
9870 libdir=$hardcode_libdirs
9871 eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
9873 if test -n "$runpath_var" && test -n "$perm_rpath"; then
9874 # We should set the runpath_var.
9876 for dir in $perm_rpath; do
9877 func_append rpath "$dir:"
9879 eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
9881 test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
9884 shlibpath=$finalize_shlibpath
9885 test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
9886 if test -n "$shlibpath"; then
9887 eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
9890 # Get the real and link names of the library.
9891 eval shared_ext=\"$shrext_cmds\"
9892 eval library_names=\"$library_names_spec\"
9893 set dummy $library_names
9898 if test -n "$soname_spec"; then
9899 eval soname=\"$soname_spec\"
9903 if test -z "$dlname"; then
9907 lib=$output_objdir/$realname
9911 func_append linknames " $link"
9914 # Use standard objects if they are pic
9915 test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
9916 test "X$libobjs" = "X " && libobjs=
9919 if test -n "$export_symbols" && test -n "$include_expsyms"; then
9920 $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
9921 export_symbols=$output_objdir/$libname.uexp
9922 func_append delfiles " $export_symbols"
9925 orig_export_symbols=
9927 cygwin* | mingw* | cegcc*)
9928 if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
9929 # exporting using user supplied symfile
9930 func_dll_def_p "$export_symbols" || {
9931 # and it's NOT already a .def file. Must figure out
9932 # which of the given symbols are data symbols and tag
9933 # them as such. So, trigger use of export_symbols_cmds.
9934 # export_symbols gets reassigned inside the "prepare
9935 # the list of exported symbols" if statement, so the
9936 # include_expsyms logic still works.
9937 orig_export_symbols=$export_symbols
9939 always_export_symbols=yes
9945 # Prepare the list of exported symbols
9946 if test -z "$export_symbols"; then
9947 if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
9948 func_verbose "generating symbol list for '$libname.la'"
9949 export_symbols=$output_objdir/$libname.exp
9950 $opt_dry_run || $RM $export_symbols
9951 cmds=$export_symbols_cmds
9952 save_ifs=$IFS; IFS='~'
9953 for cmd1 in $cmds; do
9955 # Take the normal branch if the nm_file_list_spec branch
9956 # doesn't work or if tool conversion is not needed.
9957 case $nm_file_list_spec~$to_tool_file_cmd in
9958 *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
9959 try_normal_branch=yes
9962 len=$func_len_result
9965 try_normal_branch=no
9968 if test yes = "$try_normal_branch" \
9969 && { test "$len" -lt "$max_cmd_len" \
9970 || test "$max_cmd_len" -le -1; }
9972 func_show_eval "$cmd" 'exit $?'
9973 skipped_export=false
9974 elif test -n "$nm_file_list_spec"; then
9975 func_basename "$output"
9976 output_la=$func_basename_result
9977 save_libobjs=$libobjs
9979 output=$output_objdir/$output_la.nm
9980 func_to_tool_file "$output"
9981 libobjs=$nm_file_list_spec$func_to_tool_file_result
9982 func_append delfiles " $output"
9983 func_verbose "creating $NM input file list: $output"
9984 for obj in $save_libobjs; do
9985 func_to_tool_file "$obj"
9986 $ECHO "$func_to_tool_file_result"
9989 func_show_eval "$cmd" 'exit $?'
9991 libobjs=$save_libobjs
9992 skipped_export=false
9994 # The command line is too long to execute in one step.
9995 func_verbose "using reloadable object file for export list..."
9997 # Break out early, otherwise skipped_export may be
9998 # set to false by a later but shorter cmd.
10003 if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
10004 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
10005 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
10010 if test -n "$export_symbols" && test -n "$include_expsyms"; then
10011 tmp_export_symbols=$export_symbols
10012 test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
10013 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
10016 if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
10017 # The given exports_symbols file has to be filtered, so filter it.
10018 func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
10019 # FIXME: $output_objdir/$libname.filter potentially contains lots of
10020 # 's' commands, which not all seds can handle. GNU sed should be fine
10021 # though. Also, the filter scales superlinearly with the number of
10022 # global variables. join(1) would be nice here, but unfortunately
10023 # isn't a blessed tool.
10024 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
10025 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
10026 export_symbols=$output_objdir/$libname.def
10027 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
10031 for test_deplib in $deplibs; do
10032 case " $convenience " in
10033 *" $test_deplib "*) ;;
10035 func_append tmp_deplibs " $test_deplib"
10039 deplibs=$tmp_deplibs
10041 if test -n "$convenience"; then
10042 if test -n "$whole_archive_flag_spec" &&
10043 test yes = "$compiler_needs_object" &&
10044 test -z "$libobjs"; then
10045 # extract the archives, so we have objects to list.
10046 # TODO: could optimize this to just extract one archive.
10047 whole_archive_flag_spec=
10049 if test -n "$whole_archive_flag_spec"; then
10050 save_libobjs=$libobjs
10051 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
10052 test "X$libobjs" = "X " && libobjs=
10054 gentop=$output_objdir/${outputname}x
10055 func_append generated " $gentop"
10057 func_extract_archives $gentop $convenience
10058 func_append libobjs " $func_extract_archives_result"
10059 test "X$libobjs" = "X " && libobjs=
10063 if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
10064 eval flag=\"$thread_safe_flag_spec\"
10065 func_append linker_flags " $flag"
10068 # Make a backup of the uninstalled library when relinking
10069 if test relink = "$opt_mode"; then
10070 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
10073 # Do each of the archive commands.
10074 if test yes = "$module" && test -n "$module_cmds"; then
10075 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
10076 eval test_cmds=\"$module_expsym_cmds\"
10077 cmds=$module_expsym_cmds
10079 eval test_cmds=\"$module_cmds\"
10083 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
10084 eval test_cmds=\"$archive_expsym_cmds\"
10085 cmds=$archive_expsym_cmds
10087 eval test_cmds=\"$archive_cmds\"
10092 if test : != "$skipped_export" &&
10093 func_len " $test_cmds" &&
10094 len=$func_len_result &&
10095 test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
10098 # The command line is too long to link in one step, link piecewise
10099 # or, if using GNU ld and skipped_export is not :, use a linker
10102 # Save the value of $output and $libobjs because we want to
10103 # use them later. If we have whole_archive_flag_spec, we
10104 # want to use save_libobjs as it was before
10105 # whole_archive_flag_spec was expanded, because we can't
10106 # assume the linker understands whole_archive_flag_spec.
10107 # This may have to be revisited, in case too many
10108 # convenience libraries get linked in and end up exceeding
10110 if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
10111 save_libobjs=$libobjs
10113 save_output=$output
10114 func_basename "$output"
10115 output_la=$func_basename_result
10117 # Clear the reloadable object creation command queue and
10118 # initialize k to one.
10125 if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
10126 output=$output_objdir/$output_la.lnkscript
10127 func_verbose "creating GNU ld script: $output"
10128 echo 'INPUT (' > $output
10129 for obj in $save_libobjs
10131 func_to_tool_file "$obj"
10132 $ECHO "$func_to_tool_file_result" >> $output
10134 echo ')' >> $output
10135 func_append delfiles " $output"
10136 func_to_tool_file "$output"
10137 output=$func_to_tool_file_result
10138 elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
10139 output=$output_objdir/$output_la.lnk
10140 func_verbose "creating linker input file list: $output"
10142 set x $save_libobjs
10145 if test yes = "$compiler_needs_object"; then
10151 func_to_tool_file "$obj"
10152 $ECHO "$func_to_tool_file_result" >> $output
10154 func_append delfiles " $output"
10155 func_to_tool_file "$output"
10156 output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
10158 if test -n "$save_libobjs"; then
10159 func_verbose "creating reloadable object files..."
10160 output=$output_objdir/$output_la-$k.$objext
10161 eval test_cmds=\"$reload_cmds\"
10162 func_len " $test_cmds"
10163 len0=$func_len_result
10166 # Loop over the list of objects to be linked.
10167 for obj in $save_libobjs
10170 func_arith $len + $func_len_result
10171 len=$func_arith_result
10172 if test -z "$objlist" ||
10173 test "$len" -lt "$max_cmd_len"; then
10174 func_append objlist " $obj"
10176 # The command $test_cmds is almost too long, add a
10177 # command to the queue.
10178 if test 1 -eq "$k"; then
10179 # The first file doesn't have a previous command to add.
10180 reload_objs=$objlist
10181 eval concat_cmds=\"$reload_cmds\"
10183 # All subsequent reloadable object files will link in
10184 # the last one created.
10185 reload_objs="$objlist $last_robj"
10186 eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
10188 last_robj=$output_objdir/$output_la-$k.$objext
10190 k=$func_arith_result
10191 output=$output_objdir/$output_la-$k.$objext
10193 func_len " $last_robj"
10194 func_arith $len0 + $func_len_result
10195 len=$func_arith_result
10198 # Handle the remaining objects by creating one last
10199 # reloadable object file. All subsequent reloadable object
10200 # files will link in the last one created.
10201 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
10202 reload_objs="$objlist $last_robj"
10203 eval concat_cmds=\"\$concat_cmds$reload_cmds\"
10204 if test -n "$last_robj"; then
10205 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
10207 func_append delfiles " $output"
10213 ${skipped_export-false} && {
10214 func_verbose "generating symbol list for '$libname.la'"
10215 export_symbols=$output_objdir/$libname.exp
10216 $opt_dry_run || $RM $export_symbols
10218 # Append the command to create the export file.
10219 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
10220 eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
10221 if test -n "$last_robj"; then
10222 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
10226 test -n "$save_libobjs" &&
10227 func_verbose "creating a temporary reloadable object file: $output"
10229 # Loop through the commands generated above and execute them.
10230 save_ifs=$IFS; IFS='~'
10231 for cmd in $concat_cmds; do
10234 func_quote_arg expand,pretty "$cmd"
10235 eval "func_echo $func_quote_arg_result"
10237 $opt_dry_run || eval "$cmd" || {
10240 # Restore the uninstalled library and exit
10241 if test relink = "$opt_mode"; then
10242 ( cd "$output_objdir" && \
10243 $RM "${realname}T" && \
10244 $MV "${realname}U" "$realname" )
10252 if test -n "$export_symbols_regex" && ${skipped_export-false}; then
10253 func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
10254 func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
10258 ${skipped_export-false} && {
10259 if test -n "$export_symbols" && test -n "$include_expsyms"; then
10260 tmp_export_symbols=$export_symbols
10261 test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
10262 $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
10265 if test -n "$orig_export_symbols"; then
10266 # The given exports_symbols file has to be filtered, so filter it.
10267 func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
10268 # FIXME: $output_objdir/$libname.filter potentially contains lots of
10269 # 's' commands, which not all seds can handle. GNU sed should be fine
10270 # though. Also, the filter scales superlinearly with the number of
10271 # global variables. join(1) would be nice here, but unfortunately
10272 # isn't a blessed tool.
10273 $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
10274 func_append delfiles " $export_symbols $output_objdir/$libname.filter"
10275 export_symbols=$output_objdir/$libname.def
10276 $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
10281 # Restore the value of output.
10282 output=$save_output
10284 if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
10285 eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
10286 test "X$libobjs" = "X " && libobjs=
10288 # Expand the library linking commands again to reset the
10289 # value of $libobjs for piecewise linking.
10291 # Do each of the archive commands.
10292 if test yes = "$module" && test -n "$module_cmds"; then
10293 if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
10294 cmds=$module_expsym_cmds
10299 if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
10300 cmds=$archive_expsym_cmds
10307 if test -n "$delfiles"; then
10308 # Append the command to remove temporary files to $cmds.
10309 eval cmds=\"\$cmds~\$RM $delfiles\"
10312 # Add any objects from preloaded convenience libraries
10313 if test -n "$dlprefiles"; then
10314 gentop=$output_objdir/${outputname}x
10315 func_append generated " $gentop"
10317 func_extract_archives $gentop $dlprefiles
10318 func_append libobjs " $func_extract_archives_result"
10319 test "X$libobjs" = "X " && libobjs=
10322 save_ifs=$IFS; IFS='~'
10323 for cmd in $cmds; do
10328 func_quote_arg expand,pretty "$cmd"
10329 eval "func_echo $func_quote_arg_result"
10331 $opt_dry_run || eval "$cmd" || {
10334 # Restore the uninstalled library and exit
10335 if test relink = "$opt_mode"; then
10336 ( cd "$output_objdir" && \
10337 $RM "${realname}T" && \
10338 $MV "${realname}U" "$realname" )
10346 # Restore the uninstalled library and exit
10347 if test relink = "$opt_mode"; then
10348 $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
10350 if test -n "$convenience"; then
10351 if test -z "$whole_archive_flag_spec"; then
10352 func_show_eval '${RM}r "$gentop"'
10359 # Create links to the real library.
10360 for linkname in $linknames; do
10361 if test "$realname" != "$linkname"; then
10362 func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
10366 # If -module or -export-dynamic was specified, set the dlname.
10367 if test yes = "$module" || test yes = "$export_dynamic"; then
10368 # On all known operating systems, these are identical.
10375 if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
10376 func_warning "'-dlopen' is ignored for objects"
10379 case " $deplibs" in
10381 func_warning "'-l' and '-L' are ignored for objects" ;;
10384 test -n "$rpath" && \
10385 func_warning "'-rpath' is ignored for objects"
10387 test -n "$xrpath" && \
10388 func_warning "'-R' is ignored for objects"
10390 test -n "$vinfo" && \
10391 func_warning "'-version-info' is ignored for objects"
10393 test -n "$release" && \
10394 func_warning "'-release' is ignored for objects"
10398 test -n "$objs$old_deplibs" && \
10399 func_fatal_error "cannot build library object '$output' from non-libtool objects"
10402 func_lo2o "$libobj"
10403 obj=$func_lo2o_result
10411 # Delete the old objects.
10412 $opt_dry_run || $RM $obj $libobj
10414 # Objects from convenience libraries. This assumes
10415 # single-version convenience libraries. Whenever we create
10416 # different ones for PIC/non-PIC, this we'll have to duplicate
10420 # if reload_cmds runs $LD directly, get rid of -Wl from
10421 # whole_archive_flag_spec and hope we can get by with turning comma
10423 case $reload_cmds in
10424 *\$LD[\ \$]*) wl= ;;
10426 if test -n "$convenience"; then
10427 if test -n "$whole_archive_flag_spec"; then
10428 eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
10429 test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
10430 reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
10432 gentop=$output_objdir/${obj}x
10433 func_append generated " $gentop"
10435 func_extract_archives $gentop $convenience
10436 reload_conv_objs="$reload_objs $func_extract_archives_result"
10440 # If we're not building shared, we need to use non_pic_objs
10441 test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
10443 # Create the old-style object.
10444 reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
10447 func_execute_cmds "$reload_cmds" 'exit $?'
10449 # Exit if we aren't doing a library object file.
10450 if test -z "$libobj"; then
10451 if test -n "$gentop"; then
10452 func_show_eval '${RM}r "$gentop"'
10458 test yes = "$build_libtool_libs" || {
10459 if test -n "$gentop"; then
10460 func_show_eval '${RM}r "$gentop"'
10463 # Create an invalid libtool object if no PIC, so that we don't
10464 # accidentally link it into a program.
10465 # $show "echo timestamp > $libobj"
10466 # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
10470 if test -n "$pic_flag" || test default != "$pic_mode"; then
10471 # Only do commands if we really have different PIC objects.
10472 reload_objs="$libobjs $reload_conv_objs"
10474 func_execute_cmds "$reload_cmds" 'exit $?'
10477 if test -n "$gentop"; then
10478 func_show_eval '${RM}r "$gentop"'
10486 *cygwin*) func_stripname '' '.exe' "$output"
10487 output=$func_stripname_result.exe;;
10489 test -n "$vinfo" && \
10490 func_warning "'-version-info' is ignored for programs"
10492 test -n "$release" && \
10493 func_warning "'-release' is ignored for programs"
10496 && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
10497 && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
10500 *-*-rhapsody* | *-*-darwin1.[012])
10501 # On Rhapsody replace the C library is the System framework
10502 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
10503 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
10509 # Don't allow lazy linking, it breaks C++ global constructors
10510 # But is supposedly fixed on 10.4 or later (yay!).
10511 if test CXX = "$tagname"; then
10512 case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
10514 func_append compile_command " $wl-bind_at_load"
10515 func_append finalize_command " $wl-bind_at_load"
10519 # Time to change all our "foo.ltframework" stuff back to "-framework foo"
10520 compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
10521 finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
10526 # move library search paths that coincide with paths to not yet
10527 # installed libraries to the beginning of the library search list
10529 for path in $notinst_path; do
10530 case " $new_libs " in
10531 *" -L$path/$objdir "*) ;;
10533 case " $compile_deplibs " in
10534 *" -L$path/$objdir "*)
10535 func_append new_libs " -L$path/$objdir" ;;
10540 for deplib in $compile_deplibs; do
10543 case " $new_libs " in
10545 *) func_append new_libs " $deplib" ;;
10548 *) func_append new_libs " $deplib" ;;
10551 compile_deplibs=$new_libs
10554 func_append compile_command " $compile_deplibs"
10555 func_append finalize_command " $finalize_deplibs"
10557 if test -n "$rpath$xrpath"; then
10558 # If the user specified any rpath flags, then add them.
10559 for libdir in $rpath $xrpath; do
10560 # This is the magic to use -rpath.
10561 case "$finalize_rpath " in
10563 *) func_append finalize_rpath " $libdir" ;;
10568 # Now hardcode the library paths
10571 for libdir in $compile_rpath $finalize_rpath; do
10572 if test -n "$hardcode_libdir_flag_spec"; then
10573 if test -n "$hardcode_libdir_separator"; then
10574 if test -z "$hardcode_libdirs"; then
10575 hardcode_libdirs=$libdir
10577 # Just accumulate the unique libdirs.
10578 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10579 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
10582 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10587 eval flag=\"$hardcode_libdir_flag_spec\"
10588 func_append rpath " $flag"
10590 elif test -n "$runpath_var"; then
10591 case "$perm_rpath " in
10593 *) func_append perm_rpath " $libdir" ;;
10597 *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
10598 testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
10599 case :$dllsearchpath: in
10601 ::) dllsearchpath=$libdir;;
10602 *) func_append dllsearchpath ":$libdir";;
10604 case :$dllsearchpath: in
10605 *":$testbindir:"*) ;;
10606 ::) dllsearchpath=$testbindir;;
10607 *) func_append dllsearchpath ":$testbindir";;
10612 # Substitute the hardcoded libdirs into the rpath.
10613 if test -n "$hardcode_libdir_separator" &&
10614 test -n "$hardcode_libdirs"; then
10615 libdir=$hardcode_libdirs
10616 eval rpath=\" $hardcode_libdir_flag_spec\"
10618 compile_rpath=$rpath
10622 for libdir in $finalize_rpath; do
10623 if test -n "$hardcode_libdir_flag_spec"; then
10624 if test -n "$hardcode_libdir_separator"; then
10625 if test -z "$hardcode_libdirs"; then
10626 hardcode_libdirs=$libdir
10628 # Just accumulate the unique libdirs.
10629 case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
10630 *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
10633 func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
10638 eval flag=\"$hardcode_libdir_flag_spec\"
10639 func_append rpath " $flag"
10641 elif test -n "$runpath_var"; then
10642 case "$finalize_perm_rpath " in
10644 *) func_append finalize_perm_rpath " $libdir" ;;
10648 # Substitute the hardcoded libdirs into the rpath.
10649 if test -n "$hardcode_libdir_separator" &&
10650 test -n "$hardcode_libdirs"; then
10651 libdir=$hardcode_libdirs
10652 eval rpath=\" $hardcode_libdir_flag_spec\"
10654 finalize_rpath=$rpath
10656 if test -n "$libobjs" && test yes = "$build_old_libs"; then
10657 # Transform all the library objects into standard objects.
10658 compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
10659 finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
10662 func_generate_dlsyms "$outputname" "@PROGRAM@" false
10664 # template prelinking step
10665 if test -n "$prelink_cmds"; then
10666 func_execute_cmds "$prelink_cmds" 'exit $?'
10669 wrappers_required=:
10671 *cegcc* | *mingw32ce*)
10672 # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
10673 wrappers_required=false
10675 *cygwin* | *mingw* )
10676 test yes = "$build_libtool_libs" || wrappers_required=false
10679 if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
10680 wrappers_required=false
10684 $wrappers_required || {
10685 # Replace the output file specification.
10686 compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
10687 link_command=$compile_command$compile_rpath
10689 # We have no uninstalled library dependencies, so finalize right now.
10691 func_show_eval "$link_command" 'exit_status=$?'
10693 if test -n "$postlink_cmds"; then
10694 func_to_tool_file "$output"
10695 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10696 func_execute_cmds "$postlink_cmds" 'exit $?'
10699 # Delete the generated files.
10700 if test -f "$output_objdir/${outputname}S.$objext"; then
10701 func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
10707 if test -n "$compile_shlibpath$finalize_shlibpath"; then
10708 compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
10710 if test -n "$finalize_shlibpath"; then
10711 finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
10716 if test -n "$runpath_var"; then
10717 if test -n "$perm_rpath"; then
10718 # We should set the runpath_var.
10720 for dir in $perm_rpath; do
10721 func_append rpath "$dir:"
10723 compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
10725 if test -n "$finalize_perm_rpath"; then
10726 # We should set the runpath_var.
10728 for dir in $finalize_perm_rpath; do
10729 func_append rpath "$dir:"
10731 finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
10735 if test yes = "$no_install"; then
10736 # We don't need to create a wrapper script.
10737 link_command=$compile_var$compile_command$compile_rpath
10738 # Replace the output file specification.
10739 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
10740 # Delete the old output file.
10741 $opt_dry_run || $RM $output
10742 # Link the executable and exit
10743 func_show_eval "$link_command" 'exit $?'
10745 if test -n "$postlink_cmds"; then
10746 func_to_tool_file "$output"
10747 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10748 func_execute_cmds "$postlink_cmds" 'exit $?'
10754 case $hardcode_action,$fast_install in
10756 # Fast installation is not supported
10757 link_command=$compile_var$compile_command$compile_rpath
10758 relink_command=$finalize_var$finalize_command$finalize_rpath
10760 func_warning "this platform does not like uninstalled shared libraries"
10761 func_warning "'$output' will be relinked during installation"
10764 link_command=$finalize_var$compile_command$finalize_rpath
10765 relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
10768 link_command=$compile_var$compile_command$compile_rpath
10769 relink_command=$finalize_var$finalize_command$finalize_rpath
10772 link_command=$finalize_var$compile_command$finalize_rpath
10777 # Replace the output file specification.
10778 link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
10780 # Delete the old output files.
10781 $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
10783 func_show_eval "$link_command" 'exit $?'
10785 if test -n "$postlink_cmds"; then
10786 func_to_tool_file "$output_objdir/$outputname"
10787 postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
10788 func_execute_cmds "$postlink_cmds" 'exit $?'
10791 # Now create the wrapper script.
10792 func_verbose "creating $output"
10794 # Quote the relink command for shipping.
10795 if test -n "$relink_command"; then
10796 # Preserve any variables that may affect compiler behavior
10797 for var in $variables_saved_for_relink; do
10798 if eval test -z \"\${$var+set}\"; then
10799 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
10800 elif eval var_value=\$$var; test -z "$var_value"; then
10801 relink_command="$var=; export $var; $relink_command"
10803 func_quote_arg pretty "$var_value"
10804 relink_command="$var=$func_quote_arg_result; export $var; $relink_command"
10807 func_quote eval cd "`pwd`"
10808 func_quote_arg pretty,unquoted "($func_quote_result; $relink_command)"
10809 relink_command=$func_quote_arg_unquoted_result
10812 # Only actually do things if not in dry run mode.
10814 # win32 will think the script is a binary if it has
10815 # a .exe suffix, so we strip it off here.
10817 *.exe) func_stripname '' '.exe' "$output"
10818 output=$func_stripname_result ;;
10820 # test for cygwin because mv fails w/o .exe extensions
10824 func_stripname '' '.exe' "$outputname"
10825 outputname=$func_stripname_result ;;
10829 *cygwin* | *mingw* )
10830 func_dirname_and_basename "$output" "" "."
10831 output_name=$func_basename_result
10832 output_path=$func_dirname_result
10833 cwrappersource=$output_path/$objdir/lt-$output_name.c
10834 cwrapper=$output_path/$output_name.exe
10835 $RM $cwrappersource $cwrapper
10836 trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
10838 func_emit_cwrapperexe_src > $cwrappersource
10840 # The wrapper executable is built using the $host compiler,
10841 # because it contains $host paths and files. If cross-
10842 # compiling, it, like the target executable, must be
10843 # executed on the $host or under an emulation environment.
10845 $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
10849 # Now, create the wrapper script for func_source use:
10850 func_ltwrapper_scriptname $cwrapper
10851 $RM $func_ltwrapper_scriptname_result
10852 trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
10854 # note: this script will not be executed, so do not chmod.
10855 if test "x$build" = "x$host"; then
10856 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
10858 func_emit_wrapper no > $func_ltwrapper_scriptname_result
10864 trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
10866 func_emit_wrapper no > $output
10875 # See if we need to build an old-fashioned archive.
10876 for oldlib in $oldlibs; do
10878 case $build_libtool_libs in
10880 oldobjs="$libobjs_save $symfileobj"
10881 addlibs=$convenience
10882 build_libtool_libs=no
10885 oldobjs=$libobjs_save
10886 addlibs=$old_convenience
10887 build_libtool_libs=no
10890 oldobjs="$old_deplibs $non_pic_objects"
10891 $preload && test -f "$symfileobj" \
10892 && func_append oldobjs " $symfileobj"
10893 addlibs=$old_convenience
10897 if test -n "$addlibs"; then
10898 gentop=$output_objdir/${outputname}x
10899 func_append generated " $gentop"
10901 func_extract_archives $gentop $addlibs
10902 func_append oldobjs " $func_extract_archives_result"
10905 # Do each command in the archive commands.
10906 if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
10907 cmds=$old_archive_from_new_cmds
10910 # Add any objects from preloaded convenience libraries
10911 if test -n "$dlprefiles"; then
10912 gentop=$output_objdir/${outputname}x
10913 func_append generated " $gentop"
10915 func_extract_archives $gentop $dlprefiles
10916 func_append oldobjs " $func_extract_archives_result"
10919 # POSIX demands no paths to be encoded in archives. We have
10920 # to avoid creating archives with duplicate basenames if we
10921 # might have to extract them afterwards, e.g., when creating a
10922 # static archive out of a convenience library, or when linking
10923 # the entirety of a libtool archive into another (currently
10924 # not supported by libtool).
10925 if (for obj in $oldobjs
10927 func_basename "$obj"
10928 $ECHO "$func_basename_result"
10929 done | sort | sort -uc >/dev/null 2>&1); then
10932 echo "copying selected object files to avoid basename conflicts..."
10933 gentop=$output_objdir/${outputname}x
10934 func_append generated " $gentop"
10935 func_mkdir_p "$gentop"
10936 save_oldobjs=$oldobjs
10939 for obj in $save_oldobjs
10941 func_basename "$obj"
10942 objbase=$func_basename_result
10943 case " $oldobjs " in
10944 " ") oldobjs=$obj ;;
10945 *[\ /]"$objbase "*)
10947 # Make sure we don't pick an alternate name that also
10949 newobj=lt$counter-$objbase
10950 func_arith $counter + 1
10951 counter=$func_arith_result
10952 case " $oldobjs " in
10953 *[\ /]"$newobj "*) ;;
10954 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
10957 func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
10958 func_append oldobjs " $gentop/$newobj"
10960 *) func_append oldobjs " $obj" ;;
10964 func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
10965 tool_oldlib=$func_to_tool_file_result
10966 eval cmds=\"$old_archive_cmds\"
10969 len=$func_len_result
10970 if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
10971 cmds=$old_archive_cmds
10972 elif test -n "$archiver_list_spec"; then
10973 func_verbose "using command file archive linking..."
10974 for obj in $oldobjs
10976 func_to_tool_file "$obj"
10977 $ECHO "$func_to_tool_file_result"
10978 done > $output_objdir/$libname.libcmd
10979 func_to_tool_file "$output_objdir/$libname.libcmd"
10980 oldobjs=" $archiver_list_spec$func_to_tool_file_result"
10981 cmds=$old_archive_cmds
10983 # the command line is too long to link in one step, link in parts
10984 func_verbose "using piecewise archive linking..."
10985 save_RANLIB=$RANLIB
10989 save_oldobjs=$oldobjs
10991 # Is there a better way of finding the last object in the list?
10992 for obj in $save_oldobjs
10996 eval test_cmds=\"$old_archive_cmds\"
10997 func_len " $test_cmds"
10998 len0=$func_len_result
11000 for obj in $save_oldobjs
11003 func_arith $len + $func_len_result
11004 len=$func_arith_result
11005 func_append objlist " $obj"
11006 if test "$len" -lt "$max_cmd_len"; then
11009 # the above command should be used before it gets too long
11011 if test "$obj" = "$last_oldobj"; then
11012 RANLIB=$save_RANLIB
11014 test -z "$concat_cmds" || concat_cmds=$concat_cmds~
11015 eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
11020 RANLIB=$save_RANLIB
11022 if test -z "$oldobjs"; then
11023 eval cmds=\"\$concat_cmds\"
11025 eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
11029 func_execute_cmds "$cmds" 'exit $?'
11032 test -n "$generated" && \
11033 func_show_eval "${RM}r$generated"
11035 # Now create the libtool archive.
11039 test yes = "$build_old_libs" && old_library=$libname.$libext
11040 func_verbose "creating $output"
11042 # Preserve any variables that may affect compiler behavior
11043 for var in $variables_saved_for_relink; do
11044 if eval test -z \"\${$var+set}\"; then
11045 relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
11046 elif eval var_value=\$$var; test -z "$var_value"; then
11047 relink_command="$var=; export $var; $relink_command"
11049 func_quote_arg pretty,unquoted "$var_value"
11050 relink_command="$var=$func_quote_arg_unquoted_result; export $var; $relink_command"
11053 # Quote the link command for shipping.
11054 func_quote eval cd "`pwd`"
11055 relink_command="($func_quote_result; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
11056 func_quote_arg pretty,unquoted "$relink_command"
11057 relink_command=$func_quote_arg_unquoted_result
11058 if test yes = "$hardcode_automatic"; then
11062 # Only create the output if not a dry run.
11064 for installed in no yes; do
11065 if test yes = "$installed"; then
11066 if test -z "$install_libdir"; then
11069 output=$output_objdir/${outputname}i
11070 # Replace all uninstalled libtool libraries with the installed ones
11071 newdependency_libs=
11072 for deplib in $dependency_libs; do
11075 func_basename "$deplib"
11076 name=$func_basename_result
11077 func_resolve_sysroot "$deplib"
11078 eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
11079 test -z "$libdir" && \
11080 func_fatal_error "'$deplib' is not a valid libtool archive"
11081 func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
11084 func_stripname -L '' "$deplib"
11085 func_replace_sysroot "$func_stripname_result"
11086 func_append newdependency_libs " -L$func_replace_sysroot_result"
11089 func_stripname -R '' "$deplib"
11090 func_replace_sysroot "$func_stripname_result"
11091 func_append newdependency_libs " -R$func_replace_sysroot_result"
11093 *) func_append newdependency_libs " $deplib" ;;
11096 dependency_libs=$newdependency_libs
11099 for lib in $dlfiles; do
11102 func_basename "$lib"
11103 name=$func_basename_result
11104 eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
11105 test -z "$libdir" && \
11106 func_fatal_error "'$lib' is not a valid libtool archive"
11107 func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
11109 *) func_append newdlfiles " $lib" ;;
11112 dlfiles=$newdlfiles
11114 for lib in $dlprefiles; do
11117 # Only pass preopened files to the pseudo-archive (for
11118 # eventual linking with the app. that links it) if we
11119 # didn't already link the preopened objects directly into
11121 func_basename "$lib"
11122 name=$func_basename_result
11123 eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
11124 test -z "$libdir" && \
11125 func_fatal_error "'$lib' is not a valid libtool archive"
11126 func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
11130 dlprefiles=$newdlprefiles
11133 for lib in $dlfiles; do
11135 [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
11136 *) abs=`pwd`"/$lib" ;;
11138 func_append newdlfiles " $abs"
11140 dlfiles=$newdlfiles
11142 for lib in $dlprefiles; do
11144 [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
11145 *) abs=`pwd`"/$lib" ;;
11147 func_append newdlprefiles " $abs"
11149 dlprefiles=$newdlprefiles
11152 # place dlname in correct position for cygwin
11153 # In fact, it would be nice if we could use this code for all target
11154 # systems that can't hard-code library paths into their executables
11155 # and that have no shared library path variable independent of PATH,
11156 # but it turns out we can't easily determine that from inspecting
11157 # libtool variables, so we have to hard-code the OSs to which it
11158 # applies here; at the moment, that means platforms that use the PE
11159 # object format with DLL files. See the long comment at the top of
11160 # tests/bindir.at for full details.
11162 case $host,$output,$installed,$module,$dlname in
11163 *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
11164 # If a -bindir argument was supplied, place the dll there.
11165 if test -n "$bindir"; then
11166 func_relative_path "$install_libdir" "$bindir"
11167 tdlname=$func_relative_path_result/$dlname
11169 # Otherwise fall back on heuristic.
11170 tdlname=../bin/$dlname
11175 # $outputname - a libtool library file
11176 # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
11178 # Please DO NOT delete this file!
11179 # It is necessary for linking the library.
11181 # The name that we can dlopen(3).
11184 # Names of this library.
11185 library_names='$library_names'
11187 # The name of the static archive.
11188 old_library='$old_library'
11190 # Linker flags that cannot go in dependency_libs.
11191 inherited_linker_flags='$new_inherited_linker_flags'
11193 # Libraries that this one depends upon.
11194 dependency_libs='$dependency_libs'
11196 # Names of additional weak libraries provided by this library
11197 weak_library_names='$weak_libs'
11199 # Version information for $libname.
11204 # Is this an already installed library?
11205 installed=$installed
11207 # Should we warn about portability when linking against -modules?
11208 shouldnotlink=$module
11210 # Files to dlopen/dlpreopen
11212 dlpreopen='$dlprefiles'
11214 # Directory that this library needs to be installed in:
11215 libdir='$install_libdir'"
11216 if test no,yes = "$installed,$need_relink"; then
11217 $ECHO >> $output "\
11218 relink_command=\"$relink_command\""
11223 # Do a symbolic link so that the libtool archive can be found in
11224 # LD_LIBRARY_PATH before the program is installed.
11225 func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
11231 if test link = "$opt_mode" || test relink = "$opt_mode"; then
11232 func_mode_link ${1+"$@"}
11236 # func_mode_uninstall arg...
11237 func_mode_uninstall ()
11246 # This variable tells wrapper scripts just to set variables rather
11247 # than running their programs.
11248 libtool_install_magic=$magic
11253 -f) func_append RM " $arg"; rmforce=: ;;
11254 -*) func_append RM " $arg" ;;
11255 *) func_append files " $arg" ;;
11260 func_fatal_help "you must specify an RM program"
11264 for file in $files; do
11265 func_dirname "$file" "" "."
11266 dir=$func_dirname_result
11267 if test . = "$dir"; then
11272 func_basename "$file"
11273 name=$func_basename_result
11274 test uninstall = "$opt_mode" && odir=$dir
11276 # Remember odir for removal later, being careful to avoid duplicates
11277 if test clean = "$opt_mode"; then
11278 case " $rmdirs " in
11280 *) func_append rmdirs " $odir" ;;
11284 # Don't error if the file doesn't exist and rm -f was used.
11285 if { test -L "$file"; } >/dev/null 2>&1 ||
11286 { test -h "$file"; } >/dev/null 2>&1 ||
11287 test -f "$file"; then
11289 elif test -d "$file"; then
11292 elif $rmforce; then
11300 # Possibly a libtool archive, so verify it.
11301 if func_lalib_p "$file"; then
11302 func_source $dir/$name
11304 # Delete the libtool libraries and symlinks.
11305 for n in $library_names; do
11306 func_append rmfiles " $odir/$n"
11308 test -n "$old_library" && func_append rmfiles " $odir/$old_library"
11312 case " $library_names " in
11314 *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
11316 test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
11319 if test -n "$library_names"; then
11320 # Do each command in the postuninstall commands.
11321 func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
11324 if test -n "$old_library"; then
11325 # Do each command in the old_postuninstall commands.
11326 func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
11328 # FIXME: should reinstall the best remaining shared library.
11335 # Possibly a libtool object, so verify it.
11336 if func_lalib_p "$file"; then
11338 # Read the .lo file
11339 func_source $dir/$name
11341 # Add PIC object to the list of files to remove.
11342 if test -n "$pic_object" && test none != "$pic_object"; then
11343 func_append rmfiles " $dir/$pic_object"
11346 # Add non-PIC object to the list of files to remove.
11347 if test -n "$non_pic_object" && test none != "$non_pic_object"; then
11348 func_append rmfiles " $dir/$non_pic_object"
11354 if test clean = "$opt_mode"; then
11358 func_stripname '' '.exe' "$file"
11359 file=$func_stripname_result
11360 func_stripname '' '.exe' "$name"
11361 noexename=$func_stripname_result
11362 # $file with .exe has already been added to rmfiles,
11363 # add $file without .exe
11364 func_append rmfiles " $file"
11367 # Do a test to see if this is a libtool program.
11368 if func_ltwrapper_p "$file"; then
11369 if func_ltwrapper_executable_p "$file"; then
11370 func_ltwrapper_scriptname "$file"
11372 func_source $func_ltwrapper_scriptname_result
11373 func_append rmfiles " $func_ltwrapper_scriptname_result"
11376 func_source $dir/$noexename
11379 # note $name still contains .exe if it was in $file originally
11380 # as does the version of $file that was added into $rmfiles
11381 func_append rmfiles " $odir/$name $odir/${name}S.$objext"
11382 if test yes = "$fast_install" && test -n "$relink_command"; then
11383 func_append rmfiles " $odir/lt-$name"
11385 if test "X$noexename" != "X$name"; then
11386 func_append rmfiles " $odir/lt-$noexename.c"
11392 func_show_eval "$RM $rmfiles" 'exit_status=1'
11395 # Try to remove the $objdir's in the directories where we deleted files
11396 for dir in $rmdirs; do
11397 if test -d "$dir"; then
11398 func_show_eval "rmdir $dir >/dev/null 2>&1"
11405 if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
11406 func_mode_uninstall ${1+"$@"}
11409 test -z "$opt_mode" && {
11411 func_fatal_help "you must specify a MODE"
11414 test -z "$exec_cmd" && \
11415 func_fatal_help "invalid operation mode '$opt_mode'"
11417 if test -n "$exec_cmd"; then
11418 eval exec "$exec_cmd"
11425 # The TAGs below are defined such that we never get into a situation
11426 # where we disable both kinds of libraries. Given conflicting
11427 # choices, we go for a static library, that is the most portable,
11428 # since we can't tell whether shared libraries were disabled because
11429 # the user asked for that or because the platform doesn't support
11430 # them. This is particularly important on AIX, because we don't
11431 # support having both static and shared libraries enabled at the same
11432 # time on that platform, so we default to a shared-only configuration.
11433 # If a disable-shared tag is given, we'll fallback to a static-only
11434 # configuration. But we'll never go from static-only to shared-only.
11436 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
11437 build_libtool_libs=no
11439 # ### END LIBTOOL TAG CONFIG: disable-shared
11441 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
11442 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
11443 # ### END LIBTOOL TAG CONFIG: disable-static
11446 # mode:shell-script