Update Zig to 0.15.0-dev.1092+d772c0627

mpfaff · mpfaff · commit cc542939b9f5 · 2025-07-20T12:48:36.000-04:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -41,7 +41,7 @@ jobs:
                   version: 1.0
             - uses: mlugg/setup-zig@v1
               with:
-                version: 0.15.0-dev.386+2e35fdd03
+                version: 0.15.0-dev.1092+d772c0627
             - name: "Build"
               run: |
                   zig build build-all -Doptimize=$OPTIMIZE
diff --git a/build.zig.zon b/build.zig.zon
@@ -5,7 +5,7 @@
 
     .fingerprint = 0x6002b2b610072fc5,
 
-    .minimum_zig_version = "0.15.0-dev.386+2e35fdd03",
+    .minimum_zig_version = "0.15.0-dev.1092+d772c0627",
 
     .dependencies = .{
         .plthook = .{
diff --git a/src/Config.zig b/src/Config.zig
@@ -4,6 +4,7 @@ const std = @import("std");
 const root = @import("root.zig");
 const alloc = root.alloc;
 const logger = root.logger;
+const fmtString = root.util.fmtString;
 const os_char = root.util.os_char;
 
 /// Path to a managed assembly to invoke.
@@ -61,10 +62,7 @@ inline fn getEnvBool(comptime key: []const u8) bool {
 
 fn invalidEnvValue(key: []const u8, value: [:0]const os_char) noreturn {
     @branchHint(.cold);
-    std.debug.panic("Invalid value for environment variable {s}: {s}", .{ key, switch (builtin.os.tag) {
-        .windows => std.unicode.fmtUtf16Le(value),
-        else => value,
-    } });
+    std.debug.panic("Invalid value for environment variable {s}: {f}", .{ key, fmtString(value) });
 }
 
 fn getEnvBoolOs(key: EnvKey) bool {
diff --git a/src/bootstrap.zig b/src/bootstrap.zig
@@ -61,7 +61,7 @@ fn mono_doorstop_bootstrap(mono_domain: *mono.Domain) void {
         util.setEnv("DOORSTOP_MANAGED_FOLDER_DIR", norm_assembly_dir.str);
     }
 
-    logger.debug("Opening assembly: {}", .{util.fmtString(config.target_assembly.?)});
+    logger.debug("Opening assembly: {f}", .{util.fmtString(config.target_assembly.?)});
 
     const dll_path = util.narrow(true, true, config.target_assembly.?);
     defer dll_path.deinit();
@@ -70,7 +70,7 @@ fn mono_doorstop_bootstrap(mono_domain: *mono.Domain) void {
         var s = mono.ImageOpenFileStatus.ok;
         const image = mono.image_open_from_file_with_name(config.target_assembly.?, &s, 0, dll_path.str);
         if (s != .ok or image == null) {
-            logger.err("Failed to open assembly: {s}. Got result: {}", .{ util.fmtString(config.target_assembly.?), s });
+            logger.err("Failed to open assembly: {f}. Got result: {}", .{ util.fmtString(config.target_assembly.?), s });
             return;
         }
         break :blk image.?;
@@ -81,7 +81,7 @@ fn mono_doorstop_bootstrap(mono_domain: *mono.Domain) void {
     var s = mono.ImageOpenStatus.ok;
     _ = mono.addrs.assembly_load_from_full.?(image, dll_path.str, &s, 0);
     if (s != .ok) {
-        logger.err("Failed to load assembly: {s}. Got result: {}", .{ util.fmtString(config.target_assembly.?), s });
+        logger.err("Failed to load assembly: {f}. Got result: {}", .{ util.fmtString(config.target_assembly.?), s });
         return;
     }
 
@@ -98,7 +98,7 @@ fn mono_doorstop_bootstrap(mono_domain: *mono.Domain) void {
         std.debug.panic("Method has {} parameters; expected 0", .{params});
     }
 
-    logger.debug("Invoking method {}", .{util.fmtAddress(method)});
+    logger.debug("Invoking method {f}", .{util.fmtAddress(method)});
     var exc: ?*mono.Object = null;
     _ = mono.addrs.runtime_invoke.?(method, null, null, &exc);
     if (exc) |e| {
@@ -174,8 +174,8 @@ fn il2cpp_doorstop_bootstrap() void {
         @panic("CoreCLR paths not set");
     };
 
-    logger.debug("CoreCLR runtime path: {}", .{util.fmtString(clr_runtime_coreclr_path)});
-    logger.debug("CoreCLR corlib dir: {}", .{util.fmtString(clr_corlib_dir)});
+    logger.debug("CoreCLR runtime path: {f}", .{util.fmtString(clr_runtime_coreclr_path)});
+    logger.debug("CoreCLR corlib dir: {f}", .{util.fmtString(clr_corlib_dir)});
 
     if (!util.paths.exists(clr_runtime_coreclr_path, .file) or
         !util.paths.exists(clr_corlib_dir, .directory))
@@ -188,7 +188,7 @@ fn il2cpp_doorstop_bootstrap() void {
         .windows => std.os.windows.LoadLibraryW(clr_runtime_coreclr_path) catch @panic("Failed to load CoreCLR runtime"),
         else => std.c.dlopen(clr_runtime_coreclr_path, .{ .LAZY = true }) orelse @panic("Failed to load CoreCLR runtime"),
     };
-    logger.debug("Loaded coreclr.dll: {}", .{util.fmtAddress(coreclr_module)});
+    logger.debug("Loaded coreclr.dll: {f}", .{util.fmtAddress(coreclr_module)});
 
     coreclr.load(coreclr_module);
 
@@ -209,9 +209,9 @@ fn il2cpp_doorstop_bootstrap() void {
     const app_paths_env_n = util.narrow(true, true, app_paths_env);
     defer app_paths_env_n.deinit();
 
-    logger.debug("App path: {}", .{util.fmtString(app_path)});
-    logger.debug("Target dir: {}", .{util.fmtString(target_dir)});
-    logger.debug("Target name: {}", .{util.fmtString(target_name)});
+    logger.debug("App path: {f}", .{util.fmtString(app_path)});
+    logger.debug("Target dir: {f}", .{util.fmtString(target_dir)});
+    logger.debug("Target name: {f}", .{util.fmtString(target_name)});
     logger.debug("APP_PATHS: {s}", .{app_paths_env_n.str});
 
     const props = "APP_PATHS";
@@ -282,11 +282,11 @@ pub fn hook_mono_jit_parse_options(argc: c_int, argv: [*][*:0]u8) callconv(.c) v
                 else => s,
             } else "127.0.0.1:10000";
 
-            debug_options = std.fmt.allocPrintZ(alloc, "--debugger-agent=transport=dt_socket,server=y,address={s}{s}{s}", .{
+            debug_options = std.fmt.allocPrintSentinel(alloc, "--debugger-agent=transport=dt_socket,server=y,address={s}{s}{s}", .{
                 mono_debug_address,
                 if (config.mono_debug_suspend) "" else ",suspend=n",
                 if (config.mono_debug_suspend or !mono_is_net35) "" else ",defer=y",
-            }) catch @panic("Out of memory");
+            }, 0) catch @panic("Out of memory");
         }
 
         logger.debug("Debug options: {s}", .{debug_options.?});
diff --git a/src/debug/env.zig b/src/debug/env.zig
@@ -10,14 +10,14 @@ pub fn dumpProgramPath() void {
     var program_path_buf: util.paths.ProgramPathBuf = undefined;
     const app_path = program_path_buf.get();
     const app_dir = util.paths.getFolderName(util.os_char, app_path);
-    logger.debug("Executable path: {}", .{util.fmtString(app_path)});
-    logger.debug("Application dir: {}", .{util.fmtString(app_dir)});
+    logger.debug("Executable path: {f}", .{util.fmtString(app_path)});
+    logger.debug("Application dir: {f}", .{util.fmtString(app_dir)});
 }
 
 pub fn dumpWorkingDir() void {
     const working_dir = util.paths.getWorkingDir() catch |e| std.debug.panic("Failed to determine current working directory path: {}", .{e});
     defer alloc.free(working_dir);
-    logger.debug("Working dir: {}", .{util.fmtString(working_dir)});
+    logger.debug("Working dir: {f}", .{util.fmtString(working_dir)});
 }
 
 pub fn dumpDoorstopPath(module: if (builtin.os.tag == .windows) std.os.windows.HMODULE else void) void {
@@ -28,5 +28,5 @@ pub fn dumpDoorstopPath(module: if (builtin.os.tag == .windows) std.os.windows.H
         else => &dumpDoorstopPath,
     }).?;
 
-    logger.debug("Doorstop library path: {}", .{util.fmtString(doorstop_path)});
+    logger.debug("Doorstop library path: {f}", .{util.fmtString(doorstop_path)});
 }
diff --git a/src/hooks.zig b/src/hooks.zig
@@ -25,10 +25,11 @@ fn hookBootConfigCommon() ?[*:0]const os_char {
             const program_path = program_path_buf.get();
             const app_folder = util.paths.getFolderName(u8, util.paths.getFolderName(u8, program_path));
 
-            break :blk std.fmt.allocPrintZ(
+            break :blk std.fmt.allocPrintSentinel(
                 alloc,
                 "{s}/Resources/Data/boot.config",
                 .{app_folder},
+                0,
             ) catch @panic("Out of memory");
         },
         else => blk: {
@@ -45,8 +46,8 @@ fn hookBootConfigCommon() ?[*:0]const os_char {
     defer alloc.free(path);
 
     defaultBootConfig = util.file_identity.getFileIdentity(null, path) catch |e| {
-        std.debug.panic("Failed to get identity of default boot.config file at \"{s}\": {}", .{
-            if (builtin.os.tag == .windows) std.unicode.fmtUtf16Le(path) else path,
+        std.debug.panic("Failed to get identity of default boot.config file at \"{f}\": {}", .{
+            util.fmtString(path),
             e,
         });
     };
@@ -183,7 +184,7 @@ fn redirectInit(
     if (std.mem.eql(u8, name, args.name)) {
         if (!initialized) {
             initialized = true;
-            logger.debug("Intercepted {s} from {}", .{ args.name, util.fmtAddress(handle) });
+            logger.debug("Intercepted {s} from {f}", .{ args.name, util.fmtAddress(handle) });
             // the old code had the next two bits swapped on nix. Test and see if it matters.
             if (args.should_capture_mono_path) {
                 // Resolve dlsym so that it can be passed to capture_mono_path.
@@ -197,7 +198,7 @@ fn redirectInit(
                 const path = buf.get(switch (builtin.os.tag) {
                     .windows => handle,
                     else => std.c.dlsym(handle, name),
-                }) orelse std.debug.panic("Failed to resolve path to module {}", .{util.fmtAddress(handle)});
+                }) orelse std.debug.panic("Failed to resolve path to module {f}", .{util.fmtAddress(handle)});
                 util.setEnv("DOORSTOP_MONO_LIB_PATH", path);
             }
             args.init_func(handle);
@@ -217,14 +218,14 @@ fn dlsym_hook(handle: util.Module(false), name_ptr: [*:0]const u8) callconv(if (
             // Documented that if the "HIWORD" is 0, the name_ptr actually specifies an
             // ordinal. On 64-bit, this seems to be implemented more like a cast,
             // checking if the upper 48 bits are 0 rather than just the upper 16.
-            logger.debug("dlsym({}, {})", .{ util.fmtAddress(handle), ordinal });
+            logger.debug("dlsym({f}, {})", .{ util.fmtAddress(handle), ordinal });
             return std.os.windows.kernel32.GetProcAddress(handle, name_ptr);
         }
     }
 
     const name = std.mem.span(name_ptr);
 
-    logger.debug("dlsym({}, \"{s}\")", .{ util.fmtAddress(handle), name });
+    logger.debug("dlsym({f}, \"{f}\")", .{ util.fmtAddress(handle), std.zig.fmtString(name) });
 
     for ([_]RedirectInitArgs{
         .{ .name = "il2cpp_init", .init_func = &runtimes.il2cpp.load, .target = &bootstrap.init_il2cpp, .should_capture_mono_path = false },
diff --git a/src/runtimes/mono.zig b/src/runtimes/mono.zig
@@ -157,7 +157,7 @@ pub fn image_open_from_file_with_name(
             .windows => blk1: {
                 const cwd = std.fs.cwd();
                 logger.debug("got cwd", .{});
-                logger.debug("opening {}", .{std.unicode.fmtUtf16Le(path)});
+                logger.debug("opening {f}", .{std.unicode.fmtUtf16Le(path)});
                 const prefixed_path = std.os.windows.wToPrefixedFileW(cwd.fd, path) catch |e| break :blk1 e;
                 break :blk1 cwd.openFileW(prefixed_path.span(), .{});
             },
diff --git a/src/util.zig b/src/util.zig
@@ -26,46 +26,30 @@ pub fn empty(comptime T: type) *[0:0]T {
 pub const FmtAddress = struct {
     addr: usize,
 
-    pub fn format(
-        self: @This(),
-        comptime fmt: []const u8,
-        _: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        if (fmt.len == 0) {
-            return writer.print(std.fmt.comptimePrint("0x{{?x:0>{}}}", .{@sizeOf(*anyopaque) * 2}), .{self.addr});
-        } else {
-            @compileError("unknown format string: '" ++ fmt ++ "'");
-        }
+    pub fn format(self: @This(), writer: *std.io.Writer) !void {
+        return writer.print(std.fmt.comptimePrint("0x{{x:0>{}}}", .{@sizeOf(*anyopaque) * 2}), .{self.addr});
     }
 };
 
 pub fn fmtAddress(ptr: anytype) FmtAddress {
     return .{ .addr = @intFromPtr(ptr) };
 }
 
-pub const FmtString = struct {
-    str: []const os_char,
+pub fn FmtString(comptime char: type) type {
+    return struct {
+        str: []const char,
 
-    pub fn format(
-        self: @This(),
-        comptime fmt: []const u8,
-        options: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        if (builtin.os.tag == .windows) {
-            return std.unicode.fmtUtf16Le(self.str).format(fmt, options, writer);
-        } else {
-            if (comptime fmt.len == 0 or std.mem.eql(u8, fmt, "s")) {
-                return writer.writeAll(self.str);
+        pub fn format(self: @This(), writer: *std.io.Writer) !void {
+            if (char == u16) {
+                return std.unicode.fmtUtf16Le(self.str).format(writer);
             } else {
-                @compileError("unknown format string: '" ++ fmt ++ "'");
+                return writer.writeAll(self.str);
             }
         }
-    }
-};
+    };
+}
 
-pub fn fmtString(str: []const os_char) FmtString {
+pub fn fmtString(str: []const os_char) FmtString(os_char) {
     return .{ .str = str };
 }
 
diff --git a/src/util/logging.zig b/src/util/logging.zig
@@ -13,17 +13,16 @@ pub fn log(
 ) void {
     const level_txt = comptime @tagName(message_level);
     const scope_txt = comptime @tagName(scope);
-    const stderr = std.io.getStdErr().writer();
-    var bw = std.io.bufferedWriter(stderr);
-    const writer = bw.writer();
+    var buf: [4096]u8 = undefined;
+    var writer = std.fs.File.stderr().writer(&buf);
 
     std.debug.lockStdErr();
     defer std.debug.unlockStdErr();
     nosuspend {
-        writer.print(
+        writer.interface.print(
             level_txt ++ " " ++ scope_txt ++ " " ++ format ++ "\n",
             args,
         ) catch return;
-        bw.flush() catch return;
+        writer.interface.flush() catch return;
     }
 }
diff --git a/src/windows/hooks.zig b/src/windows/hooks.zig
@@ -3,6 +3,7 @@ const std = @import("std");
 const root = @import("../root.zig");
 
 const alloc = root.alloc;
+const util = root.util;
 const os_char = root.util.os_char;
 
 pub var stdout_handle: ?std.os.windows.HANDLE = null;
@@ -64,18 +65,14 @@ fn genCreateFileHook(comptime char: type, comptime real_fn: CreateFileFn(char))
             }
 
             const id = root.util.file_identity.getFileIdentity(handle, &.{}) catch |e| {
-                root.logger.err("Failed to get identity of file \"{s}\": {}", .{ switch (char) {
-                    u8 => lpFileName,
-                    u16 => std.unicode.fmtUtf16Le(std.mem.span(lpFileName)),
-                    else => @compileError("Unsupported char type " ++ @typeName(char)),
-                }, e });
+                root.logger.err("Failed to get identity of file \"{f}\": {}", .{ util.FmtString(char){ .str = std.mem.span(lpFileName) }, e });
                 return handle;
             };
 
             if (root.util.file_identity.are_same(id, root.hooks.defaultBootConfig)) {
                 std.os.windows.CloseHandle(handle);
                 const boot_config_override = root.config.boot_config_override.?;
-                root.logger.debug("Overriding boot.config to \"{s}\"", .{std.unicode.fmtUtf16Le(boot_config_override)});
+                root.logger.debug("Overriding boot.config to \"{f}\"", .{std.unicode.fmtUtf16Le(boot_config_override)});
                 // caller can handle the error
                 return std.os.windows.kernel32.CreateFileW(
                     boot_config_override,
diff --git a/src/windows/iat_hook.zig b/src/windows/iat_hook.zig
@@ -87,11 +87,11 @@ fn Protected(comptime T: type) type {
 fn getDllThunk(module: std.os.windows.HMODULE, target_dll: [:0]const u8, target_function: *const anyopaque) !Protected(*const anyopaque) {
     var thunks = getDllThunks(module, target_dll) orelse return error.NoDllMatch;
 
-    logger.debug("  searching for {}", .{root.util.fmtAddress(target_function)});
+    logger.debug("  searching for {f}", .{root.util.fmtAddress(target_function)});
 
     while (thunks[0]) |*thunk| : (thunks += 1) {
         if (thunk.* == target_function) {
-            logger.debug("    found {} in {}", .{ root.util.fmtAddress(target_function), root.util.fmtAddress(thunk) });
+            logger.debug("    found {f} in {f}", .{ root.util.fmtAddress(target_function), root.util.fmtAddress(thunk) });
             return .{ .ptr = thunk };
         }
     }
