@zigc/lib 0.16.0-dev.3132 → 0.16.0-dev.3142

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0-dev.3132",
+  "version": "0.16.0-dev.3142",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Step/ConfigHeader.zig

@@ -420,12 +420,21 @@ fn render_cmake(
         };
         defer allocator.free(line);
 
-        if (!std.mem.startsWith(u8, line, "#")) {
+        const line_start = std.mem.findNone(u8, line, " \t\r") orelse {
+            try bw.writeAll(line);
+            if (!last_line) try bw.writeByte('\n');
+            continue;
+        };
+        const whitespace_prefix = line[0..line_start];
+        const trimmed_line = line[line_start..];
+
+        if (!std.mem.startsWith(u8, trimmed_line, "#")) {
             try bw.writeAll(line);
             if (!last_line) try bw.writeByte('\n');
             continue;
         }
-        var it = std.mem.tokenizeAny(u8, line[1..], " \t\r");
+
+        var it = std.mem.tokenizeAny(u8, trimmed_line[1..], " \t\r");
         const cmakedefine = it.next().?;
         if (!std.mem.eql(u8, cmakedefine, "cmakedefine") and
             !std.mem.eql(u8, cmakedefine, "cmakedefine01"))
@@ -502,6 +511,7 @@ fn render_cmake(
             value = Value{ .ident = it.rest() };
         }
 
+        try bw.writeAll(whitespace_prefix);
         try renderValueC(bw, name, value);
     }
 

package/std/Io/Threaded.zig

@@ -6090,12 +6090,19 @@ fn dirRealPathFileWindows(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8,
         }
     };
     defer windows.CloseHandle(h_file);
-    return realPathWindows(h_file, out_buffer);
+
+    // We can re-use the path buffer for the WTF-16 representation since
+    // we don't need the prefixed path anymore
+    return realPathWindowsBuf(h_file, out_buffer, &path_name_w.data);
 }
 
 fn realPathWindows(h_file: windows.HANDLE, out_buffer: []u8) File.RealPathError!usize {
     var wide_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
-    const wide_slice = try GetFinalPathNameByHandle(h_file, .{}, &wide_buf);
+    return realPathWindowsBuf(h_file, out_buffer, &wide_buf);
+}
+
+fn realPathWindowsBuf(h_file: windows.HANDLE, out_buffer: []u8, wtf16_buffer: []u16) File.RealPathError!usize {
+    const wide_slice = try GetFinalPathNameByHandle(h_file, .{}, wtf16_buffer);
 
     const len = std.unicode.calcWtf8Len(wide_slice);
     if (len > out_buffer.len)
@@ -13010,6 +13017,7 @@ fn netReceiveOneWindows(
         .CANCELLED => unreachable,
         .INSUFFICIENT_RESOURCES => return error.SystemResources,
         .BUFFER_OVERFLOW => return error.MessageOversize,
+        .PORT_UNREACHABLE => return error.PortUnreachable,
         else => |status| return windows.unexpectedStatus(status),
     }
 }

package/std/Io.zig

@@ -374,6 +374,13 @@ pub const Operation = union(enum) {
             ConnectionResetByPeer,
             /// The local network interface used to reach the destination is offline.
             NetworkDown,
+            /// A connectionless packet was previously sent successfully,
+            /// however, it was not received because no service is operating at
+            /// the destination port of the transport on the remote system.
+            /// This caused an ICMP port unreachable packet to be returned to
+            /// the OS where it was queued up to be reported at the next call
+            /// to send or receive on the bound socket.
+            PortUnreachable,
         } || Io.UnexpectedError;
 
         pub const Result = struct { ?net.Socket.ReceiveError, usize };
@@ -2491,3 +2498,964 @@ test {
     _ = Semaphore;
     _ = @import("Io/test.zig");
 }
