From: Mark Thom Date: Sun, 28 Jan 2018 01:28:20 +0000 (-0700) Subject: fix bug in printer over lists. X-Git-Tag: v0.8.110~598 X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=17d98f3942a8ec31ba4661ba195ffe6ff33b44e4;p=scryer-prolog.git fix bug in printer over lists. --- diff --git a/src/prolog/heap_iter.rs b/src/prolog/heap_iter.rs index ae76ac6d..a2fd7a42 100644 --- a/src/prolog/heap_iter.rs +++ b/src/prolog/heap_iter.rs @@ -5,26 +5,15 @@ use std::vec::Vec; pub struct HeapCellPreOrderIterator<'a> { machine_st : &'a MachineState, - state_stack : Vec + state_stack : Vec } impl<'a> HeapCellPreOrderIterator<'a> { - pub fn new(machine_st: &'a MachineState, r: Ref) -> Self + pub fn new(machine_st: &'a MachineState, a: Addr) -> Self { HeapCellPreOrderIterator { machine_st, - state_stack: vec![r] - } - } - - // called under the assumption that the location at r is about to - // be visited, and so any follow up states need to be added to - // state_stack. returns the dereferenced Addr from Ref. - fn follow(&mut self, r: Ref) -> Addr - { - match r { - Ref::HeapCell(hc) => self.follow_heap(hc), - Ref::StackCell(fr, sc) => self.follow_addr(Addr::StackCell(fr, sc)) + state_stack: vec![a] } } @@ -33,34 +22,35 @@ impl<'a> HeapCellPreOrderIterator<'a> { match &self.machine_st.heap[h] { &HeapCellValue::NamedStr(arity, _, _) => { for idx in (1 .. arity + 1).rev() { - self.state_stack.push(Ref::HeapCell(h + idx)); + self.state_stack.push(Addr::HeapCell(h + idx)); } Addr::HeapCell(h) }, &HeapCellValue::Addr(ref a) => - self.follow_addr(a.clone()) + self.follow(a.clone()) } } - - fn follow_addr(&mut self, addr: Addr) -> Addr + + // called under the assumption that the location at r is about to + // be visited, and so any follow up states need to be added to + // state_stack. returns the dereferenced Addr from Ref. + fn follow(&mut self, addr: Addr) -> Addr { let da = self.machine_st.store(self.machine_st.deref(addr)); match &da { &Addr::Con(_) => da, &Addr::Lis(a) => { - self.state_stack.push(Ref::HeapCell(a + 1)); - self.state_stack.push(Ref::HeapCell(a)); + self.state_stack.push(Addr::HeapCell(a + 1)); + self.state_stack.push(Addr::HeapCell(a)); da }, &Addr::HeapCell(_) | &Addr::StackCell(_, _) => da, - &Addr::Str(s) => { - self.follow_heap(s); // record terms of structure. - Addr::HeapCell(s) - } + &Addr::Str(s) => + self.follow_heap(s) // record terms of structure. } } } @@ -69,8 +59,8 @@ impl<'a> Iterator for HeapCellPreOrderIterator<'a> { type Item = HeapCellValue; fn next(&mut self) -> Option { - if let Some(r) = self.state_stack.pop() { - match self.follow(r) { + if let Some(a) = self.state_stack.pop() { + match self.follow(a) { Addr::HeapCell(h) => Some(self.machine_st.heap[h].clone()), Addr::StackCell(fr, sc) => { let heap_val = HeapCellValue::Addr(self.machine_st.and_stack[fr][sc].clone()); @@ -129,7 +119,7 @@ impl<'a> Iterator for HeapCellPostOrderIterator<'a> { } impl MachineState { - pub fn post_order_iter<'a>(&'a self, r: Ref) -> HeapCellPostOrderIterator<'a> { - HeapCellPostOrderIterator::new(HeapCellPreOrderIterator::new(self, r)) + pub fn post_order_iter<'a>(&'a self, a: Addr) -> HeapCellPostOrderIterator<'a> { + HeapCellPostOrderIterator::new(HeapCellPreOrderIterator::new(self, a)) } } diff --git a/src/prolog/machine/machine_state.rs b/src/prolog/machine/machine_state.rs index bc0b6a89..3222866e 100644 --- a/src/prolog/machine/machine_state.rs +++ b/src/prolog/machine/machine_state.rs @@ -259,31 +259,15 @@ impl MachineState { self.trail(r1); } - fn print_var(&self, r: Ref, fmt: Fmt, output: Outputter) -> Outputter + pub(super) fn print_term(&self, a: Addr, fmt: Fmt, output: Outputter) -> Outputter where Fmt: HeapCellValueFormatter, Outputter: HeapCellValueOutputter { - let iter = HeapCellPreOrderIterator::new(&self, r); + let iter = HeapCellPreOrderIterator::new(&self, a); let printer = HeapCellPrinter::new(iter, fmt, output); printer.print() } - pub(super) fn print_term(&self, addr: &Addr, fmt: Fmt, mut output: Outputter) - -> Outputter - where Fmt: HeapCellValueFormatter, Outputter: HeapCellValueOutputter - { - match addr { - &Addr::Con(ref c) => { - output.append(format!("{}", c).as_str()); - output - }, - &Addr::Lis(h) | &Addr::HeapCell(h) | &Addr::Str(h) => - self.print_var(Ref::HeapCell(h), fmt, output), - &Addr::StackCell(fr, sc) => - self.print_var(Ref::StackCell(fr, sc), fmt, output) - } - } - fn unify(&mut self, a1: Addr, a2: Addr) { let mut pdl = vec![a1, a2]; @@ -508,15 +492,9 @@ impl MachineState { return Ok(n.clone()); } - let r = match a { - Addr::Str(h) | Addr::HeapCell(h) => Ok(Ref::HeapCell(h)), - Addr::StackCell(fr, sc) => Ok(Ref::StackCell(fr, sc)), - _ => Err(instantiation_err.clone()) - }?; - let mut interms: Vec = Vec::with_capacity(64); - for heap_val in self.post_order_iter(r) { + for heap_val in self.post_order_iter(a) { match heap_val { HeapCellValue::NamedStr(2, name, Some(Fixity::In)) => { let a2 = interms.pop().unwrap(); @@ -1641,7 +1619,7 @@ impl MachineState { self.p += 1; }, &ControlInstruction::DisplayCall => { - let output = self.print_term(&self[temp_v!(1)], + let output = self.print_term(self[temp_v!(1)].clone(), DisplayFormatter {}, PrinterOutputter::new()); @@ -1650,7 +1628,7 @@ impl MachineState { self.p += 1; }, &ControlInstruction::DisplayExecute => { - let output = self.print_term(&self[temp_v!(1)], + let output = self.print_term(self[temp_v!(1)].clone(), DisplayFormatter {}, PrinterOutputter::new()); diff --git a/src/prolog/machine/mod.rs b/src/prolog/machine/mod.rs index 8d9e43f0..fe05da8e 100644 --- a/src/prolog/machine/mod.rs +++ b/src/prolog/machine/mod.rs @@ -228,7 +228,7 @@ impl Machine { let h = self.ms.heap.h; self.ms.copy_and_align_ball_to_heap(); - let msg = self.ms.print_term(&Addr::HeapCell(h), + let msg = self.ms.print_term(Addr::HeapCell(h), TermFormatter {}, PrinterOutputter::new()) .result(); @@ -322,7 +322,7 @@ impl Machine { output.append(var.as_str()); output.append(" = "); - output = self.ms.print_term(addr, TermFormatter {}, output); + output = self.ms.print_term(addr.clone(), TermFormatter {}, output); } output diff --git a/src/tests.rs b/src/tests.rs index 0d53753a..b2e80bec 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -588,7 +588,7 @@ fn test_queries_on_conjuctive_queries() { submit(&mut wam, "p(a, [f(g(X))])."); submit(&mut wam, "q(Y, c)."); - assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", [["Y = f(g(_9))", "X = a", "Z = c"]]); + assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", [["Y = [f(g(_9))]", "X = a", "Z = c"]]); assert_prolog_failure!(&mut wam, "?- p(X, Y), q(Y, X)."); submit(&mut wam, "member(X, [X|_]). @@ -620,51 +620,51 @@ fn test_queries_on_conjuctive_queries() { submit(&mut wam, "q(Y, c)."); assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", - [["X = a", "Z = c", "Y = f(g(_9))"], + [["X = a", "Z = c", "Y = [f(g(_9))]"], ["X = _0", "Z = c", "Y = c"]]); assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, Z).", - [["Z = c", "Y = f(g(_9))", "X = a"]]); + [["Z = c", "Y = [f(g(_9))]", "X = a"]]); submit(&mut wam, "q([f(g(x))], Z). q([f(g(y))], Y). q([f(g(z))], a)."); assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", - [["Z = _10", "X = a", "Y = f(g(x))"], - ["Z = _10", "X = a", "Y = f(g(y))"], - ["Z = a", "X = a", "Y = f(g(z))"]]); + [["Z = _10", "X = a", "Y = [f(g(x))]"], + ["Z = _10", "X = a", "Y = [f(g(y))]"], + ["Z = a", "X = a", "Y = [f(g(z))]"]]); assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, Z).", - [["X = a", "Y = f(g(x))", "Z = _10"], - ["X = a", "Y = f(g(y))", "Z = _10"], - ["X = a", "Y = f(g(z))", "Z = a"]]); + [["X = a", "Y = [f(g(x))]", "Z = _10"], + ["X = a", "Y = [f(g(y))]", "Z = _10"], + ["X = a", "Y = [f(g(z))]", "Z = a"]]); assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, X).", - [["X = a", "Y = f(g(x))"], - ["X = a", "Y = f(g(y))"], - ["X = a", "Y = f(g(z))"]]); + [["X = a", "Y = [f(g(x))]"], + ["X = a", "Y = [f(g(y))]"], + ["X = a", "Y = [f(g(z))]"]]); submit(&mut wam, "p(X, [f(g(x))]). p(X, [f(g(y))]). p(X, [f(g(z))])."); assert_prolog_failure!(&mut wam, "?- q(f(X), Y), p(X, Y)."); assert_prolog_success!(&mut wam, "?- q(X, Y), p(X, Y).", - [["Y = [f(g(x))]", "X = f(g(x))"], - ["Y = [f(g(y))]", "X = f(g(x))"], - ["Y = [f(g(z))]", "X = f(g(x))"], - ["Y = [f(g(x))]", "X = f(g(y))"], - ["Y = [f(g(y))]", "X = f(g(y))"], - ["Y = [f(g(z))]", "X = f(g(y))"]]); + [["Y = [f(g(x))]", "X = [f(g(x))]"], + ["Y = [f(g(y))]", "X = [f(g(x))]"], + ["Y = [f(g(z))]", "X = [f(g(x))]"], + ["Y = [f(g(x))]", "X = [f(g(y))]"], + ["Y = [f(g(y))]", "X = [f(g(y))]"], + ["Y = [f(g(z))]", "X = [f(g(y))]"]]); assert_prolog_success!(&mut wam, "?- p(X, Y), q(X, Y).", - [["Y = f(g(x))", "X = [f(g(x))]"], - ["Y = f(g(x))", "X = [f(g(y))]"], - ["Y = f(g(y))", "X = [f(g(x))]"], - ["Y = f(g(y))", "X = [f(g(y))]"], - ["Y = f(g(z))", "X = [f(g(x))]"], - ["Y = f(g(z))", "X = [f(g(y))]"]]); + [["Y = [f(g(x))]", "X = [f(g(x))]"], + ["Y = [f(g(x))]", "X = [f(g(y))]"], + ["Y = [f(g(y))]", "X = [f(g(x))]"], + ["Y = [f(g(y))]", "X = [f(g(y))]"], + ["Y = [f(g(z))]", "X = [f(g(x))]"], + ["Y = [f(g(z))]", "X = [f(g(y))]"]]); assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, X).", - [["Y = f(g(x))", "X = s_0_2"], - ["Y = f(g(y))", "X = s_0_2"], - ["Y = f(g(z))", "X = a"]]); + [["Y = [f(g(x))]", "X = s_0_2"], + ["Y = [f(g(y))]", "X = s_0_2"], + ["Y = [f(g(z))]", "X = a"]]); assert_prolog_success!(&mut wam, "?- q(X, Y), p(Y, X).", - [["Y = s_0_1", "X = f(g(x))"], - ["Y = s_0_1", "X = f(g(y))"], - ["Y = a" , "X = f(g(z))"]]); + [["Y = s_0_1", "X = [f(g(x))]"], + ["Y = s_0_1", "X = [f(g(y))]"], + ["Y = a" , "X = [f(g(z))]"]]); } #[test]