authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-05-28 12:31:10-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-05-28 12:31:10-07:00
log3a3d2187f986066859cfb793fb7ee1cae4dfea08
tree950c39722d71cdd6f2af75c255ee92a318cda516
parent40afac40b8d9f274d63448a11f9f4259a1f68528

std.Progress: better Windows support

* Merge a bunch of related state together into TerminalMode. Windows sometimes follows the same path as posix via ansi_escape_codes, sometimes not. * Use a different thread entry point for Windows API but share the same entry point on Windows when the terminal is in ansi_escape_codes mode. * Only clear the terminal when the stderr lock is held. * Don't try to clear the terminal when nothing has been written yet. * Don't try to clear the terminal in IPC mode. * Fix size detection logic bug under error conditions.

1 files changed, 115 insertions(+), 101 deletions(-)

lib/std/Progress.zig+115-101
......@@ -8,19 +8,13 @@ const assert = std.debug.assert;
88const Progress = @This();
99const posix = std.posix;
1010const is_big_endian = builtin.cpu.arch.endian() == .big;
11const is_windows = builtin.os.tag == .windows;
1112
1213/// `null` if the current node (and its children) should
1314/// not print on update()
14terminal: ?std.fs.File,
15terminal: std.fs.File,
1516
16/// Is this a windows API terminal (note: this is not the same as being run on windows
17/// because other terminals exist like MSYS/git-bash)
18is_windows_terminal: bool,
19/// The output code page of the console (only set if the console is a Windows API terminal)
20console_code_page: if (builtin.os.tag == .windows) windows.UINT else void,
21
22/// Whether the terminal supports ANSI escape codes.
23supports_ansi_escape_codes: bool,
17terminal_mode: TerminalMode,
2418
2519update_thread: ?std.Thread,
2620
......@@ -53,6 +47,19 @@ node_freelist: []Node.OptionalIndex,
5347node_freelist_first: Node.OptionalIndex,
5448node_end_index: u32,
5549
50pub const TerminalMode = union(enum) {
51 off,
52 ansi_escape_codes,
53 /// This is not the same as being run on windows because other terminals
54 /// exist like MSYS/git-bash.
55 windows_api: if (is_windows) WindowsApi else void,
56
57 pub const WindowsApi = struct {
58 /// The output code page of the console.
59 code_page: windows.UINT,
60 };
61};
62
5663pub const Options = struct {
5764 /// User-provided buffer with static lifetime.
5865 ///
......@@ -297,10 +304,8 @@ pub const Node = struct {
297304};
298305
299306var global_progress: Progress = .{
300 .terminal = null,
301 .is_windows_terminal = false,
302 .console_code_page = if (builtin.os.tag == .windows) undefined else {},
303 .supports_ansi_escape_codes = false,
307 .terminal = undefined,
308 .terminal_mode = .off,
304309 .update_thread = null,
305310 .redraw_event = .{},
306311 .refresh_rate_ns = undefined,
......@@ -376,20 +381,16 @@ pub fn start(options: Options) Node {
376381 return .{ .index = .none };
377382 }
378383 const stderr = std.io.getStdErr();
384 global_progress.terminal = stderr;
379385 if (stderr.supportsAnsiEscapeCodes()) {
380 global_progress.terminal = stderr;
381 global_progress.supports_ansi_escape_codes = true;
382 } else if (builtin.os.tag == .windows and stderr.isTty()) {
383 global_progress.is_windows_terminal = true;
384 global_progress.console_code_page = windows.kernel32.GetConsoleOutputCP();
385 global_progress.terminal = stderr;
386 } else if (builtin.os.tag != .windows) {
387 // we are in a "dumb" terminal like in acme or writing to a file
388 global_progress.terminal = stderr;
386 global_progress.terminal_mode = .ansi_escape_codes;
387 } else if (is_windows and stderr.isTty()) {
388 global_progress.terminal_mode = TerminalMode{ .windows_api = .{
389 .code_page = windows.kernel32.GetConsoleOutputCP(),
390 } };
389391 }
390392
391 const can_clear_terminal = global_progress.supports_ansi_escape_codes or global_progress.is_windows_terminal;
392 if (global_progress.terminal == null or !can_clear_terminal) {
393 if (global_progress.terminal_mode == .off) {
393394 return .{ .index = .none };
394395 }
395396
......@@ -404,7 +405,11 @@ pub fn start(options: Options) Node {
404405 };
405406 }
406407
407 if (std.Thread.spawn(.{}, updateThreadRun, .{})) |thread| {
408 if (switch (global_progress.terminal_mode) {
409 .off => unreachable, // handled a few lines above
410 .ansi_escape_codes => std.Thread.spawn(.{}, updateThreadRun, .{}),
411 .windows_api => if (is_windows) std.Thread.spawn(.{}, windowsApiUpdateThreadRun, .{}) else unreachable,
412 }) |thread| {
408413 global_progress.update_thread = thread;
409414 } else |err| {
410415 std.log.warn("unable to spawn thread for printing progress to terminal: {s}", .{@errorName(err)});
......@@ -438,13 +443,42 @@ fn updateThreadRun() void {
438443
439444 {
440445 const resize_flag = wait(global_progress.initial_delay_ns);
446 if (@atomicLoad(bool, &global_progress.done, .seq_cst)) return;
441447 maybeUpdateSize(resize_flag);
442448
449 const buffer = computeRedraw(&serialized_buffer);
450 if (stderr_mutex.tryLock()) {
451 defer stderr_mutex.unlock();
452 write(buffer) catch return;
453 }
454 }
455
456 while (true) {
457 const resize_flag = wait(global_progress.refresh_rate_ns);
458
443459 if (@atomicLoad(bool, &global_progress.done, .seq_cst)) {
444460 stderr_mutex.lock();
445461 defer stderr_mutex.unlock();
446 return clearTerminal();
462 return clearWrittenWithEscapeCodes() catch {};
463 }
464
465 maybeUpdateSize(resize_flag);
466
467 const buffer = computeRedraw(&serialized_buffer);
468 if (stderr_mutex.tryLock()) {
469 defer stderr_mutex.unlock();
470 write(buffer) catch return;
447471 }
472 }
473}
474
475fn windowsApiUpdateThreadRun() void {
476 var serialized_buffer: Serialized.Buffer = undefined;
477
478 {
479 const resize_flag = wait(global_progress.initial_delay_ns);
480 if (@atomicLoad(bool, &global_progress.done, .seq_cst)) return;
481 maybeUpdateSize(resize_flag);
448482
449483 const buffer = computeRedraw(&serialized_buffer);
450484 if (stderr_mutex.tryLock()) {
......@@ -455,17 +489,19 @@ fn updateThreadRun() void {
455489
456490 while (true) {
457491 const resize_flag = wait(global_progress.refresh_rate_ns);
458 maybeUpdateSize(resize_flag);
459492
460493 if (@atomicLoad(bool, &global_progress.done, .seq_cst)) {
461494 stderr_mutex.lock();
462495 defer stderr_mutex.unlock();
463 return clearTerminal();
496 return clearWrittenWindowsApi() catch {};
464497 }
465498
499 maybeUpdateSize(resize_flag);
500
466501 const buffer = computeRedraw(&serialized_buffer);
467502 if (stderr_mutex.tryLock()) {
468503 defer stderr_mutex.unlock();
504 clearWrittenWindowsApi() catch return;
469505 write(buffer) catch return;
470506 }
471507 }
......@@ -476,7 +512,7 @@ fn updateThreadRun() void {
476512/// During the lock, any `std.Progress` information is cleared from the terminal.
477513pub fn lockStdErr() void {
478514 stderr_mutex.lock();
479 clearTerminal();
515 clearWrittenWithEscapeCodes() catch {};
480516}
481517
482518pub fn unlockStdErr() void {
......@@ -504,7 +540,7 @@ fn ipcThreadRun(fd: posix.fd_t) anyerror!void {
504540 _ = wait(global_progress.refresh_rate_ns);
505541
506542 if (@atomicLoad(bool, &global_progress.done, .seq_cst))
507 return clearTerminal();
543 return;
508544
509545 const serialized = serialize(&serialized_buffer);
510546 writeIpc(fd, serialized) catch |err| switch (err) {
......@@ -569,41 +605,36 @@ const TreeSymbol = enum {
569605 var max: usize = 0;
570606 inline for (@typeInfo(Encoding).Enum.fields) |field| {
571607 const len = symbol.bytes(@field(Encoding, field.name)).len;
572 if (len > max) max = len;
608 max = @max(max, len);
573609 }
574610 return max;
575611 }
576612};
577613
578fn appendTreeSymbol(comptime symbol: TreeSymbol, buf: []u8, start_i: usize) usize {
579 if (builtin.os.tag == .windows and global_progress.is_windows_terminal) {
580 const bytes = switch (global_progress.console_code_page) {
581 // Code page 437 is the default code page and contains the box drawing symbols
582 437 => symbol.bytes(.code_page_437),
583 // UTF-8
584 65001 => symbol.bytes(.utf8),
585 // Fall back to ASCII approximation
586 else => symbol.bytes(.ascii),
587 };
588 @memcpy(buf[start_i..][0..bytes.len], bytes);
589 return start_i + bytes.len;
614fn appendTreeSymbol(symbol: TreeSymbol, buf: []u8, start_i: usize) usize {
615 switch (global_progress.terminal_mode) {
616 .off => unreachable,
617 .ansi_escape_codes => {
618 const bytes = symbol.escapeSeq();
619 buf[start_i..][0..bytes.len].* = bytes.*;
620 return start_i + bytes.len;
621 },
622 .windows_api => |windows_api| {
623 const bytes = if (!is_windows) unreachable else switch (windows_api.code_page) {
624 // Code page 437 is the default code page and contains the box drawing symbols
625 437 => symbol.bytes(.code_page_437),
626 // UTF-8
627 65001 => symbol.bytes(.utf8),
628 // Fall back to ASCII approximation
629 else => symbol.bytes(.ascii),
630 };
631 @memcpy(buf[start_i..][0..bytes.len], bytes);
632 return start_i + bytes.len;
633 },
590634 }
591
592 // Drawing the tree is disabled when ansi escape codes are not supported
593 assert(global_progress.supports_ansi_escape_codes);
594
595 const bytes = symbol.escapeSeq();
596 buf[start_i..][0..bytes.len].* = bytes.*;
597 return start_i + bytes.len;
598635}
599636
600fn clearTerminal() void {
601 if (builtin.os.tag == .windows and global_progress.is_windows_terminal) {
602 return clearTerminalWindowsApi() catch {
603 global_progress.terminal = null;
604 };
605 }
606
637fn clearWrittenWithEscapeCodes() anyerror!void {
607638 if (global_progress.written_newline_count == 0) return;
608639
609640 var i: usize = 0;
......@@ -618,9 +649,7 @@ fn clearTerminal() void {
618649 i += finish_sync.len;
619650
620651 global_progress.accumulated_newline_count = 0;
621 write(buf[0..i]) catch {
622 global_progress.terminal = null;
623 };
652 try write(buf[0..i]);
624653}
625654
626655fn computeClear(buf: []u8, start_i: usize) usize {
......@@ -645,7 +674,7 @@ fn computeClear(buf: []u8, start_i: usize) usize {
645674/// U+25BA or ►
646675const windows_api_start_marker = 0x25BA;
647676
648fn clearTerminalWindowsApi() error{Unexpected}!void {
677fn clearWrittenWindowsApi() error{Unexpected}!void {
649678 // This uses a 'marker' strategy. The idea is:
650679 // - Always write a marker (in this case U+25BA or ►) at the beginning of the progress
651680 // - Get the current cursor position (at the end of the progress)
......@@ -667,7 +696,7 @@ fn clearTerminalWindowsApi() error{Unexpected}!void {
667696 // like any of the available attributes are invisible/benign.
668697 const prev_nl_n = global_progress.written_newline_count;
669698 if (prev_nl_n > 0) {
670 const handle = (global_progress.terminal orelse return).handle;
699 const handle = global_progress.terminal.handle;
671700 const screen_area = @as(windows.DWORD, global_progress.cols) * global_progress.rows;
672701
673702 var console_info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
......@@ -777,14 +806,14 @@ const SavedMetadata = struct {
777806 nodes_len: u8,
778807
779808 fn getIpcFd(metadata: SavedMetadata) posix.fd_t {
780 return if (builtin.os.tag == .windows)
809 return if (is_windows)
781810 @ptrFromInt(@as(usize, metadata.ipc_fd) << 2)
782811 else
783812 metadata.ipc_fd;
784813 }
785814
786815 fn setIpcFd(fd: posix.fd_t) u16 {
787 return @intCast(if (builtin.os.tag == .windows)
816 return @intCast(if (is_windows)
788817 @shrExact(@intFromPtr(fd), 2)
789818 else
790819 fd);
......@@ -1019,35 +1048,21 @@ fn computeRedraw(serialized_buffer: *Serialized.Buffer) []u8 {
10191048 var i: usize = 0;
10201049 const buf = global_progress.draw_buffer;
10211050
1022 if (global_progress.supports_ansi_escape_codes) {
1023 buf[i..][0..start_sync.len].* = start_sync.*;
1024 i += start_sync.len;
1025
1026 i = computeClear(buf, i);
1027 } else if (builtin.os.tag == .windows and global_progress.is_windows_terminal) {
1028 clearTerminalWindowsApi() catch {
1029 global_progress.terminal = null;
1030 return buf[0..0];
1031 };
1051 buf[i..][0..start_sync.len].* = start_sync.*;
1052 i += start_sync.len;
10321053
1033 // Write the marker that we will use to find the beginning of the progress when clearing.
1034 // Note: This doesn't have to use WriteConsoleW, but doing so avoids dealing with the code page.
1035 var num_chars_written: windows.DWORD = undefined;
1036 const handle = (global_progress.terminal orelse return buf[0..0]).handle;
1037 if (windows.kernel32.WriteConsoleW(handle, &[_]u16{windows_api_start_marker}, 1, &num_chars_written, null) == 0) {
1038 global_progress.terminal = null;
1039 return buf[0..0];
1040 }
1054 switch (global_progress.terminal_mode) {
1055 .off => unreachable,
1056 .ansi_escape_codes => i = computeClear(buf, i),
1057 .windows_api => if (!is_windows) unreachable,
10411058 }
10421059
10431060 global_progress.accumulated_newline_count = 0;
10441061 const root_node_index: Node.Index = @enumFromInt(0);
10451062 i = computeNode(buf, i, serialized, children, root_node_index);
10461063
1047 if (global_progress.supports_ansi_escape_codes) {
1048 buf[i..][0..finish_sync.len].* = finish_sync.*;
1049 i += finish_sync.len;
1050 }
1064 buf[i..][0..finish_sync.len].* = finish_sync.*;
1065 i += finish_sync.len;
10511066
10521067 return buf[0..i];
10531068}
......@@ -1075,15 +1090,15 @@ fn computePrefix(
10751090 buf[i..][0..prefix.len].* = prefix.*;
10761091 i += prefix.len;
10771092 } else {
1078 const upper_bound_len = TreeSymbol.line.maxByteLen() + line_upper_bound_len;
1093 const upper_bound_len = comptime (TreeSymbol.line.maxByteLen() + line_upper_bound_len);
10791094 if (i + upper_bound_len > buf.len) return buf.len;
10801095 i = appendTreeSymbol(.line, buf, i);
10811096 }
10821097 return i;
10831098}
10841099
1085const line_upper_bound_len = @max(TreeSymbol.tee.maxByteLen(), TreeSymbol.langle.maxByteLen()) + "[4294967296/4294967296] ".len +
1086 Node.max_name_len + finish_sync.len;
1100const line_upper_bound_len = @max(TreeSymbol.tee.maxByteLen(), TreeSymbol.langle.maxByteLen()) +
1101 "[4294967296/4294967296] ".len + Node.max_name_len + finish_sync.len;
10871102
10881103fn computeNode(
10891104 buf: []u8,
......@@ -1157,8 +1172,7 @@ fn withinRowLimit(p: *Progress) bool {
11571172}
11581173
11591174fn write(buf: []const u8) anyerror!void {
1160 const tty = global_progress.terminal orelse return;
1161 try tty.writeAll(buf);
1175 try global_progress.terminal.writeAll(buf);
11621176 global_progress.written_newline_count = global_progress.accumulated_newline_count;
11631177}
11641178
......@@ -1218,23 +1232,23 @@ fn writeIpc(fd: posix.fd_t, serialized: Serialized) error{BrokenPipe}!void {
12181232fn maybeUpdateSize(resize_flag: bool) void {
12191233 if (!resize_flag) return;
12201234
1221 const fd = (global_progress.terminal orelse return).handle;
1235 const fd = global_progress.terminal.handle;
12221236
1223 if (builtin.os.tag == .windows) {
1237 if (is_windows) {
12241238 var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
12251239
1226 if (windows.kernel32.GetConsoleScreenBufferInfo(fd, &info) == windows.FALSE) {
1240 if (windows.kernel32.GetConsoleScreenBufferInfo(fd, &info) != windows.FALSE) {
1241 // In the old Windows console, dwSize.Y is the line count of the
1242 // entire scrollback buffer, so we use this instead so that we
1243 // always get the size of the screen.
1244 const screen_height = info.srWindow.Bottom - info.srWindow.Top;
1245 global_progress.rows = @intCast(screen_height);
1246 global_progress.cols = @intCast(info.dwSize.X);
1247 } else {
12271248 std.log.debug("failed to determine terminal size; using conservative guess 80x25", .{});
12281249 global_progress.rows = 25;
12291250 global_progress.cols = 80;
12301251 }
1231
1232 // In the old Windows console, dwSize.Y is the line count of the entire
1233 // scrollback buffer, so we use this instead so that we always get the
1234 // size of the screen.
1235 const screen_height = info.srWindow.Bottom - info.srWindow.Top;
1236 global_progress.rows = @intCast(screen_height);
1237 global_progress.cols = @intCast(info.dwSize.X);
12381252 } else {
12391253 var winsize: posix.winsize = .{
12401254 .ws_row = 0,