+
+/// An implementation of `Io` which simulates a system supporting no `Io` operations.
+///
+/// This system has the following properties:
+/// * Concurrency is unavailable.
+/// * The stdio handles are pipes whose remote ends are already closed.
+/// * The filesystem is entirely empty, including that the cwd is no longer present.
+/// * The filesystem is full, so attempting to create entries always returns `error.NoSpaceLeft`.
+/// * No entropy source is supported, so `randomSecure` always returns `error.EntropyUnavailable`, and `random` always returns (fills the buffer) with 0.
+/// * No clocks are supported, so `now` and `sleep` always return `error.UnsupportedClock`.
+/// * No network is connected, so network operations always return `error.NetworkDown`.
+pub const failing: std.Io = .{
+    .userdata = null,
+    .vtable = &.{
+        .crashHandler = noCrashHandler,
+
+        .async = noAsync,
+        .concurrent = failingConcurrent,
+        .await = unreachableAwait,
+        .cancel = unreachableCancel,
+
+        .groupAsync = noGroupAsync,
+        .groupConcurrent = failingGroupConcurrent,
+        .groupAwait = unreachableGroupAwait,
+        .groupCancel = unreachableGroupCancel,
+
+        .recancel = unreachableRecancel,
+        .swapCancelProtection = unreachableSwapCancelProtection,
+        .checkCancel = unreachableCheckCancel,
+
+        .futexWait = noFutexWait,
+        .futexWaitUncancelable = noFutexWaitUncancelable,
+        .futexWake = noFutexWake,
+
+        .operate = failingOperate,
+        .batchAwaitAsync = unreachableBatchAwaitAsync,
+        .batchAwaitConcurrent = unreachableBatchAwaitConcurrent,
+        .batchCancel = unreachableBatchCancel,
+
+        .dirCreateDir = failingDirCreateDir,
+        .dirCreateDirPath = failingDirCreateDirPath,
+        .dirCreateDirPathOpen = failingDirCreateDirPathOpen,
+        .dirOpenDir = failingDirOpenDir,
+        .dirStat = failingDirStat,
+        .dirStatFile = failingDirStatFile,
+        .dirAccess = failingDirAccess,
+        .dirCreateFile = failingDirCreateFile,
+        .dirCreateFileAtomic = failingDirCreateFileAtomic,
+        .dirOpenFile = failingDirOpenFile,
+        .dirClose = unreachableDirClose,
+        .dirRead = noDirRead,
+        .dirRealPath = failingDirRealPath,
+        .dirRealPathFile = failingDirRealPathFile,
+        .dirDeleteFile = failingDirDeleteFile,
+        .dirDeleteDir = failingDirDeleteDir,
+        .dirRename = failingDirRename,
+        .dirRenamePreserve = failingDirRenamePreserve,
+        .dirSymLink = failingDirSymLink,
+        .dirReadLink = failingDirReadLink,
+        .dirSetOwner = failingDirSetOwner,
+        .dirSetFileOwner = failingDirSetFileOwner,
+        .dirSetPermissions = failingDirSetPermissions,
+        .dirSetFilePermissions = failingDirSetFilePermissions,
+        .dirSetTimestamps = noDirSetTimestamps,
+        .dirHardLink = failingDirHardLink,
+
+        .fileStat = failingFileStat,
+        .fileLength = failingFileLength,
+        .fileClose = unreachableFileClose,
+        .fileWritePositional = failingFileWritePositional,
+        .fileWriteFileStreaming = noFileWriteFileStreaming,
+        .fileWriteFilePositional = noFileWriteFilePositional,
+        .fileReadPositional = failingFileReadPositional,
+        .fileSeekBy = failingFileSeekBy,
+        .fileSeekTo = failingFileSeekTo,
+        .fileSync = failingFileSync,
+        .fileIsTty = unreachableFileIsTty,
+        .fileEnableAnsiEscapeCodes = unreachableFileEnableAnsiEscapeCodes,
+        .fileSupportsAnsiEscapeCodes = unreachableFileSupportsAnsiEscapeCodes,
+        .fileSetLength = failingFileSetLength,
+        .fileSetOwner = failingFileSetOwner,
+        .fileSetPermissions = failingFileSetPermissions,
+        .fileSetTimestamps = noFileSetTimestamps,
+        .fileLock = failingFileLock,
+        .fileTryLock = failingFileTryLock,
+        .fileUnlock = unreachableFileUnlock,
+        .fileDowngradeLock = failingFileDowngradeLock,
+        .fileRealPath = failingFileRealPath,
+        .fileHardLink = failingFileHardLink,
+
+        .fileMemoryMapCreate = failingFileMemoryMapCreate,
+        .fileMemoryMapDestroy = unreachableFileMemoryMapDestroy,
+        .fileMemoryMapSetLength = unreachableFileMemoryMapSetLength,
+        .fileMemoryMapRead = unreachableFileMemoryMapRead,
+        .fileMemoryMapWrite = unreachableFileMemoryMapWrite,
+
+        .processExecutableOpen = failingProcessExecutableOpen,
+        .processExecutablePath = failingProcessExecutablePath,
+        .lockStderr = unreachableLockStderr,
+        .tryLockStderr = noTryLockStderr,
+        .unlockStderr = unreachableUnlockStderr,
+        .processCurrentPath = failingProcessCurrentPath,
+        .processSetCurrentDir = failingProcessSetCurrentDir,
+        .processSetCurrentPath = failingProcessSetCurrentPath,
+        .processReplace = failingProcessReplace,
+        .processReplacePath = failingProcessReplacePath,
+        .processSpawn = failingProcessSpawn,
+        .processSpawnPath = failingProcessSpawnPath,
+        .childWait = unreachableChildWait,
+        .childKill = unreachableChildKill,
+
+        .progressParentFile = failingProgressParentFile,
+
+        .random = noRandom,
+        .randomSecure = failingRandomSecure,
+
+        .now = noNow,
+        .clockResolution = failingClockResolution,
+        .sleep = noSleep,
+
+        .netListenIp = failingNetListenIp,
+        .netAccept = failingNetAccept,
+        .netBindIp = failingNetBindIp,
+        .netConnectIp = failingNetConnectIp,
+        .netListenUnix = failingNetListenUnix,
+        .netConnectUnix = failingNetConnectUnix,
+        .netSocketCreatePair = failingNetSocketCreatePair,
+        .netSend = failingNetSend,
+        .netRead = failingNetRead,
+        .netWrite = failingNetWrite,
+        .netWriteFile = failingNetWriteFile,
+        .netClose = unreachableNetClose,
+        .netShutdown = failingNetShutdown,
+        .netInterfaceNameResolve = failingNetInterfaceNameResolve,
+        .netInterfaceName = unreachableNetInterfaceName,
+        .netLookup = failingNetLookup,
+    },
+};
+
+pub fn noCrashHandler(userdata: ?*anyopaque) void {
+    _ = userdata;
+}
+
+pub fn noAsync(userdata: ?*anyopaque, result: []u8, result_alignment: std.mem.Alignment, context: []const u8, context_alignment: std.mem.Alignment, start: *const fn (context: *const anyopaque, result: *anyopaque) void) ?*AnyFuture {
+    _ = userdata;
+    _ = result_alignment;
+    _ = context_alignment;
+    start(context.ptr, result.ptr);
+    return null;
+}
+
+pub fn failingConcurrent(
+    userdata: ?*anyopaque,
+    result_len: usize,
+    result_alignment: std.mem.Alignment,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+) ConcurrentError!*AnyFuture {
+    _ = userdata;
+    _ = result_len;
+    _ = result_alignment;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableAwait(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn unreachableCancel(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn noGroupAsync(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) void {
+    _ = userdata;
+    _ = group;
+    _ = context_alignment;
+    start(context.ptr);
+}
+
+pub fn failingGroupConcurrent(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) ConcurrentError!void {
+    _ = userdata;
+    _ = group;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableGroupAwait(userdata: ?*anyopaque, group: *Group, token: *anyopaque) Cancelable!void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableGroupCancel(userdata: ?*anyopaque, group: *Group, token: *anyopaque) void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableRecancel(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn unreachableSwapCancelProtection(userdata: ?*anyopaque, new: CancelProtection) CancelProtection {
+    _ = userdata;
+    _ = new;
+    unreachable;
+}
+
+pub fn unreachableCheckCancel(userdata: ?*anyopaque) Cancelable!void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn noFutexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Timeout) Cancelable!void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected or timeout != .none);
+}
+
+pub fn noFutexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected);
+}
+
+pub fn noFutexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
+    _ = userdata;
+    _ = ptr;
+    _ = max_waiters;
+    // no-op
+}
+
+pub fn failingOperate(userdata: ?*anyopaque, operation: Operation) Cancelable!Operation.Result {
+    _ = userdata;
+    return switch (operation) {
+        .file_read_streaming => .{ .file_read_streaming = error.InputOutput },
+        .file_write_streaming => .{ .file_write_streaming = error.InputOutput },
+        .device_io_control => unreachable,
+        .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+    };
+}
+
+pub fn unreachableBatchAwaitAsync(userdata: ?*anyopaque, b: *Batch) Cancelable!void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn unreachableBatchAwaitConcurrent(userdata: ?*anyopaque, b: *Batch, timeout: Timeout) Batch.AwaitConcurrentError!void {
+    _ = userdata;
+    _ = b;
+    _ = timeout;
+    unreachable;
+}
+
+pub fn unreachableBatchCancel(userdata: ?*anyopaque, b: *Batch) void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn failingDirCreateDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPath(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPathOpen(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, options: Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.OpenOptions) Dir.OpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
+    _ = userdata;
+    _ = dir;
+    return error.Streaming;
+}
+
+pub fn failingDirStatFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.StatFileOptions) Dir.StatFileError!File.Stat {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.AccessOptions) Dir.AccessError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: File.CreateFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateFileAtomic(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn unreachableDirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
+    _ = userdata;
+    _ = dirs;
+    unreachable;
+}
+
+pub fn noDirRead(userdata: ?*anyopaque, dir_reader: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
+    _ = userdata;
+    _ = dir_reader;
+    _ = buffer;
+    return 0;
+}
+
+pub fn failingDirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRealPathFile(userdata: ?*anyopaque, dir: Dir, path_name: []const u8, out_buffer: []u8) Dir.RealPathFileError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = path_name;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRename(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenameError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRenamePreserve(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenamePreserveError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSymLink(userdata: ?*anyopaque, dir: Dir, target_path: []const u8, sym_link_path: []const u8, flags: Dir.SymLinkFlags) Dir.SymLinkError!void {
+    _ = userdata;
+    _ = dir;
+    _ = target_path;
+    _ = sym_link_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingDirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetOwner(userdata: ?*anyopaque, dir: Dir, owner: ?File.Uid, group: ?File.Gid) Dir.SetOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFileOwner(userdata: ?*anyopaque, dir: std.Io.Dir, sub_path: []const u8, owner: ?File.Uid, group: ?File.Gid, options: Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = owner;
+    _ = group;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetPermissions(userdata: ?*anyopaque, dir: Dir, permissions: Dir.Permissions) Dir.SetPermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFilePermissions(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: File.Permissions, options: Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn noDirSetTimestamps(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.SetTimestampsOptions) Dir.SetTimestampsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    // no-op
+}
+
+pub fn failingDirHardLink(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, options: Dir.HardLinkOptions) Dir.HardLinkError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn failingFileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn unreachableFileClose(userdata: ?*anyopaque, files: []const File) void {
+    _ = userdata;
+    _ = files;
+    unreachable;
+}
+
+pub fn failingFileWritePositional(userdata: ?*anyopaque, file: File, header: []const u8, data: []const []const u8, splat: usize, offset: u64) File.WritePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = offset;
+    for (data[0 .. data.len - 1]) |item| {
+        if (item.len > 0) return error.BrokenPipe;
+    }
+    if (data[data.len - 1].len != 0 and splat != 0) return error.BrokenPipe;
+    return 0;
+}
+
+pub fn noFileWriteFileStreaming(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) File.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.Unimplemented;
+}
+
+pub fn noFileWriteFilePositional(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit, offset: u64) File.WriteFilePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    _ = offset;
+    return error.Unimplemented;
+}
+
+pub fn failingFileReadPositional(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = offset;
+    for (data) |item| {
+        if (item.len > 0) return error.InputOutput;
+    }
+    return 0;
+}
+
+pub fn failingFileSeekBy(userdata: ?*anyopaque, file: File, relative_offset: i64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = relative_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSeekTo(userdata: ?*anyopaque, file: File, absolute_offset: u64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = absolute_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
+    _ = userdata;
+    _ = file;
+    return error.NoSpaceLeft;
+}
+
+pub fn unreachableFileIsTty(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileSupportsAnsiEscapeCodes(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    _ = userdata;
+    _ = file;
+    _ = length;
+    return error.NonResizable;
+}
+
+pub fn failingFileSetOwner(userdata: ?*anyopaque, file: File, owner: ?File.Uid, group: ?File.Gid) File.SetOwnerError!void {
+    _ = userdata;
+    _ = file;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingFileSetPermissions(userdata: ?*anyopaque, file: File, permissions: File.Permissions) File.SetPermissionsError!void {
+    _ = userdata;
+    _ = file;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn noFileSetTimestamps(userdata: ?*anyopaque, file: File, options: File.SetTimestampsOptions) File.SetTimestampsError!void {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    // no-op
+}
+
+pub fn failingFileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn failingFileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn unreachableFileUnlock(userdata: ?*anyopaque, file: File) void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
+    _ = userdata;
+    _ = file;
+    // no-op
+}
+
+pub fn failingFileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
+    _ = userdata;
+    _ = file;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingFileHardLink(userdata: ?*anyopaque, file: File, new_dir: Dir, new_sub_path: []const u8, options: File.HardLinkOptions) File.HardLinkError!void {
+    _ = userdata;
+    _ = file;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileMemoryMapCreate(userdata: ?*anyopaque, file: File, options: File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    return error.AccessDenied;
+}
+
+pub fn unreachableFileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapSetLength(userdata: ?*anyopaque, mm: *File.MemoryMap, new_len: usize) File.MemoryMap.SetLengthError!void {
+    _ = userdata;
+    _ = mm;
+    _ = new_len;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) std.process.OpenExecutableError!File {
+    _ = userdata;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessExecutablePath(userdata: ?*anyopaque, buffer: []u8) std.process.ExecutablePathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn unreachableLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    unreachable;
+}
+
+pub fn noTryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!?LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    return null;
+}
+
+pub fn unreachableUnlockStderr(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn failingProcessCurrentPath(userdata: ?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.CurrentDirUnlinked;
+}
+
+pub fn failingProcessSetCurrentDir(userdata: ?*anyopaque, dir: Dir) std.process.SetCurrentDirError!void {
+    _ = userdata;
+    _ = dir;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessSetCurrentPath(userdata: ?*anyopaque, path: []const u8) std.process.SetCurrentPathError!void {
+    _ = userdata;
+    _ = path;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessReplace(userdata: ?*anyopaque, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessReplacePath(userdata: ?*anyopaque, dir: Dir, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawn(userdata: ?*anyopaque, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawnPath(userdata: ?*anyopaque, dir: Dir, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn unreachableChildWait(userdata: ?*anyopaque, child: *std.process.Child) std.process.Child.WaitError!std.process.Child.Term {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn unreachableChildKill(userdata: ?*anyopaque, child: *std.process.Child) void {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn failingProgressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
+    _ = userdata;
+    return error.UnsupportedOperation;
+}
+
+pub fn noRandom(userdata: ?*anyopaque, buffer: []u8) void {
+    _ = userdata;
+    @memset(buffer, 0);
+}
+
+pub fn failingRandomSecure(userdata: ?*anyopaque, buffer: []u8) RandomSecureError!void {
+    _ = userdata;
+    _ = buffer;
+    return error.EntropyUnavailable;
+}
+
+pub fn noNow(userdata: ?*anyopaque, clock: Clock) Timestamp {
+    _ = userdata;
+    _ = clock;
+    return .zero;
+}
+
+pub fn failingClockResolution(userdata: ?*anyopaque, clock: Clock) Clock.ResolutionError!Duration {
+    _ = userdata;
+    _ = clock;
+    return error.ClockUnavailable;
+}
+
+pub fn noSleep(userdata: ?*anyopaque, clock: Timeout) Cancelable!void {
+    _ = userdata;
+    _ = clock;
+}
+
+pub fn failingNetListenIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ListenOptions) net.IpAddress.ListenError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetAccept(userdata: ?*anyopaque, listen_fd: net.Socket.Handle, options: net.Server.AcceptOptions) net.Server.AcceptError!net.Socket {
+    _ = userdata;
+    _ = listen_fd;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetBindIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.BindOptions) net.IpAddress.BindError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetListenUnix(userdata: ?*anyopaque, address: *const net.UnixAddress, options: net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectUnix(userdata: ?*anyopaque, address: *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    return error.NetworkDown;
+}
+
+pub fn failingNetSocketCreatePair(userdata: ?*anyopaque, options: net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingNetSend(userdata: ?*anyopaque, handle: net.Socket.Handle, messages: []net.OutgoingMessage, flags: net.SendFlags) struct { ?net.Socket.SendError, usize } {
+    _ = userdata;
+    _ = handle;
+    _ = messages;
+    _ = flags;
+    return .{ error.NetworkDown, 0 };
+}
+
+pub fn failingNetRead(userdata: ?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
+    _ = userdata;
+    _ = src;
+    _ = data;
+    return error.NetworkDown;
+}
+
+pub fn failingNetWrite(userdata: ?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize {
+    _ = userdata;
+    _ = dest;
+    _ = header;
+    _ = data;
+    _ = splat;
+    return error.NetworkDown;
+}
+
+pub fn failingNetWriteFile(userdata: ?*anyopaque, handle: net.Socket.Handle, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) net.Stream.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = handle;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.NetworkDown;
+}
+
+pub fn unreachableNetClose(userdata: ?*anyopaque, handle: []const net.Socket.Handle) void {
+    _ = userdata;
+    _ = handle;
+    unreachable;
+}
+
+pub fn failingNetShutdown(userdata: ?*anyopaque, handle: net.Socket.Handle, how: net.ShutdownHow) net.ShutdownError!void {
+    _ = userdata;
+    _ = handle;
+    _ = how;
+    return error.NetworkDown;
+}
+
+pub fn failingNetInterfaceNameResolve(userdata: ?*anyopaque, name: *const net.Interface.Name) net.Interface.Name.ResolveError!net.Interface {
+    _ = userdata;
+    _ = name;
+    return error.InterfaceNotFound;
+}
+
+pub fn unreachableNetInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interface.NameError!net.Interface.Name {
+    _ = userdata;
+    _ = interface;
+    unreachable;
+}
+
+pub fn failingNetLookup(userdata: ?*anyopaque, host_name: net.HostName, resolved: *Queue(net.HostName.LookupResult), options: net.HostName.LookupOptions) net.HostName.LookupError!void {
+    _ = userdata;
+    _ = host_name;
+    _ = resolved;
+    _ = options;
+    return error.NetworkDown;
+}
+
+test failing {
+    const f: Io = .failing;
+    // file stuff
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createDir(.cwd(), f, "test", .default_dir));
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createFile(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openDir(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openFile(.cwd(), f, "test", .{}));
+    try File.writeStreamingAll(.stdout(), f, &.{});
+    try std.testing.expectError(error.AccessDenied, File.MemoryMap.create(f, .stdout(), .{ .len = 0 }));
+    // async stuff
+    const closure = struct {
+        var foo: usize = 0;
+        fn doOp() void {
+            foo = 4;
+        }
+    };
+    var future = f.async(closure.doOp, .{});
+    _ = future.await(f);
+    try std.testing.expect(closure.foo == 4);
+    // random stuff
+    var buffer: [1]u8 = undefined;
+    f.random(&buffer);
+    try std.testing.expect(buffer[0] == 0);
+}

package/std/builtin/assembly.zig

@@ -682,6 +682,40 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         x30: bool = false,
         x31: bool = false,
 
+        // ABI aliases for integer registers
+        ra: bool = false,
+        sp: bool = false,
+        gp: bool = false,
+        tp: bool = false,
+        t0: bool = false,
+        t1: bool = false,
+        t2: bool = false,
+        s0: bool = false,
+        fp: bool = false,
+        s1: bool = false,
+        a0: bool = false,
+        a1: bool = false,
+        a2: bool = false,
+        a3: bool = false,
+        a4: bool = false,
+        a5: bool = false,
+        a6: bool = false,
+        a7: bool = false,
+        s2: bool = false,
+        s3: bool = false,
+        s4: bool = false,
+        s5: bool = false,
+        s6: bool = false,
+        s7: bool = false,
+        s8: bool = false,
+        s9: bool = false,
+        s10: bool = false,
+        s11: bool = false,
+        t3: bool = false,
+        t4: bool = false,
+        t5: bool = false,
+        t6: bool = false,
+
         fflags: bool = false,
         frm: bool = false,
 
@@ -718,6 +752,40 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         f30: bool = false,
         f31: bool = false,
 
+        // ABI aliases for float registers
+        ft0: bool = false,
+        ft1: bool = false,
+        ft2: bool = false,
+        ft3: bool = false,
+        ft4: bool = false,
+        ft5: bool = false,
+        ft6: bool = false,
+        ft7: bool = false,
+        fs0: bool = false,
+        fs1: bool = false,
+        fa0: bool = false,
+        fa1: bool = false,
+        fa2: bool = false,
+        fa3: bool = false,
+        fa4: bool = false,
+        fa5: bool = false,
+        fa6: bool = false,
+        fa7: bool = false,
+        fs2: bool = false,
+        fs3: bool = false,
+        fs4: bool = false,
+        fs5: bool = false,
+        fs6: bool = false,
+        fs7: bool = false,
+        fs8: bool = false,
+        fs9: bool = false,
+        fs10: bool = false,
+        fs11: bool = false,
+        ft8: bool = false,
+        ft9: bool = false,
+        ft10: bool = false,
+        ft11: bool = false,
+
         vtype: bool = false,
         vl: bool = false,
         vxsat: bool = false,

package/std/enums.zig

@@ -284,6 +284,18 @@ pub fn EnumSet(comptime E: type) type {
         /// A set containing all possible keys.
         pub const full: Self = .{ .bits = .full };
 
+        /// Deprecated: use `.empty`.
+        /// Returns a set containing no keys.
+        pub fn initEmpty() Self {
+            return .empty;
+        }
+
+        /// Deprecated: use `.full`.
+        /// Returns a set containing all possible keys.
+        pub fn initFull() Self {
+            return .full;
+        }
+
         /// Returns a set containing multiple keys.
         pub fn initMany(keys: []const Key) Self {
             var set: Self = .empty;

package/std/os/emscripten.zig

@@ -11,22 +11,6 @@ const c = std.c;
 
 pub const FILE = c.FILE;
 
-var __stack_chk_guard: usize = 0;
-fn __stack_chk_fail() callconv(.c) void {
-    std.debug.print("stack smashing detected: terminated\n", .{});
-    emscripten_force_exit(127);
-}
-
-comptime {
-    if (builtin.os.tag == .emscripten) {
-        if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) {
-            // Emscripten does not provide these symbols, so we must export our own
-            @export(&__stack_chk_guard, .{ .name = "__stack_chk_guard", .linkage = .strong });
-            @export(&__stack_chk_fail, .{ .name = "__stack_chk_fail", .linkage = .strong });
-        }
-    }
-}
-
 pub const PF = linux.PF;
 pub const AF = linux.AF;
 pub const CLOCK = linux.CLOCK;

package/std/posix.zig

@@ -513,6 +513,9 @@ pub const GetSockNameError = error{
     SocketNotBound,
 
     FileDescriptorNotASocket,
+
+    /// The socket is not connected (connection-oriented sockets only).
+    SocketUnconnected,
 } || UnexpectedError;
 
 pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSockNameError!void {
@@ -529,6 +532,7 @@ pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSock
             .INVAL => unreachable, // invalid parameters
             .NOTSOCK => return error.FileDescriptorNotASocket,
             .NOBUFS => return error.SystemResources,
+            .NOTCONN => return error.SocketUnconnected,
         }
     }
 }