std.os.windows: UTF-16 to UTF-8 conversion for Windows console input (cooked mode only)

Author: Prcuvu

lib/std/os.zig

@@ -3185,8 +3185,7 @@ pub fn isatty(handle: fd_t) bool {
         if (isCygwinPty(handle))
             return true;
 
-        var out: windows.DWORD = undefined;
-        return windows.kernel32.GetConsoleMode(handle, &out) != 0;
+        return windows.IsConsoleHandle(handle);
     }
     if (builtin.link_libc) {
         return system.isatty(handle) != 0;

lib/std/os/windows.zig

@@ -446,7 +446,7 @@ pub fn GetQueuedCompletionStatusEx(
 pub fn CloseHandle(hObject: HANDLE) void {
     assert(ntdll.NtClose(hObject) == .SUCCESS);
     if (IsConsoleHandle(hObject)) {
-        _ = RemoveConsoleHandleData(hObject) catch {};
+        _ = removeConsoleHandleData(hObject) catch {};
     }
 }
 
@@ -459,6 +459,7 @@ pub const ReadFileError = error{
     NetNameDeleted,
     OperationAborted,
     Unexpected,
+    NotOpenForReading,
 };
 
 /// If buffer's length exceeds what a Windows DWORD integer can hold, it will be broken into
@@ -526,21 +527,164 @@ pub fn ReadFile(in_hFile: HANDLE, buffer: []u8, offset: ?u64, io_mode: std.io.Mo
                 };
                 break :blk &overlapped_data;
             } else null;
-            if (kernel32.ReadFile(in_hFile, buffer.ptr, want_read_count, &amt_read, overlapped) == 0) {
-                switch (kernel32.GetLastError()) {
-                    .IO_PENDING => unreachable,
-                    .OPERATION_ABORTED => continue,
-                    .BROKEN_PIPE => return 0,
-                    .HANDLE_EOF => return 0,
-                    .NETNAME_DELETED => return error.NetNameDeleted,
-                    else => |err| return unexpectedError(err),
+            var console_mode: DWORD = undefined;
+            const is_console_handle: bool = kernel32.GetConsoleMode(in_hFile, &console_mode) != FALSE;
+            const is_cooked_mode: bool = (console_mode & ENABLE_LINE_INPUT) != 0;
+            // Implementation issue:
+            // There is no reliable way to implement perfectly platform-agnostic UTF-16 to UTF-8
+            // conversion for raw mode, because it is impossible to know the number of pending
+            // code units stored in console input buffer, while in cooked mode we can rely on the
+            // terminating LF character. Without knowing that, ReadConsoleW() may accidentally pop
+            // out characters without blocking, or prompt for user input at unexpected timing.
+            // In the case of raw mode, redirect to kernel32.ReadFile() without conversion for now,
+            // just don't make things worse.
+            if (is_console_handle and is_cooked_mode) {
+                assert(offset == null);
+                amt_read = ReadConsoleWithUtf16ToUtf8Conversion(in_hFile, buffer) catch |err| return err;
+            } else {
+                if (kernel32.ReadFile(in_hFile, buffer.ptr, want_read_count, &amt_read, overlapped) == 0) {
+                    switch (kernel32.GetLastError()) {
+                        .IO_PENDING => unreachable,
+                        .OPERATION_ABORTED => continue,
+                        .BROKEN_PIPE => return 0,
+                        .HANDLE_EOF => return 0,
+                        .NETNAME_DELETED => return error.NetNameDeleted,
+                        .INVALID_HANDLE => return error.NotOpenForReading,
+                        else => |err| return unexpectedError(err),
+                    }
                 }
             }
             return amt_read;
         }
     }
 }
 
