[thirdparty/git.git] / compat / winansi.c

/*
 * Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
 */

#undef NOGDI
#include "../git-compat-util.h"
#include <wingdi.h>
#include <winreg.h>

/*
 ANSI codes used by git: m, K

 This file is git-specific. Therefore, this file does not attempt
 to implement any codes that are not used by git.
*/

static HANDLE console;
static WORD plain_attr;
static WORD attr;
static int negative;
static int non_ascii_used = 0;
static HANDLE hthread, hread, hwrite;
static HANDLE hconsole1, hconsole2;

#ifdef __MINGW32__
#if !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 5
typedef struct _CONSOLE_FONT_INFOEX {
	ULONG cbSize;
	DWORD nFont;
	COORD dwFontSize;
	UINT FontFamily;
	UINT FontWeight;
	WCHAR FaceName[LF_FACESIZE];
} CONSOLE_FONT_INFOEX, *PCONSOLE_FONT_INFOEX;
#endif
#endif

typedef BOOL (WINAPI *PGETCURRENTCONSOLEFONTEX)(HANDLE, BOOL,
		PCONSOLE_FONT_INFOEX);

static void warn_if_raster_font(void)
{
	DWORD fontFamily = 0;
	PGETCURRENTCONSOLEFONTEX pGetCurrentConsoleFontEx;

	/* don't bother if output was ascii only */
	if (!non_ascii_used)
		return;

	/* GetCurrentConsoleFontEx is available since Vista */
	pGetCurrentConsoleFontEx = (PGETCURRENTCONSOLEFONTEX) GetProcAddress(
			GetModuleHandle("kernel32.dll"),
			"GetCurrentConsoleFontEx");
	if (pGetCurrentConsoleFontEx) {
		CONSOLE_FONT_INFOEX cfi;
		cfi.cbSize = sizeof(cfi);
		if (pGetCurrentConsoleFontEx(console, 0, &cfi))
			fontFamily = cfi.FontFamily;
	} else {
		/* pre-Vista: check default console font in registry */
		HKEY hkey;
		if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CURRENT_USER, "Console",
				0, KEY_READ, &hkey)) {
			DWORD size = sizeof(fontFamily);
			RegQueryValueExA(hkey, "FontFamily", NULL, NULL,
					(LPVOID) &fontFamily, &size);
			RegCloseKey(hkey);
		}
	}

	if (!(fontFamily & TMPF_TRUETYPE)) {
		const wchar_t *msg = L"\nWarning: Your console font probably "
			L"doesn\'t support Unicode. If you experience strange "
			L"characters in the output, consider switching to a "
			L"TrueType font such as Consolas!\n";
		DWORD dummy;
		WriteConsoleW(console, msg, wcslen(msg), &dummy, NULL);
	}
}

static int is_console(int fd)
{
	CONSOLE_SCREEN_BUFFER_INFO sbi;
	HANDLE hcon;

	static int initialized = 0;

	/* get OS handle of the file descriptor */
	hcon = (HANDLE) _get_osfhandle(fd);
	if (hcon == INVALID_HANDLE_VALUE)
		return 0;

	/* check if its a device (i.e. console, printer, serial port) */
	if (GetFileType(hcon) != FILE_TYPE_CHAR)
		return 0;

	/* check if its a handle to a console output screen buffer */
	if (!GetConsoleScreenBufferInfo(hcon, &sbi))
		return 0;

	/* initialize attributes */
	if (!initialized) {
		console = hcon;
		attr = plain_attr = sbi.wAttributes;
		negative = 0;
		initialized = 1;
	}

	return 1;
}

#define BUFFER_SIZE 4096
#define MAX_PARAMS 16

static void write_console(unsigned char *str, size_t len)
{
	/* only called from console_thread, so a static buffer will do */
	static wchar_t wbuf[2 * BUFFER_SIZE + 1];
	DWORD dummy;

	/* convert utf-8 to utf-16 */
	int wlen = xutftowcsn(wbuf, (char*) str, ARRAY_SIZE(wbuf), len);

	/* write directly to console */
	WriteConsoleW(console, wbuf, wlen, &dummy, NULL);

	/* remember if non-ascii characters are printed */
	if (wlen != len)
		non_ascii_used = 1;
}

#define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
#define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)

static void set_console_attr(void)
{
	WORD attributes = attr;
	if (negative) {
		attributes &= ~FOREGROUND_ALL;
		attributes &= ~BACKGROUND_ALL;

		/* This could probably use a bitmask
		   instead of a series of ifs */
		if (attr & FOREGROUND_RED)
			attributes |= BACKGROUND_RED;
		if (attr & FOREGROUND_GREEN)
			attributes |= BACKGROUND_GREEN;
		if (attr & FOREGROUND_BLUE)
			attributes |= BACKGROUND_BLUE;

		if (attr & BACKGROUND_RED)
			attributes |= FOREGROUND_RED;
		if (attr & BACKGROUND_GREEN)
			attributes |= FOREGROUND_GREEN;
		if (attr & BACKGROUND_BLUE)
			attributes |= FOREGROUND_BLUE;
	}
	SetConsoleTextAttribute(console, attributes);
}

static void erase_in_line(void)
{
	CONSOLE_SCREEN_BUFFER_INFO sbi;
	DWORD dummy; /* Needed for Windows 7 (or Vista) regression */

	if (!console)
		return;

	GetConsoleScreenBufferInfo(console, &sbi);
	FillConsoleOutputCharacterA(console, ' ',
		sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
		&dummy);
}

