Fixed interpreted program.

Cargo.toml

@@ -4,4 +4,10 @@ version = "0.1.0"
 authors = ["Jasper Schulz <[email protected]>"]
 
 [dependencies]
-maplit = "*"
+maplit = "*"
+kaktus = "0.1.2"
+log = "0.3"
+env_logger = "0.3"
+frunk = "0.1.22"
+frunk_core = "0.0.11"
+boolinator = "2.4.0"

README.md

@@ -0,0 +1,24 @@
+# daly
+Simple VM for a Dyon--subset
+
+To run use:
+
+    cargo run
+
+To see what is happening internally, you can enable logging:
+
+    RUST_LOG=daly cargo run 
+
+## Current state
+
+* `main.rs` implements a simple interpreter for some dyon-bytecode. `main()` contains the bytecode of [this](https://github.com/greenMT/example-programs/blob/master/example-programs/dyon/min_loop.dyon) program.
+
+* the interpreter traces execution of loops
+
+* `tracerunner.rs` contains an independent execution engine for generated traces
+
+
+### Optimisations
+
+**Inlining**
+Inlining of function calls is performed. Necessary steps for deoptimisation can be found in `tracerunner::Runner::recover`.

src/bytecode.rs

@@ -0,0 +1,40 @@
+
+
+#[derive(Debug, Clone, Copy)]
+pub enum Comp {
+    Eq,
+    Lt,
+    Le,
+    Gt,
+    Ge,
+}
+
+
+#[derive(Debug, Clone)]
+pub enum Instruction {
+    Call(String),
+    Return,
+
+    Add,
+    Cmp(Comp),
+
+    Jump(usize),
+    JumpIfTrue(usize),
+    JumpIfFalse(usize),
+
+    Load(usize),
+    Store(usize),
+    Const(usize),
+
+    Array(usize),
+    ArrayGet,
+    Push,
+
+    Loop,
+    Break,
+
+    // intrinsics
+    Len,
+    Print,
+    Clone,
+}

src/conversions.rs

@@ -0,0 +1,80 @@
+
+// XXX: there might be a macro which implements From/Into for enums
+
+use super::*;
+
+impl From<bool> for Value {
+    fn from(b: bool) -> Self {
+        Value::Bool(b)
+    }
+}
+
+impl From<Value> for bool {
+    fn from(val: Value) -> Self {
+        match val {
+            Value::Bool(b) => b,
+            _ => panic!("unexpeted Array variant"),
+        }
+    }
+}
+
+impl From<Vec<usize>> for Value {
+    fn from(xs: Vec<usize>) -> Self {
+        Value::Array(xs)
+    }
+}
+
+impl From<Value> for Vec<usize> {
+    fn from(val: Value) -> Self {
+        match val {
+            Value::Array(xs) => xs,
+            _ => panic!("unexpeted Array variant"),
+        }
+    }
+}
+
+impl AsMut<Vec<usize>> for Value {
+    fn as_mut(&mut self) -> &mut Vec<usize> {
+        match *self {
+            Value::Array(ref mut xs) => xs,
+            _ => panic!("unexpeted Array variant"),
+        }
+    }
+}
+
+
+impl From<Value> for usize {
+    fn from(val: Value) -> Self {
+        match val {
+            Value::Usize(n) => n,
+            _ => panic!("unexpeted Array variant"),
+        }
+    }
+}
+
+impl From<usize> for Value {
+    fn from(n: usize) -> Self {
+        Value::Usize(n)
+    }
+}
+
+
+impl<'a> From<&'a Instruction> for TraceInstruction {
+    fn from(instr: &Instruction) -> TraceInstruction {
+        use Instruction as I;
+        use TraceInstruction as TI;
+
+        match *instr {
+            I::Add => TI::Add,
+            I::Cmp(c) => TI::Cmp(c),
+            I::Const(c) => TI::Const(c),
+            I::Len => TI::Len,
+            I::Print => TI::Print,
+            I::Clone => TI::Clone,
+            I::Array(u) => TI::Array(u),
+            I::ArrayGet => TI::ArrayGet,
+
+            _ => panic!("can not convert {:?}", instr),
+        }
+    }
+}