close input.write

.gitignore

@@ -1,4 +1,2 @@
 *.out
 bin/
-.zig-cache
-zig-out

Makefile

@@ -1,15 +1,18 @@
 LIBRARIES = -lreadline
 RELEASE_ARGS = -DRELEASEBUILD
 SOURCES = ./msh.c
-OUTPUT_DIR = ./zig-out/bin
+OUTPUT_DIR = ./bin
 OUTPUT_BIN = ${OUTPUT_DIR}/PROG
 OUTPUT = -o ${OUTPUT_BIN}
 
 build: output_dir
-	zig build install --release=fast
+	gcc -Wall -std=gnu99 ${RELEASE_ARGS} ${SOURCES} ${OUTPUT:PROG=mash} ${LIBRARIES}
 
 debug: output_dir
-	zig build
+	gcc -Wall -std=gnu99 -g ${SOURCES} ${OUTPUT:PROG=mash} ${LIBRARIES}
+
+output_dir:
+	mkdir -p ${OUTPUT_DIR}
 
 install:
 	mv ${OUTPUT_BIN:PROG=mash} /usr/sbin/blah

build.zig

@@ -1,81 +0,0 @@
-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 linenoise = b.dependency("linenoize", .{
-        .target = target,
-        .optimize = optimize,
-    }).module("linenoise");
-
-    // We will also create a module for our other entry point, 'main.zig'.
-    const exe_mod = b.createModule(.{
-        // `root_source_file` is the Zig "entry point" of the module. If a module
-        // only contains e.g. external object files, you can make this `null`.
-        // 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 = b.path("src/main.zig"),
-        .imports = &.{.{ .name = "linenoise", .module = linenoise }},
-        .target = target,
-        .optimize = optimize,
-    });
-
-    // This creates another `std.Build.Step.Compile`, but this one builds an executable
-    // rather than a static library.
-    const exe = b.addExecutable(.{
-        .name = "math_shell",
-        .root_module = exe_mod,
-    });
-
-    // 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);
-
-    const exe_unit_tests = b.addTest(.{
-        .root_module = exe_mod,
-    });
-
-    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_exe_unit_tests.step);
-}

build.zig.zon

@@ -1,52 +0,0 @@
-.{
-    // This is the default name used by packages depending on this one. For
-    // example, when a user runs `zig fetch --save <url>`, this field is used
-    // as the key in the `dependencies` table. Although the user can choose a
-    // different name, most users will stick with this provided value.
-    //
-    // It is redundant to include "zig" in this name because it is already
-    // within the Zig package namespace.
-    .name = .math_shell,
-
-    // 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",
-
-    // Together with name, this represents a globally unique package
-    // identifier. This field is generated by the Zig toolchain when the
-    // package is first created, and then *never changes*. This allows
-    // unambiguous detection of one package being an updated version of
-    // another.
-    //
-    // When forking a Zig project, this id should be regenerated (delete the
-    // field and run `zig build`) if the upstream project is still maintained.
-    // Otherwise, the fork is *hostile*, attempting to take control over the
-    // original project's identity. Thus it is recommended to leave the comment
-    // on the following line intact, so that it shows up in code reviews that
-    // modify the field.
-    .fingerprint = 0x62a0107bbe8924ff, // Changing this has security and trust implications.
-
-    // Tracks the earliest Zig version that the package considers to be a
-    // supported use case.
-    .minimum_zig_version = "0.14.0",
-
-    // This field is optional.
-    // Each dependency must either provide a `url` and `hash`, or a `path`.
-    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
-    // Once all dependencies are fetched, `zig build` no longer requires
-    // internet connectivity.
-    .dependencies = .{
-        .linenoize = .{
-            .url = "git+https://github.com/joachimschmidt557/linenoize?ref=v0.1.0#8bf767663382624bd676b05829fa8d3975a05d88",
-            .hash = "linenoize-0.1.0-J7HK8IfXAABxH-V4Bp2Q0G7P-nrOmq9g8LuQAoX3SjDy",
-        },
-    },
-    .paths = .{
-        "build.zig",
-        "build.zig.zon",
-        "src",
-        // For example...
-        //"LICENSE",
-        //"README.md",
-    },
-}

msh.c

@@ -251,6 +251,7 @@ char *getPrompt() {
 		printf("Error forking\n");
 	} else { // Parent process
 		close(input.read);
+    close(input.write);
 		close(output.write);
 
 		outputFileD = fdopen(output.read, "r");

msh.h

@@ -0,0 +1,4 @@
+int builtinExit(char **args);
+int builtinAuthor(char **args);
+int builtinCD(char **dir);
+int builtinNMN(char **args);

src/get_prompt.bash

@@ -1,7 +0,0 @@
-ver=$(bash --version | head -n 1 | awk '{print $4}' | grep -o "\.\..")
-check_ver=$(echo -e "${ver}\n4.3" | sort -V | head -n 1)
-if [[ "${ver}" == "${check_ver}" ]]; then
-  echo "[${USER}@${HOSTNAME} ${PWD##*/}]$ "
-else
-  echo "${PS1@P}"
-fi

src/main.zig

@@ -1,98 +0,0 @@
-const std = @import("std");
-const Linenoise = @import("linenoise").Linenoise;
-
-fn clear() !void {
-    const stdout = std.io.getStdOut().writer();
-    try stdout.print("\u{001b}[H\u{001b}[J", .{});
-}
-const Pipe = packed struct {
-    const fd_t = std.posix.fd_t;
-    read: fd_t,
-    write: fd_t,
-};
-
-fn pipe() !Pipe {
-    return @bitCast(try std.posix.pipe());
-}
-
-fn getPrompt() ![]const u8 {
-    const p = try pipe();
-
-    const close = std.posix.close;
-    const dup2 = std.posix.dup2;
-    const STDIN_FILENO = std.posix.STDIN_FILENO;
-    const STDOUT_FILENO = std.posix.STDOUT_FILENO;
-    const STDERR_FILENO = std.posix.STDERR_FILENO;
-    const script = @embedFile("./get_prompt.bash");
-
-    if (std.posix.fork()) |pid| {
-        if (pid == 0) {
-            close(p.read);
-
-            try dup2(p.write, STDOUT_FILENO);
-            close(STDIN_FILENO);
-            close(STDERR_FILENO); // Do not print errors to the screen
-
-            // Command-line arguments (must include program name as first argument)
-            // const args = [_:null]?[*:0]const u8{ "bash", "-i", "-c", script, null };
-            var args = [_:null]?[*:0]const u8{ "bash", "-i", "-c", script, null };
-            try std.posix.execvpeZ("bash", &args, std.c.environ);
-
-            // std.posix.execvpeZ("bash", @as([*:null]const ?[*:0]const u8, &args[0]), std.os.environ);
-            _ = std.posix.execvpeZ("bash", @as([*:null]const ?[*:0]const u8, &args[0]), std.os.environ);
-            // kill the child
-            std.process.exit(0);
-        } else {}
-        return "";
-    } else |err| {
-        return err;
-    }
-}
-
-pub fn main() !void {
-    try clear();
-
-    const allocator = std.heap.page_allocator;
-    var ln = Linenoise.init(allocator);
-    defer ln.deinit();
-
-    _ = try getPrompt();
-
-    while (try ln.linenoise("hello> ")) |input| {
-        defer allocator.free(input);
-        std.debug.print("input: {s}\n", .{input});
-        try ln.history.add(input);
-    }
-
-    // // 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();
-
-    // 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());
-}
-
-test "fuzz example" {
-    const Context = struct {
-        fn testOne(context: @This(), input: []const u8) anyerror!void {
-            _ = context;
-            // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
-            try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input));
-        }
-    };
-    try std.testing.fuzz(Context{}, Context.testOne, .{});
-}