+fn ReadConsoleWithUtf16ToUtf8Conversion(hConsoleInput: HANDLE, buffer: []u8) ReadFileError!DWORD {
+    const handle_data: *ConsoleHandleData = getConsoleHandleData(hConsoleInput) catch |err| switch (err) {
+        error.ConsoleHandleLimitReached => @panic("Reached maximum number of 64 console handles."),
+        else => return error.Unexpected,
+    };
+    // The temporary buffer can be huge, so keep it away from stack
+    var heap_allocator: std.heap.HeapAllocator = std.heap.HeapAllocator.init();
+    defer heap_allocator.deinit();
+    const allocator: std.mem.Allocator = heap_allocator.allocator();
+    var temp_buffer: []u8 = allocator.alloc(u8, buffer.len) catch @panic("Out of memory.");
+    defer allocator.free(temp_buffer);
+
+    var bytes_read: DWORD = 0;
+    var reached_end_of_line: bool = false;
+
+    // Try flushing leftover UTF-8 bytes first (one codepoint at most)
+    if (handle_data.utf8_buffer.bytes_used != 0) {
+        // LF will only appear at the first byte and there will be only one byte in the buffer
+        if (handle_data.utf8_buffer.data[0] == 0x0A) {
+            assert(handle_data.utf8_buffer.bytes_used == 1);
+            reached_end_of_line = true;
+        }
+        // Is there enough space for all bytes in UTF-8 buffer?
+        const has_enough_space: bool = buffer.len >= handle_data.utf8_buffer.bytes_used;
+        const max_bytes_to_read: usize = if (has_enough_space) handle_data.utf8_buffer.bytes_used else buffer.len;
+        for (0..max_bytes_to_read) |index| {
+            temp_buffer[index] = handle_data.utf8_buffer.data[handle_data.utf8_buffer.front_index];
+            // Front index wraps around in the case of 4-byte sequence (non-BMP code point)
+            handle_data.utf8_buffer.front_index +%= 1;
+        }
+        bytes_read += @truncate(max_bytes_to_read);
+        handle_data.utf8_buffer.bytes_used -= @truncate(max_bytes_to_read);
+        if (has_enough_space) {
+            // UTF-8 buffer is now empty, we can safely reset front_index to zero
+            handle_data.utf8_buffer.front_index = 0;
+        } else {
+            return ReadConsoleProcessUtf8Buffer(buffer, temp_buffer, bytes_read, false);
+        }
+        // LF ends a console read immediately
+        if (reached_end_of_line) {
+            return ReadConsoleProcessUtf8Buffer(buffer, temp_buffer, bytes_read, false);
+        }
+    }
+    assert(handle_data.utf8_buffer.front_index == 0);
+    while (bytes_read < buffer.len) {
+        // Read only one code unit each loop
+        var utf16_code_unit: u16 = undefined;
+        var utf16_code_units_read: DWORD = undefined;
+        if (kernel32.ReadConsoleW(hConsoleInput, &utf16_code_unit, 1, &utf16_code_units_read, null) == FALSE) {
+            switch (kernel32.GetLastError()) {
+                .INVALID_HANDLE => return error.NotOpenForReading,
+                else => |err| return unexpectedError(err),
+            }
+        }
+        if (utf16_code_unit == 0x000D) {
+            // CR should always be followed by an LF, so just discard it
+            continue;
+        } else if (utf16_code_unit >= 0xD800 and utf16_code_unit <= 0xDBFF) {
+            // When a high surrogate is encountered, store it into the UTF-16 buffer
+            assert(handle_data.utf16_buffer.code_units_used == 0);
+            handle_data.utf16_buffer.data[0] = utf16_code_unit;
+            handle_data.utf16_buffer.code_units_used = 1;
+            continue;
+        } else if (utf16_code_unit >= 0xDC00 and utf16_code_unit <= 0xDFFF) {
+            // When a low surrogate is encountered, assemble surrogate pair and convert to UTF-8
+            if (!(utf16_code_units_read == 1 and
+                handle_data.utf16_buffer.data[0] >= 0xD800 and handle_data.utf16_buffer.data[0] <= 0xDBFF)) {
+                unreachable;
+            }
+            handle_data.utf16_buffer.data[1] = utf16_code_unit;
+            handle_data.utf16_buffer.code_units_used = 0;
+            const utf8_bytes: usize = std.unicode.utf16leToUtf8(&handle_data.utf8_buffer.data, &handle_data.utf16_buffer.data) catch return error.Unexpected;
+            assert(utf8_bytes == 4);
+            handle_data.utf8_buffer.bytes_used = 4;
+        } else {
+            assert(handle_data.utf16_buffer.code_units_used == 0);
+            const utf8_bytes: usize = std.unicode.utf16leToUtf8(&handle_data.utf8_buffer.data, @as(*[1]u16, &utf16_code_unit)) catch return error.Unexpected;
+            handle_data.utf8_buffer.bytes_used = @truncate(utf8_bytes);
+            // LF ends a console read immediately
+            if (handle_data.utf8_buffer.bytes_used == 1 and handle_data.utf8_buffer.data[0] == 0x0A) {
+                reached_end_of_line = true;
+            }
+        }
+        // Is there enough space for all bytes in UTF-8 buffer?
+        const has_enough_space: bool = buffer.len >= bytes_read + handle_data.utf8_buffer.bytes_used;
+        const max_bytes_to_read: usize = if (has_enough_space) handle_data.utf8_buffer.bytes_used else buffer.len - bytes_read;
+        for (0..max_bytes_to_read) |index| {
+            temp_buffer[bytes_read + index] = handle_data.utf8_buffer.data[handle_data.utf8_buffer.front_index];
+            // Front index wraps around in the case of 4-byte sequence (non-BMP code point)
+            handle_data.utf8_buffer.front_index +%= 1;
+        }
+        bytes_read += @truncate(max_bytes_to_read);
+        handle_data.utf8_buffer.bytes_used -= @truncate(max_bytes_to_read);
+        if (has_enough_space) {
+            // UTF-8 buffer is now empty, we can safely reset front_index to zero
+            handle_data.utf8_buffer.front_index = 0;
+        } else {
+            break;
+        }
+        // LF ends a console read immediately
+        if (reached_end_of_line) {
+            break;
+        }
+    }
+    return ReadConsoleProcessUtf8Buffer(buffer, temp_buffer, bytes_read, true);
+}
+
+fn ReadConsoleProcessUtf8Buffer(buffer: []u8, temp_buffer: []u8, bytes_read: DWORD, comptime truncate_after_SUB: bool) DWORD {
+    if (truncate_after_SUB) {
+        // Truncate everything after the SUB (Ctrl+Z) character
+        var index: DWORD = 0;
+        var reached_end_of_file: bool = false;
+        while (index < bytes_read and !reached_end_of_file) {
+            if (temp_buffer[index] == 0x1A) {
+                reached_end_of_file = true;
+            }
+            buffer[index] = temp_buffer[index];
+            index += 1;
+        }
+        return index;
+    } else {
+        std.mem.copy(u8, buffer, temp_buffer);
+        return bytes_read;
+    }
+}
+
 pub const WriteFileError = error{
     SystemResources,
     OperationAborted,
@@ -646,7 +790,7 @@ pub fn WriteFile(
 }
 
 fn WriteConsoleWithUtf8ToUtf16Conversion(handle: HANDLE, bytes: []const u8) WriteFileError!DWORD {
-    const handle_data: *ConsoleHandleData = GetConsoleHandleData(handle) catch |err| switch (err) {
+    const handle_data: *ConsoleHandleData = getConsoleHandleData(handle) catch |err| switch (err) {
         error.ConsoleHandleLimitReached => @panic("Reached maximum number of 64 console handles."),
         else => return error.Unexpected,
     };
@@ -688,6 +832,7 @@ fn WriteConsoleWithUtf8ToUtf16Conversion(handle: HANDLE, bytes: []const u8) Writ
                 byte_index += bytes_needed;
             }
         }
+        // Handle LF to CRLF conversion
         switch (utf16_buffer[0]) {
             0x000D => {
                 handle_data.last_character_written_is_CR = true;
@@ -5167,52 +5312,71 @@ pub fn ProcessBaseAddress(handle: HANDLE) ProcessBaseAddressError!HMODULE {
     return ppeb.ImageBaseAddress;
 }
 
+pub const ENABLE_PROCESSED_INPUT = 0x0001;
+pub const ENABLE_LINE_INPUT = 0x0002;
+pub const ENABLE_ECHO_INPUT = 0x0004;
+pub const ENABLE_WINDOW_INPUT = 0x0008;
+pub const ENABLE_MOUSE_INPUT = 0x0010;
+pub const ENABLE_INSERT_MODE = 0x0020;
+pub const ENABLE_QUICK_EDIT_MODE = 0x0040;
+pub const ENABLE_EXTENDED_FLAGS = 0x0080;
+pub const ENABLE_AUTO_POSITION = 0x0100;
+pub const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+
+pub const CONSOLE_READCONSOLE_CONTROL = extern struct {
+    nLength: ULONG,
+    nInitialChars: ULONG,
+    dwCtrlWakeupMask: ULONG,
+    dwControlKeyState: ULONG,
+};
+
+pub const PCONSOLE_READCONSOLE_CONTROL = *CONSOLE_READCONSOLE_CONTROL;
+
 pub fn IsConsoleHandle(handle: HANDLE) bool {
     var out: DWORD = undefined;
     return kernel32.GetConsoleMode(handle, &out) != FALSE;
 }
 
+// Non-public extra data associated with console handle, and its helper functions
 const ConsoleHandleData = struct {
     is_assigned: bool = false,
-
     handle: ?HANDLE = null,
-
-    /// On Windows NT, UTF-8 encoded strings should be converted to UTF-16 before writing to the
-    /// native console. Since write() might be called with a string fragment or even a single byte,
-    /// we have to store residual UTF-8 byte(s) without returning error. UTF-16 code unit(s) will be
-    /// generated when we have enough bytes to complete a code point.
     utf8_buffer: Utf8Buffer = .{},
-
-    /// Used for LF to CRLF conversion before writing to the native console.
+    utf16_buffer: Utf16Buffer = .{},
     last_character_written_is_CR: bool = false,
 
-    pub const Utf8Buffer = struct {
+    const Utf8Buffer = struct {
         data: [4]u8 = .{ 0x00, 0x00, 0x00, 0x00 },
         bytes_used: u3 = 0,
+        front_index: u2 = 0,
+    };
+
+    const Utf16Buffer = struct {
+        data: [2]u16 = .{ 0x0000, 0x0000 },
+        code_units_used: u2 = 0,
     };
 };
 
-const console_handle_data_limit = 64;
+const max_console_handle_data = 64;
 
 var console_handle_data_array: switch (builtin.os.tag) {
-    .windows => [console_handle_data_limit]ConsoleHandleData,
+    .windows => [max_console_handle_data]ConsoleHandleData,
     else => void,
 } = switch (builtin.os.tag) {
-    .windows => [_]ConsoleHandleData{.{}} ** console_handle_data_limit,
+    .windows => [_]ConsoleHandleData{.{}} ** max_console_handle_data,
     else => void{},
 };
 
 const ConsoleHandleDataError = error{
-    OsUnsupported,
     DataNotFound,
     ConsoleHandleLimitReached,
 };
 
-fn GetConsoleHandleData(handle: HANDLE) ConsoleHandleDataError!*ConsoleHandleData {
+fn getConsoleHandleData(handle: HANDLE) ConsoleHandleDataError!*ConsoleHandleData {
     if (builtin.os.tag == .windows) {
         var found_unassigned: bool = false;
         var first_unassigned_index: usize = undefined;
-        for (0..console_handle_data_limit) |index| {
+        for (0..max_console_handle_data) |index| {
             if (console_handle_data_array[index].is_assigned) {
                 if (console_handle_data_array[index].handle == handle) {
                     return &console_handle_data_array[index];
@@ -5232,20 +5396,20 @@ fn GetConsoleHandleData(handle: HANDLE) ConsoleHandleDataError!*ConsoleHandleDat
             return error.ConsoleHandleLimitReached;
         }
     } else {
-        return error.OsUnsupported;
+        @compileError("Unsupported OS");
     }
 }
 
-fn RemoveConsoleHandleData(handle: HANDLE) ConsoleHandleDataError!usize {
+fn removeConsoleHandleData(handle: HANDLE) ConsoleHandleDataError!usize {
     if (builtin.os.tag == .windows) {
-        for (0..console_handle_data_limit) |index| {
+        for (0..max_console_handle_data) |index| {
             if (console_handle_data_array[index].is_assigned and console_handle_data_array[index].handle == handle) {
                 console_handle_data_array[index].is_assigned = false;
                 return index;
             }
         }
         return error.DataNotFound;
     } else {
-        return error.OsUnsupported;
+        @compileError("Unsupported OS");
     }
 }

lib/std/os/windows/kernel32.zig

@@ -174,6 +174,7 @@ pub extern "kernel32" fn FillConsoleOutputCharacterW(hConsoleOutput: HANDLE, cCh
 pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: *DWORD) callconv(WINAPI) BOOL;
 pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(WINAPI) BOOL;
 
+pub extern "kernel32" fn ReadConsoleW(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: *DWORD, pInputControl: ?LPVOID) callconv(WINAPI) BOOL;
 pub extern "kernel32" fn WriteConsoleW(hConsoleOutput: HANDLE, lpBuffer: *const anyopaque, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: ?*DWORD, lpReserved: ?LPVOID) callconv(WINAPI) BOOL;
 
 pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(WINAPI) DWORD;