thac0/vim
1
0
Fork 0
forked from aniani/vim
Code Activity
Files
184f71cc6868a240dc872ed2852542bbc1d43e28
vim/src/os_mswin.c
Keith Thompson 184f71cc68 patch 9.1.0006: is*() and to*() function may be unsafe 
Problem:  is*() and to*() function may be unsafe
Solution: Add SAFE_* macros and start using those instead
          (Keith Thompson)

Use SAFE_() macros for is*() and to*() functions

The standard is*() and to*() functions declared in <ctype.h> have
undefined behavior for negative arguments other than EOF.  If plain char
is signed, passing an unchecked value from argv for from user input
to one of these functions has undefined behavior.

Solution: Add SAFE_*() macros that cast the argument to unsigned char.

Most implementations behave sanely for negative arguments, and most
character values in practice are non-negative, but it's still best
to avoid undefined behavior.

The change from #13347 has been omitted, as this has already been
separately fixed in commit ac709e2fc0
(v9.0.2054)

fixes: #13332
closes: #13347

Signed-off-by: Keith Thompson <Keith.S.Thompson@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2024-01-04 21:19:04 +01:00

3227 lines
73 KiB
C
Raw Blame History

/* 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.
*/
/*
* os_mswin.c
*
* Routines for Win32.
*/
#include "vim.h"
#include <sys/types.h>
#include <signal.h>
#include <limits.h>
#ifndef PROTO
# include <process.h>
#endif
#undef chdir
#ifdef __GNUC__
# ifndef __MINGW32__
# include <dirent.h>
# endif
#else
# include <direct.h>
#endif
#ifndef PROTO
# if !defined(FEAT_GUI_MSWIN)
# include <shellapi.h>
# endif
# if defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)
# include <dlgs.h>
# include <winspool.h>
# include <commdlg.h>
# endif
#endif // PROTO
#ifdef __MINGW32__
# ifndef FROM_LEFT_1ST_BUTTON_PRESSED
# define FROM_LEFT_1ST_BUTTON_PRESSED 0x0001
# endif
# ifndef RIGHTMOST_BUTTON_PRESSED
# define RIGHTMOST_BUTTON_PRESSED 0x0002
# endif
# ifndef FROM_LEFT_2ND_BUTTON_PRESSED
# define FROM_LEFT_2ND_BUTTON_PRESSED 0x0004
# endif
# ifndef FROM_LEFT_3RD_BUTTON_PRESSED
# define FROM_LEFT_3RD_BUTTON_PRESSED 0x0008
# endif
# ifndef FROM_LEFT_4TH_BUTTON_PRESSED
# define FROM_LEFT_4TH_BUTTON_PRESSED 0x0010
# endif
/*
* EventFlags
*/
# ifndef MOUSE_MOVED
# define MOUSE_MOVED 0x0001
# endif
# ifndef DOUBLE_CLICK
# define DOUBLE_CLICK 0x0002
# endif
#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 BOOL;
typedef int CALLBACK;
typedef int COLORREF;
typedef int CONSOLE_CURSOR_INFO;
typedef int COORD;
typedef int DWORD;
typedef int ENUMLOGFONTW;
typedef int HANDLE;
typedef int HDC;
typedef int HFONT;
typedef int HICON;
typedef int HWND;
typedef int INPUT_RECORD;
typedef int INT_PTR;
typedef int KEY_EVENT_RECORD;
typedef int LOGFONTW;
typedef int LPARAM;
typedef int LPBOOL;
typedef int LPCSTR;
typedef int LPCWSTR;
typedef int LPDWORD;
typedef int LPSTR;
typedef int LPTSTR;
typedef int LPVOID;
typedef int LPWSTR;
typedef int LRESULT;
typedef int MOUSE_EVENT_RECORD;
typedef int NEWTEXTMETRICW;
typedef int PACL;
typedef int PRINTDLGW;
typedef int PSECURITY_DESCRIPTOR;
typedef int PSID;
typedef int SECURITY_INFORMATION;
typedef int SHORT;
typedef int SMALL_RECT;
typedef int TEXTMETRIC;
typedef int UINT;
typedef int WCHAR;
typedef int WNDENUMPROC;
typedef int WORD;
typedef int WPARAM;
typedef void VOID;
#endif
// Record all output and all keyboard & mouse input
// #define MCH_WRITE_DUMP
#ifdef MCH_WRITE_DUMP
FILE* fdDump = NULL;
#endif
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
extern char g_szOrigTitle[];
#endif
#ifdef FEAT_GUI
extern HWND s_hwnd;
#else
static HWND s_hwnd = 0; // console window handle, set by GetConsoleHwnd()
#endif
#ifdef FEAT_JOB_CHANNEL
int WSInitialized = FALSE; // WinSock is initialized
#endif
// Don't generate prototypes here, because some systems do have these
// functions.
#if defined(__GNUC__) && !defined(PROTO)
# ifndef __MINGW32__
int _stricoll(char *a, char *b)
{
// the ANSI-ish correct way is to use strxfrm():
char a_buff[512], b_buff[512]; // file names, so this is enough on Win32
strxfrm(a_buff, a, 512);
strxfrm(b_buff, b, 512);
return strcoll(a_buff, b_buff);
}
char * _fullpath(char *buf, char *fname, int len)
{
LPTSTR toss;
return (char *)GetFullPathName(fname, len, buf, &toss);
}
# endif
# if !defined(__MINGW32__) || (__GNUC__ < 4)
int _chdrive(int drive)
{
char temp [3] = "-:";
temp[0] = drive + 'A' - 1;
return !SetCurrentDirectory(temp);
}
# endif
#endif
#ifndef PROTO
/*
* Save the instance handle of the exe/dll.
*/
void
SaveInst(HINSTANCE hInst)
{
g_hinst = hInst;
}
#endif
#if defined(FEAT_GUI_MSWIN) || defined(PROTO)
/*
* GUI version of mch_exit().
* Shut down and exit with status `r'
* Careful: mch_exit() may be called before mch_init()!
*/
void
mch_exit_g(int r)
{
exiting = TRUE;
display_errors();
ml_close_all(TRUE); // remove all memfiles
# ifdef FEAT_OLE
UninitOLE();
# endif
# ifdef FEAT_JOB_CHANNEL
if (WSInitialized)
{
WSInitialized = FALSE;
WSACleanup();
}
# endif
# ifdef DYNAMIC_GETTEXT
dyn_libintl_end();
# endif
if (gui.in_use)
gui_exit(r);
# ifdef EXITFREE
free_all_mem();
# endif
exit(r);
}
#endif // FEAT_GUI_MSWIN
/*
* Init the tables for toupper() and tolower().
*/
void
mch_early_init(void)
{
int i;
PlatformId();
// Init the tables for toupper() and tolower()
for (i = 0; i < 256; ++i)
toupper_tab[i] = tolower_tab[i] = i;
CharUpperBuff((LPSTR)toupper_tab, 256);
CharLowerBuff((LPSTR)tolower_tab, 256);
}
/*
* Return TRUE if the input comes from a terminal, FALSE otherwise.
*/
int
mch_input_isatty(void)
{
#ifdef FEAT_GUI_MSWIN
# ifdef VIMDLL
if (gui.in_use)
# endif
return TRUE; // GUI always has a tty
#endif
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
if (isatty(read_cmd_fd))
return TRUE;
return FALSE;
#endif
}
/*
* mch_settitle(): set titlebar of our window
*/
void
mch_settitle(
char_u *title,
char_u *icon UNUSED)
{
#ifdef FEAT_GUI_MSWIN
# ifdef VIMDLL
if (gui.in_use)
# endif
{
gui_mch_settitle(title, icon);
return;
}
#endif
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
if (title != NULL)
{
WCHAR *wp = enc_to_utf16(title, NULL);
if (wp == NULL)
return;
SetConsoleTitleW(wp);
vim_free(wp);
return;
}
#endif
}
/*
* Restore the window/icon title.
* which is one of:
* SAVE_RESTORE_TITLE: Just restore title
* SAVE_RESTORE_ICON: Just restore icon (which we don't have)
* SAVE_RESTORE_BOTH: Restore title and icon (which we don't have)
*/
void
mch_restore_title(int which UNUSED)
{
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
# ifdef VIMDLL
if (!gui.in_use)
# endif
SetConsoleTitle(g_szOrigTitle);
#endif
}
/*
* Return TRUE if we can restore the title (we can)
*/
int
mch_can_restore_title(void)
{
return TRUE;
}
/*
* Return TRUE if we can restore the icon title (we can't)
*/
int
mch_can_restore_icon(void)
{
return FALSE;
}
/*
* Get absolute file name into buffer "buf" of length "len" bytes,
* turning all '/'s into '\\'s and getting the correct case of each component
* of the file name. Append a (back)slash to a directory name.
* When 'shellslash' set do it the other way around.
* Return OK or FAIL.
*/
int
mch_FullName(
char_u *fname,
char_u *buf,
int len,
int force UNUSED)
{
int nResult = FAIL;
WCHAR *wname;
WCHAR wbuf[MAX_PATH];
char_u *cname = NULL;
wname = enc_to_utf16(fname, NULL);
if (wname != NULL && _wfullpath(wbuf, wname, MAX_PATH) != NULL)
{
cname = utf16_to_enc((short_u *)wbuf, NULL);
if (cname != NULL)
{
vim_strncpy(buf, cname, len - 1);
nResult = OK;
}
}
vim_free(wname);
vim_free(cname);
#ifdef USE_FNAME_CASE
fname_case(buf, len);
#else
slash_adjust(buf);
#endif
return nResult;
}
/*
* Return TRUE if "fname" does not depend on the current directory.
*/
int
mch_isFullName(char_u *fname)
{
// A name like "d:/foo" and "//server/share" is absolute. "d:foo" is not.
// Another way to check is to use mch_FullName() and see if the result is
// the same as the name or mch_FullName() fails. However, this has quite a
// bit of overhead, so let's not do that.
if (*fname == NUL)
return FALSE;
return ((ASCII_ISALPHA(fname[0]) && fname[1] == ':'
&& (fname[2] == '/' || fname[2] == '\\'))
|| (fname[0] == fname[1] && (fname[0] == '/' || fname[0] == '\\')));
}
/*
* Replace all slashes by backslashes.
* This used to be the other way around, but MS-DOS sometimes has problems
* with slashes (e.g. in a command name). We can't have mixed slashes and
* backslashes, because comparing file names will not work correctly. The
* commands that use a file name should try to avoid the need to type a
* backslash twice.
* When 'shellslash' set do it the other way around.
* When the path looks like a URL leave it unmodified.
*/
void
slash_adjust(char_u *p)
{
if (path_with_url(p))
return;
if (*p == '`')
{
size_t len = STRLEN(p);
// don't replace backslash in backtick quoted strings
if (len > 2 && *(p + len - 1) == '`')
return;
}
while (*p)
{
if (*p == psepcN)
*p = psepc;
MB_PTR_ADV(p);
}
}
// Use 64-bit stat functions.
#undef stat
#undef _stat
#undef _wstat
#undef _fstat
#define stat _stat64
#define _stat _stat64
#define _wstat _wstat64
#define _fstat _fstat64
static int
read_reparse_point(const WCHAR *name, char_u *buf, DWORD *buf_len)
{
HANDLE h;
BOOL ok;
h = CreateFileW(name, FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
NULL);
if (h == INVALID_HANDLE_VALUE)
return FAIL;
ok = DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, NULL, 0, buf, *buf_len,
buf_len, NULL);
CloseHandle(h);
return ok ? OK : FAIL;
}
static int
wstat_symlink_aware(const WCHAR *name, stat_T *stp)
{
#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__MINGW32__)
// Work around for VC12 or earlier (and MinGW). _wstat() can't handle
// symlinks properly.
// VC9 or earlier: _wstat() doesn't support a symlink at all. It retrieves
// status of a symlink itself.
// VC10: _wstat() supports a symlink to a normal file, but it doesn't
// support a symlink to a directory (always returns an error).
// VC11 and VC12: _wstat() doesn't return an error for a symlink to a
// directory, but it doesn't set S_IFDIR flag.
// MinGW: Same as VC9.
int n;
BOOL is_symlink = FALSE;
HANDLE hFind, h;
DWORD attr = 0;
WIN32_FIND_DATAW findDataW;
hFind = FindFirstFileW(name, &findDataW);
if (hFind != INVALID_HANDLE_VALUE)
{
attr = findDataW.dwFileAttributes;
if ((attr & FILE_ATTRIBUTE_REPARSE_POINT)
&& (findDataW.dwReserved0 == IO_REPARSE_TAG_SYMLINK))
is_symlink = TRUE;
FindClose(hFind);
}
if (is_symlink)
{
h = CreateFileW(name, FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING,
(attr & FILE_ATTRIBUTE_DIRECTORY)
? FILE_FLAG_BACKUP_SEMANTICS : 0,
NULL);
if (h != INVALID_HANDLE_VALUE)
{
int fd;
fd = _open_osfhandle((intptr_t)h, _O_RDONLY);
n = _fstat(fd, (struct _stat *)stp);
if ((n == 0) && (attr & FILE_ATTRIBUTE_DIRECTORY))
stp->st_mode = (stp->st_mode & ~S_IFREG) | S_IFDIR;
_close(fd);
return n;
}
}
#endif
return _wstat(name, (struct _stat *)stp);
}
char_u *
resolve_appexeclink(char_u *fname)
{
DWORD attr = 0;
int idx;
WCHAR *p, *end, *wname;
// The buffer size is arbitrarily chosen to be "big enough" (TM), the
// ceiling should be around 16k.
char_u buf[4096];
DWORD buf_len = sizeof(buf);
REPARSE_DATA_BUFFER *rb = (REPARSE_DATA_BUFFER *)buf;
wname = enc_to_utf16(fname, NULL);
if (wname == NULL)
return NULL;
attr = GetFileAttributesW(wname);
if (attr == INVALID_FILE_ATTRIBUTES ||
(attr & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
{
vim_free(wname);
return NULL;
}
// The applinks are similar to symlinks but with a huge difference: they can
// only be executed, any other I/O operation on them is bound to fail with
// ERROR_FILE_NOT_FOUND even though the file exists.
if (read_reparse_point(wname, buf, &buf_len) == FAIL)
{
vim_free(wname);
return NULL;
}
vim_free(wname);
if (rb->ReparseTag != IO_REPARSE_TAG_APPEXECLINK)
return NULL;
// The (undocumented) reparse buffer contains a set of N null-terminated
// Unicode strings, the application path is stored in the third one.
if (rb->AppExecLinkReparseBuffer.StringCount < 3)
return NULL;
p = rb->AppExecLinkReparseBuffer.StringList;
end = p + rb->ReparseDataLength / sizeof(WCHAR);
for (idx = 0; p < end
&& idx < (int)rb->AppExecLinkReparseBuffer.StringCount
&& idx != 2; )
{
if (*p++ == L'\0')
++idx;
}
return utf16_to_enc(p, NULL);
}
/*
* stat() can't handle a trailing '/' or '\', remove it first.
*/
int
vim_stat(const char *name, stat_T *stp)
{
// WinNT and later can use _MAX_PATH wide characters for a pathname, which
// means that the maximum pathname is _MAX_PATH * 3 bytes when 'enc' is
// UTF-8.
char_u buf[_MAX_PATH * 3 + 1];
char_u *p;
WCHAR *wp;
int n;
vim_strncpy((char_u *)buf, (char_u *)name, sizeof(buf) - 1);
p = buf + STRLEN(buf);
if (p > buf)
MB_PTR_BACK(buf, p);
// Remove trailing '\\' except root path.
if (p > buf && (*p == '\\' || *p == '/') && p[-1] != ':')
*p = NUL;
if ((buf[0] == '\\' && buf[1] == '\\') || (buf[0] == '/' && buf[1] == '/'))
{
// UNC root path must be followed by '\\'.
p = vim_strpbrk(buf + 2, (char_u *)"\\/");
if (p != NULL)
{
p = vim_strpbrk(p + 1, (char_u *)"\\/");
if (p == NULL)
STRCAT(buf, "\\");
}
}
wp = enc_to_utf16(buf, NULL);
if (wp == NULL)
return -1;
n = wstat_symlink_aware(wp, stp);
vim_free(wp);
return n;
}
#if (defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)) || defined(PROTO)
void
mch_settmode(tmode_T tmode UNUSED)
{
// nothing to do
}
int
mch_get_shellsize(void)
{
// never used
return OK;
}
void
mch_set_shellsize(void)
{
// never used
}
/*
* Rows and/or Columns has changed.
*/
void
mch_new_shellsize(void)
{
// never used
}
#endif
/*
* We have no job control, so fake it by starting a new shell.
*/
void
mch_suspend(void)
{
suspend_shell();
}
#if defined(USE_MCH_ERRMSG) || defined(PROTO)
# ifdef display_errors
# undef display_errors
# endif
/*
* Display the saved error message(s).
*/
void
display_errors(void)
{
# ifdef FEAT_GUI
char_u *p;
# ifdef VIMDLL
if (gui.in_use || gui.starting)
# endif
{
if (error_ga.ga_data != NULL)
{
// avoid putting up a message box with blanks only
for (p = (char_u *)error_ga.ga_data; *p; ++p)
if (!SAFE_isspace(*p))
{
// Only use a dialog when not using --gui-dialog-file:
// write text to a file.
if (!gui_dialog_log((char_u *)"Errors", p))
(void)gui_mch_dialog(
gui.starting ? VIM_INFO :
VIM_ERROR,
gui.starting ? (char_u *)_("Message") :
(char_u *)_("Error"),
p, (char_u *)_("&Ok"),
1, NULL, FALSE);
break;
}
ga_clear(&error_ga);
}
return;
}
# endif
# if !defined(FEAT_GUI) || defined(VIMDLL)
FlushFileBuffers(GetStdHandle(STD_ERROR_HANDLE));
# endif
}
#endif
/*
* Return TRUE if "p" contain a wildcard that can be expanded by
* dos_expandpath().
*/
int
mch_has_exp_wildcard(char_u *p)
{
for ( ; *p; MB_PTR_ADV(p))
{
if (vim_strchr((char_u *)"?*[", *p) != NULL
|| (*p == '~' && p[1] != NUL))
return TRUE;
}
return FALSE;
}
/*
* Return TRUE if "p" contain a wildcard or a "~1" kind of thing (could be a
* shortened file name).
*/
int
mch_has_wildcard(char_u *p)
{
for ( ; *p; MB_PTR_ADV(p))
{
if (vim_strchr((char_u *)
#ifdef VIM_BACKTICK
"?*$[`"
#else
"?*$["
#endif
, *p) != NULL
|| (*p == '~' && p[1] != NUL))
return TRUE;
}
return FALSE;
}
/*
* The normal _chdir() does not change the default drive. This one does.
* Returning 0 implies success; -1 implies failure.
*/
int
mch_chdir(char *path)
{
WCHAR *p;
int n;
if (path[0] == NUL) // just checking...
return -1;
if (p_verbose >= 5)
{
verbose_enter();
smsg("chdir(%s)", path);
verbose_leave();
}
if (SAFE_isalpha(path[0]) && path[1] == ':') // has a drive name
{
// If we can change to the drive, skip that part of the path. If we
// can't then the current directory may be invalid, try using chdir()
// with the whole path.
if (_chdrive(TOLOWER_ASC(path[0]) - 'a' + 1) == 0)
path += 2;
}
if (*path == NUL) // drive name only
return 0;
p = enc_to_utf16((char_u *)path, NULL);
if (p == NULL)
return -1;
n = _wchdir(p);
vim_free(p);
return n;
}
#if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
/*
* return non-zero if a character is available
*/
int
mch_char_avail(void)
{
// never used
return TRUE;
}
# if defined(FEAT_TERMINAL) || defined(PROTO)
/*
* Check for any pending input or messages.
*/
int
mch_check_messages(void)
{
// TODO: check for messages
return TRUE;
}
# endif
#endif
#if defined(FEAT_LIBCALL) || defined(PROTO)
/*
* Call a DLL routine which takes either a string or int param
* and returns an allocated string.
* Return OK if it worked, FAIL if not.
*/
typedef LPTSTR (*MYSTRPROCSTR)(LPTSTR);
typedef LPTSTR (*MYINTPROCSTR)(int);
typedef int (*MYSTRPROCINT)(LPTSTR);
typedef int (*MYINTPROCINT)(int);
/*
* Check if a pointer points to a valid NUL terminated string.
* Return the length of the string, including terminating NUL.
* Returns 0 for an invalid pointer, 1 for an empty string.
*/
static size_t
check_str_len(char_u *str)
{
SYSTEM_INFO si;
MEMORY_BASIC_INFORMATION mbi;
size_t length = 0;
size_t i;
const char_u *p;
// get page size
GetSystemInfo(&si);
// get memory information
if (!VirtualQuery(str, &mbi, sizeof(mbi)))
return 0;
// pre cast these (typing savers)
long_u dwStr = (long_u)str;
long_u dwBaseAddress = (long_u)mbi.BaseAddress;
// get start address of page that str is on
long_u strPage = dwStr - (dwStr - dwBaseAddress) % si.dwPageSize;
// get length from str to end of page
long_u pageLength = si.dwPageSize - (dwStr - strPage);
for (p = str; !IsBadReadPtr(p, (UINT)pageLength);
p += pageLength, pageLength = si.dwPageSize)
for (i = 0; i < pageLength; ++i, ++length)
if (p[i] == NUL)
return length + 1;
return 0;
}
/*
* Passed to do_in_runtimepath() to load a vim.ico file.
*/
static void
mch_icon_load_cb(char_u *fname, void *cookie)
{
HANDLE *h = (HANDLE *)cookie;
*h = LoadImage(NULL,
(LPSTR)fname,
IMAGE_ICON,
64,
64,
LR_LOADFROMFILE | LR_LOADMAP3DCOLORS);
}
/*
* Try loading an icon file from 'runtimepath'.
*/
int
mch_icon_load(HANDLE *iconp)
{
return do_in_runtimepath((char_u *)"bitmaps/vim.ico",
0, mch_icon_load_cb, iconp);
}
int
mch_libcall(
char_u *libname,
char_u *funcname,
char_u *argstring, // NULL when using a argint
int argint,
char_u **string_result,// NULL when using number_result
int *number_result)
{
HINSTANCE hinstLib;
MYSTRPROCSTR ProcAdd;
MYINTPROCSTR ProcAddI;
char_u *retval_str = NULL;
int retval_int = 0;
size_t len;
BOOL fRunTimeLinkSuccess = FALSE;
// Get a handle to the DLL module.
hinstLib = vimLoadLib((char *)libname);
// If the handle is valid, try to get the function address.
if (hinstLib != NULL)
{
# ifdef HAVE_TRY_EXCEPT
__try
{
# endif
if (argstring != NULL)
{
// Call with string argument
ProcAdd = (MYSTRPROCSTR)GetProcAddress(hinstLib, (LPCSTR)funcname);
if ((fRunTimeLinkSuccess = (ProcAdd != NULL)) != 0)
{
if (string_result == NULL)
retval_int = ((MYSTRPROCINT)ProcAdd)((LPSTR)argstring);
else
retval_str = (char_u *)(ProcAdd)((LPSTR)argstring);
}
}
else
{
// Call with number argument
ProcAddI = (MYINTPROCSTR) GetProcAddress(hinstLib, (LPCSTR)funcname);
if ((fRunTimeLinkSuccess = (ProcAddI != NULL)) != 0)
{
if (string_result == NULL)
retval_int = ((MYINTPROCINT)ProcAddI)(argint);
else
retval_str = (char_u *)(ProcAddI)(argint);
}
}
// Save the string before we free the library.
// Assume that a "1" result is an illegal pointer.
if (string_result == NULL)
*number_result = retval_int;
else if (retval_str != NULL
&& (len = check_str_len(retval_str)) > 0)
{
*string_result = alloc(len);
if (*string_result != NULL)
mch_memmove(*string_result, retval_str, len);
}
# ifdef HAVE_TRY_EXCEPT
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
if (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW)
_resetstkoflw();
fRunTimeLinkSuccess = 0;
}
# endif
// Free the DLL module.
(void)FreeLibrary(hinstLib);
}
if (!fRunTimeLinkSuccess)
{
semsg(_(e_library_call_failed_for_str), funcname);
return FAIL;
}
return OK;
}
#endif
/*
* Debugging helper: expose the MCH_WRITE_DUMP stuff to other modules
*/
void
DumpPutS(const char *psz UNUSED)
{
#ifdef MCH_WRITE_DUMP
if (fdDump)
{
fputs(psz, fdDump);
if (psz[strlen(psz) - 1] != '\n')
fputc('\n', fdDump);
fflush(fdDump);
}
#endif
}
#ifdef _DEBUG
void __cdecl
Trace(
char *pszFormat,
...)
{
CHAR szBuff[2048];
va_list args;
va_start(args, pszFormat);
vsprintf(szBuff, pszFormat, args);
va_end(args);
OutputDebugString(szBuff);
}
#endif //_DEBUG
#if !defined(FEAT_GUI) || defined(VIMDLL) || defined(PROTO)
extern HWND g_hWnd; // This is in os_win32.c.
/*
* Showing the printer dialog is tricky since we have no GUI
* window to parent it. The following routines are needed to
* get the window parenting and Z-order to work properly.
*/
static void
GetConsoleHwnd(void)
{
// Skip if it's already set.
if (s_hwnd != 0)
return;
// Window handle may have been found by init code (Windows NT only)
if (g_hWnd != 0)
{
s_hwnd = g_hWnd;
return;
}
s_hwnd = GetConsoleWindow();
}
/*
* Console implementation of ":winpos".
*/
int
mch_get_winpos(int *x, int *y)
{
RECT rect;
GetConsoleHwnd();
GetWindowRect(s_hwnd, &rect);
*x = rect.left;
*y = rect.top;
return OK;
}
/*
* Console implementation of ":winpos x y".
*/
void
mch_set_winpos(int x, int y)
{
GetConsoleHwnd();
SetWindowPos(s_hwnd, NULL, x, y, 0, 0,
SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
}
#endif
#if (defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)) || defined(PROTO)
//=================================================================
// Win32 printer stuff
static HFONT prt_font_handles[2][2][2];
static PRINTDLGW prt_dlg;
static const int boldface[2] = {FW_REGULAR, FW_BOLD};
static TEXTMETRIC prt_tm;
static int prt_line_height;
static int prt_number_width;
static int prt_left_margin;
static int prt_right_margin;
static int prt_top_margin;
static char_u szAppName[] = TEXT("VIM");
static HWND hDlgPrint;
static int *bUserAbort = NULL;
static char_u *prt_name = NULL;
// Defines which are also in vim.rc.
# define IDC_BOX1 400
# define IDC_PRINTTEXT1 401
# define IDC_PRINTTEXT2 402
# define IDC_PROGRESS 403
static BOOL
vimSetDlgItemText(HWND hDlg, int nIDDlgItem, char_u *s)
{
WCHAR *wp;
BOOL ret;
wp = enc_to_utf16(s, NULL);
if (wp == NULL)
return FALSE;
ret = SetDlgItemTextW(hDlg, nIDDlgItem, wp);
vim_free(wp);
return ret;
}
/*
* Convert BGR to RGB for Windows GDI calls
*/
static COLORREF
swap_me(COLORREF colorref)
{
int temp;
char *ptr = (char *)&colorref;
temp = *(ptr);
*(ptr ) = *(ptr + 2);
*(ptr + 2) = temp;
return colorref;
}
static INT_PTR CALLBACK
PrintDlgProc(
HWND hDlg,
UINT message,
WPARAM wParam UNUSED,
LPARAM lParam UNUSED)
{
# ifdef FEAT_GETTEXT
NONCLIENTMETRICS nm;
static HFONT hfont;
# endif
switch (message)
{
case WM_INITDIALOG:
# ifdef FEAT_GETTEXT
nm.cbSize = sizeof(NONCLIENTMETRICS);
if (SystemParametersInfo(
SPI_GETNONCLIENTMETRICS,
sizeof(NONCLIENTMETRICS),
&nm,
0))
{
char buff[MAX_PATH];
int i;
// Translate the dialog texts
hfont = CreateFontIndirect(&nm.lfMessageFont);
for (i = IDC_PRINTTEXT1; i <= IDC_PROGRESS; i++)
{
SendDlgItemMessage(hDlg, i, WM_SETFONT, (WPARAM)hfont, 1);
if (GetDlgItemText(hDlg,i, buff, sizeof(buff)))
vimSetDlgItemText(hDlg,i, (char_u *)_(buff));
}
SendDlgItemMessage(hDlg, IDCANCEL,
WM_SETFONT, (WPARAM)hfont, 1);
if (GetDlgItemText(hDlg,IDCANCEL, buff, sizeof(buff)))
vimSetDlgItemText(hDlg,IDCANCEL, (char_u *)_(buff));
}
# endif
SetWindowText(hDlg, (LPCSTR)szAppName);
if (prt_name != NULL)
{
vimSetDlgItemText(hDlg, IDC_PRINTTEXT2, (char_u *)prt_name);
VIM_CLEAR(prt_name);
}
EnableMenuItem(GetSystemMenu(hDlg, FALSE), SC_CLOSE, MF_GRAYED);
# if !defined(FEAT_GUI) || defined(VIMDLL)
# ifdef VIMDLL
if (!gui.in_use)
# endif
BringWindowToTop(s_hwnd);
# endif
return TRUE;
case WM_COMMAND:
*bUserAbort = TRUE;
EnableWindow(GetParent(hDlg), TRUE);
DestroyWindow(hDlg);
hDlgPrint = NULL;
# ifdef FEAT_GETTEXT
DeleteObject(hfont);
# endif
return TRUE;
}
return FALSE;
}
static BOOL CALLBACK
AbortProc(HDC hdcPrn UNUSED, int iCode UNUSED)
{
MSG msg;
while (!*bUserAbort && PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
if (!hDlgPrint || !IsDialogMessageW(hDlgPrint, &msg))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
return !*bUserAbort;
}
# if !defined(FEAT_GUI) || defined(VIMDLL)
static UINT_PTR CALLBACK
PrintHookProc(
HWND hDlg, // handle to dialog box
UINT uiMsg, // message identifier
WPARAM wParam UNUSED, // message parameter
LPARAM lParam // message parameter
)
{
HWND hwndOwner;
RECT rc, rcDlg, rcOwner;
PRINTDLGW *pPD;
if (uiMsg != WM_INITDIALOG)
return FALSE;
// Get the owner window and dialog box rectangles.
if ((hwndOwner = GetParent(hDlg)) == NULL)
hwndOwner = GetDesktopWindow();
GetWindowRect(hwndOwner, &rcOwner);
GetWindowRect(hDlg, &rcDlg);
CopyRect(&rc, &rcOwner);
// Offset the owner and dialog box rectangles so that
// right and bottom values represent the width and
// height, and then offset the owner again to discard
// space taken up by the dialog box.
OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top);
OffsetRect(&rc, -rc.left, -rc.top);
OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom);
// The new position is the sum of half the remaining
// space and the owner's original position.
SetWindowPos(hDlg,
HWND_TOP,
rcOwner.left + (rc.right / 2),
rcOwner.top + (rc.bottom / 2),
0, 0, // ignores size arguments
SWP_NOSIZE);
// tackle the printdlg copiesctrl problem
pPD = (PRINTDLGW *)lParam;
pPD->nCopies = (WORD)pPD->lCustData;
SetDlgItemInt( hDlg, edt3, pPD->nCopies, FALSE );
// Bring the window to top
BringWindowToTop(GetParent(hDlg));
SetForegroundWindow(hDlg);
return FALSE;
}
# endif
void
mch_print_cleanup(void)
{
int pifItalic;
int pifBold;
int pifUnderline;
for (pifBold = 0; pifBold <= 1; pifBold++)
for (pifItalic = 0; pifItalic <= 1; pifItalic++)
for (pifUnderline = 0; pifUnderline <= 1; pifUnderline++)
DeleteObject(prt_font_handles[pifBold][pifItalic][pifUnderline]);
if (prt_dlg.hDC != NULL)
DeleteDC(prt_dlg.hDC);
if (!*bUserAbort)
SendMessage(hDlgPrint, WM_COMMAND, 0, 0);
}
static int
to_device_units(int idx, int dpi, int physsize, int offset, int def_number)
{
int ret = 0;
int u;
int nr;
u = prt_get_unit(idx);
if (u == PRT_UNIT_NONE)
{
u = PRT_UNIT_PERC;
nr = def_number;
}
else
nr = printer_opts[idx].number;
switch (u)
{
case PRT_UNIT_PERC:
ret = (physsize * nr) / 100;
break;
case PRT_UNIT_INCH:
ret = (nr * dpi);
break;
case PRT_UNIT_MM:
ret = (nr * 10 * dpi) / 254;
break;
case PRT_UNIT_POINT:
ret = (nr * 10 * dpi) / 720;
break;
}
if (ret < offset)
return 0;
else
return ret - offset;
}
static int
prt_get_cpl(void)
{
int hr;
int phyw;
int dvoff;
int rev_offset;
int dpi;
GetTextMetrics(prt_dlg.hDC, &prt_tm);
prt_line_height = prt_tm.tmHeight + prt_tm.tmExternalLeading;
hr = GetDeviceCaps(prt_dlg.hDC, HORZRES);
phyw = GetDeviceCaps(prt_dlg.hDC, PHYSICALWIDTH);
dvoff = GetDeviceCaps(prt_dlg.hDC, PHYSICALOFFSETX);
dpi = GetDeviceCaps(prt_dlg.hDC, LOGPIXELSX);
rev_offset = phyw - (dvoff + hr);
prt_left_margin = to_device_units(OPT_PRINT_LEFT, dpi, phyw, dvoff, 10);
if (prt_use_number())
{
prt_number_width = PRINT_NUMBER_WIDTH * prt_tm.tmAveCharWidth;
prt_left_margin += prt_number_width;
}
else
prt_number_width = 0;
prt_right_margin = hr - to_device_units(OPT_PRINT_RIGHT, dpi, phyw,
rev_offset, 5);
return (prt_right_margin - prt_left_margin) / prt_tm.tmAveCharWidth;
}
static int
prt_get_lpp(void)
{
int vr;
int phyw;
int dvoff;
int rev_offset;
int bottom_margin;
int dpi;
vr = GetDeviceCaps(prt_dlg.hDC, VERTRES);
phyw = GetDeviceCaps(prt_dlg.hDC, PHYSICALHEIGHT);
dvoff = GetDeviceCaps(prt_dlg.hDC, PHYSICALOFFSETY);
dpi = GetDeviceCaps(prt_dlg.hDC, LOGPIXELSY);
rev_offset = phyw - (dvoff + vr);
prt_top_margin = to_device_units(OPT_PRINT_TOP, dpi, phyw, dvoff, 5);
// adjust top margin if there is a header
prt_top_margin += prt_line_height * prt_header_height();
bottom_margin = vr - to_device_units(OPT_PRINT_BOT, dpi, phyw,
rev_offset, 5);
return (bottom_margin - prt_top_margin) / prt_line_height;
}
int
mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
{
static HGLOBAL stored_dm = NULL;
static HGLOBAL stored_devn = NULL;
static int stored_nCopies = 1;
static int stored_nFlags = 0;
LOGFONTW fLogFont;
int pifItalic;
int pifBold;
int pifUnderline;
DEVMODEW *mem;
DEVNAMES *devname;
int i;
DWORD err;
bUserAbort = &(psettings->user_abort);
CLEAR_FIELD(prt_dlg);
prt_dlg.lStructSize = sizeof(PRINTDLGW);
# if !defined(FEAT_GUI) || defined(VIMDLL)
# ifdef VIMDLL
if (!gui.in_use)
# endif
GetConsoleHwnd(); // get value of s_hwnd
# endif
prt_dlg.hwndOwner = s_hwnd;
prt_dlg.Flags = PD_NOPAGENUMS | PD_NOSELECTION | PD_RETURNDC;
if (!forceit)
{
prt_dlg.hDevMode = stored_dm;
prt_dlg.hDevNames = stored_devn;
prt_dlg.lCustData = stored_nCopies; // work around bug in print dialog
# if !defined(FEAT_GUI) || defined(VIMDLL)
# ifdef VIMDLL
if (!gui.in_use)
# endif
{
/*
* Use hook to prevent console window being sent to back
*/
prt_dlg.lpfnPrintHook = PrintHookProc;
prt_dlg.Flags |= PD_ENABLEPRINTHOOK;
}
# endif
prt_dlg.Flags |= stored_nFlags;
}
/*
* If bang present, return default printer setup with no dialog
* never show dialog if we are running over telnet
*/
if (forceit
# if !defined(FEAT_GUI) || defined(VIMDLL)
# ifdef VIMDLL
|| (!gui.in_use && !term_console)
# else
|| !term_console
# endif
# endif
)
{
prt_dlg.Flags |= PD_RETURNDEFAULT;
/*
* MSDN suggests setting the first parameter to WINSPOOL for
* NT, but NULL appears to work just as well.
*/
if (*p_pdev != NUL)
prt_dlg.hDC = CreateDC(NULL, (LPCSTR)p_pdev, NULL, NULL);
else
{
prt_dlg.Flags |= PD_RETURNDEFAULT;
if (PrintDlgW(&prt_dlg) == 0)
goto init_fail_dlg;
}
}
else if (PrintDlgW(&prt_dlg) == 0)
goto init_fail_dlg;
else
{
/*
* keep the previous driver context
*/
stored_dm = prt_dlg.hDevMode;
stored_devn = prt_dlg.hDevNames;
stored_nFlags = prt_dlg.Flags;
stored_nCopies = prt_dlg.nCopies;
}
if (prt_dlg.hDC == NULL)
{
emsg(_(e_printer_selection_failed));
mch_print_cleanup();
return FALSE;
}
// Not all printer drivers report the support of color (or grey) in the
// same way. Let's set has_color if there appears to be some way to print
// more than B&W.
i = GetDeviceCaps(prt_dlg.hDC, NUMCOLORS);
psettings->has_color = (GetDeviceCaps(prt_dlg.hDC, BITSPIXEL) > 1
|| GetDeviceCaps(prt_dlg.hDC, PLANES) > 1
|| i > 2 || i == -1);
// Ensure all font styles are baseline aligned
SetTextAlign(prt_dlg.hDC, TA_BASELINE|TA_LEFT);
/*
* On some windows systems the nCopies parameter is not
* passed back correctly. It must be retrieved from the
* hDevMode struct.
*/
mem = (DEVMODEW *)GlobalLock(prt_dlg.hDevMode);
if (mem != NULL)
{
if (mem->dmCopies != 1)
stored_nCopies = mem->dmCopies;
if ((mem->dmFields & DM_DUPLEX) && (mem->dmDuplex & ~DMDUP_SIMPLEX))
psettings->duplex = TRUE;
if ((mem->dmFields & DM_COLOR) && (mem->dmColor & DMCOLOR_COLOR))
psettings->has_color = TRUE;
}
GlobalUnlock(prt_dlg.hDevMode);
devname = (DEVNAMES *)GlobalLock(prt_dlg.hDevNames);
if (devname != 0)
{
WCHAR *wprinter_name = (WCHAR *)devname + devname->wDeviceOffset;
WCHAR *wport_name = (WCHAR *)devname + devname->wOutputOffset;
char_u *text = (char_u *)_("to %s on %s");
char_u *printer_name = utf16_to_enc(wprinter_name, NULL);
char_u *port_name = utf16_to_enc(wport_name, NULL);
if (printer_name != NULL && port_name != NULL)
prt_name = alloc(STRLEN(printer_name)
+ STRLEN(port_name) + STRLEN(text));
if (prt_name != NULL)
wsprintf((char *)prt_name, (const char *)text,
printer_name, port_name);
vim_free(printer_name);
vim_free(port_name);
}
GlobalUnlock(prt_dlg.hDevNames);
/*
* Initialise the font according to 'printfont'
*/
CLEAR_FIELD(fLogFont);
if (get_logfont(&fLogFont, p_pfn, prt_dlg.hDC, TRUE) == FAIL)
{
semsg(_(e_unknown_printer_font_str), p_pfn);
mch_print_cleanup();
return FALSE;
}
for (pifBold = 0; pifBold <= 1; pifBold++)
for (pifItalic = 0; pifItalic <= 1; pifItalic++)
for (pifUnderline = 0; pifUnderline <= 1; pifUnderline++)
{
fLogFont.lfWeight = boldface[pifBold];
fLogFont.lfItalic = pifItalic;
fLogFont.lfUnderline = pifUnderline;
prt_font_handles[pifBold][pifItalic][pifUnderline]
= CreateFontIndirectW(&fLogFont);
}
SetBkMode(prt_dlg.hDC, OPAQUE);
SelectObject(prt_dlg.hDC, prt_font_handles[0][0][0]);
/*
* Fill in the settings struct
*/
psettings->chars_per_line = prt_get_cpl();
psettings->lines_per_page = prt_get_lpp();
if (prt_dlg.Flags & PD_USEDEVMODECOPIESANDCOLLATE)
{
psettings->n_collated_copies = (prt_dlg.Flags & PD_COLLATE)
? prt_dlg.nCopies : 1;
psettings->n_uncollated_copies = (prt_dlg.Flags & PD_COLLATE)
? 1 : prt_dlg.nCopies;
if (psettings->n_collated_copies == 0)
psettings->n_collated_copies = 1;
if (psettings->n_uncollated_copies == 0)
psettings->n_uncollated_copies = 1;
}
else
{
psettings->n_collated_copies = 1;
psettings->n_uncollated_copies = 1;
}
psettings->jobname = jobname;
return TRUE;
init_fail_dlg:
err = CommDlgExtendedError();
if (err)
{
char_u *buf;
// I suspect FormatMessage() doesn't work for values returned by
// CommDlgExtendedError(). What does?
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, err, 0, (LPTSTR)(&buf), 0, NULL);
semsg(_(e_print_error_str),
buf == NULL ? (char_u *)_("Unknown") : buf);
LocalFree((LPVOID)(buf));
}
else
msg_clr_eos(); // Maybe canceled
mch_print_cleanup();
return FALSE;
}
int
mch_print_begin(prt_settings_T *psettings)
{
int ret = 0;
char szBuffer[300];
WCHAR *wp;
hDlgPrint = CreateDialog(g_hinst, TEXT("PrintDlgBox"),
prt_dlg.hwndOwner, PrintDlgProc);
SetAbortProc(prt_dlg.hDC, AbortProc);
wsprintf(szBuffer, _("Printing '%s'"), gettail(psettings->jobname));
vimSetDlgItemText(hDlgPrint, IDC_PRINTTEXT1, (char_u *)szBuffer);
wp = enc_to_utf16(psettings->jobname, NULL);
if (wp != NULL)
{
DOCINFOW di;
CLEAR_FIELD(di);
di.cbSize = sizeof(di);
di.lpszDocName = wp;
ret = StartDocW(prt_dlg.hDC, &di);
vim_free(wp);
}
# ifdef FEAT_GUI
// Give focus back to main window (when using MDI).
# ifdef VIMDLL
if (gui.in_use)
# endif
SetFocus(s_hwnd);
# endif
return (ret > 0);
}
void
mch_print_end(prt_settings_T *psettings UNUSED)
{
EndDoc(prt_dlg.hDC);
if (!*bUserAbort)
SendMessage(hDlgPrint, WM_COMMAND, 0, 0);
}
int
mch_print_end_page(void)
{
return (EndPage(prt_dlg.hDC) > 0);
}
int
mch_print_begin_page(char_u *msg)
{
if (msg != NULL)
vimSetDlgItemText(hDlgPrint, IDC_PROGRESS, msg);
return (StartPage(prt_dlg.hDC) > 0);
}
int
mch_print_blank_page(void)
{
return (mch_print_begin_page(NULL) ? (mch_print_end_page()) : FALSE);
}
static int prt_pos_x = 0;
static int prt_pos_y = 0;
void
mch_print_start_line(int margin, int page_line)
{
if (margin)
prt_pos_x = -prt_number_width;
else
prt_pos_x = 0;
prt_pos_y = page_line * prt_line_height
+ prt_tm.tmAscent + prt_tm.tmExternalLeading;
}
int
mch_print_text_out(char_u *p, int len)
{
SIZE sz;
WCHAR *wp;
int wlen = len;
int ret = FALSE;
wp = enc_to_utf16(p, &wlen);
if (wp == NULL)
return FALSE;
TextOutW(prt_dlg.hDC, prt_pos_x + prt_left_margin,
prt_pos_y + prt_top_margin, wp, wlen);
GetTextExtentPoint32W(prt_dlg.hDC, wp, wlen, &sz);
vim_free(wp);
prt_pos_x += (sz.cx - prt_tm.tmOverhang);
// This is wrong when printing spaces for a TAB.
if (p[len] != NUL)
{
wlen = mb_ptr2len(p + len);
wp = enc_to_utf16(p + len, &wlen);
if (wp != NULL)
{
GetTextExtentPoint32W(prt_dlg.hDC, wp, 1, &sz);
ret = (prt_pos_x + prt_left_margin + sz.cx > prt_right_margin);
vim_free(wp);
}
}
return ret;
}
void
mch_print_set_font(int iBold, int iItalic, int iUnderline)
{
SelectObject(prt_dlg.hDC, prt_font_handles[iBold][iItalic][iUnderline]);
}
void
mch_print_set_bg(long_u bgcol)
{
SetBkColor(prt_dlg.hDC, GetNearestColor(prt_dlg.hDC,
swap_me((COLORREF)bgcol)));
/*
* With a white background we can draw characters transparent, which is
* good for italic characters that overlap to the next char cell.
*/
if (bgcol == 0xffffffUL)
SetBkMode(prt_dlg.hDC, TRANSPARENT);
else
SetBkMode(prt_dlg.hDC, OPAQUE);
}
void
mch_print_set_fg(long_u fgcol)
{
SetTextColor(prt_dlg.hDC, GetNearestColor(prt_dlg.hDC,
swap_me((COLORREF)fgcol)));
}
#endif // FEAT_PRINTER && !FEAT_POSTSCRIPT
#if defined(FEAT_SHORTCUT) || defined(PROTO)
# ifndef PROTO
# include <shlobj.h>
# endif
# define is_path_sep(c) ((c) == L'\\' || (c) == L'/')
static int
is_reparse_point_included(LPCWSTR fname)
{
LPCWSTR p = fname, q;
WCHAR buf[MAX_PATH];
DWORD attr;
if (SAFE_isalpha(p[0]) && p[1] == L':' && is_path_sep(p[2]))
p += 3;
else if (is_path_sep(p[0]) && is_path_sep(p[1]))
p += 2;
while (*p != L'\0')
{
q = wcspbrk(p, L"\\/");
if (q == NULL)
p = q = fname + wcslen(fname);
else
p = q + 1;
if (q - fname >= MAX_PATH)
return FALSE;
wcsncpy(buf, fname, q - fname);
buf[q - fname] = L'\0';
attr = GetFileAttributesW(buf);
if (attr != INVALID_FILE_ATTRIBUTES
&& (attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0)
return TRUE;
}
return FALSE;
}
/*
* Return the resolved file path, NULL if "fname" is an AppExecLink reparse
* point, already fully resolved, or it doesn't exists.
*/
char_u *
resolve_reparse_point(char_u *fname)
{
HANDLE h = INVALID_HANDLE_VALUE;
DWORD size;
WCHAR *p, *wp;
char_u *rfname = NULL;
WCHAR *buff = NULL;
p = enc_to_utf16(fname, NULL);
if (p == NULL)
goto fail;
if (!is_reparse_point_included(p))
{
vim_free(p);
goto fail;
}
h = CreateFileW(p, 0, 0, NULL, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, NULL);
vim_free(p);
if (h == INVALID_HANDLE_VALUE)
goto fail;
size = GetFinalPathNameByHandleW(h, NULL, 0, 0);
if (size == 0)
goto fail;
buff = ALLOC_MULT(WCHAR, size);
if (buff == NULL)
goto fail;
if (GetFinalPathNameByHandleW(h, buff, size, 0) == 0)
goto fail;
if (wcsncmp(buff, L"\\\\?\\UNC\\", 8) == 0)
{
buff[6] = L'\\';
wp = buff + 6;
}
else if (wcsncmp(buff, L"\\\\?\\", 4) == 0)
wp = buff + 4;
else
wp = buff;
rfname = utf16_to_enc(wp, NULL);
fail:
if (h != INVALID_HANDLE_VALUE)
CloseHandle(h);
if (buff != NULL)
vim_free(buff);
return rfname;
}
/*
* When "fname" is the name of a shortcut (*.lnk) resolve the file it points
* to and return that name in allocated memory.
* Otherwise NULL is returned.
*/
static char_u *
resolve_shortcut(char_u *fname)
{
HRESULT hr;
IShellLink *psl = NULL;
IPersistFile *ppf = NULL;
OLECHAR wsz[MAX_PATH];
char_u *rfname = NULL;
int len;
IShellLinkW *pslw = NULL;
WIN32_FIND_DATAW ffdw; // we get those free of charge
// Check if the file name ends in ".lnk". Avoid calling
// CoCreateInstance(), it's quite slow.
if (fname == NULL)
return rfname;
len = (int)STRLEN(fname);
if (len <= 4 || STRNICMP(fname + len - 4, ".lnk", 4) != 0)
return rfname;
CoInitialize(NULL);
// create a link manager object and request its interface
hr = CoCreateInstance(
&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkW, (void**)&pslw);
if (hr == S_OK)
{
WCHAR *p = enc_to_utf16(fname, NULL);
if (p != NULL)
{
// Get a pointer to the IPersistFile interface.
hr = pslw->lpVtbl->QueryInterface(
pslw, &IID_IPersistFile, (void**)&ppf);
if (hr != S_OK)
goto shortcut_errorw;
// "load" the name and resolve the link
hr = ppf->lpVtbl->Load(ppf, p, STGM_READ);
if (hr != S_OK)
goto shortcut_errorw;
# if 0 // This makes Vim wait a long time if the target does not exist.
hr = pslw->lpVtbl->Resolve(pslw, NULL, SLR_NO_UI);
if (hr != S_OK)
goto shortcut_errorw;
# endif
// Get the path to the link target.
ZeroMemory(wsz, MAX_PATH * sizeof(WCHAR));
hr = pslw->lpVtbl->GetPath(pslw, wsz, MAX_PATH, &ffdw, 0);
if (hr == S_OK && wsz[0] != NUL)
rfname = utf16_to_enc(wsz, NULL);
shortcut_errorw:
vim_free(p);
}
}
// Release all interface pointers (both belong to the same object)
if (ppf != NULL)
ppf->lpVtbl->Release(ppf);
if (psl != NULL)
psl->lpVtbl->Release(psl);
if (pslw != NULL)
pslw->lpVtbl->Release(pslw);
CoUninitialize();
return rfname;
}
char_u *
mch_resolve_path(char_u *fname, int reparse_point)
{
char_u *path = resolve_shortcut(fname);
if (path == NULL && reparse_point)
path = resolve_reparse_point(fname);
return path;
}
#endif
#if (defined(FEAT_EVAL) && (!defined(FEAT_GUI) || defined(VIMDLL))) || defined(PROTO)
/*
* Bring ourselves to the foreground. Does work if the OS doesn't allow it.
*/
void
win32_set_foreground(void)
{
GetConsoleHwnd(); // get value of s_hwnd
if (s_hwnd != 0)
SetForegroundWindow(s_hwnd);
}
#endif
#if defined(FEAT_CLIENTSERVER) || defined(PROTO)
/*
* Client-server code for Vim
*
* Originally written by Paul Moore
*/
// In order to handle inter-process messages, we need to have a window. But
// the functions in this module can be called before the main GUI window is
// created (and may also be called in the console version, where there is no
// GUI window at all).
//
// So we create a hidden window, and arrange to destroy it on exit.
HWND message_window = 0; // window that's handling messages
# define VIM_CLASSNAME "VIM_MESSAGES"
# define VIM_CLASSNAME_LEN (sizeof(VIM_CLASSNAME) - 1)
// Timeout for sending a message to another Vim instance. Normally this works
// instantly, but it may hang when the other Vim instance is halted.
# define SENDMESSAGE_TIMEOUT (5 * 1000)
// Communication is via WM_COPYDATA messages. The message type is sent in
// the dwData parameter. Types are defined here.
# define COPYDATA_KEYS 0
# define COPYDATA_REPLY 1
# define COPYDATA_EXPR 10
# define COPYDATA_RESULT 11
# define COPYDATA_ERROR_RESULT 12
# define COPYDATA_ENCODING 20
// This is a structure containing a server HWND and its name.
struct server_id
{
HWND hwnd;
char_u *name;
};
// Last received 'encoding' that the client uses.
static char_u *client_enc = NULL;
/*
* Tell the other side what encoding we are using.
* Return -1 if timeout happens. Other errors are ignored.
*/
static int
serverSendEnc(HWND target)
{
COPYDATASTRUCT data;
data.dwData = COPYDATA_ENCODING;
data.cbData = (DWORD)STRLEN(p_enc) + 1;
data.lpData = p_enc;
if (SendMessageTimeout(target, WM_COPYDATA,
(WPARAM)message_window, (LPARAM)&data,
SMTO_ABORTIFHUNG, SENDMESSAGE_TIMEOUT, NULL) == 0)
return -1;
return 0;
}
/*
* Clean up on exit. This destroys the hidden message window.
*/
static void
CleanUpMessaging(void)
{
if (message_window == 0)
return;
DestroyWindow(message_window);
message_window = 0;
}
static int save_reply(HWND server, char_u *reply, int expr);
/*
* The window procedure for the hidden message window.
* It handles callback messages and notifications from servers.
* In order to process these messages, it is necessary to run a
* message loop. Code which may run before the main message loop
* is started (in the GUI) is careful to pump messages when it needs
* to. Features which require message delivery during normal use will
* not work in the console version - this basically means those
* features which allow Vim to act as a server, rather than a client.
*/
static LRESULT CALLBACK
Messaging_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_COPYDATA)
{
// This is a message from another Vim. The dwData member of the
// COPYDATASTRUCT determines the type of message:
// COPYDATA_ENCODING:
// The encoding that the client uses. Following messages will
// use this encoding, convert if needed.
// COPYDATA_KEYS:
// A key sequence. We are a server, and a client wants these keys
// adding to the input queue.
// COPYDATA_REPLY:
// A reply. We are a client, and a server has sent this message
// in response to a request. (server2client())
// COPYDATA_EXPR:
// An expression. We are a server, and a client wants us to
// evaluate this expression.
// COPYDATA_RESULT:
// A reply. We are a client, and a server has sent this message
// in response to a COPYDATA_EXPR.
// COPYDATA_ERROR_RESULT:
// A reply. We are a client, and a server has sent this message
// in response to a COPYDATA_EXPR that failed to evaluate.
COPYDATASTRUCT *data = (COPYDATASTRUCT*)lParam;
HWND sender = (HWND)wParam;
COPYDATASTRUCT reply;
char_u *res;
int retval;
DWORD_PTR dwret = 0;
char_u *str;
char_u *tofree;
switch (data->dwData)
{
case COPYDATA_ENCODING:
// Remember the encoding that the client uses.
vim_free(client_enc);
client_enc = enc_canonize((char_u *)data->lpData);
return 1;
case COPYDATA_KEYS:
// Remember who sent this, for <client>
clientWindow = sender;
// Add the received keys to the input buffer. The loop waiting
// for the user to do something should check the input buffer.
str = serverConvert(client_enc, (char_u *)data->lpData, &tofree);
server_to_input_buf(str);
vim_free(tofree);
# ifdef FEAT_GUI
// Wake up the main GUI loop.
# ifdef VIMDLL
if (gui.in_use)
# endif
if (s_hwnd != 0)
PostMessage(s_hwnd, WM_NULL, 0, 0);
# endif
return 1;
case COPYDATA_EXPR:
// Remember who sent this, for <client>
clientWindow = sender;
str = serverConvert(client_enc, (char_u *)data->lpData, &tofree);
res = eval_client_expr_to_string(str);
if (res == NULL)
{
char *err = _(e_invalid_expression_received);
size_t len = STRLEN(str) + STRLEN(err) + 5;
res = alloc(len);
if (res != NULL)
vim_snprintf((char *)res, len, "%s: \"%s\"", err, str);
reply.dwData = COPYDATA_ERROR_RESULT;
}
else
reply.dwData = COPYDATA_RESULT;
reply.lpData = res;
reply.cbData = (DWORD)STRLEN(res) + 1;
if (serverSendEnc(sender) < 0)
retval = -1;
else
{
if (SendMessageTimeout(sender, WM_COPYDATA,
(WPARAM)message_window, (LPARAM)&reply,
SMTO_ABORTIFHUNG, SENDMESSAGE_TIMEOUT, &dwret) == 0)
retval = -1;
else
retval = (int)dwret;
}
vim_free(tofree);
vim_free(res);
return retval;
case COPYDATA_REPLY:
case COPYDATA_RESULT:
case COPYDATA_ERROR_RESULT:
if (data->lpData != NULL)
{
str = serverConvert(client_enc, (char_u *)data->lpData,
&tofree);
if (tofree == NULL)
str = vim_strsave(str);
if (save_reply(sender, str,
(data->dwData == COPYDATA_REPLY ? 0 :
(data->dwData == COPYDATA_RESULT ? 1 :
2))) == FAIL)
vim_free(str);
else if (data->dwData == COPYDATA_REPLY)
{
char_u winstr[30];
sprintf((char *)winstr, PRINTF_HEX_LONG_U, (long_u)sender);
apply_autocmds(EVENT_REMOTEREPLY, winstr, str,
TRUE, curbuf);
}
}
return 1;
}
return 0;
}
else if (msg == WM_ACTIVATE && wParam == WA_ACTIVE)
{
// When the message window is activated (brought to the foreground),
// this actually applies to the text window.
# if !defined(FEAT_GUI) || defined(VIMDLL)
# ifdef VIMDLL
if (!gui.in_use)
# endif
GetConsoleHwnd(); // get value of s_hwnd
# endif
if (s_hwnd != 0)
{
SetForegroundWindow(s_hwnd);
return 0;
}
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
/*
* Initialise the message handling process. This involves creating a window
* to handle messages - the window will not be visible.
*/
void
serverInitMessaging(void)
{
WNDCLASS wndclass;
// Clean up on exit
atexit(CleanUpMessaging);
// Register a window class - we only really care
// about the window procedure
wndclass.style = 0;
wndclass.lpfnWndProc = Messaging_WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = g_hinst;
wndclass.hIcon = NULL;
wndclass.hCursor = NULL;
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = VIM_CLASSNAME;
RegisterClass(&wndclass);
// Create the message window. It will be hidden, so the details don't
// matter. Don't use WS_OVERLAPPEDWINDOW, it will make a shortcut remove
// focus from gvim.
message_window = CreateWindow(VIM_CLASSNAME, "",
WS_POPUPWINDOW | WS_CAPTION,
CW_USEDEFAULT, CW_USEDEFAULT,
100, 100, NULL, NULL,
g_hinst, NULL);
}
// Used by serverSendToVim() to find an alternate server name.
static char_u *altname_buf_ptr = NULL;
/*
* Get the title of the window "hwnd", which is the Vim server name, in
* "name[namelen]" and return the length.
* Returns zero if window "hwnd" is not a Vim server.
*/
static int
getVimServerName(HWND hwnd, char *name, int namelen)
{
int len;
char buffer[VIM_CLASSNAME_LEN + 1];
// Ignore windows which aren't Vim message windows
len = GetClassName(hwnd, buffer, sizeof(buffer));
if (len != VIM_CLASSNAME_LEN || STRCMP(buffer, VIM_CLASSNAME) != 0)
return 0;
// Get the title of the window
return GetWindowText(hwnd, name, namelen);
}
static BOOL CALLBACK
enumWindowsGetServer(HWND hwnd, LPARAM lparam)
{
struct server_id *id = (struct server_id *)lparam;
char server[MAX_PATH];
// Get the title of the window
if (getVimServerName(hwnd, server, sizeof(server)) == 0)
return TRUE;
// If this is the server we're looking for, return its HWND
if (STRICMP(server, id->name) == 0)
{
id->hwnd = hwnd;
return FALSE;
}
// If we are looking for an alternate server, remember this name.
if (altname_buf_ptr != NULL
&& STRNICMP(server, id->name, STRLEN(id->name)) == 0
&& vim_isdigit(server[STRLEN(id->name)]))
{
STRCPY(altname_buf_ptr, server);
altname_buf_ptr = NULL; // don't use another name
}
// Otherwise, keep looking
return TRUE;
}
static BOOL CALLBACK
enumWindowsGetNames(HWND hwnd, LPARAM lparam)
{
garray_T *ga = (garray_T *)lparam;
char server[MAX_PATH];
// Get the title of the window
if (getVimServerName(hwnd, server, sizeof(server)) == 0)
return TRUE;
// Add the name to the list
ga_concat(ga, (char_u *)server);
ga_concat(ga, (char_u *)"\n");
return TRUE;
}
struct enum_windows_s
{
WNDENUMPROC lpEnumFunc;
LPARAM lParam;
};
static BOOL CALLBACK
enum_windows_child(HWND hwnd, LPARAM lParam)
{
struct enum_windows_s *ew = (struct enum_windows_s *)lParam;
return (ew->lpEnumFunc)(hwnd, ew->lParam);
}
static BOOL CALLBACK
enum_windows_toplevel(HWND hwnd, LPARAM lParam)
{
struct enum_windows_s *ew = (struct enum_windows_s *)lParam;
if ((ew->lpEnumFunc)(hwnd, ew->lParam))
return TRUE;
return EnumChildWindows(hwnd, enum_windows_child, lParam);
}
/*
* Enumerate all windows including children.
*/
static BOOL
enum_windows(WNDENUMPROC lpEnumFunc, LPARAM lParam)
{
struct enum_windows_s ew;
ew.lpEnumFunc = lpEnumFunc;
ew.lParam = lParam;
return EnumWindows(enum_windows_toplevel, (LPARAM)&ew);
}
static HWND
findServer(char_u *name)
{
struct server_id id;
id.name = name;
id.hwnd = 0;
enum_windows(enumWindowsGetServer, (LPARAM)(&id));
return id.hwnd;
}
void
serverSetName(char_u *name)
{
char_u *ok_name;
HWND hwnd = 0;
int i = 0;
char_u *p;
// Leave enough space for a 9-digit suffix to ensure uniqueness!
ok_name = alloc(STRLEN(name) + 10);
STRCPY(ok_name, name);
p = ok_name + STRLEN(name);
for (;;)
{
// This is inefficient - we're doing an EnumWindows loop for each
// possible name. It would be better to grab all names in one go,
// and scan the list each time...
hwnd = findServer(ok_name);
if (hwnd == 0)
break;
++i;
if (i >= 1000)
break;
sprintf((char *)p, "%d", i);
}
if (hwnd != 0)
vim_free(ok_name);
else
{
// Remember the name
serverName = ok_name;
need_maketitle = TRUE; // update Vim window title later
// Update the message window title
SetWindowText(message_window, (LPCSTR)ok_name);
# ifdef FEAT_EVAL
// Set the servername variable
set_vim_var_string(VV_SEND_SERVER, serverName, -1);
# endif
}
}
char_u *
serverGetVimNames(void)
{
garray_T ga;
ga_init2(&ga, 1, 100);
enum_windows(enumWindowsGetNames, (LPARAM)(&ga));
ga_append(&ga, NUL);
return ga.ga_data;
}
int
serverSendReply(
char_u *name, // Where to send.
char_u *reply) // What to send.
{
HWND target;
COPYDATASTRUCT data;
long_u n = 0;
DWORD_PTR dwret = 0;
// The "name" argument is a magic cookie obtained from expand("<client>").
// It should be of the form 0xXXXXX - i.e. a C hex literal, which is the
// value of the client's message window HWND.
sscanf((char *)name, SCANF_HEX_LONG_U, &n);
if (n == 0)
return -1;
target = (HWND)n;
if (!IsWindow(target))
return -1;
data.dwData = COPYDATA_REPLY;
data.cbData = (DWORD)STRLEN(reply) + 1;
data.lpData = reply;
if (serverSendEnc(target) < 0)
return -1;
if (SendMessageTimeout(target, WM_COPYDATA,
(WPARAM)message_window, (LPARAM)&data,
SMTO_ABORTIFHUNG, SENDMESSAGE_TIMEOUT, &dwret) == 0)
return -1;
return dwret ? 0 : -1;
}
int
serverSendToVim(
char_u *name, // Where to send.
char_u *cmd, // What to send.
char_u **result, // Result of eval'ed expression
void *ptarget, // HWND of server
int asExpr, // Expression or keys?
int timeout, // timeout in seconds or zero
int silent) // don't complain about no server
{
HWND target;
COPYDATASTRUCT data;
char_u *retval = NULL;
int retcode = 0;
DWORD_PTR dwret = 0;
char_u altname_buf[MAX_PATH];
// Execute locally if no display or target is ourselves
if (serverName != NULL && STRICMP(name, serverName) == 0)
return sendToLocalVim(cmd, asExpr, result);
// If the server name does not end in a digit then we look for an
// alternate name. e.g. when "name" is GVIM then we may find GVIM2.
if (STRLEN(name) > 1 && !vim_isdigit(name[STRLEN(name) - 1]))
altname_buf_ptr = altname_buf;
altname_buf[0] = NUL;
target = findServer(name);
altname_buf_ptr = NULL;
if (target == 0 && altname_buf[0] != NUL)
// Use another server name we found.
target = findServer(altname_buf);
if (target == 0)
{
if (!silent)
semsg(_(e_no_registered_server_named_str), name);
return -1;
}
if (ptarget)
*(HWND *)ptarget = target;
data.dwData = asExpr ? COPYDATA_EXPR : COPYDATA_KEYS;
data.cbData = (DWORD)STRLEN(cmd) + 1;
data.lpData = cmd;
if (serverSendEnc(target) < 0)
return -1;
if (SendMessageTimeout(target, WM_COPYDATA,
(WPARAM)message_window, (LPARAM)&data,
SMTO_ABORTIFHUNG, SENDMESSAGE_TIMEOUT, &dwret) == 0)
return -1;
if (dwret == 0)
return -1;
if (asExpr)
retval = serverGetReply(target, &retcode, TRUE, TRUE, timeout);
if (result == NULL)
vim_free(retval);
else
*result = retval; // Caller assumes responsibility for freeing
return retcode;
}
/*
* Bring the server to the foreground.
*/
void
serverForeground(char_u *name)
{
HWND target = findServer(name);
if (target != 0)
SetForegroundWindow(target);
}
// Replies from server need to be stored until the client picks them up via
// remote_read(). So we maintain a list of server-id/reply pairs.
// Note that there could be multiple replies from one server pending if the
// client is slow picking them up.
// We just store the replies in a simple list. When we remove an entry, we
// move list entries down to fill the gap.
// The server ID is simply the HWND.
typedef struct
{
HWND server; // server window
char_u *reply; // reply string
int expr_result; // 0 for REPLY, 1 for RESULT 2 for error
} reply_T;
static garray_T reply_list = {0, 0, sizeof(reply_T), 5, 0};
# define REPLY_ITEM(i) ((reply_T *)(reply_list.ga_data) + (i))
# define REPLY_COUNT (reply_list.ga_len)
// Flag which is used to wait for a reply
static int reply_received = 0;
/*
* Store a reply. "reply" must be allocated memory (or NULL).
*/
static int
save_reply(HWND server, char_u *reply, int expr)
{
reply_T *rep;
if (ga_grow(&reply_list, 1) == FAIL)
return FAIL;
rep = REPLY_ITEM(REPLY_COUNT);
rep->server = server;
rep->reply = reply;
rep->expr_result = expr;
if (rep->reply == NULL)
return FAIL;
++REPLY_COUNT;
reply_received = 1;
return OK;
}
/*
* Get a reply from server "server".
* When "expr_res" is non NULL, get the result of an expression, otherwise a
* server2client() message.
* When non NULL, point to return code. 0 => OK, -1 => ERROR
* If "remove" is TRUE, consume the message, the caller must free it then.
* if "wait" is TRUE block until a message arrives (or the server exits).
*/
char_u *
serverGetReply(HWND server, int *expr_res, int remove, int wait, int timeout)
{
int i;
char_u *reply;
reply_T *rep;
int did_process = FALSE;
time_t start;
time_t now;
// When waiting, loop until the message waiting for is received.
time(&start);
for (;;)
{
// Reset this here, in case a message arrives while we are going
// through the already received messages.
reply_received = 0;
for (i = 0; i < REPLY_COUNT; ++i)
{
rep = REPLY_ITEM(i);
if (rep->server == server
&& ((rep->expr_result != 0) == (expr_res != NULL)))
{
// Save the values we've found for later
reply = rep->reply;
if (expr_res != NULL)
*expr_res = rep->expr_result == 1 ? 0 : -1;
if (remove)
{
// Move the rest of the list down to fill the gap
mch_memmove(rep, rep + 1,
(REPLY_COUNT - i - 1) * sizeof(reply_T));
--REPLY_COUNT;
}
// Return the reply to the caller, who takes on responsibility
// for freeing it if "remove" is TRUE.
return reply;
}
}
// If we got here, we didn't find a reply. Return immediately if the
// "wait" parameter isn't set.
if (!wait)
{
// Process pending messages once. Without this, looping on
// remote_peek() would never get the reply.
if (!did_process)
{
did_process = TRUE;
serverProcessPendingMessages();
continue;
}
break;
}
// We need to wait for a reply. Enter a message loop until the
// "reply_received" flag gets set.
// Loop until we receive a reply
while (reply_received == 0)
{
# ifdef FEAT_TIMERS
// TODO: use the return value to decide how long to wait.
check_due_timer();
# endif
time(&now);
if (timeout > 0 && (now - start) >= timeout)
break;
// Wait for a SendMessage() call to us. This could be the reply
// we are waiting for. Use a timeout of a second, to catch the
// situation that the server died unexpectedly.
MsgWaitForMultipleObjects(0, NULL, TRUE, 1000, QS_ALLINPUT);
// If the server has died, give up
if (!IsWindow(server))
return NULL;
serverProcessPendingMessages();
}
}
return NULL;
}
/*
* Process any messages in the Windows message queue.
*/
void
serverProcessPendingMessages(void)
{
MSG msg;
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
#endif // FEAT_CLIENTSERVER
#if defined(FEAT_GUI) || (defined(FEAT_PRINTER) && !defined(FEAT_POSTSCRIPT)) \
|| defined(PROTO)
struct charset_pair
{
char *name;
BYTE charset;
};
static struct charset_pair
charset_pairs[] =
{
{"ANSI", ANSI_CHARSET},
{"CHINESEBIG5", CHINESEBIG5_CHARSET},
{"DEFAULT", DEFAULT_CHARSET},
{"HANGEUL", HANGEUL_CHARSET},
{"OEM", OEM_CHARSET},
{"SHIFTJIS", SHIFTJIS_CHARSET},
{"SYMBOL", SYMBOL_CHARSET},
{"ARABIC", ARABIC_CHARSET},
{"BALTIC", BALTIC_CHARSET},
{"EASTEUROPE", EASTEUROPE_CHARSET},
{"GB2312", GB2312_CHARSET},
{"GREEK", GREEK_CHARSET},
{"HEBREW", HEBREW_CHARSET},
{"JOHAB", JOHAB_CHARSET},
{"MAC", MAC_CHARSET},
{"RUSSIAN", RUSSIAN_CHARSET},
{"THAI", THAI_CHARSET},
{"TURKISH", TURKISH_CHARSET},
# ifdef VIETNAMESE_CHARSET
{"VIETNAMESE", VIETNAMESE_CHARSET},
# endif
{NULL, 0}
};
struct quality_pair
{
char *name;
DWORD quality;
};
static struct quality_pair
quality_pairs[] = {
# ifdef CLEARTYPE_QUALITY
{"CLEARTYPE", CLEARTYPE_QUALITY},
# endif
# ifdef ANTIALIASED_QUALITY
{"ANTIALIASED", ANTIALIASED_QUALITY},
# endif
# ifdef NONANTIALIASED_QUALITY
{"NONANTIALIASED", NONANTIALIASED_QUALITY},
# endif
# ifdef PROOF_QUALITY
{"PROOF", PROOF_QUALITY},
# endif
# ifdef DRAFT_QUALITY
{"DRAFT", DRAFT_QUALITY},
# endif
{"DEFAULT", DEFAULT_QUALITY},
{NULL, 0}
};
/*
* Convert a charset ID to a name.
* Return NULL when not recognized.
*/
char *
charset_id2name(int id)
{
struct charset_pair *cp;
for (cp = charset_pairs; cp->name != NULL; ++cp)
if ((BYTE)id == cp->charset)
break;
return cp->name;
}
/*
* Convert a quality ID to a name.
* Return NULL when not recognized.
*/
char *
quality_id2name(DWORD id)
{
struct quality_pair *qp;
for (qp = quality_pairs; qp->name != NULL; ++qp)
if (id == qp->quality)
break;
return qp->name;
}
static const LOGFONTW s_lfDefault =
{
-12, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, FIXED_PITCH | FF_DONTCARE,
L"Fixedsys" // see _ReadVimIni
};
// Initialise the "current height" to -12 (same as s_lfDefault) just
// in case the user specifies a font in "guifont" with no size before a font
// with an explicit size has been set. This defaults the size to this value
// (-12 equates to roughly 9pt).
int current_font_height = -12; // also used in gui_w32.c
/*
* Convert a string representing a point size into pixels. The string should
* be a positive decimal number, with an optional decimal point (eg, "12", or
* "10.5"). The pixel value is returned, and a pointer to the next unconverted
* character is stored in *end. The flag "vertical" says whether this
* calculation is for a vertical (height) size or a horizontal (width) one.
*/
static int
points_to_pixels(WCHAR *str, WCHAR **end, int vertical, long_i pprinter_dc)
{
int pixels;
int points = 0;
int divisor = 0;
HWND hwnd = (HWND)0;
HDC hdc;
HDC printer_dc = (HDC)pprinter_dc;
while (*str != NUL)
{
if (*str == L'.' && divisor == 0)
{
// Start keeping a divisor, for later
divisor = 1;
}
else
{
if (!VIM_ISDIGIT(*str))
break;
points *= 10;
points += *str - L'0';
divisor *= 10;
}
++str;
}
if (divisor == 0)
divisor = 1;
if (printer_dc == NULL)
{
hwnd = GetDesktopWindow();
hdc = GetWindowDC(hwnd);
}
else
hdc = printer_dc;
pixels = MulDiv(points,
GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX),
72 * divisor);
if (printer_dc == NULL)
ReleaseDC(hwnd, hdc);
*end = str;
return pixels;
}
/*
* Convert pixel into point size. This is a reverse of points_to_pixels.
*/
static double
pixels_to_points(int pixels, int vertical, long_i pprinter_dc)
{
double points = 0;
HWND hwnd = (HWND)0;
HDC hdc;
HDC printer_dc = (HDC)pprinter_dc;
if (printer_dc == NULL)
{
hwnd = GetDesktopWindow();
hdc = GetWindowDC(hwnd);
}
else
hdc = printer_dc;
points = pixels * 72.0 / GetDeviceCaps(hdc, vertical ? LOGPIXELSY : LOGPIXELSX);
if (printer_dc == NULL)
ReleaseDC(hwnd, hdc);
return points;
}
static int CALLBACK
font_enumproc(
ENUMLOGFONTW *elf,
NEWTEXTMETRICW *ntm UNUSED,
DWORD type UNUSED,
LPARAM lparam)
{
// Return value:
// 0 = terminate now (monospace & ANSI)
// 1 = continue, still no luck...
// 2 = continue, but we have an acceptable LOGFONTW
// (monospace, not ANSI)
// We use these values, as EnumFontFamilies returns 1 if the
// callback function is never called. So, we check the return as
// 0 = perfect, 2 = OK, 1 = no good...
// It's not pretty, but it works!
LOGFONTW *lf = (LOGFONTW *)(lparam);
# ifndef FEAT_PROPORTIONAL_FONTS
// Ignore non-monospace fonts without further ado
if ((ntm->tmPitchAndFamily & 1) != 0)
return 1;
# endif
// Remember this LOGFONTW as a "possible"
*lf = elf->elfLogFont;
// Terminate the scan as soon as we find an ANSI font
if (lf->lfCharSet == ANSI_CHARSET
|| lf->lfCharSet == OEM_CHARSET
|| lf->lfCharSet == DEFAULT_CHARSET)
return 0;
// Continue the scan - we have a non-ANSI font
return 2;
}
static int
init_logfont(LOGFONTW *lf)
{
int n;
HWND hwnd = GetDesktopWindow();
HDC hdc = GetWindowDC(hwnd);
n = EnumFontFamiliesW(hdc,
lf->lfFaceName,
(FONTENUMPROCW)font_enumproc,
(LPARAM)lf);
ReleaseDC(hwnd, hdc);
// If we couldn't find a usable font, return failure
if (n == 1)
return FAIL;
// Tidy up the rest of the LOGFONTW structure. We set to a basic
// font - get_logfont() sets bold, italic, etc based on the user's
// input.
lf->lfHeight = current_font_height;
lf->lfWidth = 0;
lf->lfItalic = FALSE;
lf->lfUnderline = FALSE;
lf->lfStrikeOut = FALSE;
lf->lfWeight = FW_NORMAL;
// Return success
return OK;
}
/*
* Call back for EnumFontFamiliesW in expand_font_enumproc.
*
*/
static int CALLBACK
expand_font_enumproc(
ENUMLOGFONTW *elf,
NEWTEXTMETRICW *ntm UNUSED,
DWORD type UNUSED,
LPARAM lparam)
{
LOGFONTW *lf = (LOGFONTW*)elf;
# ifndef FEAT_PROPORTIONAL_FONTS
// Ignore non-monospace fonts without further ado
if ((ntm->tmPitchAndFamily & 1) != 0)
return 1;
# endif
// Filter only on ANSI. Otherwise will see a lot of random fonts that we
// usually don't want.
if (lf->lfCharSet != ANSI_CHARSET)
return 1;
int (*add_match)(char_u *) = (int (*)(char_u *))lparam;
WCHAR *faceNameW = lf->lfFaceName;
char_u *faceName = utf16_to_enc(faceNameW, NULL);
if (!faceName)
return 0;
add_match(faceName);
vim_free(faceName);
return 1;
}
/*
* Cmdline expansion for setting 'guifont'. Will enumerate through all
* monospace fonts for completion. If used after ':', will expand to possible
* font configuration options like font sizes.
*
* This function has "gui" in its name because in some platforms (GTK) font
* handling is done by the GUI code, whereas in Windows it's part of the
* platform code.
*/
void
gui_mch_expand_font(optexpand_T *args, void *param UNUSED, int (*add_match)(char_u *val))
{
expand_T *xp = args->oe_xp;
if (xp->xp_pattern > args->oe_set_arg && *(xp->xp_pattern-1) == ':')
{
char buf[30];
// Always fill in with the current font size as first option for
// convenience. We simply round to the closest integer for simplicity.
int font_height = (int)round(
pixels_to_points(-current_font_height, TRUE, (long_i)NULL));
vim_snprintf(buf, ARRAY_LENGTH(buf), "h%d", font_height);
add_match((char_u *)buf);
// Note: Keep this in sync with get_logfont(). Don't include 'c' and
// 'q' as we fill in all the values below.
static char *(p_gfn_win_opt_values[]) = {
"h" , "w" , "W" , "b" , "i" , "u" , "s"};
for (size_t i = 0; i < ARRAY_LENGTH(p_gfn_win_opt_values); i++)
add_match((char_u *)p_gfn_win_opt_values[i]);
struct charset_pair *cp;
for (cp = charset_pairs; cp->name != NULL; ++cp)
{
vim_snprintf(buf, ARRAY_LENGTH(buf), "c%s", cp->name);
add_match((char_u *)buf);
}
struct quality_pair *qp;
for (qp = quality_pairs; qp->name != NULL; ++qp)
{
vim_snprintf(buf, ARRAY_LENGTH(buf), "q%s", qp->name);
add_match((char_u *)buf);
}
return;
}
HWND hwnd = GetDesktopWindow();
HDC hdc = GetWindowDC(hwnd);
EnumFontFamiliesW(hdc,
NULL,
(FONTENUMPROCW)expand_font_enumproc,
(LPARAM)add_match);
ReleaseDC(hwnd, hdc);
}
/*
* Compare a UTF-16 string and an ASCII string literally.
* Only works all the code points are inside ASCII range.
*/
static int
utf16ascncmp(const WCHAR *w, const char *p, size_t n)
{
size_t i;
for (i = 0; i < n; i++)
{
if (w[i] == 0 || w[i] != p[i])
return w[i] - p[i];
}
return 0;
}
/*
* Get font info from "name" into logfont "lf".
* Return OK for a valid name, FAIL otherwise.
*/
int
get_logfont(
LOGFONTW *lf,
char_u *name,
HDC printer_dc,
int verbose)
{
WCHAR *p;
int i;
int ret = FAIL;
static LOGFONTW *lastlf = NULL;
WCHAR *wname;
*lf = s_lfDefault;
if (name == NULL)
return OK;
wname = enc_to_utf16(name, NULL);
if (wname == NULL)
return FAIL;
if (wcscmp(wname, L"*") == 0)
{
# if defined(FEAT_GUI_MSWIN)
CHOOSEFONTW cf;
// if name is "*", bring up std font dialog:
CLEAR_FIELD(cf);
cf.lStructSize = sizeof(cf);
cf.hwndOwner = s_hwnd;
cf.Flags = CF_SCREENFONTS | CF_FIXEDPITCHONLY | CF_INITTOLOGFONTSTRUCT;
if (lastlf != NULL)
*lf = *lastlf;
cf.lpLogFont = lf;
cf.nFontType = 0 ; //REGULAR_FONTTYPE;
if (ChooseFontW(&cf))
ret = OK;
# endif
goto theend;
}
/*
* Split name up, it could be <name>:h<height>:w<width> etc.
*/
for (p = wname; *p && *p != L':'; p++)
{
if (p - wname + 1 >= LF_FACESIZE)
goto theend; // Name too long
lf->lfFaceName[p - wname] = *p;
}
if (p != wname)
lf->lfFaceName[p - wname] = NUL;
// First set defaults
lf->lfHeight = -12;
lf->lfWidth = 0;
lf->lfWeight = FW_NORMAL;
lf->lfItalic = FALSE;
lf->lfUnderline = FALSE;
lf->lfStrikeOut = FALSE;
/*
* If the font can't be found, try replacing '_' by ' '.
*/
if (init_logfont(lf) == FAIL)
{
int did_replace = FALSE;
for (i = 0; lf->lfFaceName[i]; ++i)
if (lf->lfFaceName[i] == L'_')
{
lf->lfFaceName[i] = L' ';
did_replace = TRUE;
}
if (!did_replace || init_logfont(lf) == FAIL)
goto theend;
}
while (*p == L':')
p++;
// Set the values found after ':'
while (*p)
{
switch (*p++)
{
// Note: Keep this in sync with gui_mch_expand_font().
case L'h':
lf->lfHeight = - points_to_pixels(p, &p, TRUE, (long_i)printer_dc);
break;
case L'w':
lf->lfWidth = points_to_pixels(p, &p, FALSE, (long_i)printer_dc);
break;
case L'W':
lf->lfWeight = wcstol(p, &p, 10);
break;
case L'b':
lf->lfWeight = FW_BOLD;
break;
case L'i':
lf->lfItalic = TRUE;
break;
case L'u':
lf->lfUnderline = TRUE;
break;
case L's':
lf->lfStrikeOut = TRUE;
break;
case L'c':
{
struct charset_pair *cp;
for (cp = charset_pairs; cp->name != NULL; ++cp)
if (utf16ascncmp(p, cp->name, strlen(cp->name)) == 0)
{
lf->lfCharSet = cp->charset;
p += strlen(cp->name);
break;
}
if (cp->name == NULL && verbose)
{
char_u *s = utf16_to_enc(p, NULL);
semsg(_(e_illegal_str_name_str_in_font_name_str),
"charset", s, name);
vim_free(s);
break;
}
break;
}
case L'q':
{
struct quality_pair *qp;
for (qp = quality_pairs; qp->name != NULL; ++qp)
if (utf16ascncmp(p, qp->name, strlen(qp->name)) == 0)
{
lf->lfQuality = qp->quality;
p += strlen(qp->name);
break;
}
if (qp->name == NULL && verbose)
{
char_u *s = utf16_to_enc(p, NULL);
semsg(_(e_illegal_str_name_str_in_font_name_str),
"quality", s, name);
vim_free(s);
break;
}
break;
}
default:
if (verbose)
semsg(_(e_illegal_char_nr_in_font_name_str), p[-1], name);
goto theend;
}
while (*p == L':')
p++;
}
ret = OK;
theend:
// ron: init lastlf
if (ret == OK && printer_dc == NULL)
{
vim_free(lastlf);
lastlf = ALLOC_ONE(LOGFONTW);
if (lastlf != NULL)
mch_memmove(lastlf, lf, sizeof(LOGFONTW));
}
vim_free(wname);
return ret;
}
#endif // defined(FEAT_GUI) || defined(FEAT_PRINTER)
#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
/*
* Initialize the Winsock dll.
*/
void
channel_init_winsock(void)
{
WSADATA wsaData;
int wsaerr;
if (WSInitialized)
return;
wsaerr = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (wsaerr == 0)
WSInitialized = TRUE;
}
#endif
View Git Blame Copy Permalink