srctree

Gregory Mullen parent e733e54f f51942f7
upgrade to zig v0.12.0-dev.3508

src/builtins.zig added: 155, removed: 161, total 0
@@ -206,7 +206,7 @@ fn exit(hsh: *HSH, i: *ParsedIterator) Err!u8 {
hsh.tty.raze();
hsh.tkn.raze();
hsh.raze();
std.os.exit(code);
std.posix.exit(code);
}
 
/// TODO implement job selection support
 
src/exec.zig added: 155, removed: 161, total 0
@@ -14,7 +14,7 @@ const Parser = parse.Parser;
const ParsedIterator = parse.ParsedIterator;
const log = @import("log");
const mem = std.mem;
const fd_t = std.os.fd_t;
const fd_t = std.posix.fd_t;
const bi = @import("builtins.zig");
const fs = @import("fs.zig");
const signal = @import("signals.zig");
@@ -22,9 +22,9 @@ const logic_ = @import("logic.zig");
const Variables = @import("variables.zig");
const Funcs = @import("funcs.zig");
 
const STDIN_FILENO = std.os.STDIN_FILENO;
const STDOUT_FILENO = std.os.STDOUT_FILENO;
const STDERR_FILENO = std.os.STDERR_FILENO;
const STDIN_FILENO = std.posix.STDIN_FILENO;
const STDOUT_FILENO = std.posix.STDOUT_FILENO;
const STDERR_FILENO = std.posix.STDERR_FILENO;
 