static void set_attr(char func, const int *params, int paramlen)
{
	int i;
	switch (func) {
	case 'm':
		for (i = 0; i < paramlen; i++) {
			switch (params[i]) {
			case 0: /* reset */
				attr = plain_attr;
				negative = 0;
				break;
			case 1: /* bold */
				attr |= FOREGROUND_INTENSITY;
				break;
			case 2:  /* faint */
			case 22: /* normal */
				attr &= ~FOREGROUND_INTENSITY;
				break;
			case 3:  /* italic */
				/* Unsupported */
				break;
			case 4:  /* underline */
			case 21: /* double underline */
				/* Wikipedia says this flag does nothing */
				/* Furthermore, mingw doesn't define this flag
				attr |= COMMON_LVB_UNDERSCORE; */
				break;
			case 24: /* no underline */
				/* attr &= ~COMMON_LVB_UNDERSCORE; */
				break;
			case 5:  /* slow blink */
			case 6:  /* fast blink */
				/* We don't have blink, but we do have
				   background intensity */
				attr |= BACKGROUND_INTENSITY;
				break;
			case 25: /* no blink */
				attr &= ~BACKGROUND_INTENSITY;
				break;
			case 7:  /* negative */
				negative = 1;
				break;
			case 27: /* positive */
				negative = 0;
				break;
			case 8:  /* conceal */
			case 28: /* reveal */
				/* Unsupported */
				break;
			case 30: /* Black */
				attr &= ~FOREGROUND_ALL;
				break;
			case 31: /* Red */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_RED;
				break;
			case 32: /* Green */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_GREEN;
				break;
			case 33: /* Yellow */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_RED | FOREGROUND_GREEN;
				break;
			case 34: /* Blue */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_BLUE;
				break;
			case 35: /* Magenta */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_RED | FOREGROUND_BLUE;
				break;
			case 36: /* Cyan */
				attr &= ~FOREGROUND_ALL;
				attr |= FOREGROUND_GREEN | FOREGROUND_BLUE;
				break;
			case 37: /* White */
				attr |= FOREGROUND_RED |
					FOREGROUND_GREEN |
					FOREGROUND_BLUE;
				break;
			case 38: /* Unknown */
				break;
			case 39: /* reset */
				attr &= ~FOREGROUND_ALL;
				attr |= (plain_attr & FOREGROUND_ALL);
				break;
			case 40: /* Black */
				attr &= ~BACKGROUND_ALL;
				break;
			case 41: /* Red */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_RED;
				break;
			case 42: /* Green */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_GREEN;
				break;
			case 43: /* Yellow */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_RED | BACKGROUND_GREEN;
				break;
			case 44: /* Blue */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_BLUE;
				break;
			case 45: /* Magenta */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_RED | BACKGROUND_BLUE;
				break;
			case 46: /* Cyan */
				attr &= ~BACKGROUND_ALL;
				attr |= BACKGROUND_GREEN | BACKGROUND_BLUE;
				break;
			case 47: /* White */
				attr |= BACKGROUND_RED |
					BACKGROUND_GREEN |
					BACKGROUND_BLUE;
				break;
			case 48: /* Unknown */
				break;
			case 49: /* reset */
				attr &= ~BACKGROUND_ALL;
				attr |= (plain_attr & BACKGROUND_ALL);
				break;
			default:
				/* Unsupported code */
				break;
			}
		}
		set_console_attr();
		break;
	case 'K':
		erase_in_line();
		break;
	default:
		/* Unsupported code */
		break;
	}
}

enum {
	TEXT = 0, ESCAPE = 033, BRACKET = '['
};

static DWORD WINAPI console_thread(LPVOID unused)
{
	unsigned char buffer[BUFFER_SIZE];
	DWORD bytes;
	int start, end = 0, c, parampos = 0, state = TEXT;
	int params[MAX_PARAMS];

	while (1) {
		/* read next chunk of bytes from the pipe */
		if (!ReadFile(hread, buffer + end, BUFFER_SIZE - end, &bytes,
				NULL)) {
			/* exit if pipe has been closed or disconnected */
			if (GetLastError() == ERROR_PIPE_NOT_CONNECTED ||
					GetLastError() == ERROR_BROKEN_PIPE)
				break;
			/* ignore other errors */
			continue;
		}

		/* scan the bytes and handle ANSI control codes */
		bytes += end;
		start = end = 0;
		while (end < bytes) {
			c = buffer[end++];
			switch (state) {
			case TEXT:
				if (c == ESCAPE) {
					/* print text seen so far */
					if (end - 1 > start)
						write_console(buffer + start,
							end - 1 - start);

					/* then start parsing escape sequence */
					start = end - 1;
					memset(params, 0, sizeof(params));
					parampos = 0;
					state = ESCAPE;
				}
				break;

			case ESCAPE:
				/* continue if "\033[", otherwise bail out */
				state = (c == BRACKET) ? BRACKET : TEXT;
				break;

			case BRACKET:
				/* parse [0-9;]* into array of parameters */
				if (c >= '0' && c <= '9') {
					params[parampos] *= 10;
					params[parampos] += c - '0';
				} else if (c == ';') {
					/*
					 * next parameter, bail out if out of
					 * bounds
					 */
					parampos++;
					if (parampos >= MAX_PARAMS)
						state = TEXT;
				} else {
					/*
					 * end of escape sequence, change
					 * console attributes
					 */
					set_attr(c, params, parampos + 1);
					start = end;
					state = TEXT;
				}
				break;
			}
		}

		/* print remaining text unless parsing an escape sequence */
		if (state == TEXT && end > start) {
			/* check for incomplete UTF-8 sequences and fix end */
			if (buffer[end - 1] >= 0x80) {
				if (buffer[end -1] >= 0xc0)
					end--;
				else if (end - 1 > start &&
						buffer[end - 2] >= 0xe0)
					end -= 2;
				else if (end - 2 > start &&
						buffer[end - 3] >= 0xf0)
					end -= 3;
			}

			/* print remaining complete UTF-8 sequences */
			if (end > start)
				write_console(buffer + start, end - start);

			/* move remaining bytes to the front */
			if (end < bytes)
				memmove(buffer, buffer + end, bytes - end);
			end = bytes - end;
		} else {
			/* all data has been consumed, mark buffer empty */
			end = 0;
		}
	}

	/* check if the console font supports unicode */
	warn_if_raster_font();

	CloseHandle(hread);
	return 0;
}

