Re: [PATCH] [cygwin]: Add cross-compile support to cwrapper

[Charles Wilson]

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