From: Mark Thom Date: Fri, 12 Jan 2018 03:56:04 +0000 (-0700) Subject: another big refactor X-Git-Tag: v0.8.110~636 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=c513bbeafafdadb661ea488b734a90e153afb7a3;p=scryer-prolog.git another big refactor --- diff --git a/Cargo.lock b/Cargo.lock index a8c09442..966a4013 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,14 +1,3 @@ -[root] -name = "rusty-wam" -version = "0.7.4" -dependencies = [ - "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", - "num 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)", - "ordered-float 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", - "regex 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", - "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)", -] - [[package]] name = "aho-corasick" version = "0.6.4" @@ -180,6 +169,17 @@ name = "rustc-serialize" version = "0.3.24" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "rusty-wam" +version = "0.7.4" +dependencies = [ + "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", + "num 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)", + "ordered-float 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", + "regex 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", + "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "termion" version = "1.5.1" diff --git a/src/prolog/arithmetic.rs b/src/prolog/arithmetic.rs index 5ccb7972..4d16c4f7 100644 --- a/src/prolog/arithmetic.rs +++ b/src/prolog/arithmetic.rs @@ -5,14 +5,14 @@ use std::cmp::{min, max}; use std::vec::Vec; pub struct ArithExprIterator<'a> { - state_stack: Vec> + state_stack: Vec> } pub type ArithCont = (Code, Option); impl<'a> ArithExprIterator<'a> { fn push_subterm(&mut self, lvl: Level, term: &'a Term) { - self.state_stack.push(IteratorState::to_state(lvl, term)); + self.state_stack.push(TermIterState::to_state(lvl, term)); } fn new(term: &'a Term) -> Result { @@ -20,13 +20,13 @@ impl<'a> ArithExprIterator<'a> { &Term::AnonVar => return Err(ArithmeticError::InvalidTerm), &Term::Clause(_, _, ref terms) => - IteratorState::Clause(0, ClauseType::Root, terms), + TermIterState::Clause(0, ClauseType::Root, terms), &Term::Constant(ref cell, ref cons) => - IteratorState::Constant(Level::Shallow, cell, cons), + TermIterState::Constant(Level::Shallow, cell, cons), &Term::Cons(_, _, _) => return Err(ArithmeticError::InvalidTerm), &Term::Var(ref cell, ref var) => - IteratorState::Var(Level::Shallow, cell, var) + TermIterState::Var(Level::Shallow, cell, var) }; Ok(ArithExprIterator { state_stack: vec![state] }) @@ -45,26 +45,26 @@ impl<'a> Iterator for ArithExprIterator<'a> { fn next(&mut self) -> Option { while let Some(iter_state) = self.state_stack.pop() { match iter_state { - IteratorState::AnonVar(lvl) => + TermIterState::AnonVar(lvl) => return Some(TermRef::AnonVar(lvl)), - IteratorState::Clause(child_num, ct, child_terms) => { + TermIterState::Clause(child_num, ct, child_terms) => { if child_num == child_terms.len() { return Some(TermRef::Clause(ct, child_terms)); } else { - self.state_stack.push(IteratorState::Clause(child_num + 1, ct, child_terms)); + self.state_stack.push(TermIterState::Clause(child_num + 1, ct, child_terms)); self.push_subterm(ct.level_of_subterms(), child_terms[child_num].as_ref()); } }, - IteratorState::InitialCons(lvl, cell, head, tail) => { - self.state_stack.push(IteratorState::FinalCons(lvl, cell, head, tail)); + TermIterState::InitialCons(lvl, cell, head, tail) => { + self.state_stack.push(TermIterState::FinalCons(lvl, cell, head, tail)); self.push_subterm(Level::Deep, tail); self.push_subterm(Level::Deep, head); }, - IteratorState::FinalCons(lvl, cell, head, tail) => + TermIterState::FinalCons(lvl, cell, head, tail) => return Some(TermRef::Cons(lvl, cell, head, tail)), - IteratorState::Constant(lvl, cell, constant) => + TermIterState::Constant(lvl, cell, constant) => return Some(TermRef::Constant(lvl, cell, constant)), - IteratorState::Var(lvl, cell, var) => + TermIterState::Var(lvl, cell, var) => return Some(TermRef::Var(lvl, cell, var)) }; } diff --git a/src/prolog/ast.rs b/src/prolog/ast.rs index 7cc9ed0e..a53f40e2 100644 --- a/src/prolog/ast.rs +++ b/src/prolog/ast.rs @@ -862,8 +862,18 @@ impl Addr { _ => false } } - + pub fn as_ref(&self) -> Option { + match self { + &Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), + &Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), + &Addr::Lis(hc) => Some(Ref::HeapCell(hc)), + &Addr::Str(hc) => Some(Ref::HeapCell(hc)), + _ => None + } + } + + pub fn as_var(&self) -> Option { match self { &Addr::HeapCell(hc) => Some(Ref::HeapCell(hc)), &Addr::StackCell(fr, sc) => Some(Ref::StackCell(fr, sc)), @@ -896,37 +906,14 @@ pub enum Ref { #[derive(Clone, PartialEq)] pub enum HeapCellValue { - Con(Constant), - Lis(usize), - NamedStr(usize, Rc), - Ref(Ref), - Str(usize) -} - -impl From for HeapCellValue { - fn from(addr: Addr) -> HeapCellValue { - match addr { - Addr::Con(constant) => - HeapCellValue::Con(constant), - Addr::HeapCell(hc) => - HeapCellValue::Ref(Ref::HeapCell(hc)), - Addr::Lis(a) => - HeapCellValue::Lis(a), - Addr::StackCell(fr, sc) => - HeapCellValue::Ref(Ref::StackCell(fr, sc)), - Addr::Str(hc) => - HeapCellValue::Str(hc) - } - } + Addr(Addr), + NamedStr(usize, Rc), // arity, name. } impl HeapCellValue { pub fn as_addr(&self, focus: usize) -> Addr { match self { - &HeapCellValue::Con(ref c) => Addr::Con(c.clone()), - &HeapCellValue::Lis(a) => Addr::Lis(a), - &HeapCellValue::Ref(r) => Addr::from(r), - &HeapCellValue::Str(s) => Addr::Str(s), + &HeapCellValue::Addr(ref a) => a.clone(), &HeapCellValue::NamedStr(_, _) => Addr::Str(focus) } } @@ -1064,7 +1051,7 @@ impl Term { } } -pub enum IteratorState<'a> { +pub enum TermIterState<'a> { AnonVar(Level), Clause(usize, ClauseType<'a>, &'a Vec>), Constant(Level, &'a Cell, &'a Constant), @@ -1073,19 +1060,19 @@ pub enum IteratorState<'a> { Var(Level, &'a Cell, &'a Var) } -impl<'a> IteratorState<'a> { - pub fn to_state(lvl: Level, term: &'a Term) -> IteratorState<'a> { +impl<'a> TermIterState<'a> { + pub fn to_state(lvl: Level, term: &'a Term) -> TermIterState<'a> { match term { &Term::AnonVar => - IteratorState::AnonVar(lvl), + TermIterState::AnonVar(lvl), &Term::Clause(ref cell, ref atom, ref child_terms) => - IteratorState::Clause(0, ClauseType::Deep(lvl, cell, atom), child_terms), + TermIterState::Clause(0, ClauseType::Deep(lvl, cell, atom), child_terms), &Term::Cons(ref cell, ref head, ref tail) => - IteratorState::InitialCons(lvl, cell, head.as_ref(), tail.as_ref()), + TermIterState::InitialCons(lvl, cell, head.as_ref(), tail.as_ref()), &Term::Constant(ref cell, ref constant) => - IteratorState::Constant(lvl, cell, constant), + TermIterState::Constant(lvl, cell, constant), &Term::Var(ref cell, ref var) => - IteratorState::Var(lvl, cell, var) + TermIterState::Var(lvl, cell, var) } } } diff --git a/src/prolog/copier.rs b/src/prolog/copier.rs index f108d15c..cdf7e192 100644 --- a/src/prolog/copier.rs +++ b/src/prolog/copier.rs @@ -17,81 +17,87 @@ pub trait CopierTarget // after it's been copied to L2. fn duplicate_term(&mut self, a: Addr) where Self: IndexMut { - let mut forward_trail: Vec<(Ref, HeapCellValue)>= Vec::new(); + let mut trail: Vec<(Ref, HeapCellValue)>= Vec::new(); let mut scan = self.source(); let old_h = self.threshold(); - self.push(HeapCellValue::from(a)); + self.push(HeapCellValue::Addr(a)); while scan < self.threshold() { match self[scan].clone() { - HeapCellValue::Con(_) | HeapCellValue::NamedStr(_, _) => + HeapCellValue::NamedStr(_, _) => scan += 1, - HeapCellValue::Lis(a) => { - self[scan] = HeapCellValue::Lis(self.threshold()); + HeapCellValue::Addr(a) => + match a.clone() { + Addr::Lis(a) => { + self[scan] = HeapCellValue::Addr(Addr::Lis(self.threshold())); - let hcv = self[a].clone(); - self.push(hcv); + let hcv = self[a].clone(); + self.push(hcv); - let hcv = self[a+1].clone(); - self.push(hcv); + let hcv = self[a+1].clone(); + self.push(hcv); - scan += 1; - }, - HeapCellValue::Ref(r) => { - let ra = Addr::from(r); - let rd = self.store(self.deref(ra.clone())); - - match rd { - Addr::HeapCell(hc) if hc >= old_h => { - self[scan] = HeapCellValue::Ref(Ref::HeapCell(hc)); scan += 1; }, - _ if ra == rd => { - self[scan] = HeapCellValue::Ref(Ref::HeapCell(scan)); - - match r { - Ref::HeapCell(hc) => - self[hc] = HeapCellValue::Ref(Ref::HeapCell(scan)), - Ref::StackCell(fr, sc) => - self.stack()[fr][sc] = Addr::HeapCell(scan) + Addr::HeapCell(_) | Addr::StackCell(_, _) => { + let ra = a; + let rd = self.store(self.deref(ra.clone())); + + match rd.clone() { + Addr::HeapCell(hc) if hc >= old_h => { + self[scan] = HeapCellValue::Addr(rd); + scan += 1; + }, + _ if ra == rd => { + self[scan] = HeapCellValue::Addr(Addr::HeapCell(scan)); + + if let Addr::HeapCell(hc) = ra.clone() { + self[hc] = HeapCellValue::Addr(Addr::HeapCell(scan)); + trail.push((Ref::HeapCell(hc), + HeapCellValue::Addr(Addr::HeapCell(hc)))); + } else if let Addr::StackCell(fr, sc) = ra { + self.stack()[fr][sc] = Addr::HeapCell(scan); + trail.push((Ref::StackCell(fr, sc), + HeapCellValue::Addr(Addr::StackCell(fr, sc)))); + } + + scan += 1; + }, + _ => self[scan] = HeapCellValue::Addr(rd) }; + }, + Addr::Str(s) => { + match self[s].clone() { + HeapCellValue::NamedStr(arity, name) => { + let threshold = self.threshold(); + + self[scan] = HeapCellValue::Addr(Addr::Str(threshold)); + self[s] = HeapCellValue::Addr(Addr::Str(threshold)); + + trail.push((Ref::HeapCell(s), + HeapCellValue::NamedStr(arity, name.clone()))); + + self.push(HeapCellValue::NamedStr(arity, name)); + + for i in 0 .. arity { + let hcv = self[s + 1 + i].clone(); + self.push(hcv); + } + }, + HeapCellValue::Addr(Addr::Str(o)) => + self[scan] = HeapCellValue::Addr(Addr::Str(o)), + _ => {} + } - forward_trail.push((r, HeapCellValue::Ref(r))); scan += 1; }, - _ => self[scan] = HeapCellValue::from(rd) + Addr::Con(_) => scan += 1 } - }, - HeapCellValue::Str(s) => { - match self[s].clone() { - HeapCellValue::NamedStr(arity, name) => { - let threshold = self.threshold(); - - self[scan] = HeapCellValue::Str(threshold); - self[s] = HeapCellValue::Str(threshold); - - forward_trail.push((Ref::HeapCell(s), - HeapCellValue::NamedStr(arity, name.clone()))); - - self.push(HeapCellValue::NamedStr(arity, name)); - - for i in 0 .. arity { - let hcv = self[s + 1 + i].clone(); - self.push(hcv); - } - }, - HeapCellValue::Str(o) => - self[scan] = HeapCellValue::Str(o), - _ => {} - }; - - scan += 1; - } - }; + } } - for (r, hcv) in forward_trail { + for (r, hcv) in trail { match r { Ref::HeapCell(hc) => self[hc] = hcv, Ref::StackCell(fr, sc) => self.stack()[fr][sc] = hcv.as_addr(0) diff --git a/src/prolog/heapview.rs b/src/prolog/heapview.rs index 52ed0747..f46fe65c 100644 --- a/src/prolog/heapview.rs +++ b/src/prolog/heapview.rs @@ -128,10 +128,6 @@ impl<'a> HeapCellViewer<'a> fn from_heap(&mut self, mut focus: usize) -> CellView<'a> { loop { match &self.heap[focus] { - &HeapCellValue::Con(ref c) => - return CellView::Con(c), - &HeapCellValue::Lis(a) => - return self.handle_list(a), &HeapCellValue::NamedStr(arity, ref name) => { self.state_stack.push(CellRef::TToken(TToken::RRBracket)); @@ -145,21 +141,29 @@ impl<'a> HeapCellViewer<'a> return CellView::Str(arity, name); }, - &HeapCellValue::Ref(Ref::HeapCell(hc)) => - if focus == hc { - return CellView::HeapVar(hc); - } else { - focus = hc; - }, - &HeapCellValue::Ref(Ref::StackCell(fr, sc)) => - match self.deref_cell(&self.and_stack[fr][sc]) { - CellRef::Lis(hc) => return self.handle_list(hc), - CellRef::View(cell_view) => return cell_view, - CellRef::Redirect(hc) => focus = hc, - CellRef::TToken(token) => return CellView::TToken(token) - }, - &HeapCellValue::Str(cell_num) => - focus = cell_num, + &HeapCellValue::Addr(ref a) => + match a { + &Addr::Con(ref c) => + return CellView::Con(c), + &Addr::Lis(a) => + return self.handle_list(a), + &Addr::HeapCell(hc) => + if focus == hc { + return CellView::HeapVar(hc); + } else { + focus = hc; + }, + &Addr::StackCell(fr, sc) => + match self.deref_cell(&self.and_stack[fr][sc]) { + CellRef::Lis(hc) => return self.handle_list(hc), + CellRef::View(cell_view) => return cell_view, + CellRef::Redirect(hc) => focus = hc, + CellRef::TToken(token) => return CellView::TToken(token) + }, + &Addr::Str(cell_num) => + focus = cell_num, + }, + } } } diff --git a/src/prolog/iterators.rs b/src/prolog/iterators.rs index e5cf2d35..26a7c0fa 100644 --- a/src/prolog/iterators.rs +++ b/src/prolog/iterators.rs @@ -5,12 +5,12 @@ use std::iter::*; use std::vec::Vec; pub struct QueryIterator<'a> { - state_stack: Vec> + state_stack: Vec> } impl<'a> QueryIterator<'a> { fn push_subterm(&mut self, lvl: Level, term: &'a Term) { - self.state_stack.push(IteratorState::to_state(lvl, term)); + self.state_stack.push(TermIterState::to_state(lvl, term)); } fn from_term(term: &'a Term) -> Self { @@ -18,13 +18,13 @@ impl<'a> QueryIterator<'a> { &Term::AnonVar => return QueryIterator { state_stack: vec![] }, &Term::Clause(_, _, ref terms) => - IteratorState::Clause(0, ClauseType::Root, terms), + TermIterState::Clause(0, ClauseType::Root, terms), &Term::Cons(_, _, _) => return QueryIterator { state_stack: vec![] }, &Term::Constant(_, _) => return QueryIterator { state_stack: vec![] }, &Term::Var(ref cell, ref var) => - IteratorState::Var(Level::Shallow, cell, var) + TermIterState::Var(Level::Shallow, cell, var) }; QueryIterator { state_stack: vec![state] } @@ -33,21 +33,21 @@ impl<'a> QueryIterator<'a> { fn new(term: &'a QueryTerm) -> Self { match term { &QueryTerm::CallN(ref terms) => { - let state = IteratorState::Clause(1, ClauseType::CallN, terms); + let state = TermIterState::Clause(1, ClauseType::CallN, terms); QueryIterator { state_stack: vec![state] } }, &QueryTerm::Catch(ref terms) => { - let state = IteratorState::Clause(0, ClauseType::Catch, terms); + let state = TermIterState::Clause(0, ClauseType::Catch, terms); QueryIterator { state_stack: vec![state] } }, &QueryTerm::Arg(ref terms) | &QueryTerm::Functor(ref terms) => { - let state = IteratorState::Clause(0, ClauseType::Root, terms); + let state = TermIterState::Clause(0, ClauseType::Root, terms); QueryIterator { state_stack: vec![state] } }, &QueryTerm::Inlined(InlinedQueryTerm::CompareNumber(_, ref terms)) | &QueryTerm::Is(ref terms) => { - let state = IteratorState::Clause(0, ClauseType::Is, terms); + let state = TermIterState::Clause(0, ClauseType::Is, terms); QueryIterator { state_stack: vec![state] } }, &QueryTerm::Inlined(InlinedQueryTerm::IsAtomic(ref terms)) @@ -57,7 +57,7 @@ impl<'a> QueryIterator<'a> { &QueryTerm::Term(ref term) => Self::from_term(term), &QueryTerm::Throw(ref term) => { - let state = IteratorState::Clause(0, ClauseType::Throw, term); + let state = TermIterState::Clause(0, ClauseType::Throw, term); QueryIterator { state_stack: vec![state] } }, &QueryTerm::Cut => QueryIterator { state_stack: vec![] } @@ -77,9 +77,9 @@ impl<'a> Iterator for QueryIterator<'a> { fn next(&mut self) -> Option { while let Some(iter_state) = self.state_stack.pop() { match iter_state { - IteratorState::AnonVar(lvl) => + TermIterState::AnonVar(lvl) => return Some(TermRef::AnonVar(lvl)), - IteratorState::Clause(child_num, ct, child_terms) => { + TermIterState::Clause(child_num, ct, child_terms) => { if child_num == child_terms.len() { match ct { ClauseType::CallN => @@ -90,20 +90,20 @@ impl<'a> Iterator for QueryIterator<'a> { return None }; } else { - self.state_stack.push(IteratorState::Clause(child_num + 1, ct, child_terms)); + self.state_stack.push(TermIterState::Clause(child_num + 1, ct, child_terms)); self.push_subterm(ct.level_of_subterms(), child_terms[child_num].as_ref()); } }, - IteratorState::InitialCons(lvl, cell, head, tail) => { - self.state_stack.push(IteratorState::FinalCons(lvl, cell, head, tail)); + TermIterState::InitialCons(lvl, cell, head, tail) => { + self.state_stack.push(TermIterState::FinalCons(lvl, cell, head, tail)); self.push_subterm(Level::Deep, tail); self.push_subterm(Level::Deep, head); }, - IteratorState::FinalCons(lvl, cell, head, tail) => + TermIterState::FinalCons(lvl, cell, head, tail) => return Some(TermRef::Cons(lvl, cell, head, tail)), - IteratorState::Constant(lvl, cell, constant) => + TermIterState::Constant(lvl, cell, constant) => return Some(TermRef::Constant(lvl, cell, constant)), - IteratorState::Var(lvl, cell, var) => + TermIterState::Var(lvl, cell, var) => return Some(TermRef::Var(lvl, cell, var)) }; } @@ -113,29 +113,29 @@ impl<'a> Iterator for QueryIterator<'a> { } pub struct FactIterator<'a> { - state_queue: VecDeque>, + state_queue: VecDeque>, } impl<'a> FactIterator<'a> { fn push_subterm(&mut self, lvl: Level, term: &'a Term) { - self.state_queue.push_back(IteratorState::to_state(lvl, term)); + self.state_queue.push_back(TermIterState::to_state(lvl, term)); } fn new(term: &'a Term) -> FactIterator<'a> { let states = match term { &Term::AnonVar => - vec![IteratorState::AnonVar(Level::Shallow)], + vec![TermIterState::AnonVar(Level::Shallow)], &Term::Clause(_, _, ref terms) => - vec![IteratorState::Clause(0, ClauseType::Root, terms)], + vec![TermIterState::Clause(0, ClauseType::Root, terms)], &Term::Cons(ref cell, ref head, ref tail) => - vec![IteratorState::InitialCons(Level::Shallow, + vec![TermIterState::InitialCons(Level::Shallow, cell, head.as_ref(), tail.as_ref())], &Term::Constant(ref cell, ref constant) => - vec![IteratorState::Constant(Level::Shallow, cell, constant)], + vec![TermIterState::Constant(Level::Shallow, cell, constant)], &Term::Var(ref cell, ref var) => - vec![IteratorState::Var(Level::Shallow, cell, var)] + vec![TermIterState::Var(Level::Shallow, cell, var)] }; FactIterator { state_queue: VecDeque::from(states) } @@ -148,9 +148,9 @@ impl<'a> Iterator for FactIterator<'a> { fn next(&mut self) -> Option { while let Some(state) = self.state_queue.pop_front() { match state { - IteratorState::AnonVar(lvl) => + TermIterState::AnonVar(lvl) => return Some(TermRef::AnonVar(lvl)), - IteratorState::Clause(_, ct, child_terms) => { + TermIterState::Clause(_, ct, child_terms) => { for child_term in child_terms { self.push_subterm(ct.level_of_subterms(), child_term); } @@ -162,15 +162,15 @@ impl<'a> Iterator for FactIterator<'a> { continue }; }, - IteratorState::InitialCons(lvl, cell, head, tail) => { + TermIterState::InitialCons(lvl, cell, head, tail) => { self.push_subterm(Level::Deep, head); self.push_subterm(Level::Deep, tail); return Some(TermRef::Cons(lvl, cell, head, tail)); }, - IteratorState::Constant(lvl, cell, constant) => + TermIterState::Constant(lvl, cell, constant) => return Some(TermRef::Constant(lvl, cell, constant)), - IteratorState::Var(lvl, cell, var) => + TermIterState::Var(lvl, cell, var) => return Some(TermRef::Var(lvl, cell, var)), _ => {} } diff --git a/src/prolog/machine.rs b/src/prolog/machine.rs index 314bc710..f426c33d 100644 --- a/src/prolog/machine.rs +++ b/src/prolog/machine.rs @@ -535,7 +535,7 @@ impl Machine { result += cell_num.to_string().as_str(); }, CellView::StackVar(_, cell_num) => { - result += "s_"; + result += "s_"; result += cell_num.to_string().as_str(); }, CellView::Str(_, ref name) => @@ -669,7 +669,7 @@ impl MachineState { Ref::StackCell(fr, sc) => self.and_stack[fr][sc] = t2, Ref::HeapCell(hc) => - self.heap[hc] = HeapCellValue::from(t2) + self.heap[hc] = HeapCellValue::Addr(t2) }; self.trail(r1); @@ -764,7 +764,7 @@ impl MachineState { for i in a1 .. a2 { match self.trail[i] { Ref::HeapCell(r) => - self.heap[r] = HeapCellValue::Ref(Ref::HeapCell(r)), + self.heap[r] = HeapCellValue::Addr(Addr::HeapCell(r)), Ref::StackCell(fr, sc) => self.and_stack[fr][sc] = Addr::StackCell(fr, sc) } @@ -818,7 +818,7 @@ impl MachineState { match self.store(addr) { Addr::HeapCell(hc) => { - self.heap[hc] = HeapCellValue::Con(c.clone()); + self.heap[hc] = HeapCellValue::Addr(Addr::Con(c.clone())); self.trail(Ref::HeapCell(hc)); }, Addr::StackCell(fr, sc) => { @@ -1142,7 +1142,7 @@ impl MachineState { Addr::HeapCell(hc) => { let h = self.heap.h; - self.heap.push(HeapCellValue::Lis(h+1)); + self.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); self.bind(Ref::HeapCell(hc), Addr::HeapCell(h)); self.mode = MachineMode::Write; @@ -1150,7 +1150,7 @@ impl MachineState { Addr::StackCell(fr, sc) => { let h = self.heap.h; - self.heap.push(HeapCellValue::Lis(h+1)); + self.heap.push(HeapCellValue::Addr(Addr::Lis(h+1))); self.bind(Ref::StackCell(fr, sc), Addr::HeapCell(h)); self.mode = MachineMode::Write; @@ -1181,10 +1181,10 @@ impl MachineState { Addr::HeapCell(_) | Addr::StackCell(_, _) => { let h = self.heap.h; - self.heap.push(HeapCellValue::Str(h + 1)); + self.heap.push(HeapCellValue::Addr(Addr::Str(h + 1))); self.heap.push(HeapCellValue::NamedStr(arity, name.clone())); - self.bind(addr.as_ref().unwrap(), Addr::HeapCell(h)); + self.bind(addr.as_var().unwrap(), Addr::HeapCell(h)); self.mode = MachineMode::Write; }, @@ -1206,7 +1206,7 @@ impl MachineState { self.write_constant_to_var(addr, c.clone()); }, MachineMode::Write => { - self.heap.push(HeapCellValue::Con(c.clone())); + self.heap.push(HeapCellValue::Addr(Addr::Con(c.clone()))); } }; @@ -1219,7 +1219,7 @@ impl MachineState { MachineMode::Write => { let h = self.heap.h; - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self[reg] = Addr::HeapCell(h); } }; @@ -1249,7 +1249,7 @@ impl MachineState { } } - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self.bind(Ref::HeapCell(h), addr); } }; @@ -1266,7 +1266,7 @@ impl MachineState { }, MachineMode::Write => { let heap_val = self.store(self[reg].clone()); - self.heap.push(HeapCellValue::from(heap_val)); + self.heap.push(HeapCellValue::Addr(heap_val)); } }; @@ -1280,7 +1280,7 @@ impl MachineState { let h = self.heap.h; for i in h .. h + n { - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(i))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(i))); } } }; @@ -1374,7 +1374,7 @@ impl MachineState { } else { let h = self.heap.h; - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self.bind(Ref::HeapCell(h), addr); self.registers[arg] = self.heap[h].as_addr(h); @@ -1392,15 +1392,15 @@ impl MachineState { }, RegType::Temp(_) => { let h = self.heap.h; - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self[norm] = Addr::HeapCell(h); self.registers[arg] = Addr::HeapCell(h); } }; }, - &QueryInstruction::SetConstant(ref constant) => { - self.heap.push(HeapCellValue::Con(constant.clone())); + &QueryInstruction::SetConstant(ref c) => { + self.heap.push(HeapCellValue::Addr(Addr::Con(c.clone()))); }, &QueryInstruction::SetLocalValue(reg) => { let addr = self.deref(self[reg].clone()); @@ -1408,28 +1408,28 @@ impl MachineState { if let Addr::HeapCell(hc) = addr { if hc < h { - self.heap.push(HeapCellValue::from(addr)); + self.heap.push(HeapCellValue::Addr(addr)); return; } } - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self.bind(Ref::HeapCell(h), addr); }, &QueryInstruction::SetVariable(reg) => { let h = self.heap.h; - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); self[reg] = Addr::HeapCell(h); }, &QueryInstruction::SetValue(reg) => { let heap_val = self[reg].clone(); - self.heap.push(HeapCellValue::from(heap_val)); + self.heap.push(HeapCellValue::Addr(heap_val)); }, &QueryInstruction::SetVoid(n) => { let h = self.heap.h; for i in h .. h + n { - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(i))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(i))); } } } @@ -1539,7 +1539,7 @@ impl MachineState { self.throw_exception(functor!("type_error", 2, [atom!("callable"), - HeapCellValue::from(addr)])); + HeapCellValue::Addr(addr)])); return None; } }; @@ -1552,11 +1552,11 @@ impl MachineState { for heap_value in self.ball.1.iter().cloned() { self.heap.push(match heap_value { - HeapCellValue::Con(c) => HeapCellValue::Con(c), - HeapCellValue::Lis(a) => HeapCellValue::Lis(a - diff), - HeapCellValue::Ref(Ref::HeapCell(hc)) => - HeapCellValue::Ref(Ref::HeapCell(hc - diff)), - HeapCellValue::Str(s) => HeapCellValue::Str(s - diff), + HeapCellValue::Addr(Addr::Con(c)) => HeapCellValue::Addr(Addr::Con(c)), + HeapCellValue::Addr(Addr::Lis(a)) => HeapCellValue::Addr(Addr::Lis(a - diff)), + HeapCellValue::Addr(Addr::HeapCell(hc)) => + HeapCellValue::Addr(Addr::HeapCell(hc - diff)), + HeapCellValue::Addr(Addr::Str(s)) => HeapCellValue::Addr(Addr::Str(s - diff)), _ => heap_value }); } @@ -1658,7 +1658,7 @@ impl MachineState { let ball = self.heap[h].as_addr(h); - match addr.as_ref() { + match addr.as_var() { Some(r) => { self.bind(r, ball); self.p += 1; @@ -1822,7 +1822,7 @@ impl MachineState { for _ in 0 .. arity { let h = self.heap.h; - self.heap.push(HeapCellValue::Ref(Ref::HeapCell(h))); + self.heap.push(HeapCellValue::Addr(Addr::HeapCell(h))); } self.unify(a1, f_a); diff --git a/src/prolog/macros.rs b/src/prolog/macros.rs index 3ac2f46a..91e0bc23 100644 --- a/src/prolog/macros.rs +++ b/src/prolog/macros.rs @@ -53,7 +53,7 @@ macro_rules! functor { macro_rules! atom { ($name:expr) => ( - HeapCellValue::Con(Constant::Atom(Rc::new(String::from($name)))) + HeapCellValue::Addr(Addr::Con(Constant::Atom(Rc::new(String::from($name))))) ) }