Update to Zig 0.15.0 (closes #829)

Signed-off-by: AnErrupTion <anerruption@disroot.org>

build.zig

@@ -10,7 +10,7 @@ const InitSystem = enum {
     dinit,
 };
 
-const min_zig_string = "0.14.0";
+const min_zig_string = "0.15.0";
 const current_zig = builtin.zig_version;
 
 // Implementing zig version detection through compile time
@@ -55,9 +55,11 @@ pub fn build(b: *std.Build) !void {
 
     const exe = b.addExecutable(.{
         .name = "ly",
-        .root_source_file = b.path("src/main.zig"),
+        .root_module = b.createModule(.{
-        .target = target,
+            .root_source_file = b.path("src/main.zig"),
-        .optimize = optimize,
+            .target = target,
+            .optimize = optimize,
+        }),
     });
 
     const zigini = b.dependency("zigini", .{ .target = target, .optimize = optimize });
@@ -360,7 +362,7 @@ fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion)
 
             const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
             if (version.order(ancestor_ver) != .gt) {
-                std.debug.print("{s} version '{}' must be greater than tagged ancestor '{}'\n", .{ name, version, ancestor_ver });
+                std.debug.print("{s} version '{f}' must be greater than tagged ancestor '{f}'\n", .{ name, version, ancestor_ver });
                 std.process.exit(1);
             }
 
@@ -395,8 +397,11 @@ fn patchFile(allocator: std.mem.Allocator, source_file: []const u8, patch_map: P
     var file = try std.fs.cwd().openFile(source_file, .{});
     defer file.close();
 
-    const reader = file.reader();
+    const stat = try file.stat();
-    var text = try reader.readAllAlloc(allocator, std.math.maxInt(u16));
+
+    var buffer: [4096]u8 = undefined;
+    var reader = file.reader(&buffer);
+    var text = try reader.interface.readAlloc(allocator, stat.size);
 
     var iterator = patch_map.iterator();
     while (iterator.next()) |kv| {
@@ -418,8 +423,10 @@ fn installText(
     var file = try destination_directory.createFile(destination_file, options);
     defer file.close();
 
-    const writer = file.writer();
+    var buffer: [1024]u8 = undefined;
-    try writer.writeAll(text);
+    var writer = file.writer(&buffer);
+    try writer.interface.writeAll(text);
+    try writer.interface.flush();
 
     std.debug.print("info: installed {s}/{s}\n", .{ destination_directory_path, destination_file });
 }

build.zig.zon

@@ -2,15 +2,15 @@
     .name = .ly,
     .version = "1.2.0",
     .fingerprint = 0xa148ffcc5dc2cb59,
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.15.0",
     .dependencies = .{
         .clap = .{
-            .url = "https://github.com/Hejsil/zig-clap/archive/refs/tags/0.10.0.tar.gz",
+            .url = "https://github.com/Hejsil/zig-clap/archive/refs/tags/0.11.0.tar.gz",
-            .hash = "clap-0.10.0-oBajB434AQBDh-Ei3YtoKIRxZacVPF1iSwp3IX_ZB8f0",
+            .hash = "clap-0.11.0-oBajB-HnAQDPCKYzwF7rO3qDFwRcD39Q0DALlTSz5H7e",
         },
         .zigini = .{
-            .url = "https://github.com/Kawaii-Ash/zigini/archive/2ed3d417f17fab5b0ee8cad8a63c6d62d7ac1042.tar.gz",
+            .url = "https://github.com/AnErrupTion/zigini/archive/d580d42f1b1051c0a35d63ab0f5704c6340e0bd3.tar.gz",
-            .hash = "zigini-0.3.1-BSkB7XJGAAB2E-sKyzhTaQCBlYBL8yqzE4E_jmSY99sC",
+            .hash = "zigini-0.3.2-BSkB7aVHAADhxwo0aEdWtNzaVXer3d8RwXMuZd-q-spO",
         },
         .termbox2 = .{
             .url = "git+https://github.com/AnErrupTion/termbox2?ref=get_cell#e975d250ee6567773400e9d5b0b5c2f175349c57",

readme.md

@@ -13,7 +13,7 @@ with a mirror on [GitHub](https://github.com/fairyglade/ly).
 ## Dependencies
 
 - Compile-time:
-  - zig 0.14.x
+  - zig 0.15.x
   - libc
   - pam
   - xcb (optional, required by default; needed for X11 support)

src/auth.zig

@@ -24,12 +24,12 @@ pub const AuthOptions = struct {
 };
 
 var xorg_pid: std.posix.pid_t = 0;
-pub fn xorgSignalHandler(i: c_int) callconv(.C) void {
+pub fn xorgSignalHandler(i: c_int) callconv(.c) void {
     if (xorg_pid > 0) _ = std.c.kill(xorg_pid, i);
 }
 
 var child_pid: std.posix.pid_t = 0;
-pub fn sessionSignalHandler(i: c_int) callconv(.C) void {
+pub fn sessionSignalHandler(i: c_int) callconv(.c) void {
     if (child_pid > 0) _ = std.c.kill(child_pid, i);
 }
 
@@ -114,7 +114,7 @@ pub fn authenticate(options: AuthOptions, current_environment: Environment, logi
         // If we receive SIGTERM, forward it to child_pid
         const act = std.posix.Sigaction{
             .handler = .{ .handler = &sessionSignalHandler },
-            .mask = std.posix.empty_sigset,
+            .mask = std.posix.sigemptyset(),
             .flags = 0,
         };
         std.posix.sigaction(std.posix.SIG.TERM, &act, null);
@@ -230,7 +230,7 @@ fn loginConv(
     msg: ?[*]?*const interop.pam.pam_message,
     resp: ?*?[*]interop.pam.pam_response,
     appdata_ptr: ?*anyopaque,
-) callconv(.C) c_int {
+) callconv(.c) c_int {
     const message_count: u32 = @intCast(num_msg);
     const messages = msg.?;
 
@@ -299,13 +299,15 @@ fn getXPid(display_num: u8) !i32 {
     const file = try std.fs.openFileAbsolute(file_name, .{});
     defer file.close();
 
-    var file_buf: [20]u8 = undefined;
+    var file_buffer: [32]u8 = undefined;
-    var fbs = std.io.fixedBufferStream(&file_buf);
+    var file_reader = file.reader(&file_buffer);
+    var reader = &file_reader.interface;
 
-    _ = try file.reader().streamUntilDelimiter(fbs.writer(), '\n', 20);
+    var buffer: [20]u8 = undefined;
-    const line = fbs.getWritten();
+    var writer = std.Io.Writer.fixed(&buffer);
 
-    return std.fmt.parseInt(i32, std.mem.trim(u8, line, " "), 10);
+    const written = try reader.streamDelimiter(&writer, '\n');
+    return std.fmt.parseInt(i32, std.mem.trim(u8, buffer[0..written], " "), 10);
 }
 
 fn createXauthFile(pwd: [:0]const u8) ![:0]const u8 {
@@ -452,7 +454,7 @@ fn executeX11Cmd(shell: [*:0]const u8, pw_dir: [*:0]const u8, options: AuthOptio
     // If we receive SIGTERM, clean up by killing the xorg_pid process
     const act = std.posix.Sigaction{
         .handler = .{ .handler = &xorgSignalHandler },
-        .mask = std.posix.empty_sigset,
+        .mask = std.posix.sigemptyset(),
         .flags = 0,
     };
     std.posix.sigaction(std.posix.SIG.TERM, &act, null);

src/config/migrator.zig

@@ -40,7 +40,6 @@ const removed_properties = [_][]const u8{
 };
 
 var temporary_allocator = std.heap.page_allocator;
-var buffer = std.mem.zeroes([10 * color_properties.len]u8);
 
 pub var auto_eight_colors: bool = true;
 
@@ -205,21 +204,21 @@ pub fn tryMigrateSaveFile(user_buf: *[32]u8) Save {
         var file = std.fs.openFileAbsolute(path, .{}) catch return save;
         defer file.close();
 
-        const reader = file.reader();
+        var file_buffer: [64]u8 = undefined;
+        var file_reader = file.reader(&file_buffer);
+        var reader = &file_reader.interface;
 
-        var user_fbs = std.io.fixedBufferStream(user_buf);
+        var user_writer = std.Io.Writer.fixed(user_buf);
-        reader.streamUntilDelimiter(user_fbs.writer(), '\n', user_buf.len) catch return save;
+        var written = reader.streamDelimiter(&user_writer, '\n') catch return save;
-        const user = user_fbs.getWritten();
+        if (written > 0) save.user = user_buf[0..written];
-        if (user.len > 0) save.user = user;
 
         var session_buf: [20]u8 = undefined;
-        var session_fbs = std.io.fixedBufferStream(&session_buf);
+        var session_writer = std.Io.Writer.fixed(&session_buf);
-        reader.streamUntilDelimiter(session_fbs.writer(), '\n', session_buf.len) catch return save;
+        written = reader.streamDelimiter(&session_writer, '\n') catch return save;
 
-        const session_index_str = session_fbs.getWritten();
         var session_index: ?usize = null;
-        if (session_index_str.len > 0) {
+        if (written > 0) {
-            session_index = std.fmt.parseUnsigned(usize, session_index_str, 10) catch return save;
+            session_index = std.fmt.parseUnsigned(usize, session_buf[0..written], 10) catch return save;
         }
         save.session_index = session_index;
     }

src/main.zig

@@ -36,7 +36,7 @@ const temporary_allocator = std.heap.page_allocator;
 const ly_top_str = "Ly version " ++ build_options.version;
 
 var session_pid: std.posix.pid_t = -1;
-fn signalHandler(i: c_int) callconv(.C) void {
+fn signalHandler(i: c_int) callconv(.c) void {
     if (session_pid == 0) return;
 
     // Forward signal to session to clean up
@@ -50,7 +50,7 @@ fn signalHandler(i: c_int) callconv(.C) void {
     std.c.exit(i);
 }
 
-fn ttyControlTransferSignalHandler(_: c_int) callconv(.C) void {
+fn ttyControlTransferSignalHandler(_: c_int) callconv(.c) void {
     _ = termbox.tb_shutdown();
 }
 
@@ -60,16 +60,20 @@ pub fn main() !void {
     var shutdown_cmd: []const u8 = undefined;
     var restart_cmd: []const u8 = undefined;
 
-    const stderr = std.io.getStdErr().writer();
+    var stderr_buffer: [128]u8 = undefined;
+    var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
+    var stderr = &stderr_writer.interface;
 
     defer {
         // If we can't shutdown or restart due to an error, we print it to standard error. If that fails, just bail out
         if (shutdown) {
             const shutdown_error = std.process.execv(temporary_allocator, &[_][]const u8{ "/bin/sh", "-c", shutdown_cmd });
             stderr.print("error: couldn't shutdown: {s}\n", .{@errorName(shutdown_error)}) catch std.process.exit(1);
+            stderr.flush() catch std.process.exit(1);
         } else if (restart) {
             const restart_error = std.process.execv(temporary_allocator, &[_][]const u8{ "/bin/sh", "-c", restart_cmd });
             stderr.print("error: couldn't restart: {s}\n", .{@errorName(restart_error)}) catch std.process.exit(1);
+            stderr.flush() catch std.process.exit(1);
         } else {
             // The user has quit Ly using Ctrl+C
             temporary_allocator.free(shutdown_cmd);
@@ -97,6 +101,7 @@ pub fn main() !void {
     var diag = clap.Diagnostic{};
     var res = clap.parse(clap.Help, &params, clap.parsers.default, .{ .diagnostic = &diag, .allocator = allocator }) catch |err| {
         diag.report(stderr, err) catch {};
+        try stderr.flush();
         return err;
     };
     defer res.deinit();
@@ -112,10 +117,12 @@ pub fn main() !void {
         try clap.help(stderr, clap.Help, &params, .{});
 
         _ = try stderr.write("Note: if you want to configure Ly, please check the config file, which is located at " ++ build_options.config_directory ++ "/ly/config.ini.\n");
+        try stderr.flush();
         std.process.exit(0);
     }
     if (res.args.version != 0) {
         _ = try stderr.write("Ly version " ++ build_options.version ++ "\n");
+        try stderr.flush();
         std.process.exit(0);
     }
 
@@ -222,17 +229,9 @@ pub fn main() !void {
         log_file = try std.fs.openFileAbsolute("/dev/null", .{ .mode = .write_only });
     }
 
-    const log_writer = log_file.writer();
+    var log_buffer: [1024]u8 = undefined;
-
+    var log_file_writer = log_file.writer(&log_buffer);
-    // if (migrator.mapped_config_fields) save_migrated_config: {
+    var log_writer = &log_file_writer.interface;
-    //     var file = try std.fs.cwd().createFile(config_path, .{});
-    //     defer file.close();
-
-    //     const writer = file.writer();
-    //     ini.writeFromStruct(config, writer, null, true, .{}) catch {
-    //         break :save_migrated_config;
-    //     };
-    // }
 
     // These strings only end up getting freed if the user quits Ly using Ctrl+C, which is fine since in the other cases
     // we end up shutting down or restarting the system
@@ -249,7 +248,7 @@ pub fn main() !void {
 
     const act = std.posix.Sigaction{
         .handler = .{ .handler = &signalHandler },
-        .mask = std.posix.empty_sigset,
+        .mask = std.posix.sigemptyset(),
         .flags = 0,
     };
     std.posix.sigaction(std.posix.SIG.TERM, &act, null);
@@ -818,11 +817,16 @@ pub fn main() !void {
                     var file = std.fs.cwd().createFile(save_path, .{}) catch break :save_last_settings;
                     defer file.close();
 
+                    var file_buffer: [64]u8 = undefined;
+                    var file_writer = file.writer(&file_buffer);
+                    var writer = &file_writer.interface;
+
                     const save_data = Save{
                         .user = login.getCurrentUser(),
                         .session_index = session.label.current,
                     };
-                    ini.writeFromStruct(save_data, file.writer(), null, .{}) catch break :save_last_settings;
+                    ini.writeFromStruct(save_data, writer, null, .{}) catch break :save_last_settings;
+                    try writer.flush();
 
                     // Delete previous save file if it exists
                     if (migrator.maybe_save_file) |path| std.fs.cwd().deleteFile(path) catch {};
@@ -855,7 +859,7 @@ pub fn main() !void {
                         // Signal action to give up control on the TTY
                         const tty_control_transfer_act = std.posix.Sigaction{
                             .handler = .{ .handler = &ttyControlTransferSignalHandler },
-                            .mask = std.posix.empty_sigset,
+                            .mask = std.posix.sigemptyset(),
                             .flags = 0,
                         };
                         std.posix.sigaction(std.posix.SIG.CHLD, &tty_control_transfer_act, null);