Convert unix path to windows path

As an alternative to the accepted answer, you may wish to consider that MSYS itself will perform the conversion at any boundary between MSYS parent and native child process; thus, in an MSYS shell console:

cmd //c echo /c/my/path/to/a/folder

would display the appropriately converted path c:/my/path/to/a/folder. Additionally, this technique offers the possible advantage that it will emit the fully converted native form of a path, such as:

cmd //c echo /home/my/path/to/a/folder

to yield its native equivalent C:/MinGW/msys/1.0/home/my/path/to/a/folder, (assuming your MSYS installation is in the recommended default location, at C:/MinGW/msys/1.0).

With the caveat that running MSYS shell without proper initialization, as performed by msys.bat, may not work, (especially when running on 64-bit Windows), you may be able to run an equivalent command from within a native process, (such as within CMake), as:

C:/MinGW/msys/1.0/bin/sh -c 'cmd //c echo /home/my/path/to/a/folder'

Note that, if you invoke this from a native process which is itself running within an MSYS console, the initialization will have been correctly performed for the console’s own shell process, and should thus propagate through the native process; the issues are more likely to arise if you attempt to invoke MSYS processes directly from a cmd.exe process, in a native Windows console, (or other native container).

Also note that, if the path name in question contains spaces, (never a good idea), you may need to enclose it within double quotes:

cmd //c echo "/home/my/path with spaces"

In this case, some experimentation indicates that the double quotes remain within the cmd output. I’m not entirely certain if this is necessary; you should use your discretion in your own particular usage case.

1. Always double-quote your variables so that you don’t need to care about spaces or shell meta-characters.

2. you can use sed or tr to convert /s to . e.g. sed 's:/:\:g' or tr '/' '\' (note: because is the shell escape character, it needs to be escaped to be treated as a literal backslash).

3. Alternatively, bash’s string manipulation operators will do the job (but aren’t posix standard, so aren’t portable). The only mistake you made there was in not quoting the variables.

But note that, as mentioned by @Michael Homer, it shouldn’t be necessary to modify the path separator…I’ve certainly had no difficulty running wine program.exe /unix/path/to/file in the past.

resulting in:

#!/bin/bash

p1="$1"
p2="$2"

# optional transformation
p1="$(printf "%s" "$p1" | tr '/' '\')"
p2="$(printf "%s" "$p2" | tr '/' '\')"

wine /utils/wincmp.exe "$p1" "$p2"

or

#!/bin/bash

p1="${1////\}"
p2="${2////\}"

wine /utils/wincmp.exe "$p1" "$p2"

or even:

#!/bin/bash
wine /utils/wincmp.exe "${1////\}" "${2////\}"

(but this last version doesn’t give you any opportunity to sanity-check the file arguments, or do any kind of option handling — e.g. with getopts)

Finally, you may want to reconsider your preference for a Windows diff tool, or at least conduct a more thorough survey before deciding (you’ve only evaluated a small subset of available tools and GUI wrappers). A Windows/wine based tool will not integrate pleasantly into Linux/UNIX-based development workflow.

(personally, I mostly use either diff -u or colordiff -u piped into less. Given that I’m working with text files, there’s no need for a GUI interface. It’s also identical to what I get from git diff etc. On the rare occasions I need a side-by-side diff, I mostly use sdiff).

winepath is the helper program to convert file paths between UNIX and Windows.

Usage

Usage: winepath [OPTION] [PATH]...
Convert PATH(s) to Unix or Windows long or short paths.

  -u, --unix    converts a Windows path to a Unix path
  -w, --windows converts a Unix path to a long Windows path
  -l, --long    converts the short Windows path of an existing file or
                directory to the long format
  -s, --short   converts the long Windows path of an existing file or
                directory to the short format
  -h, --help    output this help message and exit
  -v, --version output version information and exit

If more than one option is given then the input paths are output in all formats specified, in the order long, short, Unix, Windows.

If no option is given the default is Unix format.

Examples

$ winepath c:\
/home/vitaliy/.wine/dosdevices/c:/

$ winepath "c:program files"
/home/vitaliy/.wine/dosdevices/c:/Program Files

$ winepath -w ~
z:homevitaliy

$ winepath -w /media/dvd/
d:

To launch documents from inside Windows apps, create a small shell script called e.g. /usr/bin/run_prog containing

#!/bin/sh
$1 "`wine winepath -u "$2"`"

And then add a registry entry like this:

[HKEY_CLASSES_ROOTxcelfileShellOpencommand]
@="/bin/sh run_prog /usr/bin/oocalc "%1""

See also winenative — Tres Finocchiaro’s script that uses winepath to launch Linux apps from inside Windows apps

I wrote a bat file to do this. Just place the file wherever you are working or add it to your path (or just put it above your code, which would be easier to work with). Remember to assign «variable» to your file path first (if you are using a separate file, try using parameters).

What the code does:

1) Get the first letter of the path, which is the drive.

2) Remove the first two letters.

3) Change the slashes.

4) This is the tricky part: since Linux is case sensitive, we need to convert uppercase drive letter to lowercase. Do this by matching each (tell me if there is a better way). You can remove unnecessary drive letters too, since you probably have no more than ten drives.

5) Combine everything to give the final string.

The result:

Input:

E:myfilesapp1datafile.csv

Output (with the quotation marks):

"/mnt/e/myfiles/app1/data/file.csv"

The code is as follows:

@echo OFF

set "variable=E:myfilesapp1datafile.csv"

set "drive=%variable:~0,1%"

set variable=%variable:~2%
set "variable=%variable:=/%"

if %drive%==A set "drive=a"
if %drive%==B set "drive=b"
if %drive%==C set "drive=c"
if %drive%==D set "drive=d"
if %drive%==E set "drive=e"
if %drive%==F set "drive=f"
if %drive%==G set "drive=g"
if %drive%==H set "drive=h"
if %drive%==I set "drive=i"
if %drive%==J set "drive=j"
if %drive%==K set "drive=k"
if %drive%==L set "drive=l"
if %drive%==M set "drive=m"
if %drive%==N set "drive=n"
if %drive%==O set "drive=o"
if %drive%==P set "drive=p"
if %drive%==Q set "drive=q"
if %drive%==R set "drive=r"
if %drive%==S set "drive=s"
if %drive%==T set "drive=t"
if %drive%==U set "drive=u"
if %drive%==V set "drive=v"
if %drive%==W set "drive=w"
if %drive%==X set "drive=x"
if %drive%==Y set "drive=y"
if %drive%==Z set "drive=z"

set "variable=/mnt/%drive%%variable%"

echo "%variable%"

@echo ON