Add compiled artifact execution

Author: axiom-systemstech

examples/hello.axm

@@ -0,0 +1,4 @@
+AXIOM_ARTIFACT_V1
+FUNCTION:main
+PARAMS:0
+INSTR:PushString:Hello AXIOM;Print

native/src/main.rs

@@ -1,5 +1,6 @@
 use std::env;
 use std::fs;
+use std::path::Path;
 use std::process::ExitCode;
 
 fn main() -> ExitCode {
@@ -64,8 +65,16 @@ fn main() -> ExitCode {
                 })
         }) {
             Ok(program) => {
+                let output_path = match axiom_native::vm::write_artifact_file(Path::new(&path), &program) {
+                    Ok(path) => path,
+                    Err(error) => {
+                        eprintln!("error: {}", error.message);
+                        return ExitCode::from(1);
+                    }
+                };
                 let artifact = axiom_native::vm::build_artifact(&program);
                 println!("build ok: {path}");
+                println!("artifact file: {}", output_path.display());
                 println!("artifact bytes: {}", artifact.len());
                 ExitCode::SUCCESS
             }
@@ -77,33 +86,60 @@ fn main() -> ExitCode {
                 ExitCode::from(1)
             }
         },
-        "run" => match axiom_native::parser::parse(&source).and_then(|program| {
-            axiom_native::semantic::analyze(&program)
-                .map(|_| program)
-                .map_err(|error| axiom_native::parser::ParseError {
-                    message: error.message,
-                    line: 0,
-                    column: 0,
-                })
-        }) {
-            Ok(program) => match axiom_native::vm::execute_program(&program) {
-                Ok(output) => {
-                    print!("{output}");
-                    ExitCode::SUCCESS
+        "run" => {
+            if Path::new(&path).extension().and_then(|ext| ext.to_str()) == Some("axm") {
+                match fs::read_to_string(&path) {
+                    Ok(encoded) => match axiom_native::vm::Artifact::deserialize(&encoded) {
+                        Ok(artifact) => match axiom_native::vm::execute_artifact(&artifact) {
+                            Ok(output) => {
+                                print!("{output}");
+                                ExitCode::SUCCESS
+                            }
+                            Err(error) => {
+                                eprintln!("error: {}", error.message);
+                                ExitCode::from(1)
+                            }
+                        },
+                        Err(error) => {
+                            eprintln!("error: {}", error.message);
+                            ExitCode::from(1)
+                        }
+                    },
+                    Err(error) => {
+                        eprintln!("error: cannot read {path}: {error}");
+                        ExitCode::from(1)
+                    }
                 }
-                Err(error) => {
-                    eprintln!("error: {}", error.message);
-                    ExitCode::from(1)
+            } else {
+                match axiom_native::parser::parse(&source).and_then(|program| {
+                    axiom_native::semantic::analyze(&program)
+                        .map(|_| program)
+                        .map_err(|error| axiom_native::parser::ParseError {
+                            message: error.message,
+                            line: 0,
+                            column: 0,
+                        })
+                }) {
+                    Ok(program) => match axiom_native::vm::execute_program(&program) {
+                        Ok(output) => {
+                            print!("{output}");
+                            ExitCode::SUCCESS
+                        }
+                        Err(error) => {
+                            eprintln!("error: {}", error.message);
+                            ExitCode::from(1)
+                        }
+                    },
+                    Err(error) => {
+                        eprintln!(
+                            "error: {} at {}:{}",
+                            error.message, error.line, error.column
+                        );
+                        ExitCode::from(1)
+                    }
                 }
-            },
-            Err(error) => {
-                eprintln!(
-                    "error: {} at {}:{}",
-                    error.message, error.line, error.column
-                );
-                ExitCode::from(1)
             }
-        },
+        }
         _ => {
             eprintln!("error: unknown command '{command}'");
             print_help();

native/src/vm.rs

@@ -156,10 +156,37 @@ pub fn execute_program(program: &Program) -> Result<String, VmError> {
     Ok(machine.output)
 }
 
+pub fn execute_artifact(artifact: &Artifact) -> Result<String, VmError> {
+    let functions = artifact
+        .functions
+        .iter()
+        .cloned()
+        .map(|function| LoweredFunction {
+            name: function.name,
+            parameters: function.parameters,
+            return_type: None,
+            instructions: function.instructions,
+        })
+        .collect();
+    let mut machine = Machine::new(functions);
+    machine.call_function("main", Vec::new())?;
+    Ok(machine.output)
+}
+
 pub fn build_artifact(program: &Program) -> String {
     compile_program(program).serialize()
 }
 
+pub fn write_artifact_file(path: &std::path::Path, program: &Program) -> Result<std::path::PathBuf, VmError> {
+    let artifact = compile_program(program);
+    let serialized = artifact.serialize();
+    let out_path = path.with_extension("axm");
+    std::fs::write(&out_path, &serialized).map_err(|error| VmError {
+        message: format!("cannot write artifact '{}': {error}", out_path.display()),
+    })?;
+    Ok(out_path)
+}
+
 struct Machine {
     functions: Vec<LoweredFunction>,
     output: String,
@@ -593,4 +620,14 @@ mod tests {
         assert_eq!(decoded.functions[0].name, "main");
         assert!(!decoded.functions[0].instructions.is_empty());
     }
+
+    #[test]
+    fn executes_deserialized_artifact() {
+        let program = parse("fn main() { print(42) }").unwrap();
+        let artifact = compile_program(&program);
+        let encoded = artifact.serialize();
+        let decoded = Artifact::deserialize(&encoded).unwrap();
+        let output = execute_artifact(&decoded).unwrap();
+        assert_eq!(output, "42\n");
+    }
 }