fix bug in printer over lists.

diff --git a/src/prolog/heap_iter.rs b/src/prolog/heap_iter.rs
index ae76ac6d78ad5dba5a8867a95db3c38002d1b880..a2fd7a428533fe0934038b47f2242d9077afa5c4 100644 (file)
--- 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<Ref>
+    state_stack : Vec<Addr>
 }
 
 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<Self::Item> {
-        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 bc0b6a8944e5f22cea2533db5dfee1742f74d9f9..3222866efbb048b6a9b4ed4cdf76b2461256780c 100644 (file)
--- 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<Fmt, Outputter>(&self, r: Ref, fmt: Fmt, output: Outputter) -> Outputter
+    pub(super) fn print_term<Fmt, Outputter>(&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<Fmt, Outputter>(&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<Number> = 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 8d9e43f0b3b98ddb2561a9217e0344e33389ed1d..fe05da8e0da746497d61bf139659c8058c842de3 100644 (file)
--- 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 0d53753aa7f01867686103d7efe32baa554cdc5d..b2e80bec8bce24bf844532b7a427d98e6f9bf854 100644 (file)
--- 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]