From b9564b7db890cf889caf52f98ed5fa0e247163df Mon Sep 17 00:00:00 2001 From: Tim Culverhouse Date: Wed, 17 Jan 2024 21:52:33 -0600 Subject: [PATCH] initial commit Signed-off-by: Tim Culverhouse --- .gitignore | 2 + build.zig | 102 ++++++++++++++++++++++++++++++++++++ build.zig.zon | 36 +++++++++++++ src/main.zig | 30 +++++++++++ src/root.zig | 10 ++++ src/tty/Tty.zig | 132 +++++++++++++++++++++++++++++++++++++++++++++++ src/tty/main.zig | 4 ++ 7 files changed, 316 insertions(+) create mode 100644 .gitignore create mode 100644 build.zig create mode 100644 build.zig.zon create mode 100644 src/main.zig create mode 100644 src/root.zig create mode 100644 src/tty/Tty.zig create mode 100644 src/tty/main.zig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e73c965 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +zig-cache/ +zig-out/ diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..2b3f36c --- /dev/null +++ b/build.zig @@ -0,0 +1,102 @@ +const std = @import("std"); + +// Although this function looks imperative, note that its job is to +// declaratively construct a build graph that will be executed by an external +// runner. +pub fn build(b: *std.Build) void { + // Standard target options allows the person running `zig build` to choose + // what target to build for. Here we do not override the defaults, which + // means any target is allowed, and the default is native. Other options + // for restricting supported target set are available. + const target = b.standardTargetOptions(.{}); + + // Standard optimization options allow the person running `zig build` to select + // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not + // set a preferred release mode, allowing the user to decide how to optimize. + const optimize = b.standardOptimizeOption(.{}); + + const libxev = b.dependency("libxev", .{ + .optimize = optimize, + .target = target, + }); + const ziglyph = b.dependency("ziglyph", .{ + .optimize = optimize, + .target = target, + }); + + const lib = b.addStaticLibrary(.{ + .name = "salmon", + // In this case the main source file is merely a path, however, in more + // complicated build scripts, this could be a generated file. + .root_source_file = .{ .path = "src/root.zig" }, + .target = target, + .optimize = optimize, + }); + + // This declares intent for the library to be installed into the standard + // location when the user invokes the "install" step (the default step when + // running `zig build`). + b.installArtifact(lib); + + const exe = b.addExecutable(.{ + .name = "salmon", + .root_source_file = .{ .path = "src/main.zig" }, + .target = target, + .optimize = optimize, + }); + exe.root_module.addImport("ziglyph", ziglyph.module("ziglyph")); + exe.root_module.addImport("xev", libxev.module("xev")); + + // This declares intent for the executable to be installed into the + // standard location when the user invokes the "install" step (the default + // step when running `zig build`). + b.installArtifact(exe); + + // This *creates* a Run step in the build graph, to be executed when another + // step is evaluated that depends on it. The next line below will establish + // such a dependency. + const run_cmd = b.addRunArtifact(exe); + + // By making the run step depend on the install step, it will be run from the + // installation directory rather than directly from within the cache directory. + // This is not necessary, however, if the application depends on other installed + // files, this ensures they will be present and in the expected location. + run_cmd.step.dependOn(b.getInstallStep()); + + // This allows the user to pass arguments to the application in the build + // command itself, like this: `zig build run -- arg1 arg2 etc` + if (b.args) |args| { + run_cmd.addArgs(args); + } + + // This creates a build step. It will be visible in the `zig build --help` menu, + // and can be selected like this: `zig build run` + // This will evaluate the `run` step rather than the default, which is "install". + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run_cmd.step); + + // Creates a step for unit testing. This only builds the test executable + // but does not run it. + const lib_unit_tests = b.addTest(.{ + .root_source_file = .{ .path = "src/root.zig" }, + .target = target, + .optimize = optimize, + }); + + const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests); + + const exe_unit_tests = b.addTest(.{ + .root_source_file = .{ .path = "src/main.zig" }, + .target = target, + .optimize = optimize, + }); + + const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests); + + // Similar to creating the run step earlier, this exposes a `test` step to + // the `zig build --help` menu, providing a way for the user to request + // running the unit tests. + const test_step = b.step("test", "Run unit tests"); + test_step.dependOn(&run_lib_unit_tests.step); + test_step.dependOn(&run_exe_unit_tests.step); +} diff --git a/build.zig.zon b/build.zig.zon new file mode 100644 index 0000000..ac31bb4 --- /dev/null +++ b/build.zig.zon @@ -0,0 +1,36 @@ +.{ + .name = "salmon", + // This is a [Semantic Version](https://semver.org/). + // In a future version of Zig it will be used for package deduplication. + .version = "0.0.0", + + // This field is optional. + // This is currently advisory only; Zig does not yet do anything + // with this value. + //.minimum_zig_version = "0.11.0", + + .dependencies = .{ + .libxev = .{ + .url = "https://github.com/mitchellh/libxev/archive/4e6781895e4e6c477597c8c2713d36cd82b57d07.tar.gz", + .hash = "12203f87e00caa6c07c02a748f234a5c0ee2ca5c334ec464e88810d93e7b5495a56f", + }, + .ziglyph = .{ + .url = "https://codeberg.org/dude_the_builder/ziglyph/archive/main.tar.gz", + .hash = "12208553f3f47e51494e187f4c0e6f6b3844e3993436cad4a0e8c4db4e99645967b5", + }, + }, + + .paths = .{ + // This makes *all* files, recursively, included in this package. It is generally + // better to explicitly list the files and directories instead, to insure that + // fetching from tarballs, file system paths, and version control all result + // in the same contents hash. + "", + // For example... + //"build.zig", + //"build.zig.zon", + //"src", + //"LICENSE", + //"README.md", + }, +} diff --git a/src/main.zig b/src/main.zig new file mode 100644 index 0000000..19924bd --- /dev/null +++ b/src/main.zig @@ -0,0 +1,30 @@ +const std = @import("std"); +const Tty = @import("tty/Tty.zig"); + +pub fn main() !void { + // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`) + std.debug.print("All your {s} are belong to us.\n", .{"codebase"}); + + // stdout is for the actual output of your application, for example if you + // are implementing gzip, then only the compressed bytes should be sent to + // stdout, not any debugging messages. + const stdout_file = std.io.getStdOut().writer(); + var bw = std.io.bufferedWriter(stdout_file); + const stdout = bw.writer(); + + var tty = try Tty.init(); + defer tty.deinit(); + + try tty.run(); + + try stdout.print("Run `zig build test` to run the tests.\n", .{}); + + try bw.flush(); // don't forget to flush! +} + +test "simple test" { + var list = std.ArrayList(i32).init(std.testing.allocator); + defer list.deinit(); // try commenting this out and see if zig detects the memory leak! + try list.append(42); + try std.testing.expectEqual(@as(i32, 42), list.pop()); +} diff --git a/src/root.zig b/src/root.zig new file mode 100644 index 0000000..ecfeade --- /dev/null +++ b/src/root.zig @@ -0,0 +1,10 @@ +const std = @import("std"); +const testing = std.testing; + +export fn add(a: i32, b: i32) i32 { + return a + b; +} + +test "basic add functionality" { + try testing.expect(add(3, 7) == 10); +} diff --git a/src/tty/Tty.zig b/src/tty/Tty.zig new file mode 100644 index 0000000..1272d00 --- /dev/null +++ b/src/tty/Tty.zig @@ -0,0 +1,132 @@ +const std = @import("std"); +const os = std.os; +const xev = @import("xev"); + +const log = std.log.scoped(.tty); + +const Tty = @This(); + +/// the original state of the terminal, prior to calling makeRaw +termios: os.termios, + +/// The file descriptor we are using for I/O +fd: os.fd_t, + +/// Stream attached to our fd +stream: xev.Stream, + +/// event loop +loop: xev.Loop, + +read_buffer: [1024]u8 = undefined, + +/// initializes a Tty instance by opening /dev/tty and "making it raw" +pub fn init() !Tty { + // Open our tty + const fd = try os.open("/dev/tty", os.system.O.RDWR, 0); + + // Initialize the stream + const stream = xev.Stream.initFd(fd); + + // Initialize event loop + const loop = try xev.Loop.init(.{}); + + // Set the termios of the tty + const termios = try makeRaw(fd); + + return Tty{ + .fd = fd, + .stream = stream, + .termios = termios, + .loop = loop, + }; +} + +/// release resources associated with the Tty return it to it's original state +pub fn deinit(self: *Tty) void { + os.tcsetattr(self.fd, .FLUSH, self.termios) catch |err| { + log.err("couldn't restore terminal: {}", .{err}); + }; + os.close(self.fd); + self.stream.deinit(); + self.loop.deinit(); +} + +/// read input from the tty +pub fn run(self: *Tty) !void { + var c_stream: xev.Completion = undefined; + + // Initialize our read event + self.stream.read( + &self.loop, + &c_stream, + .{ .slice = self.read_buffer[0..] }, + Tty, + self, + readCallback, + ); + + try self.loop.run(.until_done); +} + +fn readCallback( + ud: ?*Tty, + loop: *xev.Loop, + c: *xev.Completion, + stream: xev.Stream, + buf: xev.ReadBuffer, + r: xev.ReadError!usize, +) xev.CallbackAction { + _ = stream; // autofix + _ = c; // autofix + _ = loop; // autofix + const tty = ud.?; + _ = tty; // autofix + const n = r catch |err| { + // Log the error and shutdown + log.err("read error: {}", .{err}); + return .disarm; + }; + log.info("{s}\r", .{buf.slice[0..n]}); + return .rearm; +} + +/// makeRaw enters the raw state for the terminal. +pub fn makeRaw(fd: os.fd_t) !os.termios { + const state = try os.tcgetattr(fd); + var raw = state; + // see termios(3) + raw.iflag &= ~@as( + os.tcflag_t, + os.system.IGNBRK | + os.system.BRKINT | + os.system.PARMRK | + os.system.ISTRIP | + os.system.INLCR | + os.system.IGNCR | + os.system.ICRNL | + os.system.IXON, + ); + raw.oflag &= ~@as(os.tcflag_t, os.system.OPOST); + raw.lflag &= ~@as( + os.tcflag_t, + os.system.ECHO | + os.system.ECHONL | + os.system.ICANON | + os.system.ISIG | + os.system.IEXTEN, + ); + raw.cflag &= ~@as( + os.tcflag_t, + os.system.CSIZE | + os.system.PARENB, + ); + raw.cflag |= @as( + os.tcflag_t, + os.system.CS8, + ); + raw.cc[os.system.V.MIN] = 1; + raw.cc[os.system.V.TIME] = 0; + try os.tcsetattr(fd, .FLUSH, raw); + return state; +} diff --git a/src/tty/main.zig b/src/tty/main.zig new file mode 100644 index 0000000..8e595b4 --- /dev/null +++ b/src/tty/main.zig @@ -0,0 +1,4 @@ +const std = @import("std"); +const os = std.os; + +pub const Tty = @import("Tty.zig");