static void winansi_exit(void)
{
	/* flush all streams */
	_flushall();

	/* signal console thread to exit */
	FlushFileBuffers(hwrite);
	DisconnectNamedPipe(hwrite);

	/* wait for console thread to copy remaining data */
	WaitForSingleObject(hthread, INFINITE);

	/* cleanup handles... */
	CloseHandle(hwrite);
	CloseHandle(hthread);
}

static void die_lasterr(const char *fmt, ...)
{
	va_list params;
	va_start(params, fmt);
	errno = err_win_to_posix(GetLastError());
	die_errno(fmt, params);
	va_end(params);
}

static HANDLE duplicate_handle(HANDLE hnd)
{
	HANDLE hresult, hproc = GetCurrentProcess();
	if (!DuplicateHandle(hproc, hnd, hproc, &hresult, 0, TRUE,
			DUPLICATE_SAME_ACCESS))
		die_lasterr("DuplicateHandle(%li) failed",
			(long) (intptr_t) hnd);
	return hresult;
}


/*
 * Make MSVCRT's internal file descriptor control structure accessible
 * so that we can tweak OS handles and flags directly (we need MSVCRT
 * to treat our pipe handle as if it were a console).
 *
 * We assume that the ioinfo structure (exposed by MSVCRT.dll via
 * __pioinfo) starts with the OS handle and the flags. The exact size
 * varies between MSVCRT versions, so we try different sizes until
 * toggling the FDEV bit of _pioinfo(1)->osflags is reflected in
 * isatty(1).
 */
typedef struct {
	HANDLE osfhnd;
	char osflags;
} ioinfo;

extern __declspec(dllimport) ioinfo *__pioinfo[];

static size_t sizeof_ioinfo = 0;

#define IOINFO_L2E 5
#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)

#define FPIPE 0x08
#define FDEV  0x40

static inline ioinfo* _pioinfo(int fd)
{
	return (ioinfo*)((char*)__pioinfo[fd >> IOINFO_L2E] +
			(fd & (IOINFO_ARRAY_ELTS - 1)) * sizeof_ioinfo);
}

static int init_sizeof_ioinfo()
{
	int istty, wastty;
	/* don't init twice */
	if (sizeof_ioinfo)
		return sizeof_ioinfo >= 256;

	sizeof_ioinfo = sizeof(ioinfo);
	wastty = isatty(1);
	while (sizeof_ioinfo < 256) {
		/* toggle FDEV flag, check isatty, then toggle back */
		_pioinfo(1)->osflags ^= FDEV;
		istty = isatty(1);
		_pioinfo(1)->osflags ^= FDEV;
		/* return if we found the correct size */
		if (istty != wastty)
			return 0;
		sizeof_ioinfo += sizeof(void*);
	}
	error("Tweaking file descriptors doesn't work with this MSVCRT.dll");
	return 1;
}

static HANDLE swap_osfhnd(int fd, HANDLE new_handle)
{
	ioinfo *pioinfo;
	HANDLE old_handle;

	/* init ioinfo size if we haven't done so */
	if (init_sizeof_ioinfo())
		return INVALID_HANDLE_VALUE;

	/* get ioinfo pointer and change the handles */
	pioinfo = _pioinfo(fd);
	old_handle = pioinfo->osfhnd;
	pioinfo->osfhnd = new_handle;
	return old_handle;
}

#ifdef DETECT_MSYS_TTY

#include <winternl.h>
#include <ntstatus.h>

static void detect_msys_tty(int fd)
{
	ULONG result;
	BYTE buffer[1024];
	POBJECT_NAME_INFORMATION nameinfo = (POBJECT_NAME_INFORMATION) buffer;
	PWSTR name;

	/* check if fd is a pipe */
	HANDLE h = (HANDLE) _get_osfhandle(fd);
	if (GetFileType(h) != FILE_TYPE_PIPE)
		return;

	/* get pipe name */
	if (!NT_SUCCESS(NtQueryObject(h, ObjectNameInformation,
			buffer, sizeof(buffer) - 2, &result)))
		return;
	name = nameinfo->Name.Buffer;
	name[nameinfo->Name.Length] = 0;

	/* check if this could be a MSYS2 pty pipe ('msys-XXXX-ptyN-XX') */
	if (!wcsstr(name, L"msys-") || !wcsstr(name, L"-pty"))
		return;

	/* init ioinfo size if we haven't done so */
	if (init_sizeof_ioinfo())
		return;

	/* set FDEV flag, reset FPIPE flag */
	_pioinfo(fd)->osflags &= ~FPIPE;
	_pioinfo(fd)->osflags |= FDEV;
}

#endif

