use references when executing instructions, not moves.

diff --git a/src/l0/ast.rs b/src/l0/ast.rs
index ee08b35a1bbbe50c57d4bc2c44b29cc5166ac06b..e84d385127e78ef2fef1d566e123d4d8208d9c41 100644 (file)
--- a/src/l0/ast.rs
+++ b/src/l0/ast.rs
@@ -17,7 +17,6 @@ pub enum Term {
     Var(Var)
 }
 
-#[derive(Clone)]
 pub enum MachineInstruction {
     GetStructure(Atom, usize, usize),
     PutStructure(Atom, usize, usize),

diff --git a/src/l0/machine.rs b/src/l0/machine.rs
index e9146f9f19143b2ad2cef1b2d0bb737bab5ff8c3..e507c1f1f08daf4fcf9a46b2968a8b79eef6359d 100644 (file)
--- a/src/l0/machine.rs
+++ b/src/l0/machine.rs
@@ -112,9 +112,9 @@ impl MachineState {
         }
     }    
     
-    pub fn execute(&mut self, instr: MachineInstruction) {
+    pub fn execute<'a, 'b : 'a>(&'a mut self, instr: &'b MachineInstruction) {
         match instr {
-            MachineInstruction::GetStructure(name, arity, reg) => {
+            &MachineInstruction::GetStructure(ref name, arity, reg) => {
                 let addr = self.deref(Addr::RegNum(reg));
 
                 match self.lookup(addr) {
@@ -122,7 +122,7 @@ impl MachineState {
                         let result = &self.heap[a];
 
                         if let &HeapCell::NamedStr(named_arity, ref named_str) = result {
-                            if arity == named_arity && name == *named_str {
+                            if arity == named_arity && *name == *named_str {
                                 self.s = a + 1;
                                 self.mode = MachineMode::Read;
                             } else {
@@ -132,7 +132,7 @@ impl MachineState {
                     },
                     &HeapCell::Ref(reg) => {
                         self.heap.push(HeapCell::Str(self.h + 1));
-                        self.heap.push(HeapCell::NamedStr(arity, name));
+                        self.heap.push(HeapCell::NamedStr(arity, name.clone()));
 
                         let h = self.h;
 
@@ -146,25 +146,25 @@ impl MachineState {
                     }
                 };
             },
-            MachineInstruction::PutStructure(name, arity, reg) => {
+            &MachineInstruction::PutStructure(ref name, arity, reg) => {
                 self.heap.push(HeapCell::Str(self.h + 1));
-                self.heap.push(HeapCell::NamedStr(arity, name));
+                self.heap.push(HeapCell::NamedStr(arity, name.clone()));
 
                 self.registers[reg] = self.heap[self.h].clone();
 
                 self.h += 2;
             },
-            MachineInstruction::SetVariable(reg) => {
+            &MachineInstruction::SetVariable(reg) => {
                 self.heap.push(HeapCell::Ref(self.h));
                 self.registers[reg] = self.heap[self.h].clone();
 
                 self.h += 1;
             },
-            MachineInstruction::SetValue(reg) => {
+            &MachineInstruction::SetValue(reg) => {
                 self.heap.push(self.registers[reg].clone());
                 self.h += 1;
             },
-            MachineInstruction::UnifyVariable(reg) => {
+            &MachineInstruction::UnifyVariable(reg) => {
                 match self.mode {
                     MachineMode::Read  => self.registers[reg] = self.heap[self.s].clone(),
                     MachineMode::Write => {
@@ -176,7 +176,7 @@ impl MachineState {
 
                 self.s += 1;
             },
-            MachineInstruction::UnifyValue(reg) => {
+            &MachineInstruction::UnifyValue(reg) => {
                 let s = self.s;
 
                 match self.mode {

diff --git a/src/main.rs b/src/main.rs
index af1d26a9f1e457638c6346891d2ca4410e450531..370f42980ee172788113418d055250ce3ddddfb6 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -40,14 +40,14 @@ fn l0_repl<'a>() {
                 println!("Program stored.");
             },
             Ok(TopLevel::Query(query)) => {
-                if let Some(program) = ms.program.clone().take() {                
+                if let Some(program) = ms.program.take() {                
                     let query = compile_query(&query);
                     
-                    for instruction in query {
+                    for instruction in &query {
                         ms.execute(instruction);
                     }
 
-                    for instruction in program {                    
+                    for instruction in &program {                    
                         ms.execute(instruction);
 
                         if ms.fail {                            
@@ -62,6 +62,7 @@ fn l0_repl<'a>() {
                     }
 
                     ms.reset_heap();
+                    ms.program = Some(program);
                 } else {
                     println!("No program to speak of.");
                 }