mirror of
https://github.com/vim/vim
synced 2025-03-16 14:57:52 +01:00
Problem: MS-Windows: incorrect Win32 error checking Solution: fix wrong order of error handling and perform some minor refactoring (Nir Lichtman) In the function that adjusts the process privileges there is a mistake in which GetLastError is called after CloseHandle, though clearly the last error check is meant for the privileges related call before hand and the current state appears like a mistake. So fix this problem, and also perform the following: - Remove the static variable done since the PlatformId is only called during initialization - Fix incorrect parameter passed to the Win32 API privileges function closes: #15845 Signed-off-by: Nir Lichtman <nir@lichtman.org> Signed-off-by: Christian Brabandt <cb@256bit.org>
9052 lines
213 KiB
C
9052 lines
213 KiB
C
/* 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_win32.c
|
|
*
|
|
* Used for both the console version and the Win32 GUI. A lot of code is for
|
|
* the console version only, so there is a lot of "#ifndef FEAT_GUI_MSWIN".
|
|
*
|
|
* Win32 system-dependent routines.
|
|
* Portions lifted from the Win32 SDK samples, the MSDOS-dependent code,
|
|
* NetHack 3.1.3, GNU Emacs 19.30, and Vile 5.5.
|
|
*
|
|
* George V. Reilly <george@reilly.org> wrote most of this.
|
|
* Roger Knobbe <rogerk@wonderware.com> did the initial port of Vim 3.0.
|
|
*/
|
|
|
|
#include "vim.h"
|
|
|
|
#ifdef FEAT_MZSCHEME
|
|
# include "if_mzsch.h"
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <signal.h>
|
|
#include <limits.h>
|
|
|
|
// cproto fails on missing include files
|
|
#ifndef PROTO
|
|
# include <process.h>
|
|
# include <winternl.h>
|
|
# include <direct.h>
|
|
|
|
# if !defined(FEAT_GUI_MSWIN)
|
|
# include <shellapi.h>
|
|
# endif
|
|
|
|
# ifdef FEAT_JOB_CHANNEL
|
|
# include <tlhelp32.h>
|
|
# endif
|
|
#endif
|
|
|
|
// Record all output and all keyboard & mouse input
|
|
// #define MCH_WRITE_DUMP
|
|
|
|
#ifdef MCH_WRITE_DUMP
|
|
FILE* fdDump = NULL;
|
|
#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
|
|
typedef char * LPCSTR;
|
|
typedef char * LPWSTR;
|
|
typedef int ACCESS_MASK;
|
|
typedef int BOOL;
|
|
typedef int BOOLEAN;
|
|
typedef int CALLBACK;
|
|
typedef int COLORREF;
|
|
typedef int CONSOLE_CURSOR_INFO;
|
|
typedef int COORD;
|
|
typedef int DWORD;
|
|
typedef int HANDLE;
|
|
typedef int LPHANDLE;
|
|
typedef int HDC;
|
|
typedef int HFONT;
|
|
typedef int HICON;
|
|
typedef int HINSTANCE;
|
|
typedef int HWND;
|
|
typedef int INPUT_RECORD;
|
|
typedef int INT;
|
|
typedef int KEY_EVENT_RECORD;
|
|
typedef int LOGFONT;
|
|
typedef int LPBOOL;
|
|
typedef int LPCTSTR;
|
|
typedef int LPDWORD;
|
|
typedef int LPSTR;
|
|
typedef int LPTSTR;
|
|
typedef int LPVOID;
|
|
typedef int MOUSE_EVENT_RECORD;
|
|
typedef int PACL;
|
|
typedef int PDWORD;
|
|
typedef int PHANDLE;
|
|
typedef int PRINTDLG;
|
|
typedef int PSECURITY_DESCRIPTOR;
|
|
typedef int PSID;
|
|
typedef int SECURITY_INFORMATION;
|
|
typedef int SHORT;
|
|
typedef int SMALL_RECT;
|
|
typedef int TEXTMETRIC;
|
|
typedef int TOKEN_INFORMATION_CLASS;
|
|
typedef int TRUSTEE;
|
|
typedef int WORD;
|
|
typedef int WCHAR;
|
|
typedef void VOID;
|
|
typedef int BY_HANDLE_FILE_INFORMATION;
|
|
typedef int SE_OBJECT_TYPE;
|
|
typedef int PSNSECINFO;
|
|
typedef int PSNSECINFOW;
|
|
typedef int STARTUPINFO;
|
|
typedef int PROCESS_INFORMATION;
|
|
typedef int LPSECURITY_ATTRIBUTES;
|
|
# define __stdcall // empty
|
|
#endif
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
// Win32 Console handles for input and output
|
|
static HANDLE g_hConIn = INVALID_HANDLE_VALUE;
|
|
static HANDLE g_hConOut = INVALID_HANDLE_VALUE;
|
|
|
|
// Win32 Screen buffer,coordinate,console I/O information
|
|
static SMALL_RECT g_srScrollRegion;
|
|
// This is explicitly initialised to work around a LTCG issue on Windows ARM64
|
|
// (at least of 19.39.33321). This pushes this into the `.data` rather than
|
|
// `.bss` which corrects code generation in `write_chars` (#13453).
|
|
static COORD g_coord = {0, 0}; // 0-based, but external coords are 1-based
|
|
|
|
// The attribute of the screen when the editor was started
|
|
static WORD g_attrDefault = 7; // lightgray text on black background
|
|
static WORD g_attrCurrent;
|
|
|
|
static int g_fCBrkPressed = FALSE; // set by ctrl-break interrupt
|
|
static int g_fCtrlCPressed = FALSE; // set when ctrl-C or ctrl-break detected
|
|
static int g_fForceExit = FALSE; // set when forcefully exiting
|
|
|
|
static void scroll(unsigned cLines);
|
|
static void set_scroll_region(unsigned left, unsigned top,
|
|
unsigned right, unsigned bottom);
|
|
static void set_scroll_region_tb(unsigned top, unsigned bottom);
|
|
static void set_scroll_region_lr(unsigned left, unsigned right);
|
|
static void insert_lines(unsigned cLines);
|
|
static void delete_lines(unsigned cLines);
|
|
static void gotoxy(unsigned x, unsigned y);
|
|
static void standout(void);
|
|
static int s_cursor_visible = TRUE;
|
|
static int did_create_conin = FALSE;
|
|
// The 'input_record_buffer' is an internal dynamic fifo queue of MS-Windows
|
|
// console INPUT_RECORD events that are normally read from the console input
|
|
// buffer. This provides an injection point for testing the low-level handling
|
|
// of INPUT_RECORDs.
|
|
typedef struct input_record_buffer_node_S
|
|
{
|
|
INPUT_RECORD ir;
|
|
struct input_record_buffer_node_S *next;
|
|
} input_record_buffer_node_T;
|
|
typedef struct input_record_buffer_S
|
|
{
|
|
input_record_buffer_node_T *head;
|
|
input_record_buffer_node_T *tail;
|
|
int length;
|
|
} input_record_buffer_T;
|
|
static input_record_buffer_T input_record_buffer;
|
|
static int read_input_record_buffer(INPUT_RECORD* irEvents, int nMaxLength);
|
|
static int write_input_record_buffer(INPUT_RECORD* irEvents, int nLength);
|
|
#endif
|
|
#ifdef FEAT_GUI_MSWIN
|
|
static int s_dont_use_vimrun = TRUE;
|
|
static int need_vimrun_warning = FALSE;
|
|
static char *vimrun_path = "vimrun ";
|
|
#endif
|
|
|
|
static int win32_getattrs(char_u *name);
|
|
static int win32_setattrs(char_u *name, int attrs);
|
|
static int win32_set_archive(char_u *name);
|
|
|
|
static int conpty_working = 0;
|
|
static int conpty_type = 0;
|
|
static int conpty_stable = 0;
|
|
static int conpty_fix_type = 0;
|
|
static void vtp_flag_init();
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
static int vtp_working = 0;
|
|
static void vtp_init();
|
|
static void vtp_exit();
|
|
static void vtp_sgr_bulk(int arg);
|
|
static void vtp_sgr_bulks(int argc, int *argv);
|
|
|
|
static int wt_working = 0;
|
|
static void wt_init(void);
|
|
|
|
static int g_color_index_bg = 0;
|
|
static int g_color_index_fg = 7;
|
|
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
static guicolor_T save_console_bg_rgb;
|
|
static guicolor_T save_console_fg_rgb;
|
|
static guicolor_T store_console_bg_rgb;
|
|
static guicolor_T store_console_fg_rgb;
|
|
static int default_console_color_bg = 0x000000; // black
|
|
static int default_console_color_fg = 0xc0c0c0; // white
|
|
# define USE_VTP (vtp_working && is_term_win32() \
|
|
&& (p_tgc || t_colors >= 256))
|
|
# define USE_WT (wt_working)
|
|
# else
|
|
# define USE_VTP 0
|
|
# define USE_WT 0
|
|
# endif
|
|
|
|
static void set_console_color_rgb(void);
|
|
static void reset_console_color_rgb(void);
|
|
static void restore_console_color_rgb(void);
|
|
#endif // !FEAT_GUI_MSWIN || VIMDLL
|
|
|
|
// This flag is newly created from Windows 10
|
|
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
|
|
# define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
|
|
#endif
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
static int suppress_winsize = 1; // don't fiddle with console
|
|
#endif
|
|
|
|
static WCHAR *exe_pathw = NULL;
|
|
|
|
static BOOL win8_or_later = FALSE;
|
|
static BOOL win10_22H2_or_later = FALSE;
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
static BOOL use_alternate_screen_buffer = FALSE;
|
|
#endif
|
|
|
|
/*
|
|
* Get version number including build number
|
|
*/
|
|
typedef BOOL (WINAPI *PfnRtlGetVersion)(LPOSVERSIONINFOW);
|
|
#define MAKE_VER(major, minor, build) \
|
|
(((major) << 24) | ((minor) << 16) | (build))
|
|
|
|
static DWORD
|
|
get_build_number(void)
|
|
{
|
|
OSVERSIONINFOW osver;
|
|
HMODULE hNtdll;
|
|
PfnRtlGetVersion pRtlGetVersion;
|
|
DWORD ver = MAKE_VER(0, 0, 0);
|
|
|
|
osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
|
|
hNtdll = GetModuleHandle("ntdll.dll");
|
|
if (hNtdll == NULL)
|
|
return ver;
|
|
|
|
pRtlGetVersion =
|
|
(PfnRtlGetVersion)GetProcAddress(hNtdll, "RtlGetVersion");
|
|
pRtlGetVersion(&osver);
|
|
ver = MAKE_VER(min(osver.dwMajorVersion, 255),
|
|
min(osver.dwMinorVersion, 255),
|
|
min(osver.dwBuildNumber, 32767));
|
|
return ver;
|
|
}
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
static BOOL
|
|
is_ambiwidth_event(
|
|
INPUT_RECORD *ir)
|
|
{
|
|
return ir->EventType == KEY_EVENT
|
|
&& ir->Event.KeyEvent.bKeyDown
|
|
&& ir->Event.KeyEvent.wRepeatCount == 1
|
|
&& ir->Event.KeyEvent.wVirtualKeyCode == 0x12
|
|
&& ir->Event.KeyEvent.wVirtualScanCode == 0x38
|
|
&& ir->Event.KeyEvent.uChar.UnicodeChar == 0
|
|
&& ir->Event.KeyEvent.dwControlKeyState == 2;
|
|
}
|
|
|
|
static void
|
|
make_ambiwidth_event(
|
|
INPUT_RECORD *down,
|
|
INPUT_RECORD *up)
|
|
{
|
|
down->Event.KeyEvent.wVirtualKeyCode = 0;
|
|
down->Event.KeyEvent.wVirtualScanCode = 0;
|
|
down->Event.KeyEvent.uChar.UnicodeChar
|
|
= up->Event.KeyEvent.uChar.UnicodeChar;
|
|
down->Event.KeyEvent.dwControlKeyState = 0;
|
|
}
|
|
|
|
/*
|
|
* Version of ReadConsoleInput() that works with IME.
|
|
* Works around problems on Windows 8.
|
|
*/
|
|
static BOOL
|
|
read_console_input(
|
|
HANDLE hInput,
|
|
INPUT_RECORD *lpBuffer,
|
|
int nLength,
|
|
LPDWORD lpEvents)
|
|
{
|
|
enum
|
|
{
|
|
IRSIZE = 10
|
|
};
|
|
static INPUT_RECORD s_irCache[IRSIZE];
|
|
static DWORD s_dwIndex = 0;
|
|
static DWORD s_dwMax = 0;
|
|
DWORD dwEvents;
|
|
int head;
|
|
int tail;
|
|
int i;
|
|
static INPUT_RECORD s_irPseudo;
|
|
|
|
if (s_dwMax == 0 && input_record_buffer.length > 0)
|
|
{
|
|
dwEvents = read_input_record_buffer(s_irCache, IRSIZE);
|
|
s_dwIndex = 0;
|
|
s_dwMax = dwEvents;
|
|
}
|
|
|
|
if (nLength == -2)
|
|
return (s_dwMax > 0) ? TRUE : FALSE;
|
|
|
|
if (!win8_or_later)
|
|
{
|
|
if (nLength == -1)
|
|
return PeekConsoleInputW(hInput, lpBuffer, 1, lpEvents);
|
|
return ReadConsoleInputW(hInput, lpBuffer, 1, &dwEvents);
|
|
}
|
|
|
|
if (s_dwMax == 0)
|
|
{
|
|
if (!vtp_working && nLength == -1)
|
|
return PeekConsoleInputW(hInput, lpBuffer, 1, lpEvents);
|
|
GetNumberOfConsoleInputEvents(hInput, &dwEvents);
|
|
if (dwEvents == 0 && nLength == -1)
|
|
return PeekConsoleInputW(hInput, lpBuffer, 1, lpEvents);
|
|
ReadConsoleInputW(hInput, s_irCache, IRSIZE, &dwEvents);
|
|
s_dwIndex = 0;
|
|
s_dwMax = dwEvents;
|
|
if (dwEvents == 0)
|
|
{
|
|
*lpEvents = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
for (i = s_dwIndex; i < (int)s_dwMax - 1; ++i)
|
|
if (is_ambiwidth_event(&s_irCache[i]))
|
|
make_ambiwidth_event(&s_irCache[i], &s_irCache[i + 1]);
|
|
|
|
if (s_dwMax > 1)
|
|
{
|
|
head = 0;
|
|
tail = s_dwMax - 1;
|
|
while (head != tail)
|
|
{
|
|
if (s_irCache[head].EventType == WINDOW_BUFFER_SIZE_EVENT
|
|
&& s_irCache[head + 1].EventType
|
|
== WINDOW_BUFFER_SIZE_EVENT)
|
|
{
|
|
// Remove duplicate event to avoid flicker.
|
|
for (i = head; i < tail; ++i)
|
|
s_irCache[i] = s_irCache[i + 1];
|
|
--tail;
|
|
continue;
|
|
}
|
|
head++;
|
|
}
|
|
s_dwMax = tail + 1;
|
|
}
|
|
}
|
|
|
|
if (s_irCache[s_dwIndex].EventType == KEY_EVENT)
|
|
{
|
|
if (s_irCache[s_dwIndex].Event.KeyEvent.wRepeatCount > 1)
|
|
{
|
|
s_irPseudo = s_irCache[s_dwIndex];
|
|
s_irPseudo.Event.KeyEvent.wRepeatCount = 1;
|
|
s_irCache[s_dwIndex].Event.KeyEvent.wRepeatCount--;
|
|
*lpBuffer = s_irPseudo;
|
|
*lpEvents = 1;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
*lpBuffer = s_irCache[s_dwIndex];
|
|
if (!(nLength == -1 || nLength == -2) && ++s_dwIndex >= s_dwMax)
|
|
s_dwMax = 0;
|
|
*lpEvents = 1;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Version of PeekConsoleInput() that works with IME.
|
|
*/
|
|
static BOOL
|
|
peek_console_input(
|
|
HANDLE hInput,
|
|
INPUT_RECORD *lpBuffer,
|
|
DWORD nLength UNUSED,
|
|
LPDWORD lpEvents)
|
|
{
|
|
return read_console_input(hInput, lpBuffer, -1, lpEvents);
|
|
}
|
|
|
|
# ifdef FEAT_CLIENTSERVER
|
|
static DWORD
|
|
msg_wait_for_multiple_objects(
|
|
DWORD nCount,
|
|
LPHANDLE pHandles,
|
|
BOOL fWaitAll,
|
|
DWORD dwMilliseconds,
|
|
DWORD dwWakeMask)
|
|
{
|
|
if (read_console_input(NULL, NULL, -2, NULL))
|
|
return WAIT_OBJECT_0;
|
|
return MsgWaitForMultipleObjects(nCount, pHandles, fWaitAll,
|
|
dwMilliseconds, dwWakeMask);
|
|
}
|
|
# endif
|
|
|
|
# ifndef FEAT_CLIENTSERVER
|
|
static DWORD
|
|
wait_for_single_object(
|
|
HANDLE hHandle,
|
|
DWORD dwMilliseconds)
|
|
{
|
|
if (read_console_input(NULL, NULL, -2, NULL))
|
|
return WAIT_OBJECT_0;
|
|
return WaitForSingleObject(hHandle, dwMilliseconds);
|
|
}
|
|
# endif
|
|
#endif // !FEAT_GUI_MSWIN || VIMDLL
|
|
|
|
void
|
|
mch_get_exe_name(void)
|
|
{
|
|
// Maximum length of $PATH is more than MAXPATHL. 8191 is often mentioned
|
|
// as the maximum length that works. Add 1 for a NUL byte and 5 for
|
|
// "PATH=".
|
|
#define MAX_ENV_PATH_LEN (8191 + 1 + 5)
|
|
WCHAR temp[MAX_ENV_PATH_LEN];
|
|
WCHAR buf[MAX_PATH];
|
|
int updated = FALSE;
|
|
static int enc_prev = -1;
|
|
|
|
if (exe_name == NULL || exe_pathw == NULL || enc_prev != enc_codepage)
|
|
{
|
|
// store the name of the executable, may be used for $VIM
|
|
GetModuleFileNameW(NULL, buf, MAX_PATH);
|
|
if (*buf != NUL)
|
|
{
|
|
if (enc_codepage == -1)
|
|
enc_codepage = GetACP();
|
|
vim_free(exe_name);
|
|
exe_name = utf16_to_enc(buf, NULL);
|
|
enc_prev = enc_codepage;
|
|
|
|
WCHAR *wp = wcsrchr(buf, '\\');
|
|
if (wp != NULL)
|
|
*wp = NUL;
|
|
vim_free(exe_pathw);
|
|
exe_pathw = _wcsdup(buf);
|
|
updated = TRUE;
|
|
}
|
|
}
|
|
|
|
if (exe_pathw == NULL || !updated)
|
|
return;
|
|
|
|
// Append our starting directory to $PATH, so that when doing
|
|
// "!xxd" it's found in our starting directory. Needed because
|
|
// SearchPath() also looks there.
|
|
WCHAR *p = _wgetenv(L"PATH");
|
|
if (p == NULL || wcslen(p) + wcslen(exe_pathw) + 2 + 5 < MAX_ENV_PATH_LEN)
|
|
{
|
|
wcscpy(temp, L"PATH=");
|
|
|
|
if (p == NULL || *p == NUL)
|
|
wcscat(temp, exe_pathw);
|
|
else
|
|
{
|
|
wcscat(temp, p);
|
|
|
|
// Check if exe_path is already included in $PATH.
|
|
if (wcsstr(temp, exe_pathw) == NULL)
|
|
{
|
|
// Append ';' if $PATH doesn't end with it.
|
|
size_t len = wcslen(temp);
|
|
if (temp[len - 1] != L';')
|
|
wcscat(temp, L";");
|
|
|
|
wcscat(temp, exe_pathw);
|
|
}
|
|
}
|
|
_wputenv(temp);
|
|
#ifdef libintl_wputenv
|
|
libintl_wputenv(temp);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unescape characters in "p" that appear in "escaped".
|
|
*/
|
|
static void
|
|
unescape_shellxquote(char_u *p, char_u *escaped)
|
|
{
|
|
int l = (int)STRLEN(p);
|
|
int n;
|
|
|
|
while (*p != NUL)
|
|
{
|
|
if (*p == '^' && vim_strchr(escaped, p[1]) != NULL)
|
|
mch_memmove(p, p + 1, l--);
|
|
n = (*mb_ptr2len)(p);
|
|
p += n;
|
|
l -= n;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Load library "name".
|
|
*/
|
|
HINSTANCE
|
|
vimLoadLib(const char *name)
|
|
{
|
|
HINSTANCE dll = NULL;
|
|
|
|
// No need to load any library when registering OLE.
|
|
if (found_register_arg)
|
|
return NULL;
|
|
|
|
// NOTE: Do not use mch_dirname() and mch_chdir() here, they may call
|
|
// vimLoadLib() recursively, which causes a stack overflow.
|
|
if (exe_pathw == NULL)
|
|
{
|
|
mch_get_exe_name();
|
|
if (exe_pathw == NULL)
|
|
return NULL;
|
|
}
|
|
|
|
WCHAR old_dirw[MAXPATHL];
|
|
|
|
if (GetCurrentDirectoryW(MAXPATHL, old_dirw) == 0)
|
|
return NULL;
|
|
|
|
// Change directory to where the executable is, both to make
|
|
// sure we find a .dll there and to avoid looking for a .dll
|
|
// in the current directory.
|
|
SetCurrentDirectoryW(exe_pathw);
|
|
dll = LoadLibrary(name);
|
|
SetCurrentDirectoryW(old_dirw);
|
|
return dll;
|
|
}
|
|
|
|
#if defined(VIMDLL) || defined(PROTO)
|
|
/*
|
|
* Check if the current executable file is for the GUI subsystem.
|
|
*/
|
|
int
|
|
mch_is_gui_executable(void)
|
|
{
|
|
PBYTE pImage = (PBYTE)GetModuleHandle(NULL);
|
|
PIMAGE_DOS_HEADER pDOS = (PIMAGE_DOS_HEADER)pImage;
|
|
PIMAGE_NT_HEADERS pPE;
|
|
|
|
if (pDOS->e_magic != IMAGE_DOS_SIGNATURE)
|
|
return FALSE;
|
|
pPE = (PIMAGE_NT_HEADERS)(pImage + pDOS->e_lfanew);
|
|
if (pPE->Signature != IMAGE_NT_SIGNATURE)
|
|
return FALSE;
|
|
if (pPE->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
#if defined(DYNAMIC_ICONV) || defined(DYNAMIC_GETTEXT) \
|
|
|| defined(FEAT_PYTHON3) || defined(PROTO)
|
|
/*
|
|
* Get related information about 'funcname' which is imported by 'hInst'.
|
|
* If 'info' is 0, return the function address.
|
|
* If 'info' is 1, return the module name which the function is imported from.
|
|
* If 'info' is 2, hook the function with 'ptr', and return the original
|
|
* function address.
|
|
*/
|
|
static void *
|
|
get_imported_func_info(HINSTANCE hInst, const char *funcname, int info,
|
|
const void *ptr)
|
|
{
|
|
PBYTE pImage = (PBYTE)hInst;
|
|
PIMAGE_DOS_HEADER pDOS = (PIMAGE_DOS_HEADER)hInst;
|
|
PIMAGE_NT_HEADERS pPE;
|
|
PIMAGE_IMPORT_DESCRIPTOR pImpDesc;
|
|
PIMAGE_THUNK_DATA pIAT; // Import Address Table
|
|
PIMAGE_THUNK_DATA pINT; // Import Name Table
|
|
PIMAGE_IMPORT_BY_NAME pImpName;
|
|
DWORD ImpVA;
|
|
|
|
if (pDOS->e_magic != IMAGE_DOS_SIGNATURE)
|
|
return NULL;
|
|
pPE = (PIMAGE_NT_HEADERS)(pImage + pDOS->e_lfanew);
|
|
if (pPE->Signature != IMAGE_NT_SIGNATURE)
|
|
return NULL;
|
|
|
|
ImpVA = pPE->OptionalHeader
|
|
.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
|
|
if (ImpVA == 0)
|
|
return NULL; // No Import Table
|
|
pImpDesc = (PIMAGE_IMPORT_DESCRIPTOR)(pImage + ImpVA);
|
|
|
|
for (; pImpDesc->FirstThunk; ++pImpDesc)
|
|
{
|
|
if (!pImpDesc->OriginalFirstThunk)
|
|
continue;
|
|
pIAT = (PIMAGE_THUNK_DATA)(pImage + pImpDesc->FirstThunk);
|
|
pINT = (PIMAGE_THUNK_DATA)(pImage + pImpDesc->OriginalFirstThunk);
|
|
for (; pIAT->u1.Function; ++pIAT, ++pINT)
|
|
{
|
|
if (IMAGE_SNAP_BY_ORDINAL(pINT->u1.Ordinal))
|
|
continue;
|
|
pImpName = (PIMAGE_IMPORT_BY_NAME)(pImage
|
|
+ (UINT_PTR)(pINT->u1.AddressOfData));
|
|
if (strcmp((char *)pImpName->Name, funcname) == 0)
|
|
{
|
|
void *original;
|
|
DWORD old, new = PAGE_READWRITE;
|
|
|
|
switch (info)
|
|
{
|
|
case 0:
|
|
return (void *)pIAT->u1.Function;
|
|
case 1:
|
|
return (void *)(pImage + pImpDesc->Name);
|
|
case 2:
|
|
original = (void *)pIAT->u1.Function;
|
|
VirtualProtect(&pIAT->u1.Function, sizeof(void *),
|
|
new, &old);
|
|
pIAT->u1.Function = (UINT_PTR)ptr;
|
|
VirtualProtect(&pIAT->u1.Function, sizeof(void *),
|
|
old, &new);
|
|
return original;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Get the module handle which 'funcname' in 'hInst' is imported from.
|
|
*/
|
|
HINSTANCE
|
|
find_imported_module_by_funcname(HINSTANCE hInst, const char *funcname)
|
|
{
|
|
char *modulename;
|
|
|
|
modulename = (char *)get_imported_func_info(hInst, funcname, 1, NULL);
|
|
if (modulename != NULL)
|
|
return GetModuleHandleA(modulename);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Get the address of 'funcname' which is imported by 'hInst' DLL.
|
|
*/
|
|
void *
|
|
get_dll_import_func(HINSTANCE hInst, const char *funcname)
|
|
{
|
|
return get_imported_func_info(hInst, funcname, 0, NULL);
|
|
}
|
|
|
|
/*
|
|
* Hook the function named 'funcname' which is imported by 'hInst' DLL,
|
|
* and return the original function address.
|
|
*/
|
|
void *
|
|
hook_dll_import_func(HINSTANCE hInst, const char *funcname, const void *hook)
|
|
{
|
|
return get_imported_func_info(hInst, funcname, 2, hook);
|
|
}
|
|
#endif
|
|
|
|
#if defined(FEAT_PYTHON3) || defined(PROTO)
|
|
/*
|
|
* Check if the specified DLL is a function forwarder.
|
|
* If yes, return the instance of the forwarded DLL.
|
|
* If no, return the specified DLL.
|
|
* If error, return NULL.
|
|
* This assumes that the DLL forwards all the function to a single DLL.
|
|
*/
|
|
HINSTANCE
|
|
get_forwarded_dll(HINSTANCE hInst)
|
|
{
|
|
PBYTE pImage = (PBYTE)hInst;
|
|
PIMAGE_DOS_HEADER pDOS = (PIMAGE_DOS_HEADER)hInst;
|
|
PIMAGE_NT_HEADERS pPE;
|
|
PIMAGE_EXPORT_DIRECTORY pExpDir;
|
|
DWORD ExpVA;
|
|
DWORD ExpSize;
|
|
LPDWORD pFunctionTable;
|
|
|
|
if (pDOS->e_magic != IMAGE_DOS_SIGNATURE)
|
|
return NULL;
|
|
pPE = (PIMAGE_NT_HEADERS)(pImage + pDOS->e_lfanew);
|
|
if (pPE->Signature != IMAGE_NT_SIGNATURE)
|
|
return NULL;
|
|
|
|
ExpVA = pPE->OptionalHeader
|
|
.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
|
|
ExpSize = pPE->OptionalHeader
|
|
.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
|
|
if (ExpVA == 0)
|
|
return hInst; // No Export Directory
|
|
pExpDir = (PIMAGE_EXPORT_DIRECTORY)(pImage + ExpVA);
|
|
pFunctionTable = (LPDWORD)(pImage + pExpDir->AddressOfFunctions);
|
|
|
|
if (pExpDir->NumberOfNames == 0)
|
|
return hInst; // No export names.
|
|
|
|
// Check only the first entry.
|
|
if ((pFunctionTable[0] < ExpVA) || (pFunctionTable[0] >= ExpVA + ExpSize))
|
|
// The first entry is not a function forwarder.
|
|
return hInst;
|
|
|
|
// The first entry is a function forwarder.
|
|
// The name is represented as "DllName.FunctionName".
|
|
const char *name = (const char *)(pImage + pFunctionTable[0]);
|
|
const char *p = strchr(name, '.');
|
|
if (p == NULL)
|
|
return hInst;
|
|
|
|
// Extract DllName.
|
|
char buf[MAX_PATH];
|
|
if (p - name + 1 > sizeof(buf))
|
|
return NULL;
|
|
strncpy(buf, name, p - name);
|
|
buf[p - name] = '\0';
|
|
return GetModuleHandleA(buf);
|
|
}
|
|
#endif
|
|
|
|
#if defined(DYNAMIC_GETTEXT) || defined(PROTO)
|
|
# ifndef GETTEXT_DLL
|
|
# define GETTEXT_DLL "libintl.dll"
|
|
# define GETTEXT_DLL_ALT1 "libintl-8.dll"
|
|
# define GETTEXT_DLL_ALT2 "intl.dll"
|
|
# endif
|
|
// Dummy functions
|
|
static char *null_libintl_gettext(const char *);
|
|
static char *null_libintl_ngettext(const char *, const char *, unsigned long n);
|
|
static char *null_libintl_textdomain(const char *);
|
|
static char *null_libintl_bindtextdomain(const char *, const char *);
|
|
static char *null_libintl_bind_textdomain_codeset(const char *, const char *);
|
|
static int null_libintl_wputenv(const wchar_t *);
|
|
|
|
static HINSTANCE hLibintlDLL = NULL;
|
|
char *(*dyn_libintl_gettext)(const char *) = null_libintl_gettext;
|
|
char *(*dyn_libintl_ngettext)(const char *, const char *, unsigned long n)
|
|
= null_libintl_ngettext;
|
|
char *(*dyn_libintl_textdomain)(const char *) = null_libintl_textdomain;
|
|
char *(*dyn_libintl_bindtextdomain)(const char *, const char *)
|
|
= null_libintl_bindtextdomain;
|
|
char *(*dyn_libintl_bind_textdomain_codeset)(const char *, const char *)
|
|
= null_libintl_bind_textdomain_codeset;
|
|
int (*dyn_libintl_wputenv)(const wchar_t *) = null_libintl_wputenv;
|
|
|
|
int
|
|
dyn_libintl_init(void)
|
|
{
|
|
int i;
|
|
static struct
|
|
{
|
|
char *name;
|
|
FARPROC *ptr;
|
|
} libintl_entry[] =
|
|
{
|
|
{"gettext", (FARPROC*)&dyn_libintl_gettext},
|
|
{"ngettext", (FARPROC*)&dyn_libintl_ngettext},
|
|
{"textdomain", (FARPROC*)&dyn_libintl_textdomain},
|
|
{"bindtextdomain", (FARPROC*)&dyn_libintl_bindtextdomain},
|
|
{NULL, NULL}
|
|
};
|
|
HINSTANCE hmsvcrt;
|
|
|
|
// No need to initialize twice.
|
|
if (hLibintlDLL != NULL)
|
|
return 1;
|
|
// Load gettext library (libintl.dll and other names).
|
|
hLibintlDLL = vimLoadLib(GETTEXT_DLL);
|
|
# ifdef GETTEXT_DLL_ALT1
|
|
if (!hLibintlDLL)
|
|
hLibintlDLL = vimLoadLib(GETTEXT_DLL_ALT1);
|
|
# endif
|
|
# ifdef GETTEXT_DLL_ALT2
|
|
if (!hLibintlDLL)
|
|
hLibintlDLL = vimLoadLib(GETTEXT_DLL_ALT2);
|
|
# endif
|
|
if (!hLibintlDLL)
|
|
{
|
|
if (p_verbose > 0)
|
|
{
|
|
verbose_enter();
|
|
semsg(_(e_could_not_load_library_str_str), GETTEXT_DLL, GetWin32Error());
|
|
verbose_leave();
|
|
}
|
|
return 0;
|
|
}
|
|
for (i = 0; libintl_entry[i].name != NULL
|
|
&& libintl_entry[i].ptr != NULL; ++i)
|
|
{
|
|
if ((*libintl_entry[i].ptr = GetProcAddress(hLibintlDLL,
|
|
libintl_entry[i].name)) == NULL)
|
|
{
|
|
dyn_libintl_end();
|
|
if (p_verbose > 0)
|
|
{
|
|
verbose_enter();
|
|
semsg(_(e_could_not_load_library_function_str), libintl_entry[i].name);
|
|
verbose_leave();
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// The bind_textdomain_codeset() function is optional.
|
|
dyn_libintl_bind_textdomain_codeset = (char *(*)(const char *, const char *))
|
|
GetProcAddress(hLibintlDLL, "bind_textdomain_codeset");
|
|
if (dyn_libintl_bind_textdomain_codeset == NULL)
|
|
dyn_libintl_bind_textdomain_codeset =
|
|
null_libintl_bind_textdomain_codeset;
|
|
|
|
// _wputenv() function for the libintl.dll is optional.
|
|
hmsvcrt = find_imported_module_by_funcname(hLibintlDLL, "getenv");
|
|
if (hmsvcrt != NULL)
|
|
dyn_libintl_wputenv = (int (*)(const wchar_t *))
|
|
GetProcAddress(hmsvcrt, "_wputenv");
|
|
if (dyn_libintl_wputenv == NULL || dyn_libintl_wputenv == _wputenv)
|
|
dyn_libintl_wputenv = null_libintl_wputenv;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
dyn_libintl_end(void)
|
|
{
|
|
if (hLibintlDLL)
|
|
FreeLibrary(hLibintlDLL);
|
|
hLibintlDLL = NULL;
|
|
dyn_libintl_gettext = null_libintl_gettext;
|
|
dyn_libintl_ngettext = null_libintl_ngettext;
|
|
dyn_libintl_textdomain = null_libintl_textdomain;
|
|
dyn_libintl_bindtextdomain = null_libintl_bindtextdomain;
|
|
dyn_libintl_bind_textdomain_codeset = null_libintl_bind_textdomain_codeset;
|
|
dyn_libintl_wputenv = null_libintl_wputenv;
|
|
}
|
|
|
|
static char *
|
|
null_libintl_gettext(const char *msgid)
|
|
{
|
|
return (char*)msgid;
|
|
}
|
|
|
|
static char *
|
|
null_libintl_ngettext(
|
|
const char *msgid,
|
|
const char *msgid_plural,
|
|
unsigned long n)
|
|
{
|
|
return (char *)(n == 1 ? msgid : msgid_plural);
|
|
}
|
|
|
|
static char *
|
|
null_libintl_bindtextdomain(
|
|
const char *domainname UNUSED,
|
|
const char *dirname UNUSED)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static char *
|
|
null_libintl_bind_textdomain_codeset(
|
|
const char *domainname UNUSED,
|
|
const char *codeset UNUSED)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static char *
|
|
null_libintl_textdomain(const char *domainname UNUSED)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
null_libintl_wputenv(const wchar_t *envstring UNUSED)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif // DYNAMIC_GETTEXT
|
|
|
|
// This symbol is not defined in older versions of the SDK or Visual C++
|
|
|
|
#ifndef VER_PLATFORM_WIN32_WINDOWS
|
|
# define VER_PLATFORM_WIN32_WINDOWS 1
|
|
#endif
|
|
|
|
#ifdef HAVE_ACL
|
|
# ifndef PROTO
|
|
# include <aclapi.h>
|
|
# endif
|
|
# ifndef PROTECTED_DACL_SECURITY_INFORMATION
|
|
# define PROTECTED_DACL_SECURITY_INFORMATION 0x80000000L
|
|
# endif
|
|
#endif
|
|
|
|
#ifdef HAVE_ACL
|
|
/*
|
|
* Enables or disables the specified privilege.
|
|
*/
|
|
static BOOL
|
|
win32_enable_privilege(LPTSTR lpszPrivilege)
|
|
{
|
|
LUID luid;
|
|
HANDLE hToken;
|
|
TOKEN_PRIVILEGES tokenPrivileges;
|
|
|
|
if (!OpenProcessToken(GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
|
|
return FALSE;
|
|
|
|
if (!LookupPrivilegeValue(NULL, lpszPrivilege, &luid))
|
|
{
|
|
CloseHandle(hToken);
|
|
return FALSE;
|
|
}
|
|
|
|
tokenPrivileges.PrivilegeCount = 1;
|
|
tokenPrivileges.Privileges[0].Luid = luid;
|
|
tokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
if (!AdjustTokenPrivileges(hToken, FALSE, &tokenPrivileges, 0, NULL, NULL))
|
|
{
|
|
CloseHandle(hToken);
|
|
return FALSE;
|
|
}
|
|
|
|
if (GetLastError() != ERROR_SUCCESS)
|
|
{
|
|
CloseHandle(hToken);
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle(hToken);
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef _MSC_VER
|
|
// Suppress the deprecation warning for using GetVersionEx().
|
|
// It is needed for implementing "windowsversion()".
|
|
# pragma warning(push)
|
|
# pragma warning(disable: 4996)
|
|
#endif
|
|
/*
|
|
* Set "win8_or_later" and fill in "windowsVersion" if possible.
|
|
*/
|
|
void
|
|
PlatformId(void)
|
|
{
|
|
OSVERSIONINFO ovi;
|
|
|
|
ovi.dwOSVersionInfoSize = sizeof(ovi);
|
|
if (!GetVersionEx(&ovi))
|
|
return;
|
|
|
|
#ifdef FEAT_EVAL
|
|
vim_snprintf(windowsVersion, sizeof(windowsVersion), "%d.%d",
|
|
(int)ovi.dwMajorVersion, (int)ovi.dwMinorVersion);
|
|
#endif
|
|
if ((ovi.dwMajorVersion == 6 && ovi.dwMinorVersion >= 2)
|
|
|| ovi.dwMajorVersion > 6)
|
|
win8_or_later = TRUE;
|
|
|
|
if ((ovi.dwMajorVersion == 10 && ovi.dwBuildNumber >= 19045)
|
|
|| ovi.dwMajorVersion > 10)
|
|
win10_22H2_or_later = TRUE;
|
|
|
|
#ifdef HAVE_ACL
|
|
// Enable privilege for getting or setting SACLs.
|
|
if (!win32_enable_privilege(SE_SECURITY_NAME))
|
|
return;
|
|
#endif
|
|
}
|
|
#ifdef _MSC_VER
|
|
# pragma warning(pop)
|
|
#endif
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
|
|
# define SHIFT (SHIFT_PRESSED)
|
|
# define CTRL (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)
|
|
# define ALT (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)
|
|
# define ALT_GR (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED)
|
|
|
|
|
|
// When uChar.AsciiChar is 0, then we need to look at wVirtualKeyCode.
|
|
// We map function keys to their ANSI terminal equivalents, as produced
|
|
// by ANSI.SYS, for compatibility with the MS-DOS version of Vim. Any
|
|
// ANSI key with a value >= '\300' is nonstandard, but provided anyway
|
|
// so that the user can have access to all SHIFT-, CTRL-, and ALT-
|
|
// combinations of function/arrow/etc keys.
|
|
|
|
static const struct
|
|
{
|
|
WORD wVirtKey;
|
|
BOOL fAnsiKey;
|
|
int chAlone;
|
|
int chShift;
|
|
int chCtrl;
|
|
int chAlt;
|
|
} VirtKeyMap[] =
|
|
{
|
|
// Key ANSI alone shift ctrl alt
|
|
{ VK_ESCAPE,FALSE, ESC, ESC, ESC, ESC, },
|
|
|
|
{ VK_F1, TRUE, ';', 'T', '^', 'h', },
|
|
{ VK_F2, TRUE, '<', 'U', '_', 'i', },
|
|
{ VK_F3, TRUE, '=', 'V', '`', 'j', },
|
|
{ VK_F4, TRUE, '>', 'W', 'a', 'k', },
|
|
{ VK_F5, TRUE, '?', 'X', 'b', 'l', },
|
|
{ VK_F6, TRUE, '@', 'Y', 'c', 'm', },
|
|
{ VK_F7, TRUE, 'A', 'Z', 'd', 'n', },
|
|
{ VK_F8, TRUE, 'B', '[', 'e', 'o', },
|
|
{ VK_F9, TRUE, 'C', '\\', 'f', 'p', },
|
|
{ VK_F10, TRUE, 'D', ']', 'g', 'q', },
|
|
{ VK_F11, TRUE, '\205', '\207', '\211', '\213', },
|
|
{ VK_F12, TRUE, '\206', '\210', '\212', '\214', },
|
|
|
|
{ VK_HOME, TRUE, 'G', '\302', 'w', '\303', },
|
|
{ VK_UP, TRUE, 'H', '\304', '\305', '\306', },
|
|
{ VK_PRIOR, TRUE, 'I', '\307', '\204', '\310', }, // PgUp
|
|
{ VK_LEFT, TRUE, 'K', '\311', 's', '\312', },
|
|
{ VK_RIGHT, TRUE, 'M', '\313', 't', '\314', },
|
|
{ VK_END, TRUE, 'O', '\315', 'u', '\316', },
|
|
{ VK_DOWN, TRUE, 'P', '\317', '\320', '\321', },
|
|
{ VK_NEXT, TRUE, 'Q', '\322', 'v', '\323', }, // PgDn
|
|
{ VK_INSERT,TRUE, 'R', '\324', '\325', '\326', },
|
|
{ VK_DELETE,TRUE, 'S', '\327', '\330', '\331', },
|
|
{ VK_BACK, TRUE, 'x', 'y', 'z', '{', }, // Backspace
|
|
|
|
{ VK_SNAPSHOT,TRUE, 0, 0, 0, 'r', }, // PrtScrn
|
|
|
|
# if 0
|
|
// Most people don't have F13-F20, but what the hell...
|
|
{ VK_F13, TRUE, '\332', '\333', '\334', '\335', },
|
|
{ VK_F14, TRUE, '\336', '\337', '\340', '\341', },
|
|
{ VK_F15, TRUE, '\342', '\343', '\344', '\345', },
|
|
{ VK_F16, TRUE, '\346', '\347', '\350', '\351', },
|
|
{ VK_F17, TRUE, '\352', '\353', '\354', '\355', },
|
|
{ VK_F18, TRUE, '\356', '\357', '\360', '\361', },
|
|
{ VK_F19, TRUE, '\362', '\363', '\364', '\365', },
|
|
{ VK_F20, TRUE, '\366', '\367', '\370', '\371', },
|
|
# endif
|
|
{ VK_ADD, TRUE, 'N', 'N', 'N', 'N', }, // keyp '+'
|
|
{ VK_SUBTRACT, TRUE,'J', 'J', 'J', 'J', }, // keyp '-'
|
|
// { VK_DIVIDE, TRUE,'N', 'N', 'N', 'N', }, // keyp '/'
|
|
{ VK_MULTIPLY, TRUE,'7', '7', '7', '7', }, // keyp '*'
|
|
|
|
{ VK_NUMPAD0,TRUE, '\332', '\333', '\334', '\335', },
|
|
{ VK_NUMPAD1,TRUE, '\336', '\337', '\340', '\341', },
|
|
{ VK_NUMPAD2,TRUE, '\342', '\343', '\344', '\345', },
|
|
{ VK_NUMPAD3,TRUE, '\346', '\347', '\350', '\351', },
|
|
{ VK_NUMPAD4,TRUE, '\352', '\353', '\354', '\355', },
|
|
{ VK_NUMPAD5,TRUE, '\356', '\357', '\360', '\361', },
|
|
{ VK_NUMPAD6,TRUE, '\362', '\363', '\364', '\365', },
|
|
{ VK_NUMPAD7,TRUE, '\366', '\367', '\370', '\371', },
|
|
{ VK_NUMPAD8,TRUE, '\372', '\373', '\374', '\375', },
|
|
// Sorry, out of number space! <negri>
|
|
{ VK_NUMPAD9,TRUE, '\376', '\377', '|', '}', },
|
|
};
|
|
|
|
|
|
/*
|
|
* The return code indicates key code size.
|
|
*/
|
|
static int
|
|
win32_kbd_patch_key(
|
|
KEY_EVENT_RECORD *pker)
|
|
{
|
|
UINT uMods = pker->dwControlKeyState;
|
|
static int s_iIsDead = 0;
|
|
static WORD awAnsiCode[2];
|
|
static BYTE abKeystate[256];
|
|
|
|
|
|
if (s_iIsDead == 2)
|
|
{
|
|
pker->uChar.UnicodeChar = (WCHAR) awAnsiCode[1];
|
|
s_iIsDead = 0;
|
|
return 1;
|
|
}
|
|
|
|
// check if it already has a valid unicode character.
|
|
if (pker->uChar.UnicodeChar != 0)
|
|
return 1;
|
|
|
|
CLEAR_FIELD(abKeystate);
|
|
|
|
// Clear any pending dead keys
|
|
ToUnicode(VK_SPACE, MapVirtualKey(VK_SPACE, 0), abKeystate, awAnsiCode, 2, 0);
|
|
|
|
if (uMods & SHIFT_PRESSED)
|
|
abKeystate[VK_SHIFT] = 0x80;
|
|
if (uMods & CAPSLOCK_ON)
|
|
abKeystate[VK_CAPITAL] = 1;
|
|
|
|
if ((uMods & ALT_GR) == ALT_GR)
|
|
{
|
|
abKeystate[VK_CONTROL] = abKeystate[VK_LCONTROL] =
|
|
abKeystate[VK_MENU] = abKeystate[VK_RMENU] = 0x80;
|
|
}
|
|
|
|
s_iIsDead = ToUnicode(pker->wVirtualKeyCode, pker->wVirtualScanCode,
|
|
abKeystate, awAnsiCode, 2, 0);
|
|
|
|
if (s_iIsDead > 0)
|
|
pker->uChar.UnicodeChar = (WCHAR) awAnsiCode[0];
|
|
|
|
return s_iIsDead;
|
|
}
|
|
|
|
static BOOL g_fJustGotFocus = FALSE;
|
|
|
|
/*
|
|
* Decode a KEY_EVENT into one or two keystrokes
|
|
*/
|
|
static BOOL
|
|
decode_key_event(
|
|
KEY_EVENT_RECORD *pker,
|
|
WCHAR *pch,
|
|
WCHAR *pch2,
|
|
int *pmodifiers,
|
|
BOOL fDoPost UNUSED)
|
|
{
|
|
int i;
|
|
const int nModifs = pker->dwControlKeyState & (SHIFT | ALT | CTRL);
|
|
|
|
*pch = *pch2 = NUL;
|
|
g_fJustGotFocus = FALSE;
|
|
|
|
// ignore key up events
|
|
if (!pker->bKeyDown)
|
|
return FALSE;
|
|
|
|
// ignore some keystrokes
|
|
switch (pker->wVirtualKeyCode)
|
|
{
|
|
// modifiers
|
|
case VK_SHIFT:
|
|
case VK_CONTROL:
|
|
case VK_MENU: // Alt key
|
|
return FALSE;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Shift-TAB
|
|
if (pker->wVirtualKeyCode == VK_TAB && (nModifs & SHIFT_PRESSED))
|
|
{
|
|
*pch = K_NUL;
|
|
*pch2 = '\017';
|
|
return TRUE;
|
|
}
|
|
|
|
for (i = ARRAY_LENGTH(VirtKeyMap); --i >= 0; )
|
|
{
|
|
if (VirtKeyMap[i].wVirtKey == pker->wVirtualKeyCode)
|
|
{
|
|
*pch = VirtKeyMap[i].chAlone;
|
|
if ((nModifs & SHIFT) != 0)
|
|
*pch = VirtKeyMap[i].chShift;
|
|
else if ((nModifs & CTRL) != 0 && (nModifs & ~CTRL) == 0)
|
|
*pch = VirtKeyMap[i].chCtrl;
|
|
else if ((nModifs & ALT) != 0)
|
|
*pch = VirtKeyMap[i].chAlt;
|
|
|
|
if (*pch != 0)
|
|
{
|
|
if (VirtKeyMap[i].fAnsiKey)
|
|
{
|
|
*pch2 = *pch;
|
|
*pch = K_NUL;
|
|
if (pmodifiers)
|
|
{
|
|
if (pker->wVirtualKeyCode >= VK_F1
|
|
&& pker->wVirtualKeyCode <= VK_F12)
|
|
{
|
|
if ((nModifs & ALT) != 0)
|
|
{
|
|
*pmodifiers |= MOD_MASK_ALT;
|
|
if ((nModifs & SHIFT) == 0)
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
}
|
|
if ((nModifs & CTRL) != 0)
|
|
{
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
if ((nModifs & SHIFT) == 0)
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
}
|
|
}
|
|
else if (pker->wVirtualKeyCode >= VK_END
|
|
&& pker->wVirtualKeyCode <= VK_DOWN)
|
|
{
|
|
// (0x23 - 0x28): VK_END, VK_HOME,
|
|
// VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN
|
|
|
|
*pmodifiers = 0;
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
if ((nModifs & SHIFT) != 0
|
|
&& (nModifs & ~SHIFT) == 0)
|
|
{
|
|
*pch2 = VirtKeyMap[i].chShift;
|
|
}
|
|
if ((nModifs & CTRL) != 0
|
|
&& (nModifs & ~CTRL) == 0)
|
|
{
|
|
*pch2 = VirtKeyMap[i].chCtrl;
|
|
if (pker->wVirtualKeyCode == VK_UP
|
|
|| pker->wVirtualKeyCode == VK_DOWN)
|
|
{
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
}
|
|
}
|
|
if ((nModifs & SHIFT) != 0
|
|
&& (nModifs & CTRL) != 0)
|
|
{
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
*pch2 = VirtKeyMap[i].chShift;
|
|
}
|
|
if ((nModifs & ALT) != 0)
|
|
{
|
|
*pch2 = VirtKeyMap[i].chAlt;
|
|
*pmodifiers |= MOD_MASK_ALT;
|
|
if ((nModifs & ~ALT) == 0)
|
|
{
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
}
|
|
else if ((nModifs & SHIFT) != 0)
|
|
{
|
|
*pch2 = VirtKeyMap[i].chShift;
|
|
}
|
|
else if ((nModifs & CTRL) != 0)
|
|
{
|
|
if (pker->wVirtualKeyCode == VK_UP
|
|
|| pker->wVirtualKeyCode == VK_DOWN)
|
|
{
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
}
|
|
else
|
|
{
|
|
*pch2 = VirtKeyMap[i].chCtrl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (pker->wVirtualKeyCode == VK_INSERT
|
|
&& (nModifs & SHIFT) != 0
|
|
&& (nModifs & ~SHIFT) == 0)
|
|
{
|
|
*pmodifiers = 0;
|
|
*pch2 = VirtKeyMap[i].chShift;
|
|
}
|
|
else
|
|
{
|
|
*pch2 = VirtKeyMap[i].chAlone;
|
|
if ((nModifs & SHIFT) != 0)
|
|
*pmodifiers |= MOD_MASK_SHIFT;
|
|
if ((nModifs & CTRL) != 0)
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
if ((nModifs & ALT) != 0)
|
|
*pmodifiers |= MOD_MASK_ALT;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
i = win32_kbd_patch_key(pker);
|
|
|
|
if (i < 0)
|
|
*pch = NUL;
|
|
else
|
|
{
|
|
*pch = (i > 0) ? pker->uChar.UnicodeChar : NUL;
|
|
|
|
if (pmodifiers != NULL)
|
|
{
|
|
// Pass on the ALT key as a modifier, but only when not combined
|
|
// with CTRL (which is ALTGR).
|
|
if ((nModifs & ALT) != 0 && (nModifs & CTRL) == 0)
|
|
*pmodifiers |= MOD_MASK_ALT;
|
|
|
|
// Pass on SHIFT only for special keys, because we don't know when
|
|
// it's already included with the character.
|
|
if ((nModifs & SHIFT) != 0 && *pch <= 0x20)
|
|
*pmodifiers |= MOD_MASK_SHIFT;
|
|
|
|
// Pass on CTRL only for non-special keys, because we don't know
|
|
// when it's already included with the character. And not when
|
|
// combined with ALT (which is ALTGR).
|
|
if ((nModifs & CTRL) != 0 && (nModifs & ALT) == 0
|
|
&& *pch >= 0x20 && *pch < 0x80)
|
|
*pmodifiers |= MOD_MASK_CTRL;
|
|
}
|
|
}
|
|
|
|
return (*pch != NUL);
|
|
}
|
|
|
|
# if defined(FEAT_EVAL)
|
|
static int
|
|
encode_key_event(dict_T *args, INPUT_RECORD *ir)
|
|
{
|
|
static int s_dwMods = 0;
|
|
|
|
char_u *action = dict_get_string(args, "event", TRUE);
|
|
if (action && (STRICMP(action, "keydown") == 0
|
|
|| STRICMP(action, "keyup") == 0))
|
|
{
|
|
BOOL isKeyDown = STRICMP(action, "keydown") == 0;
|
|
WORD vkCode = dict_get_number_def(args, "keycode", 0);
|
|
if (vkCode <= 0 || vkCode >= 0xFF)
|
|
{
|
|
semsg(_(e_invalid_argument_nr), (long)vkCode);
|
|
return FALSE;
|
|
}
|
|
|
|
ir->EventType = KEY_EVENT;
|
|
KEY_EVENT_RECORD ker;
|
|
ZeroMemory(&ker, sizeof(ker));
|
|
ker.bKeyDown = isKeyDown;
|
|
ker.wRepeatCount = 1;
|
|
ker.wVirtualScanCode = 0;
|
|
ker.dwControlKeyState = 0;
|
|
int mods = (int)dict_get_number(args, "modifiers");
|
|
// Encode the win32 console key modifiers from Vim keyboard modifiers.
|
|
if (mods)
|
|
{
|
|
// If "modifiers" is explicitly set in the args, then we reset any
|
|
// remembered modifier key state that may have been set from
|
|
// earlier mod-key-down events, even if they are not yet unset by
|
|
// earlier mod-key-up events.
|
|
s_dwMods = 0;
|
|
if (mods & MOD_MASK_SHIFT)
|
|
ker.dwControlKeyState |= SHIFT_PRESSED;
|
|
if (mods & MOD_MASK_CTRL)
|
|
ker.dwControlKeyState |= LEFT_CTRL_PRESSED;
|
|
if (mods & MOD_MASK_ALT)
|
|
ker.dwControlKeyState |= LEFT_ALT_PRESSED;
|
|
}
|
|
|
|
if (vkCode == VK_LSHIFT || vkCode == VK_RSHIFT || vkCode == VK_SHIFT)
|
|
{
|
|
if (isKeyDown)
|
|
s_dwMods |= SHIFT_PRESSED;
|
|
else
|
|
s_dwMods &= ~SHIFT_PRESSED;
|
|
}
|
|
else if (vkCode == VK_LCONTROL || vkCode == VK_CONTROL)
|
|
{
|
|
if (isKeyDown)
|
|
s_dwMods |= LEFT_CTRL_PRESSED;
|
|
else
|
|
s_dwMods &= ~LEFT_CTRL_PRESSED;
|
|
}
|
|
else if (vkCode == VK_RCONTROL)
|
|
{
|
|
if (isKeyDown)
|
|
s_dwMods |= RIGHT_CTRL_PRESSED;
|
|
else
|
|
s_dwMods &= ~RIGHT_CTRL_PRESSED;
|
|
}
|
|
else if (vkCode == VK_LMENU || vkCode == VK_MENU)
|
|
{
|
|
if (isKeyDown)
|
|
s_dwMods |= LEFT_ALT_PRESSED;
|
|
else
|
|
s_dwMods &= ~LEFT_ALT_PRESSED;
|
|
}
|
|
else if (vkCode == VK_RMENU)
|
|
{
|
|
if (isKeyDown)
|
|
s_dwMods |= RIGHT_ALT_PRESSED;
|
|
else
|
|
s_dwMods &= ~RIGHT_ALT_PRESSED;
|
|
}
|
|
ker.dwControlKeyState |= s_dwMods;
|
|
ker.wVirtualKeyCode = vkCode;
|
|
ker.uChar.UnicodeChar = 0;
|
|
ir->Event.KeyEvent = ker;
|
|
vim_free(action);
|
|
}
|
|
else
|
|
{
|
|
if (action == NULL)
|
|
{
|
|
semsg(_(e_missing_argument_str), "event");
|
|
}
|
|
else
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str_str), "event", action);
|
|
vim_free(action);
|
|
}
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
# endif // FEAT_EVAL
|
|
#endif // !FEAT_GUI_MSWIN || VIMDLL
|
|
|
|
|
|
/*
|
|
* For the GUI the mouse handling is in gui_w32.c.
|
|
*/
|
|
#if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
|
|
void
|
|
mch_setmouse(int on UNUSED)
|
|
{
|
|
}
|
|
#else // !FEAT_GUI_MSWIN || VIMDLL
|
|
static int g_fMouseAvail = FALSE; // mouse present
|
|
static int g_fMouseActive = FALSE; // mouse enabled
|
|
static int g_nMouseClick = -1; // mouse status
|
|
static int g_xMouse; // mouse x coordinate
|
|
static int g_yMouse; // mouse y coordinate
|
|
static DWORD g_cmodein = 0; // Original console input mode
|
|
static DWORD g_cmodeout = 0; // Original console output mode
|
|
|
|
/*
|
|
* Enable or disable mouse input
|
|
*/
|
|
void
|
|
mch_setmouse(int on)
|
|
{
|
|
DWORD cmodein;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
if (!g_fMouseAvail)
|
|
return;
|
|
|
|
g_fMouseActive = on;
|
|
GetConsoleMode(g_hConIn, &cmodein);
|
|
|
|
if (g_fMouseActive)
|
|
{
|
|
cmodein |= ENABLE_MOUSE_INPUT;
|
|
cmodein &= ~ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
else
|
|
{
|
|
cmodein &= ~ENABLE_MOUSE_INPUT;
|
|
cmodein |= g_cmodein & ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
|
|
SetConsoleMode(g_hConIn, cmodein | ENABLE_EXTENDED_FLAGS);
|
|
}
|
|
|
|
|
|
# if defined(FEAT_BEVAL_TERM) || defined(PROTO)
|
|
/*
|
|
* Called when 'balloonevalterm' changed.
|
|
*/
|
|
void
|
|
mch_bevalterm_changed(void)
|
|
{
|
|
mch_setmouse(g_fMouseActive);
|
|
}
|
|
# endif
|
|
|
|
/*
|
|
* Win32 console mouse scroll event handler.
|
|
* Console version of the _OnMouseWheel() function in gui_w32.c
|
|
*
|
|
* This encodes the mouse scroll direction and keyboard modifiers into
|
|
* g_nMouseClick, and the mouse position into g_xMouse and g_yMouse
|
|
*
|
|
* The direction of the scroll is decoded from two fields of the win32 console
|
|
* mouse event record;
|
|
* 1. The orientation - vertical or horizontal flag - from dwEventFlags
|
|
* 2. The sign - positive or negative (aka delta flag) - from dwButtonState
|
|
*
|
|
* When scroll orientation is HORIZONTAL
|
|
* - If the high word of the dwButtonState member contains a positive
|
|
* value, the wheel was rotated to the right.
|
|
* - Otherwise, the wheel was rotated to the left.
|
|
* When scroll orientation is VERTICAL
|
|
* - If the high word of the dwButtonState member contains a positive value,
|
|
* the wheel was rotated forward, away from the user.
|
|
* - Otherwise, the wheel was rotated backward, toward the user.
|
|
*/
|
|
static void
|
|
decode_mouse_wheel(MOUSE_EVENT_RECORD *pmer)
|
|
{
|
|
int horizontal = (pmer->dwEventFlags == MOUSE_HWHEELED);
|
|
int zDelta = pmer->dwButtonState;
|
|
|
|
g_xMouse = pmer->dwMousePosition.X;
|
|
g_yMouse = pmer->dwMousePosition.Y;
|
|
|
|
# ifdef FEAT_PROP_POPUP
|
|
int lcol = g_xMouse;
|
|
int lrow = g_yMouse;
|
|
win_T *wp = mouse_find_win(&lrow, &lcol, FIND_POPUP);
|
|
if (wp != NULL && popup_is_popup(wp))
|
|
{
|
|
g_nMouseClick = -1;
|
|
cmdarg_T cap;
|
|
oparg_T oa;
|
|
CLEAR_FIELD(cap);
|
|
clear_oparg(&oa);
|
|
cap.oap = &oa;
|
|
if (horizontal)
|
|
{
|
|
cap.arg = zDelta < 0 ? MSCR_LEFT : MSCR_RIGHT;
|
|
cap.cmdchar = zDelta < 0 ? K_MOUSELEFT : K_MOUSERIGHT;
|
|
}
|
|
else
|
|
{
|
|
cap.cmdchar = zDelta < 0 ? K_MOUSEUP : K_MOUSEDOWN;
|
|
cap.arg = zDelta < 0 ? MSCR_UP : MSCR_DOWN;
|
|
}
|
|
|
|
// Mouse hovers over popup window, scroll it if possible.
|
|
mouse_row = wp->w_winrow;
|
|
mouse_col = wp->w_wincol;
|
|
nv_mousescroll(&cap);
|
|
update_screen(0);
|
|
setcursor();
|
|
out_flush();
|
|
return;
|
|
}
|
|
# endif
|
|
mouse_col = g_xMouse;
|
|
mouse_row = g_yMouse;
|
|
|
|
char_u modifiers = 0;
|
|
char_u direction = 0;
|
|
|
|
// Decode the direction into an event that Vim can process
|
|
if (horizontal)
|
|
direction = zDelta >= 0 ? KE_MOUSELEFT : KE_MOUSERIGHT;
|
|
else
|
|
direction = zDelta >= 0 ? KE_MOUSEDOWN : KE_MOUSEUP;
|
|
|
|
// Decode the win32 console key modifiers into Vim mouse modifiers.
|
|
if (pmer->dwControlKeyState & SHIFT_PRESSED)
|
|
modifiers |= MOD_MASK_SHIFT; // MOUSE_SHIFT;
|
|
if (pmer->dwControlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
|
|
modifiers |= MOD_MASK_CTRL; // MOUSE_CTRL;
|
|
if (pmer->dwControlKeyState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
|
|
modifiers |= MOD_MASK_ALT; // MOUSE_ALT;
|
|
|
|
// add (bitwise or) the scroll direction and the key modifier chars
|
|
// together.
|
|
g_nMouseClick = ((direction << 8) | modifiers);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Decode a MOUSE_EVENT. If it's a valid event, return MOUSE_LEFT,
|
|
* MOUSE_MIDDLE, or MOUSE_RIGHT for a click; MOUSE_DRAG for a mouse
|
|
* move with a button held down; and MOUSE_RELEASE after a MOUSE_DRAG
|
|
* or a MOUSE_LEFT, _MIDDLE, or _RIGHT. We encode the button type,
|
|
* the number of clicks, and the Shift/Ctrl/Alt modifiers in g_nMouseClick,
|
|
* and we return the mouse position in g_xMouse and g_yMouse.
|
|
*
|
|
* Every MOUSE_LEFT, _MIDDLE, or _RIGHT will be followed by zero or more
|
|
* MOUSE_DRAGs and one MOUSE_RELEASE. MOUSE_RELEASE will be followed only
|
|
* by MOUSE_LEFT, _MIDDLE, or _RIGHT.
|
|
*
|
|
* For multiple clicks, we send, say, MOUSE_LEFT/1 click, MOUSE_RELEASE,
|
|
* MOUSE_LEFT/2 clicks, MOUSE_RELEASE, MOUSE_LEFT/3 clicks, MOUSE_RELEASE, ....
|
|
*
|
|
* Windows will send us MOUSE_MOVED notifications whenever the mouse
|
|
* moves, even if it stays within the same character cell. We ignore
|
|
* all MOUSE_MOVED messages if the position hasn't really changed, and
|
|
* we ignore all MOUSE_MOVED messages where no button is held down (i.e.,
|
|
* we're only interested in MOUSE_DRAG).
|
|
*
|
|
* All of this is complicated by the code that fakes MOUSE_MIDDLE on
|
|
* 2-button mouses by pressing the left & right buttons simultaneously.
|
|
* In practice, it's almost impossible to click both at the same time,
|
|
* so we need to delay a little. Also, we tend not to get MOUSE_RELEASE
|
|
* in such cases, if the user is clicking quickly.
|
|
*/
|
|
static BOOL
|
|
decode_mouse_event(
|
|
MOUSE_EVENT_RECORD *pmer)
|
|
{
|
|
static int s_nOldButton = -1;
|
|
static int s_nOldMouseClick = -1;
|
|
static int s_xOldMouse = -1;
|
|
static int s_yOldMouse = -1;
|
|
static linenr_T s_old_topline = 0;
|
|
# ifdef FEAT_DIFF
|
|
static int s_old_topfill = 0;
|
|
# endif
|
|
static int s_cClicks = 1;
|
|
static BOOL s_fReleased = TRUE;
|
|
static DWORD s_dwLastClickTime = 0;
|
|
static BOOL s_fNextIsMiddle = FALSE;
|
|
|
|
static DWORD cButtons = 0; // number of buttons supported
|
|
|
|
const DWORD LEFT = FROM_LEFT_1ST_BUTTON_PRESSED;
|
|
const DWORD MIDDLE = FROM_LEFT_2ND_BUTTON_PRESSED;
|
|
const DWORD RIGHT = RIGHTMOST_BUTTON_PRESSED;
|
|
const DWORD LEFT_RIGHT = LEFT | RIGHT;
|
|
|
|
int nButton;
|
|
|
|
if (cButtons == 0 && !GetNumberOfConsoleMouseButtons(&cButtons))
|
|
cButtons = 2;
|
|
|
|
if (!g_fMouseAvail || !g_fMouseActive)
|
|
{
|
|
g_nMouseClick = -1;
|
|
return FALSE;
|
|
}
|
|
|
|
// get a spurious MOUSE_EVENT immediately after receiving focus; ignore
|
|
if (g_fJustGotFocus)
|
|
{
|
|
g_fJustGotFocus = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
// If there is an unprocessed mouse click drop this one.
|
|
if (g_nMouseClick != -1)
|
|
return TRUE;
|
|
|
|
if (pmer->dwEventFlags == MOUSE_WHEELED
|
|
|| pmer->dwEventFlags == MOUSE_HWHEELED)
|
|
{
|
|
decode_mouse_wheel(pmer);
|
|
return TRUE; // we now should have a mouse scroll in g_nMouseClick
|
|
}
|
|
|
|
nButton = -1;
|
|
g_xMouse = pmer->dwMousePosition.X;
|
|
g_yMouse = pmer->dwMousePosition.Y;
|
|
|
|
if (pmer->dwEventFlags == MOUSE_MOVED)
|
|
{
|
|
// Ignore MOUSE_MOVED events if (x, y) hasn't changed. (We get these
|
|
// events even when the mouse moves only within a char cell.)
|
|
if (s_xOldMouse == g_xMouse && s_yOldMouse == g_yMouse)
|
|
return FALSE;
|
|
}
|
|
|
|
// If no buttons are pressed...
|
|
if ((pmer->dwButtonState & ((1 << cButtons) - 1)) == 0)
|
|
{
|
|
nButton = MOUSE_RELEASE;
|
|
|
|
// If the last thing returned was MOUSE_RELEASE, ignore this
|
|
if (s_fReleased)
|
|
{
|
|
# ifdef FEAT_BEVAL_TERM
|
|
// do return mouse move events when we want them
|
|
if (p_bevalterm)
|
|
nButton = MOUSE_DRAG;
|
|
else
|
|
# endif
|
|
return FALSE;
|
|
}
|
|
|
|
s_fReleased = TRUE;
|
|
}
|
|
else // one or more buttons pressed
|
|
{
|
|
// on a 2-button mouse, hold down left and right buttons
|
|
// simultaneously to get MIDDLE.
|
|
|
|
if (cButtons == 2 && s_nOldButton != MOUSE_DRAG)
|
|
{
|
|
DWORD dwLR = (pmer->dwButtonState & LEFT_RIGHT);
|
|
|
|
// if either left or right button only is pressed, see if the
|
|
// next mouse event has both of them pressed
|
|
if (dwLR == LEFT || dwLR == RIGHT)
|
|
{
|
|
for (;;)
|
|
{
|
|
// wait a short time for next input event
|
|
if (WaitForSingleObject(g_hConIn, p_mouset / 3)
|
|
!= WAIT_OBJECT_0)
|
|
break;
|
|
else
|
|
{
|
|
DWORD cRecords = 0;
|
|
INPUT_RECORD ir;
|
|
MOUSE_EVENT_RECORD* pmer2 = &ir.Event.MouseEvent;
|
|
|
|
peek_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
if (cRecords == 0 || ir.EventType != MOUSE_EVENT
|
|
|| !(pmer2->dwButtonState & LEFT_RIGHT))
|
|
break;
|
|
else
|
|
{
|
|
if (pmer2->dwEventFlags != MOUSE_MOVED)
|
|
{
|
|
read_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
return decode_mouse_event(pmer2);
|
|
}
|
|
else if (s_xOldMouse == pmer2->dwMousePosition.X &&
|
|
s_yOldMouse == pmer2->dwMousePosition.Y)
|
|
{
|
|
// throw away spurious mouse move
|
|
read_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
// are there any more mouse events in queue?
|
|
peek_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
if (cRecords==0 || ir.EventType != MOUSE_EVENT)
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (s_fNextIsMiddle)
|
|
{
|
|
nButton = (pmer->dwEventFlags == MOUSE_MOVED)
|
|
? MOUSE_DRAG : MOUSE_MIDDLE;
|
|
s_fNextIsMiddle = FALSE;
|
|
}
|
|
else if (cButtons == 2 &&
|
|
((pmer->dwButtonState & LEFT_RIGHT) == LEFT_RIGHT))
|
|
{
|
|
nButton = MOUSE_MIDDLE;
|
|
|
|
if (! s_fReleased && pmer->dwEventFlags != MOUSE_MOVED)
|
|
{
|
|
s_fNextIsMiddle = TRUE;
|
|
nButton = MOUSE_RELEASE;
|
|
}
|
|
}
|
|
else if ((pmer->dwButtonState & LEFT) == LEFT)
|
|
nButton = MOUSE_LEFT;
|
|
else if ((pmer->dwButtonState & MIDDLE) == MIDDLE)
|
|
nButton = MOUSE_MIDDLE;
|
|
else if ((pmer->dwButtonState & RIGHT) == RIGHT)
|
|
nButton = MOUSE_RIGHT;
|
|
|
|
if (! s_fReleased && ! s_fNextIsMiddle
|
|
&& nButton != s_nOldButton && s_nOldButton != MOUSE_DRAG)
|
|
return FALSE;
|
|
|
|
s_fReleased = s_fNextIsMiddle;
|
|
}
|
|
|
|
if (pmer->dwEventFlags == 0 || pmer->dwEventFlags == DOUBLE_CLICK)
|
|
{
|
|
// button pressed or released, without mouse moving
|
|
if (nButton != -1 && nButton != MOUSE_RELEASE)
|
|
{
|
|
DWORD dwCurrentTime = GetTickCount();
|
|
|
|
if (s_xOldMouse != g_xMouse
|
|
|| s_yOldMouse != g_yMouse
|
|
|| s_nOldButton != nButton
|
|
|| s_old_topline != curwin->w_topline
|
|
# ifdef FEAT_DIFF
|
|
|| s_old_topfill != curwin->w_topfill
|
|
# endif
|
|
|| (int)(dwCurrentTime - s_dwLastClickTime) > p_mouset)
|
|
{
|
|
s_cClicks = 1;
|
|
}
|
|
else if (++s_cClicks > 4)
|
|
{
|
|
s_cClicks = 1;
|
|
}
|
|
|
|
s_dwLastClickTime = dwCurrentTime;
|
|
}
|
|
}
|
|
else if (pmer->dwEventFlags == MOUSE_MOVED)
|
|
{
|
|
if (nButton != -1 && nButton != MOUSE_RELEASE)
|
|
nButton = MOUSE_DRAG;
|
|
|
|
s_cClicks = 1;
|
|
}
|
|
|
|
if (nButton == -1)
|
|
return FALSE;
|
|
|
|
if (nButton != MOUSE_RELEASE)
|
|
s_nOldButton = nButton;
|
|
|
|
g_nMouseClick = nButton;
|
|
|
|
if (pmer->dwControlKeyState & SHIFT_PRESSED)
|
|
g_nMouseClick |= MOUSE_SHIFT;
|
|
if (pmer->dwControlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
|
|
g_nMouseClick |= MOUSE_CTRL;
|
|
if (pmer->dwControlKeyState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
|
|
g_nMouseClick |= MOUSE_ALT;
|
|
|
|
if (nButton != MOUSE_DRAG && nButton != MOUSE_RELEASE)
|
|
SET_NUM_MOUSE_CLICKS(g_nMouseClick, s_cClicks);
|
|
|
|
// only pass on interesting (i.e., different) mouse events
|
|
if (s_xOldMouse == g_xMouse
|
|
&& s_yOldMouse == g_yMouse
|
|
&& s_nOldMouseClick == g_nMouseClick)
|
|
{
|
|
g_nMouseClick = -1;
|
|
return FALSE;
|
|
}
|
|
|
|
s_xOldMouse = g_xMouse;
|
|
s_yOldMouse = g_yMouse;
|
|
s_old_topline = curwin->w_topline;
|
|
# ifdef FEAT_DIFF
|
|
s_old_topfill = curwin->w_topfill;
|
|
# endif
|
|
s_nOldMouseClick = g_nMouseClick;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
# ifdef FEAT_EVAL
|
|
static int
|
|
encode_mouse_event(dict_T *args, INPUT_RECORD *ir)
|
|
{
|
|
int button;
|
|
int row;
|
|
int col;
|
|
int repeated_click;
|
|
int_u mods = 0;
|
|
int move;
|
|
|
|
if (!dict_has_key(args, "row") || !dict_has_key(args, "col"))
|
|
return FALSE;
|
|
|
|
// Note: "move" is optional, requires fewer arguments
|
|
move = (int)dict_get_bool(args, "move", FALSE);
|
|
if (!move && (!dict_has_key(args, "button")
|
|
|| !dict_has_key(args, "multiclick")
|
|
|| !dict_has_key(args, "modifiers")))
|
|
return FALSE;
|
|
|
|
row = (int)dict_get_number(args, "row") - 1;
|
|
col = (int)dict_get_number(args, "col") - 1;
|
|
|
|
ir->EventType = MOUSE_EVENT;
|
|
MOUSE_EVENT_RECORD mer;
|
|
ZeroMemory(&mer, sizeof(mer));
|
|
mer.dwMousePosition.X = col;
|
|
mer.dwMousePosition.Y = row;
|
|
|
|
if (move)
|
|
{
|
|
mer.dwButtonState = 0;
|
|
mer.dwEventFlags = MOUSE_MOVED;
|
|
}
|
|
else
|
|
{
|
|
button = (int)dict_get_number(args, "button");
|
|
repeated_click = (int)dict_get_number(args, "multiclick");
|
|
mods = (int)dict_get_number(args, "modifiers");
|
|
// Reset the scroll values to known values.
|
|
// XXX: Remove this when/if the scroll step is made configurable.
|
|
mouse_set_hor_scroll_step(6);
|
|
mouse_set_vert_scroll_step(3);
|
|
|
|
switch (button)
|
|
{
|
|
case MOUSE_LEFT:
|
|
mer.dwButtonState = FROM_LEFT_1ST_BUTTON_PRESSED;
|
|
mer.dwEventFlags = repeated_click == 1 ? DOUBLE_CLICK : 0;
|
|
break;
|
|
case MOUSE_MIDDLE:
|
|
mer.dwButtonState = FROM_LEFT_2ND_BUTTON_PRESSED;
|
|
mer.dwEventFlags = repeated_click == 1 ? DOUBLE_CLICK : 0;
|
|
break;
|
|
case MOUSE_RIGHT:
|
|
mer.dwButtonState = RIGHTMOST_BUTTON_PRESSED;
|
|
mer.dwEventFlags = repeated_click == 1 ? DOUBLE_CLICK : 0;
|
|
break;
|
|
case MOUSE_RELEASE:
|
|
// umm? Assume Left Release?
|
|
mer.dwEventFlags = 0;
|
|
|
|
case MOUSE_MOVE:
|
|
mer.dwButtonState = 0;
|
|
mer.dwEventFlags = MOUSE_MOVED;
|
|
break;
|
|
case MOUSE_X1:
|
|
mer.dwButtonState = FROM_LEFT_3RD_BUTTON_PRESSED;
|
|
break;
|
|
case MOUSE_X2:
|
|
mer.dwButtonState = FROM_LEFT_4TH_BUTTON_PRESSED;
|
|
break;
|
|
case MOUSE_4: // KE_MOUSEDOWN;
|
|
mer.dwButtonState = -1;
|
|
mer.dwEventFlags = MOUSE_WHEELED;
|
|
break;
|
|
case MOUSE_5: // KE_MOUSEUP;
|
|
mer.dwButtonState = +1;
|
|
mer.dwEventFlags = MOUSE_WHEELED;
|
|
break;
|
|
case MOUSE_6: // KE_MOUSELEFT;
|
|
mer.dwButtonState = -1;
|
|
mer.dwEventFlags = MOUSE_HWHEELED;
|
|
break;
|
|
case MOUSE_7: // KE_MOUSERIGHT;
|
|
mer.dwButtonState = +1;
|
|
mer.dwEventFlags = MOUSE_HWHEELED;
|
|
break;
|
|
default:
|
|
semsg(_(e_invalid_argument_str), "button");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
mer.dwControlKeyState = 0;
|
|
if (mods != 0)
|
|
{
|
|
// Encode the win32 console key modifiers from Vim MOUSE modifiers.
|
|
if (mods & MOUSE_SHIFT)
|
|
mer.dwControlKeyState |= SHIFT_PRESSED;
|
|
if (mods & MOUSE_CTRL)
|
|
mer.dwControlKeyState |= LEFT_CTRL_PRESSED;
|
|
if (mods & MOUSE_ALT)
|
|
mer.dwControlKeyState |= LEFT_ALT_PRESSED;
|
|
}
|
|
ir->Event.MouseEvent = mer;
|
|
return TRUE;
|
|
}
|
|
# endif // FEAT_EVAL
|
|
|
|
static int
|
|
write_input_record_buffer(INPUT_RECORD* irEvents, int nLength)
|
|
{
|
|
int nCount = 0;
|
|
while (nCount < nLength)
|
|
{
|
|
input_record_buffer.length++;
|
|
input_record_buffer_node_T *event_node =
|
|
malloc(sizeof(input_record_buffer_node_T));
|
|
event_node->ir = irEvents[nCount++];
|
|
event_node->next = NULL;
|
|
if (input_record_buffer.tail == NULL)
|
|
{
|
|
input_record_buffer.head = event_node;
|
|
input_record_buffer.tail = event_node;
|
|
}
|
|
else
|
|
{
|
|
input_record_buffer.tail->next = event_node;
|
|
input_record_buffer.tail = input_record_buffer.tail->next;
|
|
}
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
static int
|
|
read_input_record_buffer(INPUT_RECORD* irEvents, int nMaxLength)
|
|
{
|
|
int nCount = 0;
|
|
while (nCount < nMaxLength && input_record_buffer.head != NULL)
|
|
{
|
|
input_record_buffer.length--;
|
|
input_record_buffer_node_T *pop_head = input_record_buffer.head;
|
|
irEvents[nCount++] = pop_head->ir;
|
|
input_record_buffer.head = pop_head->next;
|
|
vim_free(pop_head);
|
|
if (input_record_buffer.length == 0)
|
|
input_record_buffer.tail = NULL;
|
|
}
|
|
return nCount;
|
|
}
|
|
#endif // !FEAT_GUI_MSWIN || VIMDLL
|
|
|
|
#ifdef FEAT_EVAL
|
|
/*
|
|
* The 'test_mswin_event' function is for testing Vim's low-level handling of
|
|
* user input events. ie, this manages the encoding of INPUT_RECORD events
|
|
* so that we have a way to test how Vim decodes INPUT_RECORD events in Windows
|
|
* consoles.
|
|
*
|
|
* The 'test_mswin_event' function is based on 'test_gui_event'. In fact, when
|
|
* the Windows GUI is running, the arguments; 'event' and 'args', are the same.
|
|
* So, it acts as an alias for 'test_gui_event' for the Windows GUI.
|
|
*
|
|
* When the Windows console is running, the arguments; 'event' and 'args', are
|
|
* a subset of what 'test_gui_event' handles, ie, only "key" and "mouse"
|
|
* events are encoded as INPUT_RECORD events.
|
|
*
|
|
* Note: INPUT_RECORDs are only used by the Windows console, not the GUI. The
|
|
* GUI sends MSG structs instead.
|
|
*/
|
|
int
|
|
test_mswin_event(char_u *event, dict_T *args)
|
|
{
|
|
int lpEventsWritten = 0;
|
|
|
|
# if defined(VIMDLL) || defined(FEAT_GUI_MSWIN)
|
|
if (gui.in_use)
|
|
return test_gui_w32_sendevent(event, args);
|
|
# endif
|
|
|
|
# if defined(VIMDLL) || !defined(FEAT_GUI_MSWIN)
|
|
|
|
// Currently implemented event record types are; KEY_EVENT and MOUSE_EVENT
|
|
// Potentially could also implement: FOCUS_EVENT and WINDOW_BUFFER_SIZE_EVENT
|
|
// Maybe also: MENU_EVENT
|
|
|
|
INPUT_RECORD ir;
|
|
BOOL input_encoded = FALSE;
|
|
BOOL execute = FALSE;
|
|
if (STRCMP(event, "key") == 0)
|
|
{
|
|
execute = dict_get_bool(args, "execute", FALSE);
|
|
if (dict_has_key(args, "event"))
|
|
input_encoded = encode_key_event(args, &ir);
|
|
else if (!execute)
|
|
{
|
|
semsg(_(e_missing_argument_str), "event");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (STRCMP(event, "mouse") == 0)
|
|
{
|
|
execute = TRUE;
|
|
input_encoded = encode_mouse_event(args, &ir);
|
|
}
|
|
else
|
|
{
|
|
semsg(_(e_invalid_value_for_argument_str_str), "event", event);
|
|
return FALSE;
|
|
}
|
|
|
|
// Ideally, WriteConsoleInput would be used to inject these low-level
|
|
// events. But, this doesn't work well in the CI test environment. So
|
|
// implementing an input_record_buffer instead.
|
|
if (input_encoded)
|
|
lpEventsWritten = write_input_record_buffer(&ir, 1);
|
|
|
|
// Set flags to execute the event, ie. like feedkeys mode X.
|
|
if (execute)
|
|
{
|
|
int save_msg_scroll = msg_scroll;
|
|
// Avoid a 1 second delay when the keys start Insert mode.
|
|
msg_scroll = FALSE;
|
|
ch_log(NULL, "test_mswin_event() executing");
|
|
exec_normal(TRUE, TRUE, TRUE);
|
|
msg_scroll |= save_msg_scroll;
|
|
}
|
|
|
|
# endif
|
|
return lpEventsWritten;
|
|
}
|
|
#endif // FEAT_EVAL
|
|
|
|
#ifdef MCH_CURSOR_SHAPE
|
|
/*
|
|
* Set the shape of the cursor.
|
|
* 'thickness' can be from 1 (thin) to 99 (block)
|
|
*/
|
|
static void
|
|
mch_set_cursor_shape(int thickness)
|
|
{
|
|
if (vtp_working)
|
|
{
|
|
if (*T_CSI == NUL)
|
|
{
|
|
// If 't_SI' is not set, use the default cursor styles.
|
|
if (thickness < 50)
|
|
vtp_printf("\033[3 q"); // underline
|
|
else
|
|
vtp_printf("\033[0 q"); // default
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CONSOLE_CURSOR_INFO ConsoleCursorInfo;
|
|
ConsoleCursorInfo.dwSize = thickness;
|
|
ConsoleCursorInfo.bVisible = s_cursor_visible;
|
|
|
|
SetConsoleCursorInfo(g_hConOut, &ConsoleCursorInfo);
|
|
if (s_cursor_visible)
|
|
SetConsoleCursorPosition(g_hConOut, g_coord);
|
|
}
|
|
}
|
|
|
|
void
|
|
mch_update_cursor(void)
|
|
{
|
|
int idx;
|
|
int thickness;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
|
|
/*
|
|
* How the cursor is drawn depends on the current mode.
|
|
*/
|
|
idx = get_shape_idx(FALSE);
|
|
|
|
if (shape_table[idx].shape == SHAPE_BLOCK)
|
|
thickness = 99; // 100 doesn't work on W95
|
|
else
|
|
thickness = shape_table[idx].percentage;
|
|
mch_set_cursor_shape(thickness);
|
|
}
|
|
#endif
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
/*
|
|
* Handle FOCUS_EVENT.
|
|
*/
|
|
static void
|
|
handle_focus_event(INPUT_RECORD ir)
|
|
{
|
|
g_fJustGotFocus = ir.Event.FocusEvent.bSetFocus;
|
|
ui_focus_change((int)g_fJustGotFocus);
|
|
}
|
|
|
|
static void ResizeConBuf(HANDLE hConsole, COORD coordScreen);
|
|
|
|
/*
|
|
* Wait until console input from keyboard or mouse is available,
|
|
* or the time is up.
|
|
* When "ignore_input" is TRUE even wait when input is available.
|
|
* Return TRUE if something is available FALSE if not.
|
|
*/
|
|
static int
|
|
WaitForChar(long msec, int ignore_input)
|
|
{
|
|
DWORD dwNow = 0, dwEndTime = 0;
|
|
INPUT_RECORD ir;
|
|
DWORD cRecords;
|
|
WCHAR ch, ch2;
|
|
# ifdef FEAT_TIMERS
|
|
int tb_change_cnt = typebuf.tb_change_cnt;
|
|
# endif
|
|
|
|
if (msec > 0)
|
|
// Wait until the specified time has elapsed.
|
|
dwEndTime = GetTickCount() + msec;
|
|
else if (msec < 0)
|
|
// Wait forever.
|
|
dwEndTime = INFINITE;
|
|
|
|
// We need to loop until the end of the time period, because
|
|
// we might get multiple unusable mouse events in that time.
|
|
for (;;)
|
|
{
|
|
// Only process messages when waiting.
|
|
if (msec != 0)
|
|
{
|
|
# ifdef MESSAGE_QUEUE
|
|
parse_queued_messages();
|
|
# endif
|
|
# ifdef FEAT_MZSCHEME
|
|
mzvim_check_threads();
|
|
# endif
|
|
# ifdef FEAT_CLIENTSERVER
|
|
serverProcessPendingMessages();
|
|
# endif
|
|
}
|
|
|
|
if (g_nMouseClick != -1
|
|
# ifdef FEAT_CLIENTSERVER
|
|
|| (!ignore_input && input_available())
|
|
# endif
|
|
)
|
|
return TRUE;
|
|
|
|
if (msec > 0)
|
|
{
|
|
// If the specified wait time has passed, return. Beware that
|
|
// GetTickCount() may wrap around (overflow).
|
|
dwNow = GetTickCount();
|
|
if ((int)(dwNow - dwEndTime) >= 0)
|
|
break;
|
|
}
|
|
if (msec != 0)
|
|
{
|
|
DWORD dwWaitTime = dwEndTime - dwNow;
|
|
|
|
// Don't wait for more than 11 msec to avoid dropping characters,
|
|
// check channel while waiting for input and handle a callback from
|
|
// 'balloonexpr'.
|
|
if (dwWaitTime > 11)
|
|
dwWaitTime = 11;
|
|
|
|
# ifdef FEAT_MZSCHEME
|
|
if (mzthreads_allowed() && p_mzq > 0 && (long)dwWaitTime > p_mzq)
|
|
dwWaitTime = p_mzq; // don't wait longer than 'mzquantum'
|
|
# endif
|
|
# ifdef FEAT_TIMERS
|
|
// When waiting very briefly don't trigger timers.
|
|
if (dwWaitTime > 10)
|
|
{
|
|
long due_time;
|
|
|
|
// Trigger timers and then get the time in msec until the next
|
|
// one is due. Wait up to that time.
|
|
due_time = check_due_timer();
|
|
if (typebuf.tb_change_cnt != tb_change_cnt)
|
|
{
|
|
// timer may have used feedkeys().
|
|
return FALSE;
|
|
}
|
|
if (due_time > 0 && dwWaitTime > (DWORD)due_time)
|
|
dwWaitTime = due_time;
|
|
}
|
|
# endif
|
|
if (
|
|
# ifdef FEAT_CLIENTSERVER
|
|
// Wait for either an event on the console input or a
|
|
// message in the client-server window.
|
|
msg_wait_for_multiple_objects(1, &g_hConIn, FALSE,
|
|
dwWaitTime, QS_SENDMESSAGE) != WAIT_OBJECT_0
|
|
# else
|
|
wait_for_single_object(g_hConIn, dwWaitTime)
|
|
!= WAIT_OBJECT_0
|
|
# endif
|
|
)
|
|
continue;
|
|
}
|
|
|
|
cRecords = 0;
|
|
peek_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
# ifdef FEAT_MBYTE_IME
|
|
// May have to redraw if the cursor ends up in the wrong place.
|
|
// Only when not peeking.
|
|
if (State == MODE_CMDLINE && msg_row == Rows - 1 && msec != 0)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
|
|
if (GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
{
|
|
if (csbi.dwCursorPosition.Y != msg_row)
|
|
{
|
|
// The screen is now messed up, must redraw the command
|
|
// line and later all the windows.
|
|
redraw_all_later(UPD_CLEAR);
|
|
compute_cmdrow();
|
|
redrawcmd();
|
|
}
|
|
}
|
|
}
|
|
# endif
|
|
|
|
if (cRecords > 0)
|
|
{
|
|
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown)
|
|
{
|
|
# ifdef FEAT_MBYTE_IME
|
|
// Windows IME sends two '\n's with only one 'ENTER'. First:
|
|
// wVirtualKeyCode == 13. second: wVirtualKeyCode == 0
|
|
if (ir.Event.KeyEvent.uChar.UnicodeChar == 0
|
|
&& ir.Event.KeyEvent.wVirtualKeyCode == 13)
|
|
{
|
|
read_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
continue;
|
|
}
|
|
# endif
|
|
if (decode_key_event(&ir.Event.KeyEvent, &ch, &ch2,
|
|
NULL, FALSE))
|
|
return TRUE;
|
|
}
|
|
|
|
read_console_input(g_hConIn, &ir, 1, &cRecords);
|
|
|
|
if (ir.EventType == FOCUS_EVENT)
|
|
handle_focus_event(ir);
|
|
else if (ir.EventType == WINDOW_BUFFER_SIZE_EVENT)
|
|
{
|
|
COORD dwSize = ir.Event.WindowBufferSizeEvent.dwSize;
|
|
|
|
// Only call shell_resized() when the size actually changed to
|
|
// avoid the screen is cleared.
|
|
if (dwSize.X != Columns || dwSize.Y != Rows)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
GetConsoleScreenBufferInfo(g_hConOut, &csbi);
|
|
dwSize.X = csbi.srWindow.Right - csbi.srWindow.Left + 1;
|
|
dwSize.Y = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
|
|
if (dwSize.X != Columns || dwSize.Y != Rows)
|
|
{
|
|
ResizeConBuf(g_hConOut, dwSize);
|
|
shell_resized();
|
|
}
|
|
}
|
|
}
|
|
else if (ir.EventType == MOUSE_EVENT
|
|
&& decode_mouse_event(&ir.Event.MouseEvent))
|
|
return TRUE;
|
|
}
|
|
else if (msec == 0)
|
|
break;
|
|
}
|
|
|
|
# ifdef FEAT_CLIENTSERVER
|
|
// Something might have been received while we were waiting.
|
|
if (input_available())
|
|
return TRUE;
|
|
# endif
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* return non-zero if a character is available
|
|
*/
|
|
int
|
|
mch_char_avail(void)
|
|
{
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return TRUE;
|
|
# endif
|
|
return WaitForChar(0L, FALSE);
|
|
}
|
|
|
|
# if defined(FEAT_TERMINAL) || defined(PROTO)
|
|
/*
|
|
* Check for any pending input or messages.
|
|
*/
|
|
int
|
|
mch_check_messages(void)
|
|
{
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return TRUE;
|
|
# endif
|
|
return WaitForChar(0L, TRUE);
|
|
}
|
|
# endif
|
|
|
|
/*
|
|
* Create the console input. Used when reading stdin doesn't work.
|
|
*/
|
|
static void
|
|
create_conin(void)
|
|
{
|
|
g_hConIn = CreateFile("CONIN$", GENERIC_READ|GENERIC_WRITE,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
(LPSECURITY_ATTRIBUTES) NULL,
|
|
OPEN_EXISTING, 0, (HANDLE)NULL);
|
|
did_create_conin = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Get a keystroke or a mouse event, use a blocking wait.
|
|
*/
|
|
static WCHAR
|
|
tgetch(int *pmodifiers, WCHAR *pch2)
|
|
{
|
|
WCHAR ch;
|
|
|
|
for (;;)
|
|
{
|
|
INPUT_RECORD ir;
|
|
DWORD cRecords = 0;
|
|
|
|
# ifdef FEAT_CLIENTSERVER
|
|
(void)WaitForChar(-1L, FALSE);
|
|
if (input_available())
|
|
return 0;
|
|
if (g_nMouseClick != -1)
|
|
return 0;
|
|
# endif
|
|
if (read_console_input(g_hConIn, &ir, 1, &cRecords) == 0)
|
|
{
|
|
if (did_create_conin)
|
|
read_error_exit();
|
|
create_conin();
|
|
continue;
|
|
}
|
|
|
|
if (ir.EventType == KEY_EVENT)
|
|
{
|
|
if (decode_key_event(&ir.Event.KeyEvent, &ch, pch2,
|
|
pmodifiers, TRUE))
|
|
return ch;
|
|
}
|
|
else if (ir.EventType == FOCUS_EVENT)
|
|
handle_focus_event(ir);
|
|
else if (ir.EventType == WINDOW_BUFFER_SIZE_EVENT)
|
|
shell_resized();
|
|
else if (ir.EventType == MOUSE_EVENT)
|
|
{
|
|
if (decode_mouse_event(&ir.Event.MouseEvent))
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
#endif // !FEAT_GUI_MSWIN
|
|
|
|
|
|
/*
|
|
* mch_inchar(): low-level input function.
|
|
* Get one or more characters from the keyboard or the mouse.
|
|
* If time == 0, do not wait for characters.
|
|
* If time == n, wait a short time for characters.
|
|
* If time == -1, wait forever for characters.
|
|
* Returns the number of characters read into buf.
|
|
*/
|
|
int
|
|
mch_inchar(
|
|
char_u *buf UNUSED,
|
|
int maxlen UNUSED,
|
|
long time UNUSED,
|
|
int tb_change_cnt UNUSED)
|
|
{
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
|
|
int len;
|
|
int c;
|
|
# ifdef VIMDLL
|
|
// Extra space for maximum three CSIs. E.g. U+1B6DB -> 0xF0 0x9B 0x9B 0x9B.
|
|
# define TYPEAHEADSPACE 6
|
|
# else
|
|
# define TYPEAHEADSPACE 0
|
|
# endif
|
|
# define TYPEAHEADLEN (20 + TYPEAHEADSPACE)
|
|
static char_u typeahead[TYPEAHEADLEN]; // previously typed bytes.
|
|
static int typeaheadlen = 0;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return 0;
|
|
# endif
|
|
|
|
// First use any typeahead that was kept because "buf" was too small.
|
|
if (typeaheadlen > 0)
|
|
goto theend;
|
|
|
|
if (time >= 0)
|
|
{
|
|
if (!WaitForChar(time, FALSE)) // no character available
|
|
return 0;
|
|
}
|
|
else // time == -1, wait forever
|
|
{
|
|
mch_set_winsize_now(); // Allow winsize changes from now on
|
|
|
|
/*
|
|
* If there is no character available within 2 seconds (default)
|
|
* write the autoscript file to disk. Or cause the CursorHold event
|
|
* to be triggered.
|
|
*/
|
|
if (!WaitForChar(p_ut, FALSE))
|
|
{
|
|
if (trigger_cursorhold() && maxlen >= 3)
|
|
{
|
|
buf[0] = K_SPECIAL;
|
|
buf[1] = KS_EXTRA;
|
|
buf[2] = (int)KE_CURSORHOLD;
|
|
return 3;
|
|
}
|
|
before_blocking();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Try to read as many characters as there are, until the buffer is full.
|
|
*/
|
|
|
|
// we will get at least one key. Get more if they are available.
|
|
g_fCBrkPressed = FALSE;
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputc('[', fdDump);
|
|
# endif
|
|
|
|
// Keep looping until there is something in the typeahead buffer and more
|
|
// to get and still room in the buffer (up to two bytes for a char and
|
|
// three bytes for a modifier).
|
|
while ((typeaheadlen == 0 || WaitForChar(0L, FALSE))
|
|
&& typeaheadlen + 5 + TYPEAHEADSPACE <= TYPEAHEADLEN)
|
|
{
|
|
if (typebuf_changed(tb_change_cnt))
|
|
{
|
|
// "buf" may be invalid now if a client put something in the
|
|
// typeahead buffer and "buf" is in the typeahead buffer.
|
|
typeaheadlen = 0;
|
|
break;
|
|
}
|
|
if (g_nMouseClick != -1)
|
|
{
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fprintf(fdDump, "{%02x @ %d, %d}",
|
|
g_nMouseClick, g_xMouse, g_yMouse);
|
|
# endif
|
|
char_u modifiers = ((char_u *)(&g_nMouseClick))[0];
|
|
char_u scroll_dir = ((char_u *)(&g_nMouseClick))[1];
|
|
|
|
if (scroll_dir == KE_MOUSEDOWN
|
|
|| scroll_dir == KE_MOUSEUP
|
|
|| scroll_dir == KE_MOUSELEFT
|
|
|| scroll_dir == KE_MOUSERIGHT)
|
|
{
|
|
if (modifiers > 0)
|
|
{
|
|
// use K_SPECIAL instead of CSI to make mappings work
|
|
typeahead[typeaheadlen++] = K_SPECIAL;
|
|
typeahead[typeaheadlen++] = KS_MODIFIER;
|
|
typeahead[typeaheadlen++] = modifiers;
|
|
}
|
|
typeahead[typeaheadlen++] = CSI;
|
|
typeahead[typeaheadlen++] = KS_EXTRA;
|
|
typeahead[typeaheadlen++] = scroll_dir;
|
|
}
|
|
else
|
|
{
|
|
typeahead[typeaheadlen++] = ESC + 128;
|
|
typeahead[typeaheadlen++] = 'M';
|
|
typeahead[typeaheadlen++] = g_nMouseClick;
|
|
}
|
|
|
|
// Pass the pointer coordinates of the mouse event in 2 bytes,
|
|
// allowing for > 223 columns. Both for click and scroll events.
|
|
// This is the same as what is used for the GUI.
|
|
typeahead[typeaheadlen++] = (char_u)(g_xMouse / 128 + ' ' + 1);
|
|
typeahead[typeaheadlen++] = (char_u)(g_xMouse % 128 + ' ' + 1);
|
|
typeahead[typeaheadlen++] = (char_u)(g_yMouse / 128 + ' ' + 1);
|
|
typeahead[typeaheadlen++] = (char_u)(g_yMouse % 128 + ' ' + 1);
|
|
|
|
g_nMouseClick = -1;
|
|
}
|
|
else
|
|
{
|
|
WCHAR ch2 = NUL;
|
|
int modifiers = 0;
|
|
|
|
c = tgetch(&modifiers, &ch2);
|
|
|
|
c = simplify_key(c, &modifiers);
|
|
|
|
// Some chars need adjustment when the Ctrl modifier is used.
|
|
++no_reduce_keys;
|
|
c = may_adjust_key_for_ctrl(modifiers, c);
|
|
--no_reduce_keys;
|
|
|
|
// remove the SHIFT modifier for keys where it's already included,
|
|
// e.g., '(' and '*'
|
|
modifiers = may_remove_shift_modifier(modifiers, c);
|
|
|
|
if (typebuf_changed(tb_change_cnt))
|
|
{
|
|
// "buf" may be invalid now if a client put something in the
|
|
// typeahead buffer and "buf" is in the typeahead buffer.
|
|
typeaheadlen = 0;
|
|
break;
|
|
}
|
|
|
|
if (c == Ctrl_C && ctrl_c_interrupts)
|
|
{
|
|
# if defined(FEAT_CLIENTSERVER)
|
|
trash_input_buf();
|
|
# endif
|
|
got_int = TRUE;
|
|
}
|
|
|
|
if (g_nMouseClick == -1)
|
|
{
|
|
int n = 1;
|
|
|
|
if (ch2 == NUL)
|
|
{
|
|
int i, j;
|
|
char_u *p;
|
|
WCHAR ch[2];
|
|
|
|
ch[0] = c;
|
|
if (c >= 0xD800 && c <= 0xDBFF) // High surrogate
|
|
{
|
|
ch[1] = tgetch(&modifiers, &ch2);
|
|
n++;
|
|
}
|
|
p = utf16_to_enc(ch, &n);
|
|
if (p != NULL)
|
|
{
|
|
for (i = 0, j = 0; i < n; i++)
|
|
{
|
|
typeahead[typeaheadlen + j++] = p[i];
|
|
# ifdef VIMDLL
|
|
if (p[i] == CSI)
|
|
{
|
|
typeahead[typeaheadlen + j++] = KS_EXTRA;
|
|
typeahead[typeaheadlen + j++] = KE_CSI;
|
|
}
|
|
# endif
|
|
}
|
|
n = j;
|
|
vim_free(p);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
typeahead[typeaheadlen] = c;
|
|
# ifdef VIMDLL
|
|
if (c == CSI)
|
|
{
|
|
typeahead[typeaheadlen + 1] = KS_EXTRA;
|
|
typeahead[typeaheadlen + 2] = KE_CSI;
|
|
n = 3;
|
|
}
|
|
# endif
|
|
}
|
|
if (ch2 != NUL)
|
|
{
|
|
if (c == K_NUL)
|
|
{
|
|
switch (ch2)
|
|
{
|
|
case (WCHAR)'\324': // SHIFT+Insert
|
|
case (WCHAR)'\325': // CTRL+Insert
|
|
case (WCHAR)'\327': // SHIFT+Delete
|
|
case (WCHAR)'\330': // CTRL+Delete
|
|
typeahead[typeaheadlen + n] = (char_u)ch2;
|
|
n++;
|
|
break;
|
|
|
|
default:
|
|
typeahead[typeaheadlen + n] = 3;
|
|
typeahead[typeaheadlen + n + 1] = (char_u)ch2;
|
|
n += 2;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
typeahead[typeaheadlen + n] = 3;
|
|
typeahead[typeaheadlen + n + 1] = (char_u)ch2;
|
|
n += 2;
|
|
}
|
|
}
|
|
|
|
// Use the ALT key to set the 8th bit of the character
|
|
// when it's one byte, the 8th bit isn't set yet and not
|
|
// using a double-byte encoding (would become a lead
|
|
// byte).
|
|
if ((modifiers & MOD_MASK_ALT)
|
|
&& n == 1
|
|
&& (typeahead[typeaheadlen] & 0x80) == 0
|
|
&& !enc_dbcs
|
|
)
|
|
{
|
|
n = (*mb_char2bytes)(typeahead[typeaheadlen] | 0x80,
|
|
typeahead + typeaheadlen);
|
|
modifiers &= ~MOD_MASK_ALT;
|
|
}
|
|
|
|
if (modifiers != 0)
|
|
{
|
|
// Prepend modifiers to the character.
|
|
mch_memmove(typeahead + typeaheadlen + 3,
|
|
typeahead + typeaheadlen, n);
|
|
typeahead[typeaheadlen++] = K_SPECIAL;
|
|
typeahead[typeaheadlen++] = (char_u)KS_MODIFIER;
|
|
typeahead[typeaheadlen++] = modifiers;
|
|
}
|
|
|
|
typeaheadlen += n;
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputc(c, fdDump);
|
|
# endif
|
|
}
|
|
}
|
|
}
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fputs("]\n", fdDump);
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
|
|
theend:
|
|
// Move typeahead to "buf", as much as fits.
|
|
len = 0;
|
|
while (len < maxlen && typeaheadlen > 0)
|
|
{
|
|
buf[len++] = typeahead[0];
|
|
mch_memmove(typeahead, typeahead + 1, --typeaheadlen);
|
|
}
|
|
# ifdef FEAT_EVAL
|
|
if (len > 0)
|
|
{
|
|
buf[len] = NUL;
|
|
ch_log(NULL, "raw key input: \"%s\"", buf);
|
|
}
|
|
# endif
|
|
return len;
|
|
|
|
#else // FEAT_GUI_MSWIN
|
|
return 0;
|
|
#endif // FEAT_GUI_MSWIN
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "name" is an executable file, FALSE if not or it doesn't exist.
|
|
* When returning TRUE and "path" is not NULL save the path and set "*path" to
|
|
* the allocated memory.
|
|
* TODO: Should somehow check if it's really executable.
|
|
*/
|
|
static int
|
|
executable_file(char *name, char_u **path)
|
|
{
|
|
int attrs = win32_getattrs((char_u *)name);
|
|
|
|
// The file doesn't exist or is a folder.
|
|
if (attrs == -1 || (attrs & FILE_ATTRIBUTE_DIRECTORY))
|
|
return FALSE;
|
|
// Check if the file is an AppExecLink, a special alias used by Windows
|
|
// Store for its apps.
|
|
if (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
|
|
{
|
|
char_u *res = resolve_appexeclink((char_u *)name);
|
|
if (res == NULL)
|
|
res = resolve_reparse_point((char_u *)name);
|
|
if (res == NULL)
|
|
return FALSE;
|
|
// The path is already absolute.
|
|
if (path != NULL)
|
|
*path = res;
|
|
else
|
|
vim_free(res);
|
|
}
|
|
else if (path != NULL)
|
|
*path = FullName_save((char_u *)name, FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* If "use_path" is TRUE: Return TRUE if "name" is in $PATH.
|
|
* If "use_path" is FALSE: Return TRUE if "name" exists.
|
|
* If "use_pathext" is TRUE search "name" with extensions in $PATHEXT.
|
|
* When returning TRUE and "path" is not NULL save the path and set "*path" to
|
|
* the allocated memory.
|
|
*/
|
|
static int
|
|
executable_exists(char *name, char_u **path, int use_path, int use_pathext)
|
|
{
|
|
// 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];
|
|
size_t len = STRLEN(name);
|
|
size_t tmplen;
|
|
char_u *p, *e, *e2;
|
|
char_u *pathbuf = NULL;
|
|
char_u *pathext = NULL;
|
|
char_u *pathextbuf = NULL;
|
|
char_u *shname = NULL;
|
|
int noext = FALSE;
|
|
int retval = FALSE;
|
|
|
|
if (len >= sizeof(buf)) // safety check
|
|
return FALSE;
|
|
|
|
// Using the name directly when a Unix-shell like 'shell'.
|
|
shname = gettail(p_sh);
|
|
if (strstr((char *)shname, "sh") != NULL &&
|
|
!(strstr((char *)shname, "powershell") != NULL
|
|
|| strstr((char *)shname, "pwsh") != NULL))
|
|
noext = TRUE;
|
|
|
|
if (use_pathext)
|
|
{
|
|
pathext = mch_getenv("PATHEXT");
|
|
if (pathext == NULL)
|
|
pathext = (char_u *)".com;.exe;.bat;.cmd";
|
|
|
|
if (noext == FALSE)
|
|
{
|
|
/*
|
|
* Loop over all extensions in $PATHEXT.
|
|
* Check "name" ends with extension.
|
|
*/
|
|
p = pathext;
|
|
while (*p)
|
|
{
|
|
if (p[0] == ';'
|
|
|| (p[0] == '.' && (p[1] == NUL || p[1] == ';')))
|
|
{
|
|
// Skip empty or single ".".
|
|
++p;
|
|
continue;
|
|
}
|
|
e = vim_strchr(p, ';');
|
|
if (e == NULL)
|
|
e = p + STRLEN(p);
|
|
tmplen = e - p;
|
|
|
|
if (_strnicoll(name + len - tmplen, (char *)p, tmplen) == 0)
|
|
{
|
|
noext = TRUE;
|
|
break;
|
|
}
|
|
|
|
p = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prepend single "." to pathext, it means no extension added.
|
|
if (pathext == NULL)
|
|
pathext = (char_u *)".";
|
|
else if (noext == TRUE)
|
|
{
|
|
if (pathextbuf == NULL)
|
|
pathextbuf = alloc(STRLEN(pathext) + 3);
|
|
if (pathextbuf == NULL)
|
|
{
|
|
retval = FALSE;
|
|
goto theend;
|
|
}
|
|
STRCPY(pathextbuf, ".;");
|
|
STRCAT(pathextbuf, pathext);
|
|
pathext = pathextbuf;
|
|
}
|
|
|
|
// Use $PATH when "use_path" is TRUE and "name" is basename.
|
|
if (use_path && gettail((char_u *)name) == (char_u *)name)
|
|
{
|
|
p = mch_getenv("PATH");
|
|
if (p != NULL)
|
|
{
|
|
pathbuf = alloc(STRLEN(p) + 3);
|
|
if (pathbuf == NULL)
|
|
{
|
|
retval = FALSE;
|
|
goto theend;
|
|
}
|
|
|
|
if (mch_getenv("NoDefaultCurrentDirectoryInExePath") == NULL)
|
|
STRCPY(pathbuf, ".;");
|
|
else
|
|
*pathbuf = NUL;
|
|
STRCAT(pathbuf, p);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Walk through all entries in $PATH to check if "name" exists there and
|
|
* is an executable file.
|
|
*/
|
|
p = (pathbuf != NULL) ? pathbuf : (char_u *)".";
|
|
while (*p)
|
|
{
|
|
if (*p == ';') // Skip empty entry
|
|
{
|
|
++p;
|
|
continue;
|
|
}
|
|
e = vim_strchr(p, ';');
|
|
if (e == NULL)
|
|
e = p + STRLEN(p);
|
|
|
|
if (e - p + len + 2 > sizeof(buf))
|
|
{
|
|
retval = FALSE;
|
|
goto theend;
|
|
}
|
|
// A single "." that means current dir.
|
|
if (e - p == 1 && *p == '.')
|
|
STRCPY(buf, name);
|
|
else
|
|
{
|
|
vim_strncpy(buf, p, e - p);
|
|
add_pathsep(buf);
|
|
STRCAT(buf, name);
|
|
}
|
|
tmplen = STRLEN(buf);
|
|
|
|
/*
|
|
* Loop over all extensions in $PATHEXT.
|
|
* Check "name" with extension added.
|
|
*/
|
|
p = pathext;
|
|
while (*p)
|
|
{
|
|
if (*p == ';')
|
|
{
|
|
// Skip empty entry
|
|
++p;
|
|
continue;
|
|
}
|
|
e2 = vim_strchr(p, (int)';');
|
|
if (e2 == NULL)
|
|
e2 = p + STRLEN(p);
|
|
|
|
if (!(p[0] == '.' && (p[1] == NUL || p[1] == ';')))
|
|
{
|
|
// Not a single "." that means no extension is added.
|
|
if (e2 - p + tmplen + 1 > sizeof(buf))
|
|
{
|
|
retval = FALSE;
|
|
goto theend;
|
|
}
|
|
vim_strncpy(buf + tmplen, p, e2 - p);
|
|
}
|
|
if (executable_file((char *)buf, path))
|
|
{
|
|
retval = TRUE;
|
|
goto theend;
|
|
}
|
|
|
|
p = e2;
|
|
}
|
|
|
|
p = e;
|
|
}
|
|
|
|
theend:
|
|
free(pathextbuf);
|
|
free(pathbuf);
|
|
return retval;
|
|
}
|
|
|
|
#if (defined(__MINGW32__) && __MSVCRT_VERSION__ >= 0x800) || \
|
|
(defined(_MSC_VER) && _MSC_VER >= 1400)
|
|
/*
|
|
* Bad parameter handler.
|
|
*
|
|
* Certain MS CRT functions will intentionally crash when passed invalid
|
|
* parameters to highlight possible security holes. Setting this function as
|
|
* the bad parameter handler will prevent the crash.
|
|
*
|
|
* In debug builds the parameters contain CRT information that might help track
|
|
* down the source of a problem, but in non-debug builds the arguments are all
|
|
* NULL/0. Debug builds will also produce assert dialogs from the CRT, it is
|
|
* worth allowing these to make debugging of issues easier.
|
|
*/
|
|
static void
|
|
bad_param_handler(const wchar_t *expression UNUSED,
|
|
const wchar_t *function UNUSED,
|
|
const wchar_t *file UNUSED,
|
|
unsigned int line UNUSED,
|
|
uintptr_t pReserved UNUSED)
|
|
{
|
|
}
|
|
|
|
# define SET_INVALID_PARAM_HANDLER \
|
|
((void)_set_invalid_parameter_handler(bad_param_handler))
|
|
#else
|
|
# define SET_INVALID_PARAM_HANDLER
|
|
#endif
|
|
|
|
#ifdef FEAT_GUI_MSWIN
|
|
|
|
/*
|
|
* GUI version of mch_init().
|
|
*/
|
|
static void
|
|
mch_init_g(void)
|
|
{
|
|
# ifndef __MINGW32__
|
|
extern int _fmode;
|
|
# endif
|
|
|
|
// Silently handle invalid parameters to CRT functions
|
|
SET_INVALID_PARAM_HANDLER;
|
|
|
|
// Let critical errors result in a failure, not in a dialog box. Required
|
|
// for the timestamp test to work on removed floppies.
|
|
SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
_fmode = O_BINARY; // we do our own CR-LF translation
|
|
|
|
// Specify window size. Is there a place to get the default from?
|
|
Rows = 25;
|
|
Columns = 80;
|
|
|
|
// Look for 'vimrun'
|
|
{
|
|
char_u vimrun_location[_MAX_PATH + 4];
|
|
|
|
// First try in same directory as gvim.exe
|
|
STRCPY(vimrun_location, exe_name);
|
|
STRCPY(gettail(vimrun_location), "vimrun.exe");
|
|
if (mch_getperm(vimrun_location) >= 0)
|
|
{
|
|
if (*skiptowhite(vimrun_location) != NUL)
|
|
{
|
|
// Enclose path with white space in double quotes.
|
|
mch_memmove(vimrun_location + 1, vimrun_location,
|
|
STRLEN(vimrun_location) + 1);
|
|
*vimrun_location = '"';
|
|
STRCPY(gettail(vimrun_location), "vimrun\" ");
|
|
}
|
|
else
|
|
STRCPY(gettail(vimrun_location), "vimrun ");
|
|
|
|
vimrun_path = (char *)vim_strsave(vimrun_location);
|
|
s_dont_use_vimrun = FALSE;
|
|
}
|
|
else if (executable_exists("vimrun.exe", NULL, TRUE, FALSE))
|
|
s_dont_use_vimrun = FALSE;
|
|
|
|
// Don't give the warning for a missing vimrun.exe right now, but only
|
|
// when vimrun was supposed to be used. Don't bother people that do
|
|
// not need vimrun.exe.
|
|
if (s_dont_use_vimrun)
|
|
need_vimrun_warning = TRUE;
|
|
}
|
|
|
|
/*
|
|
* If "finstr.exe" doesn't exist, use "grep -n" for 'grepprg'.
|
|
* Otherwise the default "findstr /n" is used.
|
|
*/
|
|
if (!executable_exists("findstr.exe", NULL, TRUE, FALSE))
|
|
set_option_value_give_err((char_u *)"grepprg",
|
|
0, (char_u *)"grep -n", 0);
|
|
|
|
# ifdef FEAT_CLIPBOARD
|
|
win_clip_init();
|
|
# endif
|
|
|
|
vtp_flag_init();
|
|
}
|
|
|
|
|
|
#endif // FEAT_GUI_MSWIN
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
|
|
# define SRWIDTH(sr) ((sr).Right - (sr).Left + 1)
|
|
# define SRHEIGHT(sr) ((sr).Bottom - (sr).Top + 1)
|
|
|
|
/*
|
|
* ClearConsoleBuffer()
|
|
* Description:
|
|
* Clears the entire contents of the console screen buffer, using the
|
|
* specified attribute.
|
|
* Returns:
|
|
* TRUE on success
|
|
*/
|
|
static BOOL
|
|
ClearConsoleBuffer(WORD wAttribute)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
COORD coord;
|
|
DWORD NumCells, dummy;
|
|
|
|
if (!GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
return FALSE;
|
|
|
|
NumCells = csbi.dwSize.X * csbi.dwSize.Y;
|
|
coord.X = 0;
|
|
coord.Y = 0;
|
|
if (!FillConsoleOutputCharacter(g_hConOut, ' ', NumCells,
|
|
coord, &dummy))
|
|
return FALSE;
|
|
if (!FillConsoleOutputAttribute(g_hConOut, wAttribute, NumCells,
|
|
coord, &dummy))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* FitConsoleWindow()
|
|
* Description:
|
|
* Checks if the console window will fit within given buffer dimensions.
|
|
* Also, if requested, will shrink the window to fit.
|
|
* Returns:
|
|
* TRUE on success
|
|
*/
|
|
static BOOL
|
|
FitConsoleWindow(
|
|
COORD dwBufferSize,
|
|
BOOL WantAdjust)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
COORD dwWindowSize;
|
|
BOOL NeedAdjust = FALSE;
|
|
|
|
if (!GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
return FALSE;
|
|
|
|
/*
|
|
* A buffer resize will fail if the current console window does
|
|
* not lie completely within that buffer. To avoid this, we might
|
|
* have to move and possibly shrink the window.
|
|
*/
|
|
if (csbi.srWindow.Right >= dwBufferSize.X)
|
|
{
|
|
dwWindowSize.X = SRWIDTH(csbi.srWindow);
|
|
if (dwWindowSize.X > dwBufferSize.X)
|
|
dwWindowSize.X = dwBufferSize.X;
|
|
csbi.srWindow.Right = dwBufferSize.X - 1;
|
|
csbi.srWindow.Left = dwBufferSize.X - dwWindowSize.X;
|
|
NeedAdjust = TRUE;
|
|
}
|
|
if (csbi.srWindow.Bottom >= dwBufferSize.Y)
|
|
{
|
|
dwWindowSize.Y = SRHEIGHT(csbi.srWindow);
|
|
if (dwWindowSize.Y > dwBufferSize.Y)
|
|
dwWindowSize.Y = dwBufferSize.Y;
|
|
csbi.srWindow.Bottom = dwBufferSize.Y - 1;
|
|
csbi.srWindow.Top = dwBufferSize.Y - dwWindowSize.Y;
|
|
NeedAdjust = TRUE;
|
|
}
|
|
if (NeedAdjust && WantAdjust)
|
|
{
|
|
if (!SetConsoleWindowInfo(g_hConOut, TRUE, &csbi.srWindow))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
typedef struct ConsoleBufferStruct
|
|
{
|
|
BOOL IsValid;
|
|
CONSOLE_SCREEN_BUFFER_INFO Info;
|
|
PCHAR_INFO Buffer;
|
|
COORD BufferSize;
|
|
PSMALL_RECT Regions;
|
|
int NumRegions;
|
|
} ConsoleBuffer;
|
|
|
|
/*
|
|
* SaveConsoleBuffer()
|
|
* Description:
|
|
* Saves important information about the console buffer, including the
|
|
* actual buffer contents. The saved information is suitable for later
|
|
* restoration by RestoreConsoleBuffer().
|
|
* Returns:
|
|
* TRUE if all information was saved; FALSE otherwise
|
|
* If FALSE, still sets cb->IsValid if buffer characteristics were saved.
|
|
*/
|
|
static BOOL
|
|
SaveConsoleBuffer(
|
|
ConsoleBuffer *cb)
|
|
{
|
|
DWORD NumCells;
|
|
COORD BufferCoord;
|
|
SMALL_RECT ReadRegion;
|
|
WORD Y, Y_incr;
|
|
int i, numregions;
|
|
|
|
if (cb == NULL)
|
|
return FALSE;
|
|
|
|
if (!GetConsoleScreenBufferInfo(g_hConOut, &cb->Info))
|
|
{
|
|
cb->IsValid = FALSE;
|
|
return FALSE;
|
|
}
|
|
cb->IsValid = TRUE;
|
|
|
|
// VTP uses alternate screen buffer.
|
|
// No need to save buffer contents for restoration.
|
|
if (use_alternate_screen_buffer)
|
|
return TRUE;
|
|
|
|
/*
|
|
* Allocate a buffer large enough to hold the entire console screen
|
|
* buffer. If this ConsoleBuffer structure has already been initialized
|
|
* with a buffer of the correct size, then just use that one.
|
|
*/
|
|
if (!cb->IsValid || cb->Buffer == NULL ||
|
|
cb->BufferSize.X != cb->Info.dwSize.X ||
|
|
cb->BufferSize.Y != cb->Info.dwSize.Y)
|
|
{
|
|
cb->BufferSize.X = cb->Info.dwSize.X;
|
|
cb->BufferSize.Y = cb->Info.dwSize.Y;
|
|
NumCells = cb->BufferSize.X * cb->BufferSize.Y;
|
|
vim_free(cb->Buffer);
|
|
cb->Buffer = ALLOC_MULT(CHAR_INFO, NumCells);
|
|
if (cb->Buffer == NULL)
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* We will now copy the console screen buffer into our buffer.
|
|
* ReadConsoleOutput() seems to be limited as far as how much you
|
|
* can read at a time. Empirically, this number seems to be about
|
|
* 12000 cells (rows * columns). Start at position (0, 0) and copy
|
|
* in chunks until it is all copied. The chunks will all have the
|
|
* same horizontal characteristics, so initialize them now. The
|
|
* height of each chunk will be (12000 / width).
|
|
*/
|
|
BufferCoord.X = 0;
|
|
ReadRegion.Left = 0;
|
|
ReadRegion.Right = cb->Info.dwSize.X - 1;
|
|
Y_incr = 12000 / cb->Info.dwSize.X;
|
|
|
|
numregions = (cb->Info.dwSize.Y + Y_incr - 1) / Y_incr;
|
|
if (cb->Regions == NULL || numregions != cb->NumRegions)
|
|
{
|
|
cb->NumRegions = numregions;
|
|
vim_free(cb->Regions);
|
|
cb->Regions = ALLOC_MULT(SMALL_RECT, cb->NumRegions);
|
|
if (cb->Regions == NULL)
|
|
{
|
|
VIM_CLEAR(cb->Buffer);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
for (i = 0, Y = 0; i < cb->NumRegions; i++, Y += Y_incr)
|
|
{
|
|
/*
|
|
* Read into position (0, Y) in our buffer.
|
|
*/
|
|
BufferCoord.Y = Y;
|
|
/*
|
|
* Read the region whose top left corner is (0, Y) and whose bottom
|
|
* right corner is (width - 1, Y + Y_incr - 1). This should define
|
|
* a region of size width by Y_incr. Don't worry if this region is
|
|
* too large for the remaining buffer; it will be cropped.
|
|
*/
|
|
ReadRegion.Top = Y;
|
|
ReadRegion.Bottom = Y + Y_incr - 1;
|
|
if (!ReadConsoleOutputW(g_hConOut, // output handle
|
|
cb->Buffer, // our buffer
|
|
cb->BufferSize, // dimensions of our buffer
|
|
BufferCoord, // offset in our buffer
|
|
&ReadRegion)) // region to save
|
|
{
|
|
VIM_CLEAR(cb->Buffer);
|
|
VIM_CLEAR(cb->Regions);
|
|
return FALSE;
|
|
}
|
|
cb->Regions[i] = ReadRegion;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* RestoreConsoleBuffer()
|
|
* Description:
|
|
* Restores important information about the console buffer, including the
|
|
* actual buffer contents, if desired. The information to restore is in
|
|
* the same format used by SaveConsoleBuffer().
|
|
* Returns:
|
|
* TRUE on success
|
|
*/
|
|
static BOOL
|
|
RestoreConsoleBuffer(
|
|
ConsoleBuffer *cb,
|
|
BOOL RestoreScreen)
|
|
{
|
|
COORD BufferCoord;
|
|
SMALL_RECT WriteRegion;
|
|
int i;
|
|
|
|
// VTP uses alternate screen buffer.
|
|
// No need to restore buffer contents.
|
|
if (use_alternate_screen_buffer)
|
|
return TRUE;
|
|
|
|
if (cb == NULL || !cb->IsValid)
|
|
return FALSE;
|
|
|
|
/*
|
|
* Before restoring the buffer contents, clear the current buffer, and
|
|
* restore the cursor position and window information. Doing this now
|
|
* prevents old buffer contents from "flashing" onto the screen.
|
|
*/
|
|
if (RestoreScreen)
|
|
ClearConsoleBuffer(cb->Info.wAttributes);
|
|
|
|
FitConsoleWindow(cb->Info.dwSize, TRUE);
|
|
if (!SetConsoleScreenBufferSize(g_hConOut, cb->Info.dwSize))
|
|
return FALSE;
|
|
if (!SetConsoleTextAttribute(g_hConOut, cb->Info.wAttributes))
|
|
return FALSE;
|
|
|
|
if (!RestoreScreen)
|
|
{
|
|
/*
|
|
* No need to restore the screen buffer contents, so we're done.
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
if (!SetConsoleCursorPosition(g_hConOut, cb->Info.dwCursorPosition))
|
|
return FALSE;
|
|
if (!SetConsoleWindowInfo(g_hConOut, TRUE, &cb->Info.srWindow))
|
|
return FALSE;
|
|
|
|
/*
|
|
* Restore the screen buffer contents.
|
|
*/
|
|
if (cb->Buffer != NULL)
|
|
{
|
|
for (i = 0; i < cb->NumRegions; i++)
|
|
{
|
|
BufferCoord.X = cb->Regions[i].Left;
|
|
BufferCoord.Y = cb->Regions[i].Top;
|
|
WriteRegion = cb->Regions[i];
|
|
if (!WriteConsoleOutputW(g_hConOut, // output handle
|
|
cb->Buffer, // our buffer
|
|
cb->BufferSize, // dimensions of our buffer
|
|
BufferCoord, // offset in our buffer
|
|
&WriteRegion)) // region to restore
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
# define FEAT_RESTORE_ORIG_SCREEN
|
|
# ifdef FEAT_RESTORE_ORIG_SCREEN
|
|
static ConsoleBuffer g_cbOrig = { 0 };
|
|
# endif
|
|
static ConsoleBuffer g_cbNonTermcap = { 0 };
|
|
static ConsoleBuffer g_cbTermcap = { 0 };
|
|
|
|
char g_szOrigTitle[256] = { 0 };
|
|
HWND g_hWnd = NULL; // also used in os_mswin.c
|
|
static HICON g_hOrigIconSmall = NULL;
|
|
static HICON g_hOrigIcon = NULL;
|
|
static HICON g_hVimIcon = NULL;
|
|
static BOOL g_fCanChangeIcon = FALSE;
|
|
|
|
/*
|
|
* GetConsoleIcon()
|
|
* Description:
|
|
* Attempts to retrieve the small icon and/or the big icon currently in
|
|
* use by a given window.
|
|
* Returns:
|
|
* TRUE on success
|
|
*/
|
|
static BOOL
|
|
GetConsoleIcon(
|
|
HWND hWnd,
|
|
HICON *phIconSmall,
|
|
HICON *phIcon)
|
|
{
|
|
if (hWnd == NULL)
|
|
return FALSE;
|
|
|
|
if (phIconSmall != NULL)
|
|
*phIconSmall = (HICON)SendMessage(hWnd, WM_GETICON,
|
|
(WPARAM)ICON_SMALL, (LPARAM)0);
|
|
if (phIcon != NULL)
|
|
*phIcon = (HICON)SendMessage(hWnd, WM_GETICON,
|
|
(WPARAM)ICON_BIG, (LPARAM)0);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* SetConsoleIcon()
|
|
* Description:
|
|
* Attempts to change the small icon and/or the big icon currently in
|
|
* use by a given window.
|
|
* Returns:
|
|
* TRUE on success
|
|
*/
|
|
static BOOL
|
|
SetConsoleIcon(
|
|
HWND hWnd,
|
|
HICON hIconSmall,
|
|
HICON hIcon)
|
|
{
|
|
if (hWnd == NULL)
|
|
return FALSE;
|
|
|
|
if (hIconSmall != NULL)
|
|
SendMessage(hWnd, WM_SETICON,
|
|
(WPARAM)ICON_SMALL, (LPARAM)hIconSmall);
|
|
if (hIcon != NULL)
|
|
SendMessage(hWnd, WM_SETICON,
|
|
(WPARAM)ICON_BIG, (LPARAM) hIcon);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* SaveConsoleTitleAndIcon()
|
|
* Description:
|
|
* Saves the current console window title in g_szOrigTitle, for later
|
|
* restoration. Also, attempts to obtain a handle to the console window,
|
|
* and use it to save the small and big icons currently in use by the
|
|
* console window. This is not always possible on some versions of Windows;
|
|
* nor is it possible when running Vim remotely using Telnet (since the
|
|
* console window the user sees is owned by a remote process).
|
|
*/
|
|
static void
|
|
SaveConsoleTitleAndIcon(void)
|
|
{
|
|
// Save the original title.
|
|
if (!GetConsoleTitle(g_szOrigTitle, sizeof(g_szOrigTitle)))
|
|
return;
|
|
|
|
/*
|
|
* Obtain a handle to the console window using GetConsoleWindow() from
|
|
* KERNEL32.DLL; we need to handle in order to change the window icon.
|
|
* This function only exists on NT-based Windows, starting with Windows
|
|
* 2000. On older operating systems, we can't change the window icon
|
|
* anyway.
|
|
*/
|
|
g_hWnd = GetConsoleWindow();
|
|
if (g_hWnd == NULL)
|
|
return;
|
|
|
|
// Save the original console window icon.
|
|
GetConsoleIcon(g_hWnd, &g_hOrigIconSmall, &g_hOrigIcon);
|
|
if (g_hOrigIconSmall == NULL || g_hOrigIcon == NULL)
|
|
return;
|
|
|
|
// Extract the first icon contained in the Vim executable.
|
|
if (
|
|
# ifdef FEAT_LIBCALL
|
|
mch_icon_load((HANDLE *)&g_hVimIcon) == FAIL ||
|
|
# endif
|
|
g_hVimIcon == NULL)
|
|
g_hVimIcon = ExtractIcon(NULL, (LPCSTR)exe_name, 0);
|
|
if (g_hVimIcon != NULL)
|
|
g_fCanChangeIcon = TRUE;
|
|
}
|
|
|
|
static int g_fWindInitCalled = FALSE;
|
|
static int g_fTermcapMode = FALSE;
|
|
static CONSOLE_CURSOR_INFO g_cci;
|
|
|
|
/*
|
|
* non-GUI version of mch_init().
|
|
*/
|
|
static void
|
|
mch_init_c(void)
|
|
{
|
|
# ifndef FEAT_RESTORE_ORIG_SCREEN
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
# endif
|
|
# ifndef __MINGW32__
|
|
extern int _fmode;
|
|
# endif
|
|
|
|
// Silently handle invalid parameters to CRT functions
|
|
SET_INVALID_PARAM_HANDLER;
|
|
|
|
// Let critical errors result in a failure, not in a dialog box. Required
|
|
// for the timestamp test to work on removed floppies.
|
|
SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
_fmode = O_BINARY; // we do our own CR-LF translation
|
|
out_flush();
|
|
|
|
// Obtain handles for the standard Console I/O devices
|
|
if (read_cmd_fd == 0)
|
|
g_hConIn = GetStdHandle(STD_INPUT_HANDLE);
|
|
else
|
|
create_conin();
|
|
g_hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
wt_init();
|
|
vtp_flag_init();
|
|
# ifdef FEAT_RESTORE_ORIG_SCREEN
|
|
// Save the initial console buffer for later restoration
|
|
SaveConsoleBuffer(&g_cbOrig);
|
|
g_attrCurrent = g_attrDefault = g_cbOrig.Info.wAttributes;
|
|
# else
|
|
// Get current text attributes
|
|
GetConsoleScreenBufferInfo(g_hConOut, &csbi);
|
|
g_attrCurrent = g_attrDefault = csbi.wAttributes;
|
|
# endif
|
|
if (cterm_normal_fg_color == 0)
|
|
cterm_normal_fg_color = (g_attrCurrent & 0xf) + 1;
|
|
if (cterm_normal_bg_color == 0)
|
|
cterm_normal_bg_color = ((g_attrCurrent >> 4) & 0xf) + 1;
|
|
|
|
// Fg and Bg color index number at startup
|
|
g_color_index_fg = g_attrDefault & 0xf;
|
|
g_color_index_bg = (g_attrDefault >> 4) & 0xf;
|
|
|
|
// set termcap codes to current text attributes
|
|
update_tcap(g_attrCurrent);
|
|
|
|
GetConsoleCursorInfo(g_hConOut, &g_cci);
|
|
GetConsoleMode(g_hConIn, &g_cmodein);
|
|
GetConsoleMode(g_hConOut, &g_cmodeout);
|
|
|
|
SaveConsoleTitleAndIcon();
|
|
/*
|
|
* Set both the small and big icons of the console window to Vim's icon.
|
|
* Note that Vim presently only has one size of icon (32x32), but it
|
|
* automatically gets scaled down to 16x16 when setting the small icon.
|
|
*/
|
|
if (g_fCanChangeIcon)
|
|
SetConsoleIcon(g_hWnd, g_hVimIcon, g_hVimIcon);
|
|
|
|
ui_get_shellsize();
|
|
|
|
vtp_init();
|
|
// Switch to a new alternate screen buffer.
|
|
if (use_alternate_screen_buffer)
|
|
vtp_printf("\033[?1049h");
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
fdDump = fopen("dump", "wt");
|
|
|
|
if (fdDump)
|
|
{
|
|
time_t t;
|
|
|
|
time(&t);
|
|
fputs(ctime(&t), fdDump);
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
|
|
g_fWindInitCalled = TRUE;
|
|
|
|
g_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT);
|
|
|
|
# ifdef FEAT_CLIPBOARD
|
|
win_clip_init();
|
|
# endif
|
|
}
|
|
|
|
/*
|
|
* non-GUI version of mch_exit().
|
|
* Shut down and exit with status `r'
|
|
* Careful: mch_exit() may be called before mch_init()!
|
|
*/
|
|
static void
|
|
mch_exit_c(int r)
|
|
{
|
|
// Copy flag since stoptermcap() will clear the flag.
|
|
int fTermcapMode = g_fTermcapMode;
|
|
|
|
exiting = TRUE;
|
|
|
|
vtp_exit();
|
|
|
|
stoptermcap();
|
|
// Switch back to main screen buffer if TermcapMode was not active.
|
|
if (!fTermcapMode && use_alternate_screen_buffer)
|
|
vtp_printf("\033[?1049l");
|
|
|
|
if (g_fWindInitCalled)
|
|
settmode(TMODE_COOK);
|
|
|
|
ml_close_all(TRUE); // remove all memfiles
|
|
|
|
if (g_fWindInitCalled)
|
|
{
|
|
mch_restore_title(SAVE_RESTORE_BOTH);
|
|
/*
|
|
* Restore both the small and big icons of the console window to
|
|
* what they were at startup. Don't do this when the window is
|
|
* closed, Vim would hang here.
|
|
*/
|
|
if (g_fCanChangeIcon && !g_fForceExit)
|
|
SetConsoleIcon(g_hWnd, g_hOrigIconSmall, g_hOrigIcon);
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
time_t t;
|
|
|
|
time(&t);
|
|
fputs(ctime(&t), fdDump);
|
|
fclose(fdDump);
|
|
}
|
|
fdDump = NULL;
|
|
# endif
|
|
}
|
|
|
|
SetConsoleCursorInfo(g_hConOut, &g_cci);
|
|
SetConsoleMode(g_hConIn, g_cmodein | ENABLE_EXTENDED_FLAGS);
|
|
SetConsoleMode(g_hConOut, g_cmodeout);
|
|
|
|
# ifdef DYNAMIC_GETTEXT
|
|
dyn_libintl_end();
|
|
# endif
|
|
|
|
exit(r);
|
|
}
|
|
#endif // !FEAT_GUI_MSWIN
|
|
|
|
void
|
|
mch_init(void)
|
|
{
|
|
#ifdef VIMDLL
|
|
if (gui.starting)
|
|
mch_init_g();
|
|
else
|
|
mch_init_c();
|
|
#elif defined(FEAT_GUI_MSWIN)
|
|
mch_init_g();
|
|
#else
|
|
mch_init_c();
|
|
#endif
|
|
}
|
|
|
|
void
|
|
mch_exit(int r)
|
|
{
|
|
#ifdef FEAT_NETBEANS_INTG
|
|
netbeans_send_disconnect();
|
|
#endif
|
|
|
|
#ifdef VIMDLL
|
|
if (gui.in_use || gui.starting)
|
|
mch_exit_g(r);
|
|
else
|
|
mch_exit_c(r);
|
|
#elif defined(FEAT_GUI_MSWIN)
|
|
mch_exit_g(r);
|
|
#else
|
|
mch_exit_c(r);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Do we have an interactive window?
|
|
*/
|
|
int
|
|
mch_check_win(
|
|
int argc UNUSED,
|
|
char **argv UNUSED)
|
|
{
|
|
mch_get_exe_name();
|
|
|
|
#if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
|
|
return OK; // GUI always has a tty
|
|
#else
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return OK;
|
|
# endif
|
|
if (isatty(1))
|
|
return OK;
|
|
return FAIL;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Set the case of the file name, if it already exists.
|
|
* When "len" is > 0, also expand short to long filenames.
|
|
*/
|
|
void
|
|
fname_case(
|
|
char_u *name,
|
|
int len)
|
|
{
|
|
int flen;
|
|
WCHAR *p;
|
|
WCHAR buf[_MAX_PATH + 1];
|
|
|
|
flen = (int)STRLEN(name);
|
|
if (flen == 0)
|
|
return;
|
|
|
|
slash_adjust(name);
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return;
|
|
|
|
if (GetLongPathNameW(p, buf, _MAX_PATH))
|
|
{
|
|
char_u *q = utf16_to_enc(buf, NULL);
|
|
|
|
if (q != NULL)
|
|
{
|
|
if (len > 0 || flen >= (int)STRLEN(q))
|
|
vim_strncpy(name, q, (len > 0) ? len - 1 : flen);
|
|
vim_free(q);
|
|
}
|
|
}
|
|
vim_free(p);
|
|
}
|
|
|
|
|
|
/*
|
|
* Insert user name in s[len].
|
|
*/
|
|
int
|
|
mch_get_user_name(
|
|
char_u *s,
|
|
int len)
|
|
{
|
|
WCHAR wszUserName[256 + 1]; // UNLEN is 256
|
|
DWORD wcch = ARRAY_LENGTH(wszUserName);
|
|
|
|
if (GetUserNameW(wszUserName, &wcch))
|
|
{
|
|
char_u *p = utf16_to_enc(wszUserName, NULL);
|
|
|
|
if (p != NULL)
|
|
{
|
|
vim_strncpy(s, p, len - 1);
|
|
vim_free(p);
|
|
return OK;
|
|
}
|
|
}
|
|
s[0] = NUL;
|
|
return FAIL;
|
|
}
|
|
|
|
|
|
/*
|
|
* Insert host name in s[len].
|
|
*/
|
|
void
|
|
mch_get_host_name(
|
|
char_u *s,
|
|
int len)
|
|
{
|
|
WCHAR wszHostName[256 + 1];
|
|
DWORD wcch = ARRAY_LENGTH(wszHostName);
|
|
|
|
if (!GetComputerNameW(wszHostName, &wcch))
|
|
return;
|
|
|
|
char_u *p = utf16_to_enc(wszHostName, NULL);
|
|
if (p == NULL)
|
|
return;
|
|
|
|
vim_strncpy(s, p, len - 1);
|
|
vim_free(p);
|
|
}
|
|
|
|
|
|
/*
|
|
* return process ID
|
|
*/
|
|
long
|
|
mch_get_pid(void)
|
|
{
|
|
return (long)GetCurrentProcessId();
|
|
}
|
|
|
|
/*
|
|
* return TRUE if process "pid" is still running
|
|
*/
|
|
int
|
|
mch_process_running(long pid)
|
|
{
|
|
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, 0, (DWORD)pid);
|
|
DWORD status = 0;
|
|
int ret = FALSE;
|
|
|
|
if (hProcess == NULL)
|
|
return FALSE; // might not have access
|
|
if (GetExitCodeProcess(hProcess, &status) )
|
|
ret = status == STILL_ACTIVE;
|
|
CloseHandle(hProcess);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Get name of current directory into buffer 'buf' of length 'len' bytes.
|
|
* Return OK for success, FAIL for failure.
|
|
*/
|
|
int
|
|
mch_dirname(
|
|
char_u *buf,
|
|
int len)
|
|
{
|
|
WCHAR wbuf[_MAX_PATH + 1];
|
|
|
|
/*
|
|
* Originally this was:
|
|
* return (getcwd(buf, len) != NULL ? OK : FAIL);
|
|
* But the Win32s known bug list says that getcwd() doesn't work
|
|
* so use the Win32 system call instead. <Negri>
|
|
*/
|
|
if (GetCurrentDirectoryW(_MAX_PATH, wbuf) == 0)
|
|
return FAIL;
|
|
|
|
WCHAR wcbuf[_MAX_PATH + 1];
|
|
char_u *p = NULL;
|
|
|
|
if (GetLongPathNameW(wbuf, wcbuf, _MAX_PATH) != 0)
|
|
{
|
|
p = utf16_to_enc(wcbuf, NULL);
|
|
if (STRLEN(p) >= (size_t)len)
|
|
{
|
|
// long path name is too long, fall back to short one
|
|
VIM_CLEAR(p);
|
|
}
|
|
}
|
|
if (p == NULL)
|
|
p = utf16_to_enc(wbuf, NULL);
|
|
|
|
if (p == NULL)
|
|
return FAIL;
|
|
|
|
vim_strncpy(buf, p, len - 1);
|
|
vim_free(p);
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Get file permissions for "name".
|
|
* Return mode_t or -1 for error.
|
|
*/
|
|
long
|
|
mch_getperm(char_u *name)
|
|
{
|
|
stat_T st;
|
|
int n;
|
|
|
|
n = mch_stat((char *)name, &st);
|
|
return n == 0 ? (long)(unsigned short)st.st_mode : -1L;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set file permission for "name" to "perm".
|
|
*
|
|
* Return FAIL for failure, OK otherwise.
|
|
*/
|
|
int
|
|
mch_setperm(char_u *name, long perm)
|
|
{
|
|
long n;
|
|
WCHAR *p;
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return FAIL;
|
|
|
|
n = _wchmod(p, perm);
|
|
vim_free(p);
|
|
if (n == -1)
|
|
return FAIL;
|
|
|
|
win32_set_archive(name);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Set hidden flag for "name".
|
|
*/
|
|
void
|
|
mch_hide(char_u *name)
|
|
{
|
|
int attrs = win32_getattrs(name);
|
|
if (attrs == -1)
|
|
return;
|
|
|
|
attrs |= FILE_ATTRIBUTE_HIDDEN;
|
|
win32_setattrs(name, attrs);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if file "name" exists and is hidden.
|
|
*/
|
|
int
|
|
mch_ishidden(char_u *name)
|
|
{
|
|
int f = win32_getattrs(name);
|
|
|
|
if (f == -1)
|
|
return FALSE; // file does not exist at all
|
|
|
|
return (f & FILE_ATTRIBUTE_HIDDEN) != 0;
|
|
}
|
|
|
|
/*
|
|
* return TRUE if "name" is a directory
|
|
* return FALSE if "name" is not a directory or upon error
|
|
*/
|
|
int
|
|
mch_isdir(char_u *name)
|
|
{
|
|
int f = win32_getattrs(name);
|
|
|
|
if (f == -1)
|
|
return FALSE; // file does not exist at all
|
|
|
|
return (f & FILE_ATTRIBUTE_DIRECTORY) != 0;
|
|
}
|
|
|
|
/*
|
|
* return TRUE if "name" is a directory, NOT a symlink to a directory
|
|
* return FALSE if "name" is not a directory
|
|
* return FALSE for error
|
|
*/
|
|
int
|
|
mch_isrealdir(char_u *name)
|
|
{
|
|
return mch_isdir(name) && !mch_is_symbolic_link(name);
|
|
}
|
|
|
|
/*
|
|
* Create directory "name".
|
|
* Return 0 on success, -1 on error.
|
|
*/
|
|
int
|
|
mch_mkdir(char_u *name)
|
|
{
|
|
WCHAR *p;
|
|
int retval;
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return -1;
|
|
retval = _wmkdir(p);
|
|
vim_free(p);
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* Delete directory "name".
|
|
* Return 0 on success, -1 on error.
|
|
*/
|
|
int
|
|
mch_rmdir(char_u *name)
|
|
{
|
|
WCHAR *p;
|
|
int retval;
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return -1;
|
|
retval = _wrmdir(p);
|
|
vim_free(p);
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if file "fname" has more than one link.
|
|
*/
|
|
int
|
|
mch_is_hard_link(char_u *fname)
|
|
{
|
|
BY_HANDLE_FILE_INFORMATION info;
|
|
|
|
return win32_fileinfo(fname, &info) == FILEINFO_OK
|
|
&& info.nNumberOfLinks > 1;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "name" is a symbolic link (or a junction).
|
|
*/
|
|
int
|
|
mch_is_symbolic_link(char_u *name)
|
|
{
|
|
HANDLE hFind;
|
|
int res = FALSE;
|
|
DWORD fileFlags = 0, reparseTag = 0;
|
|
WCHAR *wn;
|
|
WIN32_FIND_DATAW findDataW;
|
|
|
|
wn = enc_to_utf16(name, NULL);
|
|
if (wn == NULL)
|
|
return FALSE;
|
|
|
|
hFind = FindFirstFileW(wn, &findDataW);
|
|
vim_free(wn);
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
fileFlags = findDataW.dwFileAttributes;
|
|
reparseTag = findDataW.dwReserved0;
|
|
FindClose(hFind);
|
|
}
|
|
|
|
if ((fileFlags & FILE_ATTRIBUTE_REPARSE_POINT)
|
|
&& (reparseTag == IO_REPARSE_TAG_SYMLINK
|
|
|| reparseTag == IO_REPARSE_TAG_MOUNT_POINT))
|
|
res = TRUE;
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if file "fname" has more than one link or if it is a symbolic
|
|
* link.
|
|
*/
|
|
int
|
|
mch_is_linked(char_u *fname)
|
|
{
|
|
if (mch_is_hard_link(fname) || mch_is_symbolic_link(fname))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Get the by-handle-file-information for "fname".
|
|
* Returns FILEINFO_OK when OK.
|
|
* Returns FILEINFO_ENC_FAIL when enc_to_utf16() failed.
|
|
* Returns FILEINFO_READ_FAIL when CreateFile() failed.
|
|
* Returns FILEINFO_INFO_FAIL when GetFileInformationByHandle() failed.
|
|
*/
|
|
int
|
|
win32_fileinfo(char_u *fname, BY_HANDLE_FILE_INFORMATION *info)
|
|
{
|
|
HANDLE hFile;
|
|
int res = FILEINFO_READ_FAIL;
|
|
WCHAR *wn;
|
|
|
|
wn = enc_to_utf16(fname, NULL);
|
|
if (wn == NULL)
|
|
return FILEINFO_ENC_FAIL;
|
|
|
|
hFile = CreateFileW(wn, // file name
|
|
GENERIC_READ, // access mode
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, // share mode
|
|
NULL, // security descriptor
|
|
OPEN_EXISTING, // creation disposition
|
|
FILE_FLAG_BACKUP_SEMANTICS, // file attributes
|
|
NULL); // handle to template file
|
|
vim_free(wn);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return FILEINFO_READ_FAIL;
|
|
|
|
if (GetFileInformationByHandle(hFile, info) != 0)
|
|
res = FILEINFO_OK;
|
|
else
|
|
res = FILEINFO_INFO_FAIL;
|
|
CloseHandle(hFile);
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* get file attributes for `name'
|
|
* -1 : error
|
|
* else FILE_ATTRIBUTE_* defined in winnt.h
|
|
*/
|
|
static int
|
|
win32_getattrs(char_u *name)
|
|
{
|
|
int attr;
|
|
WCHAR *p;
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return INVALID_FILE_ATTRIBUTES;
|
|
|
|
attr = GetFileAttributesW(p);
|
|
vim_free(p);
|
|
|
|
return attr;
|
|
}
|
|
|
|
/*
|
|
* set file attributes for `name' to `attrs'
|
|
*
|
|
* return -1 for failure, 0 otherwise
|
|
*/
|
|
static int
|
|
win32_setattrs(char_u *name, int attrs)
|
|
{
|
|
int res;
|
|
WCHAR *p;
|
|
|
|
p = enc_to_utf16(name, NULL);
|
|
if (p == NULL)
|
|
return -1;
|
|
|
|
res = SetFileAttributesW(p, attrs);
|
|
vim_free(p);
|
|
|
|
return res ? 0 : -1;
|
|
}
|
|
|
|
/*
|
|
* Set archive flag for "name".
|
|
*/
|
|
static int
|
|
win32_set_archive(char_u *name)
|
|
{
|
|
int attrs = win32_getattrs(name);
|
|
if (attrs == -1)
|
|
return -1;
|
|
|
|
attrs |= FILE_ATTRIBUTE_ARCHIVE;
|
|
return win32_setattrs(name, attrs);
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if file or directory "name" is writable (not readonly).
|
|
* Strange semantics of Win32: a readonly directory is writable, but you can't
|
|
* delete a file. Let's say this means it is writable.
|
|
*/
|
|
int
|
|
mch_writable(char_u *name)
|
|
{
|
|
int attrs = win32_getattrs(name);
|
|
|
|
return (attrs != -1 && (!(attrs & FILE_ATTRIBUTE_READONLY)
|
|
|| (attrs & FILE_ATTRIBUTE_DIRECTORY)));
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "name" can be executed, FALSE if not.
|
|
* If "use_path" is FALSE only check if "name" is executable.
|
|
* When returning TRUE and "path" is not NULL save the path and set "*path" to
|
|
* the allocated memory.
|
|
*/
|
|
int
|
|
mch_can_exe(char_u *name, char_u **path, int use_path UNUSED)
|
|
{
|
|
return executable_exists((char *)name, path, TRUE, TRUE);
|
|
}
|
|
|
|
/*
|
|
* Check what "name" is:
|
|
* NODE_NORMAL: file or directory (or doesn't exist)
|
|
* NODE_WRITABLE: writable device, socket, fifo, etc.
|
|
* NODE_OTHER: non-writable things
|
|
*/
|
|
int
|
|
mch_nodetype(char_u *name)
|
|
{
|
|
HANDLE hFile;
|
|
int type;
|
|
WCHAR *wn;
|
|
|
|
// We can't open a file with a name "\\.\con" or "\\.\prn" and trying to
|
|
// read from it later will cause Vim to hang. Thus return NODE_WRITABLE
|
|
// here.
|
|
if (STRNCMP(name, "\\\\.\\", 4) == 0)
|
|
return NODE_WRITABLE;
|
|
|
|
wn = enc_to_utf16(name, NULL);
|
|
if (wn == NULL)
|
|
return NODE_NORMAL;
|
|
|
|
hFile = CreateFileW(wn, // file name
|
|
GENERIC_WRITE, // access mode
|
|
0, // share mode
|
|
NULL, // security descriptor
|
|
OPEN_EXISTING, // creation disposition
|
|
0, // file attributes
|
|
NULL); // handle to template file
|
|
vim_free(wn);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return NODE_NORMAL;
|
|
|
|
type = GetFileType(hFile);
|
|
CloseHandle(hFile);
|
|
if (type == FILE_TYPE_CHAR)
|
|
return NODE_WRITABLE;
|
|
if (type == FILE_TYPE_DISK)
|
|
return NODE_NORMAL;
|
|
return NODE_OTHER;
|
|
}
|
|
|
|
#ifdef HAVE_ACL
|
|
struct my_acl
|
|
{
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor;
|
|
PSID pSidOwner;
|
|
PSID pSidGroup;
|
|
PACL pDacl;
|
|
PACL pSacl;
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* Return a pointer to the ACL of file "fname" in allocated memory.
|
|
* Return NULL if the ACL is not available for whatever reason.
|
|
*/
|
|
vim_acl_T
|
|
mch_get_acl(char_u *fname)
|
|
{
|
|
#ifndef HAVE_ACL
|
|
return (vim_acl_T)NULL;
|
|
#else
|
|
struct my_acl *p = NULL;
|
|
DWORD err;
|
|
|
|
p = ALLOC_CLEAR_ONE(struct my_acl);
|
|
if (p != NULL)
|
|
{
|
|
WCHAR *wn;
|
|
|
|
wn = enc_to_utf16(fname, NULL);
|
|
if (wn == NULL)
|
|
{
|
|
vim_free(p);
|
|
return NULL;
|
|
}
|
|
|
|
// Try to retrieve the entire security descriptor.
|
|
err = GetNamedSecurityInfoW(
|
|
wn, // Abstract filename
|
|
SE_FILE_OBJECT, // File Object
|
|
OWNER_SECURITY_INFORMATION |
|
|
GROUP_SECURITY_INFORMATION |
|
|
DACL_SECURITY_INFORMATION |
|
|
SACL_SECURITY_INFORMATION,
|
|
&p->pSidOwner, // Ownership information.
|
|
&p->pSidGroup, // Group membership.
|
|
&p->pDacl, // Discretionary information.
|
|
&p->pSacl, // For auditing purposes.
|
|
&p->pSecurityDescriptor);
|
|
if (err == ERROR_ACCESS_DENIED ||
|
|
err == ERROR_PRIVILEGE_NOT_HELD)
|
|
{
|
|
// Retrieve only DACL.
|
|
(void)GetNamedSecurityInfoW(
|
|
wn,
|
|
SE_FILE_OBJECT,
|
|
DACL_SECURITY_INFORMATION,
|
|
NULL,
|
|
NULL,
|
|
&p->pDacl,
|
|
NULL,
|
|
&p->pSecurityDescriptor);
|
|
}
|
|
if (p->pSecurityDescriptor == NULL)
|
|
{
|
|
mch_free_acl((vim_acl_T)p);
|
|
p = NULL;
|
|
}
|
|
vim_free(wn);
|
|
}
|
|
|
|
return (vim_acl_T)p;
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_ACL
|
|
/*
|
|
* Check if "acl" contains inherited ACE.
|
|
*/
|
|
static BOOL
|
|
is_acl_inherited(PACL acl)
|
|
{
|
|
DWORD i;
|
|
ACL_SIZE_INFORMATION acl_info;
|
|
PACCESS_ALLOWED_ACE ace;
|
|
|
|
acl_info.AceCount = 0;
|
|
GetAclInformation(acl, &acl_info, sizeof(acl_info), AclSizeInformation);
|
|
for (i = 0; i < acl_info.AceCount; i++)
|
|
{
|
|
GetAce(acl, i, (LPVOID *)&ace);
|
|
if (ace->Header.AceFlags & INHERITED_ACE)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Set the ACL of file "fname" to "acl" (unless it's NULL).
|
|
* Errors are ignored.
|
|
* This must only be called with "acl" equal to what mch_get_acl() returned.
|
|
*/
|
|
void
|
|
mch_set_acl(char_u *fname, vim_acl_T acl)
|
|
{
|
|
#ifdef HAVE_ACL
|
|
struct my_acl *p = (struct my_acl *)acl;
|
|
SECURITY_INFORMATION sec_info = 0;
|
|
WCHAR *wn;
|
|
|
|
if (p == NULL)
|
|
return;
|
|
|
|
wn = enc_to_utf16(fname, NULL);
|
|
if (wn == NULL)
|
|
return;
|
|
|
|
// Set security flags
|
|
if (p->pSidOwner)
|
|
sec_info |= OWNER_SECURITY_INFORMATION;
|
|
if (p->pSidGroup)
|
|
sec_info |= GROUP_SECURITY_INFORMATION;
|
|
if (p->pDacl)
|
|
{
|
|
sec_info |= DACL_SECURITY_INFORMATION;
|
|
// Do not inherit its parent's DACL.
|
|
// If the DACL is inherited, Cygwin permissions would be changed.
|
|
if (!is_acl_inherited(p->pDacl))
|
|
sec_info |= PROTECTED_DACL_SECURITY_INFORMATION;
|
|
}
|
|
if (p->pSacl)
|
|
sec_info |= SACL_SECURITY_INFORMATION;
|
|
|
|
(void)SetNamedSecurityInfoW(
|
|
wn, // Abstract filename
|
|
SE_FILE_OBJECT, // File Object
|
|
sec_info,
|
|
p->pSidOwner, // Ownership information.
|
|
p->pSidGroup, // Group membership.
|
|
p->pDacl, // Discretionary information.
|
|
p->pSacl // For auditing purposes.
|
|
);
|
|
vim_free(wn);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
mch_free_acl(vim_acl_T acl)
|
|
{
|
|
#ifdef HAVE_ACL
|
|
struct my_acl *p = (struct my_acl *)acl;
|
|
|
|
if (p != NULL)
|
|
{
|
|
LocalFree(p->pSecurityDescriptor); // Free the memory just in case
|
|
vim_free(p);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
|
|
/*
|
|
* handler for ctrl-break, ctrl-c interrupts, and fatal events.
|
|
*/
|
|
static BOOL WINAPI
|
|
handler_routine(
|
|
DWORD dwCtrlType)
|
|
{
|
|
INPUT_RECORD ir;
|
|
DWORD out;
|
|
|
|
switch (dwCtrlType)
|
|
{
|
|
case CTRL_C_EVENT:
|
|
if (ctrl_c_interrupts)
|
|
g_fCtrlCPressed = TRUE;
|
|
return TRUE;
|
|
|
|
case CTRL_BREAK_EVENT:
|
|
g_fCBrkPressed = TRUE;
|
|
ctrl_break_was_pressed = TRUE;
|
|
// ReadConsoleInput is blocking, send a key event to continue.
|
|
ir.EventType = KEY_EVENT;
|
|
ir.Event.KeyEvent.bKeyDown = TRUE;
|
|
ir.Event.KeyEvent.wRepeatCount = 1;
|
|
ir.Event.KeyEvent.wVirtualKeyCode = VK_CANCEL;
|
|
ir.Event.KeyEvent.wVirtualScanCode = 0;
|
|
ir.Event.KeyEvent.dwControlKeyState = 0;
|
|
ir.Event.KeyEvent.uChar.UnicodeChar = 0;
|
|
WriteConsoleInput(g_hConIn, &ir, 1, &out);
|
|
return TRUE;
|
|
|
|
// fatal events: shut down gracefully
|
|
case CTRL_CLOSE_EVENT:
|
|
case CTRL_LOGOFF_EVENT:
|
|
case CTRL_SHUTDOWN_EVENT:
|
|
windgoto((int)Rows - 1, 0);
|
|
g_fForceExit = TRUE;
|
|
|
|
vim_snprintf((char *)IObuff, IOSIZE, _("Vim: Caught %s event\n"),
|
|
(dwCtrlType == CTRL_CLOSE_EVENT
|
|
? _("close")
|
|
: dwCtrlType == CTRL_LOGOFF_EVENT
|
|
? _("logoff")
|
|
: _("shutdown")));
|
|
# ifdef DEBUG
|
|
OutputDebugString(IObuff);
|
|
# endif
|
|
|
|
preserve_exit(); // output IObuff, preserve files and exit
|
|
|
|
return TRUE; // not reached
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* set the tty in (raw) ? "raw" : "cooked" mode
|
|
*/
|
|
void
|
|
mch_settmode(tmode_T tmode)
|
|
{
|
|
DWORD cmodein;
|
|
DWORD cmodeout;
|
|
BOOL bEnableHandler;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
GetConsoleMode(g_hConIn, &cmodein);
|
|
GetConsoleMode(g_hConOut, &cmodeout);
|
|
if (tmode == TMODE_RAW)
|
|
{
|
|
cmodein &= ~(ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT |
|
|
ENABLE_ECHO_INPUT);
|
|
if (g_fMouseActive)
|
|
{
|
|
cmodein |= ENABLE_MOUSE_INPUT;
|
|
cmodein &= ~ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
else
|
|
{
|
|
cmodein |= g_cmodein & ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
cmodeout &= ~(
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
// Do not turn off the ENABLE_PROCESSED_OUTPUT flag when using
|
|
// VTP.
|
|
((vtp_working) ? 0 : ENABLE_PROCESSED_OUTPUT) |
|
|
# else
|
|
ENABLE_PROCESSED_OUTPUT |
|
|
# endif
|
|
ENABLE_WRAP_AT_EOL_OUTPUT);
|
|
bEnableHandler = TRUE;
|
|
}
|
|
else // cooked
|
|
{
|
|
cmodein |= (ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT |
|
|
ENABLE_ECHO_INPUT);
|
|
cmodeout |= (ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
|
|
bEnableHandler = FALSE;
|
|
}
|
|
SetConsoleMode(g_hConIn, cmodein | ENABLE_EXTENDED_FLAGS);
|
|
SetConsoleMode(g_hConOut, cmodeout);
|
|
SetConsoleCtrlHandler(handler_routine, bEnableHandler);
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fprintf(fdDump, "mch_settmode(%s, in = %x, out = %x)\n",
|
|
tmode == TMODE_RAW ? "raw" :
|
|
tmode == TMODE_COOK ? "cooked" : "normal",
|
|
cmodein, cmodeout);
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the size of the current window in `Rows' and `Columns'
|
|
* Return OK when size could be determined, FAIL otherwise.
|
|
*/
|
|
int
|
|
mch_get_shellsize(void)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return OK;
|
|
# endif
|
|
if (!g_fTermcapMode && g_cbTermcap.IsValid)
|
|
{
|
|
/*
|
|
* For some reason, we are trying to get the screen dimensions
|
|
* even though we are not in termcap mode. The 'Rows' and 'Columns'
|
|
* variables are really intended to mean the size of Vim screen
|
|
* while in termcap mode.
|
|
*/
|
|
Rows = g_cbTermcap.Info.dwSize.Y;
|
|
Columns = g_cbTermcap.Info.dwSize.X;
|
|
}
|
|
else if (GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
{
|
|
Rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
|
|
Columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
|
|
}
|
|
else
|
|
{
|
|
Rows = 25;
|
|
Columns = 80;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Resize console buffer to 'COORD'
|
|
*/
|
|
static void
|
|
ResizeConBuf(
|
|
HANDLE hConsole,
|
|
COORD coordScreen)
|
|
{
|
|
if (use_alternate_screen_buffer)
|
|
return;
|
|
|
|
if (!SetConsoleScreenBufferSize(hConsole, coordScreen))
|
|
{
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fprintf(fdDump, "SetConsoleScreenBufferSize failed: %lx\n",
|
|
GetLastError());
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Resize console window size to 'srWindowRect'
|
|
*/
|
|
static void
|
|
ResizeWindow(
|
|
HANDLE hConsole,
|
|
SMALL_RECT srWindowRect)
|
|
{
|
|
if (!SetConsoleWindowInfo(hConsole, TRUE, &srWindowRect))
|
|
{
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fprintf(fdDump, "SetConsoleWindowInfo failed: %lx\n",
|
|
GetLastError());
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set a console window to `xSize' * `ySize'
|
|
*/
|
|
static void
|
|
ResizeConBufAndWindow(
|
|
HANDLE hConsole,
|
|
int xSize,
|
|
int ySize)
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi; // hold current console buffer info
|
|
SMALL_RECT srWindowRect; // hold the new console size
|
|
COORD coordScreen;
|
|
COORD cursor;
|
|
static int resized = FALSE;
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fprintf(fdDump, "ResizeConBufAndWindow(%d, %d)\n", xSize, ySize);
|
|
fflush(fdDump);
|
|
}
|
|
# endif
|
|
|
|
// get the largest size we can size the console window to
|
|
coordScreen = GetLargestConsoleWindowSize(hConsole);
|
|
|
|
// define the new console window size and scroll position
|
|
srWindowRect.Left = srWindowRect.Top = (SHORT) 0;
|
|
srWindowRect.Right = (SHORT) (min(xSize, coordScreen.X) - 1);
|
|
srWindowRect.Bottom = (SHORT) (min(ySize, coordScreen.Y) - 1);
|
|
|
|
if (GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
{
|
|
int sx, sy;
|
|
|
|
sx = csbi.srWindow.Right - csbi.srWindow.Left + 1;
|
|
sy = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
|
|
if (sy < ySize || sx < xSize)
|
|
{
|
|
/*
|
|
* Increasing number of lines/columns, do buffer first.
|
|
* Use the maximal size in x and y direction.
|
|
*/
|
|
if (sy < ySize)
|
|
coordScreen.Y = ySize;
|
|
else
|
|
coordScreen.Y = sy;
|
|
if (sx < xSize)
|
|
coordScreen.X = xSize;
|
|
else
|
|
coordScreen.X = sx;
|
|
SetConsoleScreenBufferSize(hConsole, coordScreen);
|
|
}
|
|
}
|
|
|
|
// define the new console buffer size
|
|
coordScreen.X = xSize;
|
|
coordScreen.Y = ySize;
|
|
|
|
// In the new console call API, only the first time in reverse order
|
|
if (!vtp_working || resized)
|
|
{
|
|
ResizeWindow(hConsole, srWindowRect);
|
|
ResizeConBuf(hConsole, coordScreen);
|
|
}
|
|
else
|
|
{
|
|
// Workaround for a Windows 10 bug
|
|
cursor.X = srWindowRect.Left;
|
|
cursor.Y = srWindowRect.Top;
|
|
SetConsoleCursorPosition(hConsole, cursor);
|
|
|
|
ResizeConBuf(hConsole, coordScreen);
|
|
ResizeWindow(hConsole, srWindowRect);
|
|
resized = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the console window to `Rows' * `Columns'
|
|
*/
|
|
void
|
|
mch_set_shellsize(void)
|
|
{
|
|
COORD coordScreen;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
// Don't change window size while still starting up
|
|
if (suppress_winsize != 0)
|
|
{
|
|
suppress_winsize = 2;
|
|
return;
|
|
}
|
|
|
|
if (term_console)
|
|
{
|
|
coordScreen = GetLargestConsoleWindowSize(g_hConOut);
|
|
|
|
// Clamp Rows and Columns to reasonable values
|
|
if (Rows > coordScreen.Y)
|
|
Rows = coordScreen.Y;
|
|
if (Columns > coordScreen.X)
|
|
Columns = coordScreen.X;
|
|
|
|
ResizeConBufAndWindow(g_hConOut, Columns, Rows);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Rows and/or Columns has changed.
|
|
*/
|
|
void
|
|
mch_new_shellsize(void)
|
|
{
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
set_scroll_region(0, 0, Columns - 1, Rows - 1);
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when started up, to set the winsize that was delayed.
|
|
*/
|
|
void
|
|
mch_set_winsize_now(void)
|
|
{
|
|
if (suppress_winsize == 2)
|
|
{
|
|
suppress_winsize = 0;
|
|
mch_set_shellsize();
|
|
shell_resized();
|
|
}
|
|
suppress_winsize = 0;
|
|
}
|
|
#endif // FEAT_GUI_MSWIN
|
|
|
|
static BOOL
|
|
vim_create_process(
|
|
char *cmd,
|
|
BOOL inherit_handles,
|
|
DWORD flags,
|
|
STARTUPINFO *si,
|
|
PROCESS_INFORMATION *pi,
|
|
LPVOID *env,
|
|
char *cwd)
|
|
{
|
|
BOOL ret = FALSE;
|
|
WCHAR *wcmd, *wcwd = NULL;
|
|
|
|
wcmd = enc_to_utf16((char_u *)cmd, NULL);
|
|
if (wcmd == NULL)
|
|
return FALSE;
|
|
if (cwd != NULL)
|
|
{
|
|
wcwd = enc_to_utf16((char_u *)cwd, NULL);
|
|
if (wcwd == NULL)
|
|
goto theend;
|
|
}
|
|
|
|
ret = CreateProcessW(
|
|
NULL, // Executable name
|
|
wcmd, // Command to execute
|
|
NULL, // Process security attributes
|
|
NULL, // Thread security attributes
|
|
inherit_handles, // Inherit handles
|
|
flags, // Creation flags
|
|
env, // Environment
|
|
wcwd, // Current directory
|
|
(LPSTARTUPINFOW)si, // Startup information
|
|
pi); // Process information
|
|
theend:
|
|
vim_free(wcmd);
|
|
vim_free(wcwd);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static HINSTANCE
|
|
vim_shell_execute(
|
|
char *cmd,
|
|
INT n_show_cmd)
|
|
{
|
|
HINSTANCE ret;
|
|
WCHAR *wcmd;
|
|
|
|
wcmd = enc_to_utf16((char_u *)cmd, NULL);
|
|
if (wcmd == NULL)
|
|
return (HINSTANCE) 0;
|
|
|
|
ret = ShellExecuteW(NULL, NULL, wcmd, NULL, NULL, n_show_cmd);
|
|
vim_free(wcmd);
|
|
return ret;
|
|
}
|
|
|
|
|
|
#if defined(FEAT_GUI_MSWIN) || defined(PROTO)
|
|
|
|
/*
|
|
* Specialised version of system() for Win32 GUI mode.
|
|
* This version proceeds as follows:
|
|
* 1. Create a console window for use by the subprocess
|
|
* 2. Run the subprocess (it gets the allocated console by default)
|
|
* 3. Wait for the subprocess to terminate and get its exit code
|
|
* 4. Prompt the user to press a key to close the console window
|
|
*/
|
|
static int
|
|
mch_system_classic(char *cmd, int options)
|
|
{
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
DWORD ret = 0;
|
|
HWND hwnd = GetFocus();
|
|
|
|
si.cb = sizeof(si);
|
|
si.lpReserved = NULL;
|
|
si.lpDesktop = NULL;
|
|
si.lpTitle = NULL;
|
|
si.dwFlags = STARTF_USESHOWWINDOW;
|
|
/*
|
|
* It's nicer to run a filter command in a minimized window.
|
|
* Don't activate the window to keep focus on Vim.
|
|
*/
|
|
if (options & SHELL_DOOUT)
|
|
si.wShowWindow = SW_SHOWMINNOACTIVE;
|
|
else
|
|
si.wShowWindow = SW_SHOWNORMAL;
|
|
si.cbReserved2 = 0;
|
|
si.lpReserved2 = NULL;
|
|
|
|
// Now, run the command
|
|
vim_create_process(cmd, FALSE,
|
|
CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_CONSOLE,
|
|
&si, &pi, NULL, NULL);
|
|
|
|
// Wait for the command to terminate before continuing
|
|
{
|
|
# ifdef FEAT_GUI
|
|
int delay = 1;
|
|
|
|
// Keep updating the window while waiting for the shell to finish.
|
|
for (;;)
|
|
{
|
|
MSG msg;
|
|
|
|
if (PeekMessageW(&msg, (HWND)NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessageW(&msg);
|
|
delay = 1;
|
|
continue;
|
|
}
|
|
if (WaitForSingleObject(pi.hProcess, delay) != WAIT_TIMEOUT)
|
|
break;
|
|
|
|
// We start waiting for a very short time and then increase it, so
|
|
// that we respond quickly when the process is quick, and don't
|
|
// consume too much overhead when it's slow.
|
|
if (delay < 50)
|
|
delay += 10;
|
|
}
|
|
# else
|
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
|
# endif
|
|
|
|
// Get the command exit code
|
|
GetExitCodeProcess(pi.hProcess, &ret);
|
|
}
|
|
|
|
// Close the handles to the subprocess, so that it goes away
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
|
|
// Try to get input focus back. Doesn't always work though.
|
|
PostMessage(hwnd, WM_SETFOCUS, 0, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Thread launched by the gui to send the current buffer data to the
|
|
* process. This way avoid to hang up vim totally if the children
|
|
* process take a long time to process the lines.
|
|
*/
|
|
static unsigned int __stdcall
|
|
sub_process_writer(LPVOID param)
|
|
{
|
|
HANDLE g_hChildStd_IN_Wr = param;
|
|
linenr_T lnum = curbuf->b_op_start.lnum;
|
|
DWORD len = 0;
|
|
DWORD l;
|
|
char_u *lp = ml_get(lnum);
|
|
char_u *s;
|
|
int written = 0;
|
|
|
|
for (;;)
|
|
{
|
|
l = (DWORD)STRLEN(lp + written);
|
|
if (l == 0)
|
|
len = 0;
|
|
else if (lp[written] == NL)
|
|
{
|
|
// NL -> NUL translation
|
|
WriteFile(g_hChildStd_IN_Wr, "", 1, &len, NULL);
|
|
}
|
|
else
|
|
{
|
|
s = vim_strchr(lp + written, NL);
|
|
WriteFile(g_hChildStd_IN_Wr, (char *)lp + written,
|
|
s == NULL ? l : (DWORD)(s - (lp + written)),
|
|
&len, NULL);
|
|
}
|
|
if (len == l)
|
|
{
|
|
// Finished a line, add a NL, unless this line should not have
|
|
// one.
|
|
if (lnum != curbuf->b_op_end.lnum
|
|
|| (!curbuf->b_p_bin
|
|
&& curbuf->b_p_fixeol)
|
|
|| (lnum != curbuf->b_no_eol_lnum
|
|
&& (lnum != curbuf->b_ml.ml_line_count
|
|
|| curbuf->b_p_eol)))
|
|
{
|
|
WriteFile(g_hChildStd_IN_Wr, "\n", 1,
|
|
(LPDWORD)&vim_ignored, NULL);
|
|
}
|
|
|
|
++lnum;
|
|
if (lnum > curbuf->b_op_end.lnum)
|
|
break;
|
|
|
|
lp = ml_get(lnum);
|
|
written = 0;
|
|
}
|
|
else if (len > 0)
|
|
written += len;
|
|
}
|
|
|
|
// finished all the lines, close pipe
|
|
CloseHandle(g_hChildStd_IN_Wr);
|
|
return 0;
|
|
}
|
|
|
|
|
|
# define BUFLEN 100 // length for buffer, stolen from unix version
|
|
|
|
/*
|
|
* This function read from the children's stdout and write the
|
|
* data on screen or in the buffer accordingly.
|
|
*/
|
|
static void
|
|
dump_pipe(int options,
|
|
HANDLE g_hChildStd_OUT_Rd,
|
|
garray_T *ga,
|
|
char_u buffer[],
|
|
DWORD *buffer_off)
|
|
{
|
|
DWORD availableBytes = 0;
|
|
DWORD i;
|
|
int ret;
|
|
DWORD len;
|
|
DWORD toRead;
|
|
|
|
// we query the pipe to see if there is any data to read
|
|
// to avoid to perform a blocking read
|
|
ret = PeekNamedPipe(g_hChildStd_OUT_Rd, // pipe to query
|
|
NULL, // optional buffer
|
|
0, // buffer size
|
|
NULL, // number of read bytes
|
|
&availableBytes, // available bytes total
|
|
NULL); // byteLeft
|
|
|
|
// We got real data in the pipe, read it
|
|
while (ret != 0 && availableBytes > 0)
|
|
{
|
|
toRead = (DWORD)(BUFLEN - *buffer_off);
|
|
toRead = availableBytes < toRead ? availableBytes : toRead;
|
|
ReadFile(g_hChildStd_OUT_Rd, buffer + *buffer_off, toRead , &len, NULL);
|
|
|
|
// If we haven't read anything, there is a problem
|
|
if (len == 0)
|
|
break;
|
|
|
|
availableBytes -= len;
|
|
|
|
if (options & SHELL_READ)
|
|
{
|
|
// Do NUL -> NL translation, append NL separated
|
|
// lines to the current buffer.
|
|
for (i = 0; i < len; ++i)
|
|
{
|
|
if (buffer[i] == NL)
|
|
append_ga_line(ga);
|
|
else if (buffer[i] == NUL)
|
|
ga_append(ga, NL);
|
|
else
|
|
ga_append(ga, buffer[i]);
|
|
}
|
|
}
|
|
else if (has_mbyte)
|
|
{
|
|
int l;
|
|
int c;
|
|
char_u *p;
|
|
|
|
len += *buffer_off;
|
|
buffer[len] = NUL;
|
|
|
|
// Check if the last character in buffer[] is
|
|
// incomplete, keep these bytes for the next
|
|
// round.
|
|
for (p = buffer; p < buffer + len; p += l)
|
|
{
|
|
l = MB_CPTR2LEN(p);
|
|
if (l == 0)
|
|
l = 1; // NUL byte?
|
|
else if (MB_BYTE2LEN(*p) != l)
|
|
break;
|
|
}
|
|
if (p == buffer) // no complete character
|
|
{
|
|
// avoid getting stuck at an illegal byte
|
|
if (len >= 12)
|
|
++p;
|
|
else
|
|
{
|
|
*buffer_off = len;
|
|
return;
|
|
}
|
|
}
|
|
c = *p;
|
|
*p = NUL;
|
|
msg_puts((char *)buffer);
|
|
if (p < buffer + len)
|
|
{
|
|
*p = c;
|
|
*buffer_off = (DWORD)((buffer + len) - p);
|
|
mch_memmove(buffer, p, *buffer_off);
|
|
return;
|
|
}
|
|
*buffer_off = 0;
|
|
}
|
|
else
|
|
{
|
|
buffer[len] = NUL;
|
|
msg_puts((char *)buffer);
|
|
}
|
|
|
|
windgoto(msg_row, msg_col);
|
|
cursor_on();
|
|
out_flush();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Version of system to use for windows NT > 5.0 (Win2K), use pipe
|
|
* for communication and doesn't open any new window.
|
|
*/
|
|
static int
|
|
mch_system_piped(char *cmd, int options)
|
|
{
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
DWORD ret = 0;
|
|
|
|
HANDLE g_hChildStd_IN_Rd = NULL;
|
|
HANDLE g_hChildStd_IN_Wr = NULL;
|
|
HANDLE g_hChildStd_OUT_Rd = NULL;
|
|
HANDLE g_hChildStd_OUT_Wr = NULL;
|
|
|
|
char_u buffer[BUFLEN + 1]; // reading buffer + size
|
|
DWORD len;
|
|
|
|
// buffer used to receive keys
|
|
char_u ta_buf[BUFLEN + 1]; // TypeAHead
|
|
int ta_len = 0; // valid bytes in ta_buf[]
|
|
|
|
DWORD i;
|
|
int noread_cnt = 0;
|
|
garray_T ga;
|
|
int delay = 1;
|
|
DWORD buffer_off = 0; // valid bytes in buffer[]
|
|
char *p = NULL;
|
|
|
|
SECURITY_ATTRIBUTES saAttr;
|
|
|
|
// Set the bInheritHandle flag so pipe handles are inherited.
|
|
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
|
saAttr.bInheritHandle = TRUE;
|
|
saAttr.lpSecurityDescriptor = NULL;
|
|
|
|
if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0)
|
|
// Ensure the read handle to the pipe for STDOUT is not inherited.
|
|
|| ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0)
|
|
// Create a pipe for the child process's STDIN.
|
|
|| ! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)
|
|
// Ensure the write handle to the pipe for STDIN is not inherited.
|
|
|| ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
|
|
{
|
|
CloseHandle(g_hChildStd_IN_Rd);
|
|
CloseHandle(g_hChildStd_IN_Wr);
|
|
CloseHandle(g_hChildStd_OUT_Rd);
|
|
CloseHandle(g_hChildStd_OUT_Wr);
|
|
msg_puts(_("\nCannot create pipes\n"));
|
|
}
|
|
|
|
si.cb = sizeof(si);
|
|
si.lpReserved = NULL;
|
|
si.lpDesktop = NULL;
|
|
si.lpTitle = NULL;
|
|
si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
|
|
|
|
// set-up our file redirection
|
|
si.hStdError = g_hChildStd_OUT_Wr;
|
|
si.hStdOutput = g_hChildStd_OUT_Wr;
|
|
si.hStdInput = g_hChildStd_IN_Rd;
|
|
si.wShowWindow = SW_HIDE;
|
|
si.cbReserved2 = 0;
|
|
si.lpReserved2 = NULL;
|
|
|
|
if (options & SHELL_READ)
|
|
ga_init2(&ga, 1, BUFLEN);
|
|
|
|
if (cmd != NULL)
|
|
{
|
|
p = (char *)vim_strsave((char_u *)cmd);
|
|
if (p != NULL)
|
|
unescape_shellxquote((char_u *)p, p_sxe);
|
|
else
|
|
p = cmd;
|
|
}
|
|
|
|
// Now, run the command.
|
|
// About "Inherit handles" being TRUE: this command can be litigious,
|
|
// handle inheritance was deactivated for pending temp file, but, if we
|
|
// deactivate it, the pipes don't work for some reason.
|
|
vim_create_process(p, TRUE, CREATE_DEFAULT_ERROR_MODE,
|
|
&si, &pi, NULL, NULL);
|
|
|
|
if (p != cmd)
|
|
vim_free(p);
|
|
|
|
// Close our unused side of the pipes
|
|
CloseHandle(g_hChildStd_IN_Rd);
|
|
CloseHandle(g_hChildStd_OUT_Wr);
|
|
|
|
if (options & SHELL_WRITE)
|
|
{
|
|
HANDLE thread = (HANDLE)
|
|
_beginthreadex(NULL, // security attributes
|
|
0, // default stack size
|
|
sub_process_writer, // function to be executed
|
|
g_hChildStd_IN_Wr, // parameter
|
|
0, // creation flag, start immediately
|
|
NULL); // we don't care about thread id
|
|
CloseHandle(thread);
|
|
g_hChildStd_IN_Wr = NULL;
|
|
}
|
|
|
|
// Keep updating the window while waiting for the shell to finish.
|
|
for (;;)
|
|
{
|
|
MSG msg;
|
|
|
|
if (PeekMessageW(&msg, (HWND)NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessageW(&msg);
|
|
}
|
|
|
|
// write pipe information in the window
|
|
if ((options & (SHELL_READ|SHELL_WRITE))
|
|
# ifdef FEAT_GUI
|
|
|| gui.in_use
|
|
# endif
|
|
)
|
|
{
|
|
len = 0;
|
|
if (((options &
|
|
(SHELL_READ|SHELL_WRITE|SHELL_COOKED))
|
|
!= (SHELL_READ|SHELL_WRITE|SHELL_COOKED)
|
|
# ifdef FEAT_GUI
|
|
|| gui.in_use
|
|
# endif
|
|
)
|
|
&& (ta_len > 0 || noread_cnt > 4))
|
|
{
|
|
if (ta_len == 0)
|
|
{
|
|
// Get extra characters when we don't have any. Reset the
|
|
// counter and timer.
|
|
noread_cnt = 0;
|
|
len = ui_inchar(ta_buf, BUFLEN, 10L, 0);
|
|
}
|
|
if (ta_len > 0 || len > 0)
|
|
{
|
|
/*
|
|
* For pipes: Check for CTRL-C: send interrupt signal to
|
|
* child.
|
|
*/
|
|
if (len == 1 && cmd != NULL)
|
|
{
|
|
if (ta_buf[ta_len] == Ctrl_C)
|
|
{
|
|
// Learn what exit code is expected, for
|
|
// now put 9 as SIGKILL
|
|
TerminateProcess(pi.hProcess, 9);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check for CTRL-D: EOF, close pipe to child.
|
|
* Ctrl_D may be decorated by _OnChar()
|
|
*/
|
|
if ((len == 1 || len == 4 ) && cmd != NULL)
|
|
{
|
|
if (ta_buf[0] == Ctrl_D
|
|
|| (ta_buf[0] == CSI
|
|
&& ta_buf[1] == KS_MODIFIER
|
|
&& ta_buf[3] == Ctrl_D))
|
|
{
|
|
CloseHandle(g_hChildStd_IN_Wr);
|
|
g_hChildStd_IN_Wr = NULL;
|
|
len = 0;
|
|
}
|
|
}
|
|
|
|
len = term_replace_keycodes(ta_buf, ta_len, len);
|
|
|
|
/*
|
|
* For pipes: echo the typed characters. For a pty this
|
|
* does not seem to work.
|
|
*/
|
|
for (i = ta_len; i < ta_len + len; ++i)
|
|
{
|
|
if (ta_buf[i] == '\n' || ta_buf[i] == '\b')
|
|
msg_putchar(ta_buf[i]);
|
|
else if (has_mbyte)
|
|
{
|
|
int l = (*mb_ptr2len)(ta_buf + i);
|
|
|
|
msg_outtrans_len(ta_buf + i, l);
|
|
i += l - 1;
|
|
}
|
|
else
|
|
msg_outtrans_len(ta_buf + i, 1);
|
|
}
|
|
windgoto(msg_row, msg_col);
|
|
out_flush();
|
|
|
|
ta_len += len;
|
|
|
|
/*
|
|
* Write the characters to the child, unless EOF has been
|
|
* typed for pipes. Write one character at a time, to
|
|
* avoid losing too much typeahead. When writing buffer
|
|
* lines, drop the typed characters (only check for
|
|
* CTRL-C).
|
|
*/
|
|
if (options & SHELL_WRITE)
|
|
ta_len = 0;
|
|
else if (g_hChildStd_IN_Wr != NULL)
|
|
{
|
|
WriteFile(g_hChildStd_IN_Wr, (char*)ta_buf,
|
|
1, &len, NULL);
|
|
// if we are typing in, we want to keep things reactive
|
|
delay = 1;
|
|
if (len > 0)
|
|
{
|
|
ta_len -= len;
|
|
mch_memmove(ta_buf, ta_buf + len, ta_len);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ta_len)
|
|
ui_inchar_undo(ta_buf, ta_len);
|
|
|
|
if (WaitForSingleObject(pi.hProcess, delay) != WAIT_TIMEOUT)
|
|
{
|
|
dump_pipe(options, g_hChildStd_OUT_Rd, &ga, buffer, &buffer_off);
|
|
break;
|
|
}
|
|
|
|
++noread_cnt;
|
|
dump_pipe(options, g_hChildStd_OUT_Rd, &ga, buffer, &buffer_off);
|
|
|
|
// We start waiting for a very short time and then increase it, so
|
|
// that we respond quickly when the process is quick, and don't
|
|
// consume too much overhead when it's slow.
|
|
if (delay < 50)
|
|
delay += 10;
|
|
}
|
|
|
|
// Close the pipe
|
|
CloseHandle(g_hChildStd_OUT_Rd);
|
|
if (g_hChildStd_IN_Wr != NULL)
|
|
CloseHandle(g_hChildStd_IN_Wr);
|
|
|
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
|
|
|
// Get the command exit code
|
|
GetExitCodeProcess(pi.hProcess, &ret);
|
|
|
|
if (options & SHELL_READ)
|
|
{
|
|
if (ga.ga_len > 0)
|
|
{
|
|
append_ga_line(&ga);
|
|
// remember that the NL was missing
|
|
curbuf->b_no_eol_lnum = curwin->w_cursor.lnum;
|
|
}
|
|
else
|
|
curbuf->b_no_eol_lnum = 0;
|
|
ga_clear(&ga);
|
|
}
|
|
|
|
// Close the handles to the subprocess, so that it goes away
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
mch_system_g(char *cmd, int options)
|
|
{
|
|
// if we can pipe and the shelltemp option is off
|
|
if (!p_stmp)
|
|
return mch_system_piped(cmd, options);
|
|
else
|
|
return mch_system_classic(cmd, options);
|
|
}
|
|
#endif
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
static int
|
|
mch_system_c(char *cmd, int options UNUSED)
|
|
{
|
|
int ret;
|
|
WCHAR *wcmd;
|
|
char_u *buf;
|
|
size_t len;
|
|
|
|
// If the command starts and ends with double quotes, enclose the command
|
|
// in parentheses.
|
|
len = STRLEN(cmd);
|
|
if (len >= 2 && cmd[0] == '"' && cmd[len - 1] == '"')
|
|
{
|
|
len += 3;
|
|
buf = alloc(len);
|
|
if (buf == NULL)
|
|
return -1;
|
|
vim_snprintf((char *)buf, len, "(%s)", cmd);
|
|
wcmd = enc_to_utf16(buf, NULL);
|
|
free(buf);
|
|
}
|
|
else
|
|
wcmd = enc_to_utf16((char_u *)cmd, NULL);
|
|
|
|
if (wcmd == NULL)
|
|
return -1;
|
|
|
|
ret = _wsystem(wcmd);
|
|
vim_free(wcmd);
|
|
return ret;
|
|
}
|
|
|
|
#endif
|
|
|
|
static int
|
|
mch_system(char *cmd, int options)
|
|
{
|
|
#ifdef VIMDLL
|
|
if (gui.in_use || gui.starting)
|
|
return mch_system_g(cmd, options);
|
|
else
|
|
return mch_system_c(cmd, options);
|
|
#elif defined(FEAT_GUI_MSWIN)
|
|
return mch_system_g(cmd, options);
|
|
#else
|
|
return mch_system_c(cmd, options);
|
|
#endif
|
|
}
|
|
|
|
#if defined(FEAT_GUI) && defined(FEAT_TERMINAL)
|
|
/*
|
|
* Use a terminal window to run a shell command in.
|
|
*/
|
|
static int
|
|
mch_call_shell_terminal(
|
|
char_u *cmd,
|
|
int options UNUSED) // SHELL_*, see vim.h
|
|
{
|
|
jobopt_T opt;
|
|
char_u *newcmd = NULL;
|
|
typval_T argvar[2];
|
|
long_u cmdlen;
|
|
int retval = -1;
|
|
buf_T *buf;
|
|
job_T *job;
|
|
aco_save_T aco;
|
|
oparg_T oa; // operator arguments
|
|
|
|
if (cmd == NULL)
|
|
cmdlen = STRLEN(p_sh) + 1;
|
|
else
|
|
cmdlen = STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10;
|
|
newcmd = alloc(cmdlen);
|
|
if (newcmd == NULL)
|
|
return 255;
|
|
if (cmd == NULL)
|
|
{
|
|
STRCPY(newcmd, p_sh);
|
|
ch_log(NULL, "starting terminal to run a shell");
|
|
}
|
|
else
|
|
{
|
|
vim_snprintf((char *)newcmd, cmdlen, "%s %s %s", p_sh, p_shcf, cmd);
|
|
ch_log(NULL, "starting terminal for system command '%s'", cmd);
|
|
}
|
|
|
|
init_job_options(&opt);
|
|
|
|
argvar[0].v_type = VAR_STRING;
|
|
argvar[0].vval.v_string = newcmd;
|
|
argvar[1].v_type = VAR_UNKNOWN;
|
|
buf = term_start(argvar, NULL, &opt, TERM_START_SYSTEM);
|
|
if (buf == NULL)
|
|
{
|
|
vim_free(newcmd);
|
|
return 255;
|
|
}
|
|
|
|
job = term_getjob(buf->b_term);
|
|
++job->jv_refcount;
|
|
|
|
// Find a window to make "buf" curbuf.
|
|
aucmd_prepbuf(&aco, buf);
|
|
if (curbuf == buf)
|
|
{
|
|
// Only do this when a window was found for "buf".
|
|
clear_oparg(&oa);
|
|
while (term_use_loop())
|
|
{
|
|
if (oa.op_type == OP_NOP && oa.regname == NUL && !VIsual_active)
|
|
{
|
|
// If terminal_loop() returns OK we got a key that is handled
|
|
// in Normal model. We don't do redrawing anyway.
|
|
if (terminal_loop(TRUE) == OK)
|
|
normal_cmd(&oa, TRUE);
|
|
}
|
|
else
|
|
normal_cmd(&oa, TRUE);
|
|
}
|
|
retval = job->jv_exitval;
|
|
ch_log(NULL, "system command finished");
|
|
|
|
job_unref(job);
|
|
|
|
// restore curwin/curbuf and a few other things
|
|
aucmd_restbuf(&aco);
|
|
}
|
|
|
|
wait_return(TRUE);
|
|
do_buffer(DOBUF_WIPE, DOBUF_FIRST, FORWARD, buf->b_fnum, TRUE);
|
|
|
|
vim_free(newcmd);
|
|
return retval;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Either execute a command by calling the shell or start a new shell
|
|
*/
|
|
int
|
|
mch_call_shell(
|
|
char_u *cmd,
|
|
int options) // SHELL_*, see vim.h
|
|
{
|
|
int x = 0;
|
|
int tmode = cur_tmode;
|
|
WCHAR szShellTitle[512];
|
|
|
|
#ifdef FEAT_EVAL
|
|
ch_log(NULL, "executing shell command: %s", cmd);
|
|
#endif
|
|
// Change the title to reflect that we are in a subshell.
|
|
if (GetConsoleTitleW(szShellTitle, ARRAY_LENGTH(szShellTitle) - 4) > 0)
|
|
{
|
|
if (cmd == NULL)
|
|
wcscat(szShellTitle, L" :sh");
|
|
else
|
|
{
|
|
WCHAR *wn = enc_to_utf16((char_u *)cmd, NULL);
|
|
|
|
if (wn != NULL)
|
|
{
|
|
wcscat(szShellTitle, L" - !");
|
|
if ((wcslen(szShellTitle) + wcslen(wn) <
|
|
ARRAY_LENGTH(szShellTitle)))
|
|
wcscat(szShellTitle, wn);
|
|
SetConsoleTitleW(szShellTitle);
|
|
vim_free(wn);
|
|
}
|
|
}
|
|
}
|
|
|
|
out_flush();
|
|
|
|
#ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fprintf(fdDump, "mch_call_shell(\"%s\", %d)\n", cmd, options);
|
|
fflush(fdDump);
|
|
}
|
|
#endif
|
|
#if defined(FEAT_GUI) && defined(FEAT_TERMINAL)
|
|
// TODO: make the terminal window work with input or output redirected.
|
|
if (
|
|
# ifdef VIMDLL
|
|
gui.in_use &&
|
|
# endif
|
|
vim_strchr(p_go, GO_TERMINAL) != NULL
|
|
&& (options & (SHELL_FILTER|SHELL_DOOUT|SHELL_WRITE|SHELL_READ)) == 0)
|
|
{
|
|
char_u *cmdbase = cmd;
|
|
|
|
if (cmdbase != NULL)
|
|
// Skip a leading quote and (.
|
|
while (*cmdbase == '"' || *cmdbase == '(')
|
|
++cmdbase;
|
|
|
|
// Check the command does not begin with "start "
|
|
if (cmdbase == NULL || STRNICMP(cmdbase, "start", 5) != 0
|
|
|| !VIM_ISWHITE(cmdbase[5]))
|
|
{
|
|
// Use a terminal window to run the command in.
|
|
x = mch_call_shell_terminal(cmd, options);
|
|
resettitle();
|
|
return x;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Catch all deadly signals while running the external command, because a
|
|
* CTRL-C, Ctrl-Break or illegal instruction might otherwise kill us.
|
|
*/
|
|
mch_signal(SIGINT, SIG_IGN);
|
|
mch_signal(SIGBREAK, SIG_IGN);
|
|
mch_signal(SIGILL, SIG_IGN);
|
|
mch_signal(SIGFPE, SIG_IGN);
|
|
mch_signal(SIGSEGV, SIG_IGN);
|
|
mch_signal(SIGTERM, SIG_IGN);
|
|
mch_signal(SIGABRT, SIG_IGN);
|
|
|
|
if (options & SHELL_COOKED)
|
|
settmode(TMODE_COOK); // set to normal mode
|
|
|
|
if (cmd == NULL)
|
|
{
|
|
x = mch_system((char *)p_sh, options);
|
|
}
|
|
else
|
|
{
|
|
// we use "command" or "cmd" to start the shell; slow but easy
|
|
char_u *newcmd = NULL;
|
|
char_u *cmdbase = cmd;
|
|
long_u cmdlen;
|
|
|
|
// Skip a leading ", ( and "(.
|
|
if (*cmdbase == '"' )
|
|
++cmdbase;
|
|
if (*cmdbase == '(')
|
|
++cmdbase;
|
|
|
|
if ((STRNICMP(cmdbase, "start", 5) == 0) && VIM_ISWHITE(cmdbase[5]))
|
|
{
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
DWORD flags = CREATE_NEW_CONSOLE;
|
|
INT n_show_cmd = SW_SHOWNORMAL;
|
|
char_u *p;
|
|
|
|
ZeroMemory(&si, sizeof(si));
|
|
si.cb = sizeof(si);
|
|
si.lpReserved = NULL;
|
|
si.lpDesktop = NULL;
|
|
si.lpTitle = NULL;
|
|
si.dwFlags = 0;
|
|
si.cbReserved2 = 0;
|
|
si.lpReserved2 = NULL;
|
|
|
|
cmdbase = skipwhite(cmdbase + 5);
|
|
if ((STRNICMP(cmdbase, "/min", 4) == 0)
|
|
&& VIM_ISWHITE(cmdbase[4]))
|
|
{
|
|
cmdbase = skipwhite(cmdbase + 4);
|
|
si.dwFlags = STARTF_USESHOWWINDOW;
|
|
si.wShowWindow = SW_SHOWMINNOACTIVE;
|
|
n_show_cmd = SW_SHOWMINNOACTIVE;
|
|
}
|
|
else if ((STRNICMP(cmdbase, "/b", 2) == 0)
|
|
&& VIM_ISWHITE(cmdbase[2]))
|
|
{
|
|
cmdbase = skipwhite(cmdbase + 2);
|
|
flags = CREATE_NO_WINDOW;
|
|
si.dwFlags = STARTF_USESTDHANDLES;
|
|
si.hStdInput = CreateFile("\\\\.\\NUL", // File name
|
|
GENERIC_READ, // Access flags
|
|
0, // Share flags
|
|
NULL, // Security att.
|
|
OPEN_EXISTING, // Open flags
|
|
FILE_ATTRIBUTE_NORMAL, // File att.
|
|
NULL); // Temp file
|
|
si.hStdOutput = si.hStdInput;
|
|
si.hStdError = si.hStdInput;
|
|
}
|
|
|
|
// Remove a trailing ", ) and )" if they have a match
|
|
// at the start of the command.
|
|
if (cmdbase > cmd)
|
|
{
|
|
p = cmdbase + STRLEN(cmdbase);
|
|
if (p > cmdbase && p[-1] == '"' && *cmd == '"')
|
|
*--p = NUL;
|
|
if (p > cmdbase && p[-1] == ')'
|
|
&& (*cmd =='(' || cmd[1] == '('))
|
|
*--p = NUL;
|
|
}
|
|
|
|
newcmd = cmdbase;
|
|
unescape_shellxquote(cmdbase, p_sxe);
|
|
|
|
/*
|
|
* If creating new console, arguments are passed to the
|
|
* 'cmd.exe' as-is. If it's not, arguments are not treated
|
|
* correctly for current 'cmd.exe'. So unescape characters in
|
|
* shellxescape except '|' for avoiding to be treated as
|
|
* argument to them. Pass the arguments to sub-shell.
|
|
*/
|
|
if (flags != CREATE_NEW_CONSOLE)
|
|
{
|
|
char_u *subcmd;
|
|
char_u *cmd_shell = mch_getenv("COMSPEC");
|
|
|
|
if (cmd_shell == NULL || *cmd_shell == NUL)
|
|
cmd_shell = (char_u *)default_shell();
|
|
|
|
subcmd = vim_strsave_escaped_ext(cmdbase,
|
|
(char_u *)"|", '^', FALSE);
|
|
if (subcmd != NULL)
|
|
{
|
|
// make "cmd.exe /c arguments"
|
|
cmdlen = STRLEN(cmd_shell) + STRLEN(subcmd) + 5;
|
|
newcmd = alloc(cmdlen);
|
|
if (newcmd != NULL)
|
|
vim_snprintf((char *)newcmd, cmdlen, "%s /c %s",
|
|
cmd_shell, subcmd);
|
|
else
|
|
newcmd = cmdbase;
|
|
vim_free(subcmd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now, start the command as a process, so that it doesn't
|
|
* inherit our handles which causes unpleasant dangling swap
|
|
* files if we exit before the spawned process
|
|
*/
|
|
if (vim_create_process((char *)newcmd, FALSE, flags,
|
|
&si, &pi, NULL, NULL))
|
|
x = 0;
|
|
else if (vim_shell_execute((char *)newcmd, n_show_cmd)
|
|
> (HINSTANCE)32)
|
|
x = 0;
|
|
else
|
|
{
|
|
x = -1;
|
|
#ifdef FEAT_GUI_MSWIN
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
# endif
|
|
emsg(_(e_command_not_found));
|
|
#endif
|
|
}
|
|
|
|
if (newcmd != cmdbase)
|
|
vim_free(newcmd);
|
|
|
|
if (si.dwFlags == STARTF_USESTDHANDLES && si.hStdInput != NULL)
|
|
{
|
|
// Close the handle to \\.\NUL created above.
|
|
CloseHandle(si.hStdInput);
|
|
}
|
|
// Close the handles to the subprocess, so that it goes away
|
|
CloseHandle(pi.hThread);
|
|
CloseHandle(pi.hProcess);
|
|
}
|
|
else
|
|
{
|
|
cmdlen =
|
|
#ifdef FEAT_GUI_MSWIN
|
|
((gui.in_use || gui.starting) ?
|
|
(!s_dont_use_vimrun && p_stmp ?
|
|
STRLEN(vimrun_path) : STRLEN(p_sh) + STRLEN(p_shcf))
|
|
: 0) +
|
|
#endif
|
|
STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10;
|
|
|
|
newcmd = alloc(cmdlen);
|
|
if (newcmd != NULL)
|
|
{
|
|
#if defined(FEAT_GUI_MSWIN)
|
|
if (
|
|
# ifdef VIMDLL
|
|
(gui.in_use || gui.starting) &&
|
|
# endif
|
|
need_vimrun_warning)
|
|
{
|
|
char *msg = _("VIMRUN.EXE not found in your $PATH.\n"
|
|
"External commands will not pause after completion.\n"
|
|
"See :help win32-vimrun for more information.");
|
|
char *title = _("Vim Warning");
|
|
WCHAR *wmsg = enc_to_utf16((char_u *)msg, NULL);
|
|
WCHAR *wtitle = enc_to_utf16((char_u *)title, NULL);
|
|
|
|
if (wmsg != NULL && wtitle != NULL)
|
|
MessageBoxW(NULL, wmsg, wtitle, MB_ICONWARNING);
|
|
vim_free(wmsg);
|
|
vim_free(wtitle);
|
|
need_vimrun_warning = FALSE;
|
|
}
|
|
if (
|
|
# ifdef VIMDLL
|
|
(gui.in_use || gui.starting) &&
|
|
# endif
|
|
!s_dont_use_vimrun && p_stmp)
|
|
// Use vimrun to execute the command. It opens a console
|
|
// window, which can be closed without killing Vim.
|
|
vim_snprintf((char *)newcmd, cmdlen, "%s%s%s %s %s",
|
|
vimrun_path,
|
|
(msg_silent != 0 || (options & SHELL_DOOUT))
|
|
? "-s " : "",
|
|
p_sh, p_shcf, cmd);
|
|
else if (
|
|
# ifdef VIMDLL
|
|
(gui.in_use || gui.starting) &&
|
|
# endif
|
|
s_dont_use_vimrun && STRCMP(p_shcf, "/c") == 0)
|
|
// workaround for the case that "vimrun" does not exist
|
|
vim_snprintf((char *)newcmd, cmdlen, "%s %s %s %s %s",
|
|
p_sh, p_shcf, p_sh, p_shcf, cmd);
|
|
else
|
|
#endif
|
|
vim_snprintf((char *)newcmd, cmdlen, "%s %s %s",
|
|
p_sh, p_shcf, cmd);
|
|
x = mch_system((char *)newcmd, options);
|
|
vim_free(newcmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tmode == TMODE_RAW)
|
|
{
|
|
// The shell may have messed with the mode, always set it.
|
|
cur_tmode = TMODE_UNKNOWN;
|
|
settmode(TMODE_RAW); // set to raw mode
|
|
}
|
|
|
|
// Print the return value, unless "vimrun" was used.
|
|
if (x != 0 && !(options & SHELL_SILENT) && !emsg_silent
|
|
#if defined(FEAT_GUI_MSWIN)
|
|
&& ((gui.in_use || gui.starting) ?
|
|
((options & SHELL_DOOUT) || s_dont_use_vimrun || !p_stmp) : 1)
|
|
#endif
|
|
)
|
|
{
|
|
smsg(_("shell returned %d"), x);
|
|
msg_putchar('\n');
|
|
}
|
|
resettitle();
|
|
|
|
mch_signal(SIGINT, SIG_DFL);
|
|
mch_signal(SIGBREAK, SIG_DFL);
|
|
mch_signal(SIGILL, SIG_DFL);
|
|
mch_signal(SIGFPE, SIG_DFL);
|
|
mch_signal(SIGSEGV, SIG_DFL);
|
|
mch_signal(SIGTERM, SIG_DFL);
|
|
mch_signal(SIGABRT, SIG_DFL);
|
|
|
|
return x;
|
|
}
|
|
|
|
#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
|
|
static HANDLE
|
|
job_io_file_open(
|
|
char_u *fname,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition,
|
|
DWORD dwFlagsAndAttributes)
|
|
{
|
|
HANDLE h;
|
|
WCHAR *wn;
|
|
|
|
wn = enc_to_utf16(fname, NULL);
|
|
if (wn == NULL)
|
|
return INVALID_HANDLE_VALUE;
|
|
|
|
h = CreateFileW(wn, dwDesiredAccess, dwShareMode,
|
|
lpSecurityAttributes, dwCreationDisposition,
|
|
dwFlagsAndAttributes, NULL);
|
|
vim_free(wn);
|
|
return h;
|
|
}
|
|
|
|
/*
|
|
* Turn the dictionary "env" into a NUL separated list that can be used as the
|
|
* environment argument of vim_create_process().
|
|
*/
|
|
void
|
|
win32_build_env(dict_T *env, garray_T *gap, int is_terminal)
|
|
{
|
|
hashitem_T *hi;
|
|
long_u todo = env != NULL ? env->dv_hashtab.ht_used : 0;
|
|
LPVOID base = GetEnvironmentStringsW();
|
|
|
|
// for last \0
|
|
if (ga_grow(gap, 1) == FAIL)
|
|
return;
|
|
|
|
if (env != NULL)
|
|
{
|
|
FOR_ALL_HASHTAB_ITEMS(&env->dv_hashtab, hi, todo)
|
|
{
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
typval_T *item = &dict_lookup(hi)->di_tv;
|
|
WCHAR *wkey = enc_to_utf16((char_u *)hi->hi_key, NULL);
|
|
WCHAR *wval = enc_to_utf16(tv_get_string(item), NULL);
|
|
--todo;
|
|
if (wkey != NULL && wval != NULL)
|
|
{
|
|
size_t n;
|
|
size_t lkey = wcslen(wkey);
|
|
size_t lval = wcslen(wval);
|
|
|
|
if (ga_grow(gap, (int)(lkey + lval + 2)) == FAIL)
|
|
continue;
|
|
for (n = 0; n < lkey; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = wkey[n];
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = L'=';
|
|
for (n = 0; n < lval; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = wval[n];
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = L'\0';
|
|
}
|
|
vim_free(wkey);
|
|
vim_free(wval);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (base)
|
|
{
|
|
WCHAR *p = (WCHAR*) base;
|
|
|
|
// for last \0
|
|
if (ga_grow(gap, 1) == FAIL)
|
|
return;
|
|
|
|
while (*p != 0 || *(p + 1) != 0)
|
|
{
|
|
if (ga_grow(gap, 1) == OK)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = *p;
|
|
p++;
|
|
}
|
|
FreeEnvironmentStringsW(base);
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = L'\0';
|
|
}
|
|
|
|
# if defined(FEAT_CLIENTSERVER) || defined(FEAT_TERMINAL)
|
|
{
|
|
# ifdef FEAT_CLIENTSERVER
|
|
char_u *servername = get_vim_var_str(VV_SEND_SERVER);
|
|
size_t servername_len = STRLEN(servername);
|
|
# endif
|
|
# ifdef FEAT_TERMINAL
|
|
char_u *version = get_vim_var_str(VV_VERSION);
|
|
size_t version_len = STRLEN(version);
|
|
# endif
|
|
// size of "VIM_SERVERNAME=" and value,
|
|
// plus "VIM_TERMINAL=" and value,
|
|
// plus two terminating NULs
|
|
size_t n = 0
|
|
# ifdef FEAT_CLIENTSERVER
|
|
+ 15 + servername_len
|
|
# endif
|
|
# ifdef FEAT_TERMINAL
|
|
+ 13 + version_len + 2
|
|
# endif
|
|
;
|
|
|
|
if (ga_grow(gap, (int)n) == OK)
|
|
{
|
|
# ifdef FEAT_CLIENTSERVER
|
|
for (n = 0; n < 15; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) =
|
|
(WCHAR)"VIM_SERVERNAME="[n];
|
|
for (n = 0; n < servername_len; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) =
|
|
(WCHAR)servername[n];
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = L'\0';
|
|
# endif
|
|
# ifdef FEAT_TERMINAL
|
|
if (is_terminal)
|
|
{
|
|
for (n = 0; n < 13; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) =
|
|
(WCHAR)"VIM_TERMINAL="[n];
|
|
for (n = 0; n < version_len; n++)
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) =
|
|
(WCHAR)version[n];
|
|
*((WCHAR*)gap->ga_data + gap->ga_len++) = L'\0';
|
|
}
|
|
# endif
|
|
}
|
|
}
|
|
# endif
|
|
}
|
|
|
|
/*
|
|
* Create a pair of pipes.
|
|
* Return TRUE for success, FALSE for failure.
|
|
*/
|
|
static BOOL
|
|
create_pipe_pair(HANDLE handles[2])
|
|
{
|
|
static LONG s;
|
|
char name[64];
|
|
SECURITY_ATTRIBUTES sa;
|
|
|
|
sprintf(name, "\\\\?\\pipe\\vim-%08lx-%08lx",
|
|
GetCurrentProcessId(),
|
|
InterlockedIncrement(&s));
|
|
|
|
// Create named pipe. Max size of named pipe is 65535.
|
|
handles[1] = CreateNamedPipe(
|
|
name,
|
|
PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
|
|
PIPE_TYPE_BYTE | PIPE_NOWAIT,
|
|
1, MAX_NAMED_PIPE_SIZE, 0, 0, NULL);
|
|
|
|
if (handles[1] == INVALID_HANDLE_VALUE)
|
|
return FALSE;
|
|
|
|
sa.nLength = sizeof(sa);
|
|
sa.bInheritHandle = TRUE;
|
|
sa.lpSecurityDescriptor = NULL;
|
|
|
|
handles[0] = CreateFile(name,
|
|
FILE_GENERIC_READ,
|
|
FILE_SHARE_READ, &sa,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
|
|
|
|
if (handles[0] == INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(handles[1]);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
mch_job_start(char *cmd, job_T *job, jobopt_T *options)
|
|
{
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
HANDLE jo;
|
|
SECURITY_ATTRIBUTES saAttr;
|
|
channel_T *channel = NULL;
|
|
HANDLE ifd[2];
|
|
HANDLE ofd[2];
|
|
HANDLE efd[2];
|
|
garray_T ga;
|
|
|
|
int use_null_for_in = options->jo_io[PART_IN] == JIO_NULL;
|
|
int use_null_for_out = options->jo_io[PART_OUT] == JIO_NULL;
|
|
int use_null_for_err = options->jo_io[PART_ERR] == JIO_NULL;
|
|
int use_file_for_in = options->jo_io[PART_IN] == JIO_FILE;
|
|
int use_file_for_out = options->jo_io[PART_OUT] == JIO_FILE;
|
|
int use_file_for_err = options->jo_io[PART_ERR] == JIO_FILE;
|
|
int use_out_for_err = options->jo_io[PART_ERR] == JIO_OUT;
|
|
|
|
if (use_out_for_err && use_null_for_out)
|
|
use_null_for_err = TRUE;
|
|
|
|
ifd[0] = INVALID_HANDLE_VALUE;
|
|
ifd[1] = INVALID_HANDLE_VALUE;
|
|
ofd[0] = INVALID_HANDLE_VALUE;
|
|
ofd[1] = INVALID_HANDLE_VALUE;
|
|
efd[0] = INVALID_HANDLE_VALUE;
|
|
efd[1] = INVALID_HANDLE_VALUE;
|
|
ga_init2(&ga, sizeof(wchar_t), 500);
|
|
|
|
jo = CreateJobObject(NULL, NULL);
|
|
if (jo == NULL)
|
|
{
|
|
job->jv_status = JOB_FAILED;
|
|
goto failed;
|
|
}
|
|
|
|
if (options->jo_env != NULL)
|
|
win32_build_env(options->jo_env, &ga, FALSE);
|
|
|
|
ZeroMemory(&pi, sizeof(pi));
|
|
ZeroMemory(&si, sizeof(si));
|
|
si.cb = sizeof(si);
|
|
si.dwFlags |= STARTF_USESHOWWINDOW;
|
|
si.wShowWindow = SW_HIDE;
|
|
|
|
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
|
saAttr.bInheritHandle = TRUE;
|
|
saAttr.lpSecurityDescriptor = NULL;
|
|
|
|
if (use_file_for_in)
|
|
{
|
|
char_u *fname = options->jo_io_name[PART_IN];
|
|
|
|
ifd[0] = job_io_file_open(fname, GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
&saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL);
|
|
if (ifd[0] == INVALID_HANDLE_VALUE)
|
|
{
|
|
semsg(_(e_cant_open_file_str), fname);
|
|
goto failed;
|
|
}
|
|
}
|
|
else if (!use_null_for_in
|
|
&& (!create_pipe_pair(ifd)
|
|
|| !SetHandleInformation(ifd[1], HANDLE_FLAG_INHERIT, 0)))
|
|
goto failed;
|
|
|
|
if (use_file_for_out)
|
|
{
|
|
char_u *fname = options->jo_io_name[PART_OUT];
|
|
|
|
ofd[1] = job_io_file_open(fname, GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
&saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);
|
|
if (ofd[1] == INVALID_HANDLE_VALUE)
|
|
{
|
|
semsg(_(e_cant_open_file_str), fname);
|
|
goto failed;
|
|
}
|
|
}
|
|
else if (!use_null_for_out &&
|
|
(!CreatePipe(&ofd[0], &ofd[1], &saAttr, 0)
|
|
|| !SetHandleInformation(ofd[0], HANDLE_FLAG_INHERIT, 0)))
|
|
goto failed;
|
|
|
|
if (use_file_for_err)
|
|
{
|
|
char_u *fname = options->jo_io_name[PART_ERR];
|
|
|
|
efd[1] = job_io_file_open(fname, GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
&saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);
|
|
if (efd[1] == INVALID_HANDLE_VALUE)
|
|
{
|
|
semsg(_(e_cant_open_file_str), fname);
|
|
goto failed;
|
|
}
|
|
}
|
|
else if (!use_out_for_err && !use_null_for_err &&
|
|
(!CreatePipe(&efd[0], &efd[1], &saAttr, 0)
|
|
|| !SetHandleInformation(efd[0], HANDLE_FLAG_INHERIT, 0)))
|
|
goto failed;
|
|
|
|
si.dwFlags |= STARTF_USESTDHANDLES;
|
|
si.hStdInput = ifd[0];
|
|
si.hStdOutput = ofd[1];
|
|
si.hStdError = use_out_for_err ? ofd[1] : efd[1];
|
|
|
|
if (!use_null_for_in || !use_null_for_out || !use_null_for_err)
|
|
{
|
|
if (options->jo_set & JO_CHANNEL)
|
|
{
|
|
channel = options->jo_channel;
|
|
if (channel != NULL)
|
|
++channel->ch_refcount;
|
|
}
|
|
else
|
|
channel = add_channel();
|
|
if (channel == NULL)
|
|
goto failed;
|
|
}
|
|
|
|
if (!vim_create_process(cmd, TRUE,
|
|
CREATE_SUSPENDED |
|
|
CREATE_DEFAULT_ERROR_MODE |
|
|
CREATE_NEW_PROCESS_GROUP |
|
|
CREATE_UNICODE_ENVIRONMENT |
|
|
CREATE_NEW_CONSOLE,
|
|
&si, &pi,
|
|
ga.ga_data,
|
|
(char *)options->jo_cwd))
|
|
{
|
|
CloseHandle(jo);
|
|
job->jv_status = JOB_FAILED;
|
|
goto failed;
|
|
}
|
|
|
|
ga_clear(&ga);
|
|
|
|
if (!AssignProcessToJobObject(jo, pi.hProcess))
|
|
{
|
|
// if failing, switch the way to terminate
|
|
// process with TerminateProcess.
|
|
CloseHandle(jo);
|
|
jo = NULL;
|
|
}
|
|
ResumeThread(pi.hThread);
|
|
CloseHandle(pi.hThread);
|
|
job->jv_proc_info = pi;
|
|
job->jv_job_object = jo;
|
|
job->jv_status = JOB_STARTED;
|
|
|
|
CloseHandle(ifd[0]);
|
|
CloseHandle(ofd[1]);
|
|
if (!use_out_for_err && !use_null_for_err)
|
|
CloseHandle(efd[1]);
|
|
|
|
job->jv_channel = channel;
|
|
if (channel != NULL)
|
|
{
|
|
channel_set_pipes(channel,
|
|
use_file_for_in || use_null_for_in
|
|
? INVALID_FD : (sock_T)ifd[1],
|
|
use_file_for_out || use_null_for_out
|
|
? INVALID_FD : (sock_T)ofd[0],
|
|
use_out_for_err || use_file_for_err || use_null_for_err
|
|
? INVALID_FD : (sock_T)efd[0]);
|
|
channel_set_job(channel, job, options);
|
|
}
|
|
return;
|
|
|
|
failed:
|
|
CloseHandle(ifd[0]);
|
|
CloseHandle(ofd[0]);
|
|
CloseHandle(efd[0]);
|
|
CloseHandle(ifd[1]);
|
|
CloseHandle(ofd[1]);
|
|
CloseHandle(efd[1]);
|
|
channel_unref(channel);
|
|
ga_clear(&ga);
|
|
}
|
|
|
|
char *
|
|
mch_job_status(job_T *job)
|
|
{
|
|
DWORD dwExitCode = 0;
|
|
|
|
if (!GetExitCodeProcess(job->jv_proc_info.hProcess, &dwExitCode)
|
|
|| dwExitCode != STILL_ACTIVE)
|
|
{
|
|
job->jv_exitval = (int)dwExitCode;
|
|
if (job->jv_status < JOB_ENDED)
|
|
{
|
|
ch_log(job->jv_channel, "Job ended");
|
|
job->jv_status = JOB_ENDED;
|
|
}
|
|
return "dead";
|
|
}
|
|
return "run";
|
|
}
|
|
|
|
job_T *
|
|
mch_detect_ended_job(job_T *job_list)
|
|
{
|
|
HANDLE jobHandles[MAXIMUM_WAIT_OBJECTS];
|
|
job_T *jobArray[MAXIMUM_WAIT_OBJECTS];
|
|
job_T *job = job_list;
|
|
|
|
while (job != NULL)
|
|
{
|
|
DWORD n;
|
|
DWORD result;
|
|
|
|
for (n = 0; n < MAXIMUM_WAIT_OBJECTS
|
|
&& job != NULL; job = job->jv_next)
|
|
{
|
|
if (job->jv_status == JOB_STARTED)
|
|
{
|
|
jobHandles[n] = job->jv_proc_info.hProcess;
|
|
jobArray[n] = job;
|
|
++n;
|
|
}
|
|
}
|
|
if (n == 0)
|
|
continue;
|
|
result = WaitForMultipleObjects(n, jobHandles, FALSE, 0);
|
|
if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + n)
|
|
{
|
|
job_T *wait_job = jobArray[result - WAIT_OBJECT_0];
|
|
|
|
if (STRCMP(mch_job_status(wait_job), "dead") == 0)
|
|
return wait_job;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static BOOL
|
|
terminate_all(HANDLE process, int code)
|
|
{
|
|
PROCESSENTRY32 pe;
|
|
HANDLE h = INVALID_HANDLE_VALUE;
|
|
DWORD pid = GetProcessId(process);
|
|
|
|
if (pid != 0)
|
|
{
|
|
h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
{
|
|
pe.dwSize = sizeof(PROCESSENTRY32);
|
|
if (!Process32First(h, &pe))
|
|
goto theend;
|
|
|
|
do
|
|
{
|
|
if (pe.th32ParentProcessID == pid)
|
|
{
|
|
HANDLE ph = OpenProcess(
|
|
PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
|
|
if (ph != NULL)
|
|
{
|
|
terminate_all(ph, code);
|
|
CloseHandle(ph);
|
|
}
|
|
}
|
|
} while (Process32Next(h, &pe));
|
|
|
|
CloseHandle(h);
|
|
}
|
|
}
|
|
|
|
theend:
|
|
return TerminateProcess(process, code);
|
|
}
|
|
|
|
/*
|
|
* Send a (deadly) signal to "job".
|
|
* Return FAIL if it didn't work.
|
|
*/
|
|
int
|
|
mch_signal_job(job_T *job, char_u *how)
|
|
{
|
|
int ret;
|
|
|
|
if (STRCMP(how, "term") == 0 || STRCMP(how, "kill") == 0 || *how == NUL)
|
|
{
|
|
// deadly signal
|
|
if (job->jv_job_object != NULL)
|
|
{
|
|
if (job->jv_channel != NULL && job->jv_channel->ch_anonymous_pipe)
|
|
job->jv_channel->ch_killing = TRUE;
|
|
return TerminateJobObject(job->jv_job_object, (UINT)-1) ? OK : FAIL;
|
|
}
|
|
return terminate_all(job->jv_proc_info.hProcess, -1) ? OK : FAIL;
|
|
}
|
|
|
|
if (!AttachConsole(job->jv_proc_info.dwProcessId))
|
|
return FAIL;
|
|
ret = GenerateConsoleCtrlEvent(
|
|
STRCMP(how, "int") == 0 ? CTRL_C_EVENT : CTRL_BREAK_EVENT,
|
|
job->jv_proc_info.dwProcessId)
|
|
? OK : FAIL;
|
|
FreeConsole();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Clear the data related to "job".
|
|
*/
|
|
void
|
|
mch_clear_job(job_T *job)
|
|
{
|
|
if (job->jv_status == JOB_FAILED)
|
|
return;
|
|
|
|
if (job->jv_job_object != NULL)
|
|
CloseHandle(job->jv_job_object);
|
|
CloseHandle(job->jv_proc_info.hProcess);
|
|
}
|
|
#endif
|
|
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
|
|
/*
|
|
* Start termcap mode
|
|
*/
|
|
static void
|
|
termcap_mode_start(void)
|
|
{
|
|
DWORD cmodein;
|
|
|
|
if (g_fTermcapMode)
|
|
return;
|
|
|
|
SaveConsoleBuffer(&g_cbNonTermcap);
|
|
|
|
if (g_cbTermcap.IsValid)
|
|
{
|
|
/*
|
|
* We've been in termcap mode before. Restore certain screen
|
|
* characteristics, including the buffer size and the window
|
|
* size. Since we will be redrawing the screen, we don't need
|
|
* to restore the actual contents of the buffer.
|
|
*/
|
|
RestoreConsoleBuffer(&g_cbTermcap, FALSE);
|
|
reset_console_color_rgb();
|
|
SetConsoleWindowInfo(g_hConOut, TRUE, &g_cbTermcap.Info.srWindow);
|
|
Rows = g_cbTermcap.Info.dwSize.Y;
|
|
Columns = g_cbTermcap.Info.dwSize.X;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* This is our first time entering termcap mode. Clear the console
|
|
* screen buffer, and resize the buffer to match the current window
|
|
* size. We will use this as the size of our editing environment.
|
|
*/
|
|
ClearConsoleBuffer(g_attrCurrent);
|
|
set_console_color_rgb();
|
|
ResizeConBufAndWindow(g_hConOut, Columns, Rows);
|
|
}
|
|
|
|
resettitle();
|
|
|
|
GetConsoleMode(g_hConIn, &cmodein);
|
|
if (g_fMouseActive)
|
|
{
|
|
cmodein |= ENABLE_MOUSE_INPUT;
|
|
cmodein &= ~ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
else
|
|
{
|
|
cmodein &= ~ENABLE_MOUSE_INPUT;
|
|
cmodein |= g_cmodein & ENABLE_QUICK_EDIT_MODE;
|
|
}
|
|
cmodein |= ENABLE_WINDOW_INPUT;
|
|
SetConsoleMode(g_hConIn, cmodein | ENABLE_EXTENDED_FLAGS);
|
|
|
|
redraw_later_clear();
|
|
g_fTermcapMode = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* End termcap mode
|
|
*/
|
|
static void
|
|
termcap_mode_end(void)
|
|
{
|
|
DWORD cmodein;
|
|
ConsoleBuffer *cb;
|
|
COORD coord;
|
|
DWORD dwDummy;
|
|
|
|
if (!g_fTermcapMode)
|
|
return;
|
|
|
|
SaveConsoleBuffer(&g_cbTermcap);
|
|
|
|
GetConsoleMode(g_hConIn, &cmodein);
|
|
cmodein &= ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
|
|
cmodein |= g_cmodein & ENABLE_QUICK_EDIT_MODE;
|
|
SetConsoleMode(g_hConIn, cmodein | ENABLE_EXTENDED_FLAGS);
|
|
|
|
# ifdef FEAT_RESTORE_ORIG_SCREEN
|
|
cb = exiting ? &g_cbOrig : &g_cbNonTermcap;
|
|
# else
|
|
cb = &g_cbNonTermcap;
|
|
# endif
|
|
RestoreConsoleBuffer(cb, p_rs);
|
|
restore_console_color_rgb();
|
|
|
|
// Switch back to main screen buffer.
|
|
if (exiting && use_alternate_screen_buffer)
|
|
vtp_printf("\033[?1049l");
|
|
|
|
if (!USE_WT && (p_rs || exiting))
|
|
{
|
|
/*
|
|
* Clear anything that happens to be on the current line.
|
|
*/
|
|
coord.X = 0;
|
|
coord.Y = (SHORT) (p_rs ? cb->Info.dwCursorPosition.Y : (Rows - 1));
|
|
FillConsoleOutputCharacter(g_hConOut, ' ',
|
|
cb->Info.dwSize.X, coord, &dwDummy);
|
|
/*
|
|
* The following is just for aesthetics. If we are exiting without
|
|
* restoring the screen, then we want to have a prompt string
|
|
* appear at the bottom line. However, the command interpreter
|
|
* seems to always advance the cursor one line before displaying
|
|
* the prompt string, which causes the screen to scroll. To
|
|
* counter this, move the cursor up one line before exiting.
|
|
*/
|
|
if (exiting && !p_rs)
|
|
coord.Y--;
|
|
/*
|
|
* Position the cursor at the leftmost column of the desired row.
|
|
*/
|
|
SetConsoleCursorPosition(g_hConOut, coord);
|
|
}
|
|
SetConsoleCursorInfo(g_hConOut, &g_cci);
|
|
g_fTermcapMode = FALSE;
|
|
}
|
|
#endif // !FEAT_GUI_MSWIN || VIMDLL
|
|
|
|
|
|
#if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
|
|
void
|
|
mch_write(
|
|
char_u *s UNUSED,
|
|
int len UNUSED)
|
|
{
|
|
// never used
|
|
}
|
|
|
|
#else
|
|
|
|
/*
|
|
* clear `n' chars, starting from `coord'
|
|
*/
|
|
static void
|
|
clear_chars(
|
|
COORD coord,
|
|
DWORD n)
|
|
{
|
|
if (!vtp_working)
|
|
{
|
|
DWORD dwDummy;
|
|
|
|
FillConsoleOutputCharacter(g_hConOut, ' ', n, coord, &dwDummy);
|
|
FillConsoleOutputAttribute(g_hConOut, g_attrCurrent, n, coord,
|
|
&dwDummy);
|
|
}
|
|
else
|
|
{
|
|
set_console_color_rgb();
|
|
gotoxy(coord.X + 1, coord.Y + 1);
|
|
vtp_printf("\033[%dX", n);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Clear the screen
|
|
*/
|
|
static void
|
|
clear_screen(void)
|
|
{
|
|
g_coord.X = g_coord.Y = 0;
|
|
|
|
if (!vtp_working)
|
|
clear_chars(g_coord, Rows * Columns);
|
|
else
|
|
{
|
|
set_console_color_rgb();
|
|
gotoxy(1, 1);
|
|
vtp_printf("\033[2J");
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Clear to end of display
|
|
*/
|
|
static void
|
|
clear_to_end_of_display(void)
|
|
{
|
|
COORD save = g_coord;
|
|
|
|
if (!vtp_working)
|
|
clear_chars(g_coord, (Rows - g_coord.Y - 1)
|
|
* Columns + (Columns - g_coord.X));
|
|
else
|
|
{
|
|
set_console_color_rgb();
|
|
gotoxy(g_coord.X + 1, g_coord.Y + 1);
|
|
vtp_printf("\033[0J");
|
|
|
|
gotoxy(save.X + 1, save.Y + 1);
|
|
g_coord = save;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Clear to end of line
|
|
*/
|
|
static void
|
|
clear_to_end_of_line(void)
|
|
{
|
|
COORD save = g_coord;
|
|
|
|
if (!vtp_working)
|
|
clear_chars(g_coord, Columns - g_coord.X);
|
|
else
|
|
{
|
|
set_console_color_rgb();
|
|
gotoxy(g_coord.X + 1, g_coord.Y + 1);
|
|
vtp_printf("\033[0K");
|
|
|
|
gotoxy(save.X + 1, save.Y + 1);
|
|
g_coord = save;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Scroll the scroll region up by `cLines' lines
|
|
*/
|
|
static void
|
|
scroll(unsigned cLines)
|
|
{
|
|
COORD oldcoord = g_coord;
|
|
|
|
gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Top + 1);
|
|
delete_lines(cLines);
|
|
|
|
g_coord = oldcoord;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the scroll region
|
|
*/
|
|
static void
|
|
set_scroll_region(
|
|
unsigned left,
|
|
unsigned top,
|
|
unsigned right,
|
|
unsigned bottom)
|
|
{
|
|
if (left >= right
|
|
|| top >= bottom
|
|
|| right > (unsigned) Columns - 1
|
|
|| bottom > (unsigned) Rows - 1)
|
|
return;
|
|
|
|
g_srScrollRegion.Left = left;
|
|
g_srScrollRegion.Top = top;
|
|
g_srScrollRegion.Right = right;
|
|
g_srScrollRegion.Bottom = bottom;
|
|
}
|
|
|
|
static void
|
|
set_scroll_region_tb(
|
|
unsigned top,
|
|
unsigned bottom)
|
|
{
|
|
if (top >= bottom || bottom > (unsigned)Rows - 1)
|
|
return;
|
|
|
|
g_srScrollRegion.Top = top;
|
|
g_srScrollRegion.Bottom = bottom;
|
|
}
|
|
|
|
static void
|
|
set_scroll_region_lr(
|
|
unsigned left,
|
|
unsigned right)
|
|
{
|
|
if (left >= right || right > (unsigned)Columns - 1)
|
|
return;
|
|
|
|
g_srScrollRegion.Left = left;
|
|
g_srScrollRegion.Right = right;
|
|
}
|
|
|
|
|
|
/*
|
|
* Insert `cLines' lines at the current cursor position
|
|
*/
|
|
static void
|
|
insert_lines(unsigned cLines)
|
|
{
|
|
SMALL_RECT source, clip;
|
|
COORD dest;
|
|
CHAR_INFO fill;
|
|
|
|
gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Top + 1);
|
|
|
|
dest.X = g_srScrollRegion.Left;
|
|
dest.Y = g_coord.Y + cLines;
|
|
|
|
source.Left = g_srScrollRegion.Left;
|
|
source.Top = g_coord.Y;
|
|
source.Right = g_srScrollRegion.Right;
|
|
source.Bottom = g_srScrollRegion.Bottom - cLines;
|
|
|
|
clip.Left = g_srScrollRegion.Left;
|
|
clip.Top = g_coord.Y;
|
|
clip.Right = g_srScrollRegion.Right;
|
|
clip.Bottom = g_srScrollRegion.Bottom;
|
|
|
|
fill.Char.AsciiChar = ' ';
|
|
if (!USE_VTP)
|
|
fill.Attributes = g_attrCurrent;
|
|
else
|
|
fill.Attributes = g_attrDefault;
|
|
|
|
set_console_color_rgb();
|
|
|
|
ScrollConsoleScreenBuffer(g_hConOut, &source, &clip, dest, &fill);
|
|
|
|
// Here we have to deal with a win32 console flake: If the scroll
|
|
// region looks like abc and we scroll c to a and fill with d we get
|
|
// cbd... if we scroll block c one line at a time to a, we get cdd...
|
|
// vim expects cdd consistently... So we have to deal with that
|
|
// here... (this also occurs scrolling the same way in the other
|
|
// direction).
|
|
|
|
if (source.Bottom < dest.Y)
|
|
{
|
|
COORD coord;
|
|
int i;
|
|
|
|
coord.X = source.Left;
|
|
for (i = clip.Top; i < dest.Y; ++i)
|
|
{
|
|
coord.Y = i;
|
|
clear_chars(coord, source.Right - source.Left + 1);
|
|
}
|
|
}
|
|
|
|
if (vtp_working)
|
|
{
|
|
COORD coord;
|
|
int i;
|
|
|
|
coord.X = source.Left;
|
|
for (i = source.Top; i < dest.Y; ++i)
|
|
{
|
|
coord.Y = i;
|
|
clear_chars(coord, source.Right - source.Left + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Delete `cLines' lines at the current cursor position
|
|
*/
|
|
static void
|
|
delete_lines(unsigned cLines)
|
|
{
|
|
SMALL_RECT source, clip;
|
|
COORD dest;
|
|
CHAR_INFO fill;
|
|
int nb;
|
|
|
|
gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Top + 1);
|
|
|
|
dest.X = g_srScrollRegion.Left;
|
|
dest.Y = g_coord.Y;
|
|
|
|
source.Left = g_srScrollRegion.Left;
|
|
source.Top = g_coord.Y + cLines;
|
|
source.Right = g_srScrollRegion.Right;
|
|
source.Bottom = g_srScrollRegion.Bottom;
|
|
|
|
clip.Left = g_srScrollRegion.Left;
|
|
clip.Top = g_coord.Y;
|
|
clip.Right = g_srScrollRegion.Right;
|
|
clip.Bottom = g_srScrollRegion.Bottom;
|
|
|
|
fill.Char.AsciiChar = ' ';
|
|
if (!vtp_working)
|
|
fill.Attributes = g_attrCurrent;
|
|
else
|
|
fill.Attributes = g_attrDefault;
|
|
|
|
set_console_color_rgb();
|
|
|
|
ScrollConsoleScreenBuffer(g_hConOut, &source, &clip, dest, &fill);
|
|
|
|
// Here we have to deal with a win32 console flake; See insert_lines()
|
|
// above.
|
|
|
|
nb = dest.Y + (source.Bottom - source.Top) + 1;
|
|
|
|
if (nb < source.Top)
|
|
{
|
|
COORD coord;
|
|
int i;
|
|
|
|
coord.X = source.Left;
|
|
for (i = nb; i < clip.Bottom; ++i)
|
|
{
|
|
coord.Y = i;
|
|
clear_chars(coord, source.Right - source.Left + 1);
|
|
}
|
|
}
|
|
|
|
if (vtp_working)
|
|
{
|
|
COORD coord;
|
|
int i;
|
|
|
|
coord.X = source.Left;
|
|
for (i = nb; i <= source.Bottom; ++i)
|
|
{
|
|
coord.Y = i;
|
|
clear_chars(coord, source.Right - source.Left + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the cursor position to (x,y) (1-based).
|
|
*/
|
|
static void
|
|
gotoxy(
|
|
unsigned x,
|
|
unsigned y)
|
|
{
|
|
if (x < 1 || x > (unsigned)Columns || y < 1 || y > (unsigned)Rows)
|
|
return;
|
|
|
|
if (!USE_VTP)
|
|
{
|
|
// There are reports of double-width characters not displayed
|
|
// correctly. This workaround should fix it, similar to how it's done
|
|
// for VTP.
|
|
g_coord.X = 0;
|
|
SetConsoleCursorPosition(g_hConOut, g_coord);
|
|
|
|
// external cursor coords are 1-based; internal are 0-based
|
|
g_coord.X = x - 1;
|
|
g_coord.Y = y - 1;
|
|
SetConsoleCursorPosition(g_hConOut, g_coord);
|
|
}
|
|
else
|
|
{
|
|
// Move the cursor to the left edge of the screen to prevent screen
|
|
// destruction. Insider build bug. Always enabled because it's cheap
|
|
// and avoids mistakes with recognizing the build.
|
|
vtp_printf("\033[%d;%dH", g_coord.Y + 1, 1);
|
|
|
|
vtp_printf("\033[%d;%dH", y, x);
|
|
|
|
g_coord.X = x - 1;
|
|
g_coord.Y = y - 1;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Set the current text attribute = (foreground | background)
|
|
* See ../runtime/doc/os_win32.txt for the numbers.
|
|
*/
|
|
static void
|
|
textattr(WORD wAttr)
|
|
{
|
|
g_attrCurrent = wAttr & 0xff;
|
|
|
|
SetConsoleTextAttribute(g_hConOut, wAttr);
|
|
}
|
|
|
|
|
|
static void
|
|
textcolor(WORD wAttr)
|
|
{
|
|
g_attrCurrent = (g_attrCurrent & 0xf0) + (wAttr & 0x0f);
|
|
|
|
if (!vtp_working)
|
|
SetConsoleTextAttribute(g_hConOut, g_attrCurrent);
|
|
else
|
|
vtp_sgr_bulk(wAttr);
|
|
}
|
|
|
|
|
|
static void
|
|
textbackground(WORD wAttr)
|
|
{
|
|
g_attrCurrent = (g_attrCurrent & 0x0f) + ((wAttr & 0x0f) << 4);
|
|
|
|
if (!vtp_working)
|
|
SetConsoleTextAttribute(g_hConOut, g_attrCurrent);
|
|
else
|
|
vtp_sgr_bulk(wAttr);
|
|
}
|
|
|
|
|
|
/*
|
|
* restore the default text attribute (whatever we started with)
|
|
*/
|
|
static void
|
|
normvideo(void)
|
|
{
|
|
if (!vtp_working)
|
|
textattr(g_attrDefault);
|
|
else
|
|
vtp_sgr_bulk(0);
|
|
}
|
|
|
|
|
|
static WORD g_attrPreStandout = 0;
|
|
|
|
/*
|
|
* Make the text standout, by brightening it
|
|
*/
|
|
static void
|
|
standout(void)
|
|
{
|
|
g_attrPreStandout = g_attrCurrent;
|
|
|
|
textattr((WORD) (g_attrCurrent|FOREGROUND_INTENSITY|BACKGROUND_INTENSITY));
|
|
}
|
|
|
|
|
|
/*
|
|
* Turn off standout mode
|
|
*/
|
|
static void
|
|
standend(void)
|
|
{
|
|
if (g_attrPreStandout)
|
|
textattr(g_attrPreStandout);
|
|
|
|
g_attrPreStandout = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set normal fg/bg color, based on T_ME. Called when t_me has been set.
|
|
*/
|
|
void
|
|
mch_set_normal_colors(void)
|
|
{
|
|
char_u *p;
|
|
int n;
|
|
|
|
cterm_normal_fg_color = (g_attrDefault & 0xf) + 1;
|
|
cterm_normal_bg_color = ((g_attrDefault >> 4) & 0xf) + 1;
|
|
if (
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
!p_tgc &&
|
|
# endif
|
|
T_ME[0] == ESC && T_ME[1] == '|')
|
|
{
|
|
p = T_ME + 2;
|
|
n = getdigits(&p);
|
|
if (*p == 'm' && n > 0)
|
|
{
|
|
cterm_normal_fg_color = (n & 0xf) + 1;
|
|
cterm_normal_bg_color = ((n >> 4) & 0xf) + 1;
|
|
}
|
|
}
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
cterm_normal_fg_gui_color = INVALCOLOR;
|
|
cterm_normal_bg_gui_color = INVALCOLOR;
|
|
# endif
|
|
}
|
|
|
|
|
|
/*
|
|
* visual bell: flash the screen
|
|
*/
|
|
static void
|
|
visual_bell(void)
|
|
{
|
|
COORD coordOrigin = {0, 0};
|
|
WORD attrFlash = ~g_attrCurrent & 0xff;
|
|
|
|
DWORD dwDummy;
|
|
LPWORD oldattrs = NULL;
|
|
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
if (!(p_tgc || t_colors >= 256))
|
|
# endif
|
|
{
|
|
oldattrs = ALLOC_MULT(WORD, Rows * Columns);
|
|
if (oldattrs == NULL)
|
|
return;
|
|
ReadConsoleOutputAttribute(g_hConOut, oldattrs, Rows * Columns,
|
|
coordOrigin, &dwDummy);
|
|
}
|
|
|
|
FillConsoleOutputAttribute(g_hConOut, attrFlash, Rows * Columns,
|
|
coordOrigin, &dwDummy);
|
|
|
|
Sleep(15); // wait for 15 msec
|
|
|
|
if (oldattrs != NULL)
|
|
{
|
|
WriteConsoleOutputAttribute(g_hConOut, oldattrs, Rows * Columns,
|
|
coordOrigin, &dwDummy);
|
|
vim_free(oldattrs);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Make the cursor visible or invisible
|
|
*/
|
|
static void
|
|
cursor_visible(BOOL fVisible)
|
|
{
|
|
s_cursor_visible = fVisible;
|
|
|
|
if (vtp_working)
|
|
vtp_printf("\033[?25%c", fVisible ? 'h' : 'l');
|
|
|
|
# ifdef MCH_CURSOR_SHAPE
|
|
mch_update_cursor();
|
|
# endif
|
|
}
|
|
|
|
|
|
/*
|
|
* Write "cbToWrite" bytes in `pchBuf' to the screen.
|
|
* Returns the number of bytes actually written (at least one).
|
|
*/
|
|
static DWORD
|
|
write_chars(
|
|
char_u *pchBuf,
|
|
DWORD cbToWrite)
|
|
{
|
|
COORD coord = g_coord;
|
|
DWORD written;
|
|
DWORD n, cchwritten;
|
|
static DWORD cells;
|
|
static WCHAR *unicodebuf = NULL;
|
|
static int unibuflen = 0;
|
|
static int length;
|
|
int cp = enc_utf8 ? CP_UTF8 : enc_codepage;
|
|
static WCHAR *utf8spbuf = NULL;
|
|
static int utf8splength;
|
|
static DWORD utf8spcells;
|
|
static WCHAR **utf8usingbuf = &unicodebuf;
|
|
|
|
if (cbToWrite != 1 || *pchBuf != ' ' || !enc_utf8)
|
|
{
|
|
utf8usingbuf = &unicodebuf;
|
|
do
|
|
{
|
|
length = MultiByteToWideChar(cp, 0, (LPCSTR)pchBuf, cbToWrite,
|
|
unicodebuf, unibuflen);
|
|
if (length && length <= unibuflen)
|
|
break;
|
|
vim_free(unicodebuf);
|
|
unicodebuf = length ? LALLOC_MULT(WCHAR, length) : NULL;
|
|
unibuflen = unibuflen ? 0 : length;
|
|
} while (TRUE);
|
|
cells = mb_string2cells(pchBuf, cbToWrite);
|
|
}
|
|
else // cbToWrite == 1 && *pchBuf == ' ' && enc_utf8
|
|
{
|
|
if (utf8usingbuf != &utf8spbuf)
|
|
{
|
|
if (utf8spbuf == NULL)
|
|
{
|
|
cells = mb_string2cells((char_u *)" ", 1);
|
|
length = MultiByteToWideChar(CP_UTF8, 0, " ", 1, NULL, 0);
|
|
utf8spbuf = LALLOC_MULT(WCHAR, length);
|
|
if (utf8spbuf != NULL)
|
|
{
|
|
MultiByteToWideChar(CP_UTF8, 0, " ", 1, utf8spbuf, length);
|
|
utf8usingbuf = &utf8spbuf;
|
|
utf8splength = length;
|
|
utf8spcells = cells;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
utf8usingbuf = &utf8spbuf;
|
|
length = utf8splength;
|
|
cells = utf8spcells;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!USE_VTP)
|
|
{
|
|
FillConsoleOutputAttribute(g_hConOut, g_attrCurrent, cells,
|
|
coord, &written);
|
|
// When writing fails or didn't write a single character, pretend one
|
|
// character was written, otherwise we get stuck.
|
|
if (WriteConsoleOutputCharacterW(g_hConOut, *utf8usingbuf, length,
|
|
coord, &cchwritten) == 0
|
|
|| cchwritten == 0 || cchwritten == (DWORD)-1)
|
|
cchwritten = 1;
|
|
}
|
|
else
|
|
{
|
|
if (WriteConsoleW(g_hConOut, *utf8usingbuf, length, &cchwritten,
|
|
NULL) == 0 || cchwritten == 0)
|
|
cchwritten = 1;
|
|
}
|
|
|
|
if (cchwritten == (DWORD)length)
|
|
{
|
|
written = cbToWrite;
|
|
g_coord.X += (SHORT)cells;
|
|
}
|
|
else
|
|
{
|
|
char_u *p = pchBuf;
|
|
for (n = 0; n < cchwritten; n++)
|
|
MB_CPTR_ADV(p);
|
|
written = p - pchBuf;
|
|
g_coord.X += (SHORT)mb_string2cells(pchBuf, written);
|
|
}
|
|
|
|
while (g_coord.X > g_srScrollRegion.Right)
|
|
{
|
|
g_coord.X -= (SHORT) Columns;
|
|
if (g_coord.Y < g_srScrollRegion.Bottom)
|
|
g_coord.Y++;
|
|
}
|
|
|
|
// Cursor under VTP is always in the correct position, no need to reset.
|
|
if (!USE_VTP)
|
|
gotoxy(g_coord.X + 1, g_coord.Y + 1);
|
|
|
|
return written;
|
|
}
|
|
|
|
static char_u *
|
|
get_seq(
|
|
int *args,
|
|
int *count,
|
|
char_u *head)
|
|
{
|
|
int argc;
|
|
char_u *p;
|
|
|
|
if (head == NULL || *head != '\033')
|
|
return NULL;
|
|
|
|
argc = 0;
|
|
p = head;
|
|
++p;
|
|
do
|
|
{
|
|
++p;
|
|
args[argc] = getdigits(&p);
|
|
argc += (argc < 15) ? 1 : 0;
|
|
} while (*p == ';');
|
|
*count = argc;
|
|
|
|
return p;
|
|
}
|
|
|
|
static char_u *
|
|
get_sgr(
|
|
int *args,
|
|
int *count,
|
|
char_u *head)
|
|
{
|
|
char_u *p = get_seq(args, count, head);
|
|
|
|
return (p && *p == 'm') ? ++p : NULL;
|
|
}
|
|
|
|
/*
|
|
* Pointer to next if SGR (^[[n;2;*;*;*m), NULL otherwise.
|
|
*/
|
|
static char_u *
|
|
sgrn2(
|
|
char_u *head,
|
|
int n)
|
|
{
|
|
int argc;
|
|
int args[16];
|
|
char_u *p = get_sgr(args, &argc, head);
|
|
|
|
return p && argc == 5 && args[0] == n && args[1] == 2 ? p : NULL;
|
|
}
|
|
|
|
/*
|
|
* Pointer to next if SGR(^[[nm)<space>ESC, NULL otherwise.
|
|
*/
|
|
static char_u *
|
|
sgrnc(
|
|
char_u *head,
|
|
int n)
|
|
{
|
|
int argc;
|
|
int args[16];
|
|
char_u *p = get_sgr(args, &argc, head);
|
|
|
|
return p && argc == 1 && args[0] == n && (p = skipwhite(p)) && *p == '\033'
|
|
? p : NULL;
|
|
}
|
|
|
|
static char_u *
|
|
skipblank(char_u *q)
|
|
{
|
|
char_u *p = q;
|
|
|
|
while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')
|
|
++p;
|
|
return p;
|
|
}
|
|
|
|
/*
|
|
* Pointer to the next if any whitespace that may follow SGR is ESC, otherwise
|
|
* NULL.
|
|
*/
|
|
static char_u *
|
|
sgrn2c(
|
|
char_u *head,
|
|
int n)
|
|
{
|
|
char_u *p = sgrn2(head, n);
|
|
|
|
return p && *p != NUL && (p = skipblank(p)) && *p == '\033' ? p : NULL;
|
|
}
|
|
|
|
/*
|
|
* If there is only a newline between the sequence immediately following it,
|
|
* a pointer to the character following the newline is returned.
|
|
* Otherwise NULL.
|
|
*/
|
|
static char_u *
|
|
sgrn2cn(
|
|
char_u *head,
|
|
int n)
|
|
{
|
|
char_u *p = sgrn2(head, n);
|
|
|
|
return p && p[0] == 0x0a && p[1] == '\033' ? ++p : NULL;
|
|
}
|
|
|
|
/*
|
|
* mch_write(): write the output buffer to the screen, translating ESC
|
|
* sequences into calls to console output routines.
|
|
*/
|
|
void
|
|
mch_write(
|
|
char_u *s,
|
|
int len)
|
|
{
|
|
char_u *end = s + len;
|
|
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
return;
|
|
# endif
|
|
|
|
if (!term_console)
|
|
{
|
|
write(1, s, (unsigned)len);
|
|
return;
|
|
}
|
|
|
|
// translate ESC | sequences into faked bios calls
|
|
while (len--)
|
|
{
|
|
int prefix = -1;
|
|
char_u ch;
|
|
|
|
// While processing a sequence, on rare occasions it seems that another
|
|
// sequence may be inserted asynchronously.
|
|
if (len < 0)
|
|
{
|
|
redraw_all_later(UPD_CLEAR);
|
|
return;
|
|
}
|
|
|
|
while (s + ++prefix < end)
|
|
{
|
|
ch = s[prefix];
|
|
if (ch <= 0x1e && !(ch != '\n' && ch != '\r' && ch != '\b'
|
|
&& ch != '\a' && ch != '\033'))
|
|
break;
|
|
}
|
|
|
|
if (p_wd)
|
|
{
|
|
WaitForChar(p_wd, FALSE);
|
|
if (prefix != 0)
|
|
prefix = 1;
|
|
}
|
|
|
|
if (prefix != 0)
|
|
{
|
|
DWORD nWritten;
|
|
|
|
nWritten = write_chars(s, prefix);
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fputc('>', fdDump);
|
|
fwrite(s, sizeof(char_u), nWritten, fdDump);
|
|
fputs("<\n", fdDump);
|
|
}
|
|
# endif
|
|
len -= (nWritten - 1);
|
|
s += nWritten;
|
|
}
|
|
else if (s[0] == '\n')
|
|
{
|
|
// \n, newline: go to the beginning of the next line or scroll
|
|
if (g_coord.Y == g_srScrollRegion.Bottom)
|
|
{
|
|
scroll(1);
|
|
gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Bottom + 1);
|
|
}
|
|
else
|
|
{
|
|
gotoxy(g_srScrollRegion.Left + 1, g_coord.Y + 2);
|
|
}
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputs("\\n\n", fdDump);
|
|
# endif
|
|
s++;
|
|
}
|
|
else if (s[0] == '\r')
|
|
{
|
|
// \r, carriage return: go to beginning of line
|
|
gotoxy(g_srScrollRegion.Left+1, g_coord.Y + 1);
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputs("\\r\n", fdDump);
|
|
# endif
|
|
s++;
|
|
}
|
|
else if (s[0] == '\b')
|
|
{
|
|
// \b, backspace: move cursor one position left
|
|
if (g_coord.X > g_srScrollRegion.Left)
|
|
g_coord.X--;
|
|
else if (g_coord.Y > g_srScrollRegion.Top)
|
|
{
|
|
g_coord.X = g_srScrollRegion.Right;
|
|
g_coord.Y--;
|
|
}
|
|
gotoxy(g_coord.X + 1, g_coord.Y + 1);
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputs("\\b\n", fdDump);
|
|
# endif
|
|
s++;
|
|
}
|
|
else if (s[0] == '\a')
|
|
{
|
|
// \a, bell
|
|
MessageBeep(0xFFFFFFFF);
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fputs("\\a\n", fdDump);
|
|
# endif
|
|
s++;
|
|
}
|
|
else if (s[0] == ESC && len >= 3-1 && s[1] == '|')
|
|
{
|
|
# ifdef MCH_WRITE_DUMP
|
|
char_u *old_s = s;
|
|
# endif
|
|
char_u *p;
|
|
int arg1 = 0, arg2 = 0, argc = 0, args[16];
|
|
char_u *sp;
|
|
|
|
switch (s[2])
|
|
{
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
if (*(p = get_seq(args, &argc, s)) != 'm')
|
|
goto notsgr;
|
|
|
|
p = s;
|
|
|
|
// Handling frequent optional sequences. Output to the screen
|
|
// takes too long, so do not output as much as possible.
|
|
|
|
// If resetFG,FG,BG,<cr>,BG,FG are connected, the preceding
|
|
// resetFG,FG,BG are omitted.
|
|
if (sgrn2(sgrn2(sgrn2cn(sgrn2(sgrnc(p, 39), 38), 48), 48), 38))
|
|
{
|
|
p = sgrn2(sgrn2(sgrnc(p, 39), 38), 48);
|
|
len = len + 1 - (int)(p - s);
|
|
s = p;
|
|
break;
|
|
}
|
|
|
|
// If FG,BG,BG,FG of SGR are connected, the first FG can be
|
|
// omitted.
|
|
if (sgrn2(sgrn2(sgrn2c((sp = sgrn2(p, 38)), 48), 48), 38))
|
|
p = sp;
|
|
|
|
// If FG,BG,FG,BG of SGR are connected, the first FG can be
|
|
// omitted.
|
|
if (sgrn2(sgrn2(sgrn2c((sp = sgrn2(p, 38)), 48), 38), 48))
|
|
p = sp;
|
|
|
|
// If BG,BG of SGR are connected, the first BG can be omitted.
|
|
if (sgrn2((sp = sgrn2(p, 48)), 48))
|
|
p = sp;
|
|
|
|
// If restoreFG and FG are connected, the restoreFG can be
|
|
// omitted.
|
|
if (sgrn2((sp = sgrnc(p, 39)), 38))
|
|
p = sp;
|
|
|
|
p = get_seq(args, &argc, p);
|
|
|
|
notsgr:
|
|
arg1 = args[0];
|
|
arg2 = args[1];
|
|
if (*p == 'm')
|
|
{
|
|
if (argc == 1 && args[0] == 0)
|
|
normvideo();
|
|
else if (argc == 1)
|
|
{
|
|
if (USE_VTP)
|
|
textcolor((WORD)arg1);
|
|
else
|
|
textattr((WORD)arg1);
|
|
}
|
|
else if (vtp_working)
|
|
vtp_sgr_bulks(argc, args);
|
|
}
|
|
else if (argc == 2 && *p == 'H')
|
|
{
|
|
gotoxy(arg2, arg1);
|
|
}
|
|
else if (argc == 2 && *p == 'r')
|
|
{
|
|
set_scroll_region(0, arg1 - 1, Columns - 1, arg2 - 1);
|
|
}
|
|
else if (argc == 2 && *p == 'R')
|
|
{
|
|
set_scroll_region_tb(arg1, arg2);
|
|
}
|
|
else if (argc == 2 && *p == 'V')
|
|
{
|
|
set_scroll_region_lr(arg1, arg2);
|
|
}
|
|
else if (argc == 1 && *p == 'A')
|
|
{
|
|
gotoxy(g_coord.X + 1,
|
|
max(g_srScrollRegion.Top, g_coord.Y - arg1) + 1);
|
|
}
|
|
else if (argc == 1 && *p == 'b')
|
|
{
|
|
textbackground((WORD) arg1);
|
|
}
|
|
else if (argc == 1 && *p == 'C')
|
|
{
|
|
gotoxy(min(g_srScrollRegion.Right, g_coord.X + arg1) + 1,
|
|
g_coord.Y + 1);
|
|
}
|
|
else if (argc == 1 && *p == 'f')
|
|
{
|
|
textcolor((WORD) arg1);
|
|
}
|
|
else if (argc == 1 && *p == 'H')
|
|
{
|
|
gotoxy(1, arg1);
|
|
}
|
|
else if (argc == 1 && *p == 'L')
|
|
{
|
|
insert_lines(arg1);
|
|
}
|
|
else if (argc == 1 && *p == 'M')
|
|
{
|
|
delete_lines(arg1);
|
|
}
|
|
|
|
len -= (int)(p - s);
|
|
s = p + 1;
|
|
break;
|
|
|
|
case 'A':
|
|
gotoxy(g_coord.X + 1,
|
|
max(g_srScrollRegion.Top, g_coord.Y - 1) + 1);
|
|
goto got3;
|
|
|
|
case 'B':
|
|
visual_bell();
|
|
goto got3;
|
|
|
|
case 'C':
|
|
gotoxy(min(g_srScrollRegion.Right, g_coord.X + 1) + 1,
|
|
g_coord.Y + 1);
|
|
goto got3;
|
|
|
|
case 'E':
|
|
termcap_mode_end();
|
|
goto got3;
|
|
|
|
case 'F':
|
|
standout();
|
|
goto got3;
|
|
|
|
case 'f':
|
|
standend();
|
|
goto got3;
|
|
|
|
case 'H':
|
|
gotoxy(1, 1);
|
|
goto got3;
|
|
|
|
case 'j':
|
|
clear_to_end_of_display();
|
|
goto got3;
|
|
|
|
case 'J':
|
|
clear_screen();
|
|
goto got3;
|
|
|
|
case 'K':
|
|
clear_to_end_of_line();
|
|
goto got3;
|
|
|
|
case 'L':
|
|
insert_lines(1);
|
|
goto got3;
|
|
|
|
case 'M':
|
|
delete_lines(1);
|
|
goto got3;
|
|
|
|
case 'S':
|
|
termcap_mode_start();
|
|
goto got3;
|
|
|
|
case 'V':
|
|
cursor_visible(TRUE);
|
|
goto got3;
|
|
|
|
case 'v':
|
|
cursor_visible(FALSE);
|
|
goto got3;
|
|
|
|
got3:
|
|
s += 3;
|
|
len -= 2;
|
|
}
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fputs("ESC | ", fdDump);
|
|
fwrite(old_s + 2, sizeof(char_u), s - old_s - 2, fdDump);
|
|
fputc('\n', fdDump);
|
|
}
|
|
# endif
|
|
}
|
|
else if (s[0] == ESC && len >= 3-1 && s[1] == '[')
|
|
{
|
|
int l = 2;
|
|
|
|
if (SAFE_isdigit(s[l]))
|
|
l++;
|
|
if (s[l] == ' ' && s[l + 1] == 'q')
|
|
{
|
|
// DECSCUSR (cursor style) sequences
|
|
if (vtp_working)
|
|
vtp_printf("%.*s", l + 2, s); // Pass through
|
|
s += l + 2;
|
|
len -= l + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Write a single character
|
|
DWORD nWritten;
|
|
|
|
nWritten = write_chars(s, 1);
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
{
|
|
fputc('>', fdDump);
|
|
fwrite(s, sizeof(char_u), nWritten, fdDump);
|
|
fputs("<\n", fdDump);
|
|
}
|
|
# endif
|
|
|
|
len -= (nWritten - 1);
|
|
s += nWritten;
|
|
}
|
|
}
|
|
|
|
# ifdef MCH_WRITE_DUMP
|
|
if (fdDump)
|
|
fflush(fdDump);
|
|
# endif
|
|
}
|
|
|
|
#endif // FEAT_GUI_MSWIN
|
|
|
|
|
|
/*
|
|
* Delay for "msec" milliseconds.
|
|
*/
|
|
void
|
|
mch_delay(
|
|
long msec,
|
|
int flags UNUSED)
|
|
{
|
|
#if defined(FEAT_GUI_MSWIN) && !defined(VIMDLL)
|
|
Sleep((int)msec); // never wait for input
|
|
#else // Console
|
|
# ifdef VIMDLL
|
|
if (gui.in_use)
|
|
{
|
|
Sleep((int)msec); // never wait for input
|
|
return;
|
|
}
|
|
# endif
|
|
if (flags & MCH_DELAY_IGNOREINPUT)
|
|
# ifdef FEAT_MZSCHEME
|
|
if (mzthreads_allowed() && p_mzq > 0 && msec > p_mzq)
|
|
{
|
|
int towait = p_mzq;
|
|
|
|
// if msec is large enough, wait by portions in p_mzq
|
|
while (msec > 0)
|
|
{
|
|
mzvim_check_threads();
|
|
if (msec < towait)
|
|
towait = msec;
|
|
Sleep(towait);
|
|
msec -= towait;
|
|
}
|
|
}
|
|
else
|
|
# endif
|
|
Sleep((int)msec);
|
|
else
|
|
WaitForChar(msec, FALSE);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* This version of remove is not scared by a readonly (backup) file.
|
|
* This can also remove a symbolic link like Unix.
|
|
* Return 0 for success, -1 for failure.
|
|
*/
|
|
int
|
|
mch_remove(char_u *name)
|
|
{
|
|
WCHAR *wn;
|
|
int n;
|
|
|
|
/*
|
|
* On Windows, deleting a directory's symbolic link is done by
|
|
* RemoveDirectory(): mch_rmdir. It seems unnatural, but it is fact.
|
|
*/
|
|
if (mch_isdir(name) && mch_is_symbolic_link(name))
|
|
return mch_rmdir(name);
|
|
|
|
win32_setattrs(name, FILE_ATTRIBUTE_NORMAL);
|
|
|
|
wn = enc_to_utf16(name, NULL);
|
|
if (wn == NULL)
|
|
return -1;
|
|
|
|
n = DeleteFileW(wn) ? 0 : -1;
|
|
vim_free(wn);
|
|
return n;
|
|
}
|
|
|
|
|
|
/*
|
|
* Check for an "interrupt signal": CTRL-break or CTRL-C.
|
|
*/
|
|
void
|
|
mch_breakcheck(int force UNUSED)
|
|
{
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
# ifdef VIMDLL
|
|
if (!gui.in_use)
|
|
# endif
|
|
if (g_fCtrlCPressed || g_fCBrkPressed)
|
|
{
|
|
ctrl_break_was_pressed = g_fCBrkPressed;
|
|
g_fCtrlCPressed = g_fCBrkPressed = FALSE;
|
|
got_int = TRUE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// physical RAM to leave for the OS
|
|
#define WINNT_RESERVE_BYTES (256*1024*1024)
|
|
|
|
/*
|
|
* How much main memory in KiB that can be used by VIM.
|
|
*/
|
|
long_u
|
|
mch_total_mem(int special UNUSED)
|
|
{
|
|
MEMORYSTATUSEX ms;
|
|
|
|
// Need to use GlobalMemoryStatusEx() when there is more memory than
|
|
// what fits in 32 bits.
|
|
ms.dwLength = sizeof(MEMORYSTATUSEX);
|
|
GlobalMemoryStatusEx(&ms);
|
|
if (ms.ullAvailVirtual < ms.ullTotalPhys)
|
|
{
|
|
// Process address space fits in physical RAM, use all of it.
|
|
return (long_u)(ms.ullAvailVirtual / 1024);
|
|
}
|
|
if (ms.ullTotalPhys <= WINNT_RESERVE_BYTES)
|
|
{
|
|
// Catch old NT box or perverse hardware setup.
|
|
return (long_u)((ms.ullTotalPhys / 2) / 1024);
|
|
}
|
|
// Use physical RAM less reserve for OS + data.
|
|
return (long_u)((ms.ullTotalPhys - WINNT_RESERVE_BYTES) / 1024);
|
|
}
|
|
|
|
/*
|
|
* mch_wrename() works around a bug in rename (aka MoveFile) in
|
|
* Windows, the bug can be demonstrated with the following scenario:
|
|
* When renaming "abcdef~1.txt" to "abcdef~1.txt~", the short name can be
|
|
* "abcdef~1.txt" again.
|
|
*
|
|
* Like rename(), returns 0 upon success, non-zero upon failure.
|
|
* Should probably set errno appropriately when errors occur.
|
|
*/
|
|
int
|
|
mch_wrename(WCHAR *wold, WCHAR *wnew)
|
|
{
|
|
WCHAR *p;
|
|
int i;
|
|
WCHAR szTempFile[_MAX_PATH + 1];
|
|
WCHAR szNewPath[_MAX_PATH + 1];
|
|
HANDLE hf;
|
|
|
|
// No need to play tricks unless the file name contains a "~" as the
|
|
// seventh character.
|
|
p = wold;
|
|
for (i = 0; wold[i] != NUL; ++i)
|
|
if ((wold[i] == '/' || wold[i] == '\\' || wold[i] == ':')
|
|
&& wold[i + 1] != 0)
|
|
p = wold + i + 1;
|
|
if ((int)(wold + i - p) < 8 || p[6] != '~')
|
|
return (MoveFileW(wold, wnew) == 0);
|
|
|
|
// Get base path of new file name. Undocumented feature: If pszNewFile is
|
|
// a directory, no error is returned and pszFilePart will be NULL.
|
|
if (GetFullPathNameW(wnew, _MAX_PATH, szNewPath, &p) == 0 || p == NULL)
|
|
return -1;
|
|
*p = NUL;
|
|
|
|
// Get (and create) a unique temporary file name in directory of new file
|
|
if (GetTempFileNameW(szNewPath, L"VIM", 0, szTempFile) == 0)
|
|
return -2;
|
|
|
|
// blow the temp file away
|
|
if (!DeleteFileW(szTempFile))
|
|
return -3;
|
|
|
|
// rename old file to the temp file
|
|
if (!MoveFileW(wold, szTempFile))
|
|
return -4;
|
|
|
|
// now create an empty file called pszOldFile; this prevents the operating
|
|
// system using pszOldFile as an alias (SFN) if we're renaming within the
|
|
// same directory. For example, we're editing a file called
|
|
// filename.asc.txt by its SFN, filena~1.txt. If we rename filena~1.txt
|
|
// to filena~1.txt~ (i.e., we're making a backup while writing it), the
|
|
// SFN for filena~1.txt~ will be filena~1.txt, by default, which will
|
|
// cause all sorts of problems later in buf_write(). So, we create an
|
|
// empty file called filena~1.txt and the system will have to find some
|
|
// other SFN for filena~1.txt~, such as filena~2.txt
|
|
if ((hf = CreateFileW(wold, GENERIC_WRITE, 0, NULL, CREATE_NEW,
|
|
FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
|
|
return -5;
|
|
if (!CloseHandle(hf))
|
|
return -6;
|
|
|
|
// rename the temp file to the new file
|
|
if (!MoveFileW(szTempFile, wnew))
|
|
{
|
|
// Renaming failed. Rename the file back to its old name, so that it
|
|
// looks like nothing happened.
|
|
(void)MoveFileW(szTempFile, wold);
|
|
return -7;
|
|
}
|
|
|
|
// Seems to be left around on Novell filesystems
|
|
DeleteFileW(szTempFile);
|
|
|
|
// finally, remove the empty old file
|
|
if (!DeleteFileW(wold))
|
|
return -8;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Converts the filenames to UTF-16, then call mch_wrename().
|
|
* Like rename(), returns 0 upon success, non-zero upon failure.
|
|
*/
|
|
int
|
|
mch_rename(
|
|
const char *pszOldFile,
|
|
const char *pszNewFile)
|
|
{
|
|
WCHAR *wold = NULL;
|
|
WCHAR *wnew = NULL;
|
|
int retval = -1;
|
|
|
|
wold = enc_to_utf16((char_u *)pszOldFile, NULL);
|
|
wnew = enc_to_utf16((char_u *)pszNewFile, NULL);
|
|
if (wold != NULL && wnew != NULL)
|
|
retval = mch_wrename(wold, wnew);
|
|
vim_free(wold);
|
|
vim_free(wnew);
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* Get the default shell for the current hardware platform
|
|
*/
|
|
char *
|
|
default_shell(void)
|
|
{
|
|
return "cmd.exe";
|
|
}
|
|
|
|
/*
|
|
* mch_access() extends access() to do more detailed check on network drives.
|
|
* Returns 0 if file "n" has access rights according to "p", -1 otherwise.
|
|
*/
|
|
int
|
|
mch_access(char *n, int p)
|
|
{
|
|
HANDLE hFile;
|
|
int retval = -1; // default: fail
|
|
WCHAR *wn;
|
|
|
|
wn = enc_to_utf16((char_u *)n, NULL);
|
|
if (wn == NULL)
|
|
return -1;
|
|
|
|
if (mch_isdir((char_u *)n))
|
|
{
|
|
WCHAR TempNameW[_MAX_PATH + 16] = L"";
|
|
|
|
if (p & R_OK)
|
|
{
|
|
// Read check is performed by seeing if we can do a find file on
|
|
// the directory for any file.
|
|
int i;
|
|
WIN32_FIND_DATAW d;
|
|
|
|
for (i = 0; i < _MAX_PATH && wn[i] != 0; ++i)
|
|
TempNameW[i] = wn[i];
|
|
if (TempNameW[i - 1] != '\\' && TempNameW[i - 1] != '/')
|
|
TempNameW[i++] = '\\';
|
|
TempNameW[i++] = '*';
|
|
TempNameW[i++] = 0;
|
|
|
|
hFile = FindFirstFileW(TempNameW, &d);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
goto getout;
|
|
else
|
|
(void)FindClose(hFile);
|
|
}
|
|
|
|
if (p & W_OK)
|
|
{
|
|
// Trying to create a temporary file in the directory should catch
|
|
// directories on read-only network shares. However, in
|
|
// directories whose ACL allows writes but denies deletes will end
|
|
// up keeping the temporary file :-(.
|
|
if (!GetTempFileNameW(wn, L"VIM", 0, TempNameW))
|
|
goto getout;
|
|
else
|
|
DeleteFileW(TempNameW);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Don't consider a file read-only if another process has opened it.
|
|
DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
|
|
|
|
// Trying to open the file for the required access does ACL, read-only
|
|
// network share, and file attribute checks.
|
|
DWORD access_mode = ((p & W_OK) ? GENERIC_WRITE : 0)
|
|
| ((p & R_OK) ? GENERIC_READ : 0);
|
|
|
|
hFile = CreateFileW(wn, access_mode, share_mode,
|
|
NULL, OPEN_EXISTING, 0, NULL);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
goto getout;
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
retval = 0; // success
|
|
getout:
|
|
vim_free(wn);
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* Version of open() that may use UTF-16 file name.
|
|
*/
|
|
int
|
|
mch_open(const char *name, int flags, int mode)
|
|
{
|
|
WCHAR *wn;
|
|
int f;
|
|
|
|
wn = enc_to_utf16((char_u *)name, NULL);
|
|
if (wn == NULL)
|
|
return -1;
|
|
|
|
f = _wopen(wn, flags, mode);
|
|
vim_free(wn);
|
|
return f;
|
|
}
|
|
|
|
/*
|
|
* Version of fopen() that uses UTF-16 file name.
|
|
*/
|
|
FILE *
|
|
mch_fopen(const char *name, const char *mode)
|
|
{
|
|
WCHAR *wn, *wm;
|
|
FILE *f = NULL;
|
|
|
|
#if defined(DEBUG) && _MSC_VER >= 1400
|
|
// Work around an annoying assertion in the Microsoft debug CRT
|
|
// when mode's text/binary setting doesn't match _get_fmode().
|
|
char newMode = mode[strlen(mode) - 1];
|
|
int oldMode = 0;
|
|
|
|
_get_fmode(&oldMode);
|
|
if (newMode == 't')
|
|
_set_fmode(_O_TEXT);
|
|
else if (newMode == 'b')
|
|
_set_fmode(_O_BINARY);
|
|
#endif
|
|
wn = enc_to_utf16((char_u *)name, NULL);
|
|
wm = enc_to_utf16((char_u *)mode, NULL);
|
|
if (wn != NULL && wm != NULL)
|
|
f = _wfopen(wn, wm);
|
|
vim_free(wn);
|
|
vim_free(wm);
|
|
|
|
#if defined(DEBUG) && _MSC_VER >= 1400
|
|
_set_fmode(oldMode);
|
|
#endif
|
|
return f;
|
|
}
|
|
|
|
/*
|
|
* SUB STREAM (aka info stream) handling:
|
|
*
|
|
* NTFS can have sub streams for each file. The normal contents of a file is
|
|
* stored in the main stream, and extra contents (author information, title and
|
|
* so on) can be stored in a sub stream. After Windows 2000, the user can
|
|
* access and store this information in sub streams via an explorer's property
|
|
* menu item in the right click menu. This information in sub streams was lost
|
|
* when copying only the main stream. Therefore we have to copy sub streams.
|
|
*
|
|
* Incomplete explanation:
|
|
* http://msdn.microsoft.com/library/en-us/dnw2k/html/ntfs5.asp
|
|
* More useful info and an example:
|
|
* http://www.sysinternals.com/ntw2k/source/misc.shtml#streams
|
|
*/
|
|
|
|
/*
|
|
* Copy info stream data "substream". Read from the file with BackupRead(sh)
|
|
* and write to stream "substream" of file "to".
|
|
* Errors are ignored.
|
|
*/
|
|
static void
|
|
copy_substream(HANDLE sh, void *context, WCHAR *to, WCHAR *substream, long len)
|
|
{
|
|
HANDLE hTo;
|
|
WCHAR *to_name;
|
|
|
|
to_name = malloc((wcslen(to) + wcslen(substream) + 1) * sizeof(WCHAR));
|
|
wcscpy(to_name, to);
|
|
wcscat(to_name, substream);
|
|
|
|
hTo = CreateFileW(to_name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hTo != INVALID_HANDLE_VALUE)
|
|
{
|
|
long done;
|
|
DWORD todo;
|
|
DWORD readcnt, written;
|
|
char buf[4096];
|
|
|
|
// Copy block of bytes at a time. Abort when something goes wrong.
|
|
for (done = 0; done < len; done += written)
|
|
{
|
|
// (size_t) cast for Borland C 5.5
|
|
todo = (DWORD)((size_t)(len - done) > sizeof(buf) ? sizeof(buf)
|
|
: (size_t)(len - done));
|
|
if (!BackupRead(sh, (LPBYTE)buf, todo, &readcnt,
|
|
FALSE, FALSE, context)
|
|
|| readcnt != todo
|
|
|| !WriteFile(hTo, buf, todo, &written, NULL)
|
|
|| written != todo)
|
|
break;
|
|
}
|
|
CloseHandle(hTo);
|
|
}
|
|
|
|
free(to_name);
|
|
}
|
|
|
|
/*
|
|
* Copy info streams from file "from" to file "to".
|
|
*/
|
|
static void
|
|
copy_infostreams(char_u *from, char_u *to)
|
|
{
|
|
WCHAR *fromw;
|
|
WCHAR *tow;
|
|
HANDLE sh;
|
|
WIN32_STREAM_ID sid;
|
|
int headersize;
|
|
WCHAR streamname[_MAX_PATH];
|
|
DWORD readcount;
|
|
void *context = NULL;
|
|
DWORD lo, hi;
|
|
int len;
|
|
|
|
// Convert the file names to wide characters.
|
|
fromw = enc_to_utf16(from, NULL);
|
|
tow = enc_to_utf16(to, NULL);
|
|
if (fromw != NULL && tow != NULL)
|
|
{
|
|
// Open the file for reading.
|
|
sh = CreateFileW(fromw, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
|
|
if (sh != INVALID_HANDLE_VALUE)
|
|
{
|
|
// Use BackupRead() to find the info streams. Repeat until we
|
|
// have done them all.
|
|
for (;;)
|
|
{
|
|
// Get the header to find the length of the stream name. If
|
|
// the "readcount" is zero we have done all info streams.
|
|
ZeroMemory(&sid, sizeof(WIN32_STREAM_ID));
|
|
headersize = (int)((char *)&sid.cStreamName - (char *)&sid.dwStreamId);
|
|
if (!BackupRead(sh, (LPBYTE)&sid, headersize,
|
|
&readcount, FALSE, FALSE, &context)
|
|
|| readcount == 0)
|
|
break;
|
|
|
|
// We only deal with streams that have a name. The normal
|
|
// file data appears to be without a name, even though docs
|
|
// suggest it is called "::$DATA".
|
|
if (sid.dwStreamNameSize > 0)
|
|
{
|
|
// Read the stream name.
|
|
if (!BackupRead(sh, (LPBYTE)streamname,
|
|
sid.dwStreamNameSize,
|
|
&readcount, FALSE, FALSE, &context))
|
|
break;
|
|
|
|
// Copy an info stream with a name ":anything:$DATA".
|
|
// Skip "::$DATA", it has no stream name (examples suggest
|
|
// it might be used for the normal file contents).
|
|
// Note that BackupRead() counts bytes, but the name is in
|
|
// wide characters.
|
|
len = readcount / sizeof(WCHAR);
|
|
streamname[len] = 0;
|
|
if (len > 7 && wcsicmp(streamname + len - 6,
|
|
L":$DATA") == 0)
|
|
{
|
|
streamname[len - 6] = 0;
|
|
copy_substream(sh, &context, tow, streamname,
|
|
(long)sid.Size.u.LowPart);
|
|
}
|
|
}
|
|
|
|
// Advance to the next stream. We might try seeking too far,
|
|
// but BackupSeek() doesn't skip over stream borders, thus
|
|
// that's OK.
|
|
(void)BackupSeek(sh, sid.Size.u.LowPart, sid.Size.u.HighPart,
|
|
&lo, &hi, &context);
|
|
}
|
|
|
|
// Clear the context.
|
|
(void)BackupRead(sh, NULL, 0, &readcount, TRUE, FALSE, &context);
|
|
|
|
CloseHandle(sh);
|
|
}
|
|
}
|
|
vim_free(fromw);
|
|
vim_free(tow);
|
|
}
|
|
|
|
/*
|
|
* ntdll.dll definitions
|
|
*/
|
|
#define FileEaInformation 7
|
|
#ifndef STATUS_SUCCESS
|
|
# define STATUS_SUCCESS ((NTSTATUS) 0x00000000L)
|
|
#endif
|
|
|
|
typedef struct _FILE_FULL_EA_INFORMATION_ {
|
|
ULONG NextEntryOffset;
|
|
UCHAR Flags;
|
|
UCHAR EaNameLength;
|
|
USHORT EaValueLength;
|
|
CHAR EaName[1];
|
|
} FILE_FULL_EA_INFORMATION_, *PFILE_FULL_EA_INFORMATION_;
|
|
|
|
typedef struct _FILE_EA_INFORMATION_ {
|
|
ULONG EaSize;
|
|
} FILE_EA_INFORMATION_, *PFILE_EA_INFORMATION_;
|
|
|
|
#ifndef PROTO
|
|
typedef NTSTATUS (NTAPI *PfnNtOpenFile)(
|
|
PHANDLE FileHandle,
|
|
ACCESS_MASK DesiredAccess,
|
|
POBJECT_ATTRIBUTES ObjectAttributes,
|
|
PIO_STATUS_BLOCK IoStatusBlock,
|
|
ULONG ShareAccess,
|
|
ULONG OpenOptions);
|
|
typedef NTSTATUS (NTAPI *PfnNtClose)(
|
|
HANDLE Handle);
|
|
typedef NTSTATUS (NTAPI *PfnNtSetEaFile)(
|
|
HANDLE FileHandle,
|
|
PIO_STATUS_BLOCK IoStatusBlock,
|
|
PVOID Buffer,
|
|
ULONG Length);
|
|
typedef NTSTATUS (NTAPI *PfnNtQueryEaFile)(
|
|
HANDLE FileHandle,
|
|
PIO_STATUS_BLOCK IoStatusBlock,
|
|
PVOID Buffer,
|
|
ULONG Length,
|
|
BOOLEAN ReturnSingleEntry,
|
|
PVOID EaList,
|
|
ULONG EaListLength,
|
|
PULONG EaIndex,
|
|
BOOLEAN RestartScan);
|
|
typedef NTSTATUS (NTAPI *PfnNtQueryInformationFile)(
|
|
HANDLE FileHandle,
|
|
PIO_STATUS_BLOCK IoStatusBlock,
|
|
PVOID FileInformation,
|
|
ULONG Length,
|
|
FILE_INFORMATION_CLASS FileInformationClass);
|
|
typedef VOID (NTAPI *PfnRtlInitUnicodeString)(
|
|
PUNICODE_STRING DestinationString,
|
|
PCWSTR SourceString);
|
|
|
|
PfnNtOpenFile pNtOpenFile = NULL;
|
|
PfnNtClose pNtClose = NULL;
|
|
PfnNtSetEaFile pNtSetEaFile = NULL;
|
|
PfnNtQueryEaFile pNtQueryEaFile = NULL;
|
|
PfnNtQueryInformationFile pNtQueryInformationFile = NULL;
|
|
PfnRtlInitUnicodeString pRtlInitUnicodeString = NULL;
|
|
#endif
|
|
|
|
/*
|
|
* Load ntdll.dll functions.
|
|
*/
|
|
static BOOL
|
|
load_ntdll(void)
|
|
{
|
|
static int loaded = -1;
|
|
|
|
if (loaded != -1)
|
|
return (BOOL) loaded;
|
|
|
|
HMODULE hNtdll = GetModuleHandle("ntdll.dll");
|
|
if (hNtdll != NULL)
|
|
{
|
|
pNtOpenFile = (PfnNtOpenFile) GetProcAddress(hNtdll, "NtOpenFile");
|
|
pNtClose = (PfnNtClose) GetProcAddress(hNtdll, "NtClose");
|
|
pNtSetEaFile = (PfnNtSetEaFile)
|
|
GetProcAddress(hNtdll, "NtSetEaFile");
|
|
pNtQueryEaFile = (PfnNtQueryEaFile)
|
|
GetProcAddress(hNtdll, "NtQueryEaFile");
|
|
pNtQueryInformationFile = (PfnNtQueryInformationFile)
|
|
GetProcAddress(hNtdll, "NtQueryInformationFile");
|
|
pRtlInitUnicodeString = (PfnRtlInitUnicodeString)
|
|
GetProcAddress(hNtdll, "RtlInitUnicodeString");
|
|
}
|
|
if (pNtOpenFile == NULL
|
|
|| pNtClose == NULL
|
|
|| pNtSetEaFile == NULL
|
|
|| pNtQueryEaFile == NULL
|
|
|| pNtQueryInformationFile == NULL
|
|
|| pRtlInitUnicodeString == NULL)
|
|
loaded = FALSE;
|
|
else
|
|
loaded = TRUE;
|
|
return (BOOL) loaded;
|
|
}
|
|
|
|
/*
|
|
* Copy extended attributes (EA) from file "from" to file "to".
|
|
*/
|
|
static void
|
|
copy_extattr(char_u *from, char_u *to)
|
|
{
|
|
char_u *fromf = NULL;
|
|
char_u *tof = NULL;
|
|
WCHAR *fromw = NULL;
|
|
WCHAR *tow = NULL;
|
|
UNICODE_STRING u;
|
|
HANDLE h;
|
|
OBJECT_ATTRIBUTES oa;
|
|
IO_STATUS_BLOCK iosb;
|
|
FILE_EA_INFORMATION_ eainfo = {0};
|
|
void *ea = NULL;
|
|
|
|
if (!load_ntdll())
|
|
return;
|
|
|
|
// Convert the file names to the fully qualified object names.
|
|
fromf = alloc(STRLEN(from) + 5);
|
|
tof = alloc(STRLEN(to) + 5);
|
|
if (fromf == NULL || tof == NULL)
|
|
goto theend;
|
|
STRCPY(fromf, "\\??\\");
|
|
STRCAT(fromf, from);
|
|
STRCPY(tof, "\\??\\");
|
|
STRCAT(tof, to);
|
|
|
|
// Convert the names to wide characters.
|
|
fromw = enc_to_utf16(fromf, NULL);
|
|
tow = enc_to_utf16(tof, NULL);
|
|
if (fromw == NULL || tow == NULL)
|
|
goto theend;
|
|
|
|
// Get the EA.
|
|
pRtlInitUnicodeString(&u, fromw);
|
|
InitializeObjectAttributes(&oa, &u, 0, NULL, NULL);
|
|
if (pNtOpenFile(&h, FILE_READ_EA, &oa, &iosb, 0,
|
|
FILE_NON_DIRECTORY_FILE) != STATUS_SUCCESS)
|
|
goto theend;
|
|
pNtQueryInformationFile(h, &iosb, &eainfo, sizeof(eainfo),
|
|
FileEaInformation);
|
|
if (eainfo.EaSize != 0)
|
|
{
|
|
ea = alloc(eainfo.EaSize);
|
|
if (ea != NULL)
|
|
{
|
|
if (pNtQueryEaFile(h, &iosb, ea, eainfo.EaSize, FALSE,
|
|
NULL, 0, NULL, TRUE) != STATUS_SUCCESS)
|
|
{
|
|
VIM_CLEAR(ea);
|
|
}
|
|
}
|
|
}
|
|
pNtClose(h);
|
|
|
|
// Set the EA.
|
|
if (ea != NULL)
|
|
{
|
|
pRtlInitUnicodeString(&u, tow);
|
|
InitializeObjectAttributes(&oa, &u, 0, NULL, NULL);
|
|
if (pNtOpenFile(&h, FILE_WRITE_EA, &oa, &iosb, 0,
|
|
FILE_NON_DIRECTORY_FILE) != STATUS_SUCCESS)
|
|
goto theend;
|
|
|
|
pNtSetEaFile(h, &iosb, ea, eainfo.EaSize);
|
|
pNtClose(h);
|
|
}
|
|
|
|
theend:
|
|
vim_free(fromf);
|
|
vim_free(tof);
|
|
vim_free(fromw);
|
|
vim_free(tow);
|
|
vim_free(ea);
|
|
}
|
|
|
|
/*
|
|
* Copy file attributes from file "from" to file "to".
|
|
* For Windows NT and later we copy info streams.
|
|
* Always returns zero, errors are ignored.
|
|
*/
|
|
int
|
|
mch_copy_file_attribute(char_u *from, char_u *to)
|
|
{
|
|
// File streams only work on Windows NT and later.
|
|
copy_infostreams(from, to);
|
|
copy_extattr(from, to);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* The command line arguments in UTF-16
|
|
*/
|
|
static int nArgsW = 0;
|
|
static LPWSTR *ArglistW = NULL;
|
|
static int global_argc = 0;
|
|
static char **global_argv;
|
|
|
|
static int used_file_argc = 0; // last argument in global_argv[] used
|
|
// for the argument list.
|
|
static int *used_file_indexes = NULL; // indexes in global_argv[] for
|
|
// command line arguments added to
|
|
// the argument list
|
|
static int used_file_count = 0; // nr of entries in used_file_indexes
|
|
static int used_file_literal = FALSE; // take file names literally
|
|
static int used_file_full_path = FALSE; // file name was full path
|
|
static int used_file_diff_mode = FALSE; // file name was with diff mode
|
|
static int used_alist_count = 0;
|
|
|
|
|
|
/*
|
|
* Get the command line arguments. Unicode version.
|
|
* Returns argc. Zero when something fails.
|
|
*/
|
|
int
|
|
get_cmd_argsW(char ***argvp)
|
|
{
|
|
char **argv = NULL;
|
|
int argc = 0;
|
|
int i;
|
|
|
|
free_cmd_argsW();
|
|
ArglistW = CommandLineToArgvW(GetCommandLineW(), &nArgsW);
|
|
if (ArglistW != NULL)
|
|
{
|
|
argv = malloc((nArgsW + 1) * sizeof(char *));
|
|
if (argv != NULL)
|
|
{
|
|
argc = nArgsW;
|
|
argv[argc] = NULL;
|
|
for (i = 0; i < argc; ++i)
|
|
{
|
|
int len;
|
|
|
|
// Convert each Unicode argument to UTF-8.
|
|
WideCharToMultiByte_alloc(CP_UTF8, 0,
|
|
ArglistW[i], (int)wcslen(ArglistW[i]) + 1,
|
|
(LPSTR *)&argv[i], &len, 0, 0);
|
|
if (argv[i] == NULL)
|
|
{
|
|
// Out of memory, clear everything.
|
|
while (i > 0)
|
|
free(argv[--i]);
|
|
free(argv);
|
|
argv = NULL;
|
|
argc = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
global_argc = argc;
|
|
global_argv = argv;
|
|
if (argc > 0)
|
|
{
|
|
if (used_file_indexes != NULL)
|
|
free(used_file_indexes);
|
|
used_file_indexes = malloc(argc * sizeof(int));
|
|
}
|
|
|
|
if (argvp != NULL)
|
|
*argvp = argv;
|
|
return argc;
|
|
}
|
|
|
|
void
|
|
free_cmd_argsW(void)
|
|
{
|
|
if (ArglistW == NULL)
|
|
return;
|
|
|
|
GlobalFree(ArglistW);
|
|
ArglistW = NULL;
|
|
}
|
|
|
|
/*
|
|
* Remember "name" is an argument that was added to the argument list.
|
|
* This avoids that we have to re-parse the argument list when fix_arg_enc()
|
|
* is called.
|
|
*/
|
|
void
|
|
used_file_arg(char *name, int literal, int full_path, int diff_mode)
|
|
{
|
|
int i;
|
|
|
|
if (used_file_indexes == NULL)
|
|
return;
|
|
for (i = used_file_argc + 1; i < global_argc; ++i)
|
|
if (STRCMP(global_argv[i], name) == 0)
|
|
{
|
|
used_file_argc = i;
|
|
used_file_indexes[used_file_count++] = i;
|
|
break;
|
|
}
|
|
used_file_literal = literal;
|
|
used_file_full_path = full_path;
|
|
used_file_diff_mode = diff_mode;
|
|
}
|
|
|
|
/*
|
|
* Remember the length of the argument list as it was. If it changes then we
|
|
* leave it alone when 'encoding' is set.
|
|
*/
|
|
void
|
|
set_alist_count(void)
|
|
{
|
|
used_alist_count = GARGCOUNT;
|
|
}
|
|
|
|
/*
|
|
* Fix the encoding of the command line arguments. Invoked when 'encoding'
|
|
* has been changed while starting up. Use the UTF-16 command line arguments
|
|
* and convert them to 'encoding'.
|
|
*/
|
|
void
|
|
fix_arg_enc(void)
|
|
{
|
|
int i;
|
|
int idx;
|
|
char_u *str;
|
|
int *fnum_list;
|
|
|
|
// Safety checks:
|
|
// - if argument count differs between the wide and non-wide argument
|
|
// list, something must be wrong.
|
|
// - the file name arguments must have been located.
|
|
// - the length of the argument list wasn't changed by the user.
|
|
if (global_argc != nArgsW
|
|
|| ArglistW == NULL
|
|
|| used_file_indexes == NULL
|
|
|| used_file_count == 0
|
|
|| used_alist_count != GARGCOUNT)
|
|
return;
|
|
|
|
// Remember the buffer numbers for the arguments.
|
|
fnum_list = ALLOC_MULT(int, GARGCOUNT);
|
|
if (fnum_list == NULL)
|
|
return; // out of memory
|
|
for (i = 0; i < GARGCOUNT; ++i)
|
|
fnum_list[i] = GARGLIST[i].ae_fnum;
|
|
|
|
// Clear the argument list. Make room for the new arguments.
|
|
alist_clear(&global_alist);
|
|
if (ga_grow(&global_alist.al_ga, used_file_count) == FAIL)
|
|
return; // out of memory
|
|
|
|
for (i = 0; i < used_file_count; ++i)
|
|
{
|
|
idx = used_file_indexes[i];
|
|
str = utf16_to_enc(ArglistW[idx], NULL);
|
|
if (str != NULL)
|
|
{
|
|
int literal = used_file_literal;
|
|
|
|
#ifdef FEAT_DIFF
|
|
// When using diff mode may need to concatenate file name to
|
|
// directory name. Just like it's done in main().
|
|
if (used_file_diff_mode && mch_isdir(str) && GARGCOUNT > 0
|
|
&& !mch_isdir(alist_name(&GARGLIST[0])))
|
|
{
|
|
char_u *r;
|
|
|
|
r = concat_fnames(str, gettail(alist_name(&GARGLIST[0])), TRUE);
|
|
if (r != NULL)
|
|
{
|
|
vim_free(str);
|
|
str = r;
|
|
}
|
|
}
|
|
#endif
|
|
// Re-use the old buffer by renaming it. When not using literal
|
|
// names it's done by alist_expand() below.
|
|
if (used_file_literal)
|
|
buf_set_name(fnum_list[i], str);
|
|
|
|
// Check backtick literal. backtick literal is already expanded in
|
|
// main.c, so this part add str as literal.
|
|
if (literal == FALSE)
|
|
{
|
|
size_t len = STRLEN(str);
|
|
|
|
if (len > 2 && *str == '`' && *(str + len - 1) == '`')
|
|
literal = TRUE;
|
|
}
|
|
alist_add(&global_alist, str, literal ? 2 : 0);
|
|
}
|
|
}
|
|
|
|
if (!used_file_literal)
|
|
{
|
|
// Now expand wildcards in the arguments.
|
|
// Temporarily add '(' and ')' to 'isfname'. These are valid
|
|
// filename characters but are excluded from 'isfname' to make
|
|
// "gf" work on a file name in parentheses (e.g.: see vim.h).
|
|
// Also, unset wildignore to not be influenced by this option.
|
|
// The arguments specified in command-line should be kept even if
|
|
// encoding options were changed.
|
|
// Use :legacy so that it also works when in Vim9 script.
|
|
do_cmdline_cmd((char_u *)":legacy let g:SaVe_ISF = &isf|set isf+=(,)");
|
|
do_cmdline_cmd((char_u *)":legacy let g:SaVe_WIG = &wig|set wig=");
|
|
alist_expand(fnum_list, used_alist_count);
|
|
do_cmdline_cmd(
|
|
(char_u *)":legacy let &isf = g:SaVe_ISF|unlet g:SaVe_ISF");
|
|
do_cmdline_cmd(
|
|
(char_u *)":legacy let &wig = g:SaVe_WIG|unlet g:SaVe_WIG");
|
|
}
|
|
|
|
// If wildcard expansion failed, we are editing the first file of the
|
|
// arglist and there is no file name: Edit the first argument now.
|
|
if (curwin->w_arg_idx == 0 && curbuf->b_fname == NULL)
|
|
{
|
|
do_cmdline_cmd((char_u *)":rewind");
|
|
if (GARGCOUNT == 1 && used_file_full_path
|
|
&& vim_chdirfile(alist_name(&GARGLIST[0]), "drop") == OK)
|
|
last_chdir_reason = "drop";
|
|
}
|
|
|
|
set_alist_count();
|
|
}
|
|
|
|
int
|
|
mch_setenv(char *var, char *value, int x UNUSED)
|
|
{
|
|
char_u *envbuf;
|
|
WCHAR *p;
|
|
|
|
envbuf = alloc(STRLEN(var) + STRLEN(value) + 2);
|
|
if (envbuf == NULL)
|
|
return -1;
|
|
|
|
sprintf((char *)envbuf, "%s=%s", var, value);
|
|
|
|
p = enc_to_utf16(envbuf, NULL);
|
|
|
|
vim_free(envbuf);
|
|
if (p == NULL)
|
|
return -1;
|
|
_wputenv(p);
|
|
#ifdef libintl_wputenv
|
|
libintl_wputenv(p);
|
|
#endif
|
|
// Unlike Un*x systems, we can free the string for _wputenv().
|
|
vim_free(p);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Support for 256 colors and 24-bit colors was added in Windows 10
|
|
* version 1703 (Creators update).
|
|
*/
|
|
#define VTP_FIRST_SUPPORT_BUILD MAKE_VER(10, 0, 15063)
|
|
|
|
/*
|
|
* Support for pseudo-console (ConPTY) was added in windows 10
|
|
* version 1809 (October 2018 update).
|
|
*/
|
|
#define CONPTY_FIRST_SUPPORT_BUILD MAKE_VER(10, 0, 17763)
|
|
|
|
/*
|
|
* ConPTY differences between versions, need different logic.
|
|
* version 1903 (May 2019 update).
|
|
*/
|
|
#define CONPTY_1903_BUILD MAKE_VER(10, 0, 18362)
|
|
|
|
/*
|
|
* version 1909 (November 2019 update).
|
|
*/
|
|
#define CONPTY_1909_BUILD MAKE_VER(10, 0, 18363)
|
|
|
|
/*
|
|
* Stay ahead of the next update, and when it's done, fix this.
|
|
* version ? (2020 update, temporarily use the build number of insider preview)
|
|
*/
|
|
#define CONPTY_NEXT_UPDATE_BUILD MAKE_VER(10, 0, 19587)
|
|
|
|
/*
|
|
* Confirm until this version. Also the logic changes.
|
|
* insider preview.
|
|
*/
|
|
#define CONPTY_INSIDER_BUILD MAKE_VER(10, 0, 18995)
|
|
|
|
/*
|
|
* Not stable now.
|
|
*/
|
|
#define CONPTY_STABLE_BUILD MAKE_VER(10, 0, 32767) // T.B.D.
|
|
// Notes:
|
|
// Win 10 22H2 Final is build 19045, it's conpty is widely used.
|
|
// Strangely, 19045 is newer but is a lower build number than the 2020 insider
|
|
// preview which had a build 19587. And, not sure how stable that was?
|
|
// Win Server 2022 (May 10, 2022) is build 20348, its conpty is widely used.
|
|
// Win 11 starts from build 22000, even though the major version says 10!
|
|
|
|
static void
|
|
vtp_flag_init(void)
|
|
{
|
|
DWORD ver = get_build_number();
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL)
|
|
DWORD mode;
|
|
HANDLE out;
|
|
|
|
# ifdef VIMDLL
|
|
if (!gui.in_use)
|
|
# endif
|
|
{
|
|
out = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
vtp_working = (ver >= VTP_FIRST_SUPPORT_BUILD) ? 1 : 0;
|
|
GetConsoleMode(out, &mode);
|
|
mode |= (ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
|
|
if (SetConsoleMode(out, mode) == 0)
|
|
vtp_working = 0;
|
|
|
|
// VTP uses alternate screen buffer.
|
|
// But, not if running in a nested terminal
|
|
use_alternate_screen_buffer = win10_22H2_or_later && p_rs && vtp_working
|
|
&& !mch_getenv("VIM_TERMINAL");
|
|
}
|
|
#endif
|
|
|
|
if (ver >= CONPTY_FIRST_SUPPORT_BUILD)
|
|
conpty_working = 1;
|
|
if (ver >= CONPTY_STABLE_BUILD)
|
|
conpty_stable = 1;
|
|
|
|
if (ver <= CONPTY_INSIDER_BUILD)
|
|
conpty_type = 3;
|
|
if (ver <= CONPTY_1909_BUILD)
|
|
conpty_type = 2;
|
|
if (ver <= CONPTY_1903_BUILD)
|
|
conpty_type = 2;
|
|
if (ver < CONPTY_FIRST_SUPPORT_BUILD)
|
|
conpty_type = 1;
|
|
|
|
if (ver >= CONPTY_NEXT_UPDATE_BUILD)
|
|
conpty_fix_type = 1;
|
|
}
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL) || defined(PROTO)
|
|
|
|
static void
|
|
vtp_init(void)
|
|
{
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
CONSOLE_SCREEN_BUFFER_INFOEX csbi;
|
|
csbi.cbSize = sizeof(csbi);
|
|
GetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
save_console_bg_rgb = (guicolor_T)csbi.ColorTable[g_color_index_bg];
|
|
save_console_fg_rgb = (guicolor_T)csbi.ColorTable[g_color_index_fg];
|
|
store_console_bg_rgb = save_console_bg_rgb;
|
|
store_console_fg_rgb = save_console_fg_rgb;
|
|
|
|
COLORREF bg;
|
|
bg = (COLORREF)csbi.ColorTable[g_color_index_bg];
|
|
bg = (GetRValue(bg) << 16) | (GetGValue(bg) << 8) | GetBValue(bg);
|
|
default_console_color_bg = bg;
|
|
|
|
COLORREF fg;
|
|
fg = (COLORREF)csbi.ColorTable[g_color_index_fg];
|
|
fg = (GetRValue(fg) << 16) | (GetGValue(fg) << 8) | GetBValue(fg);
|
|
default_console_color_fg = fg;
|
|
# endif
|
|
set_console_color_rgb();
|
|
}
|
|
|
|
static void
|
|
vtp_exit(void)
|
|
{
|
|
restore_console_color_rgb();
|
|
}
|
|
|
|
int
|
|
vtp_printf(
|
|
char *format,
|
|
...)
|
|
{
|
|
char_u buf[100];
|
|
va_list list;
|
|
DWORD result;
|
|
int len;
|
|
|
|
if (silent_mode)
|
|
return 0;
|
|
|
|
va_start(list, format);
|
|
len = vim_vsnprintf((char *)buf, 100, (char *)format, list);
|
|
va_end(list);
|
|
WriteConsoleA(g_hConOut, buf, (DWORD)len, &result, NULL);
|
|
return (int)result;
|
|
}
|
|
|
|
static void
|
|
vtp_sgr_bulk(
|
|
int arg)
|
|
{
|
|
int args[1];
|
|
|
|
args[0] = arg;
|
|
vtp_sgr_bulks(1, args);
|
|
}
|
|
|
|
# define FAST256(x) \
|
|
if ((*p-- = "0123456789"[(n = x % 10)]) \
|
|
&& x >= 10 && (*p-- = "0123456789"[((m = x % 100) - n) / 10]) \
|
|
&& x >= 100 && (*p-- = "012"[((x & 0xff) - m) / 100]));
|
|
|
|
# define FAST256CASE(x) \
|
|
case x: \
|
|
FAST256(newargs[x - 1]);
|
|
|
|
static void
|
|
vtp_sgr_bulks(
|
|
int argc,
|
|
int *args)
|
|
{
|
|
# define MAXSGR 16
|
|
# define SGRBUFSIZE 2 + 4 * MAXSGR + 1 // '\033[' + SGR + 'm'
|
|
char_u buf[SGRBUFSIZE];
|
|
char_u *p;
|
|
int in, out;
|
|
int newargs[16];
|
|
static int sgrfgr = -1, sgrfgg, sgrfgb;
|
|
static int sgrbgr = -1, sgrbgg, sgrbgb;
|
|
|
|
if (argc == 0)
|
|
{
|
|
sgrfgr = sgrbgr = -1;
|
|
vtp_printf("\033[m");
|
|
return;
|
|
}
|
|
|
|
in = out = 0;
|
|
while (in < argc)
|
|
{
|
|
int s = args[in];
|
|
int copylen = 1;
|
|
|
|
if (s == 38)
|
|
{
|
|
if (argc - in >= 5 && args[in + 1] == 2)
|
|
{
|
|
if (sgrfgr == args[in + 2] && sgrfgg == args[in + 3]
|
|
&& sgrfgb == args[in + 4])
|
|
{
|
|
in += 5;
|
|
copylen = 0;
|
|
}
|
|
else
|
|
{
|
|
sgrfgr = args[in + 2];
|
|
sgrfgg = args[in + 3];
|
|
sgrfgb = args[in + 4];
|
|
copylen = 5;
|
|
}
|
|
}
|
|
else if (argc - in >= 3 && args[in + 1] == 5)
|
|
{
|
|
sgrfgr = -1;
|
|
copylen = 3;
|
|
}
|
|
}
|
|
else if (s == 48)
|
|
{
|
|
if (argc - in >= 5 && args[in + 1] == 2)
|
|
{
|
|
if (sgrbgr == args[in + 2] && sgrbgg == args[in + 3]
|
|
&& sgrbgb == args[in + 4])
|
|
{
|
|
in += 5;
|
|
copylen = 0;
|
|
}
|
|
else
|
|
{
|
|
sgrbgr = args[in + 2];
|
|
sgrbgg = args[in + 3];
|
|
sgrbgb = args[in + 4];
|
|
copylen = 5;
|
|
}
|
|
}
|
|
else if (argc - in >= 3 && args[in + 1] == 5)
|
|
{
|
|
sgrbgr = -1;
|
|
copylen = 3;
|
|
}
|
|
}
|
|
else if (30 <= s && s <= 39)
|
|
sgrfgr = -1;
|
|
else if (90 <= s && s <= 97)
|
|
sgrfgr = -1;
|
|
else if (40 <= s && s <= 49)
|
|
sgrbgr = -1;
|
|
else if (100 <= s && s <= 107)
|
|
sgrbgr = -1;
|
|
else if (s == 0)
|
|
sgrfgr = sgrbgr = -1;
|
|
|
|
while (copylen--)
|
|
newargs[out++] = args[in++];
|
|
}
|
|
|
|
p = &buf[sizeof(buf) - 1];
|
|
*p-- = 'm';
|
|
|
|
switch (out)
|
|
{
|
|
int n, m;
|
|
DWORD r;
|
|
|
|
FAST256CASE(16);
|
|
*p-- = ';';
|
|
FAST256CASE(15);
|
|
*p-- = ';';
|
|
FAST256CASE(14);
|
|
*p-- = ';';
|
|
FAST256CASE(13);
|
|
*p-- = ';';
|
|
FAST256CASE(12);
|
|
*p-- = ';';
|
|
FAST256CASE(11);
|
|
*p-- = ';';
|
|
FAST256CASE(10);
|
|
*p-- = ';';
|
|
FAST256CASE(9);
|
|
*p-- = ';';
|
|
FAST256CASE(8);
|
|
*p-- = ';';
|
|
FAST256CASE(7);
|
|
*p-- = ';';
|
|
FAST256CASE(6);
|
|
*p-- = ';';
|
|
FAST256CASE(5);
|
|
*p-- = ';';
|
|
FAST256CASE(4);
|
|
*p-- = ';';
|
|
FAST256CASE(3);
|
|
*p-- = ';';
|
|
FAST256CASE(2);
|
|
*p-- = ';';
|
|
FAST256CASE(1);
|
|
*p-- = '[';
|
|
*p = '\033';
|
|
WriteConsoleA(g_hConOut, p, (DWORD)(&buf[SGRBUFSIZE] - p), &r, NULL);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
wt_init(void)
|
|
{
|
|
wt_working = mch_getenv("WT_SESSION") != NULL;
|
|
}
|
|
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
static int
|
|
ctermtoxterm(
|
|
int cterm)
|
|
{
|
|
char_u r, g, b, idx;
|
|
|
|
cterm_color2rgb(cterm, &r, &g, &b, &idx);
|
|
return (((int)r << 16) | ((int)g << 8) | (int)b);
|
|
}
|
|
# endif
|
|
|
|
static void
|
|
set_console_color_rgb(void)
|
|
{
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
CONSOLE_SCREEN_BUFFER_INFOEX csbi;
|
|
guicolor_T fg, bg;
|
|
int ctermfg, ctermbg;
|
|
|
|
if (!vtp_working)
|
|
return;
|
|
|
|
get_default_console_color(&ctermfg, &ctermbg, &fg, &bg);
|
|
|
|
if (p_tgc || t_colors >= 256)
|
|
{
|
|
term_fg_rgb_color(fg);
|
|
term_bg_rgb_color(bg);
|
|
return;
|
|
}
|
|
|
|
if (use_alternate_screen_buffer)
|
|
return;
|
|
|
|
fg = (GetRValue(fg) << 16) | (GetGValue(fg) << 8) | GetBValue(fg);
|
|
bg = (GetRValue(bg) << 16) | (GetGValue(bg) << 8) | GetBValue(bg);
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
GetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
csbi.srWindow.Right += 1;
|
|
csbi.srWindow.Bottom += 1;
|
|
store_console_bg_rgb = csbi.ColorTable[g_color_index_bg];
|
|
store_console_fg_rgb = csbi.ColorTable[g_color_index_fg];
|
|
csbi.ColorTable[g_color_index_bg] = (COLORREF)bg;
|
|
csbi.ColorTable[g_color_index_fg] = (COLORREF)fg;
|
|
SetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
# endif
|
|
}
|
|
|
|
# if defined(FEAT_TERMGUICOLORS) || defined(PROTO)
|
|
void
|
|
get_default_console_color(
|
|
int *cterm_fg,
|
|
int *cterm_bg,
|
|
guicolor_T *gui_fg,
|
|
guicolor_T *gui_bg)
|
|
{
|
|
int id;
|
|
guicolor_T guifg = INVALCOLOR;
|
|
guicolor_T guibg = INVALCOLOR;
|
|
int ctermfg = 0;
|
|
int ctermbg = 0;
|
|
int dummynull = 0;
|
|
|
|
id = syn_name2id((char_u *)"Normal");
|
|
if (id > 0 && p_tgc)
|
|
syn_id2colors(id, &guifg, &guibg);
|
|
if (guifg == INVALCOLOR)
|
|
{
|
|
ctermfg = -1;
|
|
if (id > 0)
|
|
syn_id2cterm_bg(id, &ctermfg, &dummynull);
|
|
if (ctermfg != -1)
|
|
guifg = ctermtoxterm(ctermfg);
|
|
else
|
|
guifg = USE_WT ? INVALCOLOR : default_console_color_fg;
|
|
cterm_normal_fg_gui_color = guifg;
|
|
ctermfg = ctermfg < 0 ? 0 : ctermfg;
|
|
}
|
|
if (guibg == INVALCOLOR)
|
|
{
|
|
ctermbg = -1;
|
|
if (id > 0)
|
|
syn_id2cterm_bg(id, &dummynull, &ctermbg);
|
|
if (ctermbg != -1)
|
|
guibg = ctermtoxterm(ctermbg);
|
|
else
|
|
guibg = USE_WT ? INVALCOLOR : default_console_color_bg;
|
|
cterm_normal_bg_gui_color = guibg;
|
|
ctermbg = ctermbg < 0 ? 0 : ctermbg;
|
|
}
|
|
|
|
*cterm_fg = ctermfg;
|
|
*cterm_bg = ctermbg;
|
|
*gui_fg = guifg;
|
|
*gui_bg = guibg;
|
|
}
|
|
# endif
|
|
|
|
/*
|
|
* Set the console colors to the original colors or the last set colors.
|
|
*/
|
|
static void
|
|
reset_console_color_rgb(void)
|
|
{
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
if (use_alternate_screen_buffer)
|
|
return;
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFOEX csbi;
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
GetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
csbi.srWindow.Right += 1;
|
|
csbi.srWindow.Bottom += 1;
|
|
csbi.ColorTable[g_color_index_bg] = (COLORREF)store_console_bg_rgb;
|
|
csbi.ColorTable[g_color_index_fg] = (COLORREF)store_console_fg_rgb;
|
|
SetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
# endif
|
|
}
|
|
|
|
/*
|
|
* Set the console colors to the original colors.
|
|
*/
|
|
static void
|
|
restore_console_color_rgb(void)
|
|
{
|
|
# ifdef FEAT_TERMGUICOLORS
|
|
if (use_alternate_screen_buffer)
|
|
return;
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFOEX csbi;
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
GetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
|
|
csbi.cbSize = sizeof(csbi);
|
|
csbi.srWindow.Right += 1;
|
|
csbi.srWindow.Bottom += 1;
|
|
csbi.ColorTable[g_color_index_bg] = (COLORREF)save_console_bg_rgb;
|
|
csbi.ColorTable[g_color_index_fg] = (COLORREF)save_console_fg_rgb;
|
|
SetConsoleScreenBufferInfoEx(g_hConOut, &csbi);
|
|
# endif
|
|
}
|
|
|
|
void
|
|
control_console_color_rgb(void)
|
|
{
|
|
if (vtp_working)
|
|
set_console_color_rgb();
|
|
else
|
|
reset_console_color_rgb();
|
|
}
|
|
|
|
int
|
|
use_vtp(void)
|
|
{
|
|
return USE_VTP;
|
|
}
|
|
|
|
int
|
|
is_term_win32(void)
|
|
{
|
|
return T_NAME != NULL && STRCMP(T_NAME, "win32") == 0;
|
|
}
|
|
|
|
int
|
|
has_vtp_working(void)
|
|
{
|
|
return vtp_working;
|
|
}
|
|
|
|
#endif
|
|
|
|
int
|
|
has_conpty_working(void)
|
|
{
|
|
return conpty_working;
|
|
}
|
|
|
|
int
|
|
get_conpty_type(void)
|
|
{
|
|
return conpty_type;
|
|
}
|
|
|
|
int
|
|
is_conpty_stable(void)
|
|
{
|
|
return conpty_stable;
|
|
}
|
|
|
|
int
|
|
get_conpty_fix_type(void)
|
|
{
|
|
return conpty_fix_type;
|
|
}
|
|
|
|
#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL) || defined(PROTO)
|
|
void
|
|
resize_console_buf(void)
|
|
{
|
|
if (use_alternate_screen_buffer)
|
|
return;
|
|
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
COORD coord;
|
|
SMALL_RECT newsize;
|
|
|
|
if (!GetConsoleScreenBufferInfo(g_hConOut, &csbi))
|
|
return;
|
|
|
|
coord.X = SRWIDTH(csbi.srWindow);
|
|
coord.Y = SRHEIGHT(csbi.srWindow);
|
|
SetConsoleScreenBufferSize(g_hConOut, coord);
|
|
|
|
newsize.Left = 0;
|
|
newsize.Top = 0;
|
|
newsize.Right = coord.X - 1;
|
|
newsize.Bottom = coord.Y - 1;
|
|
SetConsoleWindowInfo(g_hConOut, TRUE, &newsize);
|
|
|
|
SetConsoleScreenBufferSize(g_hConOut, coord);
|
|
}
|
|
#endif
|
|
|
|
char *
|
|
GetWin32Error(void)
|
|
{
|
|
static char *oldmsg = NULL;
|
|
char *msg = NULL;
|
|
|
|
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, GetLastError(), 0, (LPSTR)&msg, 0, NULL);
|
|
if (oldmsg != NULL)
|
|
LocalFree(oldmsg);
|
|
if (msg == NULL)
|
|
return NULL;
|
|
|
|
// remove trailing \r\n
|
|
char *pcrlf = strstr(msg, "\r\n");
|
|
if (pcrlf != NULL)
|
|
*pcrlf = '\0';
|
|
oldmsg = msg;
|
|
return msg;
|
|
}
|
|
|
|
#if defined(FEAT_RELTIME) || defined(PROTO)
|
|
static HANDLE timer_handle;
|
|
static int timer_active = FALSE;
|
|
|
|
/*
|
|
* Calls to start_timeout alternate the return value pointer between the two
|
|
* entries in timeout_flags. If the previously active timeout is very close to
|
|
* expiring when start_timeout() is called then a race condition means that the
|
|
* set_flag() function may still be invoked after the previous timer is
|
|
* deleted. Ping-ponging between the two flags prevents this causing 'fake'
|
|
* timeouts.
|
|
*/
|
|
static sig_atomic_t timeout_flags[2];
|
|
static int timeout_flag_idx = 0;
|
|
static sig_atomic_t *timeout_flag = &timeout_flags[0];
|
|
|
|
|
|
static void CALLBACK
|
|
set_flag(void *param, BOOLEAN unused2 UNUSED)
|
|
{
|
|
int *timeout_flag = (int *)param;
|
|
|
|
*timeout_flag = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Stop any active timeout.
|
|
*/
|
|
void
|
|
stop_timeout(void)
|
|
{
|
|
if (timer_active)
|
|
{
|
|
BOOL ret = DeleteTimerQueueTimer(NULL, timer_handle, NULL);
|
|
timer_active = FALSE;
|
|
if (!ret && GetLastError() != ERROR_IO_PENDING)
|
|
{
|
|
semsg(_(e_could_not_clear_timeout_str), GetWin32Error());
|
|
}
|
|
}
|
|
*timeout_flag = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Start the timeout timer.
|
|
*
|
|
* The period is defined in milliseconds.
|
|
*
|
|
* The return value is a pointer to a flag that is initialised to 0. If the
|
|
* timeout expires, the flag is set to 1. This will only return pointers to
|
|
* static memory; i.e. any pointer returned by this function may always be
|
|
* safely dereferenced.
|
|
*
|
|
* This function is not expected to fail, but if it does it still returns a
|
|
* valid flag pointer; the flag will remain stuck at zero.
|
|
*/
|
|
volatile sig_atomic_t *
|
|
start_timeout(long msec)
|
|
{
|
|
BOOL ret;
|
|
|
|
timeout_flag = &timeout_flags[timeout_flag_idx];
|
|
|
|
stop_timeout();
|
|
ret = CreateTimerQueueTimer(
|
|
&timer_handle, NULL, set_flag, timeout_flag,
|
|
(DWORD)msec, 0, WT_EXECUTEDEFAULT);
|
|
if (!ret)
|
|
{
|
|
semsg(_(e_could_not_set_timeout_str), GetWin32Error());
|
|
}
|
|
else
|
|
{
|
|
timeout_flag_idx = (timeout_flag_idx + 1) % 2;
|
|
timer_active = TRUE;
|
|
*timeout_flag = FALSE;
|
|
}
|
|
return timeout_flag;
|
|
}
|
|
#endif
|