void winansi_init(void)
{
	int con1, con2;
	char name[32];

	/* check if either stdout or stderr is a console output screen buffer */
	con1 = is_console(1);
	con2 = is_console(2);
	if (!con1 && !con2) {
#ifdef DETECT_MSYS_TTY
		/* check if stdin / stdout / stderr are MSYS2 pty pipes */
		detect_msys_tty(0);
		detect_msys_tty(1);
		detect_msys_tty(2);
#endif
		return;
	}

	/* create a named pipe to communicate with the console thread */
	xsnprintf(name, sizeof(name), "\\\\.\\pipe\\winansi%lu", GetCurrentProcessId());
	hwrite = CreateNamedPipe(name, PIPE_ACCESS_OUTBOUND,
		PIPE_TYPE_BYTE | PIPE_WAIT, 1, BUFFER_SIZE, 0, 0, NULL);
	if (hwrite == INVALID_HANDLE_VALUE)
		die_lasterr("CreateNamedPipe failed");

	hread = CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
	if (hread == INVALID_HANDLE_VALUE)
		die_lasterr("CreateFile for named pipe failed");

	/* start console spool thread on the pipe's read end */
	hthread = CreateThread(NULL, 0, console_thread, NULL, 0, NULL);
	if (hthread == INVALID_HANDLE_VALUE)
		die_lasterr("CreateThread(console_thread) failed");

	/* schedule cleanup routine */
	if (atexit(winansi_exit))
		die_errno("atexit(winansi_exit) failed");

	/* redirect stdout / stderr to the pipe */
	if (con1)
		hconsole1 = swap_osfhnd(1, duplicate_handle(hwrite));
	if (con2)
		hconsole2 = swap_osfhnd(2, duplicate_handle(hwrite));
}

/*
 * Returns the real console handle if stdout / stderr is a pipe redirecting
 * to the console. Allows spawn / exec to pass the console to the next process.
 */
HANDLE winansi_get_osfhandle(int fd)
{
	HANDLE hnd = (HANDLE) _get_osfhandle(fd);
	if (isatty(fd) && GetFileType(hnd) == FILE_TYPE_PIPE) {
		if (fd == 1 && hconsole1)
			return hconsole1;
		else if (fd == 2 && hconsole2)
			return hconsole2;
	}
	return hnd;
}
Commit	Line	Data
c09df8a7 PH	1	/*
	2	* Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
	3	*/
	4
1edeb9ab	5	#undef NOGDI
c09df8a7	6	#include "../git-compat-util.h"
1edeb9ab KB	7	#include <wingdi.h>
1edeb9ab KB	8	#include <winreg.h>
c09df8a7	9
c09df8a7 PH	10	/*
	11	ANSI codes used by git: m, K
	12
	13	This file is git-specific. Therefore, this file does not attempt
	14	to implement any codes that are not used by git.
c09df8a7 PH	15	*/
	16
	17	static HANDLE console;
	18	static WORD plain_attr;
	19	static WORD attr;
	20	static int negative;
eac14f89 KB	21	static int non_ascii_used = 0;
eac14f89 KB	22	static HANDLE hthread, hread, hwrite;
eac14f89	23	static HANDLE hconsole1, hconsole2;
c09df8a7	24
1edeb9ab	25	#ifdef __MINGW32__
466931d9	26	#if !defined(__MINGW64_VERSION_MAJOR) \|\| __MINGW64_VERSION_MAJOR < 5
1edeb9ab KB	27	typedef struct _CONSOLE_FONT_INFOEX {
	28	ULONG cbSize;
	29	DWORD nFont;
	30	COORD dwFontSize;
	31	UINT FontFamily;
	32	UINT FontWeight;
	33	WCHAR FaceName[LF_FACESIZE];
	34	} CONSOLE_FONT_INFOEX, *PCONSOLE_FONT_INFOEX;
	35	#endif
466931d9	36	#endif
1edeb9ab KB	37
	38	typedef BOOL (WINAPI *PGETCURRENTCONSOLEFONTEX)(HANDLE, BOOL,
	39	PCONSOLE_FONT_INFOEX);
	40
eac14f89	41	static void warn_if_raster_font(void)
1edeb9ab	42	{
1edeb9ab KB	43	DWORD fontFamily = 0;
	44	PGETCURRENTCONSOLEFONTEX pGetCurrentConsoleFontEx;
	45
eac14f89 KB	46	/* don't bother if output was ascii only */
eac14f89 KB	47	if (!non_ascii_used)
1edeb9ab	48	return;
1edeb9ab KB	49
	50	/* GetCurrentConsoleFontEx is available since Vista */
	51	pGetCurrentConsoleFontEx = (PGETCURRENTCONSOLEFONTEX) GetProcAddress(
eac14f89 KB	52	GetModuleHandle("kernel32.dll"),
eac14f89 KB	53	"GetCurrentConsoleFontEx");
1edeb9ab KB	54	if (pGetCurrentConsoleFontEx) {
	55	CONSOLE_FONT_INFOEX cfi;
	56	cfi.cbSize = sizeof(cfi);
	57	if (pGetCurrentConsoleFontEx(console, 0, &cfi))
	58	fontFamily = cfi.FontFamily;
	59	} else {
	60	/* pre-Vista: check default console font in registry */
	61	HKEY hkey;
eac14f89 KB	62	if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CURRENT_USER, "Console",
eac14f89 KB	63	0, KEY_READ, &hkey)) {
1edeb9ab KB	64	DWORD size = sizeof(fontFamily);
	65	RegQueryValueExA(hkey, "FontFamily", NULL, NULL,
	66	(LPVOID) &fontFamily, &size);
	67	RegCloseKey(hkey);
	68	}
	69	}
	70
eac14f89 KB	71	if (!(fontFamily & TMPF_TRUETYPE)) {
	72	const wchar_t *msg = L"\nWarning: Your console font probably "
	73	L"doesn\'t support Unicode. If you experience strange "
	74	L"characters in the output, consider switching to a "
	75	L"TrueType font such as Consolas!\n";
	76	DWORD dummy;
	77	WriteConsoleW(console, msg, wcslen(msg), &dummy, NULL);
	78	}
