From 28934ea6fc5bc9fbfe89b6d542676800fb6da961 Mon Sep 17 00:00:00 2001
From: sofia <sofia@teascade.net>
Date: Sun, 17 Aug 2025 17:44:44 +0300
Subject: [PATCH] Add run-subcommand

---
 reid/src/ld.rs   | 11 +++++++++++
 reid/src/main.rs | 41 ++++++++++++++++++++++++++++++++++-------
 2 files changed, 45 insertions(+), 7 deletions(-)

diff --git a/reid/src/ld.rs b/reid/src/ld.rs
index 10959d6..1558d0e 100644
--- a/reid/src/ld.rs
+++ b/reid/src/ld.rs
@@ -104,3 +104,14 @@ fn find_objectfile(name: &str) -> String {
         .unwrap()
         .to_owned()
 }
+
+pub fn execute(path: &PathBuf) {
+    let output = Command::new(path.clone()).output().expect("Unable to execute {path}");
+
+    if !output.status.success() {
+        let code = output.status.code().unwrap_or(255);
+        log::error!("{path:?} exited with code {code}");
+        println!("{}", unsafe { String::from_utf8_unchecked(output.stderr) });
+        return;
+    }
+}
diff --git a/reid/src/main.rs b/reid/src/main.rs
index 4cb9f02..07c5f41 100644
--- a/reid/src/main.rs
+++ b/reid/src/main.rs
@@ -2,7 +2,11 @@ use std::{fs, path::PathBuf};
 
 use argh::FromArgs;
 use log::*;
-use reid::{compile_simple, ld::LDRunner, CustomIRs};
+use reid::{
+    compile_simple,
+    ld::{execute, LDRunner},
+    CustomIRs,
+};
 use reid_lib::compile::CompileOutput;
 
 #[derive(FromArgs, PartialEq, Debug)]
@@ -23,6 +27,7 @@ struct Options {
 #[argh(subcommand)]
 enum Command {
     Build(BuildOpts),
+    Run(RunOpts),
 }
 
 #[derive(FromArgs, PartialEq, Debug)]
@@ -36,6 +41,17 @@ struct BuildOpts {
     path: PathBuf,
 }
 
+#[derive(FromArgs, PartialEq, Debug)]
+/// Build and then execute the executable
+#[argh(subcommand, name = "run")]
+struct RunOpts {
+    #[argh(option, long = "lib", short = 'l')]
+    /// additional libraries to link against (with ld)
+    libraries: Vec<String>,
+    #[argh(positional)]
+    path: PathBuf,
+}
+
 fn main() {
     let options: Options = argh::from_env();
     let mut errlog = stderrlog::new();
@@ -45,12 +61,12 @@ fn main() {
     }
     errlog.init().unwrap();
 
-    match options.command {
-        Command::Build(build) => {
+    match &options.command {
+        Command::Build(BuildOpts { libraries, path }) | Command::Run(RunOpts { libraries, path }) => {
             let cpu = std::env::var("CPU").unwrap_or("generic".to_owned());
             let features = std::env::var("REIDFLAGS").unwrap_or("".to_owned());
 
-            let path = match build.path.canonicalize() {
+            let path = match path.canonicalize() {
                 Ok(path) => path,
                 Err(e) => {
                     error!("{e}");
@@ -64,6 +80,7 @@ fn main() {
             let llir_path = parent.with_extension("llir");
             let mir_path = parent.with_extension("mir");
             let asm_path = parent.with_extension("asm");
+            let out_path = object_path.with_extension("out");
 
             let before = std::time::SystemTime::now();
 
@@ -108,13 +125,23 @@ fn main() {
 
                     let linker = std::env::var("LD").unwrap_or("ld".to_owned());
                     let mut linker = LDRunner::from_command(&linker).with_library("c").with_library("m");
-                    for library in build.libraries {
+                    for library in libraries {
                         linker = linker.with_library(&library);
                     }
-                    linker.invoke(&object_path, &object_path.with_extension("out"));
+                    linker.invoke(&object_path, &out_path);
+                }
+                Err(e) => {
+                    log::error!("{e}");
+                    return;
                 }
-                Err(e) => panic!("{}", e),
             };
+
+            match &options.command {
+                Command::Build(_) => {}
+                Command::Run(_) => {
+                    execute(&out_path);
+                }
+            }
         }
     }
 }