Merge branch 'sk/mingw-uni-console'
* sk/mingw-uni-console: Win32: reliably detect console pipe handles Win32: fix broken pipe detection Win32: Thread-safe windows console output Win32: add Unicode conversion functions Win32: warn if the console font doesn't support Unicode Win32: detect console streams more reliably Win32: support Unicode console output
This commit is contained in:
Junio C Hamano
commit
641830cbe1
@ -865,9 +865,9 @@ static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **env,
|
||||
memset(&si, 0, sizeof(si));
|
||||
si.cb = sizeof(si);
|
||||
si.dwFlags = STARTF_USESTDHANDLES;
|
||||
si.hStdInput = (HANDLE) _get_osfhandle(fhin);
|
||||
si.hStdOutput = (HANDLE) _get_osfhandle(fhout);
|
||||
si.hStdError = (HANDLE) _get_osfhandle(fherr);
|
||||
si.hStdInput = winansi_get_osfhandle(fhin);
|
||||
si.hStdOutput = winansi_get_osfhandle(fhout);
|
||||
si.hStdError = winansi_get_osfhandle(fherr);
|
||||
|
||||
/* concatenate argv, quoting args as we go */
|
||||
strbuf_init(&args, 0);
|
||||
@ -1848,6 +1848,91 @@ int mingw_offset_1st_component(const char *path)
|
||||
return offset + is_dir_sep(path[offset]);
|
||||
}
|
||||
|
||||
int xutftowcsn(wchar_t *wcs, const char *utfs, size_t wcslen, int utflen)
|
||||
{
|
||||
int upos = 0, wpos = 0;
|
||||
const unsigned char *utf = (const unsigned char*) utfs;
|
||||
if (!utf || !wcs || wcslen < 1) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
/* reserve space for \0 */
|
||||
wcslen--;
|
||||
if (utflen < 0)
|
||||
utflen = INT_MAX;
|
||||
|
||||
while (upos < utflen) {
|
||||
int c = utf[upos++] & 0xff;
|
||||
if (utflen == INT_MAX && c == 0)
|
||||
break;
|
||||
|
||||
if (wpos >= wcslen) {
|
||||
wcs[wpos] = 0;
|
||||
errno = ERANGE;
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (c < 0x80) {
|
||||
/* ASCII */
|
||||
wcs[wpos++] = c;
|
||||
} else if (c >= 0xc2 && c < 0xe0 && upos < utflen &&
|
||||
(utf[upos] & 0xc0) == 0x80) {
|
||||
/* 2-byte utf-8 */
|
||||
c = ((c & 0x1f) << 6);
|
||||
c |= (utf[upos++] & 0x3f);
|
||||
wcs[wpos++] = c;
|
||||
} else if (c >= 0xe0 && c < 0xf0 && upos + 1 < utflen &&
|
||||
!(c == 0xe0 && utf[upos] < 0xa0) && /* over-long encoding */
|
||||
(utf[upos] & 0xc0) == 0x80 &&
|
||||
(utf[upos + 1] & 0xc0) == 0x80) {
|
||||
/* 3-byte utf-8 */
|
||||
c = ((c & 0x0f) << 12);
|
||||
c |= ((utf[upos++] & 0x3f) << 6);
|
||||
c |= (utf[upos++] & 0x3f);
|
||||
wcs[wpos++] = c;
|
||||
} else if (c >= 0xf0 && c < 0xf5 && upos + 2 < utflen &&
|
||||
wpos + 1 < wcslen &&
|
||||
!(c == 0xf0 && utf[upos] < 0x90) && /* over-long encoding */
|
||||
!(c == 0xf4 && utf[upos] >= 0x90) && /* > \u10ffff */
|
||||
(utf[upos] & 0xc0) == 0x80 &&
|
||||
(utf[upos + 1] & 0xc0) == 0x80 &&
|
||||
(utf[upos + 2] & 0xc0) == 0x80) {
|
||||
/* 4-byte utf-8: convert to \ud8xx \udcxx surrogate pair */
|
||||
c = ((c & 0x07) << 18);
|
||||
c |= ((utf[upos++] & 0x3f) << 12);
|
||||
c |= ((utf[upos++] & 0x3f) << 6);
|
||||
c |= (utf[upos++] & 0x3f);
|
||||
c -= 0x10000;
|
||||
wcs[wpos++] = 0xd800 | (c >> 10);
|
||||
wcs[wpos++] = 0xdc00 | (c & 0x3ff);
|
||||
} else if (c >= 0xa0) {
|
||||
/* invalid utf-8 byte, printable unicode char: convert 1:1 */
|
||||
wcs[wpos++] = c;
|
||||
} else {
|
||||
/* invalid utf-8 byte, non-printable unicode: convert to hex */
|
||||
static const char *hex = "0123456789abcdef";
|
||||
wcs[wpos++] = hex[c >> 4];
|
||||
if (wpos < wcslen)
|
||||
wcs[wpos++] = hex[c & 0x0f];
|
||||
}
|
||||
}
|
||||
wcs[wpos] = 0;
|
||||
return wpos;
|
||||
}
|
||||
|
||||
int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen)
|
||||
{
|
||||
if (!wcs || !utf || utflen < 1) {
|
||||
errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
utflen = WideCharToMultiByte(CP_UTF8, 0, wcs, -1, utf, utflen, NULL, NULL);
|
||||
if (utflen)
|
||||
return utflen - 1;
|
||||
errno = ERANGE;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void mingw_startup()
|
||||
{
|
||||
/* copy executable name to argv[0] */
|
||||
@ -1861,4 +1946,7 @@ void mingw_startup()
|
||||
_setmode(_fileno(stdin), _O_BINARY);
|
||||
_setmode(_fileno(stdout), _O_BINARY);
|
||||
_setmode(_fileno(stderr), _O_BINARY);
|
||||
|
||||
/* initialize Unicode console */
|
||||
winansi_init();
|
||||
}
|
||||
|
||||
112
compat/mingw.h
112
compat/mingw.h
@ -317,12 +317,8 @@ int mingw_raise(int sig);
|
||||
* ANSI emulation wrappers
|
||||
*/
|
||||
|
||||
int winansi_fputs(const char *str, FILE *stream);
|
||||
int winansi_printf(const char *format, ...) __attribute__((format (printf, 1, 2)));
|
||||
int winansi_fprintf(FILE *stream, const char *format, ...) __attribute__((format (printf, 2, 3)));
|
||||
#define fputs winansi_fputs
|
||||
#define printf(...) winansi_printf(__VA_ARGS__)
|
||||
#define fprintf(...) winansi_fprintf(__VA_ARGS__)
|
||||
void winansi_init(void);
|
||||
HANDLE winansi_get_osfhandle(int fd);
|
||||
|
||||
/*
|
||||
* git specific compatibility
|
||||
@ -355,6 +351,110 @@ void mingw_open_html(const char *path);
|
||||
char **make_augmented_environ(const char *const *vars);
|
||||
void free_environ(char **env);
|
||||
|
||||
/**
|
||||
* Converts UTF-8 encoded string to UTF-16LE.
|
||||
*
|
||||
* To support repositories with legacy-encoded file names, invalid UTF-8 bytes
|
||||
* 0xa0 - 0xff are converted to corresponding printable Unicode chars \u00a0 -
|
||||
* \u00ff, and invalid UTF-8 bytes 0x80 - 0x9f (which would make non-printable
|
||||
* Unicode) are converted to hex-code.
|
||||
*
|
||||
* Lead-bytes not followed by an appropriate number of trail-bytes, over-long
|
||||
* encodings and 4-byte encodings > \u10ffff are detected as invalid UTF-8.
|
||||
*
|
||||
* Maximum space requirement for the target buffer is two wide chars per UTF-8
|
||||
* char (((strlen(utf) * 2) + 1) [* sizeof(wchar_t)]).
|
||||
*
|
||||
* The maximum space is needed only if the entire input string consists of
|
||||
* invalid UTF-8 bytes in range 0x80-0x9f, as per the following table:
|
||||
*
|
||||
* | | UTF-8 | UTF-16 |
|
||||
* Code point | UTF-8 sequence | bytes | words | ratio
|
||||
* --------------+-------------------+-------+--------+-------
|
||||
* 000000-00007f | 0-7f | 1 | 1 | 1
|
||||
* 000080-0007ff | c2-df + 80-bf | 2 | 1 | 0.5
|
||||
* 000800-00ffff | e0-ef + 2 * 80-bf | 3 | 1 | 0.33
|
||||
* 010000-10ffff | f0-f4 + 3 * 80-bf | 4 | 2 (a) | 0.5
|
||||
* invalid | 80-9f | 1 | 2 (b) | 2
|
||||
* invalid | a0-ff | 1 | 1 | 1
|
||||
*
|
||||
* (a) encoded as UTF-16 surrogate pair
|
||||
* (b) encoded as two hex digits
|
||||
*
|
||||
* Note that, while the UTF-8 encoding scheme can be extended to 5-byte, 6-byte
|
||||
* or even indefinite-byte sequences, the largest valid code point \u10ffff
|
||||
* encodes as only 4 UTF-8 bytes.
|
||||
*
|
||||
* Parameters:
|
||||
* wcs: wide char target buffer
|
||||
* utf: string to convert
|
||||
* wcslen: size of target buffer (in wchar_t's)
|
||||
* utflen: size of string to convert, or -1 if 0-terminated
|
||||
*
|
||||
* Returns:
|
||||
* length of converted string (_wcslen(wcs)), or -1 on failure
|
||||
*
|
||||
* Errors:
|
||||
* EINVAL: one of the input parameters is invalid (e.g. NULL)
|
||||
* ERANGE: the output buffer is too small
|
||||
*/
|
||||
int xutftowcsn(wchar_t *wcs, const char *utf, size_t wcslen, int utflen);
|
||||
|
||||
/**
|
||||
* Simplified variant of xutftowcsn, assumes input string is \0-terminated.
|
||||
*/
|
||||
static inline int xutftowcs(wchar_t *wcs, const char *utf, size_t wcslen)
|
||||
{
|
||||
return xutftowcsn(wcs, utf, wcslen, -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Simplified file system specific variant of xutftowcsn, assumes output
|
||||
* buffer size is MAX_PATH wide chars and input string is \0-terminated,
|
||||
* fails with ENAMETOOLONG if input string is too long.
|
||||
*/
|
||||
static inline int xutftowcs_path(wchar_t *wcs, const char *utf)
|
||||
{
|
||||
int result = xutftowcsn(wcs, utf, MAX_PATH, -1);
|
||||
if (result < 0 && errno == ERANGE)
|
||||
errno = ENAMETOOLONG;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts UTF-16LE encoded string to UTF-8.
|
||||
*
|
||||
* Maximum space requirement for the target buffer is three UTF-8 chars per
|
||||
* wide char ((_wcslen(wcs) * 3) + 1).
|
||||
*
|
||||
* The maximum space is needed only if the entire input string consists of
|
||||
* UTF-16 words in range 0x0800-0xd7ff or 0xe000-0xffff (i.e. \u0800-\uffff
|
||||
* modulo surrogate pairs), as per the following table:
|
||||
*
|
||||
* | | UTF-16 | UTF-8 |
|
||||
* Code point | UTF-16 sequence | words | bytes | ratio
|
||||
* --------------+-----------------------+--------+-------+-------
|
||||
* 000000-00007f | 0000-007f | 1 | 1 | 1
|
||||
* 000080-0007ff | 0080-07ff | 1 | 2 | 2
|
||||
* 000800-00ffff | 0800-d7ff / e000-ffff | 1 | 3 | 3
|
||||
* 010000-10ffff | d800-dbff + dc00-dfff | 2 | 4 | 2
|
||||
*
|
||||
* Note that invalid code points > 10ffff cannot be represented in UTF-16.
|
||||
*
|
||||
* Parameters:
|
||||
* utf: target buffer
|
||||
* wcs: wide string to convert
|
||||
* utflen: size of target buffer
|
||||
*
|
||||
* Returns:
|
||||
* length of converted string, or -1 on failure
|
||||
*
|
||||
* Errors:
|
||||
* EINVAL: one of the input parameters is invalid (e.g. NULL)
|
||||
* ERANGE: the output buffer is too small
|
||||
*/
|
||||
int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen);
|
||||
|
||||
/*
|
||||
* A critical section used in the implementation of the spawn
|
||||
* functions (mingw_spawnv[p]e()) and waitpid(). Intialised in
|
||||
|
||||
456
compat/winansi.c
456
compat/winansi.c
@ -2,15 +2,10 @@
|
||||
* Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
|
||||
*/
|
||||
|
||||
#undef NOGDI
|
||||
#include "../git-compat-util.h"
|
||||
|
||||
/*
|
||||
Functions to be wrapped:
|
||||
*/
|
||||
#undef printf
|
||||
#undef fprintf
|
||||
#undef fputs
|
||||
/* TODO: write */
|
||||
#include <wingdi.h>
|
||||
#include <winreg.h>
|
||||
|
||||
/*
|
||||
ANSI codes used by git: m, K
|
||||
@ -23,29 +18,114 @@ 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;
|
||||
|
||||
static void init(void)
|
||||
#ifdef __MINGW32__
|
||||
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
|
||||
|
||||
typedef BOOL (WINAPI *PGETCURRENTCONSOLEFONTEX)(HANDLE, BOOL,
|
||||
PCONSOLE_FONT_INFOEX);
|
||||
|
||||
static void warn_if_raster_font(void)
|
||||
{
|
||||
CONSOLE_SCREEN_BUFFER_INFO sbi;
|
||||
DWORD fontFamily = 0;
|
||||
PGETCURRENTCONSOLEFONTEX pGetCurrentConsoleFontEx;
|
||||
|
||||
static int initialized = 0;
|
||||
if (initialized)
|
||||
/* don't bother if output was ascii only */
|
||||
if (!non_ascii_used)
|
||||
return;
|
||||
|
||||
console = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
if (console == INVALID_HANDLE_VALUE)
|
||||
console = NULL;
|
||||
/* 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 (!console)
|
||||
return;
|
||||
|
||||
GetConsoleScreenBufferInfo(console, &sbi);
|
||||
attr = plain_attr = sbi.wAttributes;
|
||||
negative = 0;
|
||||
|
||||
initialized = 1;
|
||||
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)
|
||||
@ -90,18 +170,13 @@ static void erase_in_line(void)
|
||||
&dummy);
|
||||
}
|
||||
|
||||
|
||||
static const char *set_attr(const char *str)
|
||||
static void set_attr(char func, const int *params, int paramlen)
|
||||
{
|
||||
const char *func;
|
||||
size_t len = strspn(str, "0123456789;");
|
||||
func = str + len;
|
||||
|
||||
switch (*func) {
|
||||
int i;
|
||||
switch (func) {
|
||||
case 'm':
|
||||
do {
|
||||
long val = strtol(str, (char **)&str, 10);
|
||||
switch (val) {
|
||||
for (i = 0; i < paramlen; i++) {
|
||||
switch (params[i]) {
|
||||
case 0: /* reset */
|
||||
attr = plain_attr;
|
||||
negative = 0;
|
||||
@ -224,9 +299,7 @@ static const char *set_attr(const char *str)
|
||||
/* Unsupported code */
|
||||
break;
|
||||
}
|
||||
str++;
|
||||
} while (*(str-1) == ';');
|
||||
|
||||
}
|
||||
set_console_attr();
|
||||
break;
|
||||
case 'K':
|
||||
@ -236,122 +309,271 @@ static const char *set_attr(const char *str)
|
||||
/* Unsupported code */
|
||||
break;
|
||||
}
|
||||
|
||||
return func + 1;
|
||||
}
|
||||
|
||||
static int ansi_emulate(const char *str, FILE *stream)
|
||||
enum {
|
||||
TEXT = 0, ESCAPE = 033, BRACKET = '['
|
||||
};
|
||||
|
||||
static DWORD WINAPI console_thread(LPVOID unused)
|
||||
{
|
||||
int rv = 0;
|
||||
const char *pos = str;
|
||||
unsigned char buffer[BUFFER_SIZE];
|
||||
DWORD bytes;
|
||||
int start, end = 0, c, parampos = 0, state = TEXT;
|
||||
int params[MAX_PARAMS];
|
||||
|
||||
while (*pos) {
|
||||
pos = strstr(str, "\033[");
|
||||
if (pos) {
|
||||
size_t len = pos - str;
|
||||
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;
|
||||
}
|
||||
|
||||
if (len) {
|
||||
size_t out_len = fwrite(str, 1, len, stream);
|
||||
rv += out_len;
|
||||
if (out_len < len)
|
||||
return rv;
|
||||
/* 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;
|
||||
}
|
||||
|
||||
str = pos + 2;
|
||||
rv += 2;
|
||||
/* print remaining complete UTF-8 sequences */
|
||||
if (end > start)
|
||||
write_console(buffer + start, end - start);
|
||||
|
||||
fflush(stream);
|
||||
|
||||
pos = set_attr(str);
|
||||
rv += pos - str;
|
||||
str = pos;
|
||||
/* move remaining bytes to the front */
|
||||
if (end < bytes)
|
||||
memmove(buffer, buffer + end, bytes - end);
|
||||
end = bytes - end;
|
||||
} else {
|
||||
rv += strlen(str);
|
||||
fputs(str, stream);
|
||||
return rv;
|
||||
/* all data has been consumed, mark buffer empty */
|
||||
end = 0;
|
||||
}
|
||||
}
|
||||
return rv;
|
||||
|
||||
/* check if the console font supports unicode */
|
||||
warn_if_raster_font();
|
||||
|
||||
CloseHandle(hread);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int winansi_fputs(const char *str, FILE *stream)
|
||||
static void winansi_exit(void)
|
||||
{
|
||||
int rv;
|
||||
/* flush all streams */
|
||||
_flushall();
|
||||
|
||||
if (!isatty(fileno(stream)))
|
||||
return fputs(str, stream);
|
||||
/* signal console thread to exit */
|
||||
FlushFileBuffers(hwrite);
|
||||
DisconnectNamedPipe(hwrite);
|
||||
|
||||
init();
|
||||
/* wait for console thread to copy remaining data */
|
||||
WaitForSingleObject(hthread, INFINITE);
|
||||
|
||||
if (!console)
|
||||
return fputs(str, stream);
|
||||
|
||||
rv = ansi_emulate(str, stream);
|
||||
|
||||
if (rv >= 0)
|
||||
return 0;
|
||||
else
|
||||
return EOF;
|
||||
/* cleanup handles... */
|
||||
CloseHandle(hwrite);
|
||||
CloseHandle(hthread);
|
||||
}
|
||||
|
||||
static int winansi_vfprintf(FILE *stream, const char *format, va_list list)
|
||||
static void die_lasterr(const char *fmt, ...)
|
||||
{
|
||||
int len, rv;
|
||||
char small_buf[256];
|
||||
char *buf = small_buf;
|
||||
va_list cp;
|
||||
va_list params;
|
||||
va_start(params, fmt);
|
||||
errno = err_win_to_posix(GetLastError());
|
||||
die_errno(fmt, params);
|
||||
va_end(params);
|
||||
}
|
||||
|
||||
if (!isatty(fileno(stream)))
|
||||
goto abort;
|
||||
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) hnd);
|
||||
return hresult;
|
||||
}
|
||||
|
||||
init();
|
||||
|
||||
if (!console)
|
||||
goto abort;
|
||||
/*
|
||||
* 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;
|
||||
|
||||
va_copy(cp, list);
|
||||
len = vsnprintf(small_buf, sizeof(small_buf), format, cp);
|
||||
va_end(cp);
|
||||
extern __declspec(dllimport) ioinfo *__pioinfo[];
|
||||
|
||||
if (len > sizeof(small_buf) - 1) {
|
||||
buf = malloc(len + 1);
|
||||
if (!buf)
|
||||
goto abort;
|
||||
static size_t sizeof_ioinfo = 0;
|
||||
|
||||
len = vsnprintf(buf, len + 1, format, list);
|
||||
#define IOINFO_L2E 5
|
||||
#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
|
||||
|
||||
#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*);
|
||||
}
|
||||
|
||||
rv = ansi_emulate(buf, stream);
|
||||
|
||||
if (buf != small_buf)
|
||||
free(buf);
|
||||
return rv;
|
||||
|
||||
abort:
|
||||
rv = vfprintf(stream, format, list);
|
||||
return rv;
|
||||
error("Tweaking file descriptors doesn't work with this MSVCRT.dll");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int winansi_fprintf(FILE *stream, const char *format, ...)
|
||||
static HANDLE swap_osfhnd(int fd, HANDLE new_handle)
|
||||
{
|
||||
va_list list;
|
||||
int rv;
|
||||
ioinfo *pioinfo;
|
||||
HANDLE old_handle;
|
||||
|
||||
va_start(list, format);
|
||||
rv = winansi_vfprintf(stream, format, list);
|
||||
va_end(list);
|
||||
/* init ioinfo size if we haven't done so */
|
||||
if (init_sizeof_ioinfo())
|
||||
return INVALID_HANDLE_VALUE;
|
||||
|
||||
return rv;
|
||||
/* get ioinfo pointer and change the handles */
|
||||
pioinfo = _pioinfo(fd);
|
||||
old_handle = pioinfo->osfhnd;
|
||||
pioinfo->osfhnd = new_handle;
|
||||
return old_handle;
|
||||
}
|
||||
|
||||
int winansi_printf(const char *format, ...)
|
||||
void winansi_init(void)
|
||||
{
|
||||
va_list list;
|
||||
int rv;
|
||||
int con1, con2;
|
||||
char name[32];
|
||||
|
||||
va_start(list, format);
|
||||
rv = winansi_vfprintf(stdout, format, list);
|
||||
va_end(list);
|
||||
/* check if either stdout or stderr is a console output screen buffer */
|
||||
con1 = is_console(1);
|
||||
con2 = is_console(2);
|
||||
if (!con1 && !con2)
|
||||
return;
|
||||
|
||||
return rv;
|
||||
/* create a named pipe to communicate with the console thread */
|
||||
sprintf(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 ((fd == 1 || fd == 2) && isatty(fd)
|
||||
&& GetFileType(hnd) == FILE_TYPE_PIPE)
|
||||
return (fd == 1) ? hconsole1 : hconsole2;
|
||||
return hnd;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user