1edeb9ab KB	79	}
1edeb9ab KB	80
eac14f89	81	static int is_console(int fd)
c09df8a7 PH	82	{
c09df8a7 PH	83	CONSOLE_SCREEN_BUFFER_INFO sbi;
143e6152	84	HANDLE hcon;
c09df8a7 PH	85
c09df8a7 PH	86	static int initialized = 0;
c09df8a7	87
eac14f89 KB	88	/* get OS handle of the file descriptor */
eac14f89 KB	89	hcon = (HANDLE) _get_osfhandle(fd);
143e6152 KB	90	if (hcon == INVALID_HANDLE_VALUE)
	91	return 0;
	92
eac14f89 KB	93	/* check if its a device (i.e. console, printer, serial port) */
	94	if (GetFileType(hcon) != FILE_TYPE_CHAR)
	95	return 0;
	96
143e6152 KB	97	/* check if its a handle to a console output screen buffer */
	98	if (!GetConsoleScreenBufferInfo(hcon, &sbi))
	99	return 0;
	100
eac14f89	101	/* initialize attributes */
143e6152	102	if (!initialized) {
fcd428f4	103	console = hcon;
143e6152 KB	104	attr = plain_attr = sbi.wAttributes;
	105	negative = 0;
	106	initialized = 1;
	107	}
c09df8a7	108
143e6152	109	return 1;
c09df8a7 PH	110	}
c09df8a7 PH	111
eac14f89 KB	112	#define BUFFER_SIZE 4096
	113	#define MAX_PARAMS 16
	114
	115	static void write_console(unsigned char *str, size_t len)
617ce965	116	{
eac14f89 KB	117	/* only called from console_thread, so a static buffer will do */
	118	static wchar_t wbuf[2 * BUFFER_SIZE + 1];
	119	DWORD dummy;
617ce965	120
eac14f89 KB	121	/* convert utf-8 to utf-16 */
eac14f89 KB	122	int wlen = xutftowcsn(wbuf, (char*) str, ARRAY_SIZE(wbuf), len);
617ce965	123
eac14f89 KB	124	/* write directly to console */
eac14f89 KB	125	WriteConsoleW(console, wbuf, wlen, &dummy, NULL);
1edeb9ab	126
eac14f89 KB	127	/* remember if non-ascii characters are printed */
	128	if (wlen != len)
	129	non_ascii_used = 1;
617ce965	130	}
c09df8a7 PH	131
	132	#define FOREGROUND_ALL (FOREGROUND_RED \| FOREGROUND_GREEN \| FOREGROUND_BLUE)
	133	#define BACKGROUND_ALL (BACKGROUND_RED \| BACKGROUND_GREEN \| BACKGROUND_BLUE)
	134
	135	static void set_console_attr(void)
	136	{
	137	WORD attributes = attr;
	138	if (negative) {
	139	attributes &= ~FOREGROUND_ALL;
	140	attributes &= ~BACKGROUND_ALL;
	141
	142	/* This could probably use a bitmask
	143	instead of a series of ifs */
	144	if (attr & FOREGROUND_RED)
	145	attributes \|= BACKGROUND_RED;
	146	if (attr & FOREGROUND_GREEN)
	147	attributes \|= BACKGROUND_GREEN;
	148	if (attr & FOREGROUND_BLUE)
	149	attributes \|= BACKGROUND_BLUE;
	150
	151	if (attr & BACKGROUND_RED)
	152	attributes \|= FOREGROUND_RED;
	153	if (attr & BACKGROUND_GREEN)
	154	attributes \|= FOREGROUND_GREEN;
	155	if (attr & BACKGROUND_BLUE)
	156	attributes \|= FOREGROUND_BLUE;
	157	}
	158	SetConsoleTextAttribute(console, attributes);
	159	}
	160
