LordMZTE/dotfiles
1
0
Fork 0
mirror of https://mzte.de/git/LordMZTE/dotfiles.git synced 2024-12-12 21:32:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

port to latest Zig

Browse source 
mostly pointless but gigantic stdlib refactor, typical.
This commit is contained in:
LordMZTE 2024-03-23 16:58:27 +01:00
parent c5dc5dd1e9
commit 76d2c2887a
Signed by: LordMZTE
GPG key ID: B64802DC33A64FF6
21 changed files with 76 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
plugins/mzte-mpv/src/modules/LiveChat.zig
View file

@ -7,6 +7,8 @@ const c = ffi.c;
const ffi = @import("../ffi.zig");
const util = @import("../util.zig");
const log = std.log.scoped(.@"live-chat");
// Zig segfaults when this is a ZST
padding: u1 = 0,
@ -33,9 +35,9 @@ pub fn onEvent(self: *LiveChat, mpv: *c.mpv_handle, ev: *c.mpv_event) !void {
else => return e,
};
errdefer file.close();
std.log.info("initializing subtitle transcoder: {s}", .{fname});
log.info("initializing subtitle transcoder: {s}", .{fname});
const pipe = try std.os.pipe2(.{});
const pipe = try std.posix.pipe2(.{});
// This needs to be done here instead of the separate thread. MPV will instantly
// give up if there's nothing to be read from the pipe when the command is called.
@ -85,7 +87,7 @@ fn transcoderThread(jsonf: std.fs.File, pipefd: std.c.fd_t) !void {
else => return e,
};
processLine(line_buf.items, pipe.writer()) catch |e| {
std.log.warn("failed to parse chat entry: {}", .{e});
log.warn("failed to parse chat entry: {}", .{e});
};
}

4
plugins/mzte-mpv/src/modules/SBSkip.zig
View file

@ -4,6 +4,8 @@ const c = ffi.c;
const ffi = @import("../ffi.zig");
const util = @import("../util.zig");
const log = std.log.scoped(.@"sb-skip");
const ChapterSet = std.AutoHashMap(isize, void);
skipped_chapters: ChapterSet,
@ -84,7 +86,7 @@ fn onChapterChange(
@constCast(&end_time),
));
try self.skipped_chapters.put(chapter_id, {});
try util.msg(mpv, "skipped: {s}", .{reason});
try util.msg(mpv, .@"sb-skip", "skipped: {s}", .{reason});
}
}

11
plugins/mzte-mpv/src/util.zig
View file

@ -3,11 +3,16 @@ const c = ffi.c;
const ffi = @import("ffi.zig");
pub fn msg(mpv: *c.mpv_handle, comptime fmt: []const u8, args: anytype) !void {
std.log.info(fmt, args);
pub fn msg(
mpv: *c.mpv_handle,
scope: @TypeOf(.enum_tag),
comptime fmt: []const u8,
args: anytype,
) !void {
std.log.scoped(scope).info(fmt, args);
var buf: [1024 * 4]u8 = undefined;
const osd_msg = try std.fmt.bufPrintZ(&buf, "[sbskip] " ++ fmt, args);
const osd_msg = try std.fmt.bufPrintZ(&buf, "[mzte-mpv " ++ @tagName(scope) ++ "] " ++ fmt, args);
try ffi.checkMpvError(c.mpv_command(
mpv,
@constCast(&[_:null]?[*:0]const u8{ "show-text", osd_msg, "4000" }),

22
scripts/alecor/src/cache.zig
View file

@ -2,7 +2,7 @@ const std = @import("std");
pub fn commandsCachePath(alloc: std.mem.Allocator) ![]const u8 {
return try std.fs.path.join(alloc, &.{
std.os.getenv("HOME") orelse return error.HomeNotSet,
std.posix.getenv("HOME") orelse return error.HomeNotSet,
".cache",
"alecor",
"commands",
@ -20,26 +20,26 @@ pub fn generate(alloc: std.mem.Allocator) !void {
var cache_file = try std.fs.cwd().createFile(cache_path, .{});
defer cache_file.close();
const pipefds = try std.os.pipe();
defer std.os.close(pipefds[0]);
const pipefds = try std.posix.pipe();
defer std.posix.close(pipefds[0]);
var stdout_buf_reader = std.io.bufferedReader((std.fs.File{ .handle = pipefds[0] }).reader());
// ChildProcess being useless again...
const pid = try std.os.fork();
const pid = try std.posix.fork();
if (pid == 0) {
errdefer std.os.exit(1);
try std.os.dup2(pipefds[1], 1);
std.os.close(pipefds[0]);
std.os.close(pipefds[1]);
return std.os.execvpeZ(
errdefer std.posix.exit(1);
try std.posix.dup2(pipefds[1], 1);
std.posix.close(pipefds[0]);
std.posix.close(pipefds[1]);
return std.posix.execvpeZ(
"fish",
&[_:null]?[*:0]const u8{ "fish", "-c", "complete -C ''" },
@ptrCast(std.os.environ.ptr),
);
}
std.os.close(pipefds[1]);
std.posix.close(pipefds[1]);
var cmd_buf: [1024]u8 = undefined;
var fbs = std.io.fixedBufferStream(&cmd_buf);
@ -56,5 +56,5 @@ pub fn generate(alloc: std.mem.Allocator) !void {
try cache_file.writer().writeByte('\n');
}
_ = std.os.waitpid(pid, 0);
_ = std.posix.waitpid(pid, 0);
}

2
scripts/alecor/src/correct.zig
View file

@ -170,7 +170,7 @@ fn correctArgForReq(arena: *std.heap.ArenaAllocator, req: ArgRequirement, arg: *
while (path_spliter.next()) |split| {
if (std.mem.eql(u8, split, "~")) {
try path_splits.append(std.os.getenv("HOME") orelse return error.HomeNotSet);
try path_splits.append(std.posix.getenv("HOME") orelse return error.HomeNotSet);
} else {
try path_splits.append(split);
}

6
scripts/alecor/src/main.zig
View file

@ -36,15 +36,15 @@ pub fn main() !void {
var cache_file = try std.fs.cwd().openFile(cache_path, .{});
defer cache_file.close();
const cache_content = try std.os.mmap(
const cache_content = try std.posix.mmap(
null,
(try cache_file.stat()).size,
std.os.PROT.READ,
std.posix.PROT.READ,
.{ .TYPE = .PRIVATE },
cache_file.handle,
0,
);
defer std.os.munmap(cache_content);
defer std.posix.munmap(cache_content);
var command_set = std.StringHashMap(void).init(alloc);
defer command_set.deinit();

2
scripts/hyprtool/src/main.zig
View file

@ -9,7 +9,7 @@ pub fn main() !void {
if (std.os.argv.len != 2 or !std.mem.eql(u8, std.mem.span(std.os.argv[1]), "fullerscreen"))
return error.InvalidArgs;
const inst_sig = std.os.getenv("HYPRLAND_INSTANCE_SIGNATURE") orelse
const inst_sig = std.posix.getenv("HYPRLAND_INSTANCE_SIGNATURE") orelse
return error.MissingInstanceSignature;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};

10
scripts/mzteinit/src/main.zig
View file

@ -44,7 +44,7 @@ pub fn main() void {
}
std.debug.print("Encountered fatal error (check log), starting emergency shell!\n", .{});
@panic(@errorName(std.os.execveZ(
@panic(@errorName(std.posix.execveZ(
"/bin/sh",
&[_:null]?[*:0]const u8{"/bin/sh"},
&[_:null]?[*:0]const u8{},
@ -187,7 +187,7 @@ fn ui(buf_writer: anytype, entries: []command.Command) !command.Command {
var style: ?at.style.Style = null;
try @import("figlet.zig").writeFiglet(w);
const uname = std.os.uname();
const uname = std.posix.uname();
try updateStyle(w, .{ .foreground = .Yellow }, &style);
try w.print(
"\n {s} {s} {s}\n\n",
@ -212,11 +212,11 @@ fn ui(buf_writer: anytype, entries: []command.Command) !command.Command {
try buf_writer.flush();
const old_termios = try std.os.tcgetattr(std.os.STDIN_FILENO);
const old_termios = try std.posix.tcgetattr(std.posix.STDIN_FILENO);
var new_termios = old_termios;
new_termios.lflag.ICANON = false; // No line buffering
new_termios.lflag.ECHO = false; // No echoing stuff
try std.os.tcsetattr(std.os.STDIN_FILENO, .NOW, new_termios);
try std.posix.tcsetattr(std.posix.STDIN_FILENO, .NOW, new_termios);
var cmd: ?command.Command = null;
var c: [1]u8 = undefined;
@ -233,7 +233,7 @@ fn ui(buf_writer: anytype, entries: []command.Command) !command.Command {
try buf_writer.flush();
}
}
try std.os.tcsetattr(std.os.STDIN_FILENO, .NOW, old_termios);
try std.posix.tcsetattr(std.posix.STDIN_FILENO, .NOW, old_termios);
return cmd.?;
}

6
scripts/mzteinit/src/mzteinitctl.zig
View file

@ -19,7 +19,7 @@ pub fn main() !void {
if (std.mem.eql(u8, verb, "ping")) {
const client = try Client.connect(
std.os.getenv("MZTEINIT_SOCKET") orelse return error.SocketPathUnknown,
std.posix.getenv("MZTEINIT_SOCKET") orelse return error.SocketPathUnknown,
);
defer client.deinit();
@ -28,7 +28,7 @@ pub fn main() !void {
if (std.os.argv.len < 3)
return error.InvalidArgs;
const client = if (std.os.getenv("MZTEINIT_SOCKET")) |sockpath|
const client = if (std.posix.getenv("MZTEINIT_SOCKET")) |sockpath|
try Client.connect(sockpath)
else nosock: {
std.log.warn("MZTEINIT_SOCKET not set", .{});
@ -44,7 +44,7 @@ pub fn main() !void {
const val = mzteinit_val orelse getenv: {
std.log.warn("Variable not known to MZTEINIT, falling back to current environment.", .{});
break :getenv std.os.getenv(std.mem.span(std.os.argv[2]));
break :getenv std.posix.getenv(std.mem.span(std.os.argv[2]));
};
if (val) |v| {

2
scripts/mzteinit/src/util.zig
View file

@ -48,7 +48,7 @@ pub fn fmtCommand(cmd: []const []const u8) std.fmt.Formatter(formatCommand) {
}
pub fn findInPath(alloc: std.mem.Allocator, bin: []const u8) !?[]const u8 {
const path = std.os.getenv("PATH") orelse return null;
const path = std.posix.getenv("PATH") orelse return null;
var splits = std.mem.split(u8, path, ":");
while (splits.next()) |p| {

4
scripts/mzteriver/build.zig.zon
View file

@ -5,8 +5,8 @@
.dependencies = .{
.common = .{ .path = "../../lib/common-zig" },
.wayland = .{
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4de9f2d6d5fddae1fbb29e21fd1dae69e646ab7d",
.hash = "1220d6448c277e5c41348aa95ce2ba2fc92a92cb7a9e9783edf0f816cd0260122d31",
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4f4ade382d582845b092de450527e3e7e0133f07",
.hash = "122087ee3bdff43049bf1d58513622c5f3c1430308665af0ee8961a22b60c4c10c1a",
},
},

2
scripts/mzteriver/src/init.zig
View file

@ -163,7 +163,7 @@ pub fn init(alloc: std.mem.Allocator, initial: bool) !void {
try con.runCommand(&.{ "default-layout", "rivertile" });
const home = std.os.getenv("HOME") orelse return error.HomeNotSet;
const home = std.posix.getenv("HOME") orelse return error.HomeNotSet;
const init_path = try std.fs.path.join(
alloc,
&.{ home, ".config", "mzte_localconf", "river_init" },

14
scripts/mzteriver/src/main.zig
View file

@ -43,8 +43,8 @@ pub fn main() !void {
std.log.info("river log file: {s}", .{logf_path});
break :logf try std.os.openatZ(
std.os.AT.FDCWD,
break :logf try std.posix.openatZ(
std.posix.AT.FDCWD,
logf_path.ptr,
// no CLOEXEC
.{
@ -56,13 +56,13 @@ pub fn main() !void {
);
};
{
errdefer std.os.close(logfd);
errdefer std.posix.close(logfd);
// redirect river's STDERR and STDOUT to log file
try std.os.dup2(logfd, std.os.STDOUT_FILENO);
try std.os.dup2(logfd, std.os.STDERR_FILENO);
try std.posix.dup2(logfd, std.posix.STDOUT_FILENO);
try std.posix.dup2(logfd, std.posix.STDERR_FILENO);
}
std.os.close(logfd);
std.posix.close(logfd);
var env = std.BoundedArray(?[*:0]const u8, 0xff).init(0) catch unreachable;
const envp: [*:null]?[*:0]const u8 = env: {
@ -81,6 +81,6 @@ pub fn main() !void {
break :env @ptrCast(env.slice().ptr);
};
return std.os.execvpeZ("river", &[_:null]?[*:0]const u8{"river"}, envp);
return std.posix.execvpeZ("river", &[_:null]?[*:0]const u8{"river"}, envp);
}
}

8
scripts/playvid/src/main.zig
View file

@ -10,7 +10,7 @@ pub fn main() !u8 {
defer _ = gpa.deinit();
const alloc = gpa.allocator();
var file_buf: [std.os.PATH_MAX]u8 = undefined;
var file_buf: [std.posix.PATH_MAX]u8 = undefined;
const file = try findVideoFile(alloc, &file_buf);
try std.io.getStdOut().writer().print("playing: `{s}`\n", .{file});
@ -68,11 +68,11 @@ fn findVideoFile(alloc: std.mem.Allocator, out_buf: []u8) ![]const u8 {
fn promtForDeletion(file: []const u8) !bool {
try std.io.getStdOut().writer().print("delete file `{s}`? [Y/N] ", .{file});
const old_termios = try std.os.tcgetattr(std.os.STDIN_FILENO);
const old_termios = try std.posix.tcgetattr(std.posix.STDIN_FILENO);
var new_termios = old_termios;
new_termios.lflag.ICANON = false; // No line buffering
try std.os.tcsetattr(std.os.STDIN_FILENO, .NOW, new_termios);
defer std.os.tcsetattr(std.os.STDIN_FILENO, .NOW, old_termios) catch {};
try std.posix.tcsetattr(std.posix.STDIN_FILENO, .NOW, new_termios);
defer std.posix.tcsetattr(std.posix.STDIN_FILENO, .NOW, old_termios) catch {};
const answer = try std.io.getStdIn().reader().readByte();
const ret = switch (answer) {

8
scripts/prompt/src/main.zig
View file

@ -31,23 +31,23 @@ pub fn main() !void {
const options = prompt.Options{
.status = try std.fmt.parseInt(
i16,
std.os.getenv("MZPROMPT_STATUS") orelse
std.posix.getenv("MZPROMPT_STATUS") orelse
return error.MissingEnv,
10,
),
.mode = FishMode.parse(
std.os.getenv("MZPROMPT_FISH_MODE") orelse
std.posix.getenv("MZPROMPT_FISH_MODE") orelse
return error.MissingEnv,
),
.duration = try std.fmt.parseInt(
u32,
std.os.getenv("MZPROMPT_DURATION") orelse
std.posix.getenv("MZPROMPT_DURATION") orelse
return error.MissingEnv,
10,
),
.jobs = try std.fmt.parseInt(
u32,
std.os.getenv("MZPROMPT_JOBS") orelse
std.posix.getenv("MZPROMPT_JOBS") orelse
return error.MissingEnv,
10,
),

2
scripts/prompt/src/prompt.zig
View file

@ -149,7 +149,7 @@ fn Renderer(comptime Writer: type) type {
fn renderCwd(self: *Self) !void {
var cwd_buf: [512]u8 = undefined;
const cwd = try std.os.getcwd(&cwd_buf);
const cwd = try std.posix.getcwd(&cwd_buf);
const home_path = (try known_folders.getPath(std.heap.c_allocator, .home));

4
scripts/randomwallpaper/src/main.zig
View file

@ -9,8 +9,8 @@ pub const std_options = std.Options{
pub fn main() !u8 {
const alloc = std.heap.c_allocator;
const home_s = std.os.getenv("HOME") orelse return error.HomeNotSet;
const runtime_dir = std.os.getenv("XDG_RUNTIME_DIR") orelse return error.MissingRuntimeDir;
const home_s = std.posix.getenv("HOME") orelse return error.HomeNotSet;
const runtime_dir = std.posix.getenv("XDG_RUNTIME_DIR") orelse return error.MissingRuntimeDir;
var walker = Walker.init(alloc);
defer walker.deinit();

4
scripts/vinput/build.zig.zon
View file

@ -5,8 +5,8 @@
.dependencies = .{
.common = .{ .path = "../../lib/common-zig" },
.wayland = .{
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4de9f2d6d5fddae1fbb29e21fd1dae69e646ab7d",
.hash = "1220d6448c277e5c41348aa95ce2ba2fc92a92cb7a9e9783edf0f816cd0260122d31",
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4f4ade382d582845b092de450527e3e7e0133f07",
.hash = "122087ee3bdff43049bf1d58513622c5f3c1430308665af0ee8961a22b60c4c10c1a",
},
},
}

10
scripts/vinput/src/ClipboardConnection.zig
View file

@ -50,9 +50,9 @@ const PopupWindow = struct {
const stride = width * 4;
const size = stride * height; // 1x1x4 bytes
const memfd = try std.os.memfd_create("surface_shm", 0);
defer std.os.close(memfd);
try std.os.ftruncate(memfd, size);
const memfd = try std.posix.memfd_create("surface_shm", 0);
defer std.posix.close(memfd);
try std.posix.ftruncate(memfd, size);
const shm_pool = try cc.shm.createPool(memfd, size);
errdefer shm_pool.destroy();
@ -123,9 +123,9 @@ pub fn deinit(self: *ClipboardConnection) void {
self.* = undefined;
}
pub fn getContent(self: *ClipboardConnection, out_fd: std.os.fd_t) !void {
pub fn getContent(self: *ClipboardConnection, out_fd: std.posix.fd_t) !void {
const DataDeviceListener = struct {
out_fd: std.os.fd_t,
out_fd: std.posix.fd_t,
display: *wl.Display,
fn onEvent(_: *wl.DataDevice, ev: wl.DataDevice.Event, ddl: *@This()) void {

6
scripts/vinput/src/main.zig
View file

@ -83,15 +83,15 @@ pub fn main() !void {
std.log.info("mmapping tempfile", .{});
const fcontent = try std.os.mmap(
const fcontent = try std.posix.mmap(
null,
stat.size,
std.os.PROT.READ,
std.posix.PROT.READ,
.{ .TYPE = .PRIVATE },
tempfile.handle,
0,
);
defer std.os.munmap(fcontent);
defer std.posix.munmap(fcontent);
try cp.serveContent(std.mem.trim(u8, fcontent, " \n\r"));
}

8
scripts/wlbg/build.zig.zon
View file

@ -5,12 +5,12 @@
.dependencies = .{
.common = .{ .path = "../../lib/common-zig" },
.wayland = .{
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4de9f2d6d5fddae1fbb29e21fd1dae69e646ab7d",
.hash = "1220d6448c277e5c41348aa95ce2ba2fc92a92cb7a9e9783edf0f816cd0260122d31",
.url = "git+https://git.mzte.de/LordMZTE/zig-wayland#4f4ade382d582845b092de450527e3e7e0133f07",
.hash = "122087ee3bdff43049bf1d58513622c5f3c1430308665af0ee8961a22b60c4c10c1a",
},
.xev = .{
.url = "git+https://github.com/mitchellh/libxev#418cac65473668b02cc5a85194042bdaf04acd00",
.hash = "12203116ff408eb48f81c947dfeb06f7feebf6a9efa962a560ac69463098b2c04a96",
.url = "git+https://github.com/mitchellh/libxev#0f73adfda1cff9c740160717b5431ebada6b8755",
.hash = "12203dcbe098ee49ea242432cd198b1ca557626988f056bea86630dcfe8660244407",
},
},
}