Initial commit

shell/shell.odin

@@ -0,0 +1,197 @@
+package shell
+
+import "core:fmt"
+import "core:strings"
+import "core:sys/posix"
+import "core:os"
+import "core:log"
+import "core:mem"
+
+import "../parser"
+
+ShellState :: enum {
+    Continue,
+    Stop
+}
+
+get_prompt :: proc() -> string {
+    dir := os.get_current_directory(context.temp_allocator)
+    home := string(posix.getenv("HOME"))
+    
+    if strings.contains(dir, home) {
+        dir, _ = strings.replace(dir, home, "~", 1, context.temp_allocator)
+    } 
+    
+    uid := posix.getuid()
+    pw := posix.getpwuid(uid)
+
+    user: string
+    if pw == nil {
+        user = "Skal"
+    } else {
+        user = string(pw.pw_name)
+    }
+
+    promt_parts := []string {user, " :: ", dir, " » "}
+    prompt, err := strings.concatenate(promt_parts[:], context.temp_allocator)
+    log.assertf(err == nil, "Memory allocation failed")
+
+    return prompt
+}
+
+pipe_command :: proc(pipe_seq: ^parser.PipeSequence, maybe_fd: Maybe(posix.FD), idx: int) {
+    cmd := pipe_seq.commands[idx]
+
+    fd, missing_fd := maybe_fd.?
+
+    if missing_fd {
+        dup_status := posix.dup2(fd, posix.STDOUT_FILENO)
+        log.assertf(dup_status > -1, "Pipe failed")
+
+        close_status := posix.close(fd)
+        log.assertf(close_status == .OK, "Pipe failed")
+    }
+
+    if idx == 0 {
+        if pipe_seq^.rstdin != "" {
+            stdin_fd := posix.open(pipe_seq^.rstdin, { .RDWR }, { .IRUSR, .IWUSR, .IRGRP, .IROTH })
+            log.assertf(stdin_fd > -1, "Pipe failed")
+
+            dup_status := posix.dup2(stdin_fd, posix.STDIN_FILENO)
+            log.assertf(dup_status > -1, "Pipe failed")
+
+            close_status := posix.close(stdin_fd)
+            log.assertf(close_status == .OK, "Pipe failed")
+        }
+
+        if pipe_seq^.rstdout != "" {
+            stdout_fd := posix.open(pipe_seq^.rstdout, { .WRONLY, .CREAT, .TRUNC }, { .IRUSR, .IWUSR, .IRGRP, .IROTH })
+            log.assertf(stdout_fd > -1, "Pipe failed")
+
+            dup_status := posix.dup2(stdout_fd, posix.STDOUT_FILENO)
+            log.assertf(dup_status > -1, "Pipe failed")
+
+            close_status := posix.close(stdout_fd)
+            log.assertf(close_status == .OK, "Pipe failed")
+        }
+
+        if pipe_seq^.rstderr != "" {
+            stderr_fd := posix.open(pipe_seq^.rstderr, { .WRONLY, .CREAT, .TRUNC }, { .IRUSR, .IWUSR, .IRGRP, .IROTH })
+            log.assertf(stderr_fd > -1, "Pipe failed")
+
+            dup_status := posix.dup2(stderr_fd, posix.STDERR_FILENO)
+            log.assertf(dup_status > -1, "Pipe failed")
+
+            close_status := posix.close(stderr_fd)
+            log.assertf(close_status == .OK, "Pipe failed")
+        }
+
+    } else {
+        pipe: [2]posix.FD 
+        log.assertf(posix.pipe(&pipe) == .OK, "Pipe failed")
+
+        pid := posix.fork()
+        switch pid {
+        case -1: // Error
+            log.assertf(posix.pipe(&pipe) == .OK, "Fork failed")
+        case 0: // Child
+            close_status := posix.close(pipe[0])
+            log.assertf(close_status == .OK, "Pipe failed")
+
+            pipe_command(pipe_seq, pipe[1], idx-1)
+        case: // Parent
+            close_status := posix.close(pipe[1])
+            log.assertf(close_status == .OK, "Pipe failed")
+
+            dup_status := posix.dup2(pipe[0], posix.STDIN_FILENO)
+            log.assertf(dup_status > -1, "Pipe failed")
+
+            close_status = posix.close(pipe[0])
+            log.assertf(close_status == .OK, "Pipe failed")
+
+            _ = posix.waitpid(pid, nil, { .UNTRACED, .CONTINUED })
+        }
+
+    }
+
+    argv, mem_err := make([]cstring, len(cmd.args)+1, context.temp_allocator)
+    log.assertf(mem_err == nil, "Memory allocation failed")
+
+    argv[0] = cmd.name
+    for i := 0; i < len(cmd.args); i += 1 do argv[i+1] = cmd.args[i]
+
+    _ = posix.execvp(argv[0], raw_data(argv))
+    fmt.printfln("skal: command not found: %s", argv[0])
+    os.exit(1)
+}
+
+@private
+change_dir :: proc(cmd: ^parser.Command) {
+    if len(cmd.args) > 0 {
+        ch_status := posix.chdir(cmd.args[0]) 
+        if ch_status != .OK do fmt.printf("cd: No such file or directory: %s\n", cmd.args[0]) 
+    } else { 
+        ch_status := posix.chdir(posix.getenv("HOME"))
+        if ch_status != .OK do fmt.printf("cd: No such file or directory: %s\n", posix.getenv("HOME"))
+    } 
+}
+
+stop_chain :: proc(sequence_type: parser.SequenceType, exec_failed: bool) -> bool {
+    stop_chain: bool
+
+    switch sequence_type {
+    case .Or:
+        stop_chain = !exec_failed 
+    case .And:
+        stop_chain = exec_failed
+    case .Head:
+        stop_chain = false 
+    }
+
+    return stop_chain
+}
+
+execute_cmd_seq :: proc(cmd_seq: ^parser.CommandSequence) {
+    for &pipe_seq in cmd_seq^.pipe_sequences {
+        pid := posix.fork() 
+        switch pid {
+        case -1: // Error
+            log.assertf(true, "Fork failed")
+        case 0: // Child
+            pipe_command(&pipe_seq, nil, len(pipe_seq.commands)-1)
+        case: // Parent
+            if pipe_seq.is_background {
+                fmt.printf("Background process: [%d]\n", pid)
+                posix.waitpid(pid, nil, { .NOHANG})
+            } else {
+                status: i32 
+                posix.waitpid(pid, &status, { .UNTRACED, .CONTINUED })
+
+                exec_failed := posix.WIFEXITED(status) && posix.WEXITSTATUS(status) != 0
+
+                if stop_chain(pipe_seq.sequence_type, exec_failed) do return
+            }
+        }
+
+    }
+}
+
+execute :: proc(cmd_seq: ^parser.CommandSequence) -> ShellState {
+    if len(cmd_seq^.pipe_sequences) == 0 do return .Continue 
+
+    // if pipe sequence is above 0 it has at least one command
+    first_cmd := cmd_seq^.pipe_sequences[0].commands[0]
+
+    switch first_cmd.name {
+    case "cd":
+        change_dir(&first_cmd)
+    case "exit":
+        return .Stop 
+    case:
+        execute_cmd_seq(cmd_seq)   
+    }
+
+    return .Continue
+}
+
+