1897713f JS	161	static void erase_in_line(void)
	162	{
	163	CONSOLE_SCREEN_BUFFER_INFO sbi;
492f7091	164	DWORD dummy; /* Needed for Windows 7 (or Vista) regression */
1897713f JS	165
	166	if (!console)
	167	return;
	168
	169	GetConsoleScreenBufferInfo(console, &sbi);
	170	FillConsoleOutputCharacterA(console, ' ',
	171	sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
492f7091	172	&dummy);
1897713f JS	173	}
1897713f JS	174
eac14f89	175	static void set_attr(char func, const int *params, int paramlen)
c09df8a7	176	{
eac14f89 KB	177	int i;
eac14f89 KB	178	switch (func) {
c09df8a7	179	case 'm':
eac14f89 KB	180	for (i = 0; i < paramlen; i++) {
eac14f89 KB	181	switch (params[i]) {
c09df8a7 PH	182	case 0: /* reset */
	183	attr = plain_attr;
	184	negative = 0;
	185	break;
	186	case 1: /* bold */
	187	attr \|= FOREGROUND_INTENSITY;
	188	break;
	189	case 2: /* faint */
	190	case 22: /* normal */
	191	attr &= ~FOREGROUND_INTENSITY;
	192	break;
	193	case 3: /* italic */
	194	/* Unsupported */
	195	break;
	196	case 4: /* underline */
	197	case 21: /* double underline */
	198	/* Wikipedia says this flag does nothing */
	199	/* Furthermore, mingw doesn't define this flag
	200	attr \|= COMMON_LVB_UNDERSCORE; */
	201	break;
	202	case 24: /* no underline */
	203	/* attr &= ~COMMON_LVB_UNDERSCORE; */
	204	break;
	205	case 5: /* slow blink */
	206	case 6: /* fast blink */
	207	/* We don't have blink, but we do have
	208	background intensity */
	209	attr \|= BACKGROUND_INTENSITY;
	210	break;
	211	case 25: /* no blink */
	212	attr &= ~BACKGROUND_INTENSITY;
	213	break;
	214	case 7: /* negative */
	215	negative = 1;
	216	break;
	217	case 27: /* positive */
	218	negative = 0;
	219	break;
	220	case 8: /* conceal */
	221	case 28: /* reveal */
	222	/* Unsupported */
	223	break;
	224	case 30: /* Black */
	225	attr &= ~FOREGROUND_ALL;
	226	break;
	227	case 31: /* Red */
	228	attr &= ~FOREGROUND_ALL;
	229	attr \|= FOREGROUND_RED;
	230	break;
	231	case 32: /* Green */
	232	attr &= ~FOREGROUND_ALL;
	233	attr \|= FOREGROUND_GREEN;
	234	break;
	235	case 33: /* Yellow */
	236	attr &= ~FOREGROUND_ALL;
	237	attr \|= FOREGROUND_RED \| FOREGROUND_GREEN;
	238	break;
	239	case 34: /* Blue */
	240	attr &= ~FOREGROUND_ALL;
	241	attr \|= FOREGROUND_BLUE;
	242	break;
	243	case 35: /* Magenta */
	244	attr &= ~FOREGROUND_ALL;
	245	attr \|= FOREGROUND_RED \| FOREGROUND_BLUE;
246	break;
247	case 36: /* Cyan */
248	attr &= ~FOREGROUND_ALL;
249	attr \|= FOREGROUND_GREEN \| FOREGROUND_BLUE;
250	break;
251	case 37: /* White */
252	attr \|= FOREGROUND_RED \|
253	FOREGROUND_GREEN \|
254	FOREGROUND_BLUE;
255	break;
256	case 38: /* Unknown */
257	break;
258	case 39: /* reset */
259	attr &= ~FOREGROUND_ALL;
260	attr \|= (plain_attr & FOREGROUND_ALL);
261	break;
262	case 40: /* Black */
263	attr &= ~BACKGROUND_ALL;
264	break;
265	case 41: /* Red */
266	attr &= ~BACKGROUND_ALL;
267	attr \|= BACKGROUND_RED;
268	break;
269	case 42: /* Green */
270	attr &= ~BACKGROUND_ALL;
271	attr \|= BACKGROUND_GREEN;
272	break;
273	case 43: /* Yellow */
274	attr &= ~BACKGROUND_ALL;
275	attr \|= BACKGROUND_RED \| BACKGROUND_GREEN;
276	break;
277	case 44: /* Blue */
278	attr &= ~BACKGROUND_ALL;
279	attr \|= BACKGROUND_BLUE;
280	break;
281	case 45: /* Magenta */
282	attr &= ~BACKGROUND_ALL;
283	attr \|= BACKGROUND_RED \| BACKGROUND_BLUE;
284	break;
285	case 46: /* Cyan */
286	attr &= ~BACKGROUND_ALL;
287	attr \|= BACKGROUND_GREEN \| BACKGROUND_BLUE;
288	break;
289	case 47: /* White */
290	attr \|= BACKGROUND_RED \|
291	BACKGROUND_GREEN \|
292	BACKGROUND_BLUE;
293	break;
294	case 48: /* Unknown */
295	break;
296	case 49: /* reset */
297	attr &= ~BACKGROUND_ALL;
298	attr \|= (plain_attr & BACKGROUND_ALL);
299	break;
300	default:
301	/* Unsupported code */
302	break;
303	}
eac14f89	304	}
c09df8a7 PH	305	set_console_attr();
	306	break;
	307	case 'K':
1897713f	308	erase_in_line();
c09df8a7 PH	309	break;
	310	default:
	311	/* Unsupported code */
	312	break;
	313	}
c09df8a7 PH	314	}
c09df8a7 PH	315
eac14f89 KB	316	enum {
	317	TEXT = 0, ESCAPE = 033, BRACKET = '['
	318	};
c09df8a7	319
eac14f89 KB	320	static DWORD WINAPI console_thread(LPVOID unused)
	321	{
	322	unsigned char buffer[BUFFER_SIZE];
	323	DWORD bytes;
	324	int start, end = 0, c, parampos = 0, state = TEXT;
	325	int params[MAX_PARAMS];
	326
	327	while (1) {
	328	/* read next chunk of bytes from the pipe */
	329	if (!ReadFile(hread, buffer + end, BUFFER_SIZE - end, &bytes,
	330	NULL)) {
	331	/* exit if pipe has been closed or disconnected */
	332	if (GetLastError() == ERROR_PIPE_NOT_CONNECTED \|\|
	333	GetLastError() == ERROR_BROKEN_PIPE)
	334	break;
	335	/* ignore other errors */
	336	continue;
	337	}
617ce965	338
eac14f89 KB	339	/* scan the bytes and handle ANSI control codes */
	340	bytes += end;
	341	start = end = 0;
	342	while (end < bytes) {
	343	c = buffer[end++];
	344	switch (state) {
	345	case TEXT:
	346	if (c == ESCAPE) {
	347	/* print text seen so far */
	348	if (end - 1 > start)
	349	write_console(buffer + start,
	350	end - 1 - start);
	351
	352	/* then start parsing escape sequence */
	353	start = end - 1;
	354	memset(params, 0, sizeof(params));
	355	parampos = 0;
	356	state = ESCAPE;
	357	}
	358	break;
	359
	360	case ESCAPE:
	361	/* continue if "\033[", otherwise bail out */
	362	state = (c == BRACKET) ? BRACKET : TEXT;
	363	break;
	364
	365	case BRACKET:
	366	/* parse [0-9;]* into array of parameters */
	367	if (c >= '0' && c <= '9') {
	368	params[parampos] *= 10;
	369	params[parampos] += c - '0';
	370	} else if (c == ';') {
	371	/*
	372	* next parameter, bail out if out of
	373	* bounds
	374	*/
	375	parampos++;
	376	if (parampos >= MAX_PARAMS)
	377	state = TEXT;
	378	} else {
	379	/*
	380	* end of escape sequence, change
	381	* console attributes
	382	*/
	383	set_attr(c, params, parampos + 1);
	384	start = end;
	385	state = TEXT;
	386	}
	387	break;
	388	}
	389	}
c09df8a7	390
eac14f89 KB	391	/* print remaining text unless parsing an escape sequence */
	392	if (state == TEXT && end > start) {
	393	/* check for incomplete UTF-8 sequences and fix end */
	394	if (buffer[end - 1] >= 0x80) {
	395	if (buffer[end -1] >= 0xc0)
	396	end--;
	397	else if (end - 1 > start &&
	398	buffer[end - 2] >= 0xe0)
	399	end -= 2;
	400	else if (end - 2 > start &&
	401	buffer[end - 3] >= 0xf0)
	402	end -= 3;
c09df8a7 PH	403	}
c09df8a7 PH	404
eac14f89 KB	405	/* print remaining complete UTF-8 sequences */
	406	if (end > start)
	407	write_console(buffer + start, end - start);
c09df8a7	408
eac14f89 KB	409	/* move remaining bytes to the front */
	410	if (end < bytes)
	411	memmove(buffer, buffer + end, bytes - end);
	412	end = bytes - end;
c09df8a7	413	} else {
eac14f89 KB	414	/* all data has been consumed, mark buffer empty */
eac14f89 KB	415	end = 0;
c09df8a7 PH	416	}
c09df8a7 PH	417	}
c09df8a7	418
eac14f89 KB	419	/* check if the console font supports unicode */
eac14f89 KB	420	warn_if_raster_font();
c09df8a7	421
eac14f89 KB	422	CloseHandle(hread);
eac14f89 KB	423	return 0;
c09df8a7 PH	424	}
c09df8a7 PH	425
eac14f89	426	static void winansi_exit(void)
c09df8a7	427	{
eac14f89 KB	428	/* flush all streams */
	429	_flushall();
	430
	431	/* signal console thread to exit */
	432	FlushFileBuffers(hwrite);
	433	DisconnectNamedPipe(hwrite);
	434
	435	/* wait for console thread to copy remaining data */
	436	WaitForSingleObject(hthread, INFINITE);
	437
	438	/* cleanup handles... */
eac14f89 KB	439	CloseHandle(hwrite);
	440	CloseHandle(hthread);
	441	}
c09df8a7	442
eac14f89 KB	443	static void die_lasterr(const char *fmt, ...)
	444	{
	445	va_list params;
	446	va_start(params, fmt);
	447	errno = err_win_to_posix(GetLastError());
	448	die_errno(fmt, params);
	449	va_end(params);
	450	}
c09df8a7	451
eac14f89 KB	452	static HANDLE duplicate_handle(HANDLE hnd)
	453	{
	454	HANDLE hresult, hproc = GetCurrentProcess();
	455	if (!DuplicateHandle(hproc, hnd, hproc, &hresult, 0, TRUE,
	456	DUPLICATE_SAME_ACCESS))
7c00bc39 JS	457	die_lasterr("DuplicateHandle(%li) failed",
7c00bc39 JS	458	(long) (intptr_t) hnd);
eac14f89 KB	459	return hresult;
eac14f89 KB	460	}
c09df8a7	461
c09df8a7	462
fcd428f4 KB	463	/*
	464	* Make MSVCRT's internal file descriptor control structure accessible
	465	* so that we can tweak OS handles and flags directly (we need MSVCRT
	466	* to treat our pipe handle as if it were a console).
	467	*
	468	* We assume that the ioinfo structure (exposed by MSVCRT.dll via
	469	* __pioinfo) starts with the OS handle and the flags. The exact size
	470	* varies between MSVCRT versions, so we try different sizes until
	471	* toggling the FDEV bit of _pioinfo(1)->osflags is reflected in
	472	* isatty(1).
	473	*/
	474	typedef struct {
	475	HANDLE osfhnd;
	476	char osflags;
	477	} ioinfo;
	478
	479	extern __declspec(dllimport) ioinfo *__pioinfo[];
c09df8a7	480
fcd428f4	481	static size_t sizeof_ioinfo = 0;
c09df8a7	482
fcd428f4 KB	483	#define IOINFO_L2E 5
	484	#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
	485
f7f90e0f	486	#define FPIPE 0x08
fcd428f4 KB	487	#define FDEV 0x40
	488
	489	static inline ioinfo* _pioinfo(int fd)
	490	{
	491	return (ioinfo)((char)__pioinfo[fd >> IOINFO_L2E] +
	492	(fd & (IOINFO_ARRAY_ELTS - 1)) * sizeof_ioinfo);
	493	}
	494
	495	static int init_sizeof_ioinfo()
	496	{
	497	int istty, wastty;
	498	/* don't init twice */
	499	if (sizeof_ioinfo)
	500	return sizeof_ioinfo >= 256;
	501
	502	sizeof_ioinfo = sizeof(ioinfo);
	503	wastty = isatty(1);
	504	while (sizeof_ioinfo < 256) {
	505	/* toggle FDEV flag, check isatty, then toggle back */
	506	_pioinfo(1)->osflags ^= FDEV;
	507	istty = isatty(1);
	508	_pioinfo(1)->osflags ^= FDEV;
	509	/* return if we found the correct size */
	510	if (istty != wastty)
	511	return 0;
	512	sizeof_ioinfo += sizeof(void*);
	513	}
	514	error("Tweaking file descriptors doesn't work with this MSVCRT.dll");
	515	return 1;
	516	}
	517
	518	static HANDLE swap_osfhnd(int fd, HANDLE new_handle)
	519	{
	520	ioinfo *pioinfo;
	521	HANDLE old_handle;
	522
	523	/* init ioinfo size if we haven't done so */
	524	if (init_sizeof_ioinfo())
	525	return INVALID_HANDLE_VALUE;
	526
	527	/* get ioinfo pointer and change the handles */
	528	pioinfo = _pioinfo(fd);
	529	old_handle = pioinfo->osfhnd;
	530	pioinfo->osfhnd = new_handle;
	531	return old_handle;
c09df8a7 PH	532	}
c09df8a7 PH	533
f7f90e0f KB	534	#ifdef DETECT_MSYS_TTY
	535
	536	#include <winternl.h>
	537	#include <ntstatus.h>
	538
	539	static void detect_msys_tty(int fd)
	540	{
	541	ULONG result;
	542	BYTE buffer[1024];
	543	POBJECT_NAME_INFORMATION nameinfo = (POBJECT_NAME_INFORMATION) buffer;
	544	PWSTR name;
	545
	546	/* check if fd is a pipe */
	547	HANDLE h = (HANDLE) _get_osfhandle(fd);
	548	if (GetFileType(h) != FILE_TYPE_PIPE)
	549	return;
	550
	551	/* get pipe name */
	552	if (!NT_SUCCESS(NtQueryObject(h, ObjectNameInformation,
	553	buffer, sizeof(buffer) - 2, &result)))
	554	return;
	555	name = nameinfo->Name.Buffer;
	556	name[nameinfo->Name.Length] = 0;
	557
	558	/* check if this could be a MSYS2 pty pipe ('msys-XXXX-ptyN-XX') */
	559	if (!wcsstr(name, L"msys-") \|\| !wcsstr(name, L"-pty"))
	560	return;
	561
	562	/* init ioinfo size if we haven't done so */
	563	if (init_sizeof_ioinfo())
	564	return;
	565
	566	/* set FDEV flag, reset FPIPE flag */
	567	_pioinfo(fd)->osflags &= ~FPIPE;
	568	_pioinfo(fd)->osflags \|= FDEV;
	569	}
	570
	571	#endif
	572
eac14f89	573	void winansi_init(void)
c09df8a7	574	{
fcd428f4	575	int con1, con2;
eac14f89	576	char name[32];
c09df8a7	577
eac14f89 KB	578	/* check if either stdout or stderr is a console output screen buffer */
	579	con1 = is_console(1);
	580	con2 = is_console(2);
f7f90e0f KB	581	if (!con1 && !con2) {
	582	#ifdef DETECT_MSYS_TTY
	583	/* check if stdin / stdout / stderr are MSYS2 pty pipes */
	584	detect_msys_tty(0);
	585	detect_msys_tty(1);
	586	detect_msys_tty(2);
	587	#endif
eac14f89	588	return;
f7f90e0f	589	}
c09df8a7	590
eac14f89	591	/* create a named pipe to communicate with the console thread */
5096d490	592	xsnprintf(name, sizeof(name), "\\\\.\\pipe\\winansi%lu", GetCurrentProcessId());
eac14f89 KB	593	hwrite = CreateNamedPipe(name, PIPE_ACCESS_OUTBOUND,
	594	PIPE_TYPE_BYTE \| PIPE_WAIT, 1, BUFFER_SIZE, 0, 0, NULL);
	595	if (hwrite == INVALID_HANDLE_VALUE)
	596	die_lasterr("CreateNamedPipe failed");
	597
	598	hread = CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
	599	if (hread == INVALID_HANDLE_VALUE)
	600	die_lasterr("CreateFile for named pipe failed");
	601
	602	/* start console spool thread on the pipe's read end */
	603	hthread = CreateThread(NULL, 0, console_thread, NULL, 0, NULL);
	604	if (hthread == INVALID_HANDLE_VALUE)
	605	die_lasterr("CreateThread(console_thread) failed");
	606
	607	/* schedule cleanup routine */
	608	if (atexit(winansi_exit))
	609	die_errno("atexit(winansi_exit) failed");
	610
eac14f89 KB	611	/* redirect stdout / stderr to the pipe */
eac14f89 KB	612	if (con1)
51822653	613	hconsole1 = swap_osfhnd(1, duplicate_handle(hwrite));
eac14f89	614	if (con2)
51822653	615	hconsole2 = swap_osfhnd(2, duplicate_handle(hwrite));
eac14f89	616	}
c09df8a7	617
eac14f89 KB	618	/*
	619	* Returns the real console handle if stdout / stderr is a pipe redirecting
	620	* to the console. Allows spawn / exec to pass the console to the next process.
	621	*/
	622	HANDLE winansi_get_osfhandle(int fd)
	623	{
51822653	624	HANDLE hnd = (HANDLE) _get_osfhandle(fd);
f7f90e0f KB	625	if (isatty(fd) && GetFileType(hnd) == FILE_TYPE_PIPE) {
	626	if (fd == 1 && hconsole1)
	627	return hconsole1;
	628	else if (fd == 2 && hconsole2)
	629	return hconsole2;
	630	}
51822653	631	return hnd;
c09df8a7	632	}