# Generated from ltmain.m4sh. # libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a # Written by Gordon Matzigkeit , 1996 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, # 2007, 2008, 2009 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 GNU Libtool; see the file COPYING. If not, a copy # can be downloaded from http://www.gnu.org/licenses/gpl.html, # or obtained by writing to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # Usage: $progname [OPTION]... [MODE-ARG]... # # Provide generalized library-building support services. # # --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-finish let install mode avoid finish commands # --preserve-dup-deps don't remove duplicate dependency libraries # --quiet, --silent don't print informational messages # --no-quiet, --no-silent # print informational messages (default) # --tag=TAG use configuration variables from tag TAG # -v, --verbose print more informational messages than default # --no-verbose don't print the extra informational messages # --version print version information # -h, --help, --help-all print short, long, or detailed 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) # $progname: (GNU libtool 1.3134 2009-11-29) 2.2.7a # automake: $automake_version # autoconf: $autoconf_version # # Report bugs to . setvar PROGRAM = 'libtool' setvar PACKAGE = 'libtool' setvar VERSION = '2.2.7a' setvar TIMESTAMP = "" 1.3134 2009-11-29"" setvar package_revision = '1.3134' # Be Bourne compatible if test -n ${ZSH_VERSION+set} && shell {emulate sh} >/dev/null 2>&1 { emulate sh setvar 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{ *posix* { set -o posix} } } setvar BIN_SH = 'xpg4'; export BIN_SH # for Tru64 setvar DUALCASE = '1'; export DUALCASE # for MKS sh # A function that is used when there is no print builtin or printf. proc func_fallback_echo { eval 'cat <<_LTECHO_EOF $1 _LTECHO_EOF' } # NLS nuisances: We save the old values to restore during execute mode. # Only set LANG and LC_ALL to C if already set. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). setvar lt_user_locale = '' setvar lt_safe_locale = '' for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES { eval "if test \"\${$lt_var+set}\" = set; then save_$lt_var=\$$lt_var $lt_var=C export $lt_var lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" fi" } $lt_unset CDPATH # 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. setvar progpath = "$0" : ${CP="cp -f"} : ${ECHO=$as_echo} : ${EGREP="/bin/grep -E"} : ${FGREP="/bin/grep -F"} : ${GREP="/bin/grep"} : ${LN_S="ln -s"} : ${MAKE="make"} : ${MKDIR="mkdir"} : ${MV="mv -f"} : ${RM="rm -f"} : ${SED="/mount/endor/wildenhu/local-x86_64/bin/sed"} : ${SHELL="${CONFIG_SHELL-/bin/sh}"} : ${Xsed="$SED -e 1s/^X//"} # Global variables: setvar EXIT_SUCCESS = '0' setvar EXIT_FAILURE = '1' setvar EXIT_MISMATCH = '63' # $? = 63 is used to indicate version mismatch to missing. setvar EXIT_SKIP = '77' # $? = 77 is used to indicate a skipped test to automake. setvar exit_status = "$EXIT_SUCCESS" # Make sure IFS has a sensible default setvar lt_nl = '' '' setvar IFS = "" $lt_nl"" setvar dirname = ""s,/[^/]*$,,"" setvar basename = ""s,^.*/,,"" # 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" # Implementation must be kept synchronized with func_dirname # and func_basename. For efficiency, we do not delegate to # those functions but instead duplicate the functionality here. proc func_dirname_and_basename { # Extract subdirectory from the argument. setvar func_dirname_result = $($ECHO ${1} | $SED -e $dirname) if test "X$func_dirname_result" = "X${1}" { setvar func_dirname_result = "${3}" } else { setvar func_dirname_result = ""$func_dirname_result${2}"" } setvar func_basename_result = $($ECHO ${1} | $SED -e $basename) } # Generated shell functions inserted here. # These SED scripts presuppose an absolute path with a trailing slash. setvar pathcar = ''s,^/\([^/]*\).*$,\1,'' setvar pathcdr = ''s,^/[^/]*,,'' setvar removedotparts = '':dotsl s@/\./@/@g t dotsl s,/\.$,/,'' setvar collapseslashes = ''s@/\{1,\}@/@g'' setvar finalslash = ''s,/*$,/,'' # 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. # value returned in "$func_normal_abspath_result" proc func_normal_abspath { # Start from root dir and reassemble the path. setvar func_normal_abspath_result = '' setvar func_normal_abspath_tpath = "$1" setvar func_normal_abspath_altnamespace = '' case (func_normal_abspath_tpath) { "" { # Empty path, that just means $cwd. func_stripname '' '/' $(pwd) setvar 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. ///* { # Unusual form of absolute path, do nothing. } //* { # 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. setvar func_normal_abspath_altnamespace = '/' } /* { # Absolute path, do nothing. } * { # Relative path, prepend $cwd. setvar 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. setvar func_normal_abspath_tpath = $($ECHO $func_normal_abspath_tpath | $SED \ -e $removedotparts -e $collapseslashes -e $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 { setvar func_normal_abspath_result = '/' } break } setvar func_normal_abspath_tcomponent = $($ECHO $func_normal_abspath_tpath | $SED \ -e $pathcar) setvar func_normal_abspath_tpath = $($ECHO $func_normal_abspath_tpath | $SED \ -e $pathcdr) # Figure out what to do with it case (func_normal_abspath_tcomponent) { "" { # Trailing empty path component, ignore it. } .. { # Parent dir; strip last assembled component from result. func_dirname $func_normal_abspath_result setvar func_normal_abspath_result = "$func_dirname_result" } * { # Actual path component, append it. setvar func_normal_abspath_result = "$func_normal_abspath_result/$func_normal_abspath_tcomponent" } } } # Restore leading double-slash if one was found on entry. setvar func_normal_abspath_result = "$func_normal_abspath_altnamespace$func_normal_abspath_result" } # func_relative_path SRCDIR DSTDIR # generates a relative path from SRCDIR to DSTDIR, with a trailing # slash if non-empty, suitable for immediately appending a filename # without needing to append a separator. # value returned in "$func_relative_path_result" proc func_relative_path { setvar func_relative_path_result = '' func_normal_abspath $1 setvar func_relative_path_tlibdir = "$func_normal_abspath_result" func_normal_abspath $2 setvar func_relative_path_tbindir = "$func_normal_abspath_result" # Ascend the tree starting from libdir while : { # check if we have found a prefix of bindir case (func_relative_path_tbindir) { $func_relative_path_tlibdir { # found an exact match setvar func_relative_path_tcancelled = '' break } $func_relative_path_tlibdir* { # found a matching prefix func_stripname $func_relative_path_tlibdir '' $func_relative_path_tbindir setvar func_relative_path_tcancelled = "$func_stripname_result" if test -z $func_relative_path_result { setvar func_relative_path_result = '.' } break } * { func_dirname $func_relative_path_tlibdir setvar func_relative_path_tlibdir = ${func_dirname_result} if test "x$func_relative_path_tlibdir" = x { # Have to descend all the way to the root! setvar func_relative_path_result = "../$func_relative_path_result" setvar func_relative_path_tcancelled = "$func_relative_path_tbindir" break } setvar func_relative_path_result = "../$func_relative_path_result" } } } # Now calculate path; take care to avoid doubling-up slashes. func_stripname '' '/' $func_relative_path_result setvar func_relative_path_result = "$func_stripname_result" func_stripname '/' '/' $func_relative_path_tcancelled if test "x$func_stripname_result" != x { setvar func_relative_path_result = "${func_relative_path_result}/${func_stripname_result}" } # Normalisation. If bindir is libdir, return empty string, # else relative path ending with a slash; either way, target # file name can be directly appended. if test ! -z $func_relative_path_result { func_stripname './' '' "$func_relative_path_result/" setvar func_relative_path_result = "$func_stripname_result" } } # The name of this program: func_dirname_and_basename $progpath setvar progname = "$func_basename_result" # Make sure we have an absolute path for reexecution: case (progpath) { [\\/]*|[A-Za-z]:\\* { } *[\\/]* { setvar progdir = "$func_dirname_result" setvar progdir = $(cd $progdir && pwd) setvar progpath = ""$progdir/$progname"" } * { setvar save_IFS = "$IFS" setvar IFS = ':' for progdir in $PATH { setvar IFS = "$save_IFS" test -x "$progdir/$progname" && break } setvar IFS = "$save_IFS" test -n $progdir || setvar progdir = $(pwd) setvar progpath = ""$progdir/$progname"" } } # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. setvar Xsed = ""${SED}"' -e 1s/^X//"' setvar sed_quote_subst = ''s/\([`"$\\]\)/\\\1/g'' # Same as above, but do not quote variable references. setvar double_quote_subst = ''s/\(["`\\]\)/\\\1/g'' # Re-`\' parameter expansions in output of double_quote_subst that were # `\'-ed in input to the same. If an odd number of `\' preceded a '$' # in input to 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 '$'. setvar bs = ''\\'' setvar bs2 = ''\\\\'' setvar bs4 = ''\\\\\\\\'' setvar dollar = ''\$'' setvar sed_double_backslash = ""\ s/$bs4/&\\ /g s/^$bs2$dollar/$bs&/ s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g s/\n//g"" # Standard options: setvar opt_dry_run = 'false' setvar opt_help = 'false' setvar opt_quiet = 'false' setvar opt_verbose = 'false' setvar opt_warning = ':' # func_echo arg... # Echo program name prefixed message, along with the current mode # name if it has been set yet. proc func_echo { $ECHO "$progname${mode+: }$mode: $[join(ARGV)]" } # func_verbose arg... # Echo program name prefixed message in verbose mode only. proc func_verbose { $opt_verbose && 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_echo_all arg... # Invoke $ECHO with all args, space-separated. proc func_echo_all { $ECHO "$[join(ARGV)]" } # func_error arg... # Echo program name prefixed message to standard error. proc func_error { $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2 } # func_warning arg... # Echo program name prefixed warning message to standard error. proc func_warning { $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2 # bash bug again: : } # func_fatal_error arg... # Echo program name prefixed message to standard error, and exit. proc func_fatal_error { func_error ${1+"$@"} exit $EXIT_FAILURE } # func_fatal_help arg... # Echo program name prefixed message to standard error, followed by # a help hint, and exit. proc func_fatal_help { func_error ${1+"$@"} func_fatal_error $help } setvar help = ""Try \`$progname --help' for more information."" ## default # func_grep expression filename # Check whether EXPRESSION matches any line of FILENAME, without output. proc func_grep { $GREP $1 $2 >/dev/null 2>&1 } # func_mkdir_p directory-path # Make sure the entire path to DIRECTORY-PATH is available. proc func_mkdir_p { setvar my_directory_path = "$1" setvar my_dir_list = '' if test -n $my_directory_path && test $opt_dry_run != ":" { # Protect directory names starting with `-' case (my_directory_path) { -* { setvar my_directory_path = ""./$my_directory_path"" } } # While some portion of DIR does not yet exist... while test ! -d $my_directory_path { # ...make a list in topmost first order. Use a colon delimited # list incase some portion of path contains whitespace. setvar my_dir_list = ""$my_directory_path:$my_dir_list"" # If the last portion added has no slash in it, the list is done case (my_directory_path) { */* { } * { break } } # ...otherwise throw away the child directory and loop setvar my_directory_path = $($ECHO $my_directory_path | $SED -e $dirname) } setvar my_dir_list = $($ECHO $my_dir_list | $SED 's,:*$,,) setvar save_mkdir_p_IFS = "$IFS"; setvar IFS = '':'' for my_dir in $my_dir_list { setvar IFS = "$save_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 $my_dir 2>/dev/null || : } setvar IFS = "$save_mkdir_p_IFS" # Bail out if we (or some other process) failed to create a directory. test -d $my_directory_path || \ func_fatal_error "Failed to create \`$1'" } } # func_mktempdir [string] # Make a temporary directory that won't clash with other running # libtool processes, and avoids race conditions if possible. If # given, STRING is the basename for that directory. proc func_mktempdir { setvar my_template = ""${TMPDIR-/tmp}/${1-$progname}"" if test $opt_dry_run = ":" { # Return a directory name, but don't create it in dry-run mode setvar my_tmpdir = ""${my_template}-"$$" } else { # If mktemp works, use that first and foremost setvar my_tmpdir = $(mktemp -d "${my_template}-XXXXXXXX" ) if test ! -d $my_tmpdir { # Failing that, at least try and use $RANDOM to avoid a race setvar my_tmpdir = ""${my_template}-${RANDOM-0}"$$" setvar save_mktempdir_umask = $(umask) umask 0077 $MKDIR $my_tmpdir umask $save_mktempdir_umask } # If we're not in dry-run mode, bomb out on failure test -d $my_tmpdir || \ func_fatal_error "cannot create temporary directory \`$my_tmpdir'" } $ECHO $my_tmpdir } # func_quote_for_eval arg # Aesthetically quote ARG to be evaled later. # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT # is double-quoted, suitable for a subsequent eval, whereas # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters # which are still active within double quotes backslashified. proc func_quote_for_eval { case (1) { *[\\\`\"\$]* { setvar func_quote_for_eval_unquoted_result = $($ECHO $1 | $SED $sed_quote_subst) } * { setvar func_quote_for_eval_unquoted_result = "$1" } } case (func_quote_for_eval_unquoted_result) { # Double-quote args containing shell metacharacters to delay # word splitting, command substitution and and variable # expansion for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"" { setvar func_quote_for_eval_result = ""\"$func_quote_for_eval_unquoted_result"\"" } * { setvar func_quote_for_eval_result = "$func_quote_for_eval_unquoted_result" } } } # 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 { case (1) { *[\\\`\"]* { setvar my_arg = $($ECHO $1 | $SED \ -e $double_quote_subst -e $sed_double_backslash) } * { setvar my_arg = "$1" } } case (my_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. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"" { setvar my_arg = ""\"$my_arg"\"" } } setvar func_quote_for_expand_result = "$my_arg" } # func_show_eval cmd [fail_exp] # Unless opt_silent 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 { setvar my_cmd = "$1" setvar my_fail_exp = "${2-:}" ${opt_silent-false} || do { func_quote_for_expand $my_cmd eval "func_echo $func_quote_for_expand_result" } if ${opt_dry_run-false} { :; } else { eval $my_cmd setvar my_status = ""$? if test $my_status -eq 0 { :; } else { eval "(exit $my_status); $my_fail_exp" } } } # func_show_eval_locale cmd [fail_exp] # Unless opt_silent 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 { setvar my_cmd = "$1" setvar my_fail_exp = "${2-:}" ${opt_silent-false} || do { func_quote_for_expand $my_cmd eval "func_echo $func_quote_for_expand_result" } if ${opt_dry_run-false} { :; } else { eval "$lt_user_locale $my_cmd" setvar my_status = ""$? eval $lt_safe_locale if test $my_status -eq 0 { :; } else { eval "(exit $my_status); $my_fail_exp" } } } # func_version # Echo version message to standard output and exit. proc func_version { $SED -n '/(C)/!b go :more /\./!{ N s/\n# // b more } :go /^# '$PROGRAM' (GNU /,/# warranty; / { s/^# // s/^# *$// s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/ p }' < "$progpath" exit $? } # func_usage # Echo short help message to standard output and exit. proc func_usage { $SED -n '/^# Usage:/,/^# *-h/ { s/^# // s/^# *$// s/\$progname/'$progname'/ p }' < "$progpath" echo $ECHO "run \`$progname --help | more' for full usage" exit $? } # func_help [NOEXIT] # Echo long help message to standard output and exit, # unless 'noexit' is passed as argument. proc func_help { $SED -n '/^# Usage:/,/# Report bugs to/ { s/^# // s/^# *$// s*\$progname*'$progname'* s*\$host*'"$host"'* s*\$SHELL*'"$SHELL"'* s*\$LTCC*'"$LTCC"'* s*\$LTCFLAGS*'"$LTCFLAGS"'* s*\$LD*'"$LD"'* s/\$with_gnu_ld/'"$with_gnu_ld"'/ s/\$automake_version/'"$(shell {automake --version} 2>/dev/null |$SED 1q)"'/ s/\$autoconf_version/'"$(shell {autoconf --version} 2>/dev/null |$SED 1q)"'/ p }' < "$progpath" setvar ret = ""$? if test -z $1 { exit $ret } } # func_missing_arg argname # Echo program name prefixed message to standard error and set global # exit_cmd. proc func_missing_arg { func_error "missing argument for $1" setvar exit_cmd = 'exit' } setvar exit_cmd = ':' setvar magic = ""%%%MAGIC variable%%%"" setvar magic_exe = ""%%%MAGIC EXE variable%%%"" # Global variables. # $mode is unset setvar nonopt = '' setvar execute_dlfiles = '' setvar preserve_args = '' setvar lo2o = ""s/\\.lo\$/.${objext}/"" setvar o2lo = ""s/\\.${objext}\$/.lo/"" setvar extracted_archives = '' setvar extracted_serial = '0' setvar opt_dry_run = 'false' setvar opt_finish = ':' setvar opt_duplicate_deps = 'false' setvar opt_silent = 'false' setvar opt_debug = ':' # 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. setvar exec_cmd = '' # 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_error ${1+"$@"} func_error "See the $PACKAGE documentation for more information." func_fatal_error "Fatal configuration error." } # func_config # Display the configuration for all the tags in this script. proc func_config { setvar re_begincf = ''^# ### BEGIN LIBTOOL'' setvar 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 $build_libtool_libs = yes { echo "enable shared libraries" } else { echo "disable shared libraries" } if test $build_old_libs = yes { 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: setvar tagname = "$1" setvar re_begincf = ""^# ### BEGIN LIBTOOL TAG CONFIG: $tagname"\$" setvar re_endcf = ""^# ### END LIBTOOL TAG CONFIG: $tagname"\$" setvar sed_extractcf = ""/$re_begincf/,/$re_endcf/p"" # Validate tagname. case (tagname) { *[!-_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. case (tagname) { CC { } * { if $GREP $re_begincf $progpath >/dev/null 2>&1 { setvar 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: setvar extractedcf = $($SED -n -e $sed_extractcf ) eval $extractedcf } else { func_error "ignoring unknown tag $tagname" } } } } # Parse options once, thoroughly. This comes as soon as possible in # the script to make things like `libtool --version' happen quickly. do { # Shorthand for --mode=foo, only valid as the first argument case (1) { clean|clea|cle|cl { shift; set dummy --mode clean ${1+"$@"}; shift } compile|compil|compi|comp|com|co|c { shift; set dummy --mode compile ${1+"$@"}; shift } execute|execut|execu|exec|exe|ex|e { shift; set dummy --mode execute ${1+"$@"}; shift } finish|finis|fini|fin|fi|f { shift; set dummy --mode finish ${1+"$@"}; shift } install|instal|insta|inst|ins|in|i { shift; set dummy --mode install ${1+"$@"}; shift } link|lin|li|l { shift; set dummy --mode link ${1+"$@"}; shift } uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u { shift; set dummy --mode uninstall ${1+"$@"}; shift } } # Parse non-mode specific arguments: while test "$Argc" -gt 0 { setvar opt = "$1" shift case (opt) { --config { func_config } --debug { setvar preserve_args = ""$preserve_args $opt"" func_echo "enabling shell trace mode" setvar opt_debug = ''set -x'' $opt_debug } -dlopen { test "$Argc" -eq 0 && func_missing_arg $opt && break setvar execute_dlfiles = ""$execute_dlfiles $1"" shift } --dry-run | -n { setvar opt_dry_run = ':' } --features { func_features } --finish { setvar mode = ""finish"" } --no-finish { setvar opt_finish = 'false' } --mode { test "$Argc" -eq 0 && func_missing_arg $opt && break case (1) { # Valid mode arguments: clean { } compile { } execute { } finish { } install { } link { } relink { } uninstall { } # Catch anything else as an error * { func_error "invalid argument for $opt" setvar exit_cmd = 'exit' break } } setvar mode = "$1" shift } --preserve-dup-deps { setvar opt_duplicate_deps = ':' } --quiet|--silent { setvar preserve_args = ""$preserve_args $opt"" setvar opt_silent = ':' setvar opt_verbose = 'false' } --no-quiet|--no-silent { setvar preserve_args = ""$preserve_args $opt"" setvar opt_silent = 'false' } --verbose| -v { setvar preserve_args = ""$preserve_args $opt"" setvar opt_silent = 'false' setvar opt_verbose = ':' } --no-verbose { setvar preserve_args = ""$preserve_args $opt"" setvar opt_verbose = 'false' } --tag { test "$Argc" -eq 0 && func_missing_arg $opt && break setvar preserve_args = ""$preserve_args $opt $1"" func_enable_tag $1 # tagname is set here shift } # Separate optargs to long options: -dlopen=*|--mode=*|--tag=* { func_opt_split $opt set dummy $func_opt_split_opt $func_opt_split_arg ${1+"$@"} shift } -\?|-h { func_usage } --help { setvar opt_help = ':' } --help-all { setvar opt_help = '': help-all'' } --version { func_version } -* { func_fatal_help "unrecognized option \`$opt'" } * { setvar nonopt = "$opt" break } } } case (host) { *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* { # don't eliminate duplications in $postdeps and $predeps setvar opt_duplicate_compiler_generated_deps = ':' } * { setvar opt_duplicate_compiler_generated_deps = "$opt_duplicate_deps" } } # Having warned about all mis-specified options, bail out if # anything was wrong. $exit_cmd $EXIT_FAILURE } # 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 } } ## ----------- ## ## Main. ## ## ----------- ## $opt_help || do { # Sanity checks first: func_check_version_match if test $build_libtool_libs != yes && test $build_old_libs != yes { func_fatal_configuration "not configured to build any kind of library" } test -z $mode && func_fatal_error "error: you must specify a MODE." # Darwin sucks eval "std_shrext=\"$shrext_cmds\"" # Only execute mode is allowed to have -dlopen flags. if test -n $execute_dlfiles && test $mode != execute { func_error "unrecognized option \`-dlopen'" $ECHO $help 1>&2 exit $EXIT_FAILURE } # Change the help message to a mode-specific one. setvar generic_help = "$help" setvar help = ""Try \`$progname --help --mode=$mode' for more information."" } # 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 \ | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 } # 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 { setvar lalib_p = 'no' if test -f $1 && test -r $1 && exec 5<&0 <"$1" { for lalib_p_l in 1 2 3 4 { read lalib_p_line case (lalib_p_line) { \#\ Generated\ by\ *$PACKAGE* { setvar lalib_p = 'yes'; break} } } exec 0<&5 5<&- } test $lalib_p = yes } # 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 { func_lalib_p $1 } # 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 { setvar func_ltwrapper_exec_suffix = '' case (1) { *.exe { } * { setvar 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 { setvar func_ltwrapper_scriptname_result = """" if func_ltwrapper_executable_p $1 { func_dirname_and_basename $1 "" "." func_stripname '' '.exe' $func_basename_result setvar 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 { $opt_debug setvar save_ifs = "$IFS"; setvar IFS = ''~'' for cmd in $1 { setvar IFS = "$save_ifs" eval "cmd=\"$cmd\"" func_show_eval $cmd ${2-:} } setvar 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 { $opt_debug case (1) { */* | *\\* { source "$1" } * { source "./$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 { $opt_debug if test -n $available_tags && test -z $tagname { setvar CC_quoted = '' for arg in $CC { func_quote_for_eval $arg setvar CC_quoted = ""$CC_quoted $func_quote_for_eval_result"" } setvar CC_expanded = $(func_echo_all $CC) setvar CC_quoted_expanded = $(func_echo_all $CC_quoted) case (@) { # Blanks in the command may have been stripped by the calling shell, # but not from the CC environment variable when configure was run. " $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. * { 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' ) setvar CC_quoted = '' for arg in $CC { # Double-quote args containing other shell metacharacters. func_quote_for_eval $arg setvar CC_quoted = ""$CC_quoted $func_quote_for_eval_result"" } setvar CC_expanded = $(func_echo_all $CC) setvar CC_quoted_expanded = $(func_echo_all $CC_quoted) case{ " $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. setvar 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 { setvar write_libobj = ${1} if test $build_libtool_libs = yes { setvar write_lobj = "'''${2}'''" } else { setvar write_lobj = 'none' } if test $build_old_libs = yes { setvar write_oldobj = "'''${3}'''" } else { setvar write_oldobj = 'none' } $opt_dry_run || do { cat >${write_libobj}T <<< """ # $write_libobj - a libtool object file # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $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} } } # func_mode_compile arg... proc func_mode_compile { $opt_debug # Get the compilation command and the source file. setvar base_compile = '' setvar srcfile = "$nonopt" # always keep a non-empty value in "srcfile" setvar suppress_opt = 'yes' setvar suppress_output = '' setvar arg_mode = 'normal' setvar libobj = '' setvar later = '' setvar pie_flag = ''for arg in @ARGV { case (arg_mode) { arg { # do not "continue". Instead, add this to base_compile setvar lastarg = "$arg" setvar arg_mode = 'normal' } target { setvar libobj = "$arg" setvar arg_mode = 'normal' continue } normal { # Accept any command-line options. case (arg) { -o { test -n $libobj && \ func_fatal_error "you cannot specify \`-o' more than once" setvar arg_mode = 'target' continue } -pie | -fpie | -fPIE { setvar pie_flag = ""$pie_flag $arg"" continue } -shared | -static | -prefer-pic | -prefer-non-pic { setvar later = ""$later $arg"" continue } -no-suppress { setvar suppress_opt = 'no' continue } -Xcompiler { setvar 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. -Wc,* { func_stripname '-Wc,' '' $arg setvar args = "$func_stripname_result" setvar lastarg = '' setvar save_ifs = "$IFS"; setvar IFS = '','' for arg in $args { setvar IFS = "$save_ifs" func_quote_for_eval $arg setvar lastarg = ""$lastarg $func_quote_for_eval_result"" } setvar IFS = "$save_ifs" func_stripname ' ' '' $lastarg setvar lastarg = "$func_stripname_result" # Add the arguments to base_compile. setvar base_compile = ""$base_compile $lastarg"" continue } * { # Accept the current argument as the source file. # The previous "srcfile" becomes the current argument. # setvar lastarg = "$srcfile" setvar srcfile = "$arg" } } # case $arg } } # case $arg_mode # Aesthetically quote the previous argument. func_quote_for_eval $lastarg setvar base_compile = ""$base_compile $func_quote_for_eval_result"" } # for arg case (arg_mode) { arg { func_fatal_error "you must specify an argument for -Xcompile" } target { func_fatal_error "you must specify a target with \`-o'" } * { # Get the name of the library object. test -z $libobj && do { func_basename $srcfile setvar libobj = "$func_basename_result" } } } # Recognize several different file suffixes. # If the user specifies -o file.o, it is replaced with file.lo case (libobj) { *.[cCFSifmso] | \ *.ada | *.adb | *.ads | *.asm | \ *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup { func_xform $libobj setvar libobj = "$func_xform_result" } } case (libobj) { *.lo { func_lo2o $libobj; setvar obj = "$func_lo2o_result" } * { func_fatal_error "cannot determine name of library object from \`$libobj'" } } func_infer_tag $base_compile for arg in $later { case (arg) { -shared { test $build_libtool_libs != yes && \ func_fatal_configuration "can not build a shared library" setvar build_old_libs = 'no' continue } -static { setvar build_libtool_libs = 'no' setvar build_old_libs = 'yes' continue } -prefer-pic { setvar pic_mode = 'yes' continue } -prefer-non-pic { setvar 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 "/" "" setvar objname = "$func_basename_result" setvar xdir = "$func_dirname_result" setvar lobj = "${xdir}$objdir/$objname" test -z $base_compile && \ func_fatal_help "you must specify a compilation command" # Delete any leftover library objects. if test $build_old_libs = yes { setvar removelist = ""$obj $lobj $libobj ${libobj}T"" } else { setvar removelist = ""$lobj $libobj ${libobj}T"" } # On Cygwin there's no "real" PIC flag so we must build both object types case (host_os) { cygwin* | mingw* | pw32* | os2* | cegcc* { setvar pic_mode = 'default' } } if test $pic_mode = no && test $deplibs_check_method != pass_all { # non-PIC code in shared libraries is not supported setvar pic_mode = 'default' } # Calculate the filename of the output object if compiler does # not support -o with -c if test $compiler_c_o = no { setvar output_obj = "$($ECHO $srcfile | $SED 's%^.*/%%; s%\.[^.]*$%%).${objext}" setvar lockfile = ""$output_obj.lock"" } else { setvar output_obj = '' setvar need_locks = 'no' setvar 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 $need_locks = yes { while ! $opt_dry_run || ln $progpath $lockfile { func_echo "Waiting for $lockfile to be removed" sleep 2 } } elif test $need_locks = warn { if test -f $lockfile { $ECHO "\ *** ERROR, $lockfile exists and contains: $(cat $lockfile ) 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 } setvar removelist = ""$removelist $output_obj"" $ECHO $srcfile > "$lockfile" } $opt_dry_run || $RM $removelist setvar removelist = ""$removelist $lockfile"" trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 if test -n $fix_srcfile_path { eval "srcfile=\"$fix_srcfile_path\"" } func_quote_for_eval $srcfile setvar qsrcfile = "$func_quote_for_eval_result" # Only build a PIC object if we are building libtool libraries. if test $build_libtool_libs = yes { # Without this assignment, base_compile gets emptied. setvar fbsd_hideous_sh_bug = "$base_compile" if test $pic_mode != no { setvar command = ""$base_compile $qsrcfile $pic_flag"" } else { # Don't build PIC code setvar command = ""$base_compile $qsrcfile"" } func_mkdir_p "$xdir$objdir" if test -z $output_obj { # Place PIC objects in $objdir setvar command = ""$command -o $lobj"" } func_show_eval_locale $command \ 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' if test $need_locks = warn && test "X$(cat $lockfile )" != "X$srcfile" { $ECHO "\ *** ERROR, $lockfile contains: $(cat $lockfile ) 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 $suppress_opt = yes { setvar suppress_output = '' >/dev/null 2>&1'' } } # Only build a position-dependent object if we build old libraries. if test $build_old_libs = yes { if test $pic_mode != yes { # Don't build PIC code setvar command = ""$base_compile $qsrcfile$pie_flag"" } else { setvar command = ""$base_compile $qsrcfile $pic_flag"" } if test $compiler_c_o = yes { setvar command = ""$command -o $obj"" } # Suppress compiler output if we already did a PIC compilation. setvar command = ""$command$suppress_output"" func_show_eval_locale $command \ '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' if test $need_locks = warn && test "X$(cat $lockfile )" != "X$srcfile" { $ECHO "\ *** ERROR, $lockfile contains: $(cat $lockfile ) 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 $need_locks != no { setvar removelist = "$lockfile" $RM $lockfile } } exit $EXIT_SUCCESS } $opt_help || do { test $mode = compile && func_mode_compile ${1+"$@"} } proc func_mode_help { # We need to display help for each of the modes. case (mode) { "" { # Generic help is extracted from the usage comments # at the start of this file. func_help } 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." } 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 building PIC objects only -prefer-non-pic try to building 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'." } 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." } 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." } 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)." } 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 -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." } 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." } * { func_fatal_help "invalid operation mode \`$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 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 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 { $opt_debug # The first argument is the command name. setvar cmd = "$nonopt" test -z $cmd && \ func_fatal_help "you must specify a COMMAND" # Handle -dlopen flags immediately. for file in $execute_dlfiles { test -f $file \ || func_fatal_help "\`$file' is not a file" setvar dir = '' case (file) { *.la { # 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. setvar dlname = '' setvar 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 "" "." setvar dir = "$func_dirname_result" if test -f "$dir/$objdir/$dlname" { setvar dir = ""$dir/$objdir"" } else { if test ! -f "$dir/$dlname" { func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" } } } *.lo { # Just add the directory containing the .lo file. func_dirname $file "" "." setvar dir = "$func_dirname_result" } * { func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" continue } } # Get the absolute pathname. setvar absdir = $(cd $dir && pwd) test -n $absdir && setvar 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. setvar libtool_execute_magic = "$magic" # Check if any of the arguments is a wrapper script. setvar args = ''for file in @ARGV { case (file) { -* | *.la | *.lo { } * { # 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. setvar file = ""$progdir/$program"" } elif func_ltwrapper_executable_p $file { func_ltwrapper_scriptname $file func_source $func_ltwrapper_scriptname_result # Transform arg to wrapped name. setvar file = ""$progdir/$program"" } } } # Quote arguments (to preserve shell metacharacters). func_quote_for_eval $file setvar args = ""$args $func_quote_for_eval_result"" } if test "X$opt_dry_run" = Xfalse { 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. setvar exec_cmd = ""\$cmd$args"" } else { # 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 } } test $mode = execute && func_mode_execute ${1+"$@"} # func_mode_finish arg... proc func_mode_finish { $opt_debug setvar libdirs = "$nonopt" setvar admincmds = '' if test -n "$finish_cmds$finish_eval" && test -n $libdirs {for dir in @ARGV { setvar libdirs = ""$libdirs $dir"" } 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 || setvar admincmds = ""$admincmds $cmds"" } } } # Exit here if they wanted silent mode. $opt_silent && exit $EXIT_SUCCESS 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 { setvar 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" case (host) { solaris2.[6789]|solaris2.1[0-9] { echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" echo "pages." } * { echo "more information, such as the ld(1) and ld.so(8) manual pages." } } echo "----------------------------------------------------------------------" exit $EXIT_SUCCESS } test $mode = finish && func_mode_finish ${1+"$@"} # func_mode_install arg... proc func_mode_install { $opt_debug # There may be an optional sh(1) argument at the beginning of # install_prog (especially on Windows NT). if test $nonopt = $SHELL || test $nonopt = /bin/sh || # Allow the use of GNU shtool's install command. case (nonopt) { *shtool* { :} * { false} } { # Aesthetically quote it. func_quote_for_eval $nonopt setvar install_prog = ""$func_quote_for_eval_result "" setvar arg = "$1" shift } else { setvar install_prog = '' setvar arg = "$nonopt" } # The real first argument should be the name of the installation program. # Aesthetically quote it. func_quote_for_eval $arg setvar install_prog = ""$install_prog$func_quote_for_eval_result"" setvar install_shared_prog = "$install_prog" case{ *[\\\ /]cp\ * { setvar install_cp = ':' } * { setvar install_cp = 'false' } } # We need to accept at least all the BSD install flags. setvar dest = '' setvar files = '' setvar opts = '' setvar prev = '' setvar install_type = '' setvar isdir = 'no' setvar stripme = '' setvar no_mode = ':'for arg in @ARGV { setvar arg2 = '' if test -n $dest { setvar files = ""$files $dest"" setvar dest = "$arg" continue } case (arg) { -d { setvar isdir = 'yes' } -f { if $install_cp { :; } else { setvar prev = "$arg" } } -g | -m | -o { setvar prev = "$arg" } -s { setvar stripme = "" -s"" continue } -* { } * { # If the previous option needed an argument, then skip it. if test -n $prev { if test "x$prev" = x-m && test -n $install_override_mode { setvar arg2 = "$install_override_mode" setvar no_mode = 'false' } setvar prev = '' } else { setvar dest = "$arg" continue } } } # Aesthetically quote the argument. func_quote_for_eval $arg setvar install_prog = ""$install_prog $func_quote_for_eval_result"" if test -n $arg2 { func_quote_for_eval $arg2 } setvar install_shared_prog = ""$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 setvar install_shared_prog = ""$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 setvar dest = "$func_stripname_result" # Check to see that the destination is a directory. test -d $dest && setvar isdir = 'yes' if test $isdir = yes { setvar destdir = "$dest" setvar destname = '' } else { func_dirname_and_basename $dest "" "." setvar destdir = "$func_dirname_result" setvar 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" } case (destdir) { [\\/]* | [A-Za-z]:[\\/]* { } * { for file in $files { case (file) { *.lo { } * { func_fatal_help "\`$destdir' must be an absolute directory name" } } } } } # This variable tells wrapper scripts just to set variables rather # than running their programs. setvar libtool_install_magic = "$magic" setvar staticlibs = '' setvar future_libdirs = '' setvar current_libdirs = '' for file in $files { # Do each installation. case (file) { *.$libext { # Do the static libraries later. setvar staticlibs = ""$staticlibs $file"" } *.la { # 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" setvar library_names = '' setvar old_library = '' setvar relink_command = '' func_source $file # Add the libdir to current_libdirs if it is the destination. if test "X$destdir" = "X$libdir" { case{ *" $libdir "* { } * { setvar current_libdirs = ""$current_libdirs $libdir"" } } } else { # Note the libdir as a future libdir. case{ *" $libdir "* { } * { setvar future_libdirs = ""$future_libdirs $libdir"" } } } func_dirname $file "/" "" setvar dir = "$func_dirname_result" setvar dir = ""$dir$objdir"" if test -n $relink_command { # Determine the prefix the user has applied to our future dir. setvar 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. setvar relink_command = $($ECHO $relink_command | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%) } else { setvar 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 { setvar realname = "$1" shift setvar srcname = "$realname" test -n $relink_command && setvar srcname = ""$realname"T" # Install the shared library and build the symlinks. func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ 'exit $?' setvar tstripme = "$stripme" case (host_os) { cygwin* | mingw* | pw32* | cegcc* { case (realname) { *.dll.a { setvar 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. setvar lib = ""$destdir/$realname"" func_execute_cmds $postinstall_cmds 'exit $?' } # Install the pseudo-library for information purposes. func_basename $file setvar name = "$func_basename_result" setvar instname = ""$dir/$name"i" func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' # Maybe install the static library, too. test -n $old_library && setvar staticlibs = ""$staticlibs $dir/$old_library"" } *.lo { # Install (i.e. copy) a libtool object. # Figure out destination file name, if it wasn't already specified. if test -n $destname { setvar destfile = ""$destdir/$destname"" } else { func_basename $file setvar destfile = "$func_basename_result" setvar destfile = ""$destdir/$destfile"" } # Deduce the name of the destination old-style object file. case (destfile) { *.lo { func_lo2o $destfile setvar staticdest = "$func_lo2o_result" } *.$objext { setvar staticdest = "$destfile" setvar destfile = '' } * { 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 $build_old_libs = yes { # Deduce the name of the old-style object file. func_lo2o $file setvar staticobj = "$func_lo2o_result" func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' } exit $EXIT_SUCCESS } * { # Figure out destination file name, if it wasn't already specified. if test -n $destname { setvar destfile = ""$destdir/$destname"" } else { func_basename $file setvar destfile = "$func_basename_result" setvar 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 setvar stripped_ext = """" case (file) { *.exe { if test ! -f $file { func_stripname '' '.exe' $file setvar file = "$func_stripname_result" setvar stripped_ext = "".exe"" } } } # Do a test to see if this is really a libtool program. case (host) { *cygwin* | *mingw* { if func_ltwrapper_executable_p $file { func_ltwrapper_scriptname $file setvar wrapper = "$func_ltwrapper_scriptname_result" } else { func_stripname '' '.exe' $file setvar wrapper = "$func_stripname_result" } } * { setvar wrapper = "$file" } } if func_ltwrapper_script_p $wrapper { setvar notinst_deplibs = '' setvar 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'" setvar finalize = 'yes' for lib in $notinst_deplibs { # Check to see that each library is installed. setvar libdir = '' if test -f $lib { func_source $lib } setvar libfile = ""$libdir/"$($ECHO $lib | $SED 's%^.*/%%g)" ### testsuite: skip nested quoting test if test -n $libdir && test ! -f $libfile { func_warning "\`$lib' has not been installed in \`$libdir'" setvar finalize = 'no' } } setvar relink_command = '' func_source $wrapper setvar outputname = '' if test $fast_install = no && test -n $relink_command { $opt_dry_run || do { if test $finalize = yes { setvar tmpdir = $(func_mktempdir) func_basename "$file$stripped_ext" setvar file = "$func_basename_result" setvar outputname = ""$tmpdir/$file"" # Replace the output file specification. setvar relink_command = $($ECHO $relink_command | $SED 's%@OUTPUT@%'"$outputname"'%g) $opt_silent || 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 } setvar file = "$outputname" } else { func_warning "cannot relink \`$file'" } } } else { # Install the binary that we compiled earlier. setvar file = $($ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%) } } # remove .exe since cygwin /usr/bin/install will append another # one anyway case (install_prog) { */usr/bin/install*,*cygwin* { case (file) { *.exe:*.exe { # this is ok } *.exe:* { setvar destfile = "$destfile.exe" } *:*.exe { func_stripname '' '.exe' $destfile setvar 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 setvar name = "$func_basename_result" # Set up the ranlib parameters. setvar oldlib = ""$destdir/$name"" func_show_eval "$install_prog \$file \$oldlib" 'exit $?' if test -n $stripme && test -n $old_striplib { func_show_eval "$old_striplib $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 && $opt_finish { # Maybe just do a dry run. $opt_dry_run && setvar current_libdirs = "" -n$current_libdirs"" setvar exec_cmd = ''$SHELL $progpath $preserve_args --finish$current_libdirs'' } else { exit $EXIT_SUCCESS } } test $mode = install && 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 { $opt_debug setvar my_outputname = "$1" setvar my_originator = "$2" setvar my_pic_p = "${3-no}" setvar my_prefix = $($ECHO $my_originator | sed 's%[^a-zA-Z0-9]%_%g) setvar my_dlsyms = '' if test -n "$dlfiles$dlprefiles" || test $dlself != no { if test -n $NM && test -n $global_symbol_pipe { setvar my_dlsyms = ""${my_outputname}S.c"" } else { func_error "not configured to extract global symbols from dlpreopened files" } } if test -n $my_dlsyms { case (my_dlsyms) { "" { } *.c { # Discover the nlist of each of the dlfiles. setvar 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$TIMESTAMP) $VERSION */ #ifdef __cplusplus extern \"C\" { #endif #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) #pragma GCC diagnostic ignored \"-Wstrict-prototypes\" #endif /* 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$TIMESTAMP) $VERSION */ #ifdef __cplusplus extern \"C\" { #endif #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) #pragma GCC diagnostic ignored \"-Wstrict-prototypes\" #endif /* External symbol declarations for the compiler. */\ " if test $dlself = yes { func_verbose "generating symbol list for \`$output'" $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" # Add our own program objects to the symbol list. setvar progfiles = $($ECHO "$objs$old_deplibs" | $SP2NL | $SED $lo2o | $NL2SP) for progfile in $progfiles { func_verbose "extracting global C symbols from \`$progfile'" $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'" } if test -n $exclude_expsyms { $opt_dry_run || do { $EGREP -v " ($exclude_expsyms)$" $nlist > "$nlist"T $MV "$nlist"T $nlist } } if test -n $export_symbols_regex { $opt_dry_run || do { $EGREP -e $export_symbols_regex $nlist > "$nlist"T $MV "$nlist"T $nlist } } # Prepare the list of exported symbols if test -z $export_symbols { setvar export_symbols = ""$output_objdir/$outputname.exp"" $opt_dry_run || do { $RM $export_symbols ${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' < "$nlist" > "$export_symbols" case (host) { *cygwin* | *mingw* | *cegcc* { echo EXPORTS > "$output_objdir/$outputname.def" cat $export_symbols >> "$output_objdir/$outputname.def" } } } } else { $opt_dry_run || do { ${SED} -e 's/\([].[*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/' < "$export_symbols" > "$output_objdir/$outputname.exp" $GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T $MV "$nlist"T $nlist case (host) { *cygwin* | *mingw* | *cegcc* { echo EXPORTS > "$output_objdir/$outputname.def" cat $nlist >> "$output_objdir/$outputname.def" } } } } } for dlprefile in $dlprefiles { func_verbose "extracting global C symbols from \`$dlprefile'" func_basename $dlprefile setvar name = "$func_basename_result" $opt_dry_run || do { $ECHO ": $name " >> "$nlist" eval "$NM $dlprefile 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" } echo >> "$output_objdir/$my_dlsyms" "\ /* The mapping between symbol names and symbols. */ typedef struct { const char *name; void *address; } lt_dlsymlist; >> "$output_objdir/$my_dlsyms" "\ /* The mapping between symbol names and symbols. */ typedef struct { const char *name; void *address; } lt_dlsymlist; " case (host) { *cygwin* | *mingw* | *cegcc* { echo >> "$output_objdir/$my_dlsyms" "\ /* DATA imports from DLLs on WIN32 con't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */>> "$output_objdir/$my_dlsyms" "\ /* DATA imports from DLLs on WIN32 con't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */" setvar lt_dlsym_const = '' } *osf5* { echo >> "$output_objdir/$my_dlsyms" "\ /* This system does not cope well with relocations in const data */>> "$output_objdir/$my_dlsyms" "\ /* This system does not cope well with relocations in const data */" setvar lt_dlsym_const = '' } * { setvar lt_dlsym_const = 'const' } } echo >> "$output_objdir/$my_dlsyms" "\ extern $lt_dlsym_const lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[]; $lt_dlsym_const lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[] = {\ { \"$my_originator\", (void *) 0 },>> "$output_objdir/$my_dlsyms" "\ extern $lt_dlsym_const lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[]; $lt_dlsym_const lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[] = {\ { \"$my_originator\", (void *) 0 }," case (need_lib_prefix) { no { eval $global_symbol_to_c_name_address < "$nlist" >> "$output_objdir/$my_dlsyms" } * { 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 setvar pic_flag_for_symtable = '' case{ *" -static "* { } * { case (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. *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0* { setvar pic_flag_for_symtable = "" $pic_flag -DFREEBSD_WORKAROUND"" } *-*-hpux* { setvar pic_flag_for_symtable = "" $pic_flag"" } * { if test "X$my_pic_p" != Xno { setvar pic_flag_for_symtable = "" $pic_flag"" } } } } } setvar symtab_cflags = '' for arg in $LTCFLAGS { case (arg) { -pie | -fpie | -fPIE { } * { setvar symtab_cflags = ""$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"' # Transform the symbol file into the correct name. setvar symfileobj = ""$output_objdir/${my_outputname}S.$objext"" case (host) { *cygwin* | *mingw* | *cegcc* { if test -f "$output_objdir/$my_outputname.def" { setvar compile_command = $($ECHO $compile_command | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%) setvar finalize_command = $($ECHO $finalize_command | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%) } else { setvar compile_command = $($ECHO $compile_command | $SED "s%@SYMFILE@%$symfileobj%) setvar finalize_command = $($ECHO $finalize_command | $SED "s%@SYMFILE@%$symfileobj%) } } * { setvar compile_command = $($ECHO $compile_command | $SED "s%@SYMFILE@%$symfileobj%) setvar finalize_command = $($ECHO $finalize_command | $SED "s%@SYMFILE@%$symfileobj%) } } } * { 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. setvar compile_command = $($ECHO $compile_command | $SED "s% @SYMFILE@%%) setvar finalize_command = $($ECHO $finalize_command | $SED "s% @SYMFILE@%%) } } # 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 { $opt_debug setvar win32_libid_type = ""unknown"" setvar win32_fileres = $(file -L $1 ) case (win32_fileres) { *ar\ archive\ import\ library* { # definitely import setvar win32_libid_type = ""x86 archive import"" } *ar\ archive* { # could be an import, or static if $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | $EGREP 'file format (pe-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null { setvar win32_nmres = $($NM -f posix -A $1 | $SED -n -e ' 1,100{ / I /{ s,.*,import, p q } }) case (win32_nmres) { import* { setvar win32_libid_type = ""x86 archive import""} * { setvar win32_libid_type = ""x86 archive static""} } } } *DLL* { setvar win32_libid_type = ""x86 DLL"" } *executable* { # but shell scripts are "executable" too... case (win32_fileres) { *MS\ Windows\ PE\ Intel* { setvar win32_libid_type = ""x86 DLL"" } } } } $ECHO $win32_libid_type } # func_extract_an_archive dir oldlib proc func_extract_an_archive { $opt_debug setvar f_ex_an_ar_dir = "$1"; shift setvar f_ex_an_ar_oldlib = "$1" if test $lock_old_archive_extraction = yes { setvar lockfile = "$f_ex_an_ar_oldlib.lock" while ! $opt_dry_run || ln $progpath $lockfile { 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 $lock_old_archive_extraction = yes { $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 { $opt_debug setvar my_gentop = "$1"; shift setvar my_oldlibs = ${1+"$@"} setvar my_oldobjs = """" setvar my_xlib = """" setvar my_xabs = """" setvar my_xdir = """" for my_xlib in $my_oldlibs { # Extract the objects. case (my_xlib) { [\\/]* | [A-Za-z]:[\\/]* { setvar my_xabs = "$my_xlib" } * { setvar my_xabs = "$(pwd)"/$my_xlib"" } } func_basename $my_xlib setvar my_xlib = "$func_basename_result" setvar my_xlib_u = "$my_xlib" while : { case{ *" $my_xlib_u "* { func_arith $extracted_serial + 1 setvar extracted_serial = "$func_arith_result" setvar my_xlib_u = "lt$extracted_serial-$my_xlib" } * { break } } } setvar extracted_archives = ""$extracted_archives $my_xlib_u"" setvar my_xdir = ""$my_gentop/$my_xlib_u"" func_mkdir_p $my_xdir case (host) { *-darwin* { func_verbose "Extracting $my_xabs" # Do not bother doing anything if just a dry run $opt_dry_run || do { setvar darwin_orig_dir = $(pwd) cd $my_xdir || exit $? setvar darwin_archive = "$my_xabs" setvar darwin_curdir = $(pwd) setvar darwin_base_archive = $(basename $darwin_archive) setvar darwin_arches = $($LIPO -info $darwin_archive 2>/dev/null | $GREP Architectures 2>/dev/null || true) if test -n $darwin_arches { setvar darwin_arches = $($ECHO $darwin_arches | $SED -e 's/.*are://) setvar darwin_arch = '' func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" for darwin_arch in $darwin_arches { func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" ${darwin_archive} cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" func_extract_an_archive $(pwd) ${darwin_base_archive} cd $darwin_curdir $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" } # $darwin_arches ## Okay now we've a bunch of thin objects, gotta fatten them up :) setvar darwin_filelist = $(find unfat-$$ -type f -name '*'.o -print -o -name '*'.lo -print | $SED -e $basename | sort -u) setvar darwin_file = '' setvar darwin_files = '' for darwin_file in $darwin_filelist { setvar darwin_files = $(find unfat-$$ -name $darwin_file -print | $NL2SP) $LIPO -create -output $darwin_file $darwin_files } # $darwin_filelist $RM -rf unfat-$$ cd $darwin_orig_dir } else { cd $darwin_orig_dir func_extract_an_archive $my_xdir $my_xabs } # $darwin_arches } # !$opt_dry_run } * { func_extract_an_archive $my_xdir $my_xabs } } setvar my_oldobjs = ""$my_oldobjs "$(find $my_xdir -name '*'.$objext -print -o -name '*'.lo -print | $NL2SP)" } setvar 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 in which it is stored is # the $objdir directory. This is a cygwin/mingw-specific # behavior. proc func_emit_wrapper { setvar func_emit_wrapper_arg1 = ${1-no} $ECHO "\ #! $SHELL # $output - temporary wrapper script for $objdir/$outputname # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $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\"" setvar 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\ # 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 $fast_install = yes { $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" # Export our shlibpath_var if we have one. if test $shlibpath_overrides_runpath = yes && 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 " } # fixup the dll searchpath if we need to. if test -n $dllsearchpath { $ECHO "\ # Add the dll search path components to the executable PATH PATH=$dllsearchpath:\$PATH " } $ECHO "\ if test \"\$libtool_execute_magic\" != \"$magic\"; then # Run the actual program with our arguments. " case (host) { # Backslashes separate directories on plain windows *-*-mingw | *-*-os2* | *-cegcc* { $ECHO "\ exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} " } * { $ECHO "\ exec \"\$progdir/\$program\" \${1+\"\$@\"} " } } $ECHO "\ \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 exit 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_to_host_path arg # # Convert paths to host format when used with build tools. # Intended for use with "native" mingw (where libtool itself # is running under the msys shell), or in the following cross- # build environments: # $build $host # mingw (msys) mingw [e.g. native] # cygwin mingw # *nix + wine mingw # where wine is equipped with the `winepath' executable. # In the native mingw case, the (msys) shell automatically # converts paths for any non-msys applications it launches, # but that facility isn't available from inside the cwrapper. # Similar accommodations are necessary for $host mingw and # $build cygwin. Calling this function does no harm for other # $host/$build combinations not listed above. # # ARG is the path (on $build) that should be converted to # the proper representation for $host. The result is stored # in $func_to_host_path_result. proc func_to_host_path { setvar func_to_host_path_result = "$1" if test -n $1 { case (host) { *mingw* { setvar lt_sed_naive_backslashify = ''s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'' case (build) { *mingw* { # actually, msys # awkward: cmd appends spaces to result setvar func_to_host_path_result = $(shell { cmd //c echo $1 } 2>/dev/null | $SED -e 's/[ ]*$//' -e $lt_sed_naive_backslashify) } *cygwin* { setvar func_to_host_path_result = $(cygpath -w $1 | $SED -e $lt_sed_naive_backslashify) } * { # 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: setvar func_to_host_path_tmp1 = $(winepath -w $1 ) if test "$?" -eq 0 && test -n ${func_to_host_path_tmp1} { setvar func_to_host_path_result = $($ECHO $func_to_host_path_tmp1 | $SED -e $lt_sed_naive_backslashify) } else { # Allow warning below. setvar func_to_host_path_result = '' } } } if test -z $func_to_host_path_result { func_error "Could not determine host path corresponding to" func_error " \`$1'" func_error "Continuing, but uninstalled executables may not work." # Fallback: setvar func_to_host_path_result = "$1" } } } } } # end: func_to_host_path # func_to_host_pathlist arg # # Convert pathlists to host format when used with build tools. # See func_to_host_path(), above. This function supports the # following $build/$host combinations (but does no harm for # combinations not listed here): # $build $host # mingw (msys) mingw [e.g. native] # cygwin mingw # *nix + wine mingw # # 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. # # ARG is a pathlist (on $build) that should be converted to # the proper representation on $host. The result is stored # in $func_to_host_pathlist_result. proc func_to_host_pathlist { setvar func_to_host_pathlist_result = "$1" if test -n $1 { case (host) { *mingw* { setvar lt_sed_naive_backslashify = ''s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'' # 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 setvar func_to_host_pathlist_tmp1 = "$func_stripname_result" case (build) { *mingw* { # Actually, msys. # Awkward: cmd appends spaces to result. setvar func_to_host_pathlist_result = $( shell { cmd //c echo $func_to_host_pathlist_tmp1 } 2>/dev/null | $SED -e 's/[ ]*$//' -e $lt_sed_naive_backslashify) } *cygwin* { setvar func_to_host_pathlist_result = $(cygpath -w -p $func_to_host_pathlist_tmp1 | $SED -e $lt_sed_naive_backslashify) } * { # unfortunately, winepath doesn't convert pathlists setvar func_to_host_pathlist_result = """" setvar func_to_host_pathlist_oldIFS = "$IFS" setvar IFS = ':' for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 { setvar IFS = "$func_to_host_pathlist_oldIFS" if test -n $func_to_host_pathlist_f { func_to_host_path $func_to_host_pathlist_f if test -n $func_to_host_path_result { if test -z $func_to_host_pathlist_result { setvar func_to_host_pathlist_result = "$func_to_host_path_result" } else { func_append func_to_host_pathlist_result ";$func_to_host_path_result" } } } } setvar IFS = "$func_to_host_pathlist_oldIFS" } } if test -z $func_to_host_pathlist_result { func_error "Could not determine the host path(s) corresponding to" func_error " \`$1'" func_error "Continuing, but uninstalled executables may not work." # Fallback. This may break if $1 contains DOS-style drive # specifications. The fix is not to complicate the expression # below, but for the user to provide a working wine installation # with winepath so that path translation in the cross-to-mingw # case works properly. setvar lt_replace_pathsep_nix_to_dos = ""s|:|;|g"" setvar func_to_host_pathlist_result = $(echo $func_to_host_pathlist_tmp1 |\ $SED -e $lt_replace_pathsep_nix_to_dos) } # Now, add the leading and trailing path separators back case (1) { :* { setvar func_to_host_pathlist_result = "";$func_to_host_pathlist_result"" } } case (1) { *: { func_append func_to_host_pathlist_result ";" } } } } } } # end: func_to_host_pathlist # 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$TIMESTAMP) $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. Currently, it simply execs the wrapper *script* "$SHELL $output", but could eventually absorb all of the scripts functionality and exec $objdir/$outputname directly. */ """ 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 /* 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 platforms) ... */ #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 # ifndef _INTPTR_T_DEFINED # define _INTPTR_T_DEFINED # define intptr_t int # endif #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 ((void *) stale); stale = 0; } \ } while (0) #undef LTWRAPPER_DEBUGPRINTF #if defined LT_DEBUGWRAPPER # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args static void ltwrapper_debugprintf (const char *fmt, ...) { va_list args; va_start (args, fmt); (void) vfprintf (stderr, fmt, args); va_end (args); } #else # define LTWRAPPER_DEBUGPRINTF(args) #endif const char *program_name = NULL; 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_fatal (const char *message, ...); 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 <<< """ const char * MAGIC_EXE = "$magic_exe"; const char * LIB_PATH_VARNAME = "$shlibpath_var"; """ if test $shlibpath_overrides_runpath = yes && test -n $shlibpath_var && test -n $temp_rpath { func_to_host_pathlist $temp_rpath cat <<< """ const char * LIB_PATH_VALUE = "$func_to_host_pathlist_result"; """ } else { cat <<< ''' const char * LIB_PATH_VALUE = ""; ''' } if test -n $dllsearchpath { func_to_host_pathlist "$dllsearchpath:" cat <<< """ const char * EXE_PATH_VARNAME = "PATH"; const char * EXE_PATH_VALUE = "$func_to_host_pathlist_result"; """ } else { cat <<< ''' const char * EXE_PATH_VARNAME = ""; const char * EXE_PATH_VALUE = ""; ''' } if test $fast_install = yes { 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-" #define LTWRAPPER_OPTION_PREFIX_LENGTH 5 static const size_t opt_prefix_len = LTWRAPPER_OPTION_PREFIX_LENGTH; static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX; static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script"; 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; intptr_t rval = 127; int i; program_name = (char *) xstrdup (base_name (argv[0])); LTWRAPPER_DEBUGPRINTF (("(main) argv[0] : %s\n", argv[0])); LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name)); /* very simple arg parsing; don't want to rely on getopt */ for (i = 1; i < argc; i++) { if (strcmp (argv[i], dumpscript_opt) == 0) { ''' case (host) { *mingw* | *cygwin* { # make stdout use "unix" line endings echo " setmode(1,_O_BINARY);" } } cat <<< ''' lt_dump_script (stdout); return 0; } } newargz = XMALLOC (char *, argc + 1); tmp_pathspec = find_executable (argv[0]); if (tmp_pathspec == NULL) lt_fatal ("Couldn't find %s", argv[0]); LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n", tmp_pathspec)); actual_cwrapper_path = chase_symlinks (tmp_pathspec); LTWRAPPER_DEBUGPRINTF (("(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; LTWRAPPER_DEBUGPRINTF (("(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; ''' case (host_os) { 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 */ lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE); lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE); newargc=0; for (i = 1; i < argc; i++) { if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0) { /* 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 ("Unrecognized option in %s namespace: '%s'", ltwrapper_option_prefix, argv[i]); } /* otherwise ... */ newargz[++newargc] = xstrdup (argv[i]); } newargz[++newargc] = NULL; LTWRAPPER_DEBUGPRINTF (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : ""))); for (i = 0; i < newargc; i++) { LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d] : %s\n", i, (newargz[i] ? newargz[i] : ""))); } ''' case (host_os) { mingw* { cat <<< ''' /* execv doesn't actually work on mingw as expected on unix */ newargz = prepare_spawn (newargz); rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz); if (rval == -1) { /* failed to start process */ LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno)); return 127; } return rval; ''' } * { 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 ("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; LTWRAPPER_DEBUGPRINTF (("(check_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!")); 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; LTWRAPPER_DEBUGPRINTF (("(make_executable) : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!")); 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]; int tmp_len; char *concat_name; LTWRAPPER_DEBUGPRINTF (("(find_executable) : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!")); 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 = 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 ("getcwd failed"); 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 ("getcwd failed"); 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) { LTWRAPPER_DEBUGPRINTF (("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 { char *errstr = strerror (errno); lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr); } } XFREE (tmp_pathspec); if (!has_symlinks) { return xstrdup (pathspec); } tmp_pathspec = realpath (pathspec, buf); if (tmp_pathspec == 0) { lt_fatal ("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 (strcmp (str, pat) == 0) *str = '\0'; } return str; } static void lt_error_core (int exit_status, const char *mode, const char *message, va_list ap) { fprintf (stderr, "%s: %s: ", program_name, mode); vfprintf (stderr, message, ap); fprintf (stderr, ".\n"); if (exit_status >= 0) exit (exit_status); } void lt_fatal (const char *message, ...) { va_list ap; va_start (ap, message); lt_error_core (EXIT_FAILURE, "FATAL", message, ap); va_end (ap); } void lt_setenv (const char *name, const char *value) { LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n", (name ? name : ""), (value ? value : ""))); { #ifdef HAVE_SETENV /* always make a copy, for consistency with !HAVE_SETENV */ char *str = xstrdup (value); setenv (name, str, 1); #else int 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) { int orig_value_len = strlen (orig_value); int 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) { LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n", (name ? name : ""), (value ? 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 #' */ int len = strlen (new_value); while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) { new_value[len-1] = '\0'; } lt_setenv (name, new_value); XFREE (new_value); } } void lt_update_lib_path (const char *name, const char *value) { LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n", (name ? name : ""), (value ? value : ""))); if (name && *name && value && *value) { char *new_value = lt_extend_str (getenv (name), value, 0); lt_setenv (name, new_value); XFREE (new_value); } } ''' case (host_os) { 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 -e 's/\([\\"]\)/\\\1/g' \ -e 's/^/ fputs ("/' -e 's/$/\\n", f);/' 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 { $opt_debug case{ *import* { : } * { false } } } # func_mode_link arg... proc func_mode_link { $opt_debug case (host) { *-*-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 # which 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 which 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. setvar allow_undefined = 'yes' } * { setvar allow_undefined = 'yes' } } setvar libtool_args = "$nonopt" setvar base_compile = ""$nonopt $[join(ARGV)]"" setvar compile_command = "$nonopt" setvar finalize_command = "$nonopt" setvar compile_rpath = '' setvar finalize_rpath = '' setvar compile_shlibpath = '' setvar finalize_shlibpath = '' setvar convenience = '' setvar old_convenience = '' setvar deplibs = '' setvar old_deplibs = '' setvar compiler_flags = '' setvar linker_flags = '' setvar dllsearchpath = '' setvar lib_search_path = $(pwd) setvar inst_prefix_dir = '' setvar new_inherited_linker_flags = '' setvar avoid_version = 'no' setvar bindir = '' setvar dlfiles = '' setvar dlprefiles = '' setvar dlself = 'no' setvar export_dynamic = 'no' setvar export_symbols = '' setvar export_symbols_regex = '' setvar generated = '' setvar libobjs = '' setvar ltlibs = '' setvar module = 'no' setvar no_install = 'no' setvar objs = '' setvar non_pic_objects = '' setvar precious_files_regex = '' setvar prefer_static_libs = 'no' setvar preload = 'no' setvar prev = '' setvar prevarg = '' setvar release = '' setvar rpath = '' setvar xrpath = '' setvar perm_rpath = '' setvar temp_rpath = '' setvar thread_safe = 'no' setvar vinfo = '' setvar vinfo_number = 'no' setvar weak_libs = '' setvar single_module = ""${wl}-single_module"" func_infer_tag $base_compilefor arg in @ARGV { case (arg) { -shared { test $build_libtool_libs != yes && \ func_fatal_configuration "can not build a shared library" setvar build_old_libs = 'no' break } -all-static | -static | -static-libtool-libs { case (arg) { -all-static { if test $build_libtool_libs = yes && test -z $link_static_flag { func_warning "complete static linking is impossible in this configuration" } if test -n $link_static_flag { setvar dlopen_self = "$dlopen_self_static" } setvar prefer_static_libs = 'yes' } -static { if test -z $pic_flag && test -n $link_static_flag { setvar dlopen_self = "$dlopen_self_static" } setvar prefer_static_libs = 'built' } -static-libtool-libs { if test -z $pic_flag && test -n $link_static_flag { setvar dlopen_self = "$dlopen_self_static" } setvar prefer_static_libs = 'yes' } } setvar build_libtool_libs = 'no' setvar build_old_libs = 'yes' break } } } # See if our shared archives depend on static archives. test -n $old_archive_from_new_cmds && setvar build_old_libs = 'yes' # Go through the arguments, transforming them on the way. while test "$Argc" -gt 0 { setvar arg = "$1" shift func_quote_for_eval $arg setvar 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 { case (prev) { output { func_append compile_command " @OUTPUT@" func_append finalize_command " @OUTPUT@" } } case (prev) { bindir { setvar bindir = "$arg" setvar prev = '' continue } dlfiles|dlprefiles { if test $preload = no { # Add the symbol object into the linking commands. func_append compile_command " @SYMFILE@" func_append finalize_command " @SYMFILE@" setvar preload = 'yes' } case (arg) { *.la | *.lo { } # We handle these cases below. force { if test $dlself = no { setvar dlself = 'needless' setvar export_dynamic = 'yes' } setvar prev = '' continue } self { if test $prev = dlprefiles { setvar dlself = 'yes' } elif test $prev = dlfiles && test $dlopen_self != yes { setvar dlself = 'yes' } else { setvar dlself = 'needless' setvar export_dynamic = 'yes' } setvar prev = '' continue } * { if test $prev = dlfiles { setvar dlfiles = ""$dlfiles $arg"" } else { setvar dlprefiles = ""$dlprefiles $arg"" } setvar prev = '' continue } } } expsyms { setvar export_symbols = "$arg" test -f $arg \ || func_fatal_error "symbol file \`$arg' does not exist" setvar prev = '' continue } expsyms_regex { setvar export_symbols_regex = "$arg" setvar prev = '' continue } framework { case (host) { *-*-darwin* { case{ *" $qarg.ltframework "* { } * { setvar deplibs = ""$deplibs $qarg.ltframework"" # this is fixed later } } } } setvar prev = '' continue } inst_prefix { setvar inst_prefix_dir = "$arg" setvar prev = '' continue } objectlist { if test -f $arg { setvar save_arg = "$arg" setvar moreargs = '' for fil in `cat "$save_arg"` { # moreargs="$moreargs $fil" setvar arg = "$fil" # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p $arg { setvar pic_object = '' setvar non_pic_object = '' # Read the .lo file func_source $arg if test -z $pic_object || test -z $non_pic_object || test $pic_object = none && test $non_pic_object = none { func_fatal_error "cannot find name of object for \`$arg'" } # Extract subdirectory from the argument. func_dirname $arg "/" "" setvar xdir = "$func_dirname_result" if test $pic_object != none { # Prepend the subdirectory the object is found in. setvar pic_object = ""$xdir$pic_object"" if test $prev = dlfiles { if test $build_libtool_libs = yes && test $dlopen_support = yes { setvar dlfiles = ""$dlfiles $pic_object"" setvar prev = '' continue } else { # If libtool objects are unsupported, then we need to preload. setvar prev = 'dlprefiles' } } # CHECK ME: I think I busted this. -Ossama if test $prev = dlprefiles { # Preload the old-style object. setvar dlprefiles = ""$dlprefiles $pic_object"" setvar prev = '' } # A PIC object. func_append libobjs " $pic_object" setvar arg = "$pic_object" } # Non-PIC object. if test $non_pic_object != none { # Prepend the subdirectory the object is found in. setvar 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 $pic_object = none { setvar arg = "$non_pic_object" } } else { # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. setvar 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 "/" "" setvar xdir = "$func_dirname_result" func_lo2o $arg setvar pic_object = "$xdir$objdir/$func_lo2o_result" setvar 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" } setvar arg = "$save_arg" setvar prev = '' continue } precious_regex { setvar precious_files_regex = "$arg" setvar prev = '' continue } release { setvar release = ""-$arg"" setvar prev = '' continue } rpath | xrpath { # We need an absolute path. case (arg) { [\\/]* | [A-Za-z]:[\\/]* { } * { func_fatal_error "only absolute run-paths are allowed" } } if test $prev = rpath { case{ *" $arg "* { } * { setvar rpath = ""$rpath $arg"" } } } else { case{ *" $arg "* { } * { setvar xrpath = ""$xrpath $arg"" } } } setvar prev = '' continue } shrext { setvar shrext_cmds = "$arg" setvar prev = '' continue } weak { setvar weak_libs = ""$weak_libs $arg"" setvar prev = '' continue } xcclinker { setvar linker_flags = ""$linker_flags $qarg"" setvar compiler_flags = ""$compiler_flags $qarg"" setvar prev = '' func_append compile_command " $qarg" func_append finalize_command " $qarg" continue } xcompiler { setvar compiler_flags = ""$compiler_flags $qarg"" setvar prev = '' func_append compile_command " $qarg" func_append finalize_command " $qarg" continue } xlinker { setvar linker_flags = ""$linker_flags $qarg"" setvar compiler_flags = ""$compiler_flags $wl$qarg"" setvar prev = '' func_append compile_command " $wl$qarg" func_append finalize_command " $wl$qarg" continue } * { eval "$prev=\"\$arg\"" setvar prev = '' continue } } } # test -n "$prev" setvar prevarg = "$arg" case (arg) { -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 } -allow-undefined { # FIXME: remove this flag sometime in the future. func_fatal_error "\`-allow-undefined' must not be used because it is the default" } -avoid-version { setvar avoid_version = 'yes' continue } -bindir { setvar prev = 'bindir' continue } -dlopen { setvar prev = 'dlfiles' continue } -dlpreopen { setvar prev = 'dlprefiles' continue } -export-dynamic { setvar export_dynamic = 'yes' continue } -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$arg" = "X-export-symbols" { setvar prev = 'expsyms' } else { setvar prev = 'expsyms_regex' } continue } -framework { setvar prev = 'framework' continue } -inst-prefix-dir { setvar 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 -L[A-Z][A-Z]*:* { case (with_gcc) { no/*-*-irix* | /*-*-irix* { func_append compile_command " $arg" func_append finalize_command " $arg" } } continue } -L* { func_stripname '-L' '' $arg setvar dir = "$func_stripname_result" if test -z $dir { if test "$Argc" -gt 0 { func_fatal_error "require no space between \`-L' and \`$1'" } else { func_fatal_error "need path for \`-L' option" } } # We need an absolute path. case (dir) { [\\/]* | [A-Za-z]:[\\/]* { } * { setvar absdir = $(cd $dir && pwd) test -z $absdir && \ func_fatal_error "cannot determine absolute directory name of \`$dir'" setvar dir = "$absdir" } } case{ *" -L$dir "* { } * { setvar deplibs = ""$deplibs -L$dir"" setvar lib_search_path = ""$lib_search_path $dir"" } } case (host) { *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc* { setvar testbindir = $($ECHO $dir | $SED 's*/lib$*/bin*) case{ *":$dir:"* { } :: { setvar dllsearchpath = "$dir"} * { setvar dllsearchpath = ""$dllsearchpath:$dir""} } case{ *":$testbindir:"* { } :: { setvar dllsearchpath = "$testbindir"} * { setvar dllsearchpath = ""$dllsearchpath:$testbindir""} } } } continue } -l* { if test "X$arg" = "X-lc" || test "X$arg" = "X-lm" { case (host) { *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku* { # These systems don't actually have a C or math library (as such) continue } *-*-os2* { # These systems don't actually have a C library (as such) test "X$arg" = "X-lc" && continue } *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* { # Do not include libc due to us having libc/libc_r. test "X$arg" = "X-lc" && continue } *-*-rhapsody* | *-*-darwin1.[012] { # Rhapsody C and math libraries are in the System framework setvar deplibs = ""$deplibs System.ltframework"" continue } *-*-sco3.2v5* | *-*-sco5v6* { # Causes problems with __ctype test "X$arg" = "X-lc" && continue } *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX* { # Compiler inserts libc in the correct place for threads to work test "X$arg" = "X-lc" && continue } *-*-linux* { test "X$arg" = "X-lc" && continue } } } elif test "X$arg" = "X-lc_r" { case (host) { *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* { # Do not include libc_r directly, use -pthread flag. continue } } } setvar deplibs = ""$deplibs $arg"" continue } -module { setvar 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. -model|-arch|-isysroot { setvar compiler_flags = ""$compiler_flags $arg"" func_append compile_command " $arg" func_append finalize_command " $arg" setvar prev = 'xcompiler' continue } -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads { setvar compiler_flags = ""$compiler_flags $arg"" func_append compile_command " $arg" func_append finalize_command " $arg" case{ *" $arg "* { } * { setvar new_inherited_linker_flags = ""$new_inherited_linker_flags $arg"" } } continue } -multi_module { setvar single_module = ""${wl}-multi_module"" continue } -no-fast-install { setvar fast_install = 'no' continue } -no-install { case (host) { *-*-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" setvar fast_install = 'no' } * { setvar no_install = 'yes' } } continue } -no-undefined { setvar allow_undefined = 'no' continue } -objectlist { setvar prev = 'objectlist' continue } -o { setvar prev = 'output' } -precious-files-regex { setvar prev = 'precious_regex' continue } -release { setvar prev = 'release' continue } -rpath { setvar prev = 'rpath' continue } -R { setvar prev = 'xrpath' continue } -R* { func_stripname '-R' '' $arg setvar dir = "$func_stripname_result" # We need an absolute path. case (dir) { [\\/]* | [A-Za-z]:[\\/]* { } * { func_fatal_error "only absolute run-paths are allowed" } } case{ *" $dir "* { } * { setvar xrpath = ""$xrpath $dir"" } } continue } -shared { # The effects of -shared are defined in a previous loop. continue } -shrext { setvar prev = 'shrext' continue } -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 } -thread-safe { setvar thread_safe = 'yes' continue } -version-info { setvar prev = 'vinfo' continue } -version-number { setvar prev = 'vinfo' setvar vinfo_number = 'yes' continue } -weak { setvar prev = 'weak' continue } -Wc,* { func_stripname '-Wc,' '' $arg setvar args = "$func_stripname_result" setvar arg = '' setvar save_ifs = "$IFS"; setvar IFS = '','' for flag in $args { setvar IFS = "$save_ifs" func_quote_for_eval $flag setvar arg = ""$arg $func_quote_for_eval_result"" setvar compiler_flags = ""$compiler_flags $func_quote_for_eval_result"" } setvar IFS = "$save_ifs" func_stripname ' ' '' $arg setvar arg = "$func_stripname_result" } -Wl,* { func_stripname '-Wl,' '' $arg setvar args = "$func_stripname_result" setvar arg = '' setvar save_ifs = "$IFS"; setvar IFS = '','' for flag in $args { setvar IFS = "$save_ifs" func_quote_for_eval $flag setvar arg = ""$arg $wl$func_quote_for_eval_result"" setvar compiler_flags = ""$compiler_flags $wl$func_quote_for_eval_result"" setvar linker_flags = ""$linker_flags $func_quote_for_eval_result"" } setvar IFS = "$save_ifs" func_stripname ' ' '' $arg setvar arg = "$func_stripname_result" } -Xcompiler { setvar prev = 'xcompiler' continue } -Xlinker { setvar prev = 'xlinker' continue } -XCClinker { setvar prev = 'xcclinker' continue } # -msg_* for osf cc -msg_* { func_quote_for_eval $arg setvar arg = "$func_quote_for_eval_result" } # -64, -mips[0-9] enable 64-bit mode on the SGI compiler # -r[0-9][0-9]* specifies the processor on the SGI compiler # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler # +DA*, +DD* enable 64-bit mode on the HP compiler # -q* pass through compiler args for the IBM compiler # -m*, -t[45]*, -txscale* pass through architecture-specific # compiler args for GCC # -F/path gives path to uninstalled frameworks, gcc on darwin # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC # @file GCC response files # -tp=* Portland pgcc target processor selection -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=* { func_quote_for_eval $arg setvar arg = "$func_quote_for_eval_result" func_append compile_command " $arg" func_append finalize_command " $arg" setvar compiler_flags = ""$compiler_flags $arg"" continue } # Some other compiler flag. -* | +* { func_quote_for_eval $arg setvar arg = "$func_quote_for_eval_result" } *.$objext { # A standard object. setvar objs = ""$objs $arg"" } *.lo { # A libtool-controlled object. # Check to see that this really is a libtool object. if func_lalib_unsafe_p $arg { setvar pic_object = '' setvar non_pic_object = '' # Read the .lo file func_source $arg if test -z $pic_object || test -z $non_pic_object || test $pic_object = none && test $non_pic_object = none { func_fatal_error "cannot find name of object for \`$arg'" } # Extract subdirectory from the argument. func_dirname $arg "/" "" setvar xdir = "$func_dirname_result" if test $pic_object != none { # Prepend the subdirectory the object is found in. setvar pic_object = ""$xdir$pic_object"" if test $prev = dlfiles { if test $build_libtool_libs = yes && test $dlopen_support = yes { setvar dlfiles = ""$dlfiles $pic_object"" setvar prev = '' continue } else { # If libtool objects are unsupported, then we need to preload. setvar prev = 'dlprefiles' } } # CHECK ME: I think I busted this. -Ossama if test $prev = dlprefiles { # Preload the old-style object. setvar dlprefiles = ""$dlprefiles $pic_object"" setvar prev = '' } # A PIC object. func_append libobjs " $pic_object" setvar arg = "$pic_object" } # Non-PIC object. if test $non_pic_object != none { # Prepend the subdirectory the object is found in. setvar 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 $pic_object = none { setvar arg = "$non_pic_object" } } else { # If the PIC object exists, use it instead. # $xdir was prepended to $pic_object above. setvar 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 "/" "" setvar xdir = "$func_dirname_result" func_lo2o $arg setvar pic_object = "$xdir$objdir/$func_lo2o_result" setvar 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" } } } *.$libext { # An archive. setvar deplibs = ""$deplibs $arg"" setvar old_deplibs = ""$old_deplibs $arg"" continue } *.la { # A libtool-controlled library. if test $prev = dlfiles { # This library was specified with -dlopen. setvar dlfiles = ""$dlfiles $arg"" setvar prev = '' } elif test $prev = dlprefiles { # The library was specified with -dlpreopen. setvar dlprefiles = ""$dlprefiles $arg"" setvar prev = '' } else { setvar deplibs = ""$deplibs $arg"" } continue } # Some other compiler argument. * { # Unknown arguments in both finalize_command and compile_command need # to be aesthetically quoted because they are evaled later. func_quote_for_eval $arg setvar 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 $export_dynamic = yes && test -n $export_dynamic_flag_spec { eval "arg=\"$export_dynamic_flag_spec\"" func_append compile_command " $arg" func_append finalize_command " $arg" } setvar oldlibs = '' # calculate the name of the file, without its directory func_basename $output setvar outputname = "$func_basename_result" setvar 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 { setvar shlib_search_path = '' } eval "sys_lib_search_path=\"$sys_lib_search_path_spec\"" eval "sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"" func_dirname $output "/" "" setvar output_objdir = ""$func_dirname_result$objdir"" # Create the object directory. func_mkdir_p $output_objdir # Determine the type of output case (output) { "" { func_fatal_help "you must specify an output file" } *.$libext { setvar linkmode = 'oldlib' } *.lo | *.$objext { setvar linkmode = 'obj' } *.la { setvar linkmode = 'lib' } * { setvar linkmode = 'prog' } # Anything else should be a program. } setvar specialdeplibs = '' setvar 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_duplicate_deps { case{ *" $deplib "* { setvar specialdeplibs = ""$specialdeplibs $deplib"" } } } setvar libs = ""$libs $deplib"" } if test $linkmode = lib { setvar 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). setvar pre_post_deps = '' if $opt_duplicate_compiler_generated_deps { for pre_post_dep in $predeps $postdeps { case{ *" $pre_post_dep "* { setvar specialdeplibs = ""$specialdeplibs $pre_post_deps"" } } setvar pre_post_deps = ""$pre_post_deps $pre_post_dep"" } } setvar pre_post_deps = '' } setvar deplibs = '' setvar newdependency_libs = '' setvar newlib_search_path = '' setvar need_relink = 'no' # whether we're linking any uninstalled libtool libraries setvar notinst_deplibs = '' # not-installed libtool libraries setvar notinst_path = '' # paths that contain not-installed libtool libraries case (linkmode) { lib { setvar passes = ""conv dlpreopen link"" for file in $dlfiles $dlprefiles { case (file) { *.la { } * { func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" } } } } prog { setvar compile_deplibs = '' setvar finalize_deplibs = '' setvar alldeplibs = 'no' setvar newdlfiles = '' setvar newdlprefiles = '' setvar passes = ""conv scan dlopen dlpreopen link"" } * { setvar 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 "$linkmode,$pass" = "lib,link" { ## FIXME: Find the place where the list is rebuilt in the wrong ## order, and fix it there properly setvar tmp_deplibs = '' for deplib in $deplibs { setvar tmp_deplibs = ""$deplib $tmp_deplibs"" } setvar deplibs = "$tmp_deplibs" } if test "$linkmode,$pass" = "lib,link" || test "$linkmode,$pass" = "prog,scan" { setvar libs = "$deplibs" setvar deplibs = '' } if test $linkmode = prog { case (pass) { dlopen { setvar libs = "$dlfiles" } dlpreopen { setvar libs = "$dlprefiles" } link { setvar libs = ""$deplibs %DEPLIBS% $dependency_libs"" } } } if test "$linkmode,$pass" = "lib,dlpreopen" { # Collect and forward deplibs of preopened libtool libs for lib in $dlprefiles { # Ignore non-libtool-libs setvar dependency_libs = '' case (lib) { *.la { func_source $lib } } # Collect preopened libtool deplibs, except any this library # has declared as weak libs for deplib in $dependency_libs { func_basename $deplib setvar deplib_base = "$func_basename_result" case{ *" $deplib_base "* { } * { setvar deplibs = ""$deplibs $deplib"" } } } } setvar libs = "$dlprefiles" } if test $pass = dlopen { # Collect dlpreopened libraries setvar save_deplibs = "$deplibs" setvar deplibs = '' } for deplib in $libs { setvar lib = '' setvar found = 'no' case (deplib) { -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads { if test "$linkmode,$pass" = "prog,link" { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setvar compiler_flags = ""$compiler_flags $deplib"" if test $linkmode = lib { case{ *" $deplib "* { } * { setvar new_inherited_linker_flags = ""$new_inherited_linker_flags $deplib"" } } } } continue } -l* { if test $linkmode != lib && test $linkmode != prog { func_warning "\`-l' is ignored for archives/objects" continue } func_stripname '-l' '' $deplib setvar name = "$func_stripname_result" if test $linkmode = lib { setvar searchdirs = ""$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"" } else { setvar 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 setvar lib = ""$searchdir/lib${name}${search_ext}"" if test -f $lib { if test $search_ext = ".la" { setvar found = 'yes' } else { setvar found = 'no' } break 2 } } } if test $found != yes { # deplib doesn't seem to be a libtool library if test "$linkmode,$pass" = "prog,link" { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setvar deplibs = ""$deplib $deplibs"" test $linkmode = lib && setvar newdependency_libs = ""$deplib $newdependency_libs"" } continue } else { # 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 "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { case{ *" $deplib "* { if func_lalib_p $lib { setvar library_names = '' setvar old_library = '' func_source $lib for l in $old_library $library_names { setvar ll = "$l" } if test "X$ll" = "X$old_library" { # only static version available setvar found = 'no' func_dirname $lib "" "." setvar ladir = "$func_dirname_result" setvar lib = "$ladir/$old_library" if test "$linkmode,$pass" = "prog,link" { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setvar deplibs = ""$deplib $deplibs"" test $linkmode = lib && setvar newdependency_libs = ""$deplib $newdependency_libs"" } continue } } } * { } } } } } # -l *.ltframework { if test "$linkmode,$pass" = "prog,link" { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setvar deplibs = ""$deplib $deplibs"" if test $linkmode = lib { case{ *" $deplib "* { } * { setvar new_inherited_linker_flags = ""$new_inherited_linker_flags $deplib"" } } } } continue } -L* { case (linkmode) { lib { setvar deplibs = ""$deplib $deplibs"" test $pass = conv && continue setvar newdependency_libs = ""$deplib $newdependency_libs"" func_stripname '-L' '' $deplib setvar newlib_search_path = ""$newlib_search_path $func_stripname_result"" } prog { if test $pass = conv { setvar deplibs = ""$deplib $deplibs"" continue } if test $pass = scan { setvar deplibs = ""$deplib $deplibs"" } else { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } func_stripname '-L' '' $deplib setvar newlib_search_path = ""$newlib_search_path $func_stripname_result"" } * { func_warning "\`-L' is ignored for archives/objects" } } # linkmode continue } # -L -R* { if test $pass = link { func_stripname '-R' '' $deplib setvar dir = "$func_stripname_result" # Make sure the xrpath contains only unique directories. case{ *" $dir "* { } * { setvar xrpath = ""$xrpath $dir"" } } } setvar deplibs = ""$deplib $deplibs"" continue } *.la { setvar lib = "$deplib" } *.$libext { if test $pass = conv { setvar deplibs = ""$deplib $deplibs"" continue } case (linkmode) { lib { # Linking convenience modules into shared libraries is allowed, # but linking other static libraries is non-portable. case{ *" $deplib "* { } * { setvar valid_a_lib = 'no' case (deplibs_check_method) { match_pattern* { set dummy $deplibs_check_method; shift setvar match_pattern_regex = $(expr $deplibs_check_method : "$1 \(.*\)) if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ | $EGREP $match_pattern_regex > /dev/null { setvar valid_a_lib = 'yes' } } pass_all { setvar valid_a_lib = 'yes' } } if test $valid_a_lib != yes { 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." } else { echo $ECHO "*** Warning: Linking the shared library $output against the" $ECHO "*** static library $deplib is not portable!" setvar deplibs = ""$deplib $deplibs"" } } } continue } prog { if test $pass != link { setvar deplibs = ""$deplib $deplibs"" } else { setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } continue } } # linkmode } # *.$libext *.lo | *.$objext { if test $pass = conv { setvar deplibs = ""$deplib $deplibs"" } elif test $linkmode = prog { if test $pass = dlpreopen || test $dlopen_support != yes || test $build_libtool_libs = no { # If there is no dlopen support or we're linking statically, # we need to preload. setvar newdlprefiles = ""$newdlprefiles $deplib"" setvar compile_deplibs = ""$deplib $compile_deplibs"" setvar finalize_deplibs = ""$deplib $finalize_deplibs"" } else { setvar newdlfiles = ""$newdlfiles $deplib"" } } continue } %DEPLIBS% { setvar alldeplibs = 'yes' continue } } # case $deplib if test $found = yes || test -f $lib { : } else { 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 "" "." setvar ladir = "$func_dirname_result" setvar dlname = '' setvar dlopen = '' setvar dlpreopen = '' setvar libdir = '' setvar library_names = '' setvar old_library = '' setvar inherited_linker_flags = '' # If the library was installed with an old release of libtool, # it will not redefine variables installed, or shouldnotlink setvar installed = 'yes' setvar shouldnotlink = 'no' setvar avoidtemprpath = '' # Read the .la file func_source $lib # Convert "-framework foo" to "foo.ltframework" if test -n $inherited_linker_flags { setvar tmp_inherited_linker_flags = $($ECHO $inherited_linker_flags | $SED 's/-framework \([^ $]*\)/\1.ltframework/g) for tmp_inherited_linker_flag in $tmp_inherited_linker_flags { case{ *" $tmp_inherited_linker_flag "* { } * { setvar new_inherited_linker_flags = ""$new_inherited_linker_flags $tmp_inherited_linker_flag""} } } } setvar dependency_libs = $($ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g) if test "$linkmode,$pass" = "lib,link" || test "$linkmode,$pass" = "prog,scan" || do { test $linkmode != prog && test $linkmode != lib; } { test -n $dlopen && setvar dlfiles = ""$dlfiles $dlopen"" test -n $dlpreopen && setvar dlprefiles = ""$dlprefiles $dlpreopen"" } if test $pass = conv { # Only check for convenience libraries setvar 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. setvar convenience = ""$convenience $ladir/$objdir/$old_library"" setvar old_convenience = ""$old_convenience $ladir/$objdir/$old_library"" } elif test $linkmode != prog && test $linkmode != lib { func_fatal_error "\`$lib' is not a convenience library" } setvar tmp_libs = '' for deplib in $dependency_libs { setvar deplibs = ""$deplib $deplibs"" if $opt_duplicate_deps { case{ *" $deplib "* { setvar specialdeplibs = ""$specialdeplibs $deplib"" } } } setvar tmp_libs = ""$tmp_libs $deplib"" } continue } # $pass = conv # Get the name of the library we link against. setvar linklib = '' for l in $old_library $library_names { setvar 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 $pass = dlopen { if test -z $libdir { func_fatal_error "cannot -dlopen a convenience library: \`$lib'" } if test -z $dlname || test $dlopen_support != yes || test $build_libtool_libs = no { # 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. setvar dlprefiles = ""$dlprefiles $lib $dependency_libs"" } else { setvar newdlfiles = ""$newdlfiles $lib"" } continue } # $pass = dlopen # We need an absolute path. case (ladir) { [\\/]* | [A-Za-z]:[\\/]* { setvar abs_ladir = "$ladir" } * { setvar 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" setvar abs_ladir = "$ladir" } } } func_basename $lib setvar laname = "$func_basename_result" # Find the relevant object directory and library name. if test "X$installed" = Xyes { if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib" { func_warning "library \`$lib' was moved." setvar dir = "$ladir" setvar absdir = "$abs_ladir" setvar libdir = "$abs_ladir" } else { setvar dir = "$libdir" setvar absdir = "$libdir" } test "X$hardcode_automatic" = Xyes && setvar avoidtemprpath = 'yes' } else { if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib" { setvar dir = "$ladir" setvar absdir = "$abs_ladir" # Remove this search path later setvar notinst_path = ""$notinst_path $abs_ladir"" } else { setvar dir = ""$ladir/$objdir"" setvar absdir = ""$abs_ladir/$objdir"" # Remove this search path later setvar notinst_path = ""$notinst_path $abs_ladir"" } } # $installed = yes func_stripname 'lib' '.la' $laname setvar name = "$func_stripname_result" # This library was specified with -dlpreopen. if test $pass = dlpreopen { if test -z $libdir && test $linkmode = prog { func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" } # Prefer using a static library (so that no silly _DYNAMIC symbols # are required to link). if test -n $old_library { setvar newdlprefiles = ""$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 && \ setvar dlpreconveniencelibs = ""$dlpreconveniencelibs $dir/$old_library"" # Otherwise, use the dlname, so that lt_dlopen finds it. } elif test -n $dlname { setvar newdlprefiles = ""$newdlprefiles $dir/$dlname"" } else { setvar newdlprefiles = ""$newdlprefiles $dir/$linklib"" } } # $pass = dlpreopen if test -z $libdir { # Link the convenience library if test $linkmode = lib { setvar deplibs = ""$dir/$old_library $deplibs"" } elif test "$linkmode,$pass" = "prog,link" { setvar compile_deplibs = ""$dir/$old_library $compile_deplibs"" setvar finalize_deplibs = ""$dir/$old_library $finalize_deplibs"" } else { setvar deplibs = ""$lib $deplibs"" # used for prog,scan pass } continue } if test $linkmode = prog && test $pass != link { setvar newlib_search_path = ""$newlib_search_path $ladir"" setvar deplibs = ""$lib $deplibs"" setvar linkalldeplibs = 'no' if test $link_all_deplibs != no || test -z $library_names || test $build_libtool_libs = no { setvar linkalldeplibs = 'yes' } setvar tmp_libs = '' for deplib in $dependency_libs { case (deplib) { -L* { func_stripname '-L' '' $deplib setvar newlib_search_path = ""$newlib_search_path $func_stripname_result"" } } # Need to link against all dependency_libs? if test $linkalldeplibs = yes { setvar deplibs = ""$deplib $deplibs"" } else { # Need to hardcode shared library paths # or/and link against static libraries setvar newdependency_libs = ""$deplib $newdependency_libs"" } if $opt_duplicate_deps { case{ *" $deplib "* { setvar specialdeplibs = ""$specialdeplibs $deplib"" } } } setvar tmp_libs = ""$tmp_libs $deplib"" } # for deplib continue } # $linkmode = prog... if test "$linkmode,$pass" = "prog,link" { if test -n $library_names && do { do { test $prefer_static_libs = no || test "$prefer_static_libs,$installed" = "built,yes"; } || 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. case{ *"$absdir:"* { } * { setvar temp_rpath = ""$temp_rpath$absdir:"" } } } # Hardcode the library path. # Skip directories that are in the system default run-time # search path. case{ *" $absdir "* { } * { case{ *" $absdir "* { } * { setvar compile_rpath = ""$compile_rpath $absdir"" } } } } case{ *" $libdir "* { } * { case{ *" $libdir "* { } * { setvar finalize_rpath = ""$finalize_rpath $libdir"" } } } } } # $linkmode,$pass = prog,link... if test $alldeplibs = yes && do { test $deplibs_check_method = pass_all || do { test $build_libtool_libs = yes && test -n $library_names; }; } { # We only need to search for static libraries continue } } setvar link_static = 'no' # Whether the deplib will be linked statically setvar use_static_libs = "$prefer_static_libs" if test $use_static_libs = built && test $installed = yes { setvar use_static_libs = 'no' } if test -n $library_names && do { test $use_static_libs = no || test -z $old_library; } { case (host) { *cygwin* | *mingw* | *cegcc* { # No point in relinking DLLs because paths are not encoded setvar notinst_deplibs = ""$notinst_deplibs $lib"" setvar need_relink = 'no' } * { if test $installed = no { setvar notinst_deplibs = ""$notinst_deplibs $lib"" setvar 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! setvar dlopenmodule = """" for dlpremoduletest in $dlprefiles { if test "X$dlpremoduletest" = "X$lib" { setvar dlopenmodule = "$dlpremoduletest" break } } if test -z $dlopenmodule && test $shouldnotlink = yes && test $pass = link { echo if test $linkmode = prog { $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 $linkmode = lib && test $hardcode_into_libs = yes { # Hardcode the library path. # Skip directories that are in the system default run-time # search path. case{ *" $absdir "* { } * { case{ *" $absdir "* { } * { setvar compile_rpath = ""$compile_rpath $absdir"" } } } } case{ *" $libdir "* { } * { case{ *" $libdir "* { } * { setvar finalize_rpath = ""$finalize_rpath $libdir"" } } } } } if test -n $old_archive_from_expsyms_cmds { # figure out the soname set dummy $library_names shift setvar realname = "$1" shift eval "libname=\"$libname_spec\"" # use dlname if we got it. it's perfectly good, no? if test -n $dlname { setvar soname = "$dlname" } elif test -n $soname_spec { # bleh windows case (host) { *cygwin* | mingw* | *cegcc* { func_arith $current - $age setvar major = "$func_arith_result" setvar versuffix = ""-$major"" } } eval "soname=\"$soname_spec\"" } else { setvar soname = "$realname" } # Make a new name for the extract_expsyms_cmds to use setvar soroot = "$soname" func_basename $soroot setvar soname = "$func_basename_result" func_stripname 'lib' '.dll' $soname setvar 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 setvar dir = "$output_objdir" setvar linklib = "$newlib" } # test -n "$old_archive_from_expsyms_cmds" if test $linkmode = prog || test $mode != relink { setvar add_shlibpath = '' setvar add_dir = '' setvar add = '' setvar lib_linked = 'yes' case (hardcode_action) { immediate | unsupported { if test $hardcode_direct = no { setvar add = ""$dir/$linklib"" case (host) { *-*-sco3.2v5.0.[024]* { setvar add_dir = ""-L$dir"" } *-*-sysv4*uw2* { setvar add_dir = ""-L$dir"" } *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ *-*-unixware7* { setvar add_dir = ""-L$dir"" } *-*-darwin* { # if the lib is a (non-dlopened) module then we can not # 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 { setvar add = ""$dir/$old_library"" } } elif test -n $old_library { setvar add = ""$dir/$old_library"" } } } } } elif test $hardcode_minus_L = no { case (host) { *-*-sunos* { setvar add_shlibpath = "$dir" } } setvar add_dir = ""-L$dir"" setvar add = ""-l$name"" } elif test $hardcode_shlibpath_var = no { setvar add_shlibpath = "$dir" setvar add = ""-l$name"" } else { setvar lib_linked = 'no' } } relink { if test $hardcode_direct = yes && test $hardcode_direct_absolute = no { setvar add = ""$dir/$linklib"" } elif test $hardcode_minus_L = yes { setvar add_dir = ""-L$absdir"" # Try looking first in the location we're being installed to. if test -n $inst_prefix_dir { case (libdir) { [\\/]* { setvar add_dir = ""$add_dir -L$inst_prefix_dir$libdir"" } } } setvar add = ""-l$name"" } elif test $hardcode_shlibpath_var = yes { setvar add_shlibpath = "$dir" setvar add = ""-l$name"" } else { setvar lib_linked = 'no' } } * { setvar lib_linked = 'no' } } if test $lib_linked != yes { func_fatal_configuration "unsupported hardcode properties" } if test -n $add_shlibpath { case{ *":$add_shlibpath:"* { } * { setvar compile_shlibpath = ""$compile_shlibpath$add_shlibpath:"" } } } if test $linkmode = prog { test -n $add_dir && setvar compile_deplibs = ""$add_dir $compile_deplibs"" test -n $add && setvar compile_deplibs = ""$add $compile_deplibs"" } else { test -n $add_dir && setvar deplibs = ""$add_dir $deplibs"" test -n $add && setvar deplibs = ""$add $deplibs"" if test $hardcode_direct != yes && test $hardcode_minus_L != yes && test $hardcode_shlibpath_var = yes { case{ *":$libdir:"* { } * { setvar finalize_shlibpath = ""$finalize_shlibpath$libdir:"" } } } } } if test $linkmode = prog || test $mode = relink { setvar add_shlibpath = '' setvar add_dir = '' setvar add = '' # Finalize command for both is simple: just hardcode it. if test $hardcode_direct = yes && test $hardcode_direct_absolute = no { setvar add = ""$libdir/$linklib"" } elif test $hardcode_minus_L = yes { setvar add_dir = ""-L$libdir"" setvar add = ""-l$name"" } elif test $hardcode_shlibpath_var = yes { case{ *":$libdir:"* { } * { setvar finalize_shlibpath = ""$finalize_shlibpath$libdir:"" } } setvar add = ""-l$name"" } elif test $hardcode_automatic = yes { if test -n $inst_prefix_dir && test -f "$inst_prefix_dir$libdir/$linklib" { setvar add = ""$inst_prefix_dir$libdir/$linklib"" } else { setvar add = ""$libdir/$linklib"" } } else { # We cannot seem to hardcode it, guess we'll fake it. setvar add_dir = ""-L$libdir"" # Try looking first in the location we're being installed to. if test -n $inst_prefix_dir { case (libdir) { [\\/]* { setvar add_dir = ""$add_dir -L$inst_prefix_dir$libdir"" } } } setvar add = ""-l$name"" } if test $linkmode = prog { test -n $add_dir && setvar finalize_deplibs = ""$add_dir $finalize_deplibs"" test -n $add && setvar finalize_deplibs = ""$add $finalize_deplibs"" } else { test -n $add_dir && setvar deplibs = ""$add_dir $deplibs"" test -n $add && setvar deplibs = ""$add $deplibs"" } } } elif test $linkmode = prog { # 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 $hardcode_direct != unsupported { test -n $old_library && setvar linklib = "$old_library" setvar compile_deplibs = ""$dir/$linklib $compile_deplibs"" setvar finalize_deplibs = ""$dir/$linklib $finalize_deplibs"" } else { setvar compile_deplibs = ""-l$name -L$dir $compile_deplibs"" setvar finalize_deplibs = ""-l$name -L$dir $finalize_deplibs"" } } elif test $build_libtool_libs = yes { # Not a shared library if test $deplibs_check_method != pass_all { # 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 can not 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 $module = yes { 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 $build_old_libs = no { setvar build_libtool_libs = 'module' setvar build_old_libs = 'yes' } else { setvar build_libtool_libs = 'no' } } } else { setvar deplibs = ""$dir/$old_library $deplibs"" setvar link_static = 'yes' } } # link shared/static library? if test $linkmode = lib { if test -n $dependency_libs && do { test $hardcode_into_libs != yes || test $build_old_libs = yes || test $link_static = yes; } { # Extract -R from dependency_libs setvar temp_deplibs = '' for libdir in $dependency_libs { case (libdir) { -R* { func_stripname '-R' '' $libdir setvar temp_xrpath = "$func_stripname_result" case{ *" $temp_xrpath "* { } * { setvar xrpath = ""$xrpath $temp_xrpath""} }} * { setvar temp_deplibs = ""$temp_deplibs $libdir""} } } setvar dependency_libs = "$temp_deplibs" } setvar newlib_search_path = ""$newlib_search_path $absdir"" # Link against this library test $link_static = no && setvar newdependency_libs = ""$abs_ladir/$laname $newdependency_libs"" # ... and its dependency_libs setvar tmp_libs = '' for deplib in $dependency_libs { setvar newdependency_libs = ""$deplib $newdependency_libs"" if $opt_duplicate_deps { case{ *" $deplib "* { setvar specialdeplibs = ""$specialdeplibs $deplib"" } } } setvar tmp_libs = ""$tmp_libs $deplib"" } if test $link_all_deplibs != no { # Add the search paths of all dependency libraries for deplib in $dependency_libs { setvar path = '' case (deplib) { -L* { setvar path = "$deplib" } *.la { func_dirname $deplib "" "." setvar dir = "$func_dirname_result" # We need an absolute path. case (dir) { [\\/]* | [A-Za-z]:[\\/]* { setvar absdir = "$dir" } * { setvar absdir = $(cd $dir && pwd) if test -z $absdir { func_warning "cannot determine absolute directory name of \`$dir'" setvar absdir = "$dir" } } } if $GREP "^installed=no" $deplib > /dev/null { case (host) { *-*-darwin* { setvar depdepl = '' setvar deplibrary_names = $(${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib) if test -n $deplibrary_names { for tmp in $deplibrary_names { setvar depdepl = "$tmp" } if test -f "$absdir/$objdir/$depdepl" { setvar depdepl = ""$absdir/$objdir/$depdepl"" setvar darwin_install_name = $(${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}) if test -z $darwin_install_name { setvar darwin_install_name = $(${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}) } setvar compiler_flags = ""$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"" setvar linker_flags = ""$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"" setvar path = '' } } } * { setvar path = ""-L$absdir/$objdir"" } } } else { setvar 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" setvar path = ""-L$absdir"" } } } case{ *" $path "* { } * { setvar deplibs = ""$path $deplibs"" } } } } # link_all_deplibs != no } # linkmode = lib } # for deplib in $libs if test $pass = link { if test $linkmode = "prog" { setvar compile_deplibs = ""$new_inherited_linker_flags $compile_deplibs"" setvar finalize_deplibs = ""$new_inherited_linker_flags $finalize_deplibs"" } else { setvar compiler_flags = ""$compiler_flags "$($ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g)" } } setvar dependency_libs = "$newdependency_libs" if test $pass = dlpreopen { # Link the dlpreopened libraries before other libraries for deplib in $save_deplibs { setvar deplibs = ""$deplib $deplibs"" } } if test $pass != dlopen { if test $pass != conv { # Make sure lib_search_path contains only unique directories. setvar lib_search_path = '' for dir in $newlib_search_path { case{ *" $dir "* { } * { setvar lib_search_path = ""$lib_search_path $dir"" } } } setvar newlib_search_path = '' } if test "$linkmode,$pass" != "prog,link" { setvar vars = ""deplibs"" } else { setvar vars = ""compile_deplibs finalize_deplibs"" } for var in $vars dependency_libs { # Add libraries to $var in reverse order eval tmp_libs='$'$var setvar 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: case (deplib) { -L* { setvar new_libs = ""$deplib $new_libs"" } -R* { } * { # 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. case{ *" $deplib "* { setvar new_libs = ""$deplib $new_libs"" } * { case{ *" $deplib "* { } * { setvar new_libs = ""$deplib $new_libs"" } } } } } } } setvar tmp_libs = '' for deplib in $new_libs { case (deplib) { -L* { case{ *" $deplib "* { } * { setvar tmp_libs = ""$tmp_libs $deplib"" } } } * { setvar tmp_libs = ""$tmp_libs $deplib"" } } } eval $var='$'tmp_libs } # for var } # Last step: remove runtime libs from dependency_libs # (they stay in deplibs) setvar tmp_libs = '' for i in $dependency_libs { case{ *" $i "* { setvar i = """" } } if test -n $i { setvar tmp_libs = ""$tmp_libs $i"" } } setvar dependency_libs = "$tmp_libs" } # for pass if test $linkmode = prog { setvar dlfiles = "$newdlfiles" } if test $linkmode = prog || test $linkmode = lib { setvar dlprefiles = "$newdlprefiles" } case (linkmode) { oldlib { if test -n "$dlfiles$dlprefiles" || test $dlself != no { func_warning "\`-dlopen' is ignored for archives" } case{ *\ -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. setvar build_libtool_libs = 'no' setvar oldlibs = "$output" setvar objs = ""$objs$old_deplibs"" } lib { # Make sure we only generate libraries of the form `libNAME.la'. case (outputname) { lib* { func_stripname 'lib' '.la' $outputname setvar name = "$func_stripname_result" eval "shared_ext=\"$shrext_cmds\"" eval "libname=\"$libname_spec\"" } * { test $module = no && \ func_fatal_help "libtool library \`$output' must begin with \`lib'" if test $need_lib_prefix != no { # Add the "lib" prefix for modules if required func_stripname '' '.la' $outputname setvar name = "$func_stripname_result" eval "shared_ext=\"$shrext_cmds\"" eval "libname=\"$libname_spec\"" } else { func_stripname '' '.la' $outputname setvar libname = "$func_stripname_result" } } } if test -n $objs { if test $deplibs_check_method != pass_all { 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!" setvar libobjs = ""$libobjs $objs"" } } test $dlself != no && \ func_warning "\`-dlopen self' is ignored for libtool libraries" set dummy $rpath shift test "$Argc" -gt 1 && \ func_warning "ignoring multiple \`-rpath's for a libtool library" setvar install_libdir = "$1" setvar oldlibs = '' if test -z $rpath { if test $build_libtool_libs = yes { # 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. setvar oldlibs = ""$output_objdir/$libname.$libext $oldlibs"" setvar build_libtool_libs = 'convenience' setvar 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. setvar save_ifs = "$IFS"; setvar IFS = '':'' set dummy $vinfo 0 0 0 shift setvar 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 case (vinfo_number) { yes { setvar number_major = "$1" setvar number_minor = "$2" setvar 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 # which has an extra 1 added just for fun # case (version_type) { darwin|linux|osf|windows|none { func_arith $number_major + $number_minor setvar current = "$func_arith_result" setvar age = "$number_minor" setvar revision = "$number_revision" } freebsd-aout|freebsd-elf|qnx|sunos { setvar current = "$number_major" setvar revision = "$number_minor" setvar age = ""0"" } irix|nonstopux { func_arith $number_major + $number_minor setvar current = "$func_arith_result" setvar age = "$number_minor" setvar revision = "$number_minor" setvar lt_irix_increment = 'no' } } } no { setvar current = "$1" setvar revision = "$2" setvar age = "$3" } } # Check that each of the things are valid numbers. case (current) { 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] { } * { func_error "CURRENT \`$current' must be a nonnegative integer" func_fatal_error "\`$vinfo' is not valid version information" } } case (revision) { 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] { } * { func_error "REVISION \`$revision' must be a nonnegative integer" func_fatal_error "\`$vinfo' is not valid version information" } } case (age) { 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] { } * { 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. setvar major = '' setvar versuffix = '' setvar verstring = '' case (version_type) { none { } darwin { # Like Linux, but with the current version available in # verstring for coding it into the library header func_arith $current - $age setvar major = ".$func_arith_result" setvar versuffix = ""$major.$age.$revision"" # Darwin ld doesn't like 0 for these options... func_arith $current + 1 setvar minor_current = "$func_arith_result" setvar xlcverstring = ""${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"" setvar verstring = ""-compatibility_version $minor_current -current_version $minor_current.$revision"" } freebsd-aout { setvar major = "".$current"" setvar versuffix = "".$current.$revision""; } freebsd-elf { setvar major = "".$current"" setvar versuffix = "".$current"" } irix | nonstopux { if test "X$lt_irix_increment" = "Xno" { func_arith $current - $age } else { func_arith $current - $age + 1 } setvar major = "$func_arith_result" case (version_type) { nonstopux { setvar verstring_prefix = 'nonstopux' } * { setvar verstring_prefix = 'sgi' } } setvar verstring = ""$verstring_prefix$major.$revision"" # Add in all the interfaces that we are compatible with. setvar loop = "$revision" while test $loop -ne 0 { func_arith $revision - $loop setvar iface = "$func_arith_result" func_arith $loop - 1 setvar loop = "$func_arith_result" setvar verstring = ""$verstring_prefix$major.$iface:$verstring"" } # Before this point, $major must not contain `.'. setvar major = ".$major" setvar versuffix = ""$major.$revision"" } linux { func_arith $current - $age setvar major = ".$func_arith_result" setvar versuffix = ""$major.$age.$revision"" } osf { func_arith $current - $age setvar major = ".$func_arith_result" setvar versuffix = "".$current.$age.$revision"" setvar verstring = ""$current.$age.$revision"" # Add in all the interfaces that we are compatible with. setvar loop = "$age" while test $loop -ne 0 { func_arith $current - $loop setvar iface = "$func_arith_result" func_arith $loop - 1 setvar loop = "$func_arith_result" setvar verstring = ""$verstring:${iface}.0"" } # Make executables depend on our current version. setvar verstring = ""$verstring:${current}.0"" } qnx { setvar major = "".$current"" setvar versuffix = "".$current"" } sunos { setvar major = "".$current"" setvar versuffix = "".$current.$revision"" } windows { # Use '-' rather than '.', since we only want one # extension on DOS 8.3 filesystems. func_arith $current - $age setvar major = "$func_arith_result" setvar versuffix = ""-$major"" } * { 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 { setvar major = '' case (version_type) { darwin { # we can't check for "0.0" in archive_cmds due to quoting # problems, so we reset it completely setvar verstring = '' } * { setvar verstring = ""0.0"" } } if test $need_version = no { setvar versuffix = '' } else { setvar versuffix = "".0.0"" } } # Remove version info from name if versioning should be avoided if test $avoid_version = yes && test $need_version = no { setvar major = '' setvar versuffix = '' setvar verstring = """" } # Check to see if the archive will have undefined symbols. if test $allow_undefined = yes { if test $allow_undefined_flag = unsupported { func_warning "undefined symbols not allowed in $host shared libraries" setvar build_libtool_libs = 'no' setvar build_old_libs = 'yes' } } else { # Don't allow undefined symbols. setvar allow_undefined_flag = "$no_undefined_flag" } } func_generate_dlsyms $libname $libname "yes" setvar libobjs = ""$libobjs $symfileobj"" test "X$libobjs" = "X " && setvar libobjs = '' if test $mode != relink { # Remove our outputs, but don't remove object files since they # may have been created when compiling PIC objects. setvar removelist = '' setvar tempremovelist = $($ECHO "$output_objdir/*) for p in $tempremovelist { case (p) { *.$objext | *.gcno { } $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.* { if test "X$precious_files_regex" != "X" { if $ECHO $p | $EGREP -e $precious_files_regex >/dev/null 2>&1 { continue } } setvar removelist = ""$removelist $p"" } * { } } } test -n $removelist && \ func_show_eval "${RM}r \$removelist" } # Now set the variables for building old libraries. if test $build_old_libs = yes && test $build_libtool_libs != convenience { setvar oldlibs = ""$oldlibs $output_objdir/$libname.$libext"" # Transform .lo files to .o files. setvar 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. setvar temp_xrpath = '' for libdir in $xrpath { setvar temp_xrpath = ""$temp_xrpath -R$libdir"" case{ *" $libdir "* { } * { setvar finalize_rpath = ""$finalize_rpath $libdir"" } } } if test $hardcode_into_libs != yes || test $build_old_libs = yes { setvar dependency_libs = ""$temp_xrpath $dependency_libs"" } } # Make sure dlfiles contains only unique files that won't be dlpreopened setvar old_dlfiles = "$dlfiles" setvar dlfiles = '' for lib in $old_dlfiles { case{ *" $lib "* { } * { setvar dlfiles = ""$dlfiles $lib"" } } } # Make sure dlprefiles contains only unique files setvar old_dlprefiles = "$dlprefiles" setvar dlprefiles = '' for lib in $old_dlprefiles { case{ *" $lib "* { } * { setvar dlprefiles = ""$dlprefiles $lib"" } } } if test $build_libtool_libs = yes { if test -n $rpath { case (host) { *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku* { # these systems don't actually have a c library (as such)! } *-*-rhapsody* | *-*-darwin1.[012] { # Rhapsody C library is in the System framework setvar deplibs = ""$deplibs System.ltframework"" } *-*-netbsd* { # Don't link with libc until the a.out ld.so is fixed. } *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* { # Do not include libc due to us having libc/libc_r. } *-*-sco3.2v5* | *-*-sco5v6* { # Causes problems with __ctype } *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX* { # Compiler inserts libc in the correct place for threads to work } * { # Add libc to deplibs on all other systems if necessary. if test $build_libtool_need_lc = "yes" { setvar deplibs = ""$deplibs -lc"" } } } } # Transform deplibs into only deplibs that can be linked in shared. setvar name_save = "$name" setvar libname_save = "$libname" setvar release_save = "$release" setvar versuffix_save = "$versuffix" setvar 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? setvar release = """" setvar versuffix = """" setvar major = """" setvar newdeplibs = '' setvar droppeddeps = 'no' case (deplibs_check_method) { 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. setvar newdeplibs = "$deplibs" } 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 { setvar ldd_output = $(ldd conftest) for i in $deplibs { case (i) { -l* { func_stripname -l '' $i setvar name = "$func_stripname_result" if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { case{ *" $i "* { setvar newdeplibs = ""$newdeplibs $i"" setvar i = """" } } } if test -n $i { eval "libname=\"$libname_spec\"" eval "deplib_matches=\"$library_names_spec\"" set dummy $deplib_matches; shift setvar deplib_match = "$1" if test $(expr $ldd_output : ".*$deplib_match) -ne 0 { setvar newdeplibs = ""$newdeplibs $i"" } else { setvar 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." } } } * { setvar newdeplibs = ""$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 { case (i) { -l* { func_stripname -l '' $i setvar name = "$func_stripname_result" $opt_dry_run || $RM conftest if $LTCC $LTCFLAGS -o conftest conftest.c $i { setvar ldd_output = $(ldd conftest) if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { case{ *" $i "* { setvar newdeplibs = ""$newdeplibs $i"" setvar i = """" } } } if test -n $i { eval "libname=\"$libname_spec\"" eval "deplib_matches=\"$library_names_spec\"" set dummy $deplib_matches; shift setvar deplib_match = "$1" if test $(expr $ldd_output : ".*$deplib_match) -ne 0 { setvar newdeplibs = ""$newdeplibs $i"" } else { setvar 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 { setvar 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." } } * { setvar newdeplibs = ""$newdeplibs $i"" } } } } } file_magic* { set dummy $deplibs_check_method; shift setvar file_magic_regex = $(expr $deplibs_check_method : "$1 \(.*\)) for a_deplib in $deplibs { case (a_deplib) { -l* { func_stripname -l '' $a_deplib setvar name = "$func_stripname_result" if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { case{ *" $a_deplib "* { setvar newdeplibs = ""$newdeplibs $a_deplib"" setvar a_deplib = """" } } } if test -n $a_deplib { eval "libname=\"$libname_spec\"" for i in $lib_search_path $sys_lib_search_path $shlib_search_path { setvar potential_libs = $(ls $i/$libname[.-]* ) 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? setvar potlib = "$potent_lib" while test -h $potlib { setvar potliblink = $(ls -ld $potlib | ${SED} 's/.* -> //) case (potliblink) { [\\/]* | [A-Za-z]:[\\/]* { setvar potlib = "$potliblink"} * { setvar potlib = "$($ECHO $potlib | $SED 's,[^/]*$,,)"$potliblink""} } } if eval "$file_magic_cmd \"\$potlib\"" 2>/dev/null | $SED -e 10q | $EGREP $file_magic_regex > /dev/null { setvar newdeplibs = ""$newdeplibs $a_deplib"" setvar a_deplib = """" break 2 } } } } if test -n $a_deplib { setvar 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" } } } * { # Add a -L argument. setvar newdeplibs = ""$newdeplibs $a_deplib"" } } } # Gone through all deplibs. } match_pattern* { set dummy $deplibs_check_method; shift setvar match_pattern_regex = $(expr $deplibs_check_method : "$1 \(.*\)) for a_deplib in $deplibs { case (a_deplib) { -l* { func_stripname -l '' $a_deplib setvar name = "$func_stripname_result" if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { case{ *" $a_deplib "* { setvar newdeplibs = ""$newdeplibs $a_deplib"" setvar a_deplib = """" } } } if test -n $a_deplib { eval "libname=\"$libname_spec\"" for i in $lib_search_path $sys_lib_search_path $shlib_search_path { setvar potential_libs = $(ls $i/$libname[.-]* ) for potent_lib in $potential_libs { setvar 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 { setvar newdeplibs = ""$newdeplibs $a_deplib"" setvar a_deplib = """" break 2 } } } } if test -n $a_deplib { setvar 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" } } } * { # Add a -L argument. setvar newdeplibs = ""$newdeplibs $a_deplib"" } } } # Gone through all deplibs. } none | unknown | * { setvar newdeplibs = """" setvar tmp_deplibs = $($ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g) if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" { for i in $predeps $postdeps { # can't use Xsed below, because $i might contain '/' setvar tmp_deplibs = $($ECHO " $tmp_deplibs" | $SED "s,$i,,) } } case (tmp_deplibs) { *[!\ \ ]* { echo if test "X$deplibs_check_method" = "Xnone" { 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." setvar droppeddeps = 'yes' } } } } setvar versuffix = "$versuffix_save" setvar major = "$major_save" setvar release = "$release_save" setvar libname = "$libname_save" setvar name = "$name_save" case (host) { *-*-rhapsody* | *-*-darwin1.[012] { # On Rhapsody replace the C library with the System framework setvar newdeplibs = $($ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /) } } if test $droppeddeps = yes { if test $module = yes { 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 $build_old_libs = no { setvar oldlibs = ""$output_objdir/$libname.$libext"" setvar build_libtool_libs = 'module' setvar build_old_libs = 'yes' } else { setvar 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 $allow_undefined = no { 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 $build_old_libs = no { setvar oldlibs = ""$output_objdir/$libname.$libext"" setvar build_libtool_libs = 'module' setvar build_old_libs = 'yes' } else { setvar build_libtool_libs = 'no' } } } } # Done checking deplibs! setvar deplibs = "$newdeplibs" } # Time to change all our "foo.ltframework" stuff back to "-framework foo" case (host) { *-*-darwin* { setvar newdeplibs = $($ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g) setvar new_inherited_linker_flags = $($ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g) setvar 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 setvar new_libs = '' for path in $notinst_path { case{ *" -L$path/$objdir "* { } * { case{ *" -L$path/$objdir "* { setvar new_libs = ""$new_libs -L$path/$objdir"" } } } } } for deplib in $deplibs { case (deplib) { -L* { case{ *" $deplib "* { } * { setvar new_libs = ""$new_libs $deplib"" } } } * { setvar new_libs = ""$new_libs $deplib"" } } } setvar deplibs = "$new_libs" # All the library-specific variables (install_libdir is set above). setvar library_names = '' setvar old_library = '' setvar dlname = '' # Test again, we may have decided not to build it any more if test $build_libtool_libs = yes { if test $hardcode_into_libs = yes { # Hardcode the library paths setvar hardcode_libdirs = '' setvar dep_rpath = '' setvar rpath = "$finalize_rpath" test $mode != relink && setvar rpath = ""$compile_rpath$rpath"" for libdir in $rpath { if test -n $hardcode_libdir_flag_spec { if test -n $hardcode_libdir_separator { if test -z $hardcode_libdirs { setvar hardcode_libdirs = "$libdir" } else { # Just accumulate the unique libdirs. case (hardcode_libdir_separator) { *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* { } * { setvar hardcode_libdirs = ""$hardcode_libdirs$hardcode_libdir_separator$libdir"" } } } } else { eval "flag=\"$hardcode_libdir_flag_spec\"" setvar dep_rpath = ""$dep_rpath $flag"" } } elif test -n $runpath_var { case{ *" $libdir "* { } * { setvar perm_rpath = ""$perm_rpath $libdir"" } } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setvar libdir = "$hardcode_libdirs" if test -n $hardcode_libdir_flag_spec_ld { eval "dep_rpath=\"$hardcode_libdir_flag_spec_ld\"" } else { eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" } } if test -n $runpath_var && test -n $perm_rpath { # We should set the runpath_var. setvar rpath = '' for dir in $perm_rpath { setvar rpath = ""$rpath$dir:"" } eval $runpath_var='$'rpath'$'$runpath_var export $runpath_var } test -n $dep_rpath && setvar deplibs = ""$dep_rpath $deplibs"" } setvar shlibpath = "$finalize_shlibpath" test $mode != relink && setvar 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 setvar realname = "$1" shift if test -n $soname_spec { eval "soname=\"$soname_spec\"" } else { setvar soname = "$realname" } if test -z $dlname { setvar dlname = "$soname" } setvar lib = ""$output_objdir/$realname"" setvar linknames = ''for link in @ARGV { setvar linknames = ""$linknames $link"" } # Use standard objects if they are pic test -z $pic_flag && setvar libobjs = $($ECHO $libobjs | $SP2NL | $SED $lo2o | $NL2SP) test "X$libobjs" = "X " && setvar libobjs = '' setvar delfiles = '' if test -n $export_symbols && test -n $include_expsyms { $opt_dry_run || cp $export_symbols "$output_objdir/$libname.uexp" setvar export_symbols = ""$output_objdir/$libname.uexp"" setvar delfiles = ""$delfiles $export_symbols"" } setvar orig_export_symbols = '' case (host_os) { cygwin* | mingw* | cegcc* { if test -n $export_symbols && test -z $export_symbols_regex { # exporting using user supplied symfile if test "x$($SED 1q $export_symbols)" != xEXPORTS { # 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. setvar orig_export_symbols = "$export_symbols" setvar export_symbols = '' setvar always_export_symbols = 'yes' } } } } # Prepare the list of exported symbols if test -z $export_symbols { if test $always_export_symbols = yes || test -n $export_symbols_regex { func_verbose "generating symbol list for \`$libname.la'" setvar export_symbols = ""$output_objdir/$libname.exp"" $opt_dry_run || $RM $export_symbols setvar cmds = "$export_symbols_cmds" setvar save_ifs = "$IFS"; setvar IFS = ''~'' for cmd in $cmds { setvar IFS = "$save_ifs" eval "cmd=\"$cmd\"" func_len " $cmd" setvar len = "$func_len_result" if test $len -lt $max_cmd_len || test $max_cmd_len -le -1 { func_show_eval $cmd 'exit $?' setvar skipped_export = 'false' } else { # The command line is too long to execute in one step. func_verbose "using reloadable object file for export list..." setvar skipped_export = ':' # Break out early, otherwise skipped_export may be # set to false by a later but shorter cmd. break } } setvar IFS = "$save_ifs" if test -n $export_symbols_regex && test "X$skipped_export" != "X:" { 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 { setvar tmp_export_symbols = "$export_symbols" test -n $orig_export_symbols && setvar tmp_export_symbols = "$orig_export_symbols" $opt_dry_run || $ECHO $include_expsyms | $SP2NL >> "$tmp_export_symbols" } if test "X$skipped_export" != "X:" && 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 setvar delfiles = ""$delfiles $export_symbols $output_objdir/$libname.filter"" setvar export_symbols = "$output_objdir/$libname.def" $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols } setvar tmp_deplibs = '' for test_deplib in $deplibs { case{ *" $test_deplib "* { } * { setvar tmp_deplibs = ""$tmp_deplibs $test_deplib"" } } } setvar deplibs = "$tmp_deplibs" if test -n $convenience { if test -n $whole_archive_flag_spec && test $compiler_needs_object = yes && test -z $libobjs { # extract the archives, so we have objects to list. # TODO: could optimize this to just extract one archive. setvar whole_archive_flag_spec = '' } if test -n $whole_archive_flag_spec { setvar save_libobjs = "$libobjs" eval "libobjs=\"\$libobjs $whole_archive_flag_spec\"" test "X$libobjs" = "X " && setvar libobjs = '' } else { setvar gentop = ""$output_objdir/${outputname}x"" setvar generated = ""$generated $gentop"" func_extract_archives $gentop $convenience setvar libobjs = ""$libobjs $func_extract_archives_result"" test "X$libobjs" = "X " && setvar libobjs = '' } } if test $thread_safe = yes && test -n $thread_safe_flag_spec { eval "flag=\"$thread_safe_flag_spec\"" setvar linker_flags = ""$linker_flags $flag"" } # Make a backup of the uninstalled library when relinking if test $mode = relink { $opt_dry_run || shell {cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U} || exit $? } # Do each of the archive commands. if test $module = yes && test -n $module_cmds { if test -n $export_symbols && test -n $module_expsym_cmds { eval "test_cmds=\"$module_expsym_cmds\"" setvar cmds = "$module_expsym_cmds" } else { eval "test_cmds=\"$module_cmds\"" setvar cmds = "$module_cmds" } } else { if test -n $export_symbols && test -n $archive_expsym_cmds { eval "test_cmds=\"$archive_expsym_cmds\"" setvar cmds = "$archive_expsym_cmds" } else { eval "test_cmds=\"$archive_cmds\"" setvar cmds = "$archive_cmds" } } if test "X$skipped_export" != "X:" && func_len " $test_cmds" && setvar 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 { setvar save_libobjs = "$libobjs" } setvar save_output = "$output" func_basename $output setvar output_la = "$func_basename_result" # Clear the reloadable object creation command queue and # initialize k to one. setvar test_cmds = '' setvar concat_cmds = '' setvar objlist = '' setvar last_robj = '' setvar k = '1' if test -n $save_libobjs && test "X$skipped_export" != "X:" && test $with_gnu_ld = yes { setvar output = "${output_objdir}/${output_la}.lnkscript" func_verbose "creating GNU ld script: $output" echo 'INPUT (' > $output for obj in $save_libobjs { $ECHO $obj >> $output } echo ')' >> $output setvar delfiles = ""$delfiles $output"" } elif test -n $save_libobjs && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X { setvar output = "${output_objdir}/${output_la}.lnk" func_verbose "creating linker input file list: $output" : > $output set x $save_libobjs shift setvar firstobj = '' if test $compiler_needs_object = yes { setvar firstobj = ""$1 "" shift }for obj in @ARGV { $ECHO $obj >> $output } setvar delfiles = ""$delfiles $output"" setvar output = "$firstobj'"'$file_list_spec$output'"'" } else { if test -n $save_libobjs { func_verbose "creating reloadable object files..." setvar output = "$output_objdir/$output_la-${k}.$objext" eval "test_cmds=\"$reload_cmds\"" func_len " $test_cmds" setvar len0 = "$func_len_result" setvar 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 setvar len = "$func_arith_result" if test "X$objlist" = X || 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 $k -eq 1 { # The first file doesn't have a previous command to add. setvar reload_objs = "$objlist" eval "concat_cmds=\"$reload_cmds\"" } else { # All subsequent reloadable object files will link in # the last one created. setvar reload_objs = ""$objlist $last_robj"" eval "concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"" } setvar last_robj = "$output_objdir/$output_la-${k}.$objext" func_arith $k + 1 setvar k = "$func_arith_result" setvar output = "$output_objdir/$output_la-${k}.$objext" setvar objlist = "" $obj"" func_len " $last_robj" func_arith $len0 + $func_len_result setvar 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 || setvar concat_cmds = "$concat_cmds~" setvar 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\"" } setvar delfiles = ""$delfiles $output"" } else { setvar output = '' } if ${skipped_export-false} { func_verbose "generating symbol list for \`$libname.la'" setvar export_symbols = ""$output_objdir/$libname.exp"" $opt_dry_run || $RM $export_symbols setvar libobjs = "$output" # Append the command to create the export file. test -z $concat_cmds || setvar 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. setvar save_ifs = "$IFS"; setvar IFS = ''~'' for cmd in $concat_cmds { setvar IFS = "$save_ifs" $opt_silent || do { func_quote_for_expand $cmd eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval $cmd || do { setvar lt_exit = ""$? # Restore the uninstalled library and exit if test $mode = relink { shell { cd $output_objdir && \ $RM "${realname}T" && \ $MV "${realname}U" $realname } } exit $lt_exit } } setvar 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"' } } if ${skipped_export-false} { if test -n $export_symbols && test -n $include_expsyms { setvar tmp_export_symbols = "$export_symbols" test -n $orig_export_symbols && setvar tmp_export_symbols = "$orig_export_symbols" $opt_dry_run || $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 setvar delfiles = ""$delfiles $export_symbols $output_objdir/$libname.filter"" setvar export_symbols = "$output_objdir/$libname.def" $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols } } setvar libobjs = "$output" # Restore the value of output. setvar output = "$save_output" if test -n $convenience && test -n $whole_archive_flag_spec { eval "libobjs=\"\$libobjs $whole_archive_flag_spec\"" test "X$libobjs" = "X " && setvar libobjs = '' } # Expand the library linking commands again to reset the # value of $libobjs for piecewise linking. # Do each of the archive commands. if test $module = yes && test -n $module_cmds { if test -n $export_symbols && test -n $module_expsym_cmds { setvar cmds = "$module_expsym_cmds" } else { setvar cmds = "$module_cmds" } } else { if test -n $export_symbols && test -n $archive_expsym_cmds { setvar cmds = "$archive_expsym_cmds" } else { setvar 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 { setvar gentop = ""$output_objdir/${outputname}x"" setvar generated = ""$generated $gentop"" func_extract_archives $gentop $dlprefiles setvar libobjs = ""$libobjs $func_extract_archives_result"" test "X$libobjs" = "X " && setvar libobjs = '' } setvar save_ifs = "$IFS"; setvar IFS = ''~'' for cmd in $cmds { setvar IFS = "$save_ifs" eval "cmd=\"$cmd\"" $opt_silent || do { func_quote_for_expand $cmd eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || eval $cmd || do { setvar lt_exit = ""$? # Restore the uninstalled library and exit if test $mode = relink { shell { cd $output_objdir && \ $RM "${realname}T" && \ $MV "${realname}U" $realname } } exit $lt_exit } } setvar IFS = "$save_ifs" # Restore the uninstalled library and exit if test $mode = relink { $opt_dry_run || shell {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 $module = yes || test $export_dynamic = yes { # On all known operating systems, these are identical. setvar dlname = "$soname" } } } obj { if test -n "$dlfiles$dlprefiles" || test $dlself != no { func_warning "\`-dlopen' is ignored for objects" } case{ *\ -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" case (output) { *.lo { test -n "$objs$old_deplibs" && \ func_fatal_error "cannot build library object \`$output' from non-libtool objects" setvar libobj = "$output" func_lo2o $libobj setvar obj = "$func_lo2o_result" } * { setvar libobj = '' setvar 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. setvar reload_conv_objs = '' setvar gentop = '' # reload_cmds runs $LD directly, so let us get rid of # -Wl from whole_archive_flag_spec and hope we can get by with # turning comma into space.. setvar wl = '' if test -n $convenience { if test -n $whole_archive_flag_spec { eval "tmp_whole_archive_flags=\"$whole_archive_flag_spec\"" setvar reload_conv_objs = "$reload_objs' '$($ECHO $tmp_whole_archive_flags | $SED 's|,| |g)" } else { setvar gentop = ""$output_objdir/${obj}x"" setvar generated = ""$generated $gentop"" func_extract_archives $gentop $convenience setvar reload_conv_objs = ""$reload_objs $func_extract_archives_result"" } } # Create the old-style object. setvar reload_objs = ""$objs$old_deplibs "$($ECHO $libobjs | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP)" $reload_conv_objs"" ### testsuite: skip nested quoting test setvar 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 } if test $build_libtool_libs != yes { 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 || echo timestamp > $libobj || exit $? exit $EXIT_SUCCESS } if test -n $pic_flag || test $pic_mode != default { # Only do commands if we really have different PIC objects. setvar reload_objs = ""$libobjs $reload_conv_objs"" setvar output = "$libobj" func_execute_cmds $reload_cmds 'exit $?' } if test -n $gentop { func_show_eval '${RM}r "$gentop"' } exit $EXIT_SUCCESS } prog { case (host) { *cygwin* { func_stripname '' '.exe' $output setvar 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" test $preload = yes \ && test $dlopen_support = unknown \ && test $dlopen_self = unknown \ && test $dlopen_self_static = unknown && \ func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." case (host) { *-*-rhapsody* | *-*-darwin1.[012] { # On Rhapsody replace the C library is the System framework setvar compile_deplibs = $($ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /) setvar finalize_deplibs = $($ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /) } } case (host) { *-*-darwin* { # Don't allow lazy linking, it breaks C++ global constructors # But is supposedly fixed on 10.4 or later (yay!). if test $tagname = CXX { case{ 10.[0123] { setvar compile_command = ""$compile_command ${wl}-bind_at_load"" setvar finalize_command = ""$finalize_command ${wl}-bind_at_load"" } } } # Time to change all our "foo.ltframework" stuff back to "-framework foo" setvar compile_deplibs = $($ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g) setvar 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 setvar new_libs = '' for path in $notinst_path { case{ *" -L$path/$objdir "* { } * { case{ *" -L$path/$objdir "* { setvar new_libs = ""$new_libs -L$path/$objdir"" } } } } } for deplib in $compile_deplibs { case (deplib) { -L* { case{ *" $deplib "* { } * { setvar new_libs = ""$new_libs $deplib"" } } } * { setvar new_libs = ""$new_libs $deplib"" } } } setvar compile_deplibs = "$new_libs" setvar compile_command = ""$compile_command $compile_deplibs"" setvar finalize_command = ""$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. case{ *" $libdir "* { } * { setvar finalize_rpath = ""$finalize_rpath $libdir"" } } } } # Now hardcode the library paths setvar rpath = '' setvar 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 { setvar hardcode_libdirs = "$libdir" } else { # Just accumulate the unique libdirs. case (hardcode_libdir_separator) { *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* { } * { setvar hardcode_libdirs = ""$hardcode_libdirs$hardcode_libdir_separator$libdir"" } } } } else { eval "flag=\"$hardcode_libdir_flag_spec\"" setvar rpath = ""$rpath $flag"" } } elif test -n $runpath_var { case{ *" $libdir "* { } * { setvar perm_rpath = ""$perm_rpath $libdir"" } } } case (host) { *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc* { setvar testbindir = $(${ECHO} $libdir | ${SED} -e 's*/lib$*/bin*) case{ *":$libdir:"* { } :: { setvar dllsearchpath = "$libdir"} * { setvar dllsearchpath = ""$dllsearchpath:$libdir""} } case{ *":$testbindir:"* { } :: { setvar dllsearchpath = "$testbindir"} * { setvar dllsearchpath = ""$dllsearchpath:$testbindir""} } } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setvar libdir = "$hardcode_libdirs" eval "rpath=\" $hardcode_libdir_flag_spec\"" } setvar compile_rpath = "$rpath" setvar rpath = '' setvar 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 { setvar hardcode_libdirs = "$libdir" } else { # Just accumulate the unique libdirs. case (hardcode_libdir_separator) { *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"* { } * { setvar hardcode_libdirs = ""$hardcode_libdirs$hardcode_libdir_separator$libdir"" } } } } else { eval "flag=\"$hardcode_libdir_flag_spec\"" setvar rpath = ""$rpath $flag"" } } elif test -n $runpath_var { case{ *" $libdir "* { } * { setvar finalize_perm_rpath = ""$finalize_perm_rpath $libdir"" } } } } # Substitute the hardcoded libdirs into the rpath. if test -n $hardcode_libdir_separator && test -n $hardcode_libdirs { setvar libdir = "$hardcode_libdirs" eval "rpath=\" $hardcode_libdir_flag_spec\"" } setvar finalize_rpath = "$rpath" if test -n $libobjs && test $build_old_libs = yes { # Transform all the library objects into standard objects. setvar compile_command = $($ECHO $compile_command | $SP2NL | $SED $lo2o | $NL2SP) setvar finalize_command = $($ECHO $finalize_command | $SP2NL | $SED $lo2o | $NL2SP) } func_generate_dlsyms $outputname "@PROGRAM@" "no" # template prelinking step if test -n $prelink_cmds { func_execute_cmds $prelink_cmds 'exit $?' } setvar wrappers_required = 'yes' case (host) { *cegcc* | *mingw32ce* { # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. setvar wrappers_required = 'no' } *cygwin* | *mingw* { if test $build_libtool_libs != yes { setvar wrappers_required = 'no' } } * { if test $need_relink = no || test $build_libtool_libs != yes { setvar wrappers_required = 'no' } } } if test $wrappers_required = no { # Replace the output file specification. setvar compile_command = $($ECHO $compile_command | $SED 's%@OUTPUT@%'"$output"'%g) setvar link_command = ""$compile_command$compile_rpath"" # We have no uninstalled library dependencies, so finalize right now. setvar exit_status = '0' func_show_eval $link_command 'exit_status=$?' # 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" { setvar compile_command = ""$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"" } if test -n $finalize_shlibpath { setvar finalize_command = ""$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"" } setvar compile_var = '' setvar finalize_var = '' if test -n $runpath_var { if test -n $perm_rpath { # We should set the runpath_var. setvar rpath = '' for dir in $perm_rpath { setvar rpath = ""$rpath$dir:"" } setvar compile_var = ""$runpath_var=\"$rpath\$$runpath_var\" "" } if test -n $finalize_perm_rpath { # We should set the runpath_var. setvar rpath = '' for dir in $finalize_perm_rpath { setvar rpath = ""$rpath$dir:"" } setvar finalize_var = ""$runpath_var=\"$rpath\$$runpath_var\" "" } } if test $no_install = yes { # We don't need to create a wrapper script. setvar link_command = ""$compile_var$compile_command$compile_rpath"" # Replace the output file specification. setvar 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 $?' exit $EXIT_SUCCESS } if test $hardcode_action = relink { # Fast installation is not supported setvar link_command = ""$compile_var$compile_command$compile_rpath"" setvar 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" } else { if test $fast_install != no { setvar link_command = ""$finalize_var$compile_command$finalize_rpath"" if test $fast_install = yes { setvar relink_command = $($ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g) } else { # fast_install is set to needless setvar relink_command = '' } } else { setvar link_command = ""$compile_var$compile_command$compile_rpath"" setvar relink_command = ""$finalize_var$finalize_command$finalize_rpath"" } } # Replace the output file specification. setvar 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 $?' # 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}'"' { setvar relink_command = ""{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"" } elif eval var_value='$'$var; test -z $var_value; { setvar relink_command = ""$var=; export $var; $relink_command"" } else { func_quote_for_eval $var_value setvar relink_command = ""$var=$func_quote_for_eval_result; export $var; $relink_command"" } } setvar relink_command = ""(cd $(pwd); $relink_command)"" setvar 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. case (output) { *.exe { func_stripname '' '.exe' $output setvar output = "$func_stripname_result" } } # test for cygwin because mv fails w/o .exe extensions case (host) { *cygwin* { setvar exeext = '.exe' func_stripname '' '.exe' $outputname setvar outputname = "$func_stripname_result" } * { setvar exeext = '' } } case (host) { *cygwin* | *mingw* { func_dirname_and_basename $output "" "." setvar output_name = "$func_basename_result" setvar output_path = "$func_dirname_result" setvar cwrappersource = ""$output_path/$objdir/lt-$output_name.c"" setvar 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 } } } * { $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 { if test $build_libtool_libs = convenience { setvar oldobjs = ""$libobjs_save $symfileobj"" setvar addlibs = "$convenience" setvar build_libtool_libs = 'no' } else { if test $build_libtool_libs = module { setvar oldobjs = "$libobjs_save" setvar build_libtool_libs = 'no' } else { setvar oldobjs = ""$old_deplibs $non_pic_objects"" if test $preload = yes && test -f $symfileobj { setvar oldobjs = ""$oldobjs $symfileobj"" } } setvar addlibs = "$old_convenience" } if test -n $addlibs { setvar gentop = ""$output_objdir/${outputname}x"" setvar generated = ""$generated $gentop"" func_extract_archives $gentop $addlibs setvar oldobjs = ""$oldobjs $func_extract_archives_result"" } # Do each command in the archive commands. if test -n $old_archive_from_new_cmds && test $build_libtool_libs = yes { setvar cmds = "$old_archive_from_new_cmds" } else { # Add any objects from preloaded convenience libraries if test -n $dlprefiles { setvar gentop = ""$output_objdir/${outputname}x"" setvar generated = ""$generated $gentop"" func_extract_archives $gentop $dlprefiles setvar oldobjs = ""$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..." setvar gentop = ""$output_objdir/${outputname}x"" setvar generated = ""$generated $gentop"" func_mkdir_p $gentop setvar save_oldobjs = "$oldobjs" setvar oldobjs = '' setvar counter = '1' for obj in $save_oldobjs { func_basename $obj setvar objbase = "$func_basename_result" case{ " " { setvar oldobjs = "$obj" } *[\ /]"$objbase "* { while : { # Make sure we don't pick an alternate name that also # overlaps. setvar newobj = "lt$counter-$objbase" func_arith $counter + 1 setvar counter = "$func_arith_result" case{ *[\ /]"$newobj "* { } * { if test ! -f "$gentop/$newobj" { break; } } } } func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" setvar oldobjs = ""$oldobjs $gentop/$newobj"" } * { setvar oldobjs = ""$oldobjs $obj"" } } } } eval "cmds=\"$old_archive_cmds\"" func_len " $cmds" setvar len = "$func_len_result" if test $len -lt $max_cmd_len || test $max_cmd_len -le -1 { setvar 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..." setvar save_RANLIB = "$RANLIB" setvar RANLIB = ':' setvar objlist = '' setvar concat_cmds = '' setvar save_oldobjs = "$oldobjs" setvar oldobjs = '' # Is there a better way of finding the last object in the list? for obj in $save_oldobjs { setvar last_oldobj = "$obj" } eval "test_cmds=\"$old_archive_cmds\"" func_len " $test_cmds" setvar len0 = "$func_len_result" setvar len = "$len0" for obj in $save_oldobjs { func_len " $obj" func_arith $len + $func_len_result setvar 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 setvar oldobjs = "$objlist" if test $obj = $last_oldobj { setvar RANLIB = "$save_RANLIB" } test -z $concat_cmds || setvar concat_cmds = "$concat_cmds~" eval "concat_cmds=\"\${concat_cmds}$old_archive_cmds\"" setvar objlist = '' setvar len = "$len0" } } setvar RANLIB = "$save_RANLIB" setvar oldobjs = "$objlist" if test "X$oldobjs" = "X" { 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. case (output) { *.la { setvar old_library = '' test $build_old_libs = yes && setvar 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}'"' { setvar relink_command = ""{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"" } elif eval var_value='$'$var; test -z $var_value; { setvar relink_command = ""$var=; export $var; $relink_command"" } else { func_quote_for_eval $var_value setvar relink_command = ""$var=$func_quote_for_eval_result; export $var; $relink_command"" } } # Quote the link command for shipping. setvar relink_command = ""(cd $(pwd); $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"" setvar relink_command = $($ECHO $relink_command | $SED $sed_quote_subst) if test $hardcode_automatic = yes { setvar relink_command = '' } # Only create the output if not a dry run. $opt_dry_run || do { for installed in no yes { if test $installed = yes { if test -z $install_libdir { break } setvar output = ""$output_objdir/$outputname"i" # Replace all uninstalled libtool libraries with the installed ones setvar newdependency_libs = '' for deplib in $dependency_libs { case (deplib) { *.la { func_basename $deplib setvar name = "$func_basename_result" setvar libdir = $(${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib) test -z $libdir && \ func_fatal_error "\`$deplib' is not a valid libtool archive" setvar newdependency_libs = ""$newdependency_libs $libdir/$name"" } * { setvar newdependency_libs = ""$newdependency_libs $deplib"" } } } setvar dependency_libs = "$newdependency_libs" setvar newdlfiles = '' for lib in $dlfiles { case (lib) { *.la { func_basename $lib setvar name = "$func_basename_result" setvar libdir = $(${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib) test -z $libdir && \ func_fatal_error "\`$lib' is not a valid libtool archive" setvar newdlfiles = ""$newdlfiles $libdir/$name"" } * { setvar newdlfiles = ""$newdlfiles $lib"" } } } setvar dlfiles = "$newdlfiles" setvar newdlprefiles = '' for lib in $dlprefiles { case (lib) { *.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 setvar name = "$func_basename_result" setvar libdir = $(${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib) test -z $libdir && \ func_fatal_error "\`$lib' is not a valid libtool archive" setvar newdlprefiles = ""$newdlprefiles $libdir/$name"" } } } setvar dlprefiles = "$newdlprefiles" } else { setvar newdlfiles = '' for lib in $dlfiles { case (lib) { [\\/]* | [A-Za-z]:[\\/]* { setvar abs = "$lib" } * { setvar abs = "$(pwd)"/$lib"" } } setvar newdlfiles = ""$newdlfiles $abs"" } setvar dlfiles = "$newdlfiles" setvar newdlprefiles = '' for lib in $dlprefiles { case (lib) { [\\/]* | [A-Za-z]:[\\/]* { setvar abs = "$lib" } * { setvar abs = "$(pwd)"/$lib"" } } setvar newdlprefiles = ""$newdlprefiles $abs"" } setvar 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. setvar tdlname = "$dlname" case (host) { *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 "x$bindir" != x { func_relative_path $install_libdir $bindir setvar tdlname = "$func_relative_path_result$dlname" } else { # Otherwise fall back on heuristic. setvar tdlname = "../bin/$dlname" } } } $ECHO > $output "\ # $outputname - a libtool library file # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $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 can not 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$TIMESTAMP) $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 can not 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 $installed = no && test $need_relink = yes { $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 } do { test $mode = link || test $mode = relink; } && func_mode_link ${1+"$@"} # func_mode_uninstall arg... proc func_mode_uninstall { $opt_debug setvar RM = "$nonopt" setvar files = '' setvar rmforce = '' setvar exit_status = '0' # This variable tells wrapper scripts just to set variables rather # than running their programs. setvar libtool_install_magic = "$magic"for arg in @ARGV { case (arg) { -f { setvar RM = ""$RM $arg""; setvar rmforce = 'yes' } -* { setvar RM = ""$RM $arg"" } * { setvar files = ""$files $arg"" } } } test -z $RM && \ func_fatal_help "you must specify an RM program" setvar rmdirs = '' setvar origobjdir = "$objdir" for file in $files { func_dirname $file "" "." setvar dir = "$func_dirname_result" if test "X$dir" = X. { setvar objdir = "$origobjdir" } else { setvar objdir = ""$dir/$origobjdir"" } func_basename $file setvar name = "$func_basename_result" test $mode = uninstall && setvar objdir = "$dir" # Remember objdir for removal later, being careful to avoid duplicates if test $mode = clean { case{ *" $objdir "* { } * { setvar rmdirs = ""$rmdirs $objdir"" } } } # 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 { setvar exit_status = '1' continue } elif test $rmforce = yes { continue } setvar rmfiles = "$file" case (name) { *.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 { setvar rmfiles = ""$rmfiles $objdir/$n"" } test -n $old_library && setvar rmfiles = ""$rmfiles $objdir/$old_library"" case (mode) { clean { case{ # " " in the beginning catches empty $dlname *" $dlname "* { } * { setvar rmfiles = ""$rmfiles $objdir/$dlname"" } } test -n $libdir && setvar rmfiles = ""$rmfiles $objdir/$name $objdir/${name}i"" } uninstall { if test -n $library_names { # Do each command in the postuninstall commands. func_execute_cmds $postuninstall_cmds 'test "$rmforce" = yes || exit_status=1' } if test -n $old_library { # Do each command in the old_postuninstall commands. func_execute_cmds $old_postuninstall_cmds 'test "$rmforce" = yes || exit_status=1' } # FIXME: should reinstall the best remaining shared library. } } } } *.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 $pic_object != none { setvar rmfiles = ""$rmfiles $dir/$pic_object"" } # Add non-PIC object to the list of files to remove. if test -n $non_pic_object && test $non_pic_object != none { setvar rmfiles = ""$rmfiles $dir/$non_pic_object"" } } } * { if test $mode = clean { setvar noexename = "$name" case (file) { *.exe { func_stripname '' '.exe' $file setvar file = "$func_stripname_result" func_stripname '' '.exe' $name setvar noexename = "$func_stripname_result" # $file with .exe has already been added to rmfiles, # add $file without .exe setvar rmfiles = ""$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 setvar relink_command = '' func_source $func_ltwrapper_scriptname_result setvar rmfiles = ""$rmfiles $func_ltwrapper_scriptname_result"" } else { setvar 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 setvar rmfiles = ""$rmfiles $objdir/$name $objdir/${name}S.${objext}"" if test $fast_install = yes && test -n $relink_command { setvar rmfiles = ""$rmfiles $objdir/lt-$name"" } if test "X$noexename" != "X$name" { setvar rmfiles = ""$rmfiles $objdir/lt-${noexename}.c"" } } } } } func_show_eval "$RM $rmfiles" 'exit_status=1' } setvar objdir = "$origobjdir" # 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 } do { test $mode = uninstall || test $mode = clean; } && func_mode_uninstall ${1+"$@"} test -z $mode && do { setvar help = "$generic_help" func_fatal_help "you must specify a MODE" } test -z $exec_cmd && \ func_fatal_help "invalid operation mode \`$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 # in which 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 setvar build_libtool_libs = 'no' setvar build_old_libs = 'yes' # ### END LIBTOOL TAG CONFIG: disable-shared # ### BEGIN LIBTOOL TAG CONFIG: disable-static setvar build_old_libs = $(case (build_libtool_libs) { yes { echo no} * { echo yes} }) # ### END LIBTOOL TAG CONFIG: disable-static # Local Variables: # mode:shell-script # sh-indentation:2 # End: # vi:sw=2