Charles Wilson wrote: > Charles Wilson wrote: > >> How does that sound, as an intermediate plan? > > Implemented as attached, which should be applied on top of the -take3 patch.
Ping? The attached represents the combination of -take3 http://lists.gnu.org/archive/html/libtool-patches/2009-01/msg00233.html ChangeLog for that piece is here: http://lists.gnu.org/archive/html/libtool-patches/2009-01/msg00163.html And the followup *addendum* patch, with an associated pseudo-changelog: http://lists.gnu.org/archive/html/libtool-patches/2009-01/msg00238.html These two *could* be reviewed separately, if that is preferable. Or, just look at the attached combo patch. ChangeLog (for combo patch) libltdl/m4/libtool.m4 (_LT_PATH_CONVERSION_FUNCTIONS): New function sets libtool variable $to_host_path_cmd, and employs cache. AC_SUBSTs $to_host_path_cmd, as well. (_LT_SETUP): Require it. tests/testsuite.at: Ensure to_host_path_cmd is passed as a variable setting on the configure line for (new testsuite) tests. Makefile.am: Ensure to_host_path_cmd is included in TEST_ENVIRONMENT so that it is passed to (old testsuite) tests. libltdl/config/ltmain.m4sh (func_cygpath): New function. (func_init_to_host_pathlist_cmd): New function. (func_to_host_path): Refactored to... (now uses eval $to_host_path_cmd). (func_wine_to_win32_path): Here. New function. (func_msys_to_win32): Here. New function. (func_path_convert_check): Here. New function. (func_noop_path_convert): Here. New function. (func_msys_to_mingw_path_convert): Here. New function. (func_cygwin_to_mingw_path_convert): Here. New function. (func_nix_to_mingw_path_convert): Here. New function. (func_msys_to_cygwin_path_convert): New function. (func_nix_to_cygwin_path_convert): New function. (func_to_host_pathlist): Refactored to... (now uses eval $to_host_pathlist_cmd and func_init_to_host_pathlist_cmd). (func_pathlist_convert_check): Here. New function. (func_pathlist_front_back_pathsep): Here. New function. (func_wine_to_win32_pathlist): Here. New function. (func_noop_pathlist_convert): Here. New function. (func_msys_to_mingw_pathlist_convert): Here. New function. (func_cygwin_to_mingw_pathlist_convert): Here. New function. (func_nix_to_mingw_pathlist_convert): Here. New function. (func_msys_to_cygwin_pathlist_convert): New function. (func_nix_to_cygwin_pathlist_convert): New function.
diff --git a/Makefile.am b/Makefile.am index 574147d..9cd1628 100644 --- a/Makefile.am +++ b/Makefile.am @@ -507,7 +507,8 @@ TESTS_ENVIRONMENT = MAKE="$(MAKE)" CC="$(CC)" CFLAGS="$(CFLAGS)" \ CXX="$(CXX)" CXXFLAGS="$(CXXFLAGS)" CXXCPP="$(CXXCPP)" \ F77="$(F77)" FFLAGS="$(FFLAGS)" \ FC="$(FC)" FCFLAGS="$(FCFLAGS)" \ - GCJ="$(GCJ)" GCJFLAGS="$(GCJFLAGS)" + GCJ="$(GCJ)" GCJFLAGS="$(GCJFLAGS)" \ + lt_cv_to_host_path_cmd="$(to_host_path_cmd)" BUILDCHECK_ENVIRONMENT = _lt_pkgdatadir="$(abs_top_srcdir)" \ LIBTOOLIZE="$(abs_top_builddir)/libtoolize" \ diff --git a/libltdl/config/ltmain.m4sh b/libltdl/config/ltmain.m4sh index 49e07c3..d362d73 100644 --- a/libltdl/config/ltmain.m4sh +++ b/libltdl/config/ltmain.m4sh @@ -2533,166 +2533,595 @@ fi\ " } +#################################### +# PATH CONVERSION HELPER FUNCTIONS # +#################################### + +# func_wine_to_win32_path ARG +# Helper function used by path conversion functions +# when $build is *nix, and $host is mingw, cygwin, +# or some other win32 environment. Relies on a +# correctly configured wine environment available, +# with the winepath program in $build's $PATH. +# +# ARG is the $build path to be converted to win32 format. +# result is available in $func_wine_to_win32_path_result +# result is empty on error (or when arg is empty) +func_wine_to_win32_path () +{ + $opt_debug + lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + func_wine_to_win32_path_result="$1" + if test -n "$1"; then + # 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: + func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null` + if test "$?" -eq 0 && test -n "${func_wine_to_win32_path_tmp}"; then + func_to_host_path_result=`$ECHO "$func_wine_to_win32_path_tmp" | + $SED -e "$lt_sed_naive_backslashify"` + else + func_wine_to_win32_path_result= + fi + fi +} +# end: func_wine_to_win32_path + + +# func_wine_to_win32_pathlist ARG +# Helper function used by path conversion functions +# when $build is *nix, and $host is mingw, cygwin, +# or some other win32 environment. Relies on a +# correctly configured wine environment available, +# with the winepath program in $build's $PATH. +# Assumes ARG has no leading or trailing path separator +# characters. +# +# ARG is pathlist to be converted from $build format to win32. +# Result is available in $func_wine_to_win32_pathlist_result +# Unconvertible paths in pathlist are skipped; if no paths +# are convertible, result may be empty. +func_wine_to_win32_pathlist () +{ + $opt_debug + # unfortunately, winepath doesn't convert pathlists + func_wine_to_win32_pathlist_result="" + if test -n "$1"; then + func_wine_to_win32_pathlist_oldIFS=$IFS + IFS=: + for func_wine_to_win32_pathlist_f in $1; do + IFS=$func_wine_to_win32_pathlist_oldIFS + if test -n "$func_wine_to_win32_pathlist_f" ; then + func_wine_to_win32_path "$func_wine_to_win32_pathlist_f" + if test -n "$func_wine_to_win32_path_result" ; then + if test -z "$func_wine_to_win32_pathlist_result"; then + func_wine_to_win32_pathlist_result="$func_wine_to_win32_path_result" + else + func_append func_wine_to_win32_pathlist_result ";$func_wine_to_win32_path_result" + fi + fi + fi + done + IFS=$func_wine_to_win32_pathlist_oldIFS + fi +} +# end: func_wine_to_win32_pathlist + + +# func_cygpath ARGS... +# a wrapper around calling the cygpath program via +# LT_CYGPATH, when $host is *nix and cygwin is +# hosted via a wine environment (or, rarely, when +# host is mingw -- that is, msys). +# +# Result is available in func_cygpath_result, which +# may be empty on error. Can accomodate both paths +# and pathlists (with appropriate options). +# +# ARGS are the typical arguments and options for +# the cygpath program. Usually, the last argument +# is the path or pathlist to be converted. +# +# The full *nix (or msys) path to the cygpath program must be +# specified in the LT_CYGPATH environment variable. This +# is because (a) the cygpath program shouldn't be in $PATH, +# because it usually lives in cygwin's bin/ directory -- +# along with *cygwin* versions of sed, id, cp. If the *nix (or +# msys) host environment had those programs in its $PATH, many +# bad things could happen. (b) especially in cygwin-1.7, multiple +# installations (with separate "mount tables" in +# <CYGROOT-N>/etc/fstab) can coexist on the same Win32 +# instance. The cygpath.exe for cygwin installation #N in +# <CYGROOT-N>/bin automatically deduces the appropriate +# ../etc/fstab file. Therefore, it matters which cygpath.exe +# is used. LT_CYGPATH may be replaced or supplemented by an +# LT_INIT-activated configure option in the future. +func_cygpath () +{ + $opt_debug + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` + if test "$?" -ne 0; then + # on failure, ensure result is empty + func_cygpath_result= + fi + else + func_cygpath_result= + func_error "LT_CYGPATH is empty or specifies non-existant file: \`$LT_CYGPATH'" + fi +} +#end: func_cygpath + + +# func_msys_to_win32 ARG +# Converts ARG from msys (unix-ish) format to +# win32 format. Can accomodate both paths and pathlists. +# Result is available in func_msys_to_win32_result. +func_msys_to_win32 () +{ + $opt_debug + lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + # awkward: cmd appends spaces to result + func_msys_to_win32_result=`( cmd //c echo "$1" ) 2>/dev/null | + $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` +} +#end: func_msys_to_win32 + + +# func_path_convert_check ARG1 ARG2 +# Verify that ARG1 (a path in $build format) was +# converted to $host format in ARG2. Otherwise, emit +# an error message, but continue (resetting +# func_to_host_path_result to ARG1). +func_path_convert_check () +{ + $opt_debug + if test -z "$2" && test -n "$1" ; then + func_error "Could not determine host path corresponding to" + func_error " \`$1'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback: + func_to_host_path_result="$1" + fi +} +# end func_path_convert_check + + +# func_pathlist_convert_check FROM_PATHSEP TO_PATHSEP FROM_PATHLIST TO_PATHLIST +# Verify that FROM_PATHLIST (a path in $build format) was converted +# $host format in TO_PATHLIST. Otherwise, emit an error message, but +# continue, resetting func_to_host_path_result to a simplistic +# fallback value (see below). +func_pathlist_convert_check () +{ + $opt_debug + if test -z "$4" && test -n "$3"; then + func_error "Could not determine the host path(s) corresponding to" + func_error " \`$3'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback. If even this fallback fails, the fix is not to + # complicate the expression below, but for the user to provide, + # in that situation, whatever elements are missing from the + # environment so that the actual pathlist conversion functions + # work properly (for instance, a working wine installation + # with winepath so that path translation in the cross-to-mingw + # case works). + if test "x$1" != "x$2"; then + lt_replace_pathsep_chars="s|$1|$2|g" + func_to_host_pathlist_result=`echo "$3" |\ + $SED -e "$lt_replace_pathsep_chars"` + else + func_to_host_pathlist_result="$3" + fi + fi +} +# end func_pathlist_convert_check + + +# func_pathlist_front_back_pathsep FRONTPAT BACKPAT REPL ORIG +# Modifies func_to_host_pathlist_result by prepending REPL +# if ORIG matches FRONTPAT and appending REPL if ORIG matches +# BACKPAT. +func_pathlist_front_back_pathsep () +{ + $opt_debug + case "$4" in + $1 ) func_to_host_pathlist_result="$3$func_to_host_pathlist_result" + ;; + esac + case "$4" in + $2 ) func_append func_to_host_pathlist_result "$3" + ;; + esac +} +# end func_pathlist_front_back_pathsep + -# func_to_host_path arg +############################################# +# $build to $host PATH CONVERSION FUNCTIONS # +############################################# +# invoked via `eval $to_host_path_cmd 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: +# At present, the following path conversions are supported: # $build $host # mingw (msys) mingw [e.g. native] # cygwin mingw # *nix + wine mingw +# mingw (msys) cygwin [*] [**] +# *nix + wine cygwin [**] # 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. +# [*] available, but not officially supported. See comments with +# func_msys_to_cygwin_path_convert. +# [**] requires environment variable $LT_CYGPATH. See comments +# with func_cygpath. +# In each case, ARG is the path to be converted from $build +# to $host format. the result will be available in +# $func_to_host_path_result. + + +# func_to_host_path ARG +# converts the path ARG from $build format to $host +# format. func_to_host_path () { + $opt_debug + eval '$to_host_path_cmd "$1"' +} +# end func_to_host_path + + +# func_noop_path_convert ARG +# A no-op path conversion function for use when $build == $host. +# or when there is no required (or known) conversion function +# between $build and $host. +func_noop_path_convert () +{ + $opt_debug + func_to_host_path_result="$1" +} +# end func_noop_path_convert + + +# func_msys_to_mingw_path_convert ARG +# A path conversion function for use with "native" mingw +# builds -- that is, when $host is *mingw*, and $build +# is *mingw* (which is to say, msys). In this case, the +# msys shell automatically converts paths for any non-msys +# applications it launches, but that facility isn't available +# from inside the cwrapper. +# +# ARG is the path to be converted; the result is available +# in func_to_host_path_result. +func_msys_to_mingw_path_convert () +{ + $opt_debug func_to_host_path_result="$1" if test -n "$1"; then - case $host in - *mingw* ) - lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' - case $build in - *mingw* ) # actually, msys - # awkward: cmd appends spaces to result - func_to_host_path_result=`( cmd //c echo "$1" ) 2>/dev/null | - $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` - ;; - *cygwin* ) - 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: - func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null` - if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then - func_to_host_path_result=`$ECHO "$func_to_host_path_tmp1" | - $SED -e "$lt_sed_naive_backslashify"` - else - # Allow warning below. - func_to_host_path_result= - fi - ;; - esac - if test -z "$func_to_host_path_result" ; then - func_error "Could not determine host path corresponding to" - func_error " \`$1'" - func_error "Continuing, but uninstalled executables may not work." - # Fallback: - func_to_host_path_result="$1" - fi - ;; - esac + func_msys_to_win32 "$1" + func_to_host_path_result="$func_msys_to_win32_result" + fi + func_path_convert_check "$1" "$func_to_host_path_result" +} +# end func_msys_to_mingw_path_convert + + +# func_cygwin_to_mingw_path_convert ARG +# A path conversion function for use when $host is *mingw* +# but $build is *cygwin*. In this case, the cygpath program +# provided by the $build environment is sufficient for all +# conversions. +# +# ARG is the path to be converted; the result is available +# in func_to_host_path_result. +func_cygwin_to_mingw_path_convert () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # because $build is cygwin, we call "the" cygpath + # in $PATH; no need to use LT_CYGPATH in this case. + func_to_host_path_result=`cygpath -m "$1"` + fi + func_path_convert_check "$1" "$func_to_host_path_result" +} +# end func_cygwin_to_mingw_path_convert + + +# func_nix_to_mingw_path_convert ARG +# A path conversion function for use when $host is *mingw* +# but $build is some *nix variant. In this case, we assume +# that a wine environment with a working winepath executable +# is available in $build's $PATH. +# +# ARG is the path to be converted; the result is available +# in func_to_host_path_result. +func_nix_to_mingw_path_convert () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + func_wine_to_win32_path "$1" + func_to_host_path_result="$func_wine_to_win32_path_result" + fi + func_path_convert_check "$1" "$func_to_host_path_result" +} +# end func_nix_to_mingw_path_convert + + +# func_msys_to_cygwin_path_convert ARG +# A path conversion function for use when $host is *cygwin* +# but $build is *mingw* (that is, msys). This implies running +# a cross build from msys to cygwin -- but msys has notorious +# problems executing cygwin apps, because of conflicts between +# cygwin1.dll and msys-1.0.dll. However, we'll try it. First, +# convert from msys to win32, then use func_cygpath to convert +# from win32 to cygwin. Requires LT_CYGPATH. +# +# ARG is the path to be converted; the result is available +# in func_to_host_path_result. +func_msys_to_cygwin_path_convert () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + func_msys_to_win32 "$1" + func_cygpath -u "$func_msys_to_win32_result" + func_to_host_path_result="$func_cygpath_result" + fi + func_path_convert_check "$1" "$func_to_host_path_result" +} +# end func_msys_to_cygwin_path_convert + +# func_nix_to_cygwin_path_convert ARG +# A path conversion function for use when $host is *cygwin* +# but $build is some *nix variant. In this case, we assume +# that a wine environment with a working winepath executable +# is available in $build's $PATH, and that cygwin is installed +# within that wine environment. Requires LT_CYGPATH (see +# func_cygpath). +# +# ARG is the path to be converted; the result is available +# in func_to_host_path_result. +func_nix_to_cygwin_path_convert () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # convert from *nix to win32, then use cygpath to + # convert from win32 to cygwin. + func_wine_to_win32_path "$1" + func_cygpath -u "$func_wine_to_win32_path_result" + func_to_host_path_result="$func_cygpath_result" fi + func_path_convert_check "$1" "$func_to_host_path_result" } -# end: func_to_host_path +# end func_nix_to_cygwin_path_convert + -# func_to_host_pathlist arg +################################################# +# $build to $host PATHLIST CONVERSION FUNCTIONS # +################################################# +# invoked via `eval $to_host_pathlist_cmd 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): +# At present, the following pathlist conversions are supported: # $build $host # mingw (msys) mingw [e.g. native] # cygwin mingw # *nix + wine mingw +# mingw (msys) cygwin [*] [**] +# *nix + wine cygwin [**] +# where wine is equipped with the `winepath' executable. +# [*] available, but not officially supported. See comments with +# func_msys_to_cygwin_pathlist_convert. +# [**] requires environment variable $LT_CYGPATH. See comments +# with func_cygpath. +# In each case, ARG is the pathlist to be converted from +# $build to $host format. the result will be available in +# $func_to_host_pathlist_result. # # Path separators are also converted from $build format to # $host format. If ARG begins or ends with a path separator # character, it is preserved (but converted to $host format) # on output. + + +# func_init_to_host_pathlist_cmd +# Ensures that function "pointer" variable +# $to_host_pathlist_cmd is set to the appropriate +# value, based on the value of $to_host_path_cmd. # -# 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. +# ASSUMPTIONS: all such conversion functions are +# named using the following convention: +# path conversion function : xxxxxx_path_convert () +# pathlist conversion function: xxxxxx_pathlist_convert () +# where, for any given $build/$host combination the 'xxxxxx' +# value is the same. +to_host_pathlist_cmd= +func_init_to_host_pathlist_cmd () +{ + $opt_debug + if test -z "$to_host_pathlist_cmd"; then + func_stripname '' '_path_convert' "$to_host_path_cmd" + to_host_pathlist_cmd="${func_stripname_result}_pathlist_convert" + fi +} + + +# func_to_host_pathlist ARG +# converts the pathlist ARG from $build format to $host +# format. func_to_host_pathlist () { + $opt_debug + func_init_to_host_pathlist_cmd + eval '$to_host_pathlist_cmd "$1"' +} +# end func_to_host_pathlist + + +# func_noop_pathlist_convert ARG +# A no-op pathlist conversion function for use when $build == $host, +# or when there is no required (or known) conversion function +# between $build and $host. +func_noop_pathlist_convert () +{ + $opt_debug + func_to_host_pathlist_result="$1" +} +# end func_noop_pathlist_convert + + +# func_msys_to_mingw_pathlist_convert ARG +# A pathlist conversion function for use with "native" mingw +# builds -- that is, when $host is *mingw*, and $build +# is *mingw* (which is to say, msys). In this case, the +# msys shell automatically converts pathlists for any non-msys +# applications it launches, but that facility isn't available +# from inside the cwrapper. +# +# ARG is the pathlist to be converted; the result is available +# in func_to_host_pathlist_result. +func_msys_to_mingw_pathlist_convert () +{ + $opt_debug func_to_host_pathlist_result="$1" if test -n "$1"; then - case $host in - *mingw* ) - 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" - func_to_host_pathlist_tmp1=$func_stripname_result - case $build in - *mingw* ) # Actually, msys. - # Awkward: cmd appends spaces to result. - func_to_host_pathlist_result=` - ( cmd //c echo "$func_to_host_pathlist_tmp1" ) 2>/dev/null | - $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` - ;; - *cygwin* ) - 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 - func_to_host_pathlist_result="" - func_to_host_pathlist_oldIFS=$IFS - IFS=: - for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do - IFS=$func_to_host_pathlist_oldIFS - if test -n "$func_to_host_pathlist_f" ; then - func_to_host_path "$func_to_host_pathlist_f" - if test -n "$func_to_host_path_result" ; then - if test -z "$func_to_host_pathlist_result" ; then - func_to_host_pathlist_result="$func_to_host_path_result" - else - func_append func_to_host_pathlist_result ";$func_to_host_path_result" - fi - fi - fi - done - IFS=$func_to_host_pathlist_oldIFS - ;; - esac - if test -z "$func_to_host_pathlist_result"; then - 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. - lt_replace_pathsep_nix_to_dos="s|:|;|g" - func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\ - $SED -e "$lt_replace_pathsep_nix_to_dos"` - fi - # Now, add the leading and trailing path separators back - case "$1" in - :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result" - ;; - esac - case "$1" in - *: ) func_append func_to_host_pathlist_result ";" - ;; - esac - ;; - esac + # 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" + func_to_host_pathlist_tmp1=$func_stripname_result + func_msys_to_win32 "$func_to_host_pathlist_tmp1" + func_to_host_pathlist_result="$func_msys_to_win32_result" + func_pathlist_convert_check ":" ";" \ + "$func_to_host_pathlist_tmp1" "$func_to_host_pathlist_result" + func_pathlist_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_msys_to_mingw_pathlist_convert + + +# func_cygwin_to_mingw_pathlist_convert ARG +# A pathlist conversion function for use when $host is *mingw* +# but $build is *cygwin*. In this case, the cygpath program +# provided by the $build environment is sufficient for all +# conversions. +# +# ARG is the pathlist to be converted; the result is available +# in func_to_host_pathlist_result. +func_cygwin_to_mingw_pathlist_convert () +{ + $opt_debug + func_to_host_pathlist_result="$1" + if test -n "$1"; then + # 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" + func_to_host_pathlist_tmp1=$func_stripname_result + func_to_host_pathlist_result=`cygpath -m -p "$func_to_host_pathlist_tmp1"` + func_pathlist_convert_check ":" ";" \ + "$func_to_host_pathlist_tmp1" "$func_to_host_pathlist_result" + func_pathlist_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_cygwin_to_mingw_pathlist_convert + + +# func_nix_to_mingw_pathlist_convert ARG +# A pathlist conversion function for use when $host is *mingw* +# but $build is some *nix variant. In this case, we assume +# that a wine environment with a working winepath executable +# is available in $build's $PATH. +# +# ARG is the pathlist to be converted; the result is available +# in func_to_host_pathlist_result. +func_nix_to_mingw_pathlist_convert () +{ + $opt_debug + func_to_host_pathlist_result="$1" + if test -n "$1"; then + # 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" + func_to_host_pathlist_tmp1=$func_stripname_result + func_wine_to_win32_pathlist "$func_to_host_pathlist_tmp1" + func_to_host_pathlist_result="$func_wine_to_win32_pathlist_result" + func_pathlist_convert_check ":" ";" \ + "$func_to_host_pathlist_tmp1" "$func_to_host_pathlist_result" + func_pathlist_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_nix_to_mingw_pathlist_convert + + +# func_msys_to_cygwin_pathlist_convert ARG +# A pathlist conversion function for use when $host is *cygwin* +# but $build is *mingw* (that is, msys). This implies running +# a cross build from msys to cygwin -- but msys has notorious +# problems executing cygwin apps, because of conflicts between +# cygwin1.dll and msys-1.0.dll. However, we'll try it. First, +# convert from msys to win32, then use func_cygpath to convert +# from win32 to cygwin. Requires LT_CYGPATH. +# +# ARG is the pathlist to be converted; the result is available +# in func_to_host_pathlist_result. +func_msys_to_cygwin_pathlist_convert () +{ + $opt_debug + func_to_host_pathlist_result="$1" + if test -n "$1"; then + # 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" + func_to_host_pathlist_tmp1=$func_stripname_result + func_msys_to_win32 "$func_to_host_pathlist_tmp1" + func_cygpath -u -p "$func_msys_to_win32_result" + func_to_host_pathlist_result="$func_cygpath_result" + func_pathlist_convert_check ":" ":" \ + "$func_to_host_pathlist_tmp1" "$func_to_host_pathlist_result" + func_pathlist_front_back_pathsep ":*" "*:" ":" "$1" fi } -# end: func_to_host_pathlist +# end func_msys_to_cygwin_pathlist_convert + + +# func_nix_to_cygwin_pathlist_convert ARG +# A pathlist conversion function for use when $host is *cygwin* +# but $build is some *nix variant. In this case, we assume +# that a wine environment with a working winepath executable +# is available in $build's $PATH, and that cygwin is installed +# within that wine environment. Requires LT_CYGPATH (see +# func_cygpath). +# +# ARG is the pathlist to be converted; the result is available +# in func_to_host_pathlist_result. +func_nix_to_cygwin_pathlist_convert () +{ + $opt_debug + func_to_host_pathlist_result="$1" + if test -n "$1"; then + # 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" + func_to_host_pathlist_tmp1=$func_stripname_result + func_wine_to_win32_pathlist "$func_to_host_pathlist_tmp1" + func_cygpath -u -p "$func_wine_to_win32_pathlist_result" + func_to_host_pathlist_result="$func_cygpath_result" + func_pathlist_convert_check ":" ":" \ + "$func_to_host_pathlist_tmp1" "$func_to_host_pathlist_result" + func_pathlist_front_back_pathsep ":*" "*:" ":" "$1" + fi +} +# end func_nix_to_cygwin_pathlist_convert + # func_emit_cwrapperexe_src # emit the source code for a wrapper executable on stdout diff --git a/libltdl/m4/libtool.m4 b/libltdl/m4/libtool.m4 index b75a55a..347a38f 100644 --- a/libltdl/m4/libtool.m4 +++ b/libltdl/m4/libtool.m4 @@ -166,6 +166,7 @@ _LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl m4_require([_LT_CMD_RELOAD])dnl m4_require([_LT_CHECK_MAGIC_METHOD])dnl m4_require([_LT_CMD_OLD_ARCHIVE])dnl @@ -7305,3 +7306,55 @@ _LT_EOF ;; esac ]) + +# _LT_PATH_CONVERSION_FUNCTIONS +# ----------------------------- +# Determine which path conversion functions should be +# used by func_to_host_path (and, implicitly, by +# func_to_host_pathlist). These are needed for certain +# cross-compile configurations and "native" mingw (which +# is actually an msys->mingw cross). +m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_MSG_CHECKING([how to convert $build paths to $host format]) +AC_CACHE_VAL(lt_cv_to_host_path_cmd, +[case $host in + *mingw* ) + case $build in + *mingw* ) # actually msys + lt_cv_to_host_path_cmd=func_msys_to_mingw_path_convert + ;; + *cygwin* ) + lt_cv_to_host_path_cmd=func_cygwin_to_mingw_path_convert + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_path_cmd=func_nix_to_mingw_path_convert + ;; + esac + ;; + *cygwin* ) + case $build in + *mingw* ) # actually msys + lt_cv_to_host_path_cmd=func_msys_to_cygwin_path_convert + ;; + *cygwin* ) + lt_cv_to_host_path_cmd=func_noop_path_convert + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_path_cmd=func_nix_to_cygwin_path_convert + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_path_cmd=func_noop_path_convert + ;; +esac +]) +to_host_path_cmd=$lt_cv_to_host_path_cmd +AC_MSG_RESULT([$lt_cv_to_host_path_cmd]) +_LT_DECL([to_host_path_cmd], [lt_cv_to_host_path_cmd], + [0], [convert $build paths to $host format])dnl +AC_SUBST([to_host_path_cmd])dnl +])# _LT_PATH_CONVERSION_FUNCTIONS + diff --git a/tests/testsuite.at b/tests/testsuite.at index 0929849..3fea65a 100644 --- a/tests/testsuite.at +++ b/tests/testsuite.at @@ -38,7 +38,7 @@ for tool in ACLOCAL AUTOHEADER AUTOCONF AUTOMAKE AUTORECONF; do done export ACLOCAL AUTOHEADER AUTOCONF AUTOMAKE AUTORECONF eval `$LIBTOOL --config | grep '^EGREP='` -eval `$LIBTOOL --config | $EGREP '^(host|host_os|host_alias|build|build_alias)='` +eval `$LIBTOOL --config | $EGREP '^(host|host_os|host_alias|build|build_alias|to_host_path_cmd)='` configure_options=--prefix=/nonexistent if test -n "$host_alias"; then configure_options="$configure_options --host $host_alias" @@ -46,6 +46,9 @@ fi if test -n "$build_alias"; then configure_options="$configure_options --build $build_alias" fi +if test -n "$to_host_path_cmd"; then + configure_options="$configure_options lt_cv_to_host_path_cmd=$to_host_path_cmd" +fi if (FOO=bar; unset FOO) >/dev/null 2>&1; then unset=unset else