#! /bin/sh ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in ## by inline-source v2014-01-03.01 # libtool (GNU libtool) 2.4.6 # Provide generalized library-building support services. # Written by Gordon Matzigkeit , 1996 # Copyright (C) 1996-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # GNU Libtool is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # As a special exception to the GNU General Public License, # if you distribute this file as part of a program or library that # is built using GNU Libtool, you may include this file under the # same distribution terms that you use for the rest of that program. # # GNU Libtool is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . setglobal PROGRAM = 'libtool' setglobal PACKAGE = 'libtool' setglobal VERSION = '"2.4.6 Debian-2.4.6-0.1'" setglobal package_revision = '2.4.6' ## ------ ## ## Usage. ## ## ------ ## # Run './libtool --help' for help with using this script from the # command line. ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # After configure completes, it has a better idea of some of the # shell tools we need than the defaults used by the functions shared # with bootstrap, so set those here where they can still be over- # ridden by the user, but otherwise take precedence. : $(AUTOCONF="autoconf") : $(AUTOMAKE="automake") ## -------------------------- ## ## Source external libraries. ## ## -------------------------- ## # Much of our low-level functionality needs to be sourced from external # libraries, which are installed to $pkgauxdir. # Set a version string for this script. setglobal scriptversion = '2015-01-20.17'; # UTC # General shell script boiler plate, and helper functions. # Written by Gary V. Vaughan, 2004 # Copyright (C) 2004-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # As a special exception to the GNU General Public License, if you distribute # this file as part of a program or library that is built using GNU Libtool, # you may include this file under the same distribution terms that you use # for the rest of that program. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # Evaluate this file near the top of your script to gain access to # the functions and variables defined here: # # . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh # # If you need to override any of the default environment variable # settings, do that before evaluating this file. ## -------------------- ## ## Shell normalisation. ## ## -------------------- ## # Some shells need a little help to be as Bourne compatible as possible. # Before doing anything else, make sure all that help has been provided! setglobal DUALCASE = '1'; export DUALCASE # for MKS sh if test -n $(ZSH_VERSION+set) && shell {emulate sh} >/dev/null 2>&1 { : emulate sh setglobal NULLCMD = ':' # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST } else { match $[shell {set -o}] { with *posix* set -o posix } } # NLS nuisances: We save the old values in case they are required later. setglobal _G_user_locale = '' setglobal _G_safe_locale = '' for _G_var in [LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES] { eval "if test set = \"\${$_G_var+set}\"; then save_$_G_var=\$$_G_var $_G_var=C export $_G_var _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\" _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\" fi" } # CDPATH. shell {unset CDPATH} >/dev/null 2>&1 && unset CDPATH # Make sure IFS has a sensible default setglobal sp = '' '' setglobal nl = '' '' setglobal IFS = ""$sp $nl"" # There are apparently some retarded systems that use ';' as a PATH separator! if test $(PATH_SEPARATOR+set) != set { setglobal PATH_SEPARATOR = ':' shell {setglobal PATH = ''/bin;/bin''; setglobal FPATH = $PATH; sh -c :} >/dev/null 2>&1 && do { shell {setglobal PATH = ''/bin:/bin''; setglobal FPATH = $PATH; sh -c :} >/dev/null 2>&1 || setglobal PATH_SEPARATOR = '';'' } } ## ------------------------- ## ## Locate command utilities. ## ## ------------------------- ## # func_executable_p FILE # ---------------------- # Check that FILE is an executable regular file. proc func_executable_p { test -f $1 && test -x $1 } # func_path_progs PROGS_LIST CHECK_FUNC [PATH] # -------------------------------------------- # Search for either a program that responds to --version with output # containing "GNU", or else returned by CHECK_FUNC otherwise, by # trying all the directories in PATH with each of the elements of # PROGS_LIST. # # CHECK_FUNC should accept the path to a candidate program, and # set $func_check_prog_result if it truncates its output less than # $_G_path_prog_max characters. proc func_path_progs { setglobal _G_progs_list = $1 setglobal _G_check_func = $2 setglobal _G_PATH = $(3-"$PATH") setglobal _G_path_prog_max = '0' setglobal _G_path_prog_found = 'false' setglobal _G_save_IFS = $IFS; setglobal IFS = $(PATH_SEPARATOR-:) for _G_dir in [$_G_PATH] { setglobal IFS = $_G_save_IFS test -z $_G_dir && setglobal _G_dir = '.' for _G_prog_name in [$_G_progs_list] { for _exeext in ['' .EXE] { setglobal _G_path_prog = "$_G_dir/$_G_prog_name$_exeext" func_executable_p $_G_path_prog || continue match $[$_G_path_prog --version !2 > !1] { with *GNU* setglobal func_path_progs_result = $_G_path_prog, _G_path_prog_found = ':' with * $_G_check_func $_G_path_prog setglobal func_path_progs_result = $func_check_prog_result } $_G_path_prog_found && break 3 } } } setglobal IFS = $_G_save_IFS test -z $func_path_progs_result && do { echo "no acceptable sed could be found in \$PATH" > !2 exit 1 } } # We want to be able to use the functions in this file before configure # has figured out where the best binaries are kept, which means we have # to search for them ourselves - except when the results are already set # where we skip the searches. # Unless the user overrides by setting SED, search the path for either GNU # sed, or the sed that truncates its output the least. test -z $SED && do { setglobal _G_sed_script = 's/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/' for _G_i in [1 2 3 4 5 6 7] { setglobal _G_sed_script = "$_G_sed_script$nl$_G_sed_script" } echo $_G_sed_script !2 >/dev/null | sed 99q >conftest.sed setglobal _G_sed_script = '' proc func_check_prog_sed { setglobal _G_path_prog = $1 setglobal _G_count = '0' printf 0123456789 >conftest.in while : { cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo '' >> conftest.nl $_G_path_prog -f conftest.sed conftest.out !2 >/dev/null || break diff conftest.out conftest.nl >/dev/null !2 > !1 || break setglobal _G_count = $[expr $_G_count + 1] if test $_G_count -gt $_G_path_prog_max { # Best one so far, save it but keep looking for a better one setglobal func_check_prog_result = $_G_path_prog setglobal _G_path_prog_max = $_G_count } # 10*(2^10) chars as input seems more than enough test 10 -lt $_G_count && break } rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin rm -f conftest.sed setglobal SED = $func_path_progs_result } # Unless the user overrides by setting GREP, search the path for either GNU # grep, or the grep that truncates its output the least. test -z $GREP && do { proc func_check_prog_grep { setglobal _G_path_prog = $1 setglobal _G_count = '0' setglobal _G_path_prog_max = '0' printf 0123456789 >conftest.in while : { cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo 'GREP' >> conftest.nl $_G_path_prog -e 'GREP$' -e '-(cannot match)-' conftest.out !2 >/dev/null || break diff conftest.out conftest.nl >/dev/null !2 > !1 || break setglobal _G_count = $[expr $_G_count + 1] if test $_G_count -gt $_G_path_prog_max { # Best one so far, save it but keep looking for a better one setglobal func_check_prog_result = $_G_path_prog setglobal _G_path_prog_max = $_G_count } # 10*(2^10) chars as input seems more than enough test 10 -lt $_G_count && break } rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin setglobal GREP = $func_path_progs_result } ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # All uppercase variable names are used for environment variables. These # variables can be overridden by the user before calling a script that # uses them if a suitable command of that name is not already available # in the command search PATH. : $(CP="cp -f") : $(ECHO="printf %s\n") : $(EGREP="$GREP -E") : $(FGREP="$GREP -F") : $(LN_S="ln -s") : $(MAKE="make") : $(MKDIR="mkdir") : $(MV="mv -f") : $(RM="rm -f") : $(SHELL="${CONFIG_SHELL-/bin/sh}") ## -------------------- ## ## Useful sed snippets. ## ## -------------------- ## setglobal sed_dirname = ''s|/[^/]*$||'' setglobal sed_basename = ''s|^.*/||'' # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. setglobal sed_quote_subst = ''s|\([`"$\\]\)|\\\1|g'' # Same as above, but do not quote variable references. setglobal sed_double_quote_subst = ''s/\(["`\\]\)/\\\1/g'' # Sed substitution that turns a string into a regex matching for the # string literally. setglobal sed_make_literal_regex = ''s|[].[^$\\*\/]|\\&|g'' # Sed substitution that converts a w32 file name or path # that contains forward slashes, into one that contains # (escaped) backslashes. A very naive implementation. setglobal sed_naive_backslashify = ''s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'' # Re-'\' parameter expansions in output of sed_double_quote_subst that # were '\'-ed in input to the same. If an odd number of '\' preceded a # '$' in input to sed_double_quote_subst, that '$' was protected from # expansion. Since each input '\' is now two '\'s, look for any number # of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'. setglobal _G_bs = ''\\'' setglobal _G_bs2 = ''\\\\'' setglobal _G_bs4 = ''\\\\\\\\'' setglobal _G_dollar = ''\$'' setglobal sed_double_backslash = ""\ s/$_G_bs4/&\\ /g s/^$_G_bs2$_G_dollar/$_G_bs&/ s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g s/\n//g"" ## ----------------- ## ## Global variables. ## ## ----------------- ## # Except for the global variables explicitly listed below, the following # functions in the '^func_' namespace, and the '^require_' namespace # variables initialised in the 'Resource management' section, sourcing # this file will not pollute your global namespace with anything # else. There's no portable way to scope variables in Bourne shell # though, so actually running these functions will sometimes place # results into a variable named after the function, and often use # temporary variables in the '^_G_' namespace. If you are careful to # avoid using those namespaces casually in your sourcing script, things # should continue to work as you expect. And, of course, you can freely # overwrite any of the functions or variables defined here before # calling anything to customize them. setglobal EXIT_SUCCESS = '0' setglobal EXIT_FAILURE = '1' setglobal EXIT_MISMATCH = '63' # $? = 63 is used to indicate version mismatch to missing. setglobal EXIT_SKIP = '77' # $? = 77 is used to indicate a skipped test to automake. # Allow overriding, eg assuming that you follow the convention of # putting '$debug_cmd' at the start of all your functions, you can get # bash to show function call trace with: # # debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name setglobal debug_cmd = $(debug_cmd-":") setglobal exit_cmd = ':' # By convention, finish your script with: # # exit $exit_status # # so that you can set exit_status to non-zero if you want to indicate # something went wrong during execution without actually bailing out at # the point of failure. setglobal exit_status = $EXIT_SUCCESS # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh # is ksh but when the shell is invoked as "sh" and the current value of # the _XPG environment variable is not equal to 1 (one), the special # positional parameter $0, within a function call, is the name of the # function. setglobal progpath = $0 # The name of this program. setglobal progname = $[$ECHO $progpath |$SED $sed_basename] # Make sure we have an absolute progpath for reexecution: match $progpath { with [\\/]*|[A-Za-z]:\\* with *[\\/]* setglobal progdir = $[$ECHO $progpath |$SED $sed_dirname] setglobal progdir = $[cd $progdir && pwd] setglobal progpath = "$progdir/$progname" with * setglobal _G_IFS = $IFS setglobal IFS = $(PATH_SEPARATOR-:) for progdir in [$PATH] { setglobal IFS = $_G_IFS test -x "$progdir/$progname" && break } setglobal IFS = $_G_IFS test -n $progdir || setglobal progdir = $[pwd] setglobal progpath = "$progdir/$progname" } ## ----------------- ## ## Standard options. ## ## ----------------- ## # The following options affect the operation of the functions defined # below, and should be set appropriately depending on run-time para- # meters passed on the command line. setglobal opt_dry_run = 'false' setglobal opt_quiet = 'false' setglobal opt_verbose = 'false' # Categories 'all' and 'none' are always available. Append any others # you will pass as the first argument to func_warning from your own # code. setglobal warning_categories = '' # By default, display warnings according to 'opt_warning_types'. Set # 'warning_func' to ':' to elide all warnings, or func_fatal_error to # treat the next displayed warning as a fatal error. setglobal warning_func = 'func_warn_and_continue' # Set to 'all' to display all warnings, 'none' to suppress all # warnings, or a space delimited list of some subset of # 'warning_categories' to display only the listed warnings. setglobal opt_warning_types = 'all' ## -------------------- ## ## Resource management. ## ## -------------------- ## # This section contains definitions for functions that each ensure a # particular resource (a file, or a non-empty configuration variable for # example) is available, and if appropriate to extract default values # from pertinent package files. Call them using their associated # 'require_*' variable to ensure that they are executed, at most, once. # # It's entirely deliberate that calling these functions can set # variables that don't obey the namespace limitations obeyed by the rest # of this file, in order that that they be as useful as possible to # callers. # require_term_colors # ------------------- # Allow display of bold text on terminals that support it. setglobal require_term_colors = 'func_require_term_colors' proc func_require_term_colors { $debug_cmd test -t 1 && do { # COLORTERM and USE_ANSI_COLORS environment variables take # precedence, because most terminfo databases neglect to describe # whether color sequences are supported. test -n $(COLORTERM+set) && : $(USE_ANSI_COLORS="1") if test 1 = $USE_ANSI_COLORS { # Standard ANSI escape sequences setglobal tc_reset = '''' setglobal tc_bold = ''''; setglobal tc_standout = '''' setglobal tc_red = ''''; setglobal tc_green = '''' setglobal tc_blue = ''''; setglobal tc_cyan = '''' } else { # Otherwise trust the terminfo database after all. test -n $[tput sgr0 !2 >/dev/null] && do { setglobal tc_reset = $[tput sgr0] test -n $[tput bold !2 >/dev/null] && setglobal tc_bold = $[tput bold] setglobal tc_standout = $tc_bold test -n $[tput smso !2 >/dev/null] && setglobal tc_standout = $[tput smso] test -n $[tput setaf 1 !2 >/dev/null] && setglobal tc_red = $[tput setaf 1] test -n $[tput setaf 2 !2 >/dev/null] && setglobal tc_green = $[tput setaf 2] test -n $[tput setaf 4 !2 >/dev/null] && setglobal tc_blue = $[tput setaf 4] test -n $[tput setaf 5 !2 >/dev/null] && setglobal tc_cyan = $[tput setaf 5] } } } setglobal require_term_colors = ':' } ## ----------------- ## ## Function library. ## ## ----------------- ## # This section contains a variety of useful functions to call in your # scripts. Take note of the portable wrappers for features provided by # some modern shells, which will fall back to slower equivalents on # less featureful shells. # func_append VAR VALUE # --------------------- # Append VALUE onto the existing contents of VAR. # We should try to minimise forks, especially on Windows where they are # unreasonably slow, so skip the feature probes when bash or zsh are # being used: if test set = "$(BASH_VERSION+set)$(ZSH_VERSION+set)" { : $(_G_HAVE_ARITH_OP="yes") : $(_G_HAVE_XSI_OPS="yes") # The += operator was introduced in bash 3.1 match $BASH_VERSION { with [12].* | 3.0 | 3.0* with * : $(_G_HAVE_PLUSEQ_OP="yes") } } # _G_HAVE_PLUSEQ_OP # Can be empty, in which case the shell is probed, "yes" if += is # useable or anything else if it does not work. test -z $_G_HAVE_PLUSEQ_OP \ && shell {eval 'x=a; x+=" b"; test "a b" = "$x"'} 2>/dev/null \ && setglobal _G_HAVE_PLUSEQ_OP = 'yes' if test yes = $_G_HAVE_PLUSEQ_OP { # This is an XSI compatible shell, allowing a faster implementation... eval 'func_append () { $debug_cmd eval "$1+=\$2" }' } else { # ...otherwise fall back to using expr, which is often a shell builtin. proc func_append { $debug_cmd eval "$1=\$$1\$2" } } # func_append_quoted VAR VALUE # ---------------------------- # Quote VALUE and append to the end of shell variable VAR, separated # by a space. if test yes = $_G_HAVE_PLUSEQ_OP { eval 'func_append_quoted () { $debug_cmd func_quote_for_eval "$2" eval "$1+=\\ \$func_quote_for_eval_result" }' } else { proc func_append_quoted { $debug_cmd func_quote_for_eval $2 eval "$1=\$$1\\ \$func_quote_for_eval_result" } } # func_append_uniq VAR VALUE # -------------------------- # Append unique VALUE onto the existing contents of VAR, assuming # entries are delimited by the first character of VALUE. For example: # # func_append_uniq options " --another-option option-argument" # # will only append to $options if " --another-option option-argument " # is not already present somewhere in $options already (note spaces at # each end implied by leading space in second argument). proc func_append_uniq { $debug_cmd eval _G_current_value='`$ECHO $'$1'`' setglobal _G_delim = $[expr $2 : '\(.\)] match $_G_delim$_G_current_value$_G_delim { with *"$2$_G_delim"* with * func_append @Argv } } # func_arith TERM... # ------------------ # Set func_arith_result to the result of evaluating TERMs. test -z $_G_HAVE_ARITH_OP \ && shell {eval 'test 2 = $(( 1 + 1 ))'} 2>/dev/null \ && setglobal _G_HAVE_ARITH_OP = 'yes' if test yes = $_G_HAVE_ARITH_OP { eval 'func_arith () { $debug_cmd func_arith_result=$(( $* )) }' } else { proc func_arith { $debug_cmd setglobal func_arith_result = $[expr @Argv] } } # func_basename FILE # ------------------ # Set func_basename_result to FILE with everything up to and including # the last / stripped. if test yes = $_G_HAVE_XSI_OPS { # If this shell supports suffix pattern removal, then use it to avoid # forking. Hide the definitions single quotes in case the shell chokes # on unsupported syntax... setglobal _b = ''func_basename_result=${1##*/}'' setglobal _d = ''case $1 in */*) func_dirname_result=${1%/*}$2 ;; * ) func_dirname_result=$3 ;; esac'' } else { # ...otherwise fall back to using sed. setglobal _b = ''func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'' setglobal _d = ''func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"` if test "X$func_dirname_result" = "X$1"; then func_dirname_result=$3 else func_append func_dirname_result "$2" fi'' } eval 'func_basename () { $debug_cmd '"$_b"' }' # func_dirname FILE APPEND NONDIR_REPLACEMENT # ------------------------------------------- # Compute the dirname of FILE. If nonempty, add APPEND to the result, # otherwise set result to NONDIR_REPLACEMENT. eval 'func_dirname () { $debug_cmd '"$_d"' }' # func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT # -------------------------------------------------------- # Perform func_basename and func_dirname in a single function # call: # dirname: Compute the dirname of FILE. If nonempty, # add APPEND to the result, otherwise set result # to NONDIR_REPLACEMENT. # value returned in "$func_dirname_result" # basename: Compute filename of FILE. # value retuned in "$func_basename_result" # For efficiency, we do not delegate to the functions above but instead # duplicate the functionality here. eval 'func_dirname_and_basename () { $debug_cmd '"$_b"' '"$_d"' }' # func_echo ARG... # ---------------- # Echo program name prefixed message. proc func_echo { $debug_cmd setglobal _G_message = $ifsjoin(Argv) setglobal func_echo_IFS = $IFS setglobal IFS = $nl for _G_line in [$_G_message] { setglobal IFS = $func_echo_IFS $ECHO "$progname: $_G_line" } setglobal IFS = $func_echo_IFS } # func_echo_all ARG... # -------------------- # Invoke $ECHO with all args, space-separated. proc func_echo_all { $ECHO "$ifsjoin(Argv)" } # func_echo_infix_1 INFIX ARG... # ------------------------------ # Echo program name, followed by INFIX on the first line, with any # additional lines not showing INFIX. proc func_echo_infix_1 { $debug_cmd $require_term_colors setglobal _G_infix = $1; shift setglobal _G_indent = $_G_infix setglobal _G_prefix = ""$progname: $_G_infix: "" setglobal _G_message = $ifsjoin(Argv) # Strip color escape sequences before counting printable length for _G_tc in [$tc_reset $tc_bold $tc_standout $tc_red $tc_green $tc_blue $tc_cyan] { test -n $_G_tc && do { setglobal _G_esc_tc = $[$ECHO $_G_tc | $SED $sed_make_literal_regex] setglobal _G_indent = $[$ECHO $_G_indent | $SED "s|$_G_esc_tc||g] } } setglobal _G_indent = ""$progname: "$[echo $_G_indent | $SED 's|.| |g]" "" ## exclude from sc_prohibit_nested_quotes setglobal func_echo_infix_1_IFS = $IFS setglobal IFS = $nl for _G_line in [$_G_message] { setglobal IFS = $func_echo_infix_1_IFS $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" > !2 setglobal _G_prefix = $_G_indent } setglobal IFS = $func_echo_infix_1_IFS } # func_error ARG... # ----------------- # Echo program name prefixed message to standard error. proc func_error { $debug_cmd $require_term_colors func_echo_infix_1 " $tc_standout$(tc_red)error$tc_reset" "$ifsjoin(Argv)" > !2 } # func_fatal_error ARG... # ----------------------- # Echo program name prefixed message to standard error, and exit. proc func_fatal_error { $debug_cmd func_error "$ifsjoin(Argv)" exit $EXIT_FAILURE } # func_grep EXPRESSION FILENAME # ----------------------------- # Check whether EXPRESSION matches any line of FILENAME, without output. proc func_grep { $debug_cmd $GREP $1 $2 >/dev/null !2 > !1 } # func_len STRING # --------------- # Set func_len_result to the length of STRING. STRING may not # start with a hyphen. test -z $_G_HAVE_XSI_OPS \ && shell {eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"'} 2>/dev/null \ && setglobal _G_HAVE_XSI_OPS = 'yes' if test yes = $_G_HAVE_XSI_OPS { eval 'func_len () { $debug_cmd func_len_result=${#1} }' } else { proc func_len { $debug_cmd setglobal func_len_result = $[expr $1 : ".*" !2 >/dev/null || echo $max_cmd_len] } } # func_mkdir_p DIRECTORY-PATH # --------------------------- # Make sure the entire path to DIRECTORY-PATH is available. proc func_mkdir_p { $debug_cmd setglobal _G_directory_path = $1 setglobal _G_dir_list = '' if test -n $_G_directory_path && test : != $opt_dry_run { # Protect directory names starting with '-' match $_G_directory_path { with -* setglobal _G_directory_path = "./$_G_directory_path" } # While some portion of DIR does not yet exist... while test ! -d $_G_directory_path { # ...make a list in topmost first order. Use a colon delimited # list incase some portion of path contains whitespace. setglobal _G_dir_list = "$_G_directory_path:$_G_dir_list" # If the last portion added has no slash in it, the list is done match $_G_directory_path { with */* with * break } # ...otherwise throw away the child directory and loop setglobal _G_directory_path = $[$ECHO $_G_directory_path | $SED -e $sed_dirname] } setglobal _G_dir_list = $[$ECHO $_G_dir_list | $SED 's|:*$||] setglobal func_mkdir_p_IFS = $IFS; setglobal IFS = ':' for _G_dir in [$_G_dir_list] { setglobal IFS = $func_mkdir_p_IFS # mkdir can fail with a 'File exist' error if two processes # try to create one of the directories concurrently. Don't # stop in that case! $MKDIR $_G_dir !2 >/dev/null || : } setglobal IFS = $func_mkdir_p_IFS # Bail out if we (or some other process) failed to create a directory. test -d $_G_directory_path || \ func_fatal_error "Failed to create '$1'" } } # func_mktempdir [BASENAME] # ------------------------- # Make a temporary directory that won't clash with other running # libtool processes, and avoids race conditions if possible. If # given, BASENAME is the basename for that directory. proc func_mktempdir { $debug_cmd setglobal _G_template = "$(TMPDIR-/tmp)/$(1-$progname)" if test : = $opt_dry_run { # Return a directory name, but don't create it in dry-run mode setglobal _G_tmpdir = "$_G_template-$Pid" } else { # If mktemp works, use that first and foremost setglobal _G_tmpdir = $[mktemp -d "$_G_template-XXXXXXXX" !2 >/dev/null] if test ! -d $_G_tmpdir { # Failing that, at least try and use $RANDOM to avoid a race setglobal _G_tmpdir = "$_G_template-$(RANDOM-0)$Pid" setglobal func_mktempdir_umask = $[umask] umask 0077 $MKDIR $_G_tmpdir umask $func_mktempdir_umask } # If we're not in dry-run mode, bomb out on failure test -d $_G_tmpdir || \ func_fatal_error "cannot create temporary directory '$_G_tmpdir'" } $ECHO $_G_tmpdir } # func_normal_abspath PATH # ------------------------ # Remove doubled-up and trailing slashes, "." path components, # and cancel out any ".." path components in PATH after making # it an absolute path. proc func_normal_abspath { $debug_cmd # These SED scripts presuppose an absolute path with a trailing slash. setglobal _G_pathcar = ''s|^/\([^/]*\).*$|\1|'' setglobal _G_pathcdr = ''s|^/[^/]*||'' setglobal _G_removedotparts = '':dotsl s|/\./|/|g t dotsl s|/\.$|/|'' setglobal _G_collapseslashes = ''s|/\{1,\}|/|g'' setglobal _G_finalslash = ''s|/*$|/|'' # Start from root dir and reassemble the path. setglobal func_normal_abspath_result = '' setglobal func_normal_abspath_tpath = $1 setglobal func_normal_abspath_altnamespace = '' match $func_normal_abspath_tpath { with "" # Empty path, that just means $cwd. func_stripname '' '/' $[pwd] setglobal func_normal_abspath_result = $func_stripname_result return # The next three entries are used to spot a run of precisely # two leading slashes without using negated character classes; # we take advantage of case's first-match behaviour. with ///* # Unusual form of absolute path, do nothing. with //* # Not necessarily an ordinary path; POSIX reserves leading '//' # and for example Cygwin uses it to access remote file shares # over CIFS/SMB, so we conserve a leading double slash if found. setglobal func_normal_abspath_altnamespace = '/' with /* # Absolute path, do nothing. with * # Relative path, prepend $cwd. setglobal func_normal_abspath_tpath = "$[pwd]/$func_normal_abspath_tpath" } # Cancel out all the simple stuff to save iterations. We also want # the path to end with a slash for ease of parsing, so make sure # there is one (and only one) here. setglobal func_normal_abspath_tpath = $[$ECHO $func_normal_abspath_tpath | $SED \ -e $_G_removedotparts -e $_G_collapseslashes -e $_G_finalslash] while : { # Processed it all yet? if test / = $func_normal_abspath_tpath { # If we ascended to the root using ".." the result may be empty now. if test -z $func_normal_abspath_result { setglobal func_normal_abspath_result = '/' } break } setglobal func_normal_abspath_tcomponent = $[$ECHO $func_normal_abspath_tpath | $SED \ -e $_G_pathcar] setglobal func_normal_abspath_tpath = $[$ECHO $func_normal_abspath_tpath | $SED \ -e $_G_pathcdr] # Figure out what to do with it match $func_normal_abspath_tcomponent { with "" # Trailing empty path component, ignore it. with .. # Parent dir; strip last assembled component from result. func_dirname $func_normal_abspath_result setglobal func_normal_abspath_result = $func_dirname_result with * # Actual path component, append it. func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent" } } # Restore leading double-slash if one was found on entry. setglobal func_normal_abspath_result = "$func_normal_abspath_altnamespace$func_normal_abspath_result" } # func_notquiet ARG... # -------------------- # Echo program name prefixed message only when not in quiet mode. proc func_notquiet { $debug_cmd $opt_quiet || func_echo $(1+"$@") # A bug in bash halts the script if the last line of a function # fails when set -e is in force, so we need another command to # work around that: : } # func_relative_path SRCDIR DSTDIR # -------------------------------- # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR. proc func_relative_path { $debug_cmd setglobal func_relative_path_result = '' func_normal_abspath $1 setglobal func_relative_path_tlibdir = $func_normal_abspath_result func_normal_abspath $2 setglobal func_relative_path_tbindir = $func_normal_abspath_result # Ascend the tree starting from libdir while : { # check if we have found a prefix of bindir match $func_relative_path_tbindir { with $func_relative_path_tlibdir # found an exact match setglobal func_relative_path_tcancelled = '' break with $func_relative_path_tlibdir* # found a matching prefix func_stripname $func_relative_path_tlibdir '' $func_relative_path_tbindir setglobal func_relative_path_tcancelled = $func_stripname_result if test -z $func_relative_path_result { setglobal func_relative_path_result = '.' } break with * func_dirname $func_relative_path_tlibdir setglobal func_relative_path_tlibdir = $func_dirname_result if test -z $func_relative_path_tlibdir { # Have to descend all the way to the root! setglobal func_relative_path_result = "../$func_relative_path_result" setglobal func_relative_path_tcancelled = $func_relative_path_tbindir break } setglobal func_relative_path_result = "../$func_relative_path_result" } } # Now calculate path; take care to avoid doubling-up slashes. func_stripname '' '/' $func_relative_path_result setglobal func_relative_path_result = $func_stripname_result func_stripname '/' '/' $func_relative_path_tcancelled if test -n $func_stripname_result { func_append func_relative_path_result "/$func_stripname_result" } # Normalisation. If bindir is libdir, return '.' else relative path. if test -n $func_relative_path_result { func_stripname './' '' $func_relative_path_result setglobal func_relative_path_result = $func_stripname_result } test -n $func_relative_path_result || setglobal func_relative_path_result = '.' : } # func_quote_for_eval ARG... # -------------------------- # Aesthetically quote ARGs to be evaled later. # This function returns two values: # i) func_quote_for_eval_result # double-quoted, suitable for a subsequent eval # ii) func_quote_for_eval_unquoted_result # has all characters that are still active within double # quotes backslashified. proc func_quote_for_eval { $debug_cmd setglobal func_quote_for_eval_unquoted_result = '' setglobal func_quote_for_eval_result = '' while test 0 -lt $Argc { match $1 { with *[\\\`\"\$]* setglobal _G_unquoted_arg = $[printf '%s\n' $1 |$SED $sed_quote_subst] with * setglobal _G_unquoted_arg = $1 } if test -n $func_quote_for_eval_unquoted_result { func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg" } else { func_append func_quote_for_eval_unquoted_result $_G_unquoted_arg } match $_G_unquoted_arg { # Double-quote args containing shell metacharacters to delay # word splitting, command substitution and variable expansion # for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. with *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"" setglobal _G_quoted_arg = "'"'$_G_unquoted_arg'"'" with * setglobal _G_quoted_arg = $_G_unquoted_arg } if test -n $func_quote_for_eval_result { func_append func_quote_for_eval_result " $_G_quoted_arg" } else { func_append func_quote_for_eval_result $_G_quoted_arg } shift } } # func_quote_for_expand ARG # ------------------------- # Aesthetically quote ARG to be evaled later; same as above, # but do not quote variable references. proc func_quote_for_expand { $debug_cmd match $1 { with *[\\\`\"]* setglobal _G_arg = $[$ECHO $1 | $SED \ -e $sed_double_quote_subst -e $sed_double_backslash] with * setglobal _G_arg = $1 } match $_G_arg { # Double-quote args containing shell metacharacters to delay # word splitting and command substitution for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. with *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"" setglobal _G_arg = "'"'$_G_arg'"'" } setglobal func_quote_for_expand_result = $_G_arg } # func_stripname PREFIX SUFFIX NAME # --------------------------------- # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result. # PREFIX and SUFFIX must not contain globbing or regex special # characters, hashes, percent signs, but SUFFIX may contain a leading # dot (in which case that matches only a dot). if test yes = $_G_HAVE_XSI_OPS { eval 'func_stripname () { $debug_cmd # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are # positional parameters, so assign one to ordinary variable first. func_stripname_result=$3 func_stripname_result=${func_stripname_result#"$1"} func_stripname_result=${func_stripname_result%"$2"} }' } else { proc func_stripname { $debug_cmd match $2 { with .* setglobal func_stripname_result = $[$ECHO $3 | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%] with * setglobal func_stripname_result = $[$ECHO $3 | $SED -e "s%^$1%%" -e "s%$2\$%%] } } } # func_show_eval CMD [FAIL_EXP] # ----------------------------- # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP # is given, then evaluate it. proc func_show_eval { $debug_cmd setglobal _G_cmd = $1 setglobal _G_fail_exp = $(2-':') func_quote_for_expand $_G_cmd eval "func_notquiet $func_quote_for_expand_result" $opt_dry_run || do { eval $_G_cmd setglobal _G_status = $Status if test 0 -ne $_G_status { eval "(exit $_G_status); $_G_fail_exp" } } } # func_show_eval_locale CMD [FAIL_EXP] # ------------------------------------ # Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is # not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP # is given, then evaluate it. Use the saved locale for evaluation. proc func_show_eval_locale { $debug_cmd setglobal _G_cmd = $1 setglobal _G_fail_exp = $(2-':') $opt_quiet || do { func_quote_for_expand $_G_cmd eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || do { eval "$_G_user_locale $_G_cmd" setglobal _G_status = $Status eval $_G_safe_locale if test 0 -ne $_G_status { eval "(exit $_G_status); $_G_fail_exp" } } } # func_tr_sh # ---------- # Turn $1 into a string suitable for a shell variable name. # Result is stored in $func_tr_sh_result. All characters # not in the set a-zA-Z0-9_ are replaced with '_'. Further, # if $1 begins with a digit, a '_' is prepended as well. proc func_tr_sh { $debug_cmd match $1 { with [0-9]* | *[!a-zA-Z0-9_]* setglobal func_tr_sh_result = $[$ECHO $1 | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g] with * setglobal func_tr_sh_result = $1 } } # func_verbose ARG... # ------------------- # Echo program name prefixed message in verbose mode only. proc func_verbose { $debug_cmd $opt_verbose && func_echo "$ifsjoin(Argv)" : } # func_warn_and_continue ARG... # ----------------------------- # Echo program name prefixed warning message to standard error. proc func_warn_and_continue { $debug_cmd $require_term_colors func_echo_infix_1 "$(tc_red)warning$tc_reset" "$ifsjoin(Argv)" > !2 } # func_warning CATEGORY ARG... # ---------------------------- # Echo program name prefixed warning message to standard error. Warning # messages can be filtered according to CATEGORY, where this function # elides messages where CATEGORY is not listed in the global variable # 'opt_warning_types'. proc func_warning { $debug_cmd # CATEGORY must be in the warning_categories list! match " $warning_categories " { with *" $1 "* with * func_internal_error "invalid warning category '$1'" } setglobal _G_category = $1 shift match " $opt_warning_types " { with *" $_G_category "* $warning_func $(1+"$@") } } # func_sort_ver VER1 VER2 # ----------------------- # 'sort -V' is not generally available. # Note this deviates from the version comparison in automake # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a # but this should suffice as we won't be specifying old # version formats or redundant trailing .0 in bootstrap.conf. # If we did want full compatibility then we should probably # use m4_version_compare from autoconf. proc func_sort_ver { $debug_cmd printf '%s\n%s\n' $1 $2 \ | 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 } # func_lt_ver PREV CURR # --------------------- # Return true if PREV and CURR are in the correct order according to # func_sort_ver, otherwise false. Use it like this: # # func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..." proc func_lt_ver { $debug_cmd test "x$1" = x$[func_sort_ver $1 $2 | $SED 1q] } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: #! /bin/sh # Set a version string for this script. setglobal scriptversion = '2014-01-07.03'; # UTC # A portable, pluggable option parser for Bourne shell. # Written by Gary V. Vaughan, 2010 # Copyright (C) 2010-2015 Free Software Foundation, Inc. # This is free software; see the source for copying conditions. There is NO # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # This file is a library for parsing options in your shell scripts along # with assorted other useful supporting features that you can make use # of too. # # For the simplest scripts you might need only: # # #!/bin/sh # . relative/path/to/funclib.sh # . relative/path/to/options-parser # scriptversion=1.0 # func_options ${1+"$@"} # eval set dummy "$func_options_result"; shift # ...rest of your script... # # In order for the '--version' option to work, you will need to have a # suitably formatted comment like the one at the top of this file # starting with '# Written by ' and ending with '# warranty; '. # # For '-h' and '--help' to work, you will also need a one line # description of your script's purpose in a comment directly above the # '# Written by ' line, like the one at the top of this file. # # The default options also support '--debug', which will turn on shell # execution tracing (see the comment above debug_cmd below for another # use), and '--verbose' and the func_verbose function to allow your script # to display verbose messages only when your user has specified # '--verbose'. # # After sourcing this file, you can plug processing for additional # options by amending the variables from the 'Configuration' section # below, and following the instructions in the 'Option parsing' # section further down. ## -------------- ## ## Configuration. ## ## -------------- ## # You should override these variables in your script after sourcing this # file so that they reflect the customisations you have added to the # option parser. # The usage line for option parsing errors and the start of '-h' and # '--help' output messages. You can embed shell variables for delayed # expansion at the time the message is displayed, but you will need to # quote other shell meta-characters carefully to prevent them being # expanded when the contents are evaled. setglobal usage = ''$progpath [OPTION]...'' # Short help message in response to '-h' and '--help'. Add to this or # override it after sourcing this library to reflect the full set of # options your script accepts. setglobal usage_message = '"\ --debug enable verbose shell tracing -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -v, --verbose verbosely report processing --version print version information and exit -h, --help print short or long help message and exit '" # Additional text appended to 'usage_message' in response to '--help'. setglobal long_help_message = '" Warning categories include: 'all' show all warnings 'none' turn off all the warnings 'error' warnings are treated as fatal errors'" # Help message printed before fatal option parsing errors. setglobal fatal_help = '"Try '\$progname --help' for more information.'" ## ------------------------- ## ## Hook function management. ## ## ------------------------- ## # This section contains functions for adding, removing, and running hooks # to the main code. A hook is just a named list of of function, that can # be run in order later on. # func_hookable FUNC_NAME # ----------------------- # Declare that FUNC_NAME will run hooks added with # 'func_add_hook FUNC_NAME ...'. proc func_hookable { $debug_cmd func_append hookable_fns " $1" } # func_add_hook FUNC_NAME HOOK_FUNC # --------------------------------- # Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must # first have been declared "hookable" by a call to 'func_hookable'. proc func_add_hook { $debug_cmd match " $hookable_fns " { with *" $1 "* with * func_fatal_error "'$1' does not accept hook functions." } eval func_append $(1)_hooks '" $2"' } # func_remove_hook FUNC_NAME HOOK_FUNC # ------------------------------------ # Remove HOOK_FUNC from the list of functions called by FUNC_NAME. proc func_remove_hook { $debug_cmd eval $(1)_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`' } # func_run_hooks FUNC_NAME [ARG]... # --------------------------------- # Run all hook functions registered to FUNC_NAME. # It is assumed that the list of hook functions contains nothing more # than a whitespace-delimited list of legal shell function names, and # no effort is wasted trying to catch shell meta-characters or preserve # whitespace. proc func_run_hooks { $debug_cmd match " $hookable_fns " { with *" $1 "* with * func_fatal_error "'$1' does not support hook funcions.n" } eval _G_hook_fns='$'$1_hooks; shift for _G_hook in [$_G_hook_fns] { eval $_G_hook '"$@"' # store returned options list back into positional # parameters for next 'cmd' execution. eval _G_hook_result='$'$(_G_hook)_result eval set dummy $_G_hook_result; shift } func_quote_for_eval $(1+"$@") setglobal func_run_hooks_result = $func_quote_for_eval_result } ## --------------- ## ## Option parsing. ## ## --------------- ## # In order to add your own option parsing hooks, you must accept the # full positional parameter list in your hook function, remove any # options that you action, and then pass back the remaining unprocessed # options in '_result', escaped suitably for # 'eval'. Like this: # # my_options_prep () # { # $debug_cmd # # # Extend the existing usage message. # usage_message=$usage_message' # -s, --silent don'\''t print informational messages # ' # # func_quote_for_eval ${1+"$@"} # my_options_prep_result=$func_quote_for_eval_result # } # func_add_hook func_options_prep my_options_prep # # # my_silent_option () # { # $debug_cmd # # # Note that for efficiency, we parse as many options as we can # # recognise in a loop before passing the remainder back to the # # caller on the first unrecognised argument we encounter. # while test $# -gt 0; do # opt=$1; shift # case $opt in # --silent|-s) opt_silent=: ;; # # Separate non-argument short options: # -s*) func_split_short_opt "$_G_opt" # set dummy "$func_split_short_opt_name" \ # "-$func_split_short_opt_arg" ${1+"$@"} # shift # ;; # *) set dummy "$_G_opt" "$*"; shift; break ;; # esac # done # # func_quote_for_eval ${1+"$@"} # my_silent_option_result=$func_quote_for_eval_result # } # func_add_hook func_parse_options my_silent_option # # # my_option_validation () # { # $debug_cmd # # $opt_silent && $opt_verbose && func_fatal_help "\ # '--silent' and '--verbose' options are mutually exclusive." # # func_quote_for_eval ${1+"$@"} # my_option_validation_result=$func_quote_for_eval_result # } # func_add_hook func_validate_options my_option_validation # # You'll alse need to manually amend $usage_message to reflect the extra # options you parse. It's preferable to append if you can, so that # multiple option parsing hooks can be added safely. # func_options [ARG]... # --------------------- # All the functions called inside func_options are hookable. See the # individual implementations for details. func_hookable func_options proc func_options { $debug_cmd func_options_prep $(1+"$@") eval func_parse_options \ $(func_options_prep_result+"$func_options_prep_result") eval func_validate_options \ $(func_parse_options_result+"$func_parse_options_result") eval func_run_hooks func_options \ $(func_validate_options_result+"$func_validate_options_result") # save modified positional parameters for caller setglobal func_options_result = $func_run_hooks_result } # func_options_prep [ARG]... # -------------------------- # All initialisations required before starting the option parse loop. # Note that when calling hook functions, we pass through the list of # positional parameters. If a hook function modifies that list, and # needs to propogate that back to rest of this script, then the complete # modified list must be put in 'func_run_hooks_result' before # returning. func_hookable func_options_prep proc func_options_prep { $debug_cmd # Option defaults: setglobal opt_verbose = 'false' setglobal opt_warning_types = '' func_run_hooks func_options_prep $(1+"$@") # save modified positional parameters for caller setglobal func_options_prep_result = $func_run_hooks_result } # func_parse_options [ARG]... # --------------------------- # The main option parsing loop. func_hookable func_parse_options proc func_parse_options { $debug_cmd setglobal func_parse_options_result = '' # this just eases exit handling while test $Argc -gt 0 { # Defer to hook functions for initial option parsing, so they # get priority in the event of reusing an option name. func_run_hooks func_parse_options $(1+"$@") # Adjust func_parse_options positional parameters to match eval set dummy $func_run_hooks_result; shift # Break out of the loop if we already parsed every option. test $Argc -gt 0 || break setglobal _G_opt = $1 shift match $_G_opt { with --debug|-x setglobal debug_cmd = ''set -x'' func_echo "enabling shell trace mode" $debug_cmd with --no-warnings|--no-warning|--no-warn set dummy --warnings none $(1+"$@") shift with --warnings|--warning|-W test $Argc = 0 && func_missing_arg $_G_opt && break match " $warning_categories $1" { with *" $1 "* # trailing space prevents matching last $1 above func_append_uniq opt_warning_types " $1" with *all setglobal opt_warning_types = $warning_categories with *none setglobal opt_warning_types = 'none' setglobal warning_func = ':' with *error setglobal opt_warning_types = $warning_categories setglobal warning_func = 'func_fatal_error' with * func_fatal_error \ "unsupported warning category: '$1'" } shift with --verbose|-v setglobal opt_verbose = ':' with --version func_version with -\?|-h func_usage with --help func_help # Separate optargs to long options (plugins may need this): with --*=* func_split_equals $_G_opt set dummy $func_split_equals_lhs \ $func_split_equals_rhs $(1+"$@") shift # Separate optargs to short options: with -W* func_split_short_opt $_G_opt set dummy $func_split_short_opt_name \ $func_split_short_opt_arg $(1+"$@") shift # Separate non-argument short options: with -\?*|-h*|-v*|-x* func_split_short_opt $_G_opt set dummy $func_split_short_opt_name \ "-$func_split_short_opt_arg" $(1+"$@") shift with -- break with -* func_fatal_help "unrecognised option: '$_G_opt'" with * set dummy $_G_opt $(1+"$@"); shift; break } } # save modified positional parameters for caller func_quote_for_eval $(1+"$@") setglobal func_parse_options_result = $func_quote_for_eval_result } # func_validate_options [ARG]... # ------------------------------ # Perform any sanity checks on option settings and/or unconsumed # arguments. func_hookable func_validate_options proc func_validate_options { $debug_cmd # Display all warnings if -W was not given. test -n $opt_warning_types || setglobal opt_warning_types = "" $warning_categories"" func_run_hooks func_validate_options $(1+"$@") # Bail if the options were screwed! $exit_cmd $EXIT_FAILURE # save modified positional parameters for caller setglobal func_validate_options_result = $func_run_hooks_result } ## ----------------- ## ## Helper functions. ## ## ----------------- ## # This section contains the helper functions used by the rest of the # hookable option parser framework in ascii-betical order. # func_fatal_help ARG... # ---------------------- # Echo program name prefixed message to standard error, followed by # a help hint, and exit. proc func_fatal_help { $debug_cmd eval '$'ECHO '"'"Usage: $usage"'"' eval '$'ECHO '"'"$fatal_help"'"' func_error $(1+"$@") exit $EXIT_FAILURE } # func_help # --------- # Echo long help message to standard output and exit. proc func_help { $debug_cmd func_usage_message $ECHO $long_help_message exit 0 } # func_missing_arg ARGNAME # ------------------------ # Echo program name prefixed message to standard error and set global # exit_cmd. proc func_missing_arg { $debug_cmd func_error "Missing argument for '$1'." setglobal exit_cmd = 'exit' } # func_split_equals STRING # ------------------------ # Set func_split_equals_lhs and func_split_equals_rhs shell variables after # splitting STRING at the '=' sign. test -z $_G_HAVE_XSI_OPS \ && shell {eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"'} 2>/dev/null \ && setglobal _G_HAVE_XSI_OPS = 'yes' if test yes = $_G_HAVE_XSI_OPS { # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_equals () { $debug_cmd func_split_equals_lhs=${1%%=*} func_split_equals_rhs=${1#*=} test "x$func_split_equals_lhs" = "x$1" \ && func_split_equals_rhs= }' } else { # ...otherwise fall back to using expr, which is often a shell builtin. proc func_split_equals { $debug_cmd setglobal func_split_equals_lhs = $[expr "x$1" : 'x\([^=]*\)] setglobal func_split_equals_rhs = '' test "x$func_split_equals_lhs" = "x$1" \ || setglobal func_split_equals_rhs = $[expr "x$1" : 'x[^=]*=\(.*\)$] } } #func_split_equals # func_split_short_opt SHORTOPT # ----------------------------- # Set func_split_short_opt_name and func_split_short_opt_arg shell # variables after splitting SHORTOPT after the 2nd character. if test yes = $_G_HAVE_XSI_OPS { # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_short_opt () { $debug_cmd func_split_short_opt_arg=${1#??} func_split_short_opt_name=${1%"$func_split_short_opt_arg"} }' } else { # ...otherwise fall back to using expr, which is often a shell builtin. proc func_split_short_opt { $debug_cmd setglobal func_split_short_opt_name = $[expr "x$1" : 'x-\(.\)] setglobal func_split_short_opt_arg = $[expr "x$1" : 'x-.\(.*\)$] } } #func_split_short_opt # func_usage # ---------- # Echo short help message to standard output and exit. proc func_usage { $debug_cmd func_usage_message $ECHO "Run '$progname --help |$(PAGER-more)' for full usage" exit 0 } # func_usage_message # ------------------ # Echo short help message to standard output. proc func_usage_message { $debug_cmd eval '$'ECHO '"'"Usage: $usage"'"' echo $SED -n 's|^# || /^Written by/{ x;p;x } h /^Written by/q' < $progpath echo eval '$'ECHO '"'"$usage_message"'"' } # func_version # ------------ # Echo version message to standard output and exit. proc func_version { $debug_cmd printf '%s\n' "$progname $scriptversion" $SED -n ' /(C)/!b go :more /\./!{ N s|\n# | | b more } :go /^# Written by /,/# warranty; / { s|^# || s|^# *$|| s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2| p } /^# Written by / { s|^# || p } /^warranty; /q' < $progpath exit $? } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: # Set a version string. setglobal scriptversion = ''(GNU libtool) 2.4.6'' # func_echo ARG... # ---------------- # Libtool also displays the current mode in messages, so override # funclib.sh func_echo with this custom definition. proc func_echo { $debug_cmd setglobal _G_message = $ifsjoin(Argv) setglobal func_echo_IFS = $IFS setglobal IFS = $nl for _G_line in [$_G_message] { setglobal IFS = $func_echo_IFS $ECHO "$progname$(opt_mode+: $opt_mode): $_G_line" } setglobal IFS = $func_echo_IFS } # func_warning ARG... # ------------------- # Libtool warnings are not categorized, so override funclib.sh # func_warning with this simpler definition. proc func_warning { $debug_cmd $warning_func $(1+"$@") } ## ---------------- ## ## Options parsing. ## ## ---------------- ## # Hook in the functions to make sure our own options are parsed during # the option parsing loop. setglobal usage = ''$progpath [OPTION]... [MODE-ARG]...'' # Short help message in response to '-h'. setglobal usage_message = '"Options: --config show all configuration variables --debug enable verbose shell tracing -n, --dry-run display commands without modifying any files --features display basic configuration information and exit --mode=MODE use operation mode MODE --no-warnings equivalent to '-Wnone' --preserve-dup-deps don't remove duplicate dependency libraries --quiet, --silent don't print informational messages --tag=TAG use configuration variables from tag TAG -v, --verbose print more informational messages than default --version print version information -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -h, --help, --help-all print short, long, or detailed help message '" # Additional text appended to 'usage_message' in response to '--help'. proc func_help { $debug_cmd func_usage_message $ECHO "$long_help_message MODE must be one of the following: clean remove files from the build directory compile compile a source file into a libtool object execute automatically set library path, then run a program finish complete the installation of libtool libraries install install libraries or executables link create a library or an executable uninstall remove libraries from an installed directory MODE-ARGS vary depending on the MODE. When passed as first option, '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that. Try '$progname --help --mode=MODE' for a more detailed description of MODE. When reporting a bug, please describe a test case to reproduce it and include the following information: host-triplet: $host shell: $SHELL compiler: $LTCC compiler flags: $LTCFLAGS linker: $LD (gnu? $with_gnu_ld) version: $progname (GNU libtool) 2.4.6 automake: $[shell {$AUTOMAKE --version} 2>/dev/null |$SED 1q] autoconf: $[shell {$AUTOCONF --version} 2>/dev/null |$SED 1q] Report bugs to . GNU libtool home page: . General help using GNU software: ." exit 0 } # func_lo2o OBJECT-NAME # --------------------- # Transform OBJECT-NAME from a '.lo' suffix to the platform specific # object suffix. setglobal lo2o = "s/'\'.lo'$'/.$objext/" setglobal o2lo = "s/'\'.$objext'$'/.lo/" if test yes = $_G_HAVE_XSI_OPS { eval 'func_lo2o () { case $1 in *.lo) func_lo2o_result=${1%.lo}.$objext ;; * ) func_lo2o_result=$1 ;; esac }' # func_xform LIBOBJ-OR-SOURCE # --------------------------- # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise) # suffix to a '.lo' libtool-object suffix. eval 'func_xform () { func_xform_result=${1%.*}.lo }' } else { # ...otherwise fall back to using sed. proc func_lo2o { setglobal func_lo2o_result = $[$ECHO $1 | $SED $lo2o] } proc func_xform { setglobal func_xform_result = $[$ECHO $1 | $SED 's|\.[^.]*$|.lo|] } } # func_fatal_configuration ARG... # ------------------------------- # Echo program name prefixed message to standard error, followed by # a configuration failure hint, and exit. proc func_fatal_configuration { func__fatal_error $(1+"$@") \ "See the $PACKAGE documentation for more information." \ "Fatal configuration error." } # func_config # ----------- # Display the configuration for all the tags in this script. proc func_config { setglobal re_begincf = ''^# ### BEGIN LIBTOOL'' setglobal re_endcf = ''^# ### END LIBTOOL'' # Default configuration. $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < $progpath # Now print the configurations for the tags. for tagname in [$taglist] { $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < $progpath } exit $? } # func_features # ------------- # Display the features supported by this script. proc func_features { echo "host: $host" if test yes = $build_libtool_libs { echo "enable shared libraries" } else { echo "disable shared libraries" } if test yes = $build_old_libs { echo "enable static libraries" } else { echo "disable static libraries" } exit $? } # func_enable_tag TAGNAME # ----------------------- # Verify that TAGNAME is valid, and either flag an error and exit, or # enable the TAGNAME tag. We also add TAGNAME to the global $taglist # variable here. proc func_enable_tag { # Global variable: setglobal tagname = $1 setglobal re_begincf = ""^# ### BEGIN LIBTOOL TAG CONFIG: $tagname"\$" setglobal re_endcf = ""^# ### END LIBTOOL TAG CONFIG: $tagname"\$" setglobal sed_extractcf = "/$re_begincf/,/$re_endcf/p" # Validate tagname. match $tagname { with *[!-_A-Za-z0-9,/]* func_fatal_error "invalid tag name: $tagname" } # Don't test for the "default" C tag, as we know it's # there but not specially marked. match $tagname { with CC with * if $GREP $re_begincf $progpath >/dev/null !2 > !1 { setglobal taglist = ""$taglist $tagname"" # Evaluate the configuration. Be careful to quote the path # and the sed script, to avoid splitting on whitespace, but # also don't use non-portable quotes within backquotes within # quotes we have to do it in 2 steps: setglobal extractedcf = $[$SED -n -e $sed_extractcf < $progpath] eval $extractedcf } else { func_error "ignoring unknown tag $tagname" } } } # func_check_version_match # ------------------------ # Ensure that we are using m4 macros, and libtool script from the same # release of libtool. proc func_check_version_match { if test $package_revision != $macro_revision { if test $VERSION != $macro_version { if test -z $macro_version { cat > !2 << """ $progname: Version mismatch error. This is $PACKAGE $VERSION, but the $progname: definition of this LT_INIT comes from an older release. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION $progname: and run autoconf again. """ } else { cat > !2 << """ $progname: Version mismatch error. This is $PACKAGE $VERSION, but the $progname: definition of this LT_INIT comes from $PACKAGE $macro_version. $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION $progname: and run autoconf again. """ } } else { cat > !2 << """ $progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, $progname: but the definition of this LT_INIT comes from revision $macro_revision. $progname: You should recreate aclocal.m4 with macros from revision $package_revision $progname: of $PACKAGE $VERSION and run autoconf again. """ } exit $EXIT_MISMATCH } } # libtool_options_prep [ARG]... # ----------------------------- # Preparation for options parsed by libtool. proc libtool_options_prep { $debug_mode # Option defaults: setglobal opt_config = 'false' setglobal opt_dlopen = '' setglobal opt_dry_run = 'false' setglobal opt_help = 'false' setglobal opt_mode = '' setglobal opt_preserve_dup_deps = 'false' setglobal opt_quiet = 'false' setglobal nonopt = '' setglobal preserve_args = '' # Shorthand for --mode=foo, only valid as the first argument match $1 { with clean|clea|cle|cl shift; set dummy --mode clean $(1+"$@"); shift with compile|compil|compi|comp|com|co|c shift; set dummy --mode compile $(1+"$@"); shift with execute|execut|execu|exec|exe|ex|e shift; set dummy --mode execute $(1+"$@"); shift with finish|finis|fini|fin|fi|f shift; set dummy --mode finish $(1+"$@"); shift with install|instal|insta|inst|ins|in|i shift; set dummy --mode install $(1+"$@"); shift with link|lin|li|l shift; set dummy --mode link $(1+"$@"); shift with uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u shift; set dummy --mode uninstall $(1+"$@"); shift } # Pass back the list of options. func_quote_for_eval $(1+"$@") setglobal libtool_options_prep_result = $func_quote_for_eval_result } func_add_hook func_options_prep libtool_options_prep # libtool_parse_options [ARG]... # --------------------------------- # Provide handling for libtool specific options. proc libtool_parse_options { $debug_cmd # Perform our own loop to consume as many options as possible in # each iteration. while test $Argc -gt 0 { setglobal _G_opt = $1 shift match $_G_opt { with --dry-run|--dryrun|-n setglobal opt_dry_run = ':' with --config func_config with --dlopen|-dlopen setglobal opt_dlopen = ""$(opt_dlopen+$opt_dlopen )$1"" shift with --preserve-dup-deps setglobal opt_preserve_dup_deps = ':' with --features func_features with --finish set dummy --mode finish $(1+"$@"); shift with --help setglobal opt_help = ':' with --help-all setglobal opt_help = '': help-all'' with --mode test $Argc = 0 && func_missing_arg $_G_opt && break setglobal opt_mode = $1 match $1 { # Valid mode arguments: with clean|compile|execute|finish|install|link|relink|uninstall # Catch anything else as an error with * func_error "invalid argument for $_G_opt" setglobal exit_cmd = 'exit' break } shift with --no-silent|--no-quiet setglobal opt_quiet = 'false' func_append preserve_args " $_G_opt" with --no-warnings|--no-warning|--no-warn setglobal opt_warning = 'false' func_append preserve_args " $_G_opt" with --no-verbose setglobal opt_verbose = 'false' func_append preserve_args " $_G_opt" with --silent|--quiet setglobal opt_quiet = ':' setglobal opt_verbose = 'false' func_append preserve_args " $_G_opt" with --tag test $Argc = 0 && func_missing_arg $_G_opt && break setglobal opt_tag = $1 func_append preserve_args " $_G_opt $1" func_enable_tag $1 shift with --verbose|-v setglobal opt_quiet = 'false' setglobal opt_verbose = ':' func_append preserve_args " $_G_opt" # An option not handled by this hook function: with * set dummy $_G_opt $(1+"$@"); shift; break } } # save modified positional parameters for caller func_quote_for_eval $(1+"$@") setglobal libtool_parse_options_result = $func_quote_for_eval_result } func_add_hook func_parse_options libtool_parse_options # libtool_validate_options [ARG]... # --------------------------------- # Perform any sanity checks on option settings and/or unconsumed # arguments. proc libtool_validate_options { # save first non-option argument if test 0 -lt $Argc { setglobal nonopt = $1 shift } # preserve --debug test : = $debug_cmd || func_append preserve_args " --debug" match $host { # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452 # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788 with *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2* # don't eliminate duplications in $postdeps and $predeps setglobal opt_duplicate_compiler_generated_deps = ':' with * setglobal opt_duplicate_compiler_generated_deps = $opt_preserve_dup_deps } $opt_help || do { # Sanity checks first: func_check_version_match test yes != $build_libtool_libs \ && test yes != $build_old_libs \ && func_fatal_configuration "not configured to build any kind of library" # Darwin sucks eval std_shrext='"'$shrext_cmds'"' # Only execute mode is allowed to have -dlopen flags. if test -n $opt_dlopen && test execute != $opt_mode { func_error "unrecognized option '-dlopen'" $ECHO $help !1 > !2 exit $EXIT_FAILURE } # Change the help message to a mode-specific one. setglobal generic_help = $help setglobal help = ""Try '$progname --help --mode=$opt_mode' for more information."" } # Pass back the unparsed argument list func_quote_for_eval $(1+"$@") setglobal libtool_validate_options_result = $func_quote_for_eval_result } func_add_hook func_validate_options libtool_validate_options # Process options as early as possible so that --help and --version # can return quickly. func_options $(1+"$@") eval set dummy $func_options_result; shift ## ----------- ## ## Main. ## ## ----------- ## setglobal magic = ''%%%MAGIC variable%%%'' setglobal magic_exe = ''%%%MAGIC EXE variable%%%'' # Global variables. setglobal extracted_archives = '' setglobal extracted_serial = '0' # If this variable is set in any of the actions, the command in it # will be execed at the end. This prevents here-documents from being # left over by shells. setglobal exec_cmd = '' # A function that is used when there is no print builtin or printf. proc func_fallback_echo { eval 'cat <<_LTECHO_EOF $1 _LTECHO_EOF' } # func_generated_by_libtool # True iff stdin has been generated by Libtool. This function is only # a basic sanity check; it will hardly flush out determined imposters. proc func_generated_by_libtool_p { $GREP "^# Generated by .*$PACKAGE" > /dev/null !2 > !1 } # func_lalib_p file # True iff FILE is a libtool '.la' library or '.lo' object file. # This function is only a basic sanity check; it will hardly flush out # determined imposters. proc func_lalib_p { test -f $1 && $SED -e 4q $1 !2 >/dev/null | func_generated_by_libtool_p } # func_lalib_unsafe_p file # True iff FILE is a libtool '.la' library or '.lo' object file. # This function implements the same check as func_lalib_p without # resorting to external programs. To this end, it redirects stdin and # closes it afterwards, without saving the original file descriptor. # As a safety measure, use it only where a negative result would be # fatal anyway. Works if 'file' does not exist. proc func_lalib_unsafe_p { setglobal lalib_p = 'no' if test -f $1 && test -r $1 && exec !5 5<&0 <$1 { for lalib_p_l in [1 2 3 4] { read lalib_p_line match $lalib_p_line { with \#\ Generated\ by\ *$PACKAGE* setglobal lalib_p = 'yes'; break } } exec !0 0<&5 !5 5<&- } test yes = $lalib_p } # func_ltwrapper_script_p file # True iff FILE is a libtool wrapper script # This function is only a basic sanity check; it will hardly flush out # determined imposters. proc func_ltwrapper_script_p { test -f $1 && $lt_truncate_bin < $1 !2 >/dev/null | func_generated_by_libtool_p } # func_ltwrapper_executable_p file # True iff FILE is a libtool wrapper executable # This function is only a basic sanity check; it will hardly flush out # determined imposters. proc func_ltwrapper_executable_p { setglobal func_ltwrapper_exec_suffix = '' match $1 { with *.exe with * setglobal func_ltwrapper_exec_suffix = '.exe' } $GREP $magic_exe "$1$func_ltwrapper_exec_suffix" >/dev/null !2 > !1 } # func_ltwrapper_scriptname file # Assumes file is an ltwrapper_executable # uses $file to determine the appropriate filename for a # temporary ltwrapper_script. proc func_ltwrapper_scriptname { func_dirname_and_basename $1 "" "." func_stripname '' '.exe' $func_basename_result setglobal func_ltwrapper_scriptname_result = "$func_dirname_result/$objdir/$(func_stripname_result)_ltshwrapper" } # func_ltwrapper_p file # True iff FILE is a libtool wrapper script or wrapper executable # This function is only a basic sanity check; it will hardly flush out # determined imposters. proc func_ltwrapper_p { func_ltwrapper_script_p $1 || func_ltwrapper_executable_p $1 } # func_execute_cmds commands fail_cmd # Execute tilde-delimited COMMANDS. # If FAIL_CMD is given, eval that upon failure. # FAIL_CMD may read-access the current command in variable CMD! proc func_execute_cmds { $debug_cmd setglobal save_ifs = $IFS; setglobal IFS = ''~'' for cmd in [$1] { setglobal IFS = "$sp$nl" eval cmd='"'$cmd'"' setglobal IFS = $save_ifs func_show_eval $cmd $(2-:) } setglobal IFS = $save_ifs } # func_source file # Source FILE, adding directory component if necessary. # Note that it is not necessary on cygwin/mingw to append a dot to # FILE even if both FILE and FILE.exe exist: automatic-append-.exe # behavior happens only for exec(3), not for open(2)! Also, sourcing # 'FILE.' does not work on cygwin managed mounts. proc func_source { $debug_cmd match $1 { with */* | *\\* source "$1" with * source "./$1" } } # func_resolve_sysroot PATH # Replace a leading = in PATH with a sysroot. Store the result into # func_resolve_sysroot_result proc func_resolve_sysroot { setglobal func_resolve_sysroot_result = $1 match $func_resolve_sysroot_result { with =* func_stripname '=' '' $func_resolve_sysroot_result setglobal func_resolve_sysroot_result = "$lt_sysroot$func_stripname_result" } } # func_replace_sysroot PATH # If PATH begins with the sysroot, replace it with = and # store the result into func_replace_sysroot_result. proc func_replace_sysroot { match $lt_sysroot:$1 { with ?*:"$lt_sysroot"* func_stripname $lt_sysroot '' $1 setglobal func_replace_sysroot_result = "'='$func_stripname_result" with * # Including no sysroot. setglobal func_replace_sysroot_result = $1 } } # func_infer_tag arg # Infer tagged configuration to use if any are available and # if one wasn't chosen via the "--tag" command line option. # Only attempt this if the compiler in the base compile # command doesn't match the default compiler. # arg is usually of the form 'gcc ...' proc func_infer_tag { $debug_cmd if test -n $available_tags && test -z $tagname { setglobal CC_quoted = '' for arg in [$CC] { func_append_quoted CC_quoted $arg } setglobal CC_expanded = $[func_echo_all $CC] setglobal CC_quoted_expanded = $[func_echo_all $CC_quoted] match $ifsjoin(Argv) { # Blanks in the command may have been stripped by the calling shell, # but not from the CC environment variable when configure was run. with " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "* # Blanks at the start of $base_compile will cause this to fail # if we don't check for them as well. with * for z in [$available_tags] { if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < $progpath > /dev/null { # Evaluate the configuration. eval $[$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath] setglobal CC_quoted = '' for arg in [$CC] { # Double-quote args containing other shell metacharacters. func_append_quoted CC_quoted $arg } setglobal CC_expanded = $[func_echo_all $CC] setglobal CC_quoted_expanded = $[func_echo_all $CC_quoted] match "$ifsjoin(Argv) " { with " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "* # The compiler in the base compile command matches # the one in the tagged configuration. # Assume this is the tagged configuration we want. setglobal tagname = $z break } } } # If $tagname still isn't set, then no tagged configuration # was found and let the user know that the "--tag" command # line option must be used. if test -z $tagname { func_echo "unable to infer tagged configuration" func_fatal_error "specify a tag with '--tag'" # else # func_verbose "using $tagname tagged configuration" } } } } # func_write_libtool_object output_name pic_name nonpic_name # Create a libtool object file (analogous to a ".la" file), # but don't create it if we're doing a dry run. proc func_write_libtool_object { setglobal write_libobj = $1 if test yes = $build_libtool_libs { setglobal write_lobj = "'''$2'''" } else { setglobal write_lobj = 'none' } if test yes = $build_old_libs { setglobal write_oldobj = "'''$3'''" } else { setglobal write_oldobj = 'none' } $opt_dry_run || do { cat >$(write_libobj)T << """ # $write_libobj - a libtool object file # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # Please DO NOT delete this file! # It is necessary for linking the library. # Name of the PIC object. pic_object=$write_lobj # Name of the non-PIC object non_pic_object=$write_oldobj """ $MV "$(write_libobj)T" $write_libobj } } ################################################## # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS # ################################################## # func_convert_core_file_wine_to_w32 ARG # Helper function used by file name conversion functions when $build is *nix, # and $host is mingw, cygwin, or some other w32 environment. Relies on a # correctly configured wine environment available, with the winepath program # in $build's $PATH. # # ARG is the $build file name to be converted to w32 format. # Result is available in $func_convert_core_file_wine_to_w32_result, and will # be empty on error (or when ARG is empty) proc func_convert_core_file_wine_to_w32 { $debug_cmd setglobal func_convert_core_file_wine_to_w32_result = $1 if test -n $1 { # Unfortunately, winepath does not exit with a non-zero error code, so we # are forced to check the contents of stdout. On the other hand, if the # command is not found, the shell will set an exit code of 127 and print # *an error message* to stdout. So we must check for both error code of # zero AND non-empty stdout, which explains the odd construction: setglobal func_convert_core_file_wine_to_w32_tmp = $[winepath -w $1 !2 >/dev/null] if test "$Status" -eq 0 && test -n $func_convert_core_file_wine_to_w32_tmp { setglobal func_convert_core_file_wine_to_w32_result = $[$ECHO $func_convert_core_file_wine_to_w32_tmp | $SED -e $sed_naive_backslashify] } else { setglobal func_convert_core_file_wine_to_w32_result = '' } } } # end: func_convert_core_file_wine_to_w32 # func_convert_core_path_wine_to_w32 ARG # Helper function used by path conversion functions when $build is *nix, and # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly # configured wine environment available, with the winepath program in $build's # $PATH. Assumes ARG has no leading or trailing path separator characters. # # ARG is path to be converted from $build format to win32. # Result is available in $func_convert_core_path_wine_to_w32_result. # Unconvertible file (directory) names in ARG are skipped; if no directory names # are convertible, then the result may be empty. proc func_convert_core_path_wine_to_w32 { $debug_cmd # unfortunately, winepath doesn't convert paths, only file names setglobal func_convert_core_path_wine_to_w32_result = '' if test -n $1 { setglobal oldIFS = $IFS setglobal IFS = ':' for func_convert_core_path_wine_to_w32_f in [$1] { setglobal IFS = $oldIFS func_convert_core_file_wine_to_w32 $func_convert_core_path_wine_to_w32_f if test -n $func_convert_core_file_wine_to_w32_result { if test -z $func_convert_core_path_wine_to_w32_result { setglobal func_convert_core_path_wine_to_w32_result = $func_convert_core_file_wine_to_w32_result } else { func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" } } } setglobal IFS = $oldIFS } } # end: func_convert_core_path_wine_to_w32 # func_cygpath ARGS... # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or # (2), returns the Cygwin file name or path in func_cygpath_result (input # file name or path is assumed to be in w32 format, as previously converted # from $build's *nix or MSYS format). In case (3), returns the w32 file name # or path in func_cygpath_result (input file name or path is assumed to be in # Cygwin format). Returns an empty string on error. # # ARGS are passed to cygpath, with the last one being the file name or path to # be converted. # # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH # environment variable; do not put it in $PATH. proc func_cygpath { $debug_cmd if test -n $LT_CYGPATH && test -f $LT_CYGPATH { setglobal func_cygpath_result = $[$LT_CYGPATH @Argv !2 >/dev/null] if test "$Status" -ne 0 { # on failure, ensure result is empty setglobal func_cygpath_result = '' } } else { setglobal func_cygpath_result = '' func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'" } } #end: func_cygpath # func_convert_core_msys_to_w32 ARG # Convert file name or path ARG from MSYS format to w32 format. Return # result in func_convert_core_msys_to_w32_result. proc func_convert_core_msys_to_w32 { $debug_cmd # awkward: cmd appends spaces to result setglobal func_convert_core_msys_to_w32_result = $[shell { cmd //c echo $1 } 2>/dev/null | $SED -e 's/[ ]*$//' -e $sed_naive_backslashify] } #end: func_convert_core_msys_to_w32 # func_convert_file_check ARG1 ARG2 # Verify that ARG1 (a file name in $build format) was converted to $host # format in ARG2. Otherwise, emit an error message, but continue (resetting # func_to_host_file_result to ARG1). proc func_convert_file_check { $debug_cmd if test -z $2 && test -n $1 { func_error "Could not determine host file name corresponding to" func_error " '$1'" func_error "Continuing, but uninstalled executables may not work." # Fallback: setglobal func_to_host_file_result = $1 } } # end func_convert_file_check # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH # Verify that FROM_PATH (a path in $build format) was converted to $host # format in TO_PATH. Otherwise, emit an error message, but continue, resetting # func_to_host_file_result to a simplistic fallback value (see below). proc func_convert_path_check { $debug_cmd if test -z $4 && test -n $3 { func_error "Could not determine the host path corresponding to" func_error " '$3'" func_error "Continuing, but uninstalled executables may not work." # Fallback. This is a deliberately simplistic "conversion" and # should not be "improved". See libtool.info. if test "x$1" != "x$2" { setglobal lt_replace_pathsep_chars = ""s|$1|$2|g"" setglobal func_to_host_path_result = $[echo $3 | $SED -e $lt_replace_pathsep_chars] } else { setglobal func_to_host_path_result = $3 } } } # end func_convert_path_check # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT # and appending REPL if ORIG matches BACKPAT. proc func_convert_path_front_back_pathsep { $debug_cmd match $4 { with $1 setglobal func_to_host_path_result = "$3$func_to_host_path_result" } match $4 { with $2 func_append func_to_host_path_result $3 } } # end func_convert_path_front_back_pathsep ################################################## # $build to $host FILE NAME CONVERSION FUNCTIONS # ################################################## # invoked via '$to_host_file_cmd ARG' # # In each case, ARG is the path to be converted from $build to $host format. # Result will be available in $func_to_host_file_result. # func_to_host_file ARG # Converts the file name ARG from $build format to $host format. Return result # in func_to_host_file_result. proc func_to_host_file { $debug_cmd $to_host_file_cmd $1 } # end func_to_host_file # func_to_tool_file ARG LAZY # converts the file name ARG from $build format to toolchain format. Return # result in func_to_tool_file_result. If the conversion in use is listed # in (the comma separated) LAZY, no conversion takes place. proc func_to_tool_file { $debug_cmd match ,$2, { with *,"$to_tool_file_cmd",* setglobal func_to_tool_file_result = $1 with * $to_tool_file_cmd $1 setglobal func_to_tool_file_result = $func_to_host_file_result } } # end func_to_tool_file # func_convert_file_noop ARG # Copy ARG to func_to_host_file_result. proc func_convert_file_noop { setglobal func_to_host_file_result = $1 } # end func_convert_file_noop # func_convert_file_msys_to_w32 ARG # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic # conversion to w32 is not available inside the cwrapper. Returns result in # func_to_host_file_result. proc func_convert_file_msys_to_w32 { $debug_cmd setglobal func_to_host_file_result = $1 if test -n $1 { func_convert_core_msys_to_w32 $1 setglobal func_to_host_file_result = $func_convert_core_msys_to_w32_result } func_convert_file_check $1 $func_to_host_file_result } # end func_convert_file_msys_to_w32 # func_convert_file_cygwin_to_w32 ARG # Convert file name ARG from Cygwin to w32 format. Returns result in # func_to_host_file_result. proc func_convert_file_cygwin_to_w32 { $debug_cmd setglobal func_to_host_file_result = $1 if test -n $1 { # because $build is cygwin, we call "the" cygpath in $PATH; no need to use # LT_CYGPATH in this case. setglobal func_to_host_file_result = $[cygpath -m $1] } func_convert_file_check $1 $func_to_host_file_result } # end func_convert_file_cygwin_to_w32 # func_convert_file_nix_to_w32 ARG # Convert file name ARG from *nix to w32 format. Requires a wine environment # and a working winepath. Returns result in func_to_host_file_result. proc func_convert_file_nix_to_w32 { $debug_cmd setglobal func_to_host_file_result = $1 if test -n $1 { func_convert_core_file_wine_to_w32 $1 setglobal func_to_host_file_result = $func_convert_core_file_wine_to_w32_result } func_convert_file_check $1 $func_to_host_file_result } # end func_convert_file_nix_to_w32 # func_convert_file_msys_to_cygwin ARG # Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. # Returns result in func_to_host_file_result. proc func_convert_file_msys_to_cygwin { $debug_cmd setglobal func_to_host_file_result = $1 if test -n $1 { func_convert_core_msys_to_w32 $1 func_cygpath -u $func_convert_core_msys_to_w32_result setglobal func_to_host_file_result = $func_cygpath_result } func_convert_file_check $1 $func_to_host_file_result } # end func_convert_file_msys_to_cygwin # func_convert_file_nix_to_cygwin ARG # Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed # in a wine environment, working winepath, and LT_CYGPATH set. Returns result # in func_to_host_file_result. proc func_convert_file_nix_to_cygwin { $debug_cmd setglobal func_to_host_file_result = $1 if test -n $1 { # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. func_convert_core_file_wine_to_w32 $1 func_cygpath -u $func_convert_core_file_wine_to_w32_result setglobal func_to_host_file_result = $func_cygpath_result } func_convert_file_check $1 $func_to_host_file_result } # end func_convert_file_nix_to_cygwin ############################################# # $build to $host PATH CONVERSION FUNCTIONS # ############################################# # invoked via '$to_host_path_cmd ARG' # # In each case, ARG is the path to be converted from $build to $host format. # The result will be available in $func_to_host_path_result. # # Path separators are also converted from $build format to $host format. If # ARG begins or ends with a path separator character, it is preserved (but # converted to $host format) on output. # # All path conversion functions are named using the following convention: # file name conversion function : func_convert_file_X_to_Y () # path conversion function : func_convert_path_X_to_Y () # where, for any given $build/$host combination the 'X_to_Y' value is the # same. If conversion functions are added for new $build/$host combinations, # the two new functions must follow this pattern, or func_init_to_host_path_cmd # will break. # func_init_to_host_path_cmd # Ensures that function "pointer" variable $to_host_path_cmd is set to the # appropriate value, based on the value of $to_host_file_cmd. setglobal to_host_path_cmd = '' proc func_init_to_host_path_cmd { $debug_cmd if test -z $to_host_path_cmd { func_stripname 'func_convert_file_' '' $to_host_file_cmd setglobal to_host_path_cmd = "func_convert_path_$func_stripname_result" } } # func_to_host_path ARG # Converts the path ARG from $build format to $host format. Return result # in func_to_host_path_result. proc func_to_host_path { $debug_cmd func_init_to_host_path_cmd $to_host_path_cmd $1 } # end func_to_host_path # func_convert_path_noop ARG # Copy ARG to func_to_host_path_result. proc func_convert_path_noop { setglobal func_to_host_path_result = $1 } # end func_convert_path_noop # func_convert_path_msys_to_w32 ARG # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic # conversion to w32 is not available inside the cwrapper. Returns result in # func_to_host_path_result. proc func_convert_path_msys_to_w32 { $debug_cmd setglobal func_to_host_path_result = $1 if test -n $1 { # Remove leading and trailing path separator characters from ARG. MSYS # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; # and winepath ignores them completely. func_stripname : : $1 setglobal func_to_host_path_tmp1 = $func_stripname_result func_convert_core_msys_to_w32 $func_to_host_path_tmp1 setglobal func_to_host_path_result = $func_convert_core_msys_to_w32_result func_convert_path_check : ";" \ $func_to_host_path_tmp1 $func_to_host_path_result func_convert_path_front_back_pathsep ":*" "*:" ";" $1 } } # end func_convert_path_msys_to_w32 # func_convert_path_cygwin_to_w32 ARG # Convert path ARG from Cygwin to w32 format. Returns result in # func_to_host_file_result. proc func_convert_path_cygwin_to_w32 { $debug_cmd setglobal func_to_host_path_result = $1 if test -n $1 { # See func_convert_path_msys_to_w32: func_stripname : : $1 setglobal func_to_host_path_tmp1 = $func_stripname_result setglobal func_to_host_path_result = $[cygpath -m -p $func_to_host_path_tmp1] func_convert_path_check : ";" \ $func_to_host_path_tmp1 $func_to_host_path_result func_convert_path_front_back_pathsep ":*" "*:" ";" $1 } } # end func_convert_path_cygwin_to_w32 # func_convert_path_nix_to_w32 ARG # Convert path ARG from *nix to w32 format. Requires a wine environment and # a working winepath. Returns result in func_to_host_file_result. proc func_convert_path_nix_to_w32 { $debug_cmd setglobal func_to_host_path_result = $1 if test -n $1 { # See func_convert_path_msys_to_w32: func_stripname : : $1 setglobal func_to_host_path_tmp1 = $func_stripname_result func_convert_core_path_wine_to_w32 $func_to_host_path_tmp1 setglobal func_to_host_path_result = $func_convert_core_path_wine_to_w32_result func_convert_path_check : ";" \ $func_to_host_path_tmp1 $func_to_host_path_result func_convert_path_front_back_pathsep ":*" "*:" ";" $1 } } # end func_convert_path_nix_to_w32 # func_convert_path_msys_to_cygwin ARG # Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. # Returns result in func_to_host_file_result. proc func_convert_path_msys_to_cygwin { $debug_cmd setglobal func_to_host_path_result = $1 if test -n $1 { # See func_convert_path_msys_to_w32: func_stripname : : $1 setglobal func_to_host_path_tmp1 = $func_stripname_result func_convert_core_msys_to_w32 $func_to_host_path_tmp1 func_cygpath -u -p $func_convert_core_msys_to_w32_result setglobal func_to_host_path_result = $func_cygpath_result func_convert_path_check : : \ $func_to_host_path_tmp1 $func_to_host_path_result func_convert_path_front_back_pathsep ":*" "*:" : $1 } } # end func_convert_path_msys_to_cygwin # func_convert_path_nix_to_cygwin ARG # Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a # a wine environment, working winepath, and LT_CYGPATH set. Returns result in # func_to_host_file_result. proc func_convert_path_nix_to_cygwin { $debug_cmd setglobal func_to_host_path_result = $1 if test -n $1 { # Remove leading and trailing path separator characters from # ARG. msys behavior is inconsistent here, cygpath turns them # into '.;' and ';.', and winepath ignores them completely. func_stripname : : $1 setglobal func_to_host_path_tmp1 = $func_stripname_result func_convert_core_path_wine_to_w32 $func_to_host_path_tmp1 func_cygpath -u -p $func_convert_core_path_wine_to_w32_result setglobal func_to_host_path_result = $func_cygpath_result func_convert_path_check : : \ $func_to_host_path_tmp1 $func_to_host_path_result func_convert_path_front_back_pathsep ":*" "*:" : $1 } } # end func_convert_path_nix_to_cygwin # func_dll_def_p FILE # True iff FILE is a Windows DLL '.def' file. # Keep in sync with _LT_DLL_DEF_P in libtool.m4 proc func_dll_def_p { $debug_cmd setglobal func_dll_def_p_tmp = $[$SED -n \ -e 's/^[ ]*//' \ -e '/^\(;.*\)*$/d' \ -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \ -e q \ $1] test DEF = $func_dll_def_p_tmp } # func_mode_compile arg... proc func_mode_compile { $debug_cmd # Get the compilation command and the source file. setglobal base_compile = '' setglobal srcfile = $nonopt # always keep a non-empty value in "srcfile" setglobal suppress_opt = 'yes' setglobal suppress_output = '' setglobal arg_mode = 'normal' setglobal libobj = '' setglobal later = '' setglobal pie_flag = ''for arg in @Argv { match $arg_mode { with arg # do not "continue". Instead, add this to base_compile setglobal lastarg = $arg setglobal arg_mode = 'normal' with target setglobal libobj = $arg setglobal arg_mode = 'normal' continue with normal # Accept any command-line options. match $arg { with -o test -n $libobj && \ func_fatal_error "you cannot specify '-o' more than once" setglobal arg_mode = 'target' continue with -pie | -fpie | -fPIE func_append pie_flag " $arg" continue with -shared | -static | -prefer-pic | -prefer-non-pic func_append later " $arg" continue with -no-suppress setglobal suppress_opt = 'no' continue with -Xcompiler setglobal arg_mode = 'arg' # the next one goes into the "base_compile" arg list continue # The current "srcfile" will either be retained or # replaced later. I would guess that would be a bug. with -Wc,* func_stripname '-Wc,' '' $arg setglobal args = $func_stripname_result setglobal lastarg = '' setglobal save_ifs = $IFS; setglobal IFS = ',' for arg in [$args] { setglobal IFS = $save_ifs func_append_quoted lastarg $arg } setglobal IFS = $save_ifs func_stripname ' ' '' $lastarg setglobal lastarg = $func_stripname_result # Add the arguments to base_compile. func_append base_compile " $lastarg" continue with * # Accept the current argument as the source file. # The previous "srcfile" becomes the current argument. # setglobal lastarg = $srcfile setglobal srcfile = $arg } # case $arg } # case $arg_mode # Aesthetically quote the previous argument. func_append_quoted base_compile $lastarg } # for arg match $arg_mode { with arg func_fatal_error "you must specify an argument for -Xcompile" with target func_fatal_error "you must specify a target with '-o'" with * # Get the name of the library object. test -z $libobj && do { func_basename $srcfile setglobal libobj = $func_basename_result } } # Recognize several different file suffixes. # If the user specifies -o file.o, it is replaced with file.lo match $libobj { with *.[cCFSifmso] | \ *.ada | *.adb | *.ads | *.asm | \ *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup func_xform $libobj setglobal libobj = $func_xform_result } match $libobj { with *.lo func_lo2o $libobj; setglobal obj = $func_lo2o_result with * func_fatal_error "cannot determine name of library object from '$libobj'" } func_infer_tag $base_compile for arg in [$later] { match $arg { with -shared test yes = $build_libtool_libs \ || func_fatal_configuration "cannot build a shared library" setglobal build_old_libs = 'no' continue with -static setglobal build_libtool_libs = 'no' setglobal build_old_libs = 'yes' continue with -prefer-pic setglobal pic_mode = 'yes' continue with -prefer-non-pic setglobal pic_mode = 'no' continue } } func_quote_for_eval $libobj test "X$libobj" != "X$func_quote_for_eval_result" \ && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ && func_warning "libobj name '$libobj' may not contain shell special characters." func_dirname_and_basename $obj "/" "" setglobal objname = $func_basename_result setglobal xdir = $func_dirname_result setglobal lobj = "$xdir$objdir/$objname" test -z $base_compile && \ func_fatal_help "you must specify a compilation command" # Delete any leftover library objects. if test yes = $build_old_libs { setglobal removelist = ""$obj $lobj $libobj $(libobj)T"" } else { setglobal removelist = ""$lobj $libobj $(libobj)T"" } # On Cygwin there's no "real" PIC flag so we must build both object types match $host_os { with cygwin* | mingw* | pw32* | os2* | cegcc* setglobal pic_mode = 'default' } if test no = $pic_mode && test pass_all != $deplibs_check_method { # non-PIC code in shared libraries is not supported setglobal pic_mode = 'default' } # Calculate the filename of the output object if compiler does # not support -o with -c if test no = $compiler_c_o { setglobal output_obj = "$[$ECHO $srcfile | $SED 's%^.*/%%; s%\.[^.]*$%%].$objext" setglobal lockfile = "$output_obj.lock" } else { setglobal output_obj = '' setglobal need_locks = 'no' setglobal lockfile = '' } # Lock this critical section if it is needed # We use this script file to make the link, it avoids creating a new file if test yes = $need_locks { while not $opt_dry_run || ln $progpath $lockfile !2 >/dev/null { func_echo "Waiting for $lockfile to be removed" sleep 2 } } elif test warn = $need_locks { if test -f $lockfile { $ECHO "\ *** ERROR, $lockfile exists and contains: $[cat $lockfile !2 >/dev/null] This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE } func_append removelist " $output_obj" $ECHO $srcfile > $lockfile } $opt_dry_run || $RM $removelist func_append removelist " $lockfile" trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 func_to_tool_file $srcfile func_convert_file_msys_to_w32 setglobal srcfile = $func_to_tool_file_result func_quote_for_eval $srcfile setglobal qsrcfile = $func_quote_for_eval_result # Only build a PIC object if we are building libtool libraries. if test yes = $build_libtool_libs { # Without this assignment, base_compile gets emptied. setglobal fbsd_hideous_sh_bug = $base_compile if test no != $pic_mode { setglobal command = ""$base_compile $qsrcfile $pic_flag"" } else { # Don't build PIC code setglobal command = ""$base_compile $qsrcfile"" } func_mkdir_p "$xdir$objdir" if test -z $output_obj { # Place PIC objects in $objdir func_append command " -o $lobj" } func_show_eval_locale $command \ 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' if test warn = $need_locks && test "X$[cat $lockfile !2 >/dev/null]" != "X$srcfile" { $ECHO "\ *** ERROR, $lockfile contains: $[cat $lockfile !2 >/dev/null] but it should contain: $srcfile This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE } # Just move the object if needed, then go on to compile the next one if test -n $output_obj && test "X$output_obj" != "X$lobj" { func_show_eval '$MV "$output_obj" "$lobj"' \ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' } # Allow error messages only from the first compilation. if test yes = $suppress_opt { setglobal suppress_output = '' >/dev/null 2>&1'' } } # Only build a position-dependent object if we build old libraries. if test yes = $build_old_libs { if test yes != $pic_mode { # Don't build PIC code setglobal command = ""$base_compile $qsrcfile$pie_flag"" } else { setglobal command = ""$base_compile $qsrcfile $pic_flag"" } if test yes = $compiler_c_o { func_append command " -o $obj" } # Suppress compiler output if we already did a PIC compilation. func_append command $suppress_output func_show_eval_locale $command \ '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' if test warn = $need_locks && test "X$[cat $lockfile !2 >/dev/null]" != "X$srcfile" { $ECHO "\ *** ERROR, $lockfile contains: $[cat $lockfile !2 >/dev/null] but it should contain: $srcfile This indicates that another process is trying to use the same temporary object file, and libtool could not work around it because your compiler does not support '-c' and '-o' together. If you repeat this compilation, it may succeed, by chance, but you had better avoid parallel builds (make -j) in this platform, or get a better compiler." $opt_dry_run || $RM $removelist exit $EXIT_FAILURE } # Just move the object if needed if test -n $output_obj && test "X$output_obj" != "X$obj" { func_show_eval '$MV "$output_obj" "$obj"' \ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' } } $opt_dry_run || do { func_write_libtool_object $libobj "$objdir/$objname" $objname # Unlock the critical section if it was locked if test no != $need_locks { setglobal removelist = $lockfile $RM $lockfile } } exit $EXIT_SUCCESS } $opt_help || do { test compile = $opt_mode && func_mode_compile $(1+"$@") } proc func_mode_help { # We need to display help for each of the modes. match $opt_mode { with "" # Generic help is extracted from the usage comments # at the start of this file. func_help with clean $ECHO \ "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... Remove files from the build directory. RM is the name of the program to use to delete files associated with each FILE (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed to RM. If FILE is a libtool library, object or program, all the files associated with it are deleted. Otherwise, only FILE itself is deleted using RM." with compile $ECHO \ "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE Compile a source file into a libtool library object. This mode accepts the following additional options: -o OUTPUT-FILE set the output file name to OUTPUT-FILE -no-suppress do not suppress compiler output for multiple passes -prefer-pic try to build PIC objects only -prefer-non-pic try to build non-PIC objects only -shared do not build a '.o' file suitable for static linking -static only build a '.o' file suitable for static linking -Wc,FLAG pass FLAG directly to the compiler COMPILE-COMMAND is a command to be used in creating a 'standard' object file from the given SOURCEFILE. The output file name is determined by removing the directory component from SOURCEFILE, then substituting the C source code suffix '.c' with the library object suffix, '.lo'." with execute $ECHO \ "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... Automatically set library path, then run a program. This mode accepts the following additional options: -dlopen FILE add the directory containing FILE to the library path This mode sets the library path environment variable according to '-dlopen' flags. If any of the ARGS are libtool executable wrappers, then they are translated into their corresponding uninstalled binary, and any of their required library directories are added to the library path. Then, COMMAND is executed, with ARGS as arguments." with finish $ECHO \ "Usage: $progname [OPTION]... --mode=finish [LIBDIR]... Complete the installation of libtool libraries. Each LIBDIR is a directory that contains libtool libraries. The commands that this mode executes may require superuser privileges. Use the '--dry-run' option if you just want to see what would be executed." with install $ECHO \ "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... Install executables or libraries. INSTALL-COMMAND is the installation command. The first component should be either the 'install' or 'cp' program. The following components of INSTALL-COMMAND are treated specially: -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation The rest of the components are interpreted as arguments to that command (only BSD-compatible install options are recognized)." with link $ECHO \ "Usage: $progname [OPTION]... --mode=link LINK-COMMAND... Link object files or libraries together to form another library, or to create an executable program. LINK-COMMAND is a command using the C compiler that you would use to create a program from several object files. The following components of LINK-COMMAND are treated specially: -all-static do not do any dynamic linking at all -avoid-version do not add a version suffix if possible -bindir BINDIR specify path to binaries directory (for systems where libraries must be found in the PATH setting at runtime) -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) -export-symbols SYMFILE try to export only the symbols listed in SYMFILE -export-symbols-regex REGEX try to export only the symbols matching REGEX -LLIBDIR search LIBDIR for required installed libraries -lNAME OUTPUT-FILE requires the installed library libNAME -module build a library that can dlopened -no-fast-install disable the fast-install mode -no-install link a not-installable executable -no-undefined declare that a library does not refer to external symbols -o OUTPUT-FILE create OUTPUT-FILE from the specified objects -objectlist FILE use a list of object files found in FILE to specify objects -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes) -precious-files-regex REGEX don't remove output files matching REGEX -release RELEASE specify package release information -rpath LIBDIR the created library will eventually be installed in LIBDIR -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries -shared only do dynamic linking of libtool libraries -shrext SUFFIX override the standard shared library file extension -static do not do any dynamic linking of uninstalled libtool libraries -static-libtool-libs do not do any dynamic linking of libtool libraries -version-info CURRENT[:REVISION[:AGE]] specify library version info [each variable defaults to 0] -weak LIBNAME declare that the target provides the LIBNAME interface -Wc,FLAG -Xcompiler FLAG pass linker-specific FLAG directly to the compiler -Wl,FLAG -Xlinker FLAG pass linker-specific FLAG directly to the linker -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) All other options (arguments beginning with '-') are ignored. Every other argument is treated as a filename. Files ending in '.la' are treated as uninstalled libtool libraries, other files are standard or library object files. If the OUTPUT-FILE ends in '.la', then a libtool library is created, only library objects ('.lo' files) may be specified, and '-rpath' is required, except when creating a convenience library. If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created using 'ar' and 'ranlib', or on Windows using 'lib'. If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file is created, otherwise an executable program is created." with uninstall $ECHO \ "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... Remove libraries from an installation directory. RM is the name of the program to use to delete files associated with each FILE (typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed to RM. If FILE is a libtool library, all the files associated with it are deleted. Otherwise, only FILE itself is deleted using RM." with * func_fatal_help "invalid operation mode '$opt_mode'" } echo $ECHO "Try '$progname --help' for more information about other modes." } # Now that we've collected a possible --mode arg, show help if necessary if $opt_help { if test : = $opt_help { func_mode_help } else { do { func_help noexit for opt_mode in [compile link execute install finish uninstall clean] { func_mode_help } } | $SED -n '1p; 2,$s/^Usage:/ or: /p' do { func_help noexit for opt_mode in [compile link execute install finish uninstall clean] { echo func_mode_help } } | $SED '1d /^When reporting/,/^Report/{ H d } $x /information about other modes/d /more detailed .*MODE/d s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' } exit $? } # func_mode_execute arg... proc func_mode_execute { $debug_cmd # The first argument is the command name. setglobal cmd = $nonopt test -z $cmd && \ func_fatal_help "you must specify a COMMAND" # Handle -dlopen flags immediately. for file in [$opt_dlopen] { test -f $file \ || func_fatal_help "'$file' is not a file" setglobal dir = '' match $file { with *.la func_resolve_sysroot $file setglobal file = $func_resolve_sysroot_result # Check to see that this really is a libtool archive. func_lalib_unsafe_p $file \ || func_fatal_help "'$lib' is not a valid libtool archive" # Read the libtool library. setglobal dlname = '' setglobal library_names = '' func_source $file # Skip this library if it cannot be dlopened. if test -z $dlname { # Warn if it was a shared library. test -n $library_names && \ func_warning "'$file' was not linked with '-export-dynamic'" continue } func_dirname $file "" "." setglobal dir = $func_dirname_result if test -f "$dir/$objdir/$dlname" { func_append dir "/$objdir" } else { if test ! -f "$dir/$dlname" { func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'" } } with *.lo # Just add the directory containing the .lo file. func_dirname $file "" "." setglobal dir = $func_dirname_result with * func_warning "'-dlopen' is ignored for non-libtool libraries and objects" continue } # Get the absolute pathname. setglobal absdir = $[cd $dir && pwd] test -n $absdir && setglobal dir = $absdir # Now add the directory to shlibpath_var. if eval "test -z \"\$$shlibpath_var\"" { eval "$shlibpath_var=\"\$dir\"" } else { eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" } } # This variable tells wrapper scripts just to set shlibpath_var # rather than running their programs. setglobal libtool_execute_magic = $magic # Check if any of the arguments is a wrapper script. setglobal args = ''for file in @Argv { match $file { with -* | *.la | *.lo with * # Do a test to see if this is really a libtool program. if func_ltwrapper_script_p $file { func_source $file # Transform arg to wrapped name. setglobal file = "$progdir/$program" } elif func_ltwrapper_executable_p $file { func_ltwrapper_scriptname $file func_source $func_ltwrapper_scriptname_result # Transform arg to wrapped name. setglobal file = "$progdir/$program" } } # Quote arguments (to preserve shell metacharacters). func_append_quoted args $file } if $opt_dry_run { # Display what would be done. if test -n $shlibpath_var { eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" echo "export $shlibpath_var" } $ECHO "$cmd$args" exit $EXIT_SUCCESS } else { if test -n $shlibpath_var { # Export the shlibpath_var. eval "export $shlibpath_var" } # Restore saved environment variables for lt_var in [LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES] { eval "if test \"\${save_$lt_var+set}\" = set; then $lt_var=\$save_$lt_var; export $lt_var else $lt_unset $lt_var fi" } # Now prepare to actually exec the command. setglobal exec_cmd = "'$'cmd$args" } } test execute = $opt_mode && func_mode_execute $(1+"$@") # func_mode_finish arg... proc func_mode_finish { $debug_cmd setglobal libs = '' setglobal libdirs = '' setglobal admincmds = '' for opt in [$nonopt $(1+"$@")] { if test -d $opt { func_append libdirs " $opt" } elif test -f $opt { if func_lalib_unsafe_p $opt { func_append libs " $opt" } else { func_warning "'$opt' is not a valid libtool archive" } } else { func_fatal_error "invalid argument '$opt'" } } if test -n $libs { if test -n $lt_sysroot { setglobal sysroot_regex = $[$ECHO $lt_sysroot | $SED $sed_make_literal_regex] setglobal sysroot_cmd = ""s/\([ ']\)$sysroot_regex/\1/g;"" } else { setglobal sysroot_cmd = '' } # Remove sysroot references if $opt_dry_run { for lib in [$libs] { echo "removing references to $lt_sysroot and '=' prefixes from $lib" } } else { setglobal tmpdir = $[func_mktempdir] for lib in [$libs] { $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ > $tmpdir/tmp-la mv -f $tmpdir/tmp-la $lib } $(RM)r $tmpdir } } if test -n "$finish_cmds$finish_eval" && test -n $libdirs { for libdir in [$libdirs] { if test -n $finish_cmds { # Do each command in the finish commands. func_execute_cmds $finish_cmds 'admincmds="$admincmds '"$cmd"'"' } if test -n $finish_eval { # Do the single finish_eval. eval cmds='"'$finish_eval'"' $opt_dry_run || eval $cmds || func_append admincmds " $cmds" } } } # Exit here if they wanted silent mode. $opt_quiet && exit $EXIT_SUCCESS if test -n "$finish_cmds$finish_eval" && test -n $libdirs { echo "----------------------------------------------------------------------" echo "Libraries have been installed in:" for libdir in [$libdirs] { $ECHO " $libdir" } echo echo "If you ever happen to want to link against installed libraries" echo "in a given directory, LIBDIR, you must either use libtool, and" echo "specify the full pathname of the library, or use the '-LLIBDIR'" echo "flag during linking and do at least one of the following:" if test -n $shlibpath_var { echo " - add LIBDIR to the '$shlibpath_var' environment variable" echo " during execution" } if test -n $runpath_var { echo " - add LIBDIR to the '$runpath_var' environment variable" echo " during linking" } if test -n $hardcode_libdir_flag_spec { setglobal libdir = 'LIBDIR' eval flag='"'$hardcode_libdir_flag_spec'"' $ECHO " - use the '$flag' linker flag" } if test -n $admincmds { $ECHO " - have your system administrator run these commands:$admincmds" } if test -f /etc/ld.so.conf { echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'" } echo echo "See any operating system documentation about shared libraries for" match $host { with solaris2.[6789]|solaris2.1[0-9] echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" echo "pages." with * echo "more information, such as the ld(1) and ld.so(8) manual pages." } echo "----------------------------------------------------------------------" } exit $EXIT_SUCCESS } test finish = $opt_mode && func_mode_finish $(1+"$@") # func_mode_install arg... proc func_mode_install { $debug_cmd # There may be an optional sh(1) argument at the beginning of # install_prog (especially on Windows NT). if test $SHELL = $nonopt || test /bin/sh = $nonopt || # Allow the use of GNU shtool's install command. match $nonopt { with *shtool* : with * false } { # Aesthetically quote it. func_quote_for_eval $nonopt setglobal install_prog = ""$func_quote_for_eval_result "" setglobal arg = $1 shift } else { setglobal install_prog = '' setglobal arg = $nonopt } # The real first argument should be the name of the installation program. # Aesthetically quote it. func_quote_for_eval $arg func_append install_prog $func_quote_for_eval_result setglobal install_shared_prog = $install_prog match " $install_prog " { with *[\\\ /]cp\ * setglobal install_cp = ':' with * setglobal install_cp = 'false' } # We need to accept at least all the BSD install flags. setglobal dest = '' setglobal files = '' setglobal opts = '' setglobal prev = '' setglobal install_type = '' setglobal isdir = 'false' setglobal stripme = '' setglobal no_mode = ':'for arg in @Argv { setglobal arg2 = '' if test -n $dest { func_append files " $dest" setglobal dest = $arg continue } match $arg { with -d setglobal isdir = ':' with -f if $install_cp { :; } else { setglobal prev = $arg } with -g | -m | -o setglobal prev = $arg with -s setglobal stripme = '" -s'" continue with -* with * # If the previous option needed an argument, then skip it. if test -n $prev { if test X-m = "X$prev" && test -n $install_override_mode { setglobal arg2 = $install_override_mode setglobal no_mode = 'false' } setglobal prev = '' } else { setglobal dest = $arg continue } } # Aesthetically quote the argument. func_quote_for_eval $arg func_append install_prog " $func_quote_for_eval_result" if test -n $arg2 { func_quote_for_eval $arg2 } func_append install_shared_prog " $func_quote_for_eval_result" } test -z $install_prog && \ func_fatal_help "you must specify an install program" test -n $prev && \ func_fatal_help "the '$prev' option requires an argument" if test -n $install_override_mode && $no_mode { if $install_cp { :; } else { func_quote_for_eval $install_override_mode func_append install_shared_prog " -m $func_quote_for_eval_result" } } if test -z $files { if test -z $dest { func_fatal_help "no file or destination specified" } else { func_fatal_help "you must specify a destination" } } # Strip any trailing slash from the destination. func_stripname '' '/' $dest setglobal dest = $func_stripname_result # Check to see that the destination is a directory. test -d $dest && setglobal isdir = ':' if $isdir { setglobal destdir = $dest setglobal destname = '' } else { func_dirname_and_basename $dest "" "." setglobal destdir = $func_dirname_result setglobal destname = $func_basename_result # Not a directory, so check to see that there is only one file specified. set dummy $files; shift test "$Argc" -gt 1 && \ func_fatal_help "'$dest' is not a directory" } match $destdir { with [\\/]* | [A-Za-z]:[\\/]* with * for file in [$files] { match $file { with *.lo with * func_fatal_help "'$destdir' must be an absolute directory name" } } } # This variable tells wrapper scripts just to set variables rather # than running their programs. setglobal libtool_install_magic = $magic setglobal staticlibs = '' setglobal future_libdirs = '' setglobal current_libdirs = '' for file in [$files] { # Do each installation. match $file { with *.$libext # Do the static libraries later. func_append staticlibs " $file" with *.la func_resolve_sysroot $file setglobal file = $func_resolve_sysroot_result # Check to see that this really is a libtool archive. func_lalib_unsafe_p $file \ || func_fatal_help "'$file' is not a valid libtool archive" setglobal library_names = '' setglobal old_library = '' setglobal relink_command = '' func_source $file # Add the libdir to current_libdirs if it is the destination. if test "X$destdir" = "X$libdir" { match "$current_libdirs " { with *" $libdir "* with * func_append current_libdirs " $libdir" } } else { # Note the libdir as a future libdir. match "$future_libdirs " { with *" $libdir "* with * func_append future_libdirs " $libdir" } } func_dirname $file "/" "" setglobal dir = $func_dirname_result func_append dir $objdir if test -n $relink_command { # Determine the prefix the user has applied to our future dir. setglobal inst_prefix_dir = $[$ECHO $destdir | $SED -e "s%$libdir\$%%] # Don't allow the user to place us outside of our expected # location b/c this prevents finding dependent libraries that # are installed to the same prefix. # At present, this check doesn't affect windows .dll's that # are installed into $libdir/../bin (currently, that works fine) # but it's something to keep an eye on. test $inst_prefix_dir = $destdir && \ func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir" if test -n $inst_prefix_dir { # Stick the inst_prefix_dir data into the link command. setglobal relink_command = $[$ECHO $relink_command | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%] } else { setglobal relink_command = $[$ECHO $relink_command | $SED "s%@inst_prefix_dir@%%] } func_warning "relinking '$file'" func_show_eval $relink_command \ 'func_fatal_error "error: relink '''''$file''''' with the above command before installing it"' } # See the names of the shared library. set dummy $library_names; shift if test -n $1 { setglobal realname = $1 shift setglobal srcname = $realname test -n $relink_command && setglobal srcname = "$(realname)T" # Install the shared library and build the symlinks. func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ 'exit $?' setglobal tstripme = $stripme match $host_os { with cygwin* | mingw* | pw32* | cegcc* match $realname { with *.dll.a setglobal tstripme = '' } with os2* match $realname { with *_dll.a setglobal tstripme = '' } } if test -n $tstripme && test -n $striplib { func_show_eval "$striplib $destdir/$realname" 'exit $?' } if test "$Argc" -gt 0 {for linkname in @Argv { test $linkname != $realname \ && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" } } # Do each command in the postinstall commands. setglobal lib = "$destdir/$realname" func_execute_cmds $postinstall_cmds 'exit $?' } # Install the pseudo-library for information purposes. func_basename $file setglobal name = $func_basename_result setglobal instname = "$dir/$(name)i" func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' # Maybe install the static library, too. test -n $old_library && func_append staticlibs " $dir/$old_library" with *.lo # Install (i.e. copy) a libtool object. # Figure out destination file name, if it wasn't already specified. if test -n $destname { setglobal destfile = "$destdir/$destname" } else { func_basename $file setglobal destfile = $func_basename_result setglobal destfile = "$destdir/$destfile" } # Deduce the name of the destination old-style object file. match $destfile { with *.lo func_lo2o $destfile setglobal staticdest = $func_lo2o_result with *.$objext setglobal staticdest = $destfile setglobal destfile = '' with * func_fatal_help "cannot copy a libtool object to '$destfile'" } # Install the libtool object if requested. test -n $destfile && \ func_show_eval "$install_prog $file $destfile" 'exit $?' # Install the old object if enabled. if test yes = $build_old_libs { # Deduce the name of the old-style object file. func_lo2o $file setglobal staticobj = $func_lo2o_result func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' } exit $EXIT_SUCCESS with * # Figure out destination file name, if it wasn't already specified. if test -n $destname { setglobal destfile = "$destdir/$destname" } else { func_basename $file setglobal destfile = $func_basename_result setglobal destfile = "$destdir/$destfile" } # If the file is missing, and there is a .exe on the end, strip it # because it is most likely a libtool script we actually want to # install setglobal stripped_ext = '' match $file { with *.exe if test ! -f $file { func_stripname '' '.exe' $file setglobal file = $func_stripname_result setglobal stripped_ext = '.exe' } } # Do a test to see if this is really a libtool program. match $host { with *cygwin* | *mingw* if func_ltwrapper_executable_p $file { func_ltwrapper_scriptname $file setglobal wrapper = $func_ltwrapper_scriptname_result } else { func_stripname '' '.exe' $file setglobal wrapper = $func_stripname_result } with * setglobal wrapper = $file } if func_ltwrapper_script_p $wrapper { setglobal notinst_deplibs = '' setglobal relink_command = '' func_source $wrapper # Check the variables that should have been set. test -z $generated_by_libtool_version && \ func_fatal_error "invalid libtool wrapper script '$wrapper'" setglobal finalize = ':' for lib in [$notinst_deplibs] { # Check to see that each library is installed. setglobal libdir = '' if test -f $lib { func_source $lib } setglobal libfile = "$libdir/$[$ECHO $lib | $SED 's%^.*/%%g]" if test -n $libdir && test ! -f $libfile { func_warning "'$lib' has not been installed in '$libdir'" setglobal finalize = 'false' } } setglobal relink_command = '' func_source $wrapper setglobal outputname = '' if test no = $fast_install && test -n $relink_command { $opt_dry_run || do { if $finalize { setglobal tmpdir = $[func_mktempdir] func_basename "$file$stripped_ext" setglobal file = $func_basename_result setglobal outputname = "$tmpdir/$file" # Replace the output file specification. setglobal relink_command = $[$ECHO $relink_command | $SED 's%@OUTPUT@%'"$outputname"'%g] $opt_quiet || do { func_quote_for_expand $relink_command eval "func_echo $func_quote_for_expand_result" } if eval $relink_command { : } else { func_error "error: relink '$file' with the above command before installing it" $opt_dry_run || $(RM)r $tmpdir continue } setglobal file = $outputname } else { func_warning "cannot relink '$file'" } } } else { # Install the binary that we compiled earlier. setglobal file = $[$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%] } } # remove .exe since cygwin /usr/bin/install will append another # one anyway match $install_prog,$host { with */usr/bin/install*,*cygwin* match $file:$destfile { with *.exe:*.exe # this is ok with *.exe:* setglobal destfile = "$destfile.exe" with *:*.exe func_stripname '' '.exe' $destfile setglobal destfile = $func_stripname_result } } func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' $opt_dry_run || if test -n $outputname { $(RM)r $tmpdir } } } for file in [$staticlibs] { func_basename $file setglobal name = $func_basename_result # Set up the ranlib parameters. setglobal oldlib = "$destdir/$name" func_to_tool_file $oldlib func_convert_file_msys_to_w32 setglobal tool_oldlib = $func_to_tool_file_result func_show_eval "$install_prog \$file \$oldlib" 'exit $?' if test -n $stripme && test -n $old_striplib { func_show_eval "$old_striplib $tool_oldlib" 'exit $?' } # Do each command in the postinstall commands. func_execute_cmds $old_postinstall_cmds 'exit $?' } test -n $future_libdirs && \ func_warning "remember to run '$progname --finish$future_libdirs'" if test -n $current_libdirs { # Maybe just do a dry run. $opt_dry_run && setglobal current_libdirs = "" -n$current_libdirs"" setglobal exec_cmd = ''$SHELL "$progpath" $preserve_args --finish$current_libdirs'' } else { exit $EXIT_SUCCESS } } test install = $opt_mode && func_mode_install $(1+"$@") # func_generate_dlsyms outputname originator pic_p # Extract symbols from dlprefiles and create ${outputname}S.o with # a dlpreopen symbol table. proc func_generate_dlsyms { $debug_cmd setglobal my_outputname = $1 setglobal my_originator = $2 setglobal my_pic_p = $(3-false) setglobal my_prefix = $[$ECHO $my_originator | $SED 's%[^a-zA-Z0-9]%_%g] setglobal my_dlsyms = '' if test -n "$dlfiles$dlprefiles" || test no != $dlself { if test -n $NM && test -n $global_symbol_pipe { setglobal my_dlsyms = "$(my_outputname)S.c" } else { func_error "not configured to extract global symbols from dlpreopened files" } } if test -n $my_dlsyms { match $my_dlsyms { with "" with *.c # Discover the nlist of each of the dlfiles. setglobal nlist = "$output_objdir/$my_outputname.nm" func_show_eval "$RM $nlist $(nlist)S $(nlist)T" # Parse the name list into a source file. func_verbose "creating $output_objdir/$my_dlsyms" $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */ /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */ #ifdef __cplusplus extern \"C\" { #endif #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) #pragma GCC diagnostic ignored \"-Wstrict-prototypes\" #endif /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE /* DATA imports from DLLs on WIN32 can't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT_DLSYM_CONST #elif defined __osf__ /* This system does not cope well with relocations in const data. */ # define LT_DLSYM_CONST #else # define LT_DLSYM_CONST const #endif #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* External symbol declarations for the compiler. */> "$output_objdir/$my_dlsyms" "\ /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */ /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */ #ifdef __cplusplus extern \"C\" { #endif #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) #pragma GCC diagnostic ignored \"-Wstrict-prototypes\" #endif /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE /* DATA imports from DLLs on WIN32 can't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT_DLSYM_CONST #elif defined __osf__ /* This system does not cope well with relocations in const data. */ # define LT_DLSYM_CONST #else # define LT_DLSYM_CONST const #endif #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* External symbol declarations for the compiler. */\ " if test yes = $dlself { func_verbose "generating symbol list for '$output'" $opt_dry_run || echo ': @PROGRAM@ ' > $nlist # Add our own program objects to the symbol list. setglobal progfiles = $[$ECHO "$objs$old_deplibs" | $SP2NL | $SED $lo2o | $NL2SP] for progfile in [$progfiles] { func_to_tool_file $progfile func_convert_file_msys_to_w32 func_verbose "extracting global C symbols from '$func_to_tool_file_result'" $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" } if test -n $exclude_expsyms { $opt_dry_run || do { eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' } } if test -n $export_symbols_regex { $opt_dry_run || do { eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' } } # Prepare the list of exported symbols if test -z $export_symbols { setglobal export_symbols = "$output_objdir/$outputname.exp" $opt_dry_run || do { $RM $export_symbols eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' match $host { with *cygwin* | *mingw* | *cegcc* eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' } } } else { $opt_dry_run || do { eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' eval '$MV "$nlist"T "$nlist"' match $host { with *cygwin* | *mingw* | *cegcc* eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' } } } } for dlprefile in [$dlprefiles] { func_verbose "extracting global C symbols from '$dlprefile'" func_basename $dlprefile setglobal name = $func_basename_result match $host { with *cygwin* | *mingw* | *cegcc* # if an import library, we need to obtain dlname if func_win32_import_lib_p $dlprefile { func_tr_sh $dlprefile eval "curr_lafile=\$libfile_$func_tr_sh_result" setglobal dlprefile_dlbasename = '' if test -n $curr_lafile && func_lalib_p $curr_lafile { # Use subshell, to avoid clobbering current variable values setglobal dlprefile_dlname = $[source $curr_lafile && echo $dlname] if test -n $dlprefile_dlname { func_basename $dlprefile_dlname setglobal dlprefile_dlbasename = $func_basename_result } else { # no lafile. user explicitly requested -dlpreopen . $sharedlib_from_linklib_cmd $dlprefile setglobal dlprefile_dlbasename = $sharedlib_from_linklib_result } } $opt_dry_run || do { if test -n $dlprefile_dlbasename { eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' } else { func_warning "Could not compute DLL name from $name" eval '$ECHO ": $name " >> "$nlist"' } func_to_tool_file $dlprefile func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" } } else { # not an import lib $opt_dry_run || do { eval '$ECHO ": $name " >> "$nlist"' func_to_tool_file $dlprefile func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" } } with * $opt_dry_run || do { eval '$ECHO ": $name " >> "$nlist"' func_to_tool_file $dlprefile func_convert_file_msys_to_w32 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" } } } $opt_dry_run || do { # Make sure we have at least an empty file. test -f $nlist || : > $nlist if test -n $exclude_expsyms { $EGREP -v " ($exclude_expsyms)$" $nlist > "$nlist"T $MV "$nlist"T $nlist } # Try sorting and uniquifying the output. if $GREP -v "^: " < $nlist | if sort -k 3 /dev/null !2 > !1 { sort -k 3 } else { sort +2 } | uniq > "$nlist"S { : } else { $GREP -v "^: " < $nlist > "$nlist"S } if test -f "$nlist"S { eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' } else { echo '/* NONE */' >> "$output_objdir/$my_dlsyms" } func_show_eval '$RM "${nlist}I"' if test -n $global_symbol_to_import { eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I' } echo >> "$output_objdir/$my_dlsyms" "\ /* The mapping between symbol names and symbols. */ typedef struct { const char *name; void *address; } lt_dlsymlist; extern LT_DLSYM_CONST lt_dlsymlist lt_$(my_prefix)_LTX_preloaded_symbols[];>> "$output_objdir/$my_dlsyms" "\ /* The mapping between symbol names and symbols. */ typedef struct { const char *name; void *address; } lt_dlsymlist; extern LT_DLSYM_CONST lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[];\ " if test -s "$nlist"I { echo >> "$output_objdir/$my_dlsyms" "\ static void lt_syminit(void) { LT_DLSYM_CONST lt_dlsymlist *symbol = lt_$(my_prefix)_LTX_preloaded_symbols; for (; symbol->name; ++symbol) {>> "$output_objdir/$my_dlsyms" "\ static void lt_syminit(void) { LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols; for (; symbol->name; ++symbol) {" $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms" echo >> "$output_objdir/$my_dlsyms" "\ } }>> "$output_objdir/$my_dlsyms" "\ } }" } echo >> "$output_objdir/$my_dlsyms" "\ LT_DLSYM_CONST lt_dlsymlist lt_$(my_prefix)_LTX_preloaded_symbols[] = { {\"$my_originator\", (void *) 0},>> "$output_objdir/$my_dlsyms" "\ LT_DLSYM_CONST lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[] = { {\"$my_originator\", (void *) 0}," if test -s "$nlist"I { echo >> "$output_objdir/$my_dlsyms" "\ {\"@INIT@\", (void *) <_syminit},>> "$output_objdir/$my_dlsyms" "\ {\"@INIT@\", (void *) <_syminit}," } match $need_lib_prefix { with no eval $global_symbol_to_c_name_address < $nlist >> "$output_objdir/$my_dlsyms" with * eval $global_symbol_to_c_name_address_lib_prefix < $nlist >> "$output_objdir/$my_dlsyms" } echo >> "$output_objdir/$my_dlsyms" "\ {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt_$(my_prefix)_LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif>> "$output_objdir/$my_dlsyms" "\ {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt_${my_prefix}_LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif\ " } # !$opt_dry_run setglobal pic_flag_for_symtable = '' match "$compile_command " { with *" -static "* with * match $host { # compiling the symbol table file with pic_flag works around # a FreeBSD bug that causes programs to crash when -lm is # linked before any other PIC object. But we must not use # pic_flag when linking with -static. The problem exists in # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. with *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0* setglobal pic_flag_for_symtable = "" $pic_flag -DFREEBSD_WORKAROUND"" with *-*-hpux* setglobal pic_flag_for_symtable = "" $pic_flag"" with * $my_pic_p && setglobal pic_flag_for_symtable = "" $pic_flag"" } } setglobal symtab_cflags = '' for arg in [$LTCFLAGS] { match $arg { with -pie | -fpie | -fPIE with * func_append symtab_cflags " $arg" } } # Now compile the dynamic symbol file. func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' # Clean up the generated files. func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"' # Transform the symbol file into the correct name. setglobal symfileobj = "$output_objdir/$(my_outputname)S.$objext" match $host { with *cygwin* | *mingw* | *cegcc* if test -f "$output_objdir/$my_outputname.def" { setglobal compile_command = $[$ECHO $compile_command | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%] setglobal finalize_command = $[$ECHO $finalize_command | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%] } else { setglobal compile_command = $[$ECHO $compile_command | $SED "s%@SYMFILE@%$symfileobj%] setglobal finalize_command = $[$ECHO $finalize_command | $SED "s%@SYMFILE@%$symfileobj%] } with * setglobal compile_command = $[$ECHO $compile_command | $SED "s%@SYMFILE@%$symfileobj%] setglobal finalize_command = $[$ECHO $finalize_command | $SED "s%@SYMFILE@%$symfileobj%] } with * func_fatal_error "unknown suffix for '$my_dlsyms'" } } else { # We keep going just in case the user didn't refer to # lt_preloaded_symbols. The linker will fail if global_symbol_pipe # really was required. # Nullify the symbol file. setglobal compile_command = $[$ECHO $compile_command | $SED "s% @SYMFILE@%%] setglobal finalize_command = $[$ECHO $finalize_command | $SED "s% @SYMFILE@%%] } } # func_cygming_gnu_implib_p ARG # This predicate returns with zero status (TRUE) if # ARG is a GNU/binutils-style import library. Returns # with nonzero status (FALSE) otherwise. proc func_cygming_gnu_implib_p { $debug_cmd func_to_tool_file $1 func_convert_file_msys_to_w32 setglobal 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)$] test -n $func_cygming_gnu_implib_tmp } # func_cygming_ms_implib_p ARG # This predicate returns with zero status (TRUE) if # ARG is an MS-style import library. Returns # with nonzero status (FALSE) otherwise. proc func_cygming_ms_implib_p { $debug_cmd func_to_tool_file $1 func_convert_file_msys_to_w32 setglobal func_cygming_ms_implib_tmp = $[$NM $func_to_tool_file_result | eval $global_symbol_pipe | $GREP '_NULL_IMPORT_DESCRIPTOR] test -n $func_cygming_ms_implib_tmp } # func_win32_libid arg # return the library type of file 'arg' # # Need a lot of goo to handle *both* DLLs and import libs # Has to be a shell function in order to 'eat' the argument # that is supplied when $file_magic_command is called. # Despite the name, also deal with 64 bit binaries. proc func_win32_libid { $debug_cmd setglobal win32_libid_type = 'unknown' setglobal win32_fileres = $[file -L $1 !2 >/dev/null] match $win32_fileres { with *ar\ archive\ import\ library* # definitely import setglobal win32_libid_type = '"x86 archive import'" with *ar\ archive* # could be an import, or static # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. if eval $OBJDUMP -f $1 | $SED -e '10q' !2 >/dev/null | $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null { match $nm_interface { with "MS dumpbin" if func_cygming_ms_implib_p $1 || func_cygming_gnu_implib_p $1 { setglobal win32_nmres = 'import' } else { setglobal win32_nmres = '' } with * func_to_tool_file $1 func_convert_file_msys_to_w32 setglobal win32_nmres = $[eval $NM -f posix -A '"'$func_to_tool_file_result'"' | $SED -n -e ' 1,100{ / I /{ s|.*|import| p q } }] } match $win32_nmres { with import* setglobal win32_libid_type = '"x86 archive import'" with * setglobal win32_libid_type = '"x86 archive static'" } } with *DLL* setglobal win32_libid_type = '"x86 DLL'" with *executable* # but shell scripts are "executable" too... match $win32_fileres { with *MS\ Windows\ PE\ Intel* setglobal win32_libid_type = '"x86 DLL'" } } $ECHO $win32_libid_type } # func_cygming_dll_for_implib ARG # # Platform-specific function to extract the # name of the DLL associated with the specified # import library ARG. # Invoked by eval'ing the libtool variable # $sharedlib_from_linklib_cmd # Result is available in the variable # $sharedlib_from_linklib_result proc func_cygming_dll_for_implib { $debug_cmd setglobal sharedlib_from_linklib_result = $[$DLLTOOL --identify-strict --identify $1] } # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs # # The is the core of a fallback implementation of a # platform-specific function to extract the name of the # DLL associated with the specified import library LIBNAME. # # SECTION_NAME is either .idata$6 or .idata$7, depending # on the platform and compiler that created the implib. # # Echos the name of the DLL associated with the # specified import library. proc func_cygming_dll_for_implib_fallback_core { $debug_cmd setglobal match_literal = $[$ECHO $1 | $SED $sed_make_literal_regex] $OBJDUMP -s --section $1 $2 !2 >/dev/null | $SED '/^Contents of section '"$match_literal"':/{ # Place marker at beginning of archive member dllname section s/.*/====MARK====/ p d } # These lines can sometimes be longer than 43 characters, but # are always uninteresting /:[ ]*file format pe[i]\{,1\}-/d /^In archive [^:]*:/d # Ensure marker is printed /^====MARK====/p # Remove all lines with less than 43 characters /^.\{43\}/!d # From remaining lines, remove first 43 characters s/^.\{43\}//' | $SED -n ' # Join marker and all lines until next marker into a single line /^====MARK====/ b para H $ b para b :para x s/\n//g # Remove the marker s/^====MARK====// # Remove trailing dots and whitespace s/[\. \t]*$// # Print /./p' | # we now have a list, one entry per line, of the stringified # contents of the appropriate section of all members of the # archive that possess that section. Heuristic: eliminate # all those that have a first or second character that is # a '.' (that is, objdump's representation of an unprintable # character.) This should work for all archives with less than # 0x302f exports -- but will fail for DLLs whose name actually # begins with a literal '.' or a single character followed by # a '.'. # # Of those that remain, print the first one. $SED -e '/^\./d;/^.\./d;q' } # func_cygming_dll_for_implib_fallback ARG # Platform-specific function to extract the # name of the DLL associated with the specified # import library ARG. # # This fallback implementation is for use when $DLLTOOL # does not support the --identify-strict option. # Invoked by eval'ing the libtool variable # $sharedlib_from_linklib_cmd # Result is available in the variable # $sharedlib_from_linklib_result proc func_cygming_dll_for_implib_fallback { $debug_cmd if func_cygming_gnu_implib_p $1 { # binutils import library setglobal sharedlib_from_linklib_result = $[func_cygming_dll_for_implib_fallback_core '.idata$7' $1] } elif func_cygming_ms_implib_p $1 { # ms-generated import library setglobal sharedlib_from_linklib_result = $[func_cygming_dll_for_implib_fallback_core '.idata$6' $1] } else { # unknown setglobal sharedlib_from_linklib_result = '' } } # func_extract_an_archive dir oldlib proc func_extract_an_archive { $debug_cmd setglobal f_ex_an_ar_dir = $1; shift setglobal f_ex_an_ar_oldlib = $1 if test yes = $lock_old_archive_extraction { setglobal lockfile = "$f_ex_an_ar_oldlib.lock" while not $opt_dry_run || ln $progpath $lockfile !2 >/dev/null { func_echo "Waiting for $lockfile to be removed" sleep 2 } } func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ 'stat=$?; rm -f "$lockfile"; exit $stat' if test yes = $lock_old_archive_extraction { $opt_dry_run || rm -f $lockfile } if shell {$AR t $f_ex_an_ar_oldlib | sort | sort -uc >/dev/null !2 > !1} { : } else { func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" } } # func_extract_archives gentop oldlib ... proc func_extract_archives { $debug_cmd setglobal my_gentop = $1; shift setglobal my_oldlibs = $(1+"$@") setglobal my_oldobjs = '' setglobal my_xlib = '' setglobal my_xabs = '' setglobal my_xdir = '' for my_xlib in [$my_oldlibs] { # Extract the objects. match $my_xlib { with [\\/]* | [A-Za-z]:[\\/]* setglobal my_xabs = $my_xlib with * setglobal my_xabs = "$[pwd]"/$my_xlib"" } func_basename $my_xlib setglobal my_xlib = $func_basename_result setglobal my_xlib_u = $my_xlib while : { match " $extracted_archives " { with *" $my_xlib_u "* func_arith $extracted_serial + 1 setglobal extracted_serial = $func_arith_result setglobal my_xlib_u = "lt$extracted_serial-$my_xlib" with * break } } setglobal extracted_archives = ""$extracted_archives $my_xlib_u"" setglobal my_xdir = "$my_gentop/$my_xlib_u" func_mkdir_p $my_xdir match $host { with *-darwin* func_verbose "Extracting $my_xabs" # Do not bother doing anything if just a dry run $opt_dry_run || do { setglobal darwin_orig_dir = $[pwd] cd $my_xdir || exit $? setglobal darwin_archive = $my_xabs setglobal darwin_curdir = $[pwd] func_basename $darwin_archive setglobal darwin_base_archive = $func_basename_result setglobal darwin_arches = $[$LIPO -info $darwin_archive !2 >/dev/null | $GREP Architectures !2 >/dev/null || true] if test -n $darwin_arches { setglobal darwin_arches = $[$ECHO $darwin_arches | $SED -e 's/.*are://] setglobal darwin_arch = '' func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" for darwin_arch in [$darwin_arches] { func_mkdir_p "unfat-$Pid/$darwin_base_archive-$darwin_arch" $LIPO -thin $darwin_arch -output "unfat-$Pid/$darwin_base_archive-$darwin_arch/$darwin_base_archive" $darwin_archive cd "unfat-$Pid/$darwin_base_archive-$darwin_arch" func_extract_an_archive $[pwd] $darwin_base_archive cd $darwin_curdir $RM "unfat-$Pid/$darwin_base_archive-$darwin_arch/$darwin_base_archive" } # $darwin_arches ## Okay now we've a bunch of thin objects, gotta fatten them up :) setglobal darwin_filelist = $[find unfat-$Pid -type f -name '*'.o -print -o -name '*'.lo -print | $SED -e $sed_basename | sort -u] setglobal darwin_file = '' setglobal darwin_files = '' for darwin_file in [$darwin_filelist] { setglobal darwin_files = $[find unfat-$Pid -name $darwin_file -print | sort | $NL2SP] $LIPO -create -output $darwin_file $darwin_files } # $darwin_filelist $RM -rf unfat-$Pid cd $darwin_orig_dir } else { cd $darwin_orig_dir func_extract_an_archive $my_xdir $my_xabs } # $darwin_arches } # !$opt_dry_run with * func_extract_an_archive $my_xdir $my_xabs } setglobal my_oldobjs = ""$my_oldobjs "$[find $my_xdir -name '*'.$objext -print -o -name '*'.lo -print | sort | $NL2SP]" } setglobal func_extract_archives_result = $my_oldobjs } # func_emit_wrapper [arg=no] # # Emit a libtool wrapper script on stdout. # Don't directly open a file because we may want to # incorporate the script contents within a cygwin/mingw # wrapper executable. Must ONLY be called from within # func_mode_link because it depends on a number of variables # set therein. # # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR # variable will take. If 'yes', then the emitted script # will assume that the directory where it is stored is # the $objdir directory. This is a cygwin/mingw-specific # behavior. proc func_emit_wrapper { setglobal func_emit_wrapper_arg1 = $(1-no) $ECHO "\ #! $SHELL # $output - temporary wrapper script for $objdir/$outputname # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # The $output program cannot be directly executed until all the libtool # libraries that it depends on are installed. # # This wrapper script should never be moved out of the build directory. # If it is, it will not operate correctly. # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. sed_quote_subst='$sed_quote_subst' # Be Bourne compatible if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac fi BIN_SH=xpg4; export BIN_SH # for Tru64 DUALCASE=1; export DUALCASE # for MKS sh # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH relink_command=\"$relink_command\" # This environment variable determines our operation mode. if test \"\$libtool_install_magic\" = \"$magic\"; then # install mode needs the following variables: generated_by_libtool_version='$macro_version' notinst_deplibs='$notinst_deplibs' else # When we are sourced in execute mode, \$file and \$ECHO are already set. if test \"\$libtool_execute_magic\" != \"$magic\"; then file=\"\$0\"" setglobal qECHO = $[$ECHO $ECHO | $SED $sed_quote_subst] $ECHO "\ # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF \$1 _LTECHO_EOF' } ECHO=\"$qECHO\" fi # Very basic option parsing. These options are (a) specific to # the libtool wrapper, (b) are identical between the wrapper # /script/ and the wrapper /executable/ that is used only on # windows platforms, and (c) all begin with the string "--lt-" # (application programs are unlikely to have options that match # this pattern). # # There are only two supported options: --lt-debug and # --lt-dump-script. There is, deliberately, no --lt-help. # # The first argument to this parsing function should be the # script's $0 value, followed by "$ifsjoin(Argv)". lt_option_debug= func_parse_lt_options () { lt_script_arg0=\$0 shift for lt_opt do case \"\$lt_opt\" in --lt-debug) lt_option_debug=1 ;; --lt-dump-script) lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` cat \"\$lt_dump_D/\$lt_dump_F\" exit 0 ;; --lt-*) \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 exit 1 ;; esac done # Print the debug banner immediately: if test -n \"\$lt_option_debug\"; then echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2 fi } # Used when --lt-debug. Prints its arguments to stdout # (redirection is the responsibility of the caller) func_lt_dump_args () { lt_dump_args_N=1; for lt_arg do \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\" lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` done } # Core function for launching the target application func_exec_program_core () { " match $host { # Backslashes separate directories on plain windows with *-*-mingw | *-*-os2* | *-cegcc* $ECHO "\ if test -n \"\$lt_option_debug\"; then \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2 func_lt_dump_args \${1+\"\$@\"} 1>&2 fi exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} " with * $ECHO "\ if test -n \"\$lt_option_debug\"; then \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2 func_lt_dump_args \${1+\"\$@\"} 1>&2 fi exec \"\$progdir/\$program\" \${1+\"\$@\"} " } $ECHO "\ \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 exit 1 } # A function to encapsulate launching the target application # Strips options in the --lt-* namespace from \$@ and # launches target application with the remaining arguments. func_exec_program () { case \" \$* \" in *\\ --lt-*) for lt_wr_arg do case \$lt_wr_arg in --lt-*) ;; *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; esac shift done ;; esac func_exec_program_core \${1+\"\$@\"} } # Parse options func_parse_lt_options \"\$0\" \${1+\"\$@\"} # Find the directory that this script lives in. thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` test \"x\$thisdir\" = \"x\$file\" && thisdir=. # Follow symbolic links until we get to the real thisdir. file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` while test -n \"\$file\"; do destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` # If there was a directory component, then change thisdir. if test \"x\$destdir\" != \"x\$file\"; then case \"\$destdir\" in [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; *) thisdir=\"\$thisdir/\$destdir\" ;; esac fi file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` done # Usually 'no', except on cygwin/mingw when embedded into # the cwrapper. WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then # special case for '.' if test \"\$thisdir\" = \".\"; then thisdir=\`pwd\` fi # remove .libs from thisdir case \"\$thisdir\" in *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; $objdir ) thisdir=. ;; esac fi # Try to get the absolute directory name. absdir=\`cd \"\$thisdir\" && pwd\` test -n \"\$absdir\" && thisdir=\"\$absdir\" " if test yes = $fast_install { $ECHO "\ program=lt-'$outputname'$exeext progdir=\"\$thisdir/$objdir\" if test ! -f \"\$progdir/\$program\" || { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\ test \"X\$file\" != \"X\$progdir/\$program\"; }; then file=\"\$\$-\$program\" if test ! -d \"\$progdir\"; then $MKDIR \"\$progdir\" else $RM \"\$progdir/\$file\" fi" $ECHO "\ # relink executable if necessary if test -n \"\$relink_command\"; then if relink_command_output=\`eval \$relink_command 2>&1\`; then : else \$ECHO \"\$relink_command_output\" >&2 $RM \"\$progdir/\$file\" exit 1 fi fi $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || { $RM \"\$progdir/\$program\"; $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } $RM \"\$progdir/\$file\" fi" } else { $ECHO "\ program='$outputname' progdir=\"\$thisdir/$objdir\" " } $ECHO "\ if test -f \"\$progdir/\$program\"; then" # fixup the dll searchpath if we need to. # # Fix the DLL searchpath if we need to. Do this before prepending # to shlibpath, because on Windows, both are PATH and uninstalled # libraries must come first. if test -n $dllsearchpath { $ECHO "\ # Add the dll search path components to the executable PATH PATH=$dllsearchpath:\$PATH " } # Export our shlibpath_var if we have one. if test yes = $shlibpath_overrides_runpath && test -n $shlibpath_var && test -n $temp_rpath { $ECHO "\ # Add our own library path to $shlibpath_var $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" # Some systems cannot cope with colon-terminated $shlibpath_var # The second colon is a workaround for a bug in BeOS R4 sed $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` export $shlibpath_var " } $ECHO "\ if test \"\$libtool_execute_magic\" != \"$magic\"; then # Run the actual program with our arguments. func_exec_program \${1+\"\$@\"} fi else # The program doesn't exist. \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2 \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 exit 1 fi fi\ " } # func_emit_cwrapperexe_src # emit the source code for a wrapper executable on stdout # Must ONLY be called from within func_mode_link because # it depends on a number of variable set therein. proc func_emit_cwrapperexe_src { cat << """ /* $cwrappersource - temporary wrapper executable for $objdir/$outputname Generated by $PROGRAM (GNU $PACKAGE) $VERSION The $output program cannot be directly executed until all the libtool libraries that it depends on are installed. This wrapper executable should never be moved out of the build directory. If it is, it will not operate correctly. */ """ cat << ''' #ifdef _MSC_VER # define _CRT_SECURE_NO_DEPRECATE 1 #endif #include #include #ifdef _MSC_VER # include # include # include #else # include # include # ifdef __CYGWIN__ # include # endif #endif #include #include #include #include #include #include #include #include #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* declarations of non-ANSI functions */ #if defined __MINGW32__ # ifdef __STRICT_ANSI__ int _putenv (const char *); # endif #elif defined __CYGWIN__ # ifdef __STRICT_ANSI__ char *realpath (const char *, char *); int putenv (char *); int setenv (const char *, const char *, int); # endif /* #elif defined other_platform || defined ... */ #endif /* portability defines, excluding path handling macros */ #if defined _MSC_VER # define setmode _setmode # define stat _stat # define chmod _chmod # define getcwd _getcwd # define putenv _putenv # define S_IXUSR _S_IEXEC #elif defined __MINGW32__ # define setmode _setmode # define stat _stat # define chmod _chmod # define getcwd _getcwd # define putenv _putenv #elif defined __CYGWIN__ # define HAVE_SETENV # define FOPEN_WB "wb" /* #elif defined other platforms ... */ #endif #if defined PATH_MAX # define LT_PATHMAX PATH_MAX #elif defined MAXPATHLEN # define LT_PATHMAX MAXPATHLEN #else # define LT_PATHMAX 1024 #endif #ifndef S_IXOTH # define S_IXOTH 0 #endif #ifndef S_IXGRP # define S_IXGRP 0 #endif /* path handling portability macros */ #ifndef DIR_SEPARATOR # define DIR_SEPARATOR '/' # define PATH_SEPARATOR ':' #endif #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \ defined __OS2__ # define HAVE_DOS_BASED_FILE_SYSTEM # define FOPEN_WB "wb" # ifndef DIR_SEPARATOR_2 # define DIR_SEPARATOR_2 '\\' # endif # ifndef PATH_SEPARATOR_2 # define PATH_SEPARATOR_2 ';' # endif #endif #ifndef DIR_SEPARATOR_2 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) #else /* DIR_SEPARATOR_2 */ # define IS_DIR_SEPARATOR(ch) \ (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) #endif /* DIR_SEPARATOR_2 */ #ifndef PATH_SEPARATOR_2 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) #else /* PATH_SEPARATOR_2 */ # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) #endif /* PATH_SEPARATOR_2 */ #ifndef FOPEN_WB # define FOPEN_WB "w" #endif #ifndef _O_BINARY # define _O_BINARY 0 #endif #define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) #define XFREE(stale) do { \ if (stale) { free (stale); stale = 0; } \ } while (0) #if defined LT_DEBUGWRAPPER static int lt_debug = 1; #else static int lt_debug = 0; #endif const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ void *xmalloc (size_t num); char *xstrdup (const char *string); const char *base_name (const char *name); char *find_executable (const char *wrapper); char *chase_symlinks (const char *pathspec); int make_executable (const char *path); int check_executable (const char *path); char *strendzap (char *str, const char *pat); void lt_debugprintf (const char *file, int line, const char *fmt, ...); void lt_fatal (const char *file, int line, const char *message, ...); static const char *nonnull (const char *s); static const char *nonempty (const char *s); void lt_setenv (const char *name, const char *value); char *lt_extend_str (const char *orig_value, const char *add, int to_end); void lt_update_exe_path (const char *name, const char *value); void lt_update_lib_path (const char *name, const char *value); char **prepare_spawn (char **argv); void lt_dump_script (FILE *f); ''' cat << """ #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) # define externally_visible volatile #else # define externally_visible __attribute__((externally_visible)) volatile #endif externally_visible const char * MAGIC_EXE = "$magic_exe"; const char * LIB_PATH_VARNAME = "$shlibpath_var"; """ if test yes = $shlibpath_overrides_runpath && test -n $shlibpath_var && test -n $temp_rpath { func_to_host_path $temp_rpath cat << """ const char * LIB_PATH_VALUE = "$func_to_host_path_result"; """ } else { cat << ''' const char * LIB_PATH_VALUE = ""; ''' } if test -n $dllsearchpath { func_to_host_path "$dllsearchpath:" cat << """ const char * EXE_PATH_VARNAME = "PATH"; const char * EXE_PATH_VALUE = "$func_to_host_path_result"; """ } else { cat << ''' const char * EXE_PATH_VARNAME = ""; const char * EXE_PATH_VALUE = ""; ''' } if test yes = $fast_install { cat << """ const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */ """ } else { cat << """ const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */ """ } cat << ''' #define LTWRAPPER_OPTION_PREFIX "--lt-" static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX; static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script"; static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug"; int main (int argc, char *argv[]) { char **newargz; int newargc; char *tmp_pathspec; char *actual_cwrapper_path; char *actual_cwrapper_name; char *target_name; char *lt_argv_zero; int rval = 127; int i; program_name = (char *) xstrdup (base_name (argv[0])); newargz = XMALLOC (char *, (size_t) argc + 1); /* very simple arg parsing; don't want to rely on getopt * also, copy all non cwrapper options to newargz, except * argz[0], which is handled differently */ newargc=0; for (i = 1; i < argc; i++) { if (STREQ (argv[i], dumpscript_opt)) { ''' match $host { with *mingw* | *cygwin* # make stdout use "unix" line endings echo " setmode(1,_O_BINARY);" } cat << ''' lt_dump_script (stdout); return 0; } if (STREQ (argv[i], debug_opt)) { lt_debug = 1; continue; } if (STREQ (argv[i], ltwrapper_option_prefix)) { /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX namespace, but it is not one of the ones we know about and have already dealt with, above (inluding dump-script), then report an error. Otherwise, targets might begin to believe they are allowed to use options in the LTWRAPPER_OPTION_PREFIX namespace. The first time any user complains about this, we'll need to make LTWRAPPER_OPTION_PREFIX a configure-time option or a configure.ac-settable value. */ lt_fatal (__FILE__, __LINE__, "unrecognized %s option: '%s'", ltwrapper_option_prefix, argv[i]); } /* otherwise ... */ newargz[++newargc] = xstrdup (argv[i]); } newargz[++newargc] = NULL; ''' cat << """ /* The GNU banner must be the first non-error debug message */ lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n"); """ cat << ''' lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]); lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name); tmp_pathspec = find_executable (argv[0]); if (tmp_pathspec == NULL) lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]); lt_debugprintf (__FILE__, __LINE__, "(main) found exe (before symlink chase) at: %s\n", tmp_pathspec); actual_cwrapper_path = chase_symlinks (tmp_pathspec); lt_debugprintf (__FILE__, __LINE__, "(main) found exe (after symlink chase) at: %s\n", actual_cwrapper_path); XFREE (tmp_pathspec); actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path)); strendzap (actual_cwrapper_path, actual_cwrapper_name); /* wrapper name transforms */ strendzap (actual_cwrapper_name, ".exe"); tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1); XFREE (actual_cwrapper_name); actual_cwrapper_name = tmp_pathspec; tmp_pathspec = 0; /* target_name transforms -- use actual target program name; might have lt- prefix */ target_name = xstrdup (base_name (TARGET_PROGRAM_NAME)); strendzap (target_name, ".exe"); tmp_pathspec = lt_extend_str (target_name, ".exe", 1); XFREE (target_name); target_name = tmp_pathspec; tmp_pathspec = 0; lt_debugprintf (__FILE__, __LINE__, "(main) libtool target name: %s\n", target_name); ''' cat << """ newargz[0] = XMALLOC (char, (strlen (actual_cwrapper_path) + strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1)); strcpy (newargz[0], actual_cwrapper_path); strcat (newargz[0], "$objdir"); strcat (newargz[0], "/"); """ cat << ''' /* stop here, and copy so we don't have to do this twice */ tmp_pathspec = xstrdup (newargz[0]); /* do NOT want the lt- prefix here, so use actual_cwrapper_name */ strcat (newargz[0], actual_cwrapper_name); /* DO want the lt- prefix here if it exists, so use target_name */ lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1); XFREE (tmp_pathspec); tmp_pathspec = NULL; ''' match $host_os { with mingw* cat << ''' { char* p; while ((p = strchr (newargz[0], '\\')) != NULL) { *p = '/'; } while ((p = strchr (lt_argv_zero, '\\')) != NULL) { *p = '/'; } } ''' } cat << ''' XFREE (target_name); XFREE (actual_cwrapper_path); XFREE (actual_cwrapper_name); lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */ lt_setenv ("DUALCASE", "1"); /* for MSK sh */ /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath) because on Windows, both *_VARNAMEs are PATH but uninstalled libraries must come first. */ lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE); lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE); lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n", nonnull (lt_argv_zero)); for (i = 0; i < newargc; i++) { lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n", i, nonnull (newargz[i])); } ''' match $host_os { with mingw* cat << ''' /* execv doesn't actually work on mingw as expected on unix */ newargz = prepare_spawn (newargz); rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz); if (rval == -1) { /* failed to start process */ lt_debugprintf (__FILE__, __LINE__, "(main) failed to launch target \"%s\": %s\n", lt_argv_zero, nonnull (strerror (errno))); return 127; } return rval; ''' with * cat << ''' execv (lt_argv_zero, newargz); return rval; /* =127, but avoids unused variable warning */ ''' } cat << ''' } void * xmalloc (size_t num) { void *p = (void *) malloc (num); if (!p) lt_fatal (__FILE__, __LINE__, "memory exhausted"); return p; } char * xstrdup (const char *string) { return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL; } const char * base_name (const char *name) { const char *base; #if defined HAVE_DOS_BASED_FILE_SYSTEM /* Skip over the disk name in MSDOS pathnames. */ if (isalpha ((unsigned char) name[0]) && name[1] == ':') name += 2; #endif for (base = name; *name; name++) if (IS_DIR_SEPARATOR (*name)) base = name + 1; return base; } int check_executable (const char *path) { struct stat st; lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n", nonempty (path)); if ((!path) || (!*path)) return 0; if ((stat (path, &st) >= 0) && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) return 1; else return 0; } int make_executable (const char *path) { int rval = 0; struct stat st; lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", nonempty (path)); if ((!path) || (!*path)) return 0; if (stat (path, &st) >= 0) { rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); } return rval; } /* Searches for the full path of the wrapper. Returns newly allocated full path name if found, NULL otherwise Does not chase symlinks, even on platforms that support them. */ char * find_executable (const char *wrapper) { int has_slash = 0; const char *p; const char *p_next; /* static buffer for getcwd */ char tmp[LT_PATHMAX + 1]; size_t tmp_len; char *concat_name; lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", nonempty (wrapper)); if ((wrapper == NULL) || (*wrapper == '\0')) return NULL; /* Absolute path? */ #if defined HAVE_DOS_BASED_FILE_SYSTEM if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') { concat_name = xstrdup (wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } else { #endif if (IS_DIR_SEPARATOR (wrapper[0])) { concat_name = xstrdup (wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } #if defined HAVE_DOS_BASED_FILE_SYSTEM } #endif for (p = wrapper; *p; p++) if (*p == '/') { has_slash = 1; break; } if (!has_slash) { /* no slashes; search PATH */ const char *path = getenv ("PATH"); if (path != NULL) { for (p = path; *p; p = p_next) { const char *q; size_t p_len; for (q = p; *q; q++) if (IS_PATH_SEPARATOR (*q)) break; p_len = (size_t) (q - p); p_next = (*q == '\0' ? q : q + 1); if (p_len == 0) { /* empty path: current directory */ if (getcwd (tmp, LT_PATHMAX) == NULL) lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", nonnull (strerror (errno))); tmp_len = strlen (tmp); concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, tmp, tmp_len); concat_name[tmp_len] = '/'; strcpy (concat_name + tmp_len + 1, wrapper); } else { concat_name = XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, p, p_len); concat_name[p_len] = '/'; strcpy (concat_name + p_len + 1, wrapper); } if (check_executable (concat_name)) return concat_name; XFREE (concat_name); } } /* not found in PATH; assume curdir */ } /* Relative path | not found in path: prepend cwd */ if (getcwd (tmp, LT_PATHMAX) == NULL) lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", nonnull (strerror (errno))); tmp_len = strlen (tmp); concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); memcpy (concat_name, tmp, tmp_len); concat_name[tmp_len] = '/'; strcpy (concat_name + tmp_len + 1, wrapper); if (check_executable (concat_name)) return concat_name; XFREE (concat_name); return NULL; } char * chase_symlinks (const char *pathspec) { #ifndef S_ISLNK return xstrdup (pathspec); #else char buf[LT_PATHMAX]; struct stat s; char *tmp_pathspec = xstrdup (pathspec); char *p; int has_symlinks = 0; while (strlen (tmp_pathspec) && !has_symlinks) { lt_debugprintf (__FILE__, __LINE__, "checking path component for symlinks: %s\n", tmp_pathspec); if (lstat (tmp_pathspec, &s) == 0) { if (S_ISLNK (s.st_mode) != 0) { has_symlinks = 1; break; } /* search backwards for last DIR_SEPARATOR */ p = tmp_pathspec + strlen (tmp_pathspec) - 1; while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) p--; if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) { /* no more DIR_SEPARATORS left */ break; } *p = '\0'; } else { lt_fatal (__FILE__, __LINE__, "error accessing file \"%s\": %s", tmp_pathspec, nonnull (strerror (errno))); } } XFREE (tmp_pathspec); if (!has_symlinks) { return xstrdup (pathspec); } tmp_pathspec = realpath (pathspec, buf); if (tmp_pathspec == 0) { lt_fatal (__FILE__, __LINE__, "could not follow symlinks for %s", pathspec); } return xstrdup (tmp_pathspec); #endif } char * strendzap (char *str, const char *pat) { size_t len, patlen; assert (str != NULL); assert (pat != NULL); len = strlen (str); patlen = strlen (pat); if (patlen <= len) { str += len - patlen; if (STREQ (str, pat)) *str = '\0'; } return str; } void lt_debugprintf (const char *file, int line, const char *fmt, ...) { va_list args; if (lt_debug) { (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); va_start (args, fmt); (void) vfprintf (stderr, fmt, args); va_end (args); } } static void lt_error_core (int exit_status, const char *file, int line, const char *mode, const char *message, va_list ap) { fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); vfprintf (stderr, message, ap); fprintf (stderr, ".\n"); if (exit_status >= 0) exit (exit_status); } void lt_fatal (const char *file, int line, const char *message, ...) { va_list ap; va_start (ap, message); lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); va_end (ap); } static const char * nonnull (const char *s) { return s ? s : "(null)"; } static const char * nonempty (const char *s) { return (s && !*s) ? "(empty)" : nonnull (s); } void lt_setenv (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_setenv) setting '%s' to '%s'\n", nonnull (name), nonnull (value)); { #ifdef HAVE_SETENV /* always make a copy, for consistency with !HAVE_SETENV */ char *str = xstrdup (value); setenv (name, str, 1); #else size_t len = strlen (name) + 1 + strlen (value) + 1; char *str = XMALLOC (char, len); sprintf (str, "%s=%s", name, value); if (putenv (str) != EXIT_SUCCESS) { XFREE (str); } #endif } } char * lt_extend_str (const char *orig_value, const char *add, int to_end) { char *new_value; if (orig_value && *orig_value) { size_t orig_value_len = strlen (orig_value); size_t add_len = strlen (add); new_value = XMALLOC (char, add_len + orig_value_len + 1); if (to_end) { strcpy (new_value, orig_value); strcpy (new_value + orig_value_len, add); } else { strcpy (new_value, add); strcpy (new_value + add_len, orig_value); } } else { new_value = xstrdup (add); } return new_value; } void lt_update_exe_path (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", nonnull (name), nonnull (value)); if (name && *name && value && *value) { char *new_value = lt_extend_str (getenv (name), value, 0); /* some systems can't cope with a ':'-terminated path #' */ size_t len = strlen (new_value); while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1])) { new_value[--len] = '\0'; } lt_setenv (name, new_value); XFREE (new_value); } } void lt_update_lib_path (const char *name, const char *value) { lt_debugprintf (__FILE__, __LINE__, "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", nonnull (name), nonnull (value)); if (name && *name && value && *value) { char *new_value = lt_extend_str (getenv (name), value, 0); lt_setenv (name, new_value); XFREE (new_value); } } ''' match $host_os { with mingw* cat << ''' /* Prepares an argument vector before calling spawn(). Note that spawn() does not by itself call the command interpreter (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&v); v.dwPlatformId == VER_PLATFORM_WIN32_NT; }) ? "cmd.exe" : "command.com"). Instead it simply concatenates the arguments, separated by ' ', and calls CreateProcess(). We must quote the arguments since Win32 CreateProcess() interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a special way: - Space and tab are interpreted as delimiters. They are not treated as delimiters if they are surrounded by double quotes: "...". - Unescaped double quotes are removed from the input. Their only effect is that within double quotes, space and tab are treated like normal characters. - Backslashes not followed by double quotes are not special. - But 2*n+1 backslashes followed by a double quote become n backslashes followed by a double quote (n >= 0): \" -> " \\\" -> \" \\\\\" -> \\" */ #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" #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" char ** prepare_spawn (char **argv) { size_t argc; char **new_argv; size_t i; /* Count number of arguments. */ for (argc = 0; argv[argc] != NULL; argc++) ; /* Allocate new argument vector. */ new_argv = XMALLOC (char *, argc + 1); /* Put quoted arguments into the new argument vector. */ for (i = 0; i < argc; i++) { const char *string = argv[i]; if (string[0] == '\0') new_argv[i] = xstrdup ("\"\""); else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) { int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); size_t length; unsigned int backslashes; const char *s; char *quoted_string; char *p; length = 0; backslashes = 0; if (quote_around) length++; for (s = string; *s != '\0'; s++) { char c = *s; if (c == '"') length += backslashes + 1; length++; if (c == '\\') backslashes++; else backslashes = 0; } if (quote_around) length += backslashes + 1; quoted_string = XMALLOC (char, length + 1); p = quoted_string; backslashes = 0; if (quote_around) *p++ = '"'; for (s = string; *s != '\0'; s++) { char c = *s; if (c == '"') { unsigned int j; for (j = backslashes + 1; j > 0; j--) *p++ = '\\'; } *p++ = c; if (c == '\\') backslashes++; else backslashes = 0; } if (quote_around) { unsigned int j; for (j = backslashes; j > 0; j--) *p++ = '\\'; *p++ = '"'; } *p = '\0'; new_argv[i] = quoted_string; } else new_argv[i] = (char *) string; } new_argv[argc] = NULL; return new_argv; } ''' } cat << ''' void lt_dump_script (FILE* f) { ''' func_emit_wrapper yes | $SED -n -e ' s/^\(.\{79\}\)\(..*\)/\1\ \2/ h s/\([\\"]\)/\\\1/g s/$/\\n/ s/\([^\n]*\).*/ fputs ("\1", f);/p g D' cat << ''' } ''' } # end: func_emit_cwrapperexe_src # func_win32_import_lib_p ARG # True if ARG is an import lib, as indicated by $file_magic_cmd proc func_win32_import_lib_p { $debug_cmd match $[eval $file_magic_cmd '"''$'1'"' !2 >/dev/null | $SED -e 10q] { with *import* : with * false } } # func_suncc_cstd_abi # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!! # Several compiler flags select an ABI that is incompatible with the # Cstd library. Avoid specifying it if any are in CXXFLAGS. proc func_suncc_cstd_abi { $debug_cmd match " $compile_command " { with *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "* setglobal suncc_use_cstd_abi = 'no' with * setglobal suncc_use_cstd_abi = 'yes' } } # func_mode_link arg... proc func_mode_link { $debug_cmd match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc* # It is impossible to link a dll without this setting, and # we shouldn't force the makefile maintainer to figure out # what system we are compiling for in order to pass an extra # flag for every libtool invocation. # allow_undefined=no # FIXME: Unfortunately, there are problems with the above when trying # to make a dll that has undefined symbols, in which case not # even a static library is built. For now, we need to specify # -no-undefined on the libtool link line when we can be certain # that all symbols are satisfied, otherwise we get a static library. setglobal allow_undefined = 'yes' with * setglobal allow_undefined = 'yes' } setglobal libtool_args = $nonopt setglobal base_compile = ""$nonopt $ifsjoin(Argv)"" setglobal compile_command = $nonopt setglobal finalize_command = $nonopt setglobal compile_rpath = '' setglobal finalize_rpath = '' setglobal compile_shlibpath = '' setglobal finalize_shlibpath = '' setglobal convenience = '' setglobal old_convenience = '' setglobal deplibs = '' setglobal old_deplibs = '' setglobal compiler_flags = '' setglobal linker_flags = '' setglobal dllsearchpath = '' setglobal lib_search_path = $[pwd] setglobal inst_prefix_dir = '' setglobal new_inherited_linker_flags = '' setglobal avoid_version = 'no' setglobal bindir = '' setglobal dlfiles = '' setglobal dlprefiles = '' setglobal dlself = 'no' setglobal export_dynamic = 'no' setglobal export_symbols = '' setglobal export_symbols_regex = '' setglobal generated = '' setglobal libobjs = '' setglobal ltlibs = '' setglobal module = 'no' setglobal no_install = 'no' setglobal objs = '' setglobal os2dllname = '' setglobal non_pic_objects = '' setglobal precious_files_regex = '' setglobal prefer_static_libs = 'no' setglobal preload = 'false' setglobal prev = '' setglobal prevarg = '' setglobal release = '' setglobal rpath = '' setglobal xrpath = '' setglobal perm_rpath = '' setglobal temp_rpath = '' setglobal thread_safe = 'no' setglobal vinfo = '' setglobal vinfo_number = 'no' setglobal weak_libs = '' setglobal single_module = "$wl-single_module" func_infer_tag $base_compilefor arg in @Argv { match $arg { with -shared test yes != $build_libtool_libs \ && func_fatal_configuration "cannot build a shared library" setglobal build_old_libs = 'no' break with -all-static | -static | -static-libtool-libs match $arg { with -all-static if test yes = $build_libtool_libs && test -z $link_static_flag { func_warning "complete static linking is impossible in this configuration" } if test -n $link_static_flag { setglobal dlopen_self = $dlopen_self_static } setglobal prefer_static_libs = 'yes' with -static if test -z $pic_flag && test -n $link_static_flag { setglobal dlopen_self = $dlopen_self_static } setglobal prefer_static_libs = 'built' with -static-libtool-libs if test -z $pic_flag && test -n $link_static_flag { setglobal dlopen_self = $dlopen_self_static } setglobal prefer_static_libs = 'yes' } setglobal build_libtool_libs = 'no' setglobal build_old_libs = 'yes' break } } # See if our shared archives depend on static archives. test -n $old_archive_from_new_cmds && setglobal build_old_libs = 'yes' # Go through the arguments, transforming them on the way. while test "$Argc" -gt 0 { setglobal arg = $1 shift func_quote_for_eval $arg setglobal qarg = $func_quote_for_eval_unquoted_result func_append libtool_args " $func_quote_for_eval_result" # If the previous option needs an argument, assign it. if test -n $prev { match $prev { with output func_append compile_command " @OUTPUT@" func_append finalize_command " @OUTPUT@" } match $prev { with bindir setglobal bindir = $arg setglobal prev = '' continue with dlfiles|dlprefiles $preload || do { # Add the symbol object into the linking commands. func_append compile_command " @SYMFILE@" func_append finalize_command " @SYMFILE@" setglobal preload = ':' } match $arg { with *.la | *.lo # We handle these cases below. with force if test no = $dlself { setglobal dlself = 'needless' setglobal export_dynamic = 'yes' } setglobal prev = '' continue with self if test dlprefiles = $prev { setglobal dlself = 'yes' } elif test dlfiles = $prev && test yes != $dlopen_self { setglobal dlself = 'yes' } else { setglobal dlself = 'needless' setglobal export_dynamic = 'yes' } setglobal prev = '' continue with * if test dlfiles = $prev { func_append dlfiles " $arg" } else { func_append dlprefiles " $arg" } setglobal prev = '' continue } with expsyms setglobal export_symbols = $arg test -f $arg \ || func_fatal_error "symbol file '$arg' does not exist" setglobal prev = '' continue with expsyms_regex setglobal export_symbols_regex = $arg setglobal prev = '' continue with framework match $host { with *-*-darwin* match "$deplibs " { with *" $qarg.ltframework "* with * func_append deplibs " $qarg.ltframework" # this is fixed later } } setglobal prev = '' continue with inst_prefix setglobal inst_prefix_dir = $arg setglobal prev = '' continue with mllvm # Clang does not use LLVM to link, so we can simply discard any # '-mllvm $arg' options when doing the link step. setglobal prev = '' continue with objectlist if test -f $arg { setglobal save_arg = $arg setglobal moreargs = '' for fil in [$[cat $save_arg]] { # func_append moreargs " $fil" setglobal arg = $fil # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p $arg { setglobal pic_object = '' setglobal non_pic_object = '' # Read the .lo file func_source $arg if test -z $pic_object || test -z $non_pic_object || test none = $pic_object && test none = $non_pic_object { func_fatal_error "cannot find name of object for '$arg'" } # Extract subdirectory from the argument. func_dirname $arg "/" "" setglobal xdir = $func_dirname_result if test none != $pic_object { # Prepend the subdirectory the object is found in. setglobal pic_object = "$xdir$pic_object" if test dlfiles = $prev { if test yes = $build_libtool_libs && test yes = $dlopen_support { func_append dlfiles " $pic_object" setglobal prev = '' continue } else { # If libtool objects are unsupported, then we need to preload. setglobal prev = 'dlprefiles' } } # CHECK ME: I think I busted this. -Ossama if test dlprefiles = $prev { # Preload the old-style object. func_append dlprefiles " $pic_object" setglobal prev = '' } # A PIC object. func_append libobjs " $pic_object" setglobal arg = $pic_object } # Non-PIC object. if test none != $non_pic_object { # Prepend the subdirectory the object is found in. setglobal non_pic_object = "$xdir$non_pic_object" # A standard non-PIC object func_append non_pic_objects " $non_pic_object" if test -z $pic_object || test none = $pic_object { setglobal arg = $non_pic_object } } else { # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. setglobal non_pic_object = $pic_object func_append non_pic_objects " $non_pic_object" } } else { # Only an error if not doing a dry-run. if $opt_dry_run { # Extract subdirectory from the argument. func_dirname $arg "/" "" setglobal xdir = $func_dirname_result func_lo2o $arg setglobal pic_object = "$xdir$objdir/$func_lo2o_result" setglobal non_pic_object = "$xdir$func_lo2o_result" func_append libobjs " $pic_object" func_append non_pic_objects " $non_pic_object" } else { func_fatal_error "'$arg' is not a valid libtool object" } } } } else { func_fatal_error "link input file '$arg' does not exist" } setglobal arg = $save_arg setglobal prev = '' continue with os2dllname setglobal os2dllname = $arg setglobal prev = '' continue with precious_regex setglobal precious_files_regex = $arg setglobal prev = '' continue with release setglobal release = "-$arg" setglobal prev = '' continue with rpath | xrpath # We need an absolute path. match $arg { with [\\/]* | [A-Za-z]:[\\/]* with * func_fatal_error "only absolute run-paths are allowed" } if test rpath = $prev { match "$rpath " { with *" $arg "* with * func_append rpath " $arg" } } else { match "$xrpath " { with *" $arg "* with * func_append xrpath " $arg" } } setglobal prev = '' continue with shrext setglobal shrext_cmds = $arg setglobal prev = '' continue with weak func_append weak_libs " $arg" setglobal prev = '' continue with xcclinker func_append linker_flags " $qarg" func_append compiler_flags " $qarg" setglobal prev = '' func_append compile_command " $qarg" func_append finalize_command " $qarg" continue with xcompiler func_append compiler_flags " $qarg" setglobal prev = '' func_append compile_command " $qarg" func_append finalize_command " $qarg" continue with xlinker func_append linker_flags " $qarg" func_append compiler_flags " $wl$qarg" setglobal prev = '' func_append compile_command " $wl$qarg" func_append finalize_command " $wl$qarg" continue with * eval "$prev=\"\$arg\"" setglobal prev = '' continue } } # test -n "$prev" setglobal prevarg = $arg match $arg { with -all-static if test -n $link_static_flag { # See comment for -static flag below, for more details. func_append compile_command " $link_static_flag" func_append finalize_command " $link_static_flag" } continue with -allow-undefined # FIXME: remove this flag sometime in the future. func_fatal_error "'-allow-undefined' must not be used because it is the default" with -avoid-version setglobal avoid_version = 'yes' continue with -bindir setglobal prev = 'bindir' continue with -dlopen setglobal prev = 'dlfiles' continue with -dlpreopen setglobal prev = 'dlprefiles' continue with -export-dynamic setglobal export_dynamic = 'yes' continue with -export-symbols | -export-symbols-regex if test -n $export_symbols || test -n $export_symbols_regex { func_fatal_error "more than one -exported-symbols argument is not allowed" } if test X-export-symbols = "X$arg" { setglobal prev = 'expsyms' } else { setglobal prev = 'expsyms_regex' } continue with -framework setglobal prev = 'framework' continue with -inst-prefix-dir setglobal prev = 'inst_prefix' continue # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* # so, if we see these flags be careful not to treat them like -L with -L[A-Z][A-Z]*:* match $with_gcc/$host { with no/*-*-irix* | /*-*-irix* func_append compile_command " $arg" func_append finalize_command " $arg" } continue with -L* func_stripname "-L" '' $arg if test -z $func_stripname_result { if test "$Argc" -gt 0 { func_fatal_error "require no space between '-L' and '$1'" } else { func_fatal_error "need path for '-L' option" } } func_resolve_sysroot $func_stripname_result setglobal dir = $func_resolve_sysroot_result # We need an absolute path. match $dir { with [\\/]* | [A-Za-z]:[\\/]* with * setglobal absdir = $[cd $dir && pwd] test -z $absdir && \ func_fatal_error "cannot determine absolute directory name of '$dir'" setglobal dir = $absdir } match "$deplibs " { with *" -L$dir "* | *" $arg "* # Will only happen for absolute or sysroot arguments with * # Preserve sysroot, but never include relative directories match $dir { with [\\/]* | [A-Za-z]:[\\/]* | =* func_append deplibs " $arg" with * func_append deplibs " -L$dir" } func_append lib_search_path " $dir" } match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc* setglobal testbindir = $[$ECHO $dir | $SED 's*/lib$*/bin*] match :$dllsearchpath: { with *":$dir:"* with :: setglobal dllsearchpath = $dir with * func_append dllsearchpath ":$dir" } match :$dllsearchpath: { with *":$testbindir:"* with :: setglobal dllsearchpath = $testbindir with * func_append dllsearchpath ":$testbindir" } } continue with -l* if test X-lc = "X$arg" || test X-lm = "X$arg" { match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku* # These systems don't actually have a C or math library (as such) continue with *-*-os2* # These systems don't actually have a C library (as such) test X-lc = "X$arg" && continue with *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* # Do not include libc due to us having libc/libc_r. test X-lc = "X$arg" && continue with *-*-rhapsody* | *-*-darwin1.[012] # Rhapsody C and math libraries are in the System framework func_append deplibs " System.ltframework" continue with *-*-sco3.2v5* | *-*-sco5v6* # Causes problems with __ctype test X-lc = "X$arg" && continue with *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX* # Compiler inserts libc in the correct place for threads to work test X-lc = "X$arg" && continue } } elif test X-lc_r = "X$arg" { match $host { with *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* # Do not include libc_r directly, use -pthread flag. continue } } func_append deplibs " $arg" continue with -mllvm setglobal prev = 'mllvm' continue with -module setglobal module = 'yes' continue # Tru64 UNIX uses -model [arg] to determine the layout of C++ # classes, name mangling, and exception handling. # Darwin uses the -arch flag to determine output architecture. with -model|-arch|-isysroot|--sysroot func_append compiler_flags " $arg" func_append compile_command " $arg" func_append finalize_command " $arg" setglobal prev = 'xcompiler' continue with -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=* func_append compiler_flags " $arg" func_append compile_command " $arg" func_append finalize_command " $arg" match "$new_inherited_linker_flags " { with *" $arg "* with * func_append new_inherited_linker_flags " $arg" } continue with -multi_module setglobal single_module = "$wl-multi_module" continue with -no-fast-install setglobal fast_install = 'no' continue with -no-install match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc* # The PATH hackery in wrapper scripts is required on Windows # and Darwin in order for the loader to find any dlls it needs. func_warning "'-no-install' is ignored for $host" func_warning "assuming '-no-fast-install' instead" setglobal fast_install = 'no' with * setglobal no_install = 'yes' } continue with -no-undefined setglobal allow_undefined = 'no' continue with -objectlist setglobal prev = 'objectlist' continue with -os2dllname setglobal prev = 'os2dllname' continue with -o setglobal prev = 'output' with -precious-files-regex setglobal prev = 'precious_regex' continue with -release setglobal prev = 'release' continue with -rpath setglobal prev = 'rpath' continue with -R setglobal prev = 'xrpath' continue with -R* func_stripname '-R' '' $arg setglobal dir = $func_stripname_result # We need an absolute path. match $dir { with [\\/]* | [A-Za-z]:[\\/]* with =* func_stripname '=' '' $dir setglobal dir = "$lt_sysroot$func_stripname_result" with * func_fatal_error "only absolute run-paths are allowed" } match "$xrpath " { with *" $dir "* with * func_append xrpath " $dir" } continue with -shared # The effects of -shared are defined in a previous loop. continue with -shrext setglobal prev = 'shrext' continue with -static | -static-libtool-libs # The effects of -static are defined in a previous loop. # We used to do the same as -all-static on platforms that # didn't have a PIC flag, but the assumption that the effects # would be equivalent was wrong. It would break on at least # Digital Unix and AIX. continue with -thread-safe setglobal thread_safe = 'yes' continue with -version-info setglobal prev = 'vinfo' continue with -version-number setglobal prev = 'vinfo' setglobal vinfo_number = 'yes' continue with -weak setglobal prev = 'weak' continue with -Wc,* func_stripname '-Wc,' '' $arg setglobal args = $func_stripname_result setglobal arg = '' setglobal save_ifs = $IFS; setglobal IFS = ',' for flag in [$args] { setglobal IFS = $save_ifs func_quote_for_eval $flag func_append arg " $func_quote_for_eval_result" func_append compiler_flags " $func_quote_for_eval_result" } setglobal IFS = $save_ifs func_stripname ' ' '' $arg setglobal arg = $func_stripname_result with -Wl,* func_stripname '-Wl,' '' $arg setglobal args = $func_stripname_result setglobal arg = '' setglobal save_ifs = $IFS; setglobal IFS = ',' for flag in [$args] { setglobal IFS = $save_ifs func_quote_for_eval $flag func_append arg " $wl$func_quote_for_eval_result" func_append compiler_flags " $wl$func_quote_for_eval_result" func_append linker_flags " $func_quote_for_eval_result" } setglobal IFS = $save_ifs func_stripname ' ' '' $arg setglobal arg = $func_stripname_result with -Xcompiler setglobal prev = 'xcompiler' continue with -Xlinker setglobal prev = 'xlinker' continue with -XCClinker setglobal prev = 'xcclinker' continue # -msg_* for osf cc with -msg_* func_quote_for_eval $arg setglobal arg = $func_quote_for_eval_result # Flags to be passed through unchanged, with rationale: # -64, -mips[0-9] enable 64-bit mode for the SGI compiler # -r[0-9][0-9]* specify processor for the SGI compiler # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler # +DA*, +DD* enable 64-bit mode for the HP compiler # -q* compiler args for the IBM compiler # -m*, -t[45]*, -txscale* architecture-specific flags for GCC # -F/path path to uninstalled frameworks, gcc on darwin # -p, -pg, --coverage, -fprofile-* profiling flags for GCC # -fstack-protector* stack protector flags for GCC # @file GCC response files # -tp=* Portland pgcc target processor selection # --sysroot=* for sysroot support # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization # -specs=* GCC specs files # -stdlib=* select c++ std lib with clang # -fsanitize=* Clang/GCC memory and address sanitizer with -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \ -specs=*|-fsanitize=* func_quote_for_eval $arg setglobal arg = $func_quote_for_eval_result func_append compile_command " $arg" func_append finalize_command " $arg" func_append compiler_flags " $arg" continue with -Z* if test os2 = $[expr $host : '.*\(os2\)] { # OS/2 uses -Zxxx to specify OS/2-specific options setglobal compiler_flags = ""$compiler_flags $arg"" func_append compile_command " $arg" func_append finalize_command " $arg" match $arg { with -Zlinker | -Zstack setglobal prev = 'xcompiler' } continue } else { # Otherwise treat like 'Some other compiler flag' below func_quote_for_eval $arg setglobal arg = $func_quote_for_eval_result } # Some other compiler flag. with -* | +* func_quote_for_eval $arg setglobal arg = $func_quote_for_eval_result with *.$objext # A standard object. func_append objs " $arg" with *.lo # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p $arg { setglobal pic_object = '' setglobal non_pic_object = '' # Read the .lo file func_source $arg if test -z $pic_object || test -z $non_pic_object || test none = $pic_object && test none = $non_pic_object { func_fatal_error "cannot find name of object for '$arg'" } # Extract subdirectory from the argument. func_dirname $arg "/" "" setglobal xdir = $func_dirname_result test none = $pic_object || do { # Prepend the subdirectory the object is found in. setglobal pic_object = "$xdir$pic_object" if test dlfiles = $prev { if test yes = $build_libtool_libs && test yes = $dlopen_support { func_append dlfiles " $pic_object" setglobal prev = '' continue } else { # If libtool objects are unsupported, then we need to preload. setglobal prev = 'dlprefiles' } } # CHECK ME: I think I busted this. -Ossama if test dlprefiles = $prev { # Preload the old-style object. func_append dlprefiles " $pic_object" setglobal prev = '' } # A PIC object. func_append libobjs " $pic_object" setglobal arg = $pic_object } # Non-PIC object. if test none != $non_pic_object { # Prepend the subdirectory the object is found in. setglobal non_pic_object = "$xdir$non_pic_object" # A standard non-PIC object func_append non_pic_objects " $non_pic_object" if test -z $pic_object || test none = $pic_object { setglobal arg = $non_pic_object } } else { # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. setglobal non_pic_object = $pic_object func_append non_pic_objects " $non_pic_object" } } else { # Only an error if not doing a dry-run. if $opt_dry_run { # Extract subdirectory from the argument. func_dirname $arg "/" "" setglobal xdir = $func_dirname_result func_lo2o $arg setglobal pic_object = "$xdir$objdir/$func_lo2o_result" setglobal non_pic_object = "$xdir$func_lo2o_result" func_append libobjs " $pic_object" func_append non_pic_objects " $non_pic_object" } else { func_fatal_error "'$arg' is not a valid libtool object" } } with *.$libext # An archive. func_append deplibs " $arg" func_append old_deplibs " $arg" continue with *.la # A libtool-controlled library. func_resolve_sysroot $arg if test dlfiles = $prev { # This library was specified with -dlopen. func_append dlfiles " $func_resolve_sysroot_result" setglobal prev = '' } elif test dlprefiles = $prev { # The library was specified with -dlpreopen. func_append dlprefiles " $func_resolve_sysroot_result" setglobal prev = '' } else { func_append deplibs " $func_resolve_sysroot_result" } continue # Some other compiler argument. with * # Unknown arguments in both finalize_command and compile_command need # to be aesthetically quoted because they are evaled later. func_quote_for_eval $arg setglobal arg = $func_quote_for_eval_result } # arg # Now actually substitute the argument into the commands. if test -n $arg { func_append compile_command " $arg" func_append finalize_command " $arg" } } # argument parsing loop test -n $prev && \ func_fatal_help "the '$prevarg' option requires an argument" if test yes = $export_dynamic && test -n $export_dynamic_flag_spec { eval arg='"'$export_dynamic_flag_spec'"' func_append compile_command " $arg" func_append finalize_command " $arg" } setglobal oldlibs = '' # calculate the name of the file, without its directory func_basename $output setglobal outputname = $func_basename_result setglobal libobjs_save = $libobjs if test -n $shlibpath_var { # get the directories listed in $shlibpath_var eval shlib_search_path='`''$'ECHO '"''$'$shlibpath_var'"' '|' '$'SED '''s/:/ /g''''`' } else { setglobal shlib_search_path = '' } eval sys_lib_search_path='"'$sys_lib_search_path_spec'"' eval sys_lib_dlsearch_path='"'$sys_lib_dlsearch_path_spec'"' # Definition is injected by LT_CONFIG during libtool generation. func_munge_path_list sys_lib_dlsearch_path $LT_SYS_LIBRARY_PATH func_dirname $output "/" "" setglobal output_objdir = "$func_dirname_result$objdir" func_to_tool_file "$output_objdir/" setglobal tool_output_objdir = $func_to_tool_file_result # Create the object directory. func_mkdir_p $output_objdir # Determine the type of output match $output { with "" func_fatal_help "you must specify an output file" with *.$libext setglobal linkmode = 'oldlib' with *.lo | *.$objext setglobal linkmode = 'obj' with *.la setglobal linkmode = 'lib' with * setglobal linkmode = 'prog' # Anything else should be a program. } setglobal specialdeplibs = '' setglobal libs = '' # Find all interdependent deplibs by searching for libraries # that are linked more than once (e.g. -la -lb -la) for deplib in [$deplibs] { if $opt_preserve_dup_deps { match "$libs " { with *" $deplib "* func_append specialdeplibs " $deplib" } } func_append libs " $deplib" } if test lib = $linkmode { setglobal libs = ""$predeps $libs $compiler_lib_search_path $postdeps"" # Compute libraries that are listed more than once in $predeps # $postdeps and mark them as special (i.e., whose duplicates are # not to be eliminated). setglobal pre_post_deps = '' if $opt_duplicate_compiler_generated_deps { for pre_post_dep in [$predeps $postdeps] { match "$pre_post_deps " { with *" $pre_post_dep "* func_append specialdeplibs " $pre_post_deps" } func_append pre_post_deps " $pre_post_dep" } } setglobal pre_post_deps = '' } setglobal deplibs = '' setglobal newdependency_libs = '' setglobal newlib_search_path = '' setglobal need_relink = 'no' # whether we're linking any uninstalled libtool libraries setglobal notinst_deplibs = '' # not-installed libtool libraries setglobal notinst_path = '' # paths that contain not-installed libtool libraries match $linkmode { with lib setglobal passes = '"conv dlpreopen link'" for file in [$dlfiles $dlprefiles] { match $file { with *.la with * func_fatal_help "libraries can '-dlopen' only libtool libraries: $file" } } with prog setglobal compile_deplibs = '' setglobal finalize_deplibs = '' setglobal alldeplibs = 'false' setglobal newdlfiles = '' setglobal newdlprefiles = '' setglobal passes = '"conv scan dlopen dlpreopen link'" with * setglobal passes = '"conv'" } for pass in [$passes] { # The preopen pass in lib mode reverses $deplibs; put it back here # so that -L comes before libs that need it for instance... if test lib,link = "$linkmode,$pass" { ## FIXME: Find the place where the list is rebuilt in the wrong ## order, and fix it there properly setglobal tmp_deplibs = '' for deplib in [$deplibs] { setglobal tmp_deplibs = ""$deplib $tmp_deplibs"" } setglobal deplibs = $tmp_deplibs } if test lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass" { setglobal libs = $deplibs setglobal deplibs = '' } if test prog = $linkmode { match $pass { with dlopen setglobal libs = $dlfiles with dlpreopen setglobal libs = $dlprefiles with link setglobal libs = ""$deplibs %DEPLIBS%"" test "X$link_all_deplibs" != Xno && setglobal libs = ""$libs $dependency_libs"" } } if test lib,dlpreopen = "$linkmode,$pass" { # Collect and forward deplibs of preopened libtool libs for lib in [$dlprefiles] { # Ignore non-libtool-libs setglobal dependency_libs = '' func_resolve_sysroot $lib match $lib { with *.la func_source $func_resolve_sysroot_result } # Collect preopened libtool deplibs, except any this library # has declared as weak libs for deplib in [$dependency_libs] { func_basename $deplib setglobal deplib_base = $func_basename_result match " $weak_libs " { with *" $deplib_base "* with * func_append deplibs " $deplib" } } } setglobal libs = $dlprefiles } if test dlopen = $pass { # Collect dlpreopened libraries setglobal save_deplibs = $deplibs setglobal deplibs = '' } for deplib in [$libs] { setglobal lib = '' setglobal found = 'false' match $deplib { with -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=* if test prog,link = "$linkmode,$pass" { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } else { func_append compiler_flags " $deplib" if test lib = $linkmode { match "$new_inherited_linker_flags " { with *" $deplib "* with * func_append new_inherited_linker_flags " $deplib" } } } continue with -l* if test lib != $linkmode && test prog != $linkmode { func_warning "'-l' is ignored for archives/objects" continue } func_stripname '-l' '' $deplib setglobal name = $func_stripname_result if test lib = $linkmode { setglobal searchdirs = ""$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"" } else { setglobal searchdirs = ""$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"" } for searchdir in [$searchdirs] { for search_ext in [.la $std_shrext .so .a] { # Search the libtool library setglobal lib = "$searchdir/lib$name$search_ext" if test -f $lib { if test .la = $search_ext { setglobal found = ':' } else { setglobal found = 'false' } break 2 } } } if $found { # deplib is a libtool library # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, # We need to do some special things here, and not later. if test yes = $allow_libtool_libs_with_static_runtimes { match " $predeps $postdeps " { with *" $deplib "* if func_lalib_p $lib { setglobal library_names = '' setglobal old_library = '' func_source $lib for l in [$old_library $library_names] { setglobal ll = $l } if test "X$ll" = "X$old_library" { # only static version available setglobal found = 'false' func_dirname $lib "" "." setglobal ladir = $func_dirname_result setglobal lib = "$ladir/$old_library" if test prog,link = "$linkmode,$pass" { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setglobal deplibs = ""$deplib $deplibs"" test lib = $linkmode && setglobal newdependency_libs = ""$deplib $newdependency_libs"" } continue } } with * } } } else { # deplib doesn't seem to be a libtool library if test prog,link = "$linkmode,$pass" { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setglobal deplibs = ""$deplib $deplibs"" test lib = $linkmode && setglobal newdependency_libs = ""$deplib $newdependency_libs"" } continue } # -l with *.ltframework if test prog,link = "$linkmode,$pass" { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setglobal deplibs = ""$deplib $deplibs"" if test lib = $linkmode { match "$new_inherited_linker_flags " { with *" $deplib "* with * func_append new_inherited_linker_flags " $deplib" } } } continue with -L* match $linkmode { with lib setglobal deplibs = ""$deplib $deplibs"" test conv = $pass && continue setglobal newdependency_libs = ""$deplib $newdependency_libs"" func_stripname '-L' '' $deplib func_resolve_sysroot $func_stripname_result func_append newlib_search_path " $func_resolve_sysroot_result" with prog if test conv = $pass { setglobal deplibs = ""$deplib $deplibs"" continue } if test scan = $pass { setglobal deplibs = ""$deplib $deplibs"" } else { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } func_stripname '-L' '' $deplib func_resolve_sysroot $func_stripname_result func_append newlib_search_path " $func_resolve_sysroot_result" with * func_warning "'-L' is ignored for archives/objects" } # linkmode continue # -L with -R* if test link = $pass { func_stripname '-R' '' $deplib func_resolve_sysroot $func_stripname_result setglobal dir = $func_resolve_sysroot_result # Make sure the xrpath contains only unique directories. match "$xrpath " { with *" $dir "* with * func_append xrpath " $dir" } } setglobal deplibs = ""$deplib $deplibs"" continue with *.la func_resolve_sysroot $deplib setglobal lib = $func_resolve_sysroot_result with *.$libext if test conv = $pass { setglobal deplibs = ""$deplib $deplibs"" continue } match $linkmode { with lib # Linking convenience modules into shared libraries is allowed, # but linking other static libraries is non-portable. match " $dlpreconveniencelibs " { with *" $deplib "* with * setglobal valid_a_lib = 'false' match $deplibs_check_method { with match_pattern* set dummy $deplibs_check_method; shift setglobal match_pattern_regex = $[expr $deplibs_check_method : "$1 \(.*\)] if eval "\$ECHO \"$deplib\"" !2 >/dev/null | $SED 10q \ | $EGREP $match_pattern_regex > /dev/null { setglobal valid_a_lib = ':' } with pass_all setglobal valid_a_lib = ':' } if $valid_a_lib { echo $ECHO "*** Warning: Linking the shared library $output against the" $ECHO "*** static library $deplib is not portable!" setglobal deplibs = ""$deplib $deplibs"" } else { echo $ECHO "*** Warning: Trying to link with static lib archive $deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because the file extensions .$libext of this argument makes me believe" echo "*** that it is just a static archive that I should not use here." } } continue with prog if test link != $pass { setglobal deplibs = ""$deplib $deplibs"" } else { setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } continue } # linkmode # *.$libext with *.lo | *.$objext if test conv = $pass { setglobal deplibs = ""$deplib $deplibs"" } elif test prog = $linkmode { if test dlpreopen = $pass || test yes != $dlopen_support || test no = $build_libtool_libs { # If there is no dlopen support or we're linking statically, # we need to preload. func_append newdlprefiles " $deplib" setglobal compile_deplibs = ""$deplib $compile_deplibs"" setglobal finalize_deplibs = ""$deplib $finalize_deplibs"" } else { func_append newdlfiles " $deplib" } } continue with %DEPLIBS% setglobal alldeplibs = ':' continue } # case $deplib $found || test -f $lib \ || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'" # Check to see that this really is a libtool archive. func_lalib_unsafe_p $lib \ || func_fatal_error "'$lib' is not a valid libtool archive" func_dirname $lib "" "." setglobal ladir = $func_dirname_result setglobal dlname = '' setglobal dlopen = '' setglobal dlpreopen = '' setglobal libdir = '' setglobal library_names = '' setglobal old_library = '' setglobal inherited_linker_flags = '' # If the library was installed with an old release of libtool, # it will not redefine variables installed, or shouldnotlink setglobal installed = 'yes' setglobal shouldnotlink = 'no' setglobal avoidtemprpath = '' # Read the .la file func_source $lib # Convert "-framework foo" to "foo.ltframework" if test -n $inherited_linker_flags { setglobal tmp_inherited_linker_flags = $[$ECHO $inherited_linker_flags | $SED 's/-framework \([^ $]*\)/\1.ltframework/g] for tmp_inherited_linker_flag in [$tmp_inherited_linker_flags] { match " $new_inherited_linker_flags " { with *" $tmp_inherited_linker_flag "* with * func_append new_inherited_linker_flags " $tmp_inherited_linker_flag" } } } setglobal dependency_libs = $[$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] if test lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass" || do { test prog != $linkmode && test lib != $linkmode; } { test -n $dlopen && func_append dlfiles " $dlopen" test -n $dlpreopen && func_append dlprefiles " $dlpreopen" } if test conv = $pass { # Only check for convenience libraries setglobal deplibs = ""$lib $deplibs"" if test -z $libdir { if test -z $old_library { func_fatal_error "cannot find name of link library for '$lib'" } # It is a libtool convenience library, so add in its objects. func_append convenience " $ladir/$objdir/$old_library" func_append old_convenience " $ladir/$objdir/$old_library" setglobal tmp_libs = '' for deplib in [$dependency_libs] { setglobal deplibs = ""$deplib $deplibs"" if $opt_preserve_dup_deps { match "$tmp_libs " { with *" $deplib "* func_append specialdeplibs " $deplib" } } func_append tmp_libs " $deplib" } } elif test prog != $linkmode && test lib != $linkmode { func_fatal_error "'$lib' is not a convenience library" } continue } # $pass = conv # Get the name of the library we link against. setglobal linklib = '' if test -n $old_library && do { test yes = $prefer_static_libs || test built,no = "$prefer_static_libs,$installed"; } { setglobal linklib = $old_library } else { for l in [$old_library $library_names] { setglobal linklib = $l } } if test -z $linklib { func_fatal_error "cannot find name of link library for '$lib'" } # This library was specified with -dlopen. if test dlopen = $pass { test -z $libdir \ && func_fatal_error "cannot -dlopen a convenience library: '$lib'" if test -z $dlname || test yes != $dlopen_support || test no = $build_libtool_libs { # If there is no dlname, no dlopen support or we're linking # statically, we need to preload. We also need to preload any # dependent libraries so libltdl's deplib preloader doesn't # bomb out in the load deplibs phase. func_append dlprefiles " $lib $dependency_libs" } else { func_append newdlfiles " $lib" } continue } # $pass = dlopen # We need an absolute path. match $ladir { with [\\/]* | [A-Za-z]:[\\/]* setglobal abs_ladir = $ladir with * setglobal abs_ladir = $[cd $ladir && pwd] if test -z $abs_ladir { func_warning "cannot determine absolute directory name of '$ladir'" func_warning "passing it literally to the linker, although it might fail" setglobal abs_ladir = $ladir } } func_basename $lib setglobal laname = $func_basename_result # Find the relevant object directory and library name. if test yes = $installed { if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib" { func_warning "library '$lib' was moved." setglobal dir = $ladir setglobal absdir = $abs_ladir setglobal libdir = $abs_ladir } else { setglobal dir = "$lt_sysroot$libdir" setglobal absdir = "$lt_sysroot$libdir" } test yes = $hardcode_automatic && setglobal avoidtemprpath = 'yes' } else { if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib" { setglobal dir = $ladir setglobal absdir = $abs_ladir # Remove this search path later func_append notinst_path " $abs_ladir" } else { setglobal dir = "$ladir/$objdir" setglobal absdir = "$abs_ladir/$objdir" # Remove this search path later func_append notinst_path " $abs_ladir" } } # $installed = yes func_stripname 'lib' '.la' $laname setglobal name = $func_stripname_result # This library was specified with -dlpreopen. if test dlpreopen = $pass { if test -z $libdir && test prog = $linkmode { func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'" } match $host { # special handling for platforms with PE-DLLs. with *cygwin* | *mingw* | *cegcc* # Linker will automatically link against shared library if both # static and shared are present. Therefore, ensure we extract # symbols from the import library if a shared library is present # (otherwise, the dlopen module name will be incorrect). We do # this by putting the import library name into $newdlprefiles. # We recover the dlopen module name by 'saving' the la file # name in a special purpose variable, and (later) extracting the # dlname from the la file. if test -n $dlname { func_tr_sh "$dir/$linklib" eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" func_append newdlprefiles " $dir/$linklib" } else { func_append newdlprefiles " $dir/$old_library" # Keep a list of preopened convenience libraries to check # that they are being used correctly in the link pass. test -z $libdir && \ func_append dlpreconveniencelibs " $dir/$old_library" } with * # Prefer using a static library (so that no silly _DYNAMIC symbols # are required to link). if test -n $old_library { func_append newdlprefiles " $dir/$old_library" # Keep a list of preopened convenience libraries to check # that they are being used correctly in the link pass. test -z $libdir && \ func_append dlpreconveniencelibs " $dir/$old_library" # Otherwise, use the dlname, so that lt_dlopen finds it. } elif test -n $dlname { func_append newdlprefiles " $dir/$dlname" } else { func_append newdlprefiles " $dir/$linklib" } } } # $pass = dlpreopen if test -z $libdir { # Link the convenience library if test lib = $linkmode { setglobal deplibs = ""$dir/$old_library $deplibs"" } elif test prog,link = "$linkmode,$pass" { setglobal compile_deplibs = ""$dir/$old_library $compile_deplibs"" setglobal finalize_deplibs = ""$dir/$old_library $finalize_deplibs"" } else { setglobal deplibs = ""$lib $deplibs"" # used for prog,scan pass } continue } if test prog = $linkmode && test link != $pass { func_append newlib_search_path " $ladir" setglobal deplibs = ""$lib $deplibs"" setglobal linkalldeplibs = 'false' if test no != $link_all_deplibs || test -z $library_names || test no = $build_libtool_libs { setglobal linkalldeplibs = ':' } setglobal tmp_libs = '' for deplib in [$dependency_libs] { match $deplib { with -L* func_stripname '-L' '' $deplib func_resolve_sysroot $func_stripname_result func_append newlib_search_path " $func_resolve_sysroot_result" } # Need to link against all dependency_libs? if $linkalldeplibs { setglobal deplibs = ""$deplib $deplibs"" } else { # Need to hardcode shared library paths # or/and link against static libraries setglobal newdependency_libs = ""$deplib $newdependency_libs"" } if $opt_preserve_dup_deps { match "$tmp_libs " { with *" $deplib "* func_append specialdeplibs " $deplib" } } func_append tmp_libs " $deplib" } # for deplib continue } # $linkmode = prog... if test prog,link = "$linkmode,$pass" { if test -n $library_names && do { do { test no = $prefer_static_libs || test built,yes = "$prefer_static_libs,$installed"; } || test -z $old_library; } { # We need to hardcode the library path if test -n $shlibpath_var && test -z $avoidtemprpath { # Make sure the rpath contains only unique directories. match $temp_rpath: { with *"$absdir:"* with * func_append temp_rpath "$absdir:" } } # Hardcode the library path. # Skip directories that are in the system default run-time # search path. match " $sys_lib_dlsearch_path " { with *" $absdir "* with * match "$compile_rpath " { with *" $absdir "* with * func_append compile_rpath " $absdir" } } match " $sys_lib_dlsearch_path " { with *" $libdir "* with * match "$finalize_rpath " { with *" $libdir "* with * func_append finalize_rpath " $libdir" } } } # $linkmode,$pass = prog,link... if $alldeplibs && do { test pass_all = $deplibs_check_method || do { test yes = $build_libtool_libs && test -n $library_names; }; } { # We only need to search for static libraries continue } } setglobal link_static = 'no' # Whether the deplib will be linked statically setglobal use_static_libs = $prefer_static_libs if test built = $use_static_libs && test yes = $installed { setglobal use_static_libs = 'no' } if test -n $library_names && do { test no = $use_static_libs || test -z $old_library; } { match $host { with *cygwin* | *mingw* | *cegcc* | *os2* # No point in relinking DLLs because paths are not encoded func_append notinst_deplibs " $lib" setglobal need_relink = 'no' with * if test no = $installed { func_append notinst_deplibs " $lib" setglobal need_relink = 'yes' } } # This is a shared library # Warn about portability, can't link against -module's on some # systems (darwin). Don't bleat about dlopened modules though! setglobal dlopenmodule = '' for dlpremoduletest in [$dlprefiles] { if test "X$dlpremoduletest" = "X$lib" { setglobal dlopenmodule = $dlpremoduletest break } } if test -z $dlopenmodule && test yes = $shouldnotlink && test link = $pass { echo if test prog = $linkmode { $ECHO "*** Warning: Linking the executable $output against the loadable module" } else { $ECHO "*** Warning: Linking the shared library $output against the loadable module" } $ECHO "*** $linklib is not portable!" } if test lib = $linkmode && test yes = $hardcode_into_libs { # Hardcode the library path. # Skip directories that are in the system default run-time # search path. match " $sys_lib_dlsearch_path " { with *" $absdir "* with * match "$compile_rpath " { with *" $absdir "* with * func_append compile_rpath " $absdir" } } match " $sys_lib_dlsearch_path " { with *" $libdir "* with * match "$finalize_rpath " { with *" $libdir "* with * func_append finalize_rpath " $libdir" } } } if test -n $old_archive_from_expsyms_cmds { # figure out the soname set dummy $library_names shift setglobal realname = $1 shift setglobal libname = $[eval "\\$ECHO \"$libname_spec] # use dlname if we got it. it's perfectly good, no? if test -n $dlname { setglobal soname = $dlname } elif test -n $soname_spec { # bleh windows match $host { with *cygwin* | mingw* | *cegcc* | *os2* func_arith $current - $age setglobal major = $func_arith_result setglobal versuffix = "-$major" } eval soname='"'$soname_spec'"' } else { setglobal soname = $realname } # Make a new name for the extract_expsyms_cmds to use setglobal soroot = $soname func_basename $soroot setglobal soname = $func_basename_result func_stripname 'lib' '.dll' $soname setglobal newlib = "libimp-$func_stripname_result.a" # If the library has no export list, then create one now if test -f "$output_objdir/$soname-def" { : } else { func_verbose "extracting exported symbol list from '$soname'" func_execute_cmds $extract_expsyms_cmds 'exit $?' } # Create $newlib if test -f "$output_objdir/$newlib" { :; } else { func_verbose "generating import library for '$soname'" func_execute_cmds $old_archive_from_expsyms_cmds 'exit $?' } # make sure the library variables are pointing to the new library setglobal dir = $output_objdir setglobal linklib = $newlib } # test -n "$old_archive_from_expsyms_cmds" if test prog = $linkmode || test relink != $opt_mode { setglobal add_shlibpath = '' setglobal add_dir = '' setglobal add = '' setglobal lib_linked = 'yes' match $hardcode_action { with immediate | unsupported if test no = $hardcode_direct { setglobal add = "$dir/$linklib" match $host { with *-*-sco3.2v5.0.[024]* setglobal add_dir = "-L$dir" with *-*-sysv4*uw2* setglobal add_dir = "-L$dir" with *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ *-*-unixware7* setglobal add_dir = "-L$dir" with *-*-darwin* # if the lib is a (non-dlopened) module then we cannot # link against it, someone is ignoring the earlier warnings if /usr/bin/file -L $add !2 > /dev/null | $GREP ": [^:]* bundle" >/dev/null { if test "X$dlopenmodule" != "X$lib" { $ECHO "*** Warning: lib $linklib is a module, not a shared library" if test -z $old_library { echo echo "*** And there doesn't seem to be a static archive available" echo "*** The link will probably fail, sorry" } else { setglobal add = "$dir/$old_library" } } elif test -n $old_library { setglobal add = "$dir/$old_library" } } } } elif test no = $hardcode_minus_L { match $host { with *-*-sunos* setglobal add_shlibpath = $dir } setglobal add_dir = "-L$dir" setglobal add = "-l$name" } elif test no = $hardcode_shlibpath_var { setglobal add_shlibpath = $dir setglobal add = "-l$name" } else { setglobal lib_linked = 'no' } with relink if test yes = $hardcode_direct && test no = $hardcode_direct_absolute { setglobal add = "$dir/$linklib" } elif test yes = $hardcode_minus_L { setglobal add_dir = "-L$absdir" # Try looking first in the location we're being installed to. if test -n $inst_prefix_dir { match $libdir { with [\\/]* func_append add_dir " -L$inst_prefix_dir$libdir" } } setglobal add = "-l$name" } elif test yes = $hardcode_shlibpath_var { setglobal add_shlibpath = $dir setglobal add = "-l$name" } else { setglobal lib_linked = 'no' } with * setglobal lib_linked = 'no' } if test yes != $lib_linked { func_fatal_configuration "unsupported hardcode properties" } if test -n $add_shlibpath { match :$compile_shlibpath: { with *":$add_shlibpath:"* with * func_append compile_shlibpath "$add_shlibpath:" } } if test prog = $linkmode { test -n $add_dir && setglobal compile_deplibs = ""$add_dir $compile_deplibs"" test -n $add && setglobal compile_deplibs = ""$add $compile_deplibs"" } else { test -n $add_dir && setglobal deplibs = ""$add_dir $deplibs"" test -n $add && setglobal deplibs = ""$add $deplibs"" if test yes != $hardcode_direct && test yes != $hardcode_minus_L && test yes = $hardcode_shlibpath_var { match :$finalize_shlibpath: { with *":$libdir:"* with * func_append finalize_shlibpath "$libdir:" } } } } if test prog = $linkmode || test relink = $opt_mode { setglobal add_shlibpath = '' setglobal add_dir = '' setglobal add = '' # Finalize command for both is simple: just hardcode it. if test yes = $hardcode_direct && test no = $hardcode_direct_absolute { setglobal add = "$libdir/$linklib" } elif test yes = $hardcode_minus_L { setglobal add_dir = "-L$libdir" setglobal add = "-l$name" } elif test yes = $hardcode_shlibpath_var { match :$finalize_shlibpath: { with *":$libdir:"* with * func_append finalize_shlibpath "$libdir:" } setglobal add = "-l$name" } elif test yes = $hardcode_automatic { if test -n $inst_prefix_dir && test -f "$inst_prefix_dir$libdir/$linklib" { setglobal add = "$inst_prefix_dir$libdir/$linklib" } else { setglobal add = "$libdir/$linklib" } } else { # We cannot seem to hardcode it, guess we'll fake it. setglobal add_dir = "-L$libdir" # Try looking first in the location we're being installed to. if test -n $inst_prefix_dir { match $libdir { with [\\/]* func_append add_dir " -L$inst_prefix_dir$libdir" } } setglobal add = "-l$name" } if test prog = $linkmode { test -n $add_dir && setglobal finalize_deplibs = ""$add_dir $finalize_deplibs"" test -n $add && setglobal finalize_deplibs = ""$add $finalize_deplibs"" } else { test -n $add_dir && setglobal deplibs = ""$add_dir $deplibs"" test -n $add && setglobal deplibs = ""$add $deplibs"" } } } elif test prog = $linkmode { # Here we assume that one of hardcode_direct or hardcode_minus_L # is not unsupported. This is valid on all known static and # shared platforms. if test unsupported != $hardcode_direct { test -n $old_library && setglobal linklib = $old_library setglobal compile_deplibs = ""$dir/$linklib $compile_deplibs"" setglobal finalize_deplibs = ""$dir/$linklib $finalize_deplibs"" } else { setglobal compile_deplibs = ""-l$name -L$dir $compile_deplibs"" setglobal finalize_deplibs = ""-l$name -L$dir $finalize_deplibs"" } } elif test yes = $build_libtool_libs { # Not a shared library if test pass_all != $deplibs_check_method { # We're trying link a shared library against a static one # but the system doesn't support it. # Just print a warning and add the library to dependency_libs so # that the program can be linked against the static library. echo $ECHO "*** Warning: This system cannot link to static lib archive $lib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have." if test yes = $module { echo "*** But as you try to build a module library, libtool will still create " echo "*** a static module, that should work as long as the dlopening application" echo "*** is linked with the -dlopen flag to resolve symbols at runtime." if test -z $global_symbol_pipe { echo echo "*** However, this would only work if libtool was able to extract symbol" echo "*** lists from a program, using 'nm' or equivalent, but libtool could" echo "*** not find such a program. So, this module is probably useless." echo "*** 'nm' from GNU binutils and a full rebuild may help." } if test no = $build_old_libs { setglobal build_libtool_libs = 'module' setglobal build_old_libs = 'yes' } else { setglobal build_libtool_libs = 'no' } } } else { setglobal deplibs = ""$dir/$old_library $deplibs"" setglobal link_static = 'yes' } } # link shared/static library? if test lib = $linkmode { if test -n $dependency_libs && do { test yes != $hardcode_into_libs || test yes = $build_old_libs || test yes = $link_static; } { # Extract -R from dependency_libs setglobal temp_deplibs = '' for libdir in [$dependency_libs] { match $libdir { with -R* func_stripname '-R' '' $libdir setglobal temp_xrpath = $func_stripname_result match " $xrpath " { with *" $temp_xrpath "* with * func_append xrpath " $temp_xrpath" } with * func_append temp_deplibs " $libdir" } } setglobal dependency_libs = $temp_deplibs } func_append newlib_search_path " $absdir" # Link against this library test no = $link_static && setglobal newdependency_libs = ""$abs_ladir/$laname $newdependency_libs"" # ... and its dependency_libs setglobal tmp_libs = '' for deplib in [$dependency_libs] { setglobal newdependency_libs = ""$deplib $newdependency_libs"" match $deplib { with -L* func_stripname '-L' '' $deplib func_resolve_sysroot $func_stripname_result with * func_resolve_sysroot $deplib } if $opt_preserve_dup_deps { match "$tmp_libs " { with *" $func_resolve_sysroot_result "* func_append specialdeplibs " $func_resolve_sysroot_result" } } func_append tmp_libs " $func_resolve_sysroot_result" } if test no != $link_all_deplibs { # Add the search paths of all dependency libraries for deplib in [$dependency_libs] { setglobal path = '' match $deplib { with -L* setglobal path = $deplib with *.la func_resolve_sysroot $deplib setglobal deplib = $func_resolve_sysroot_result func_dirname $deplib "" "." setglobal dir = $func_dirname_result # We need an absolute path. match $dir { with [\\/]* | [A-Za-z]:[\\/]* setglobal absdir = $dir with * setglobal absdir = $[cd $dir && pwd] if test -z $absdir { func_warning "cannot determine absolute directory name of '$dir'" setglobal absdir = $dir } } if $GREP "^installed=no" $deplib > /dev/null { match $host { with *-*-darwin* setglobal depdepl = '' eval deplibrary_names=$[$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib] if test -n $deplibrary_names { for tmp in [$deplibrary_names] { setglobal depdepl = $tmp } if test -f "$absdir/$objdir/$depdepl" { setglobal depdepl = "$absdir/$objdir/$depdepl" setglobal darwin_install_name = $[$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}] if test -z $darwin_install_name { setglobal darwin_install_name = $[$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}] } func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl" func_append linker_flags " -dylib_file $darwin_install_name:$depdepl" setglobal path = '' } } with * setglobal path = "-L$absdir/$objdir" } } else { eval libdir=$[$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib] test -z $libdir && \ func_fatal_error "'$deplib' is not a valid libtool archive" test $absdir != $libdir && \ func_warning "'$deplib' seems to be moved" setglobal path = "-L$absdir" } } match " $deplibs " { with *" $path "* with * setglobal deplibs = ""$path $deplibs"" } } } # link_all_deplibs != no } # linkmode = lib } # for deplib in $libs if test link = $pass { if test prog = $linkmode { setglobal compile_deplibs = ""$new_inherited_linker_flags $compile_deplibs"" setglobal finalize_deplibs = ""$new_inherited_linker_flags $finalize_deplibs"" } else { setglobal compiler_flags = ""$compiler_flags "$[$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g]" } } setglobal dependency_libs = $newdependency_libs if test dlpreopen = $pass { # Link the dlpreopened libraries before other libraries for deplib in [$save_deplibs] { setglobal deplibs = ""$deplib $deplibs"" } } if test dlopen != $pass { test conv = $pass || do { # Make sure lib_search_path contains only unique directories. setglobal lib_search_path = '' for dir in [$newlib_search_path] { match "$lib_search_path " { with *" $dir "* with * func_append lib_search_path " $dir" } } setglobal newlib_search_path = '' } if test prog,link = "$linkmode,$pass" { setglobal vars = '"compile_deplibs finalize_deplibs'" } else { setglobal vars = 'deplibs' } for var in [$vars dependency_libs] { # Add libraries to $var in reverse order eval tmp_libs='"''$'$var'"' setglobal new_libs = '' for deplib in [$tmp_libs] { # FIXME: Pedantically, this is the right thing to do, so # that some nasty dependency loop isn't accidentally # broken: #new_libs="$deplib $new_libs" # Pragmatically, this seems to cause very few problems in # practice: match $deplib { with -L* setglobal new_libs = ""$deplib $new_libs"" with -R* with * # And here is the reason: when a library appears more # than once as an explicit dependence of a library, or # is implicitly linked in more than once by the # compiler, it is considered special, and multiple # occurrences thereof are not removed. Compare this # with having the same library being listed as a # dependency of multiple other libraries: in this case, # we know (pedantically, we assume) the library does not # need to be listed more than once, so we keep only the # last copy. This is not always right, but it is rare # enough that we require users that really mean to play # such unportable linking tricks to link the library # using -Wl,-lname, so that libtool does not consider it # for duplicate removal. match " $specialdeplibs " { with *" $deplib "* setglobal new_libs = ""$deplib $new_libs"" with * match " $new_libs " { with *" $deplib "* with * setglobal new_libs = ""$deplib $new_libs"" } } } } setglobal tmp_libs = '' for deplib in [$new_libs] { match $deplib { with -L* match " $tmp_libs " { with *" $deplib "* with * func_append tmp_libs " $deplib" } with * func_append tmp_libs " $deplib" } } eval $var='"'$tmp_libs'"' } # for var } # Add Sun CC postdeps if required: test CXX = $tagname && do { match $host_os { with linux* match $[$CC -V !2 > !1 | sed 5q] { with *Sun\ C* # Sun C++ 5.9 func_suncc_cstd_abi if test no != $suncc_use_cstd_abi { func_append postdeps ' -library=Cstd -library=Crun' } } with solaris* func_cc_basename $CC match $func_cc_basename_result { with CC* | sunCC* func_suncc_cstd_abi if test no != $suncc_use_cstd_abi { func_append postdeps ' -library=Cstd -library=Crun' } } } } # Last step: remove runtime libs from dependency_libs # (they stay in deplibs) setglobal tmp_libs = '' for i in [$dependency_libs] { match " $predeps $postdeps $compiler_lib_search_path " { with *" $i "* setglobal i = '' } if test -n $i { func_append tmp_libs " $i" } } setglobal dependency_libs = $tmp_libs } # for pass if test prog = $linkmode { setglobal dlfiles = $newdlfiles } if test prog = $linkmode || test lib = $linkmode { setglobal dlprefiles = $newdlprefiles } match $linkmode { with oldlib if test -n "$dlfiles$dlprefiles" || test no != $dlself { func_warning "'-dlopen' is ignored for archives" } match " $deplibs" { with *\ -l* | *\ -L* func_warning "'-l' and '-L' are ignored for archives" } test -n $rpath && \ func_warning "'-rpath' is ignored for archives" test -n $xrpath && \ func_warning "'-R' is ignored for archives" test -n $vinfo && \ func_warning "'-version-info/-version-number' is ignored for archives" test -n $release && \ func_warning "'-release' is ignored for archives" test -n "$export_symbols$export_symbols_regex" && \ func_warning "'-export-symbols' is ignored for archives" # Now set the variables for building old libraries. setglobal build_libtool_libs = 'no' setglobal oldlibs = $output func_append objs $old_deplibs with lib # Make sure we only generate libraries of the form 'libNAME.la'. match $outputname { with lib* func_stripname 'lib' '.la' $outputname setglobal name = $func_stripname_result eval shared_ext='"'$shrext_cmds'"' eval libname='"'$libname_spec'"' with * test no = $module \ && func_fatal_help "libtool library '$output' must begin with 'lib'" if test no != $need_lib_prefix { # Add the "lib" prefix for modules if required func_stripname '' '.la' $outputname setglobal name = $func_stripname_result eval shared_ext='"'$shrext_cmds'"' eval libname='"'$libname_spec'"' } else { func_stripname '' '.la' $outputname setglobal libname = $func_stripname_result } } if test -n $objs { if test pass_all != $deplibs_check_method { func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs" } else { echo $ECHO "*** Warning: Linking the shared library $output against the non-libtool" $ECHO "*** objects $objs is not portable!" func_append libobjs " $objs" } } test no = $dlself \ || func_warning "'-dlopen self' is ignored for libtool libraries" set dummy $rpath shift test 1 -lt "$Argc" \ && func_warning "ignoring multiple '-rpath's for a libtool library" setglobal install_libdir = $1 setglobal oldlibs = '' if test -z $rpath { if test yes = $build_libtool_libs { # Building a libtool convenience library. # Some compilers have problems with a '.al' extension so # convenience libraries should have the same extension an # archive normally would. setglobal oldlibs = ""$output_objdir/$libname.$libext $oldlibs"" setglobal build_libtool_libs = 'convenience' setglobal build_old_libs = 'yes' } test -n $vinfo && \ func_warning "'-version-info/-version-number' is ignored for convenience libraries" test -n $release && \ func_warning "'-release' is ignored for convenience libraries" } else { # Parse the version information argument. setglobal save_ifs = $IFS; setglobal IFS = ':' set dummy $vinfo 0 0 0 shift setglobal IFS = $save_ifs test -n $7 && \ func_fatal_help "too many parameters to '-version-info'" # convert absolute version numbers to libtool ages # this retains compatibility with .la files and attempts # to make the code below a bit more comprehensible match $vinfo_number { with yes setglobal number_major = $1 setglobal number_minor = $2 setglobal number_revision = $3 # # There are really only two kinds -- those that # use the current revision as the major version # and those that subtract age and use age as # a minor version. But, then there is irix # that has an extra 1 added just for fun # match $version_type { # correct linux to gnu/linux during the next big refactor with darwin|freebsd-elf|linux|osf|windows|none func_arith $number_major + $number_minor setglobal current = $func_arith_result setglobal age = $number_minor setglobal revision = $number_revision with freebsd-aout|qnx|sunos setglobal current = $number_major setglobal revision = $number_minor setglobal age = '0' with irix|nonstopux func_arith $number_major + $number_minor setglobal current = $func_arith_result setglobal age = $number_minor setglobal revision = $number_minor setglobal lt_irix_increment = 'no' with * func_fatal_configuration "$modename: unknown library version type '$version_type'" } with no setglobal current = $1 setglobal revision = $2 setglobal age = $3 } # Check that each of the things are valid numbers. match $current { with 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] with * func_error "CURRENT '$current' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" } match $revision { with 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] with * func_error "REVISION '$revision' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" } match $age { with 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] with * func_error "AGE '$age' must be a nonnegative integer" func_fatal_error "'$vinfo' is not valid version information" } if test $age -gt $current { func_error "AGE '$age' is greater than the current interface number '$current'" func_fatal_error "'$vinfo' is not valid version information" } # Calculate the version variables. setglobal major = '' setglobal versuffix = '' setglobal verstring = '' match $version_type { with none with darwin # Like Linux, but with the current version available in # verstring for coding it into the library header func_arith $current - $age setglobal major = ".$func_arith_result" setglobal versuffix = "$major.$age.$revision" # Darwin ld doesn't like 0 for these options... func_arith $current + 1 setglobal minor_current = $func_arith_result setglobal xlcverstring = ""$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"" setglobal verstring = ""-compatibility_version $minor_current -current_version $minor_current.$revision"" # On Darwin other compilers match $CC { with nagfor* setglobal verstring = ""$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"" with * setglobal verstring = ""-compatibility_version $minor_current -current_version $minor_current.$revision"" } with freebsd-aout setglobal major = ".$current" setglobal versuffix = ".$current.$revision" with freebsd-elf func_arith $current - $age setglobal major = ".$func_arith_result" setglobal versuffix = "$major.$age.$revision" with irix | nonstopux if test no = $lt_irix_increment { func_arith $current - $age } else { func_arith $current - $age + 1 } setglobal major = $func_arith_result match $version_type { with nonstopux setglobal verstring_prefix = 'nonstopux' with * setglobal verstring_prefix = 'sgi' } setglobal verstring = "$verstring_prefix$major.$revision" # Add in all the interfaces that we are compatible with. setglobal loop = $revision while test 0 -ne $loop { func_arith $revision - $loop setglobal iface = $func_arith_result func_arith $loop - 1 setglobal loop = $func_arith_result setglobal verstring = "$verstring_prefix$major.$iface:$verstring" } # Before this point, $major must not contain '.'. setglobal major = ".$major" setglobal versuffix = "$major.$revision" with linux # correct to gnu/linux during the next big refactor func_arith $current - $age setglobal major = ".$func_arith_result" setglobal versuffix = "$major.$age.$revision" with osf func_arith $current - $age setglobal major = ".$func_arith_result" setglobal versuffix = ".$current.$age.$revision" setglobal verstring = "$current.$age.$revision" # Add in all the interfaces that we are compatible with. setglobal loop = $age while test 0 -ne $loop { func_arith $current - $loop setglobal iface = $func_arith_result func_arith $loop - 1 setglobal loop = $func_arith_result setglobal verstring = "$verstring:$iface.0" } # Make executables depend on our current version. func_append verstring ":$current.0" with qnx setglobal major = ".$current" setglobal versuffix = ".$current" with sco setglobal major = ".$current" setglobal versuffix = ".$current" with sunos setglobal major = ".$current" setglobal versuffix = ".$current.$revision" with windows # Use '-' rather than '.', since we only want one # extension on DOS 8.3 file systems. func_arith $current - $age setglobal major = $func_arith_result setglobal versuffix = "-$major" with * func_fatal_configuration "unknown library version type '$version_type'" } # Clear the version info if we defaulted, and they specified a release. if test -z $vinfo && test -n $release { setglobal major = '' match $version_type { with darwin # we can't check for "0.0" in archive_cmds due to quoting # problems, so we reset it completely setglobal verstring = '' with * setglobal verstring = '0.0' } if test no = $need_version { setglobal versuffix = '' } else { setglobal versuffix = '.0.0' } } # Remove version info from name if versioning should be avoided if test yes,no = "$avoid_version,$need_version" { setglobal major = '' setglobal versuffix = '' setglobal verstring = '' } # Check to see if the archive will have undefined symbols. if test yes = $allow_undefined { if test unsupported = $allow_undefined_flag { if test yes = $build_old_libs { func_warning "undefined symbols not allowed in $host shared libraries; building static only" setglobal build_libtool_libs = 'no' } else { func_fatal_error "can't build $host shared library unless -no-undefined is specified" } } } else { # Don't allow undefined symbols. setglobal allow_undefined_flag = $no_undefined_flag } } func_generate_dlsyms $libname $libname : func_append libobjs " $symfileobj" test " " = $libobjs && setglobal libobjs = '' if test relink != $opt_mode { # Remove our outputs, but don't remove object files since they # may have been created when compiling PIC objects. setglobal removelist = '' setglobal tempremovelist = $[$ECHO "$output_objdir/*] for p in [$tempremovelist] { match $p { with *.$objext | *.gcno with $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.* if test -n $precious_files_regex { if $ECHO $p | $EGREP -e $precious_files_regex >/dev/null !2 > !1 { continue } } func_append removelist " $p" with * } } test -n $removelist && \ func_show_eval "$(RM)r \$removelist" } # Now set the variables for building old libraries. if test yes = $build_old_libs && test convenience != $build_libtool_libs { func_append oldlibs " $output_objdir/$libname.$libext" # Transform .lo files to .o files. setglobal oldobjs = ""$objs "$[$ECHO $libobjs | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP]" } # Eliminate all temporary directories. #for path in $notinst_path; do # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` #done if test -n $xrpath { # If the user specified any rpath flags, then add them. setglobal temp_xrpath = '' for libdir in [$xrpath] { func_replace_sysroot $libdir func_append temp_xrpath " -R$func_replace_sysroot_result" match "$finalize_rpath " { with *" $libdir "* with * func_append finalize_rpath " $libdir" } } if test yes != $hardcode_into_libs || test yes = $build_old_libs { setglobal dependency_libs = ""$temp_xrpath $dependency_libs"" } } # Make sure dlfiles contains only unique files that won't be dlpreopened setglobal old_dlfiles = $dlfiles setglobal dlfiles = '' for lib in [$old_dlfiles] { match " $dlprefiles $dlfiles " { with *" $lib "* with * func_append dlfiles " $lib" } } # Make sure dlprefiles contains only unique files setglobal old_dlprefiles = $dlprefiles setglobal dlprefiles = '' for lib in [$old_dlprefiles] { match "$dlprefiles " { with *" $lib "* with * func_append dlprefiles " $lib" } } if test yes = $build_libtool_libs { if test -n $rpath { match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku* # these systems don't actually have a c library (as such)! with *-*-rhapsody* | *-*-darwin1.[012] # Rhapsody C library is in the System framework func_append deplibs " System.ltframework" with *-*-netbsd* # Don't link with libc until the a.out ld.so is fixed. with *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* # Do not include libc due to us having libc/libc_r. with *-*-sco3.2v5* | *-*-sco5v6* # Causes problems with __ctype with *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX* # Compiler inserts libc in the correct place for threads to work with * # Add libc to deplibs on all other systems if necessary. if test yes = $build_libtool_need_lc { func_append deplibs " -lc" } } } # Transform deplibs into only deplibs that can be linked in shared. setglobal name_save = $name setglobal libname_save = $libname setglobal release_save = $release setglobal versuffix_save = $versuffix setglobal major_save = $major # I'm not sure if I'm treating the release correctly. I think # release should show up in the -l (ie -lgmp5) so we don't want to # add it in twice. Is that correct? setglobal release = '' setglobal versuffix = '' setglobal major = '' setglobal newdeplibs = '' setglobal droppeddeps = 'no' match $deplibs_check_method { with pass_all # Don't check for shared/static. Everything works. # This might be a little naive. We might want to check # whether the library exists or not. But this is on # osf3 & osf4 and I'm not really sure... Just # implementing what was already the behavior. setglobal newdeplibs = $deplibs with test_compile # This code stresses the "libraries are programs" paradigm to its # limits. Maybe even breaks it. We compile a program, linking it # against the deplibs as a proxy for the library. Then we can check # whether they linked in statically or dynamically with ldd. $opt_dry_run || $RM conftest.c cat > conftest.c << """ int main() { return 0; } """ $opt_dry_run || $RM conftest if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs { setglobal ldd_output = $[ldd conftest] for i in [$deplibs] { match $i { with -l* func_stripname -l '' $i setglobal name = $func_stripname_result if test yes = $allow_libtool_libs_with_static_runtimes { match " $predeps $postdeps " { with *" $i "* func_append newdeplibs " $i" setglobal i = '' } } if test -n $i { setglobal libname = $[eval "\\$ECHO \"$libname_spec] setglobal deplib_matches = $[eval "\\$ECHO \"$library_names_spec] set dummy $deplib_matches; shift setglobal deplib_match = $1 if test $[expr $ldd_output : ".*$deplib_match] -ne 0 { func_append newdeplibs " $i" } else { setglobal droppeddeps = 'yes' echo $ECHO "*** Warning: dynamic linker does not accept needed library $i." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which I believe you do not have" echo "*** because a test_compile did reveal that the linker did not use it for" echo "*** its dynamic dependency list that programs get resolved with at runtime." } } with * func_append newdeplibs " $i" } } } else { # Error occurred in the first compile. Let's try to salvage # the situation: Compile a separate program for each library. for i in [$deplibs] { match $i { with -l* func_stripname -l '' $i setglobal name = $func_stripname_result $opt_dry_run || $RM conftest if $LTCC $LTCFLAGS -o conftest conftest.c $i { setglobal ldd_output = $[ldd conftest] if test yes = $allow_libtool_libs_with_static_runtimes { match " $predeps $postdeps " { with *" $i "* func_append newdeplibs " $i" setglobal i = '' } } if test -n $i { setglobal libname = $[eval "\\$ECHO \"$libname_spec] setglobal deplib_matches = $[eval "\\$ECHO \"$library_names_spec] set dummy $deplib_matches; shift setglobal deplib_match = $1 if test $[expr $ldd_output : ".*$deplib_match] -ne 0 { func_append newdeplibs " $i" } else { setglobal droppeddeps = 'yes' echo $ECHO "*** Warning: dynamic linker does not accept needed library $i." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because a test_compile did reveal that the linker did not use this one" echo "*** as a dynamic dependency that programs can get resolved with at runtime." } } } else { setglobal droppeddeps = 'yes' echo $ECHO "*** Warning! Library $i is needed by this library but I was not able to" echo "*** make it link in! You will probably need to install it or some" echo "*** library that it depends on before this library will be fully" echo "*** functional. Installing it before continuing would be even better." } with * func_append newdeplibs " $i" } } } with file_magic* set dummy $deplibs_check_method; shift setglobal file_magic_regex = $[expr $deplibs_check_method : "$1 \(.*\)] for a_deplib in [$deplibs] { match $a_deplib { with -l* func_stripname -l '' $a_deplib setglobal name = $func_stripname_result if test yes = $allow_libtool_libs_with_static_runtimes { match " $predeps $postdeps " { with *" $a_deplib "* func_append newdeplibs " $a_deplib" setglobal a_deplib = '' } } if test -n $a_deplib { setglobal libname = $[eval "\\$ECHO \"$libname_spec] if test -n $file_magic_glob { setglobal libnameglob = $[func_echo_all $libname | $SED -e $file_magic_glob] } else { setglobal libnameglob = $libname } test yes = $want_nocaseglob && setglobal nocaseglob = $[shopt -p nocaseglob] for i in [$lib_search_path $sys_lib_search_path $shlib_search_path] { if test yes = $want_nocaseglob { shopt -s nocaseglob setglobal potential_libs = $[ls $i/$libnameglob[.-]* !2 >/dev/null] $nocaseglob } else { setglobal potential_libs = $[ls $i/$libnameglob[.-]* !2 >/dev/null] } for potent_lib in [$potential_libs] { # Follow soft links. if ls -lLd $potent_lib !2 >/dev/null | $GREP " -> " >/dev/null { continue } # The statement above tries to avoid entering an # endless loop below, in case of cyclic links. # We might still enter an endless loop, since a link # loop can be closed while we follow links, # but so what? setglobal potlib = $potent_lib while test -h $potlib !2 >/dev/null { setglobal potliblink = $[ls -ld $potlib | $SED 's/.* -> //] match $potliblink { with [\\/]* | [A-Za-z]:[\\/]* setglobal potlib = $potliblink with * setglobal potlib = "$[$ECHO $potlib | $SED 's|[^/]*$||]"$potliblink"" } } if eval $file_magic_cmd '"''$'potlib'"' !2 >/dev/null | $SED -e 10q | $EGREP $file_magic_regex > /dev/null { func_append newdeplibs " $a_deplib" setglobal a_deplib = '' break 2 } } } } if test -n $a_deplib { setglobal droppeddeps = 'yes' echo $ECHO "*** Warning: linker path does not have real file for library $a_deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because I did check the linker path looking for a file starting" if test -z $potlib { $ECHO "*** with $libname but no candidates were found. (...for file magic test)" } else { $ECHO "*** with $libname and none of the candidates passed a file format test" $ECHO "*** using a file magic. Last file checked: $potlib" } } with * # Add a -L argument. func_append newdeplibs " $a_deplib" } } # Gone through all deplibs. with match_pattern* set dummy $deplibs_check_method; shift setglobal match_pattern_regex = $[expr $deplibs_check_method : "$1 \(.*\)] for a_deplib in [$deplibs] { match $a_deplib { with -l* func_stripname -l '' $a_deplib setglobal name = $func_stripname_result if test yes = $allow_libtool_libs_with_static_runtimes { match " $predeps $postdeps " { with *" $a_deplib "* func_append newdeplibs " $a_deplib" setglobal a_deplib = '' } } if test -n $a_deplib { setglobal libname = $[eval "\\$ECHO \"$libname_spec] for i in [$lib_search_path $sys_lib_search_path $shlib_search_path] { setglobal potential_libs = $[ls $i/$libname[.-]* !2 >/dev/null] for potent_lib in [$potential_libs] { setglobal potlib = $potent_lib # see symlink-check above in file_magic test if eval "\$ECHO \"$potent_lib\"" !2 >/dev/null | $SED 10q | \ $EGREP $match_pattern_regex > /dev/null { func_append newdeplibs " $a_deplib" setglobal a_deplib = '' break 2 } } } } if test -n $a_deplib { setglobal droppeddeps = 'yes' echo $ECHO "*** Warning: linker path does not have real file for library $a_deplib." echo "*** I have the capability to make that library automatically link in when" echo "*** you link to this library. But I can only do this if you have a" echo "*** shared version of the library, which you do not appear to have" echo "*** because I did check the linker path looking for a file starting" if test -z $potlib { $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" } else { $ECHO "*** with $libname and none of the candidates passed a file format test" $ECHO "*** using a regex pattern. Last file checked: $potlib" } } with * # Add a -L argument. func_append newdeplibs " $a_deplib" } } # Gone through all deplibs. with none | unknown | * setglobal newdeplibs = '' setglobal tmp_deplibs = $[$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g] if test yes = $allow_libtool_libs_with_static_runtimes { for i in [$predeps $postdeps] { # can't use Xsed below, because $i might contain '/' setglobal tmp_deplibs = $[$ECHO " $tmp_deplibs" | $SED "s|$i||] } } match $tmp_deplibs { with *[!\ \ ]* echo if test none = $deplibs_check_method { echo "*** Warning: inter-library dependencies are not supported in this platform." } else { echo "*** Warning: inter-library dependencies are not known to be supported." } echo "*** All declared inter-library dependencies are being dropped." setglobal droppeddeps = 'yes' } } setglobal versuffix = $versuffix_save setglobal major = $major_save setglobal release = $release_save setglobal libname = $libname_save setglobal name = $name_save match $host { with *-*-rhapsody* | *-*-darwin1.[012] # On Rhapsody replace the C library with the System framework setglobal newdeplibs = $[$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /] } if test yes = $droppeddeps { if test yes = $module { echo echo "*** Warning: libtool could not satisfy all declared inter-library" $ECHO "*** dependencies of module $libname. Therefore, libtool will create" echo "*** a static module, that should work as long as the dlopening" echo "*** application is linked with the -dlopen flag." if test -z $global_symbol_pipe { echo echo "*** However, this would only work if libtool was able to extract symbol" echo "*** lists from a program, using 'nm' or equivalent, but libtool could" echo "*** not find such a program. So, this module is probably useless." echo "*** 'nm' from GNU binutils and a full rebuild may help." } if test no = $build_old_libs { setglobal oldlibs = "$output_objdir/$libname.$libext" setglobal build_libtool_libs = 'module' setglobal build_old_libs = 'yes' } else { setglobal build_libtool_libs = 'no' } } else { echo "*** The inter-library dependencies that have been dropped here will be" echo "*** automatically added whenever a program is linked with this library" echo "*** or is declared to -dlopen it." if test no = $allow_undefined { echo echo "*** Since this library must not contain undefined symbols," echo "*** because either the platform does not support them or" echo "*** it was explicitly requested with -no-undefined," echo "*** libtool will only create a static version of it." if test no = $build_old_libs { setglobal oldlibs = "$output_objdir/$libname.$libext" setglobal build_libtool_libs = 'module' setglobal build_old_libs = 'yes' } else { setglobal build_libtool_libs = 'no' } } } } # Done checking deplibs! setglobal deplibs = $newdeplibs } # Time to change all our "foo.ltframework" stuff back to "-framework foo" match $host { with *-*-darwin* setglobal newdeplibs = $[$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] setglobal new_inherited_linker_flags = $[$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] setglobal deplibs = $[$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] } # move library search paths that coincide with paths to not yet # installed libraries to the beginning of the library search list setglobal new_libs = '' for path in [$notinst_path] { match " $new_libs " { with *" -L$path/$objdir "* with * match " $deplibs " { with *" -L$path/$objdir "* func_append new_libs " -L$path/$objdir" } } } for deplib in [$deplibs] { match $deplib { with -L* match " $new_libs " { with *" $deplib "* with * func_append new_libs " $deplib" } with * func_append new_libs " $deplib" } } setglobal deplibs = $new_libs # All the library-specific variables (install_libdir is set above). setglobal library_names = '' setglobal old_library = '' setglobal dlname = '' # Test again, we may have decided not to build it any more if test yes = $build_libtool_libs { # Remove $wl instances when linking with ld. # FIXME: should test the right _cmds variable. match $archive_cmds { with *\$LD\ * setglobal wl = '' } if test yes = $hardcode_into_libs { # Hardcode the library paths setglobal hardcode_libdirs = '' setglobal dep_rpath = '' setglobal rpath = $finalize_rpath test relink = $opt_mode || setglobal rpath = "$compile_rpath$rpath" for libdir in [$rpath] { if test -n $hardcode_libdir_flag_spec { if test -n $hardcode_libdir_separator { func_replace_sysroot $libdir setglobal libdir = $func_replace_sysroot_result if test -z $hardcode_libdirs { setglobal hardcode_libdirs = $libdir } else { # Just accumulate the unique libdirs. match $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator { with *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* with * func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" } } } else { eval flag='"'$hardcode_libdir_flag_spec'"' func_append dep_rpath " $flag" } } elif test -n $runpath_var { match "$perm_rpath " { with *" $libdir "* with * func_append perm_rpath " $libdir" } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setglobal libdir = $hardcode_libdirs eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" } if test -n $runpath_var && test -n $perm_rpath { # We should set the runpath_var. setglobal rpath = '' for dir in [$perm_rpath] { func_append rpath "$dir:" } eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" } test -n $dep_rpath && setglobal deplibs = ""$dep_rpath $deplibs"" } setglobal shlibpath = $finalize_shlibpath test relink = $opt_mode || setglobal shlibpath = "$compile_shlibpath$shlibpath" if test -n $shlibpath { eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" } # Get the real and link names of the library. eval shared_ext='"'$shrext_cmds'"' eval library_names='"'$library_names_spec'"' set dummy $library_names shift setglobal realname = $1 shift if test -n $soname_spec { eval soname='"'$soname_spec'"' } else { setglobal soname = $realname } if test -z $dlname { setglobal dlname = $soname } setglobal lib = "$output_objdir/$realname" setglobal linknames = ''for link in @Argv { func_append linknames " $link" } # Use standard objects if they are pic test -z $pic_flag && setglobal libobjs = $[$ECHO $libobjs | $SP2NL | $SED $lo2o | $NL2SP] test "X$libobjs" = "X " && setglobal libobjs = '' setglobal delfiles = '' if test -n $export_symbols && test -n $include_expsyms { $opt_dry_run || cp $export_symbols "$output_objdir/$libname.uexp" setglobal export_symbols = "$output_objdir/$libname.uexp" func_append delfiles " $export_symbols" } setglobal orig_export_symbols = '' match $host_os { with cygwin* | mingw* | cegcc* if test -n $export_symbols && test -z $export_symbols_regex { # exporting using user supplied symfile func_dll_def_p $export_symbols || do { # and it's NOT already a .def file. Must figure out # which of the given symbols are data symbols and tag # them as such. So, trigger use of export_symbols_cmds. # export_symbols gets reassigned inside the "prepare # the list of exported symbols" if statement, so the # include_expsyms logic still works. setglobal orig_export_symbols = $export_symbols setglobal export_symbols = '' setglobal always_export_symbols = 'yes' } } } # Prepare the list of exported symbols if test -z $export_symbols { if test yes = $always_export_symbols || test -n $export_symbols_regex { func_verbose "generating symbol list for '$libname.la'" setglobal export_symbols = "$output_objdir/$libname.exp" $opt_dry_run || $RM $export_symbols setglobal cmds = $export_symbols_cmds setglobal save_ifs = $IFS; setglobal IFS = ''~'' for cmd1 in [$cmds] { setglobal IFS = $save_ifs # Take the normal branch if the nm_file_list_spec branch # doesn't work or if tool conversion is not needed. match $nm_file_list_spec~$to_tool_file_cmd { with *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~* setglobal try_normal_branch = 'yes' eval cmd='"'$cmd1'"' func_len " $cmd" setglobal len = $func_len_result with * setglobal try_normal_branch = 'no' } if test yes = $try_normal_branch \ && do { test $len -lt $max_cmd_len \ || test $max_cmd_len -le -1; } { func_show_eval $cmd 'exit $?' setglobal skipped_export = 'false' } elif test -n $nm_file_list_spec { func_basename $output setglobal output_la = $func_basename_result setglobal save_libobjs = $libobjs setglobal save_output = $output setglobal output = "$output_objdir/$output_la.nm" func_to_tool_file $output setglobal libobjs = "$nm_file_list_spec$func_to_tool_file_result" func_append delfiles " $output" func_verbose "creating $NM input file list: $output" for obj in [$save_libobjs] { func_to_tool_file $obj $ECHO $func_to_tool_file_result } > "$output" eval cmd='"'$cmd1'"' func_show_eval $cmd 'exit $?' setglobal output = $save_output setglobal libobjs = $save_libobjs setglobal skipped_export = 'false' } else { # The command line is too long to execute in one step. func_verbose "using reloadable object file for export list..." setglobal skipped_export = ':' # Break out early, otherwise skipped_export may be # set to false by a later but shorter cmd. break } } setglobal IFS = $save_ifs if test -n $export_symbols_regex && test : != $skipped_export { func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' func_show_eval '$MV "${export_symbols}T" "$export_symbols"' } } } if test -n $export_symbols && test -n $include_expsyms { setglobal tmp_export_symbols = $export_symbols test -n $orig_export_symbols && setglobal tmp_export_symbols = $orig_export_symbols $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' } if test : != $skipped_export && test -n $orig_export_symbols { # The given exports_symbols file has to be filtered, so filter it. func_verbose "filter symbol list for '$libname.la' to tag DATA exports" # FIXME: $output_objdir/$libname.filter potentially contains lots of # 's' commands, which not all seds can handle. GNU sed should be fine # though. Also, the filter scales superlinearly with the number of # global variables. join(1) would be nice here, but unfortunately # isn't a blessed tool. $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter func_append delfiles " $export_symbols $output_objdir/$libname.filter" setglobal export_symbols = "$output_objdir/$libname.def" $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols } setglobal tmp_deplibs = '' for test_deplib in [$deplibs] { match " $convenience " { with *" $test_deplib "* with * func_append tmp_deplibs " $test_deplib" } } setglobal deplibs = $tmp_deplibs if test -n $convenience { if test -n $whole_archive_flag_spec && test yes = $compiler_needs_object && test -z $libobjs { # extract the archives, so we have objects to list. # TODO: could optimize this to just extract one archive. setglobal whole_archive_flag_spec = '' } if test -n $whole_archive_flag_spec { setglobal save_libobjs = $libobjs eval libobjs='"''$'libobjs $whole_archive_flag_spec'"' test "X$libobjs" = "X " && setglobal libobjs = '' } else { setglobal gentop = "$output_objdir/$(outputname)x" func_append generated " $gentop" func_extract_archives $gentop $convenience func_append libobjs " $func_extract_archives_result" test "X$libobjs" = "X " && setglobal libobjs = '' } } if test yes = $thread_safe && test -n $thread_safe_flag_spec { eval flag='"'$thread_safe_flag_spec'"' func_append linker_flags " $flag" } # Make a backup of the uninstalled library when relinking if test relink = $opt_mode { $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? } # Do each of the archive commands. if test yes = $module && test -n $module_cmds { if test -n $export_symbols && test -n $module_expsym_cmds { eval test_cmds='"'$module_expsym_cmds'"' setglobal cmds = $module_expsym_cmds } else { eval test_cmds='"'$module_cmds'"' setglobal cmds = $module_cmds } } else { if test -n $export_symbols && test -n $archive_expsym_cmds { eval test_cmds='"'$archive_expsym_cmds'"' setglobal cmds = $archive_expsym_cmds } else { eval test_cmds='"'$archive_cmds'"' setglobal cmds = $archive_cmds } } if test : != $skipped_export && func_len " $test_cmds" && setglobal len = $func_len_result && test $len -lt $max_cmd_len || test $max_cmd_len -le -1 { : } else { # The command line is too long to link in one step, link piecewise # or, if using GNU ld and skipped_export is not :, use a linker # script. # Save the value of $output and $libobjs because we want to # use them later. If we have whole_archive_flag_spec, we # want to use save_libobjs as it was before # whole_archive_flag_spec was expanded, because we can't # assume the linker understands whole_archive_flag_spec. # This may have to be revisited, in case too many # convenience libraries get linked in and end up exceeding # the spec. if test -z $convenience || test -z $whole_archive_flag_spec { setglobal save_libobjs = $libobjs } setglobal save_output = $output func_basename $output setglobal output_la = $func_basename_result # Clear the reloadable object creation command queue and # initialize k to one. setglobal test_cmds = '' setglobal concat_cmds = '' setglobal objlist = '' setglobal last_robj = '' setglobal k = '1' if test -n $save_libobjs && test : != $skipped_export && test yes = $with_gnu_ld { setglobal output = "$output_objdir/$output_la.lnkscript" func_verbose "creating GNU ld script: $output" echo 'INPUT (' > $output for obj in [$save_libobjs] { func_to_tool_file $obj $ECHO $func_to_tool_file_result >> $output } echo ')' >> $output func_append delfiles " $output" func_to_tool_file $output setglobal output = $func_to_tool_file_result } elif test -n $save_libobjs && test : != $skipped_export && test -n $file_list_spec { setglobal output = "$output_objdir/$output_la.lnk" func_verbose "creating linker input file list: $output" : > $output set x $save_libobjs shift setglobal firstobj = '' if test yes = $compiler_needs_object { setglobal firstobj = ""$1 "" shift }for obj in @Argv { func_to_tool_file $obj $ECHO $func_to_tool_file_result >> $output } func_append delfiles " $output" func_to_tool_file $output setglobal output = "$firstobj'"'$file_list_spec$func_to_tool_file_result'"'" } else { if test -n $save_libobjs { func_verbose "creating reloadable object files..." setglobal output = "$output_objdir/$output_la-$k.$objext" eval test_cmds='"'$reload_cmds'"' func_len " $test_cmds" setglobal len0 = $func_len_result setglobal len = $len0 # Loop over the list of objects to be linked. for obj in [$save_libobjs] { func_len " $obj" func_arith $len + $func_len_result setglobal len = $func_arith_result if test -z $objlist || test $len -lt $max_cmd_len { func_append objlist " $obj" } else { # The command $test_cmds is almost too long, add a # command to the queue. if test 1 -eq $k { # The first file doesn't have a previous command to add. setglobal reload_objs = $objlist eval concat_cmds='"'$reload_cmds'"' } else { # All subsequent reloadable object files will link in # the last one created. setglobal reload_objs = ""$objlist $last_robj"" eval concat_cmds='"''$'concat_cmds~$reload_cmds~'$'RM $last_robj'"' } setglobal last_robj = "$output_objdir/$output_la-$k.$objext" func_arith $k + 1 setglobal k = $func_arith_result setglobal output = "$output_objdir/$output_la-$k.$objext" setglobal objlist = "" $obj"" func_len " $last_robj" func_arith $len0 + $func_len_result setglobal len = $func_arith_result } } # Handle the remaining objects by creating one last # reloadable object file. All subsequent reloadable object # files will link in the last one created. test -z $concat_cmds || setglobal concat_cmds = "$concat_cmds~" setglobal reload_objs = ""$objlist $last_robj"" eval concat_cmds='"''$'concat_cmds$reload_cmds'"' if test -n $last_robj { eval concat_cmds='"''$'concat_cmds~'$'RM $last_robj'"' } func_append delfiles " $output" } else { setglobal output = '' } $(skipped_export-false) && do { func_verbose "generating symbol list for '$libname.la'" setglobal export_symbols = "$output_objdir/$libname.exp" $opt_dry_run || $RM $export_symbols setglobal libobjs = $output # Append the command to create the export file. test -z $concat_cmds || setglobal concat_cmds = "$concat_cmds~" eval concat_cmds='"''$'concat_cmds$export_symbols_cmds'"' if test -n $last_robj { eval concat_cmds='"''$'concat_cmds~'$'RM $last_robj'"' } } test -n $save_libobjs && func_verbose "creating a temporary reloadable object file: $output" # Loop through the commands generated above and execute them. setglobal save_ifs = $IFS; setglobal IFS = ''~'' for cmd in [$concat_cmds] { setglobal IFS = $save_ifs $opt_quiet || do { func_quote_for_expand $cmd eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval $cmd || do { setglobal lt_exit = $Status # Restore the uninstalled library and exit if test relink = $opt_mode { shell { cd $output_objdir && \ $RM "$(realname)T" && \ $MV "$(realname)U" $realname } } exit $lt_exit } } setglobal IFS = $save_ifs if test -n $export_symbols_regex && $(skipped_export-false) { func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' func_show_eval '$MV "${export_symbols}T" "$export_symbols"' } } $(skipped_export-false) && do { if test -n $export_symbols && test -n $include_expsyms { setglobal tmp_export_symbols = $export_symbols test -n $orig_export_symbols && setglobal tmp_export_symbols = $orig_export_symbols $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' } if test -n $orig_export_symbols { # The given exports_symbols file has to be filtered, so filter it. func_verbose "filter symbol list for '$libname.la' to tag DATA exports" # FIXME: $output_objdir/$libname.filter potentially contains lots of # 's' commands, which not all seds can handle. GNU sed should be fine # though. Also, the filter scales superlinearly with the number of # global variables. join(1) would be nice here, but unfortunately # isn't a blessed tool. $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter func_append delfiles " $export_symbols $output_objdir/$libname.filter" setglobal export_symbols = "$output_objdir/$libname.def" $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols } } setglobal libobjs = $output # Restore the value of output. setglobal output = $save_output if test -n $convenience && test -n $whole_archive_flag_spec { eval libobjs='"''$'libobjs $whole_archive_flag_spec'"' test "X$libobjs" = "X " && setglobal libobjs = '' } # Expand the library linking commands again to reset the # value of $libobjs for piecewise linking. # Do each of the archive commands. if test yes = $module && test -n $module_cmds { if test -n $export_symbols && test -n $module_expsym_cmds { setglobal cmds = $module_expsym_cmds } else { setglobal cmds = $module_cmds } } else { if test -n $export_symbols && test -n $archive_expsym_cmds { setglobal cmds = $archive_expsym_cmds } else { setglobal cmds = $archive_cmds } } } if test -n $delfiles { # Append the command to remove temporary files to $cmds. eval cmds='"''$'cmds~'$'RM $delfiles'"' } # Add any objects from preloaded convenience libraries if test -n $dlprefiles { setglobal gentop = "$output_objdir/$(outputname)x" func_append generated " $gentop" func_extract_archives $gentop $dlprefiles func_append libobjs " $func_extract_archives_result" test "X$libobjs" = "X " && setglobal libobjs = '' } setglobal save_ifs = $IFS; setglobal IFS = ''~'' for cmd in [$cmds] { setglobal IFS = "$sp$nl" eval cmd='"'$cmd'"' setglobal IFS = $save_ifs $opt_quiet || do { func_quote_for_expand $cmd eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval $cmd || do { setglobal lt_exit = $Status # Restore the uninstalled library and exit if test relink = $opt_mode { shell { cd $output_objdir && \ $RM "$(realname)T" && \ $MV "$(realname)U" $realname } } exit $lt_exit } } setglobal IFS = $save_ifs # Restore the uninstalled library and exit if test relink = $opt_mode { $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? if test -n $convenience { if test -z $whole_archive_flag_spec { func_show_eval '${RM}r "$gentop"' } } exit $EXIT_SUCCESS } # Create links to the real library. for linkname in [$linknames] { if test $realname != $linkname { func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' } } # If -module or -export-dynamic was specified, set the dlname. if test yes = $module || test yes = $export_dynamic { # On all known operating systems, these are identical. setglobal dlname = $soname } } with obj if test -n "$dlfiles$dlprefiles" || test no != $dlself { func_warning "'-dlopen' is ignored for objects" } match " $deplibs" { with *\ -l* | *\ -L* func_warning "'-l' and '-L' are ignored for objects" } test -n $rpath && \ func_warning "'-rpath' is ignored for objects" test -n $xrpath && \ func_warning "'-R' is ignored for objects" test -n $vinfo && \ func_warning "'-version-info' is ignored for objects" test -n $release && \ func_warning "'-release' is ignored for objects" match $output { with *.lo test -n "$objs$old_deplibs" && \ func_fatal_error "cannot build library object '$output' from non-libtool objects" setglobal libobj = $output func_lo2o $libobj setglobal obj = $func_lo2o_result with * setglobal libobj = '' setglobal obj = $output } # Delete the old objects. $opt_dry_run || $RM $obj $libobj # Objects from convenience libraries. This assumes # single-version convenience libraries. Whenever we create # different ones for PIC/non-PIC, this we'll have to duplicate # the extraction. setglobal reload_conv_objs = '' setglobal gentop = '' # if reload_cmds runs $LD directly, get rid of -Wl from # whole_archive_flag_spec and hope we can get by with turning comma # into space. match $reload_cmds { with *\$LD[\ \$]* setglobal wl = '' } if test -n $convenience { if test -n $whole_archive_flag_spec { eval tmp_whole_archive_flags='"'$whole_archive_flag_spec'"' test -n $wl || setglobal tmp_whole_archive_flags = $[$ECHO $tmp_whole_archive_flags | $SED 's|,| |g] setglobal reload_conv_objs = "$reload_objs' '$tmp_whole_archive_flags" } else { setglobal gentop = "$output_objdir/$(obj)x" func_append generated " $gentop" func_extract_archives $gentop $convenience setglobal reload_conv_objs = ""$reload_objs $func_extract_archives_result"" } } # If we're not building shared, we need to use non_pic_objs test yes = $build_libtool_libs || setglobal libobjs = $non_pic_objects # Create the old-style object. setglobal reload_objs = "$objs$old_deplibs' '$[$ECHO $libobjs | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP]' '$reload_conv_objs" setglobal output = $obj func_execute_cmds $reload_cmds 'exit $?' # Exit if we aren't doing a library object file. if test -z $libobj { if test -n $gentop { func_show_eval '${RM}r "$gentop"' } exit $EXIT_SUCCESS } test yes = $build_libtool_libs || do { if test -n $gentop { func_show_eval '${RM}r "$gentop"' } # Create an invalid libtool object if no PIC, so that we don't # accidentally link it into a program. # $show "echo timestamp > $libobj" # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? exit $EXIT_SUCCESS } if test -n $pic_flag || test default != $pic_mode { # Only do commands if we really have different PIC objects. setglobal reload_objs = ""$libobjs $reload_conv_objs"" setglobal output = $libobj func_execute_cmds $reload_cmds 'exit $?' } if test -n $gentop { func_show_eval '${RM}r "$gentop"' } exit $EXIT_SUCCESS with prog match $host { with *cygwin* func_stripname '' '.exe' $output setglobal output = "$func_stripname_result.exe" } test -n $vinfo && \ func_warning "'-version-info' is ignored for programs" test -n $release && \ func_warning "'-release' is ignored for programs" $preload \ && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \ && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support." match $host { with *-*-rhapsody* | *-*-darwin1.[012] # On Rhapsody replace the C library is the System framework setglobal compile_deplibs = $[$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /] setglobal finalize_deplibs = $[$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /] } match $host { with *-*-darwin* # Don't allow lazy linking, it breaks C++ global constructors # But is supposedly fixed on 10.4 or later (yay!). if test CXX = $tagname { match $(MACOSX_DEPLOYMENT_TARGET-10.0) { with 10.[0123] func_append compile_command " $wl-bind_at_load" func_append finalize_command " $wl-bind_at_load" } } # Time to change all our "foo.ltframework" stuff back to "-framework foo" setglobal compile_deplibs = $[$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] setglobal finalize_deplibs = $[$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g] } # move library search paths that coincide with paths to not yet # installed libraries to the beginning of the library search list setglobal new_libs = '' for path in [$notinst_path] { match " $new_libs " { with *" -L$path/$objdir "* with * match " $compile_deplibs " { with *" -L$path/$objdir "* func_append new_libs " -L$path/$objdir" } } } for deplib in [$compile_deplibs] { match $deplib { with -L* match " $new_libs " { with *" $deplib "* with * func_append new_libs " $deplib" } with * func_append new_libs " $deplib" } } setglobal compile_deplibs = $new_libs func_append compile_command " $compile_deplibs" func_append finalize_command " $finalize_deplibs" if test -n "$rpath$xrpath" { # If the user specified any rpath flags, then add them. for libdir in [$rpath $xrpath] { # This is the magic to use -rpath. match "$finalize_rpath " { with *" $libdir "* with * func_append finalize_rpath " $libdir" } } } # Now hardcode the library paths setglobal rpath = '' setglobal hardcode_libdirs = '' for libdir in [$compile_rpath $finalize_rpath] { if test -n $hardcode_libdir_flag_spec { if test -n $hardcode_libdir_separator { if test -z $hardcode_libdirs { setglobal hardcode_libdirs = $libdir } else { # Just accumulate the unique libdirs. match $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator { with *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* with * func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" } } } else { eval flag='"'$hardcode_libdir_flag_spec'"' func_append rpath " $flag" } } elif test -n $runpath_var { match "$perm_rpath " { with *" $libdir "* with * func_append perm_rpath " $libdir" } } match $host { with *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc* setglobal testbindir = $[$ECHO $libdir | $SED -e 's*/lib$*/bin*] match :$dllsearchpath: { with *":$libdir:"* with :: setglobal dllsearchpath = $libdir with * func_append dllsearchpath ":$libdir" } match :$dllsearchpath: { with *":$testbindir:"* with :: setglobal dllsearchpath = $testbindir with * func_append dllsearchpath ":$testbindir" } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setglobal libdir = $hardcode_libdirs eval rpath='"' $hardcode_libdir_flag_spec'"' } setglobal compile_rpath = $rpath setglobal rpath = '' setglobal hardcode_libdirs = '' for libdir in [$finalize_rpath] { if test -n $hardcode_libdir_flag_spec { if test -n $hardcode_libdir_separator { if test -z $hardcode_libdirs { setglobal hardcode_libdirs = $libdir } else { # Just accumulate the unique libdirs. match $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator { with *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* with * func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" } } } else { eval flag='"'$hardcode_libdir_flag_spec'"' func_append rpath " $flag" } } elif test -n $runpath_var { match "$finalize_perm_rpath " { with *" $libdir "* with * func_append finalize_perm_rpath " $libdir" } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setglobal libdir = $hardcode_libdirs eval rpath='"' $hardcode_libdir_flag_spec'"' } setglobal finalize_rpath = $rpath if test -n $libobjs && test yes = $build_old_libs { # Transform all the library objects into standard objects. setglobal compile_command = $[$ECHO $compile_command | $SP2NL | $SED $lo2o | $NL2SP] setglobal finalize_command = $[$ECHO $finalize_command | $SP2NL | $SED $lo2o | $NL2SP] } func_generate_dlsyms $outputname "@PROGRAM@" false # template prelinking step if test -n $prelink_cmds { func_execute_cmds $prelink_cmds 'exit $?' } setglobal wrappers_required = ':' match $host { with *cegcc* | *mingw32ce* # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. setglobal wrappers_required = 'false' with *cygwin* | *mingw* test yes = $build_libtool_libs || setglobal wrappers_required = 'false' with * if test no = $need_relink || test yes != $build_libtool_libs { setglobal wrappers_required = 'false' } } $wrappers_required || do { # Replace the output file specification. setglobal compile_command = $[$ECHO $compile_command | $SED 's%@OUTPUT@%'"$output"'%g] setglobal link_command = "$compile_command$compile_rpath" # We have no uninstalled library dependencies, so finalize right now. setglobal exit_status = '0' func_show_eval $link_command 'exit_status=$?' if test -n $postlink_cmds { func_to_tool_file $output setglobal postlink_cmds = $[func_echo_all $postlink_cmds | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g] func_execute_cmds $postlink_cmds 'exit $?' } # Delete the generated files. if test -f "$output_objdir/$(outputname)S.$objext" { func_show_eval '$RM "$output_objdir/${outputname}S.$objext"' } exit $exit_status } if test -n "$compile_shlibpath$finalize_shlibpath" { setglobal compile_command = ""$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"" } if test -n $finalize_shlibpath { setglobal finalize_command = ""$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"" } setglobal compile_var = '' setglobal finalize_var = '' if test -n $runpath_var { if test -n $perm_rpath { # We should set the runpath_var. setglobal rpath = '' for dir in [$perm_rpath] { func_append rpath "$dir:" } setglobal compile_var = ""$runpath_var=\"$rpath\$$runpath_var\" "" } if test -n $finalize_perm_rpath { # We should set the runpath_var. setglobal rpath = '' for dir in [$finalize_perm_rpath] { func_append rpath "$dir:" } setglobal finalize_var = ""$runpath_var=\"$rpath\$$runpath_var\" "" } } if test yes = $no_install { # We don't need to create a wrapper script. setglobal link_command = "$compile_var$compile_command$compile_rpath" # Replace the output file specification. setglobal link_command = $[$ECHO $link_command | $SED 's%@OUTPUT@%'"$output"'%g] # Delete the old output file. $opt_dry_run || $RM $output # Link the executable and exit func_show_eval $link_command 'exit $?' if test -n $postlink_cmds { func_to_tool_file $output setglobal postlink_cmds = $[func_echo_all $postlink_cmds | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g] func_execute_cmds $postlink_cmds 'exit $?' } exit $EXIT_SUCCESS } match $hardcode_action,$fast_install { with relink,* # Fast installation is not supported setglobal link_command = "$compile_var$compile_command$compile_rpath" setglobal relink_command = "$finalize_var$finalize_command$finalize_rpath" func_warning "this platform does not like uninstalled shared libraries" func_warning "'$output' will be relinked during installation" with *,yes setglobal link_command = "$finalize_var$compile_command$finalize_rpath" setglobal relink_command = $[$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g] with *,no setglobal link_command = "$compile_var$compile_command$compile_rpath" setglobal relink_command = "$finalize_var$finalize_command$finalize_rpath" with *,needless setglobal link_command = "$finalize_var$compile_command$finalize_rpath" setglobal relink_command = '' } # Replace the output file specification. setglobal link_command = $[$ECHO $link_command | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g] # Delete the old output files. $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname func_show_eval $link_command 'exit $?' if test -n $postlink_cmds { func_to_tool_file "$output_objdir/$outputname" setglobal 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] func_execute_cmds $postlink_cmds 'exit $?' } # Now create the wrapper script. func_verbose "creating $output" # Quote the relink command for shipping. if test -n $relink_command { # Preserve any variables that may affect compiler behavior for var in [$variables_saved_for_relink] { if eval test -z '"''$'{$var+set}'"' { setglobal relink_command = ""{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"" } elif eval var_value='$'$var; test -z $var_value; { setglobal relink_command = ""$var=; export $var; $relink_command"" } else { func_quote_for_eval $var_value setglobal relink_command = ""$var=$func_quote_for_eval_result; export $var; $relink_command"" } } setglobal relink_command = ""(cd $[pwd]; $relink_command)"" setglobal relink_command = $[$ECHO $relink_command | $SED $sed_quote_subst] } # Only actually do things if not in dry run mode. $opt_dry_run || do { # win32 will think the script is a binary if it has # a .exe suffix, so we strip it off here. match $output { with *.exe func_stripname '' '.exe' $output setglobal output = $func_stripname_result } # test for cygwin because mv fails w/o .exe extensions match $host { with *cygwin* setglobal exeext = '.exe' func_stripname '' '.exe' $outputname setglobal outputname = $func_stripname_result with * setglobal exeext = '' } match $host { with *cygwin* | *mingw* func_dirname_and_basename $output "" "." setglobal output_name = $func_basename_result setglobal output_path = $func_dirname_result setglobal cwrappersource = "$output_path/$objdir/lt-$output_name.c" setglobal cwrapper = "$output_path/$output_name.exe" $RM $cwrappersource $cwrapper trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 func_emit_cwrapperexe_src > $cwrappersource # The wrapper executable is built using the $host compiler, # because it contains $host paths and files. If cross- # compiling, it, like the target executable, must be # executed on the $host or under an emulation environment. $opt_dry_run || do { $LTCC $LTCFLAGS -o $cwrapper $cwrappersource $STRIP $cwrapper } # Now, create the wrapper script for func_source use: func_ltwrapper_scriptname $cwrapper $RM $func_ltwrapper_scriptname_result trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 $opt_dry_run || do { # note: this script will not be executed, so do not chmod. if test "x$build" = "x$host" { $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result } else { func_emit_wrapper no > $func_ltwrapper_scriptname_result } } with * $RM $output trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 func_emit_wrapper no > $output chmod +x $output } } exit $EXIT_SUCCESS } # See if we need to build an old-fashioned archive. for oldlib in [$oldlibs] { match $build_libtool_libs { with convenience setglobal oldobjs = ""$libobjs_save $symfileobj"" setglobal addlibs = $convenience setglobal build_libtool_libs = 'no' with module setglobal oldobjs = $libobjs_save setglobal addlibs = $old_convenience setglobal build_libtool_libs = 'no' with * setglobal oldobjs = ""$old_deplibs $non_pic_objects"" $preload && test -f $symfileobj \ && func_append oldobjs " $symfileobj" setglobal addlibs = $old_convenience } if test -n $addlibs { setglobal gentop = "$output_objdir/$(outputname)x" func_append generated " $gentop" func_extract_archives $gentop $addlibs func_append oldobjs " $func_extract_archives_result" } # Do each command in the archive commands. if test -n $old_archive_from_new_cmds && test yes = $build_libtool_libs { setglobal cmds = $old_archive_from_new_cmds } else { # Add any objects from preloaded convenience libraries if test -n $dlprefiles { setglobal gentop = "$output_objdir/$(outputname)x" func_append generated " $gentop" func_extract_archives $gentop $dlprefiles func_append oldobjs " $func_extract_archives_result" } # POSIX demands no paths to be encoded in archives. We have # to avoid creating archives with duplicate basenames if we # might have to extract them afterwards, e.g., when creating a # static archive out of a convenience library, or when linking # the entirety of a libtool archive into another (currently # not supported by libtool). if shell {for obj in [$oldobjs] { func_basename $obj $ECHO $func_basename_result } | sort | sort -uc >/dev/null !2 > !1} { : } else { echo "copying selected object files to avoid basename conflicts..." setglobal gentop = "$output_objdir/$(outputname)x" func_append generated " $gentop" func_mkdir_p $gentop setglobal save_oldobjs = $oldobjs setglobal oldobjs = '' setglobal counter = '1' for obj in [$save_oldobjs] { func_basename $obj setglobal objbase = $func_basename_result match " $oldobjs " { with " " setglobal oldobjs = $obj with *[\ /]"$objbase "* while : { # Make sure we don't pick an alternate name that also # overlaps. setglobal newobj = "lt$counter-$objbase" func_arith $counter + 1 setglobal counter = $func_arith_result match " $oldobjs " { with *[\ /]"$newobj "* with * if test ! -f "$gentop/$newobj" { break; } } } func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" func_append oldobjs " $gentop/$newobj" with * func_append oldobjs " $obj" } } } func_to_tool_file $oldlib func_convert_file_msys_to_w32 setglobal tool_oldlib = $func_to_tool_file_result eval cmds='"'$old_archive_cmds'"' func_len " $cmds" setglobal len = $func_len_result if test $len -lt $max_cmd_len || test $max_cmd_len -le -1 { setglobal cmds = $old_archive_cmds } elif test -n $archiver_list_spec { func_verbose "using command file archive linking..." for obj in [$oldobjs] { func_to_tool_file $obj $ECHO $func_to_tool_file_result } > $output_objdir/$libname.libcmd func_to_tool_file "$output_objdir/$libname.libcmd" setglobal oldobjs = "" $archiver_list_spec$func_to_tool_file_result"" setglobal cmds = $old_archive_cmds } else { # the command line is too long to link in one step, link in parts func_verbose "using piecewise archive linking..." setglobal save_RANLIB = $RANLIB setglobal RANLIB = ':' setglobal objlist = '' setglobal concat_cmds = '' setglobal save_oldobjs = $oldobjs setglobal oldobjs = '' # Is there a better way of finding the last object in the list? for obj in [$save_oldobjs] { setglobal last_oldobj = $obj } eval test_cmds='"'$old_archive_cmds'"' func_len " $test_cmds" setglobal len0 = $func_len_result setglobal len = $len0 for obj in [$save_oldobjs] { func_len " $obj" func_arith $len + $func_len_result setglobal len = $func_arith_result func_append objlist " $obj" if test $len -lt $max_cmd_len { : } else { # the above command should be used before it gets too long setglobal oldobjs = $objlist if test $obj = $last_oldobj { setglobal RANLIB = $save_RANLIB } test -z $concat_cmds || setglobal concat_cmds = "$concat_cmds~" eval concat_cmds='"''$'concat_cmds$old_archive_cmds'"' setglobal objlist = '' setglobal len = $len0 } } setglobal RANLIB = $save_RANLIB setglobal oldobjs = $objlist if test -z $oldobjs { eval cmds='"''$'concat_cmds'"' } else { eval cmds='"''$'concat_cmds~'$'old_archive_cmds'"' } } } func_execute_cmds $cmds 'exit $?' } test -n $generated && \ func_show_eval "$(RM)r$generated" # Now create the libtool archive. match $output { with *.la setglobal old_library = '' test yes = $build_old_libs && setglobal old_library = "$libname.$libext" func_verbose "creating $output" # Preserve any variables that may affect compiler behavior for var in [$variables_saved_for_relink] { if eval test -z '"''$'{$var+set}'"' { setglobal relink_command = ""{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"" } elif eval var_value='$'$var; test -z $var_value; { setglobal relink_command = ""$var=; export $var; $relink_command"" } else { func_quote_for_eval $var_value setglobal relink_command = ""$var=$func_quote_for_eval_result; export $var; $relink_command"" } } # Quote the link command for shipping. setglobal relink_command = ""(cd $[pwd]; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"" setglobal relink_command = $[$ECHO $relink_command | $SED $sed_quote_subst] if test yes = $hardcode_automatic { setglobal relink_command = '' } # Only create the output if not a dry run. $opt_dry_run || do { for installed in [no yes] { if test yes = $installed { if test -z $install_libdir { break } setglobal output = "$output_objdir/$(outputname)i" # Replace all uninstalled libtool libraries with the installed ones setglobal newdependency_libs = '' for deplib in [$dependency_libs] { match $deplib { with *.la func_basename $deplib setglobal name = $func_basename_result func_resolve_sysroot $deplib eval libdir=$[$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result] test -z $libdir && \ func_fatal_error "'$deplib' is not a valid libtool archive" func_append newdependency_libs " $(lt_sysroot:+=)$libdir/$name" with -L* func_stripname -L '' $deplib func_replace_sysroot $func_stripname_result func_append newdependency_libs " -L$func_replace_sysroot_result" with -R* func_stripname -R '' $deplib func_replace_sysroot $func_stripname_result func_append newdependency_libs " -R$func_replace_sysroot_result" with * func_append newdependency_libs " $deplib" } } setglobal dependency_libs = $newdependency_libs setglobal newdlfiles = '' for lib in [$dlfiles] { match $lib { with *.la func_basename $lib setglobal name = $func_basename_result eval libdir=$[$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib] test -z $libdir && \ func_fatal_error "'$lib' is not a valid libtool archive" func_append newdlfiles " $(lt_sysroot:+=)$libdir/$name" with * func_append newdlfiles " $lib" } } setglobal dlfiles = $newdlfiles setglobal newdlprefiles = '' for lib in [$dlprefiles] { match $lib { with *.la # Only pass preopened files to the pseudo-archive (for # eventual linking with the app. that links it) if we # didn't already link the preopened objects directly into # the library: func_basename $lib setglobal name = $func_basename_result eval libdir=$[$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib] test -z $libdir && \ func_fatal_error "'$lib' is not a valid libtool archive" func_append newdlprefiles " $(lt_sysroot:+=)$libdir/$name" } } setglobal dlprefiles = $newdlprefiles } else { setglobal newdlfiles = '' for lib in [$dlfiles] { match $lib { with [\\/]* | [A-Za-z]:[\\/]* setglobal abs = $lib with * setglobal abs = "$[pwd]"/$lib"" } func_append newdlfiles " $abs" } setglobal dlfiles = $newdlfiles setglobal newdlprefiles = '' for lib in [$dlprefiles] { match $lib { with [\\/]* | [A-Za-z]:[\\/]* setglobal abs = $lib with * setglobal abs = "$[pwd]"/$lib"" } func_append newdlprefiles " $abs" } setglobal dlprefiles = $newdlprefiles } $RM $output # place dlname in correct position for cygwin # In fact, it would be nice if we could use this code for all target # systems that can't hard-code library paths into their executables # and that have no shared library path variable independent of PATH, # but it turns out we can't easily determine that from inspecting # libtool variables, so we have to hard-code the OSs to which it # applies here; at the moment, that means platforms that use the PE # object format with DLL files. See the long comment at the top of # tests/bindir.at for full details. setglobal tdlname = $dlname match $host,$output,$installed,$module,$dlname { with *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll # If a -bindir argument was supplied, place the dll there. if test -n $bindir { func_relative_path $install_libdir $bindir setglobal tdlname = "$func_relative_path_result/$dlname" } else { # Otherwise fall back on heuristic. setglobal tdlname = "../bin/$dlname" } } $ECHO > $output "\ # $outputname - a libtool library file # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # Please DO NOT delete this file! # It is necessary for linking the library. # The name that we can dlopen(3). dlname='$tdlname' # Names of this library. library_names='$library_names' # The name of the static archive. old_library='$old_library' # Linker flags that cannot go in dependency_libs. inherited_linker_flags='$new_inherited_linker_flags' # Libraries that this one depends upon. dependency_libs='$dependency_libs' # Names of additional weak libraries provided by this library weak_library_names='$weak_libs' # Version information for $libname. current=$current age=$age revision=$revision # Is this an already installed library? installed=$installed # Should we warn about portability when linking against -modules? shouldnotlink=$module # Files to dlopen/dlpreopen dlopen='$dlfiles' dlpreopen='$dlprefiles' # Directory that this library needs to be installed in: libdir='$install_libdir'> $output "\ # $outputname - a libtool library file # Generated by $PROGRAM (GNU $PACKAGE) $VERSION # # Please DO NOT delete this file! # It is necessary for linking the library. # The name that we can dlopen(3). dlname='$tdlname' # Names of this library. library_names='$library_names' # The name of the static archive. old_library='$old_library' # Linker flags that cannot go in dependency_libs. inherited_linker_flags='$new_inherited_linker_flags' # Libraries that this one depends upon. dependency_libs='$dependency_libs' # Names of additional weak libraries provided by this library weak_library_names='$weak_libs' # Version information for $libname. current=$current age=$age revision=$revision # Is this an already installed library? installed=$installed # Should we warn about portability when linking against -modules? shouldnotlink=$module # Files to dlopen/dlpreopen dlopen='$dlfiles' dlpreopen='$dlprefiles' # Directory that this library needs to be installed in: libdir='$install_libdir'" if test no,yes = "$installed,$need_relink" { $ECHO >> $output "\ relink_command=\"$relink_command>> $output "\ relink_command=\"$relink_command\"" } } } # Do a symbolic link so that the libtool archive can be found in # LD_LIBRARY_PATH before the program is installed. func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' } exit $EXIT_SUCCESS } if test link = $opt_mode || test relink = $opt_mode { func_mode_link $(1+"$@") } # func_mode_uninstall arg... proc func_mode_uninstall { $debug_cmd setglobal RM = $nonopt setglobal files = '' setglobal rmforce = 'false' setglobal exit_status = '0' # This variable tells wrapper scripts just to set variables rather # than running their programs. setglobal libtool_install_magic = $magicfor arg in @Argv { match $arg { with -f func_append RM " $arg"; setglobal rmforce = ':' with -* func_append RM " $arg" with * func_append files " $arg" } } test -z $RM && \ func_fatal_help "you must specify an RM program" setglobal rmdirs = '' for file in [$files] { func_dirname $file "" "." setglobal dir = $func_dirname_result if test . = $dir { setglobal odir = $objdir } else { setglobal odir = "$dir/$objdir" } func_basename $file setglobal name = $func_basename_result test uninstall = $opt_mode && setglobal odir = $dir # Remember odir for removal later, being careful to avoid duplicates if test clean = $opt_mode { match " $rmdirs " { with *" $odir "* with * func_append rmdirs " $odir" } } # Don't error if the file doesn't exist and rm -f was used. if do { test -L $file; } >/dev/null 2>&1 || do { test -h $file; } >/dev/null 2>&1 || test -f $file { : } elif test -d $file { setglobal exit_status = '1' continue } elif $rmforce { continue } setglobal rmfiles = $file match $name { with *.la # Possibly a libtool archive, so verify it. if func_lalib_p $file { func_source $dir/$name # Delete the libtool libraries and symlinks. for n in [$library_names] { func_append rmfiles " $odir/$n" } test -n $old_library && func_append rmfiles " $odir/$old_library" match $opt_mode { with clean match " $library_names " { with *" $dlname "* with * test -n $dlname && func_append rmfiles " $odir/$dlname" } test -n $libdir && func_append rmfiles " $odir/$name $odir/$(name)i" with uninstall if test -n $library_names { # Do each command in the postuninstall commands. func_execute_cmds $postuninstall_cmds '$rmforce || exit_status=1' } if test -n $old_library { # Do each command in the old_postuninstall commands. func_execute_cmds $old_postuninstall_cmds '$rmforce || exit_status=1' } # FIXME: should reinstall the best remaining shared library. } } with *.lo # Possibly a libtool object, so verify it. if func_lalib_p $file { # Read the .lo file func_source $dir/$name # Add PIC object to the list of files to remove. if test -n $pic_object && test none != $pic_object { func_append rmfiles " $dir/$pic_object" } # Add non-PIC object to the list of files to remove. if test -n $non_pic_object && test none != $non_pic_object { func_append rmfiles " $dir/$non_pic_object" } } with * if test clean = $opt_mode { setglobal noexename = $name match $file { with *.exe func_stripname '' '.exe' $file setglobal file = $func_stripname_result func_stripname '' '.exe' $name setglobal noexename = $func_stripname_result # $file with .exe has already been added to rmfiles, # add $file without .exe func_append rmfiles " $file" } # Do a test to see if this is a libtool program. if func_ltwrapper_p $file { if func_ltwrapper_executable_p $file { func_ltwrapper_scriptname $file setglobal relink_command = '' func_source $func_ltwrapper_scriptname_result func_append rmfiles " $func_ltwrapper_scriptname_result" } else { setglobal relink_command = '' func_source $dir/$noexename } # note $name still contains .exe if it was in $file originally # as does the version of $file that was added into $rmfiles func_append rmfiles " $odir/$name $odir/$(name)S.$objext" if test yes = $fast_install && test -n $relink_command { func_append rmfiles " $odir/lt-$name" } if test "X$noexename" != "X$name" { func_append rmfiles " $odir/lt-$noexename.c" } } } } func_show_eval "$RM $rmfiles" 'exit_status=1' } # Try to remove the $objdir's in the directories where we deleted files for dir in [$rmdirs] { if test -d $dir { func_show_eval "rmdir $dir >/dev/null 2>&1" } } exit $exit_status } if test uninstall = $opt_mode || test clean = $opt_mode { func_mode_uninstall $(1+"$@") } test -z $opt_mode && do { setglobal help = $generic_help func_fatal_help "you must specify a MODE" } test -z $exec_cmd && \ func_fatal_help "invalid operation mode '$opt_mode'" if test -n $exec_cmd { eval exec $exec_cmd exit $EXIT_FAILURE } exit $exit_status # The TAGs below are defined such that we never get into a situation # where we disable both kinds of libraries. Given conflicting # choices, we go for a static library, that is the most portable, # since we can't tell whether shared libraries were disabled because # the user asked for that or because the platform doesn't support # them. This is particularly important on AIX, because we don't # support having both static and shared libraries enabled at the same # time on that platform, so we default to a shared-only configuration. # If a disable-shared tag is given, we'll fallback to a static-only # configuration. But we'll never go from static-only to shared-only. # ### BEGIN LIBTOOL TAG CONFIG: disable-shared setglobal build_libtool_libs = 'no' setglobal build_old_libs = 'yes' # ### END LIBTOOL TAG CONFIG: disable-shared # ### BEGIN LIBTOOL TAG CONFIG: disable-static setglobal build_old_libs = $[match $build_libtool_libs { with yes echo no with * echo yes }] # ### END LIBTOOL TAG CONFIG: disable-static # Local Variables: # mode:shell-script # sh-indentation:2 # End: