read program from file; fmt, cleanup

launcher/Cargo.toml

@@ -16,3 +16,6 @@ simple_logger = "1.9.0"
 log = "0.4.11"
 thiserror = "1.0.20"
 anyhow = "1.0.32"
+clappconfig = "0.4.0"
+
+serde = { version = "1.0.116", features = ["derive"] }

launcher/src/main.rs

@@ -1,109 +1,82 @@
 #[macro_use]
 extern crate log;
 
-
+use std::collections::HashMap;
 use std::sync::Arc;
 
-use simple_logger::SimpleLogger;
+use clappconfig::{AppConfig, clap};
+use clappconfig::clap::ArgMatches;
+use serde::{Deserialize, Serialize};
 
 use crsn::asm::data::literal::Addr;
 use crsn::runtime::run_thread::{RunThread, ThreadToken};
-use crsn::runtime::run_thread;
 use crsn_arith::ArithOps;
-use crsn_stacks::StackOps;
 use crsn_screen::ScreenOps;
-use std::time::Duration;
-use log::LevelFilter;
+use crsn_stacks::StackOps;
 
-fn main() {
-    SimpleLogger::new()
-        .with_level(LevelFilter::Warn)
-        .init().unwrap();
+mod read_file;
 
-    // ;(dec r0 (z? (ret)))
-    /*let program = "
-    (
-        (main
-            (ld r0 2)
-            (:again)
-            (dec r0)
-            (jif nz :again)
-            (fault \"that's it\")
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct LogConfig {
+    level: String,
+    modules: HashMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct Config {
+    log: LogConfig,
+    #[serde(skip)]
+    program_file: String,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            log: LogConfig {
+                level: "info".to_string(),
+                modules: Default::default(),
+            },
+            program_file: "".to_string(),
+        }
+    }
+}
+
+impl AppConfig for Config {
+    type Init = Self;
+
+    fn logging(&self) -> &str {
+        &self.log.level
+    }
+
+    fn logging_mod_levels(&self) -> Option<&HashMap<String, String>> {
+        Some(&self.log.modules)
+    }
+
+    /// Add args to later use in the `configure` method.
+    fn add_args<'a: 'b, 'b>(clap: clap::App<'a, 'b>) -> clap::App<'a, 'b> {
+        // Default impl
+        clap.arg(
+            clap::Arg::with_name("input")
+                .value_name("FILE")
+                .help("Program to run")
+                .required_unless("default-config")
+                .takes_value(true),
         )
-    )
-    ";*/
-    /*
-        let program = "
-        (
-            (main
-                (ld r0 2)
-                (call add2x r0 15)
-                (ld r0 res0)
-                (fault \"that's it\")
-            )
-            (add2x
-                (ld r0 arg0)
-                (ld r1 arg1)
-                (add r0 r1)
-                (add r0 r1)
-                (ret r0)
-            )
-        )
-        ";*/
+    }
 
-    /*    let program = "
-        (
-            (main
-                (j :lbl)
-                (ld _ arg0)
-                (fault)
-                (:lbl)
-                (call fac 5)
-                (ld r0 res0)
-            )
-            (fac
-                (cmp arg0 2
-                    (eq? (ret 2)))
-                (ld r0 arg0)
-                (dec r0)
-                (call fac r0)
-                (ld r0 arg0)
-                (mul r0 res0)
-                (ret r0)
-            )
-        )
-        ";*/
+    fn configure(mut self, clap: &ArgMatches) -> anyhow::Result<Self> {
+        self.program_file = clap.value_of("input").unwrap().to_string();
+        Ok(self)
+    }
+}
 
-    let program = "
-    (
-        (main
-            (sc-init 800 600)
-            (sc-opt 1 0) ; auto blit
-            (sc-opt 2 60) ; frame rate
 
-            (ld r0 5) ; x
-            (ld r1 0) ; y
+fn main() -> anyhow::Result<()> {
+    let config = Config::init("crsn", "crsn.json5", env!("CARGO_PKG_VERSION"))?;
 
-            (ld r2 1) ; dx
-            (ld r3 1) ; dy
+    info!("Loading {}", config.program_file);
 
-            (ld r5 0x3300ff)
-
-            (:loop)
-            (add r5 0x000001)
-            (and r5 0xffffff)
-            (sc-px r0 r1 r5)
-            (add r0 r2)
-            (add r1 r3)
-            (cmp r0 799 (eq? (ld r2 -1)))
-            (cmp r0 0 (eq? (ld r2 1)))
-            (cmp r1 599 (eq? (ld r3 -1)))
-            (cmp r1 0 (eq? (ld r3 1)))
-            (sc-blit 0)
-            (j :loop)
-        )
-    )
-    ";
+    let source = read_file::read_file(&config.program_file)?;
 
     let parsers = Arc::new(vec![
         ArithOps::new(),
@@ -111,18 +84,23 @@ fn main() {
         ScreenOps::new(),
     ]);
 
-    let parsed = crsn::asm::assemble(program, parsers).unwrap();
+    let parsed = crsn::asm::assemble(&source, parsers)?;
 
-    let uniq = run_thread::new_uniq();
+    info!("Start runtime");
 
-    let mut thread1 = RunThread::new(ThreadToken(0), Some(uniq.clone()), parsed.clone(), Addr(0), &[]);
-    //thread1.set_speed(Duration::from_millis(250));
+    let thread = RunThread::new(
+        ThreadToken(0),
+        None,
+        parsed.clone(),
+        Addr(0), // TODO find "main"?
+        &[], // TODO from CLI?
+    );
 
-    let _thread2 = RunThread::new(ThreadToken(1), Some(uniq), parsed.clone(), Addr(0), &[]);
+    let a = thread.start();
+    // ...
+    let _ = a.join();
 
-    let a = thread1.start();
-    //let b = thread2.start();
+    info!("Runtime shut down.");
 
-    a.join().unwrap();
-    //b.join().unwrap();
+    Ok(())
 }

launcher/src/read_file.rs

@@ -0,0 +1,14 @@
+use std::fs::File;
+use std::io;
+use std::io::Read;
+use std::path::Path;
+
+/// Read a file to string
+pub fn read_file<P: AsRef<Path>>(path: P) -> io::Result<String> {
+    let path = path.as_ref();
+    let mut file = File::open(path)?;
+
+    let mut buf = String::new();
+    file.read_to_string(&mut buf)?;
+    Ok(buf)
+}