Bc to program

runtest.raku

@@ -1,6 +1,7 @@
 #!/usr/bin/env raku
 use Test;
 use JSON::Fast;
+use fatal;
 
 my @specs = from-json(slurp 'test/run/spec.json');
 for @specs -> % (:$name, :$is-error, :$skip, :@dependencies) {
@@ -21,20 +22,21 @@ for @specs -> % (:$name, :$is-error, :$skip, :@dependencies) {
   $proc.stderr.tap({ $error ~= $_ });
 
   try {
-    await $proc.start;
+    my $r = await $proc.start;
 
     if $is-error {
-      fail "Expected error.";
-    } else {
-      is @output.join("\n"), $expected-output, $name;
-    }
-
-    CATCH {
-      if $is-error {
-        is $error, $expected-output, $name;
+      if $r.exitcode {
+        ok $error ~~ /$expected-output/, $name;
       } else {
-        say "ERRORS:\n" ~ $error.lines.map("ERR: " ~ *).join("\n").indent(2) if $error;
+        flunk "Expected error in $name";
       }
+    } else {
+      if $r.exitcode {
+        diag "ERRORS:\n" ~ $error.lines.map("ERR: " ~ *).join("\n").indent(2);
+        flunk $name;
+      }
+
+      is @output.join("\n"), $expected-output, $name;
     }
   }
 }

src/bc.rs

@@ -0,0 +1,48 @@
+use std::collections::HashMap;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde()]
+pub struct ModuleName {
+    pub module: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "tag", content = "contents")]
+pub enum RawInstruction {
+    PushInt(i64),
+    PushString(usize),
+    LoadLocal(usize),
+    StoreLocal(usize),
+    LoadName(ModuleName, String),
+    LoadGlobal(String),
+    Unless(usize),
+    Jump(usize),
+    Call(usize),
+    Instantiate(ModuleName, String, String),
+    IsVariant(ModuleName, String, String),
+    Field(ModuleName, String, String, String),
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ADTVariant {
+    pub name: String,
+    pub elements: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ExpectedADT {
+    pub module: Vec<String>,
+    pub name: String,
+    pub variants: Vec<ADTVariant>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Module {
+    pub name: Vec<String>,
+    pub strings: Vec<String>,
+    pub functions: HashMap<String, Vec<RawInstruction>>,
+    pub dependencies: Vec<Vec<String>>,
+    pub adts: HashMap<String, Vec<ADTVariant>>,
+    pub expected_adts: Vec<ExpectedADT>,
+}

src/lib.rs

@@ -1,3 +1,5 @@
-pub mod context;
 pub mod vm;
+pub mod bc;
+pub mod program;
+
 extern crate serde;

src/main.rs

@@ -1,9 +1,9 @@
-use lib::vm::Module;
-use std::{collections::HashMap, env, fs::File, io::Read};
+use std::{env, fs::File, io::Read};
+use lib::{bc, vm};
 
 extern crate lib;
 
-fn load_module(path: String) -> Result<Module, String> {
+fn load_module(path: String) -> Result<bc::Module, String> {
     let mut content = String::new();
     if path == "-" {
         std::io::stdin()
@@ -19,7 +19,7 @@ fn load_module(path: String) -> Result<Module, String> {
 
 fn main() {
     let mut main: Vec<String> = Vec::new();
-    let mut modules: HashMap<Vec<String>, Module> = HashMap::new();
+    let mut modules: Vec<bc::Module> = Vec::new();
 
     // XXX this means `./undo-frontend` just errors, instead of behaving like `./undo-frontend -`
     for arg in env::args().skip(1) {
@@ -30,8 +30,8 @@ fn main() {
         if main.is_empty() {
             main = module_name.clone();
         }
-        modules.insert(module_name, module);
+        modules.push(module);
     }
 
-    lib::vm::run(main, modules);
+    vm::run(main, modules);
 }