2 * Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
6 #include "../git-compat-util.h"
10 #include "win32/lazyload.h"
12 static int fd_is_interactive
[3] = { 0, 0, 0 };
13 #define FD_CONSOLE 0x1
14 #define FD_SWAPPED 0x2
18 ANSI codes used by git: m, K
20 This file is git-specific. Therefore, this file does not attempt
21 to implement any codes that are not used by git.
24 static HANDLE console
;
25 static WORD plain_attr
;
28 static int non_ascii_used
= 0;
29 static HANDLE hthread
, hread
, hwrite
;
30 static HANDLE hconsole1
, hconsole2
;
33 #if !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 5
34 typedef struct _CONSOLE_FONT_INFOEX
{
40 WCHAR FaceName
[LF_FACESIZE
];
41 } CONSOLE_FONT_INFOEX
, *PCONSOLE_FONT_INFOEX
;
45 static void warn_if_raster_font(void)
48 DECLARE_PROC_ADDR(kernel32
.dll
, BOOL
, WINAPI
,
49 GetCurrentConsoleFontEx
, HANDLE
, BOOL
,
50 PCONSOLE_FONT_INFOEX
);
52 /* don't bother if output was ascii only */
56 /* GetCurrentConsoleFontEx is available since Vista */
57 if (INIT_PROC_ADDR(GetCurrentConsoleFontEx
)) {
58 CONSOLE_FONT_INFOEX cfi
;
59 cfi
.cbSize
= sizeof(cfi
);
60 if (GetCurrentConsoleFontEx(console
, 0, &cfi
))
61 fontFamily
= cfi
.FontFamily
;
63 /* pre-Vista: check default console font in registry */
65 if (ERROR_SUCCESS
== RegOpenKeyExA(HKEY_CURRENT_USER
, "Console",
66 0, KEY_READ
, &hkey
)) {
67 DWORD size
= sizeof(fontFamily
);
68 RegQueryValueExA(hkey
, "FontFamily", NULL
, NULL
,
69 (LPVOID
) &fontFamily
, &size
);
74 if (!(fontFamily
& TMPF_TRUETYPE
)) {
75 const wchar_t *msg
= L
"\nWarning: Your console font probably "
76 L
"doesn\'t support Unicode. If you experience strange "
77 L
"characters in the output, consider switching to a "
78 L
"TrueType font such as Consolas!\n";
80 WriteConsoleW(console
, msg
, wcslen(msg
), &dummy
, NULL
);
84 static int is_console(int fd
)
86 CONSOLE_SCREEN_BUFFER_INFO sbi
;
90 static int initialized
= 0;
92 /* get OS handle of the file descriptor */
93 hcon
= (HANDLE
) _get_osfhandle(fd
);
94 if (hcon
== INVALID_HANDLE_VALUE
)
97 /* check if its a device (i.e. console, printer, serial port) */
98 if (GetFileType(hcon
) != FILE_TYPE_CHAR
)
101 /* check if its a handle to a console output screen buffer */
103 if (!GetConsoleMode(hcon
, &mode
))
106 * This code path is only reached if there is no console
107 * attached to stdout/stderr, i.e. we will not need to output
108 * any text to any console, therefore we might just as well
109 * use black as foreground color.
112 } else if (!GetConsoleScreenBufferInfo(hcon
, &sbi
))
115 if (fd
>= 0 && fd
<= 2)
116 fd_is_interactive
[fd
] |= FD_CONSOLE
;
118 /* initialize attributes */
121 attr
= plain_attr
= sbi
.wAttributes
;
129 #define BUFFER_SIZE 4096
130 #define MAX_PARAMS 16
132 static void write_console(unsigned char *str
, size_t len
)
134 /* only called from console_thread, so a static buffer will do */
135 static wchar_t wbuf
[2 * BUFFER_SIZE
+ 1];
138 /* convert utf-8 to utf-16 */
139 int wlen
= xutftowcsn(wbuf
, (char*) str
, ARRAY_SIZE(wbuf
), len
);
141 wchar_t *err
= L
"[invalid]";
142 WriteConsoleW(console
, err
, wcslen(err
), &dummy
, NULL
);
146 /* write directly to console */
147 WriteConsoleW(console
, wbuf
, wlen
, &dummy
, NULL
);
149 /* remember if non-ascii characters are printed */
154 #define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
155 #define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
157 static void set_console_attr(void)
159 WORD attributes
= attr
;
161 attributes
&= ~FOREGROUND_ALL
;
162 attributes
&= ~BACKGROUND_ALL
;
164 /* This could probably use a bitmask
165 instead of a series of ifs */
166 if (attr
& FOREGROUND_RED
)
167 attributes
|= BACKGROUND_RED
;
168 if (attr
& FOREGROUND_GREEN
)
169 attributes
|= BACKGROUND_GREEN
;
170 if (attr
& FOREGROUND_BLUE
)
171 attributes
|= BACKGROUND_BLUE
;
173 if (attr
& BACKGROUND_RED
)
174 attributes
|= FOREGROUND_RED
;
175 if (attr
& BACKGROUND_GREEN
)
176 attributes
|= FOREGROUND_GREEN
;
177 if (attr
& BACKGROUND_BLUE
)
178 attributes
|= FOREGROUND_BLUE
;
180 SetConsoleTextAttribute(console
, attributes
);
183 static void erase_in_line(void)
185 CONSOLE_SCREEN_BUFFER_INFO sbi
;
186 DWORD dummy
; /* Needed for Windows 7 (or Vista) regression */
191 GetConsoleScreenBufferInfo(console
, &sbi
);
192 FillConsoleOutputCharacterA(console
, ' ',
193 sbi
.dwSize
.X
- sbi
.dwCursorPosition
.X
, sbi
.dwCursorPosition
,
197 static void set_attr(char func
, const int *params
, int paramlen
)
202 for (i
= 0; i
< paramlen
; i
++) {
209 attr
|= FOREGROUND_INTENSITY
;
212 case 22: /* normal */
213 attr
&= ~FOREGROUND_INTENSITY
;
218 case 4: /* underline */
219 case 21: /* double underline */
220 /* Wikipedia says this flag does nothing */
221 /* Furthermore, mingw doesn't define this flag
222 attr |= COMMON_LVB_UNDERSCORE; */
224 case 24: /* no underline */
225 /* attr &= ~COMMON_LVB_UNDERSCORE; */
227 case 5: /* slow blink */
228 case 6: /* fast blink */
229 /* We don't have blink, but we do have
230 background intensity */
231 attr
|= BACKGROUND_INTENSITY
;
233 case 25: /* no blink */
234 attr
&= ~BACKGROUND_INTENSITY
;
236 case 7: /* negative */
239 case 27: /* positive */
242 case 8: /* conceal */
243 case 28: /* reveal */
247 attr
&= ~FOREGROUND_ALL
;
250 attr
&= ~FOREGROUND_ALL
;
251 attr
|= FOREGROUND_RED
;
254 attr
&= ~FOREGROUND_ALL
;
255 attr
|= FOREGROUND_GREEN
;
257 case 33: /* Yellow */
258 attr
&= ~FOREGROUND_ALL
;
259 attr
|= FOREGROUND_RED
| FOREGROUND_GREEN
;
262 attr
&= ~FOREGROUND_ALL
;
263 attr
|= FOREGROUND_BLUE
;
265 case 35: /* Magenta */
266 attr
&= ~FOREGROUND_ALL
;
267 attr
|= FOREGROUND_RED
| FOREGROUND_BLUE
;
270 attr
&= ~FOREGROUND_ALL
;
271 attr
|= FOREGROUND_GREEN
| FOREGROUND_BLUE
;
274 attr
|= FOREGROUND_RED
|
278 case 38: /* Unknown */
281 attr
&= ~FOREGROUND_ALL
;
282 attr
|= (plain_attr
& FOREGROUND_ALL
);
285 attr
&= ~BACKGROUND_ALL
;
288 attr
&= ~BACKGROUND_ALL
;
289 attr
|= BACKGROUND_RED
;
292 attr
&= ~BACKGROUND_ALL
;
293 attr
|= BACKGROUND_GREEN
;
295 case 43: /* Yellow */
296 attr
&= ~BACKGROUND_ALL
;
297 attr
|= BACKGROUND_RED
| BACKGROUND_GREEN
;
300 attr
&= ~BACKGROUND_ALL
;
301 attr
|= BACKGROUND_BLUE
;
303 case 45: /* Magenta */
304 attr
&= ~BACKGROUND_ALL
;
305 attr
|= BACKGROUND_RED
| BACKGROUND_BLUE
;
308 attr
&= ~BACKGROUND_ALL
;
309 attr
|= BACKGROUND_GREEN
| BACKGROUND_BLUE
;
312 attr
|= BACKGROUND_RED
|
316 case 48: /* Unknown */
319 attr
&= ~BACKGROUND_ALL
;
320 attr
|= (plain_attr
& BACKGROUND_ALL
);
323 /* Unsupported code */
333 /* Unsupported code */
339 TEXT
= 0, ESCAPE
= 033, BRACKET
= '['
342 static DWORD WINAPI
console_thread(LPVOID unused
)
344 unsigned char buffer
[BUFFER_SIZE
];
346 int start
, end
= 0, c
, parampos
= 0, state
= TEXT
;
347 int params
[MAX_PARAMS
];
350 /* read next chunk of bytes from the pipe */
351 if (!ReadFile(hread
, buffer
+ end
, BUFFER_SIZE
- end
, &bytes
,
353 /* exit if pipe has been closed or disconnected */
354 if (GetLastError() == ERROR_PIPE_NOT_CONNECTED
||
355 GetLastError() == ERROR_BROKEN_PIPE
)
357 /* ignore other errors */
361 /* scan the bytes and handle ANSI control codes */
364 while (end
< bytes
) {
369 /* print text seen so far */
371 write_console(buffer
+ start
,
374 /* then start parsing escape sequence */
376 memset(params
, 0, sizeof(params
));
383 /* continue if "\033[", otherwise bail out */
384 state
= (c
== BRACKET
) ? BRACKET
: TEXT
;
388 /* parse [0-9;]* into array of parameters */
389 if (c
>= '0' && c
<= '9') {
390 params
[parampos
] *= 10;
391 params
[parampos
] += c
- '0';
392 } else if (c
== ';') {
394 * next parameter, bail out if out of
398 if (parampos
>= MAX_PARAMS
)
402 * end of escape sequence, change
405 set_attr(c
, params
, parampos
+ 1);
413 /* print remaining text unless parsing an escape sequence */
414 if (state
== TEXT
&& end
> start
) {
415 /* check for incomplete UTF-8 sequences and fix end */
416 if (buffer
[end
- 1] >= 0x80) {
417 if (buffer
[end
-1] >= 0xc0)
419 else if (end
- 1 > start
&&
420 buffer
[end
- 2] >= 0xe0)
422 else if (end
- 2 > start
&&
423 buffer
[end
- 3] >= 0xf0)
427 /* print remaining complete UTF-8 sequences */
429 write_console(buffer
+ start
, end
- start
);
431 /* move remaining bytes to the front */
433 memmove(buffer
, buffer
+ end
, bytes
- end
);
436 /* all data has been consumed, mark buffer empty */
441 /* check if the console font supports unicode */
442 warn_if_raster_font();
448 static void winansi_exit(void)
450 /* flush all streams */
453 /* signal console thread to exit */
454 FlushFileBuffers(hwrite
);
455 DisconnectNamedPipe(hwrite
);
457 /* wait for console thread to copy remaining data */
458 WaitForSingleObject(hthread
, INFINITE
);
460 /* cleanup handles... */
462 CloseHandle(hthread
);
465 static void die_lasterr(const char *fmt
, ...)
468 va_start(params
, fmt
);
469 errno
= err_win_to_posix(GetLastError());
470 die_errno(fmt
, params
);
475 int winansi_dup2(int oldfd
, int newfd
)
477 int ret
= dup2(oldfd
, newfd
);
479 if (!ret
&& newfd
>= 0 && newfd
<= 2)
480 fd_is_interactive
[newfd
] = oldfd
< 0 || oldfd
> 2 ?
481 0 : fd_is_interactive
[oldfd
];
486 static HANDLE
duplicate_handle(HANDLE hnd
)
488 HANDLE hresult
, hproc
= GetCurrentProcess();
489 if (!DuplicateHandle(hproc
, hnd
, hproc
, &hresult
, 0, TRUE
,
490 DUPLICATE_SAME_ACCESS
))
491 die_lasterr("DuplicateHandle(%li) failed",
492 (long) (intptr_t) hnd
);
496 static HANDLE
swap_osfhnd(int fd
, HANDLE new_handle
)
499 * Create a copy of the original handle associated with fd
500 * because the original will get closed when we dup2().
502 HANDLE handle
= (HANDLE
)_get_osfhandle(fd
);
503 HANDLE duplicate
= duplicate_handle(handle
);
505 /* Create a temp fd associated with the already open "new_handle". */
506 int new_fd
= _open_osfhandle((intptr_t)new_handle
, O_BINARY
);
508 assert((fd
== 1) || (fd
== 2));
511 * Use stock dup2() to re-bind fd to the new handle. Note that
512 * this will implicitly close(1) and close both fd=1 and the
513 * originally associated handle. It will open a new fd=1 and
514 * call DuplicateHandle() on the handle associated with new_fd.
515 * It is because of this implicit close() that we created the
516 * copy of the original.
518 * Note that we need to update the cached console handle to the
519 * duplicated one because the dup2() call will implicitly close
522 * Note that dup2() when given target := {0,1,2} will also
523 * call SetStdHandle(), so we don't need to worry about that.
525 if (console
== handle
)
529 /* Close the temp fd. This explicitly closes "new_handle"
530 * (because it has been associated with it).
535 setvbuf(stderr
, NULL
, _IONBF
, BUFSIZ
);
536 fd_is_interactive
[fd
] |= FD_SWAPPED
;
541 #ifdef DETECT_MSYS_TTY
543 #include <winternl.h>
545 #if defined(_MSC_VER)
547 typedef struct _OBJECT_NAME_INFORMATION
550 WCHAR NameBuffer
[FLEX_ARRAY
];
551 } OBJECT_NAME_INFORMATION
, *POBJECT_NAME_INFORMATION
;
553 #define ObjectNameInformation 1
556 #include <ntstatus.h>
559 static void detect_msys_tty(int fd
)
563 POBJECT_NAME_INFORMATION nameinfo
= (POBJECT_NAME_INFORMATION
) buffer
;
566 /* check if fd is a pipe */
567 HANDLE h
= (HANDLE
) _get_osfhandle(fd
);
568 if (GetFileType(h
) != FILE_TYPE_PIPE
)
572 if (!NT_SUCCESS(NtQueryObject(h
, ObjectNameInformation
,
573 buffer
, sizeof(buffer
) - 2, &result
)))
575 name
= nameinfo
->Name
.Buffer
;
576 name
[nameinfo
->Name
.Length
/ sizeof(*name
)] = 0;
579 * Check if this could be a MSYS2 pty pipe ('msys-XXXX-ptyN-XX')
580 * or a cygwin pty pipe ('cygwin-XXXX-ptyN-XX')
582 if ((!wcsstr(name
, L
"msys-") && !wcsstr(name
, L
"cygwin-")) ||
583 !wcsstr(name
, L
"-pty"))
587 setvbuf(stderr
, NULL
, _IONBF
, BUFSIZ
);
588 fd_is_interactive
[fd
] |= FD_MSYS
;
594 * Wrapper for isatty(). Most calls in the main git code
595 * call isatty(1 or 2) to see if the instance is interactive
596 * and should: be colored, show progress, paginate output.
597 * We lie and give results for what the descriptor WAS at
598 * startup (and ignore any pipe redirection we internally
602 int winansi_isatty(int fd
)
604 if (fd
>= 0 && fd
<= 2)
605 return fd_is_interactive
[fd
] != 0;
609 void winansi_init(void)
614 /* check if either stdout or stderr is a console output screen buffer */
615 con1
= is_console(1);
616 con2
= is_console(2);
618 /* Also compute console bit for fd 0 even though we don't need the result here. */
621 if (!con1
&& !con2
) {
622 #ifdef DETECT_MSYS_TTY
623 /* check if stdin / stdout / stderr are MSYS2 pty pipes */
631 /* create a named pipe to communicate with the console thread */
632 if (swprintf(name
, ARRAY_SIZE(name
) - 1, L
"\\\\.\\pipe\\winansi%lu",
633 GetCurrentProcessId()) < 0)
634 die("Could not initialize winansi pipe name");
635 hwrite
= CreateNamedPipeW(name
, PIPE_ACCESS_OUTBOUND
,
636 PIPE_TYPE_BYTE
| PIPE_WAIT
, 1, BUFFER_SIZE
, 0, 0, NULL
);
637 if (hwrite
== INVALID_HANDLE_VALUE
)
638 die_lasterr("CreateNamedPipe failed");
640 hread
= CreateFileW(name
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
641 if (hread
== INVALID_HANDLE_VALUE
)
642 die_lasterr("CreateFile for named pipe failed");
644 /* start console spool thread on the pipe's read end */
645 hthread
= CreateThread(NULL
, 0, console_thread
, NULL
, 0, NULL
);
646 if (hthread
== INVALID_HANDLE_VALUE
)
647 die_lasterr("CreateThread(console_thread) failed");
649 /* schedule cleanup routine */
650 if (atexit(winansi_exit
))
651 die_errno("atexit(winansi_exit) failed");
653 /* redirect stdout / stderr to the pipe */
655 hconsole1
= swap_osfhnd(1, duplicate_handle(hwrite
));
657 hconsole2
= swap_osfhnd(2, duplicate_handle(hwrite
));
661 * Returns the real console handle if stdout / stderr is a pipe redirecting
662 * to the console. Allows spawn / exec to pass the console to the next process.
664 HANDLE
winansi_get_osfhandle(int fd
)
668 if (fd
== 1 && (fd_is_interactive
[1] & FD_SWAPPED
))
670 if (fd
== 2 && (fd_is_interactive
[2] & FD_SWAPPED
))
673 ret
= (HANDLE
)_get_osfhandle(fd
);
676 * There are obviously circumstances under which _get_osfhandle()
677 * returns (HANDLE)-2. This is not documented anywhere, but that is so
678 * clearly an invalid handle value that we can just work around this
679 * and return the correct value for invalid handles.
681 return ret
== (HANDLE
)-2 ? INVALID_HANDLE_VALUE
: ret
;