From: Mark Thom Date: Sat, 29 Oct 2016 19:18:12 +0000 (-0600) Subject: codegen fixes X-Git-Tag: v0.8.110~793 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=63075c97391930bd1ef19d3a305218c78ec88175;p=scryer-prolog.git codegen fixes --- diff --git a/src/l0/codegen.rs b/src/l0/codegen.rs index 8b00fa96..0c2a642a 100644 --- a/src/l0/codegen.rs +++ b/src/l0/codegen.rs @@ -24,7 +24,7 @@ impl fmt::Display for MachineInstruction { } enum IntTerm<'a> { - FinishedClause(usize, &'a Atom, &'a Vec>), + FinishedClause(usize, usize, &'a Atom, &'a Vec>), UnfinishedClause(usize, &'a Atom, &'a Vec>), FinishedAtom(usize, &'a Atom) } @@ -38,7 +38,7 @@ pub fn compile_query<'a>(t: &'a Term) -> Program match t { &Term::Clause(ref atom, ref terms) => { stack.push(IntTerm::UnfinishedClause(1, atom, terms)); - variable_allocs.insert(atom, (1, true)); + variable_allocs.insert(atom, (1, true)); }, &Term::Atom(ref atom) => { query.push(MachineInstruction::PutStructure(atom.clone(), 0, 1)); @@ -50,48 +50,51 @@ 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; - - for t in terms { + let mut counter : usize = max_reg_used; // r + 1; + + for t in terms { if t.is_variable() && !variable_allocs.contains_key(t.name()) { - variable_allocs.insert(t.name(), (counter, false)); + counter += 1; + variable_allocs.insert(t.name(), (counter, false)); + } else if !t.is_variable() { + counter += 1; } - - 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() { - &Term::Atom(ref atom) => + &Term::Atom(ref atom) => stack.push(IntTerm::FinishedAtom(r, atom)), - &Term::Clause(ref atom, ref terms) => + &Term::Clause(ref atom, ref terms) => 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) => { + query.push(MachineInstruction::PutStructure(atom.clone(), 0, r)), + 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() { let &mut (reg, ref mut seen) = variable_allocs.get_mut(var).unwrap(); @@ -102,12 +105,17 @@ pub fn compile_query<'a>(t: &'a Term) -> Program } else { query.push(MachineInstruction::SetValue(reg)); } + + if reg == counter { + counter += 1; + } } else { query.push(MachineInstruction::SetValue(counter)); - } - - counter += 1; + counter += 1; + } } + + max_reg_used = counter - 1; } }; } @@ -121,15 +129,15 @@ pub fn compile_fact<'a>(t: &'a Term) -> Program { let mut variable_allocs : HashMap<&Var, usize> = HashMap::new(); let mut fact : Program = Vec::new(); - queue.push_back((1, t)); + queue.push_back((1, t)); - while let Some(t) = queue.pop_front() { + while let Some(t) = queue.pop_front() { match t { (r, &Term::Clause(ref atom, ref terms)) => { fact.push(MachineInstruction::GetStructure(atom.clone(), terms.len(), r)); - + let mut counter : usize = reg; - + for t in terms { if t.is_variable() && !variable_allocs.contains_key(t.name()) { variable_allocs.insert(t.name(), counter); @@ -142,7 +150,7 @@ pub fn compile_fact<'a>(t: &'a Term) -> Program { fact.push(MachineInstruction::UnifyVariable(counter)); queue.push_back((counter, t)); counter += 1; - } + } } reg = counter; diff --git a/src/l0/machine.rs b/src/l0/machine.rs index 8018a6b0..e2e3cd9f 100644 --- a/src/l0/machine.rs +++ b/src/l0/machine.rs @@ -163,37 +163,27 @@ 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 => { - self.heap.push(HeapCell::Ref(self.h)); - self.registers[reg] = self.heap[self.h].clone(); - self.h += 1; - } - }; - - self.s += 1; - } else { - self.fail = true; - } + match self.mode { + MachineMode::Read => self.registers[reg] = self.heap[self.s].clone(), + MachineMode::Write => { + self.heap.push(HeapCell::Ref(self.h)); + self.registers[reg] = self.heap[self.h].clone(); + self.h += 1; + } + }; }, MachineInstruction::UnifyValue(reg) => { - if self.s < self.h { - let s = self.s; - - match self.mode { - MachineMode::Read => self.unify(Addr::RegNum(reg), Addr::HeapCell(s)), - MachineMode::Write => { - self.heap.push(self.registers[reg].clone()); - self.h += 1; - } - }; - - self.s += 1; - } else { - self.fail = true; - } + let s = self.s; + + match self.mode { + MachineMode::Read => self.unify(Addr::RegNum(reg), Addr::HeapCell(s)), + MachineMode::Write => { + self.heap.push(self.registers[reg].clone()); + self.h += 1; + } + }; + + self.s += 1; } } } diff --git a/src/main.rs b/src/main.rs index 6282a8e0..00376731 100644 --- a/src/main.rs +++ b/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); } @@ -42,7 +42,7 @@ fn l0_repl<'a>() { Ok(TopLevel::Query(query)) => { if let Some(program) = ms.program.clone().take() { let query = compile_query(&query); - + for instruction in query { ms.execute(instruction); }