Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 774 insertions, 0 deletions

diff --git a/src/winclip.c b/src/winclip.c
new file mode 100644
index 0000000..8f54c6b
--- /dev/null
+++ b/src/winclip.c
@@ -0,0 +1,774 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * winclip.c
+ *
+ * Routines for Win32 clipboard handling.
+ * Also used by Cygwin, using os_unix.c.
+ */
+
+#include "vim.h"
+
+/*
+ * Compile only the clipboard handling features when compiling for cygwin
+ * posix environment.
+ */
+#ifdef FEAT_CYGWIN_WIN32_CLIPBOARD
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+# include "winclip.pro"
+#endif
+
+/*
+ * When generating prototypes for Win32 on Unix, these lines make the syntax
+ * errors disappear.  They do not need to be correct.
+ */
+#ifdef PROTO
+#define WINAPI
+#define WINBASEAPI
+typedef int DWORD;
+typedef int LPBOOL;
+typedef int LPCSTR;
+typedef int LPCWSTR;
+typedef int LPSTR;
+typedef int LPWSTR;
+typedef int UINT;
+#endif
+
+/*
+ * Convert an UTF-8 string to UTF-16.
+ * "instr[inlen]" is the input.  "inlen" is in bytes.
+ * When "outstr" is NULL only return the number of UTF-16 words produced.
+ * Otherwise "outstr" must be a buffer of sufficient size.
+ * Returns the number of UTF-16 words produced.
+ */
+    int
+utf8_to_utf16(char_u *instr, int inlen, short_u *outstr, int *unconvlenp)
+{
+    int		outlen = 0;
+    char_u	*p = instr;
+    int		todo = inlen;
+    int		l;
+    int		ch;
+
+    while (todo > 0)
+    {
+	// Only convert if we have a complete sequence.
+	l = utf_ptr2len_len(p, todo);
+	if (l > todo)
+	{
+	    // Return length of incomplete sequence.
+	    if (unconvlenp != NULL)
+		*unconvlenp = todo;
+	    break;
+	}
+
+	ch = utf_ptr2char(p);
+	if (ch >= 0x10000)
+	{
+	    // non-BMP character, encoding with surrogate pairs
+	    ++outlen;
+	    if (outstr != NULL)
+	    {
+		*outstr++ = (0xD800 - (0x10000 >> 10)) + (ch >> 10);
+		*outstr++ = 0xDC00 | (ch & 0x3FF);
+	    }
+	}
+	else if (outstr != NULL)
+	    *outstr++ = ch;
+	++outlen;
+	p += l;
+	todo -= l;
+    }
+
+    return outlen;
+}
+
+/*
+ * Convert an UTF-16 string to UTF-8.
+ * The input is "instr[inlen]" with "inlen" in number of UTF-16 words.
+ * When "outstr" is NULL only return the required number of bytes.
+ * Otherwise "outstr" must be a buffer of sufficient size.
+ * Return the number of bytes produced.
+ */
+    int
+utf16_to_utf8(short_u *instr, int inlen, char_u *outstr)
+{
+    int		outlen = 0;
+    int		todo = inlen;
+    short_u	*p = instr;
+    int		l;
+    int		ch, ch2;
+
+    while (todo > 0)
+    {
+	ch = *p;
+	if (ch >= 0xD800 && ch <= 0xDBFF && todo > 1)
+	{
+	    // surrogate pairs handling
+	    ch2 = p[1];
+	    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF)
+	    {
+		ch = ((ch - 0xD800) << 10) + (ch2 & 0x3FF) + 0x10000;
+		++p;
+		--todo;
+	    }
+	}
+	if (outstr != NULL)
+	{
+	    l = utf_char2bytes(ch, outstr);
+	    outstr += l;
+	}
+	else
+	    l = utf_char2len(ch);
+	++p;
+	outlen += l;
+	--todo;
+    }
+
+    return outlen;
+}
+
+/*
+ * Call MultiByteToWideChar() and allocate memory for the result.
+ * Returns the result in "*out[*outlen]" with an extra zero appended.
+ * "outlen" is in words.
+ */
+    void
+MultiByteToWideChar_alloc(UINT cp, DWORD flags,
+	LPCSTR in, int inlen,
+	LPWSTR *out, int *outlen)
+{
+    *outlen = MultiByteToWideChar(cp, flags, in, inlen, 0, 0);
+    // Add one word to avoid a zero-length alloc().
+    *out = ALLOC_MULT(WCHAR, *outlen + 1);
+    if (*out == NULL)
+	return;
+
+    MultiByteToWideChar(cp, flags, in, inlen, *out, *outlen);
+    (*out)[*outlen] = 0;
+}
+
+/*
+ * Call WideCharToMultiByte() and allocate memory for the result.
+ * Returns the result in "*out[*outlen]" with an extra NUL appended.
+ */
+    void
+WideCharToMultiByte_alloc(UINT cp, DWORD flags,
+	LPCWSTR in, int inlen,
+	LPSTR *out, int *outlen,
+	LPCSTR def, LPBOOL useddef)
+{
+    *outlen = WideCharToMultiByte(cp, flags, in, inlen, NULL, 0, def, useddef);
+    // Add one byte to avoid a zero-length alloc().
+    *out = alloc(*outlen + 1);
+    if (*out == NULL)
+	return;
+    WideCharToMultiByte(cp, flags, in, inlen, *out, *outlen, def, useddef);
+    (*out)[*outlen] = 0;
+}
+
+
+#ifdef FEAT_CLIPBOARD
+/*
+ * Clipboard stuff, for cutting and pasting text to other windows.
+ */
+
+    void
+win_clip_init(void)
+{
+    clip_init(TRUE);
+
+    /*
+     * Vim's own clipboard format recognises whether the text is char, line,
+     * or rectangular block.  Only useful for copying between two Vims.
+     * "Clipboard_T" was used for previous versions, using the first
+     * character to specify MCHAR, MLINE or MBLOCK.
+     */
+    clip_star.format = RegisterClipboardFormat("VimClipboard2");
+    clip_star.format_raw = RegisterClipboardFormat("VimRawBytes");
+}
+
+// Type used for the clipboard type of Vim's data.
+typedef struct
+{
+    int type;		// MCHAR, MBLOCK or MLINE
+    int txtlen;		// length of CF_TEXT in bytes
+    int ucslen;		// length of CF_UNICODETEXT in words
+    int rawlen;		// length of clip_star.format_raw, including encoding,
+			// excluding terminating NUL
+} VimClipType_t;
+
+/*
+ * Make vim the owner of the current selection.  Return OK upon success.
+ */
+    int
+clip_mch_own_selection(Clipboard_T *cbd UNUSED)
+{
+    /*
+     * Never actually own the clipboard.  If another application sets the
+     * clipboard, we don't want to think that we still own it.
+     */
+    return FAIL;
+}
+
+/*
+ * Make vim NOT the owner of the current selection.
+ */
+    void
+clip_mch_lose_selection(Clipboard_T *cbd UNUSED)
+{
+    // Nothing needs to be done here
+}
+
+/*
+ * Copy "str[*size]" into allocated memory, changing CR-NL to NL.
+ * Return the allocated result and the size in "*size".
+ * Returns NULL when out of memory.
+ */
+    static char_u *
+crnl_to_nl(const char_u *str, int *size)
+{
+    int		pos = 0;
+    int		str_len = *size;
+    char_u	*ret;
+    char_u	*retp;
+
+    // Avoid allocating zero bytes, it generates an error message.
+    ret = alloc(str_len == 0 ? 1 : str_len);
+    if (ret != NULL)
+    {
+	retp = ret;
+	for (pos = 0; pos < str_len; ++pos)
+	{
+	    if (str[pos] == '\r' && str[pos + 1] == '\n')
+	    {
+		++pos;
+		--(*size);
+	    }
+	    *retp++ = str[pos];
+	}
+    }
+
+    return ret;
+}
+
+/*
+ * Wait for another process to Close the Clipboard.
+ * Returns TRUE for success.
+ */
+    static int
+vim_open_clipboard(void)
+{
+    int delay = 10;
+
+    while (!OpenClipboard(NULL))
+    {
+	if (delay > 500)
+	    return FALSE;  // waited too long, give up
+	Sleep(delay);
+	delay *= 2;	// wait for 10, 20, 40, 80, etc. msec
+    }
+    return TRUE;
+}
+
+/*
+ * Get the current selection and put it in the clipboard register.
+ *
+ * NOTE: Must use GlobalLock/Unlock here to ensure Win32s compatibility.
+ * On NT/W95 the clipboard data is a fixed global memory object and
+ * so its handle = its pointer.
+ * On Win32s, however, co-operation with the Win16 system means that
+ * the clipboard data is moveable and its handle is not a pointer at all,
+ * so we can't just cast the return value of GetClipboardData to (char_u*).
+ * <VN>
+ */
+    void
+clip_mch_request_selection(Clipboard_T *cbd)
+{
+    VimClipType_t	metadata = { -1, -1, -1, -1 };
+    HGLOBAL		hMem = NULL;
+    char_u		*str = NULL;
+    char_u		*to_free = NULL;
+    HGLOBAL		rawh = NULL;
+    int			str_size = 0;
+    int			maxlen;
+    size_t		n;
+
+    /*
+     * Don't pass GetActiveWindow() as an argument to OpenClipboard() because
+     * then we can't paste back into the same window for some reason - webb.
+     */
+    if (!vim_open_clipboard())
+	return;
+
+    // Check for vim's own clipboard format first.  This only gets the type of
+    // the data, still need to use CF_UNICODETEXT or CF_TEXT for the text.
+    if (IsClipboardFormatAvailable(cbd->format))
+    {
+	VimClipType_t	*meta_p;
+	HGLOBAL		meta_h;
+
+	// We have metadata on the clipboard; try to get it.
+	if ((meta_h = GetClipboardData(cbd->format)) != NULL
+		&& (meta_p = (VimClipType_t *)GlobalLock(meta_h)) != NULL)
+	{
+	    // The size of "VimClipType_t" changed, "rawlen" was added later.
+	    // Only copy what is available for backwards compatibility.
+	    n = sizeof(VimClipType_t);
+	    if (GlobalSize(meta_h) < n)
+		n = GlobalSize(meta_h);
+	    memcpy(&metadata, meta_p, n);
+	    GlobalUnlock(meta_h);
+	}
+    }
+
+    // Check for Vim's raw clipboard format first.  This is used without
+    // conversion, but only if 'encoding' matches.
+    if (IsClipboardFormatAvailable(cbd->format_raw)
+				      && metadata.rawlen > (int)STRLEN(p_enc))
+    {
+	// We have raw data on the clipboard; try to get it.
+	if ((rawh = GetClipboardData(cbd->format_raw)) != NULL)
+	{
+	    char_u	*rawp;
+
+	    rawp = (char_u *)GlobalLock(rawh);
+	    if (rawp != NULL && STRCMP(p_enc, rawp) == 0)
+	    {
+		n = STRLEN(p_enc) + 1;
+		str = rawp + n;
+		str_size = (int)(metadata.rawlen - n);
+	    }
+	    else
+	    {
+		GlobalUnlock(rawh);
+		rawh = NULL;
+	    }
+	}
+    }
+    if (str == NULL)
+    {
+	// Try to get the clipboard in Unicode if it's not an empty string.
+	if (IsClipboardFormatAvailable(CF_UNICODETEXT) && metadata.ucslen != 0)
+	{
+	    HGLOBAL hMemW;
+
+	    if ((hMemW = GetClipboardData(CF_UNICODETEXT)) != NULL)
+	    {
+		WCHAR *hMemWstr = (WCHAR *)GlobalLock(hMemW);
+
+		// Use the length of our metadata if possible, but limit it to
+		// the GlobalSize() for safety.
+		maxlen = (int)(GlobalSize(hMemW) / sizeof(WCHAR));
+		if (metadata.ucslen >= 0)
+		{
+		    if (metadata.ucslen > maxlen)
+			str_size = maxlen;
+		    else
+			str_size = metadata.ucslen;
+		}
+		else
+		{
+		    for (str_size = 0; str_size < maxlen; ++str_size)
+			if (hMemWstr[str_size] == NUL)
+			    break;
+		}
+		to_free = str = utf16_to_enc((short_u *)hMemWstr, &str_size);
+		GlobalUnlock(hMemW);
+	    }
+	}
+	// Get the clipboard in the Active codepage.
+	else if (IsClipboardFormatAvailable(CF_TEXT))
+	{
+	    if ((hMem = GetClipboardData(CF_TEXT)) != NULL)
+	    {
+		str = (char_u *)GlobalLock(hMem);
+
+		// The length is either what our metadata says or the strlen().
+		// But limit it to the GlobalSize() for safety.
+		maxlen = (int)GlobalSize(hMem);
+		if (metadata.txtlen >= 0)
+		{
+		    if (metadata.txtlen > maxlen)
+			str_size = maxlen;
+		    else
+			str_size = metadata.txtlen;
+		}
+		else
+		{
+		    for (str_size = 0; str_size < maxlen; ++str_size)
+			if (str[str_size] == NUL)
+			    break;
+		}
+
+		// The text is in the active codepage.  Convert to
+		// 'encoding', going through UTF-16.
+		acp_to_enc(str, str_size, &to_free, &maxlen);
+		if (to_free != NULL)
+		{
+		    str_size = maxlen;
+		    str = to_free;
+		}
+	    }
+	}
+    }
+
+    if (str != NULL && metadata.txtlen != 0)
+    {
+	char_u *temp_clipboard;
+
+	// If the type is not known detect it.
+	if (metadata.type == -1)
+	    metadata.type = MAUTO;
+
+	// Translate <CR><NL> into <NL>.
+	temp_clipboard = crnl_to_nl(str, &str_size);
+	if (temp_clipboard != NULL)
+	{
+	    clip_yank_selection(metadata.type, temp_clipboard, str_size, cbd);
+	    vim_free(temp_clipboard);
+	}
+    }
+
+    // unlock the global object
+    if (hMem != NULL)
+	GlobalUnlock(hMem);
+    if (rawh != NULL)
+	GlobalUnlock(rawh);
+    CloseClipboard();
+    vim_free(to_free);
+}
+
+/*
+ * Send the current selection to the clipboard.
+ */
+    void
+clip_mch_set_selection(Clipboard_T *cbd)
+{
+    char_u		*str = NULL;
+    VimClipType_t	metadata;
+    long_u		txtlen;
+    HGLOBAL		hMemRaw = NULL;
+    HGLOBAL		hMem = NULL;
+    HGLOBAL		hMemVim = NULL;
+    HGLOBAL		hMemW = NULL;
+
+    // If the '*' register isn't already filled in, fill it in now
+    cbd->owned = TRUE;
+    clip_get_selection(cbd);
+    cbd->owned = FALSE;
+
+    // Get the text to be put on the clipboard, with CR-LF.
+    metadata.type = clip_convert_selection(&str, &txtlen, cbd);
+    if (metadata.type < 0)
+	return;
+    metadata.txtlen = (int)txtlen;
+    metadata.ucslen = 0;
+    metadata.rawlen = 0;
+
+    // Always set the raw bytes: 'encoding', NUL and the text.  This is used
+    // when copy/paste from/to Vim with the same 'encoding', so that illegal
+    // bytes can also be copied and no conversion is needed.
+    {
+	LPSTR lpszMemRaw;
+
+	metadata.rawlen = (int)(txtlen + STRLEN(p_enc) + 1);
+	hMemRaw = (LPSTR)GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
+							 metadata.rawlen + 1);
+	lpszMemRaw = (LPSTR)GlobalLock(hMemRaw);
+	if (lpszMemRaw != NULL)
+	{
+	    STRCPY(lpszMemRaw, p_enc);
+	    memcpy(lpszMemRaw + STRLEN(p_enc) + 1, str, txtlen + 1);
+	    GlobalUnlock(hMemRaw);
+	}
+	else
+	    metadata.rawlen = 0;
+    }
+
+    {
+	WCHAR		*out;
+	int		len = metadata.txtlen;
+
+	// Convert the text to UTF-16. This is put on the clipboard as
+	// CF_UNICODETEXT.
+	out = (WCHAR *)enc_to_utf16(str, &len);
+	if (out != NULL)
+	{
+	    WCHAR *lpszMemW;
+
+	    // Convert the text for CF_TEXT to Active codepage. Otherwise it's
+	    // p_enc, which has no relation to the Active codepage.
+	    metadata.txtlen = WideCharToMultiByte(GetACP(), 0, out, len,
+							       NULL, 0, 0, 0);
+	    vim_free(str);
+	    str = alloc(metadata.txtlen == 0 ? 1 : metadata.txtlen);
+	    if (str == NULL)
+	    {
+		vim_free(out);
+		return;		// out of memory
+	    }
+	    WideCharToMultiByte(GetACP(), 0, out, len,
+					   (LPSTR)str, metadata.txtlen, 0, 0);
+
+	    // Allocate memory for the UTF-16 text, add one NUL word to
+	    // terminate the string.
+	    hMemW = (LPSTR)GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
+						   (len + 1) * sizeof(WCHAR));
+	    lpszMemW = (WCHAR *)GlobalLock(hMemW);
+	    if (lpszMemW != NULL)
+	    {
+		memcpy(lpszMemW, out, len * sizeof(WCHAR));
+		lpszMemW[len] = NUL;
+		GlobalUnlock(hMemW);
+	    }
+	    vim_free(out);
+	    metadata.ucslen = len;
+	}
+    }
+
+    // Allocate memory for the text, add one NUL byte to terminate the string.
+    hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, metadata.txtlen + 1);
+    {
+	LPSTR lpszMem = (LPSTR)GlobalLock(hMem);
+
+	if (lpszMem)
+	{
+	    mch_memmove((char_u *)lpszMem, str, metadata.txtlen);
+	    GlobalUnlock(hMem);
+	}
+    }
+
+    // Set up metadata:
+    {
+	VimClipType_t *lpszMemVim = NULL;
+
+	hMemVim = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,
+						       sizeof(VimClipType_t));
+	lpszMemVim = (VimClipType_t *)GlobalLock(hMemVim);
+	memcpy(lpszMemVim, &metadata, sizeof(metadata));
+	GlobalUnlock(hMemVim);
+    }
+
+    /*
+     * Open the clipboard, clear it and put our text on it.
+     * Always set our Vim format.  Put Unicode and plain text on it.
+     *
+     * Don't pass GetActiveWindow() as an argument to OpenClipboard()
+     * because then we can't paste back into the same window for some
+     * reason - webb.
+     */
+    if (vim_open_clipboard())
+    {
+	if (EmptyClipboard())
+	{
+	    SetClipboardData(cbd->format, hMemVim);
+	    hMemVim = 0;
+	    if (hMemW != NULL)
+	    {
+		if (SetClipboardData(CF_UNICODETEXT, hMemW) != NULL)
+		    hMemW = NULL;
+	    }
+	    // Always use CF_TEXT.  On Win98 Notepad won't obtain the
+	    // CF_UNICODETEXT text, only CF_TEXT.
+	    SetClipboardData(CF_TEXT, hMem);
+	    hMem = 0;
+	}
+	CloseClipboard();
+    }
+
+    vim_free(str);
+    // Free any allocations we didn't give to the clipboard:
+    if (hMemRaw)
+	GlobalFree(hMemRaw);
+    if (hMem)
+	GlobalFree(hMem);
+    if (hMemW)
+	GlobalFree(hMemW);
+    if (hMemVim)
+	GlobalFree(hMemVim);
+}
+
+#endif // FEAT_CLIPBOARD
+
+/*
+ * Note: the following two functions are only guaranteed to work when using
+ * valid MS-Windows codepages or when iconv() is available.
+ */
+
+/*
+ * Convert "str" from 'encoding' to UTF-16.
+ * Input in "str" with length "*lenp".  When "lenp" is NULL, use strlen().
+ * Output is returned as an allocated string.  "*lenp" is set to the length of
+ * the result.  A trailing NUL is always added.
+ * Returns NULL when out of memory.
+ */
+    short_u *
+enc_to_utf16(char_u *str, int *lenp)
+{
+    vimconv_T	conv;
+    WCHAR	*ret;
+    char_u	*allocbuf = NULL;
+    int		len_loc;
+    int		length;
+
+    if (lenp == NULL)
+    {
+	len_loc = (int)STRLEN(str) + 1;
+	lenp = &len_loc;
+    }
+
+    if (enc_codepage > 0)
+    {
+	// We can do any CP### -> UTF-16 in one pass, and we can do it
+	// without iconv() (convert_* may need iconv).
+	MultiByteToWideChar_alloc(enc_codepage, 0, (LPCSTR)str, *lenp,
+							       &ret, &length);
+    }
+    else
+    {
+	// Use "latin1" by default, we might be called before we have p_enc
+	// set up.  Convert to utf-8 first, works better with iconv().  Does
+	// nothing if 'encoding' is "utf-8".
+	conv.vc_type = CONV_NONE;
+	if (convert_setup(&conv, p_enc ? p_enc : (char_u *)"latin1",
+						   (char_u *)"utf-8") == FAIL)
+	    return NULL;
+	if (conv.vc_type != CONV_NONE)
+	{
+	    str = allocbuf = string_convert(&conv, str, lenp);
+	    if (str == NULL)
+		return NULL;
+	}
+	convert_setup(&conv, NULL, NULL);
+
+	length = utf8_to_utf16(str, *lenp, NULL, NULL);
+	ret = ALLOC_MULT(WCHAR, length + 1);
+	if (ret != NULL)
+	{
+	    utf8_to_utf16(str, *lenp, (short_u *)ret, NULL);
+	    ret[length] = 0;
+	}
+
+	vim_free(allocbuf);
+    }
+
+    *lenp = length;
+    return (short_u *)ret;
+}
+
+/*
+ * Convert an UTF-16 string to 'encoding'.
+ * Input in "str" with length (counted in wide characters) "*lenp".  When
+ * "lenp" is NULL, use wcslen().
+ * Output is returned as an allocated string.  If "*lenp" is not NULL it is
+ * set to the length of the result.
+ * Returns NULL when out of memory.
+ */
+    char_u *
+utf16_to_enc(short_u *str, int *lenp)
+{
+    vimconv_T	conv;
+    char_u	*utf8_str = NULL, *enc_str = NULL;
+    int		len_loc;
+
+    if (lenp == NULL)
+    {
+	len_loc = (int)wcslen(str) + 1;
+	lenp = &len_loc;
+    }
+
+    if (enc_codepage > 0)
+    {
+	// We can do any UTF-16 -> CP### in one pass.
+	int length;
+
+	WideCharToMultiByte_alloc(enc_codepage, 0, str, *lenp,
+					    (LPSTR *)&enc_str, &length, 0, 0);
+	*lenp = length;
+	return enc_str;
+    }
+
+    // Avoid allocating zero bytes, it generates an error message.
+    utf8_str = alloc(utf16_to_utf8(str, *lenp == 0 ? 1 : *lenp, NULL));
+    if (utf8_str != NULL)
+    {
+	*lenp = utf16_to_utf8(str, *lenp, utf8_str);
+
+	// We might be called before we have p_enc set up.
+	conv.vc_type = CONV_NONE;
+	convert_setup(&conv, (char_u *)"utf-8",
+					    p_enc? p_enc: (char_u *)"latin1");
+	if (conv.vc_type == CONV_NONE)
+	{
+	    // p_enc is utf-8, so we're done.
+	    enc_str = utf8_str;
+	}
+	else
+	{
+	    enc_str = string_convert(&conv, utf8_str, lenp);
+	    vim_free(utf8_str);
+	}
+
+	convert_setup(&conv, NULL, NULL);
+    }
+
+    return enc_str;
+}
+
+/*
+ * Convert from the active codepage to 'encoding'.
+ * Input is "str[str_size]".
+ * The result is in allocated memory: "out[outlen]".  "outlen" includes the
+ * terminating NUL.
+ */
+    void
+acp_to_enc(
+    char_u	*str,
+    int		str_size,
+    char_u	**out,
+    int		*outlen)
+
+{
+    LPWSTR	widestr;
+
+    MultiByteToWideChar_alloc(GetACP(), 0, (LPCSTR)str, str_size,
+							    &widestr, outlen);
+    if (widestr == NULL)
+	return;
+    ++*outlen;	// Include the 0 after the string
+    *out = utf16_to_enc((short_u *)widestr, outlen);
+    vim_free(widestr);
+}
+
+/*
+ * Convert from 'encoding' to the active codepage.
+ * Input is "str[str_size]".
+ * The result is in allocated memory: "out[outlen]".  With terminating NUL.
+ */
+    void
+enc_to_acp(
+    char_u	*str,
+    int		str_size,
+    char_u	**out,
+    int		*outlen)
+
+{
+    LPWSTR	widestr;
+    int		len = str_size;
+
+    widestr = (WCHAR *)enc_to_utf16(str, &len);
+    if (widestr == NULL)
+	return;
+    WideCharToMultiByte_alloc(GetACP(), 0, widestr, len,
+	    (LPSTR *)out, outlen, 0, 0);
+    vim_free(widestr);
+}