codegen fixes

src/l0/codegen.rs

@@ -24,7 +24,7 @@ impl fmt::Display for MachineInstruction {
 }
 
 enum IntTerm<'a> {
-    FinishedClause(usize, &'a Atom, &'a Vec<Box<Term>>),
+    FinishedClause(usize, usize, &'a Atom, &'a Vec<Box<Term>>),
     UnfinishedClause(usize, &'a Atom, &'a Vec<Box<Term>>),
     FinishedAtom(usize, &'a Atom)
 }
@@ -50,28 +50,33 @@ pub fn compile_query<'a>(t: &'a Term) -> Program
         },
     };
 
+    let mut max_reg_used : usize = 1;
+
     while let Some(int_term) = stack.pop() {
         match int_term {
             IntTerm::UnfinishedClause(r, atom, terms) => {
-                stack.push(IntTerm::FinishedClause(r, atom, terms));
+                stack.push(IntTerm::FinishedClause(r, max_reg_used, atom, terms));
 
-                let mut counter : usize = r + 1;
+                let mut counter : usize = max_reg_used; // r + 1;
 
                 for t in terms {                                        
                     if t.is_variable() && !variable_allocs.contains_key(t.name()) {
+                        counter += 1;
                         variable_allocs.insert(t.name(), (counter, false));
-                    }
-
+                    } else if !t.is_variable() {
                         counter += 1;
                     }
+                }
 
-                counter = r + terms.len();
+                max_reg_used = counter;
 
                 for t in terms.iter().rev() {
                     let r = if t.is_variable() {
                         variable_allocs.get(t.name()).unwrap().0
                     } else {
-                        counter                        
+                        let oc = counter;
+                        counter -= 1;
+                        oc
                     };
 
                     match t.as_ref() {
@@ -81,16 +86,14 @@ pub fn compile_query<'a>(t: &'a Term) -> Program
                             stack.push(IntTerm::UnfinishedClause(r, atom, terms)),
                         _ => {}
                     };                    
-
-                    counter -= 1;
                 }
             },
             IntTerm::FinishedAtom(r, atom) =>
                 query.push(MachineInstruction::PutStructure(atom.clone(), 0, r)),
-            IntTerm::FinishedClause(r, atom, terms) => {
+            IntTerm::FinishedClause(r, mr, atom, terms) => {
                 query.push(MachineInstruction::PutStructure(atom.clone(), terms.len(), r));
 
-                let mut counter : usize = r + 1;
+                let mut counter : usize = mr + 1;
 
                 for t in terms {
                     if let &Term::Var(ref var) = t.as_ref() {
@@ -102,12 +105,17 @@ pub fn compile_query<'a>(t: &'a Term) -> Program
                         } else {
                             query.push(MachineInstruction::SetValue(reg));
                         }
-                    } else {
-                        query.push(MachineInstruction::SetValue(counter));
-                    }
 
+                        if reg == counter {
                             counter += 1;
                         }
+                    } else {
+                        query.push(MachineInstruction::SetValue(counter));
+                        counter += 1;
+                    }                    
+                }
+
+                max_reg_used = counter - 1;
             }
         };
     }

src/l0/machine.rs

@@ -163,7 +163,6 @@ impl MachineState {
                 self.h += 1;
             },
             MachineInstruction::UnifyVariable(reg) => {
-                if self.s < self.h {
                 match self.mode {
                     MachineMode::Read  => self.registers[reg] = self.heap[self.s].clone(),
                     MachineMode::Write => {
@@ -172,14 +171,8 @@ impl MachineState {
                         self.h += 1;
                     }
                 };                    
-                    
-                    self.s += 1;
-                } else {
-                    self.fail = true;
-                }
             },
             MachineInstruction::UnifyValue(reg) => {
-                if self.s < self.h {                
                 let s = self.s;
 
                 match self.mode {
@@ -191,9 +184,6 @@ impl MachineState {
                 };
                 
                 self.s += 1;
-                } else {
-                    self.fail = true;
-                }
             }
         }
     }

src/main.rs

@@ -6,7 +6,7 @@ use l0::machine::{MachineState};
 
 use std::io::{self, Write};
 
-fn print_instructions(program : Program) {
+fn print_instructions(program : &Program) {
     for instruction in program {
         println!("{:}", instruction);        
     }