pub const Error = error{
InvalidSrc,
@@ -258,7 +258,7 @@ fn mkCallableStack(a: Allocator, itr: *TokenIterator) Error![]CallableStack {
if (peek.kind == .oper) {
switch (peek.kind.oper) {
.Pipe => {
const pipe = std.os.pipe2(.{}) catch return Error.OSErr;
const pipe = std.posix.pipe2(.{}) catch return Error.OSErr;
io.pipe = true;
io.out = pipe[1];
prev_stdout = pipe[0];
@@ -291,7 +291,7 @@ fn mkCallableStack(a: Allocator, itr: *TokenIterator) Error![]CallableStack {
},
.In, .HDoc => {
if (prev_stdout) |out| {
std.os.close(out);
std.posix.close(out);
prev_stdout = null;
}
if (fs.openFile(maybeio.cannon(), true)) |file| {
@@ -351,7 +351,7 @@ fn execBin(e: Binary) Error!void {
// TODO manage env
 
const environ = Variables.henviron();
const res = std.os.execveZ(e.arg, e.argv, @ptrCast(environ));
const res = std.posix.execveZ(e.arg, e.argv, @ptrCast(environ));
switch (res) {
error.FileNotFound => {
// we validate exes internally now this should be impossible
@@ -448,7 +448,7 @@ pub fn exec(h_: *HSH, input: []const u8) Error!void {
// api in this commit
//const environ = Variables.henviron();
 
var fpid: std.os.pid_t = 0;
var fpid: std.posix.pid_t = 0;
for (stack) |*s| {
defer free(a, s);
if (s.conditional) |cond| {
@@ -474,24 +474,24 @@ pub fn exec(h_: *HSH, input: []const u8) Error!void {
};
}
 
fpid = std.os.fork() catch return Error.OSErr;
fpid = std.posix.fork() catch return Error.OSErr;
if (fpid == 0) {
if (s.stdio.in != std.os.STDIN_FILENO) {
std.os.dup2(s.stdio.in, std.os.STDIN_FILENO) catch return Error.OSErr;
std.os.close(s.stdio.in);
if (s.stdio.in != std.posix.STDIN_FILENO) {
std.posix.dup2(s.stdio.in, std.posix.STDIN_FILENO) catch return Error.OSErr;
std.posix.close(s.stdio.in);
}
if (s.stdio.out != std.os.STDOUT_FILENO) {
std.os.dup2(s.stdio.out, std.os.STDOUT_FILENO) catch return Error.OSErr;
std.os.close(s.stdio.out);
if (s.stdio.out != std.posix.STDOUT_FILENO) {
std.posix.dup2(s.stdio.out, std.posix.STDOUT_FILENO) catch return Error.OSErr;
std.posix.close(s.stdio.out);
}
if (s.stdio.err != std.os.STDERR_FILENO) {
std.os.dup2(s.stdio.err, std.os.STDERR_FILENO) catch return Error.OSErr;
std.os.close(s.stdio.err);
if (s.stdio.err != std.posix.STDERR_FILENO) {
std.posix.dup2(s.stdio.err, std.posix.STDERR_FILENO) catch return Error.OSErr;
std.posix.close(s.stdio.err);
}
 
switch (s.callable) {
.builtin => |*b| {
std.os.exit(try execBuiltin(h_, b));
std.posix.exit(try execBuiltin(h_, b));
},
.exec => |e| {
try execBin(e);
@@ -517,9 +517,9 @@ pub fn exec(h_: *HSH, input: []const u8) Error!void {
.pid = fpid,
.name = try a.dupe(u8, name),
});
if (s.stdio.in != std.os.STDIN_FILENO) std.os.close(s.stdio.in);
if (s.stdio.out != std.os.STDOUT_FILENO) std.os.close(s.stdio.out);
if (s.stdio.err != std.os.STDERR_FILENO) std.os.close(s.stdio.err);
if (s.stdio.in != std.posix.STDIN_FILENO) std.posix.close(s.stdio.in);
if (s.stdio.out != std.posix.STDOUT_FILENO) std.posix.close(s.stdio.out);
if (s.stdio.err != std.posix.STDERR_FILENO) std.posix.close(s.stdio.err);
}
 
_ = jobs.waitForFg();
@@ -580,21 +580,21 @@ pub fn child(a: Allocator, argv: []const []const u8) !ChildResult {
/// Preformatted version of child. Accepts the null, and 0 terminated versions
/// to pass directly to exec. Caller maintains ownership of argv
pub fn childZ(a: Allocator, argv: [:null]const ?[*:0]const u8) Error!ChildResult {
const pipe = std.os.pipe2(.{}) catch unreachable;
const pid = std.os.fork() catch unreachable;
const pipe = std.posix.pipe2(.{}) catch unreachable;
const pid = std.posix.fork() catch unreachable;
if (pid == 0) {
// we kid nao
std.os.dup2(pipe[1], std.os.STDOUT_FILENO) catch unreachable;
std.os.close(pipe[0]);
std.os.close(pipe[1]);
std.os.execvpeZ(argv[0].?, argv.ptr, @ptrCast(std.os.environ)) catch {
std.posix.dup2(pipe[1], std.posix.STDOUT_FILENO) catch unreachable;
std.posix.close(pipe[0]);
std.posix.close(pipe[1]);
std.posix.execvpeZ(argv[0].?, argv.ptr, @ptrCast(std.os.environ)) catch {
log.err("Unexpected error in childZ\n", .{});
return Error.ChildExecFailed;
};
unreachable;
}
std.os.close(pipe[1]);
defer std.os.close(pipe[0]);
std.posix.close(pipe[1]);
defer std.posix.close(pipe[0]);
const name = std.mem.span(argv[0].?);
try jobs.add(jobs.Job{
.status = .child,
 
src/fs.zig added: 155, removed: 161, total 0
@@ -97,7 +97,7 @@ pub fn init(a: mem.Allocator, env: std.process.EnvMap) !fs {
.path = env.get("PATH"),
.paths = paths,
},
.inotify_fd = std.os.inotify_init1(std.os.linux.IN.CLOEXEC | std.os.linux.IN.NONBLOCK) catch null,
.inotify_fd = @intCast((std.os.linux.inotify_init1(std.os.linux.IN.CLOEXEC | std.os.linux.IN.NONBLOCK))),
.watches = .{null},
};
 
@@ -132,7 +132,7 @@ pub fn inotifyInstallRc(self: *fs, cb: ?INotify.Callback) !void {
pub fn checkINotify(self: *fs, h: *HSH) bool {
if (self.inotify_fd) |fd| {
var buf: [4096]u8 align(@alignOf(std.os.linux.inotify_event)) = undefined;
const rcount = std.os.read(fd, &buf) catch return true;
const rcount = std.posix.read(fd, &buf) catch return true;
if (rcount > 0) {
if (rcount < @sizeOf(std.os.linux.inotify_event)) {
log.err(
 
src/hsh.zig added: 155, removed: 161, total 0
@@ -183,8 +183,8 @@ pub const HSH = struct {
features: hshFeature,
env: std.process.EnvMap,
hfs: fs,
pid: std.os.pid_t,
pgrp: std.os.pid_t = -1,
pid: std.posix.pid_t,
pgrp: std.posix.pid_t = -1,
jobs: *jobs.Jobs,
tty: TTY = undefined,
draw: Drawable = undefined,
 
src/inotify.zig added: 155, removed: 161, total 0
@@ -27,7 +27,7 @@ callback: ?Callback,
 
pub fn init(infd: i32, path: []const u8, cb: ?Callback) !INotify {
return .{
.wdes = try std.os.inotify_add_watch(infd, path, std.os.linux.IN.ALL_EVENTS),
.wdes = try std.posix.inotify_add_watch(infd, path, std.os.linux.IN.ALL_EVENTS),
.path = path,
.callback = cb,
};
 
src/input.zig added: 155, removed: 161, total 0
@@ -63,24 +63,24 @@ pub fn do(in: *Input, hsh: *HSH, comp: *complete.CompSet) !Event {
return if (in.interact) in.interactive(hsh, comp) else in.nonInteractive(hsh, comp);
}
 
fn read(fd: std.os.fd_t, buf: []u8) !usize {
const rc = std.os.linux.read(fd, buf.ptr, buf.len);
switch (std.os.linux.getErrno(rc)) {
.SUCCESS => return @intCast(rc),
.INTR => return error.Interupted,
.AGAIN => return error.WouldBlock,
.BADF => return error.NotOpenForReading, // Can be a race condition.
.IO => return error.InputOutput,
.ISDIR => return error.IsDir,
.NOBUFS => return error.SystemResources,
.NOMEM => return error.SystemResources,
.CONNRESET => return error.ConnectionResetByPeer,
.TIMEDOUT => return error.ConnectionTimedOut,
else => |err| {
std.debug.print("unexpected read err {}\n", .{err});
@panic("unknown read error\n");
},
}
fn read(fd: std.posix.fd_t, buf: []u8) !usize {
return std.posix.read(fd, buf);
// switch (std.posix.errno(rc)) {
// .SUCCESS => return @intCast(rc),
// .INTR => return error.Interupted,
// .AGAIN => return error.WouldBlock,
// .BADF => return error.NotOpenForReading, // Can be a race condition.
// .IO => return error.InputOutput,
// .ISDIR => return error.IsDir,
// .NOBUFS => return error.SystemResources,
// .NOMEM => return error.SystemResources,
// .CONNRESET => return error.ConnectionResetByPeer,
// .TIMEDOUT => return error.ConnectionTimedOut,
// else => |err| {
// std.debug.print("unexpected read err {}\n", .{err});
// @panic("unknown read error\n");
// },
// }
}
 
fn doComplete(hsh: *HSH, tkn: *Tokenizer, comp: *complete.CompSet) !Mode {
 
src/jobs.zig added: 155, removed: 161, total 0
@@ -34,11 +34,11 @@ pub const Status = enum {
 
pub const Job = struct {
name: ?[]const u8 = null,
pid: std.os.pid_t = -1,
pgid: std.os.pid_t = -1,
pid: std.posix.pid_t = -1,
pgid: std.posix.pid_t = -1,
exit_code: ?u8 = null,
status: Status = .unknown,
termattr: ?std.os.termios = null,
termattr: ?std.posix.termios = null,
 
pub fn alive(self: Job) bool {
return self.status.alive();
@@ -57,7 +57,7 @@ pub const Job = struct {
self.status = .waiting;
}
 
pub fn background(self: *Job, tio: std.os.termios) void {
pub fn background(self: *Job, tio: std.posix.termios) void {
self.status = .background;
self.termattr = tio;
}
@@ -69,7 +69,7 @@ pub const Job = struct {
tty.setTTY(tio);
}
self.status = .running;
std.os.kill(self.pid, std.os.SIG.CONT) catch unreachable;
std.posix.kill(self.pid, std.posix.SIG.CONT) catch unreachable;
return true;
}
 
@@ -117,7 +117,7 @@ pub fn raze(a: Allocator) void {
jobs.clearAndFree();
}
 
pub fn get(jid: std.os.pid_t) Error!*Job {
pub fn get(jid: std.posix.pid_t) Error!*Job {
for (jobs.items) |*j| {
if (j.pid == jid) {
return j;
@@ -203,15 +203,15 @@ const WaitError = if (@hasDecl(std.os, "WaitError")) std.os.WaitError else error
CHILD,
};
 
fn hsh_waitpid(pid: std.os.pid_t, flags: u32) WaitError!std.os.WaitPidResult {
fn hsh_waitpid(pid: std.posix.pid_t, flags: u32) WaitError!std.posix.WaitPidResult {
const Status_t = if (builtin.link_libc) c_int else u32;
var status: Status_t = undefined;
const coerced_flags = if (builtin.link_libc) @as(c_int, @intCast(flags)) else flags;
while (true) {
const rc = std.os.linux.waitpid(pid, &status, coerced_flags);
switch (std.os.errno(rc)) {
switch (std.posix.errno(rc)) {
.SUCCESS => return .{
.pid = @as(std.os.pid_t, @intCast(rc)),
.pid = @as(std.posix.pid_t, @intCast(rc)),
.status = @as(u32, @bitCast(status)),
},
.INTR => continue,
@@ -222,10 +222,10 @@ fn hsh_waitpid(pid: std.os.pid_t, flags: u32) WaitError!std.os.WaitPidResult {
}
}
 
const waitpid = if (@TypeOf(std.os.waitpid) == fn (i32, u32) std.os.WaitPidResult)
const waitpid = if (@TypeOf(std.posix.waitpid) == fn (i32, u32) std.posix.WaitPidResult)
hsh_waitpid
else
std.os.waitpid;
std.posix.waitpid;
 
pub fn waitForFg() void {
while (getFg()) |fg| {
@@ -241,7 +241,7 @@ pub fn waitForFg() void {
}
}
 
pub fn waitFor(jid: std.os.pid_t) !*Job {
pub fn waitFor(jid: std.posix.pid_t) !*Job {
if (jid > 0) {
var job = try get(jid);
if (!job.status.alive()) {
@@ -249,11 +249,11 @@ pub fn waitFor(jid: std.os.pid_t) !*Job {
}
}
 
const s = try hsh_waitpid(jid, std.os.linux.W.UNTRACED);
const s = try hsh_waitpid(jid, std.posix.W.UNTRACED);
log.debug("status {} {} \n", .{ s.pid, s.status });
if (s.pid == jid) {
if (get(s.pid)) |job| {
if (std.os.linux.W.IFSIGNALED(s.status)) {
if (std.posix.W.IFSIGNALED(s.status)) {
job.crash(0);
} else if (std.os.linux.W.IFSTOPPED(s.status)) {
var tty = TTY.current_tty orelse unreachable;
 
src/keys.zig added: 155, removed: 161, total 0
@@ -1,6 +1,5 @@
const std = @import("std");
const log = @import("log");
const os = std.os;
 
pub const Error = error{
UnknownEvent,
@@ -99,7 +98,7 @@ pub fn translate(c: u8, io: i32) Error!Event {
 
pub fn esc(io: i32) Error!Event {
var buffer: [1]u8 = .{0x1B};
_ = os.read(io, &buffer) catch return Error.IO;
_ = std.posix.read(io, &buffer) catch return Error.IO;
switch (buffer[0]) {
0x1B => return Event.key(.Esc),
'[' => return csi(io),
@@ -120,7 +119,7 @@ pub fn esc(io: i32) Error!Event {
/// Single Shift Three
fn sst(io: i32) Error!Key {
var buffer: [1]u8 = undefined;
if ((os.read(io, &buffer) catch return Error.IO) != 1) return Error.UnknownEvent;
if ((std.posix.read(io, &buffer) catch return Error.IO) != 1) return Error.UnknownEvent;
switch (buffer[0]) {
'P' => return .F1,
'Q' => return .F2,
@@ -139,7 +138,7 @@ fn csi(io: i32) Error!Event {
var i: usize = 0;
// Iterate byte by byte to terminate as early as possible
while (i < buffer.len) : (i += 1) {
const len = os.read(io, buffer[i .. i + 1]) catch return Error.IO;
const len = std.posix.read(io, buffer[i .. i + 1]) catch return Error.IO;
if (len == 0) return Error.UnknownEvent;
switch (buffer[i]) {
'~', 'a'...'z', 'A'...'Z' => break,
 
src/main.zig added: 155, removed: 161, total 0
@@ -210,7 +210,6 @@ pub fn main() !void {
}
} else |err| {
switch (err) {
error.Interupted => log.err("intr\n", .{}),
error.InputOutput => {
hsh.tty.waitForFg();
//@breakpoint();
 
src/parse.zig added: 155, removed: 161, total 0
@@ -672,7 +672,7 @@ test "iterator aliased recurse" {
test "parse vars" {
const a = std.testing.allocator;
 
comptime var ts = [5]Token{
var ts = [5]Token{
try Token.any("echo"),
try Token.any(" "),
try Token.any("$string"),
@@ -698,7 +698,7 @@ test "parse vars" {
test "parse vars existing" {
const a = std.testing.allocator;
 
comptime var ts = [3]Token{
var ts = [3]Token{
try Token.any("echo"),
try Token.any("$string"),
try Token.any("blerg"),
@@ -727,7 +727,7 @@ test "parse vars existing" {
test "parse vars existing with white space" {
const a = std.testing.allocator;
 
comptime var ts = [5]Token{
var ts = [5]Token{
try Token.any("echo"),
try Token.any(" "),
try Token.any("$string"),
 
src/signals.zig added: 155, removed: 161, total 0
@@ -1,6 +1,5 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
const os = std.os;
const Queue = std.TailQueue;
const HSH = @import("hsh.zig").HSH;
const log = @import("log");
@@ -16,7 +15,7 @@ const cust_siginfo = extern struct {
 
pub const Signal = struct {
signal: c_int,
info: os.siginfo_t,
info: std.posix.siginfo_t,
};
 
pub const SI_CODE = enum(u6) {
@@ -39,7 +38,7 @@ var fba: std.heap.FixedBufferAllocator = undefined;
var fbuffer: []u8 = undefined;
var queue: Queue(Signal) = Queue(Signal){};
 
export fn sig_cb(sig: c_int, info: *const os.siginfo_t, _: ?*const anyopaque) callconv(.C) void {
export fn sig_cb(sig: c_int, info: *const std.posix.siginfo_t, _: ?*const anyopaque) callconv(.C) void {
log.trace(
\\
\\ ===================
@@ -50,8 +49,8 @@ export fn sig_cb(sig: c_int, info: *const os.siginfo_t, _: ?*const anyopaque) ca
, .{sig});
 
switch (sig) {
os.SIG.INT => flags.int +|= 1,
os.SIG.WINCH => flags.winch = true,
std.posix.SIG.INT => flags.int +|= 1,
std.posix.SIG.WINCH => flags.winch = true,
else => {
const sigp = alloc.create(Queue(Signal).Node) catch {
std.debug.print(
@@ -85,39 +84,39 @@ pub fn init(a: Allocator) !void {
fba = std.heap.FixedBufferAllocator.init(fbuffer);
alloc = fba.allocator();
 
const SA = std.os.linux.SA;
const SA = std.posix.SA;
// zsh blocks and unblocks winch signals during most processing, collecting
// them only when needed. It's likely something we should do as well
const wanted = [_]u6{
os.SIG.HUP,
os.SIG.INT,
os.SIG.USR1,
os.SIG.QUIT,
os.SIG.TERM,
os.SIG.CHLD,
os.SIG.CONT,
os.SIG.TSTP,
os.SIG.TTIN,
os.SIG.TTOU,
os.SIG.WINCH,
std.posix.SIG.HUP,
std.posix.SIG.INT,
std.posix.SIG.USR1,
std.posix.SIG.QUIT,
std.posix.SIG.TERM,
std.posix.SIG.CHLD,
std.posix.SIG.CONT,
std.posix.SIG.TSTP,
std.posix.SIG.TTIN,
std.posix.SIG.TTOU,
std.posix.SIG.WINCH,
};
 
for (wanted) |sig| {
try os.sigaction(sig, &os.Sigaction{
try std.posix.sigaction(sig, &std.posix.Sigaction{
.handler = .{ .sigaction = sig_cb },
.mask = os.empty_sigset,
.mask = std.posix.empty_sigset,
.flags = SA.SIGINFO | SA.RESTART,
}, null);
}
 
const ignored = [_]u6{
os.SIG.TTIN,
os.SIG.TTOU,
std.posix.SIG.TTIN,
std.posix.SIG.TTOU,
};
for (ignored) |sig| {
try os.sigaction(sig, &os.Sigaction{
.handler = .{ .handler = os.SIG.IGN },
.mask = os.empty_sigset,
try std.posix.sigaction(sig, &std.posix.Sigaction{
.handler = .{ .handler = std.posix.SIG.IGN },
.mask = std.posix.empty_sigset,
.flags = SA.RESTART,
}, null);
}
@@ -143,9 +142,9 @@ pub fn do(hsh: *HSH) SigEvent {
var sig = node.data;
const pid = sig.info.fields.common.first.piduid.pid;
switch (sig.signal) {
std.os.SIG.INT => unreachable,
std.os.SIG.WINCH => unreachable,
std.os.SIG.CHLD => {
std.posix.SIG.INT => unreachable,
std.posix.SIG.WINCH => unreachable,
std.posix.SIG.CHLD => {
const child = jobs.get(pid) catch {
log.warn("Unknown child on {} {}\n", .{ sig.info.code, pid });
continue;
@@ -173,7 +172,7 @@ pub fn do(hsh: *HSH) SigEvent {
},
}
},
std.os.SIG.TSTP => {
std.posix.SIG.TSTP => {
if (pid != 0) {
const child = jobs.get(pid) catch {
log.warn("Unknown child on {} {}\n", .{ sig.info.code, pid });
@@ -183,19 +182,19 @@ pub fn do(hsh: *HSH) SigEvent {
}
log.err("SIGNAL TSTP {} => ({any})", .{ pid, sig.info });
},
std.os.SIG.CONT => {
std.posix.SIG.CONT => {
log.warn("Unexpected cont from pid({})\n", .{pid});
hsh.waiting = false;
},
std.os.SIG.USR1 => {
std.posix.SIG.USR1 => {
_ = jobs.haltActive() catch @panic("Signal unable to pause job");
hsh.tty.setRaw() catch unreachable;
log.err("Assuming control of TTY!\n", .{});
},
std.os.SIG.TTOU => {
std.posix.SIG.TTOU => {
log.err("TTOU RIP us!\n", .{});
},
std.os.SIG.TTIN => {
std.posix.SIG.TTIN => {
log.err("TTIN RIP us! ({} -> {})\n", .{ hsh.pid, pid });
hsh.waiting = true;
},
@@ -217,15 +216,15 @@ pub fn do(hsh: *HSH) SigEvent {
}
 
pub fn block() void {
var sigset: std.os.linux.sigset_t = .{0} ** 32;
std.os.linux.sigaddset(&sigset, os.SIG.CHLD);
_ = std.os.linux.sigprocmask(os.SIG.BLOCK, &sigset, null);
var sigset: std.posix.sigset_t = .{0} ** 32;
std.os.linux.sigaddset(&sigset, std.posix.SIG.CHLD);
_ = std.os.linux.sigprocmask(std.posix.SIG.BLOCK, &sigset, null);
}
 
pub fn unblock() void {
var sigset: std.os.linux.sigset_t = .{0} ** 32;
std.os.linux.sigaddset(&sigset, os.SIG.CHLD);
_ = std.os.linux.sigprocmask(os.SIG.UNBLOCK, &sigset, null);
var sigset: std.posix.sigset_t = .{0} ** 32;
std.os.linux.sigaddset(&sigset, std.posix.SIG.CHLD);
_ = std.os.linux.sigprocmask(std.posix.SIG.UNBLOCK, &sigset, null);
}
 
pub fn raze() void {
 
src/tokenizer.zig added: 155, removed: 161, total 0
@@ -349,7 +349,7 @@ pub const Tokenizer = struct {
var file = fs.openFile(mkt, false) orelse return;
defer file.close();
file.reader().readAllArrayList(&self.raw, 4096) catch unreachable;
std.os.unlink(mkt) catch unreachable;
std.posix.unlink(mkt) catch unreachable;
self.alloc.free(mkt);
}
self.editor_mktmp = null;
 
src/tty.zig added: 155, removed: 161, total 0
@@ -1,15 +1,13 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
const os = std.os;
const fs = std.fs;
const File = fs.File;
const io = std.io;
const Reader = fs.File.Reader;
const Writer = fs.File.Writer;
const Cord = @import("draw.zig").Cord;
const custom_syscalls = @import("syscalls.zig");
const pid_t = std.os.linux.pid_t;
const fd_t = std.os.fd_t;
const pid_t = std.posix.pid_t;
const fd_t = std.posix.fd_t;
const log = @import("log");
const TCSA = std.os.linux.TCSA;
 
@@ -31,9 +29,9 @@ dev: i32,
is_tty: bool,
in: Reader,
out: Writer,
orig_attr: ?os.termios,
pid: std.os.pid_t = undefined,
owner: ?std.os.pid_t = null,
orig_attr: ?std.posix.termios,
pid: std.posix.pid_t = undefined,
owner: ?std.posix.pid_t = null,
 
/// Calling init multiple times is UB
pub fn init(a: Allocator) !TTY {
@@ -41,7 +39,7 @@ pub fn init(a: Allocator) !TTY {
const is_tty = std.io.getStdOut().isTty() and std.io.getStdIn().isTty();
 
const tty = if (is_tty)
os.open("/dev/tty", .{ .ACCMODE = .RDWR }, 0) catch std.io.getStdOut().handle
std.posix.open("/dev/tty", .{ .ACCMODE = .RDWR }, 0) catch std.io.getStdOut().handle
else
std.io.getStdOut().handle;
 
@@ -60,22 +58,22 @@ pub fn init(a: Allocator) !TTY {
return self;
}
 
fn tcAttr(tty_fd: i32) ?os.termios {
return os.tcgetattr(tty_fd) catch null;
fn tcAttr(tty_fd: i32) ?std.posix.termios {
return std.posix.tcgetattr(tty_fd) catch null;
}
 
pub fn getAttr(self: *TTY) ?os.termios {
pub fn getAttr(self: *TTY) ?std.posix.termios {
return tcAttr(self.dev);
}
 
fn makeRaw(orig: ?os.termios) os.termios {
var next = orig orelse os.termios{
fn makeRaw(orig: ?std.posix.termios) std.posix.termios {
var next = orig orelse std.posix.termios{
.oflag = .{ .OPOST = true, .ONLCR = true },
.cflag = .{ .CSIZE = .CS8, .CREAD = true, .CLOCAL = true },
.lflag = .{ .ISIG = true, .ICANON = true, .ECHO = true, .IEXTEN = true, .ECHOE = true },
.iflag = .{ .BRKINT = true, .ICRNL = true, .IMAXBEL = true },
.line = 0,
.cc = [_]u8{0} ** std.os.linux.NCCS,
.cc = [_]u8{0} ** std.posix.NCCS,
.ispeed = .B9600,
.ospeed = .B9600,
};
@@ -83,21 +81,20 @@ fn makeRaw(orig: ?os.termios) os.termios {
next.iflag.BRKINT = false;
next.iflag.INPCK = false;
next.iflag.ISTRIP = false;
//next.lflag &= ~(os.linux.ECHO | os.linux.ICANON | os.linux.ISIG | os.linux.IEXTEN);
next.lflag.ECHO = false;
next.lflag.ECHONL = false;
next.lflag.ICANON = false;
next.lflag.IEXTEN = false;
next.cc[@intFromEnum(os.system.V.TIME)] = 1; // 0.1 sec resolution
next.cc[@intFromEnum(os.system.V.MIN)] = 0;
next.cc[@intFromEnum(std.posix.system.V.TIME)] = 1; // 0.1 sec resolution
next.cc[@intFromEnum(std.posix.system.V.MIN)] = 0;
return next;
}
 
fn setTTYWhen(self: *TTY, mtio: ?os.termios, when: TCSA) !void {
if (mtio) |tio| try os.tcsetattr(self.dev, when, tio);
fn setTTYWhen(self: *TTY, mtio: ?std.posix.termios, when: TCSA) !void {
if (mtio) |tio| try std.posix.tcsetattr(self.dev, when, tio);
}
 
pub fn setTTY(self: *TTY, tio: ?os.termios) void {
pub fn setTTY(self: *TTY, tio: ?std.posix.termios) void {
self.setTTYWhen(tio, .DRAIN) catch |err| {
log.err("TTY ERROR encountered, {} when popping.\n", .{err});
};
@@ -121,10 +118,10 @@ pub fn setRaw(self: *TTY) !void {
try self.command(.DECCKM, false);
}
 
pub fn setOwner(self: *TTY, mpgrp: ?std.os.pid_t) !void {
pub fn setOwner(self: *TTY, mpgrp: ?std.posix.pid_t) !void {
if (!self.is_tty or self.owner == null) return;
const pgrp = mpgrp orelse self.pid;
_ = try std.os.tcsetpgrp(self.dev, pgrp);
_ = try std.posix.tcsetpgrp(self.dev, pgrp);
}
 
pub fn pwnTTY(self: *TTY) void {
@@ -133,10 +130,10 @@ pub fn pwnTTY(self: *TTY) void {
log.debug("pwnTTY {} and {} \n", .{ self.pid, ssid });
if (ssid != self.pid) _ = custom_syscalls.setpgid(self.pid, self.pid);
 
const res = std.os.tcsetpgrp(self.dev, self.pid) catch |err| {
const res = std.posix.tcsetpgrp(self.dev, self.pid) catch |err| {
self.owner = self.pid;
log.err("tcsetpgrp failed on pid {}, error was: {}\n", .{ self.pid, err });
const get = std.os.tcgetpgrp(self.dev) catch |err2| {
const get = std.posix.tcgetpgrp(self.dev) catch |err2| {
log.err("tcgetpgrp err {}\n", .{err2});
return;
};
@@ -144,26 +141,26 @@ pub fn pwnTTY(self: *TTY) void {
unreachable;
};
log.debug("tc pwnd {}\n", .{res});
const pgrp = std.os.tcgetpgrp(self.dev) catch unreachable;
const pgrp = std.posix.tcgetpgrp(self.dev) catch unreachable;
log.debug("get new pgrp {}\n", .{pgrp});
}
 
pub fn waitForFg(self: *TTY) void {
if (!self.is_tty) return;
var pgid = custom_syscalls.getpgid(0);
var fg = std.os.tcgetpgrp(self.dev) catch |err| {
var fg = std.posix.tcgetpgrp(self.dev) catch |err| {
log.err("died waiting for fg {}\n", .{err});
@panic("panic carefully!");
};
while (pgid != fg) {
std.os.kill(-pgid, std.os.SIG.TTIN) catch {
std.posix.kill(-pgid, std.posix.SIG.TTIN) catch {
@panic("unable to send TTIN");
};
pgid = custom_syscalls.getpgid(0);
std.os.tcsetpgrp(self.dev, pgid) catch {
std.posix.tcsetpgrp(self.dev, pgid) catch {
@panic("died in loop");
};
fg = std.os.tcgetpgrp(self.dev) catch {
fg = std.posix.tcgetpgrp(self.dev) catch {
@panic("died in loop");
};
}
@@ -208,10 +205,10 @@ pub fn command(tty: TTY, comptime code: VTCmds, comptime enable: ?bool) !void {
//}
 
pub fn geom(self: *TTY) !Cord {
var size: os.linux.winsize = std.mem.zeroes(os.linux.winsize);
const err = os.system.ioctl(self.dev, os.linux.T.IOCGWINSZ, @intFromPtr(&size));
if (os.errno(err) != .SUCCESS) {
return os.unexpectedErrno(@enumFromInt(err));
var size: std.posix.winsize = std.mem.zeroes(std.posix.winsize);
const err = std.posix.system.ioctl(self.dev, std.posix.T.IOCGWINSZ, @intFromPtr(&size));
if (std.posix.errno(err) != .SUCCESS) {
return std.posix.unexpectedErrno(@enumFromInt(err));
}
return .{
.x = size.ws_col,