set up heap_var Cow in heap_print.rs

diff --git a/src/prolog/heap_iter.rs b/src/prolog/heap_iter.rs
index 367daace0773aee1a956296633afe84d07300467..33b552aa250b8c69053419fd747c2fcc25756d64 100644 (file)
--- a/src/prolog/heap_iter.rs
+++ b/src/prolog/heap_iter.rs
@@ -120,7 +120,7 @@ impl MachineState {
     pub fn pre_order_iter<'a>(&'a self, a: Addr) -> HCPreOrderIterator<'a> {
         HCPreOrderIterator::new(self, a)
     }
-    
+
     pub fn post_order_iter<'a>(&'a self, a: Addr) -> HCPostOrderIterator<'a> {
         HCPostOrderIterator::new(HCPreOrderIterator::new(self, a))
     }
@@ -179,6 +179,37 @@ where HCIter: Iterator<Item=HeapCellValue> + MutStackHCIterator
     }
 }
 
+pub struct HCDerefAcyclicIterator<HCIter> {
+    iter: HCIter,
+    seen: HashSet<Addr>
+}
+
+impl<HCIter: MutStackHCIterator> HCDerefAcyclicIterator<HCIter>
+{
+    pub fn new(iter: HCIter) -> Self {
+        HCDerefAcyclicIterator { iter, seen: HashSet::new() }
+    }
+}
+
+impl<HCIter> Iterator for HCDerefAcyclicIterator<HCIter>
+   where HCIter: Iterator<Item=HeapCellValue> + MutStackHCIterator
+{
+    type Item = HeapCellValue;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.iter.next() {
+                Some(HeapCellValue::Addr(addr)) =>
+                    if !self.seen.contains(&addr) {
+                        self.seen.insert(addr.clone());
+                        return Some(HeapCellValue::Addr(addr));
+                    },
+                item => return item
+            }
+        }
+    }
+}
+
 pub struct HCZippedAcyclicIterator<HCIter> {
     i1: HCIter,
     i2: HCIter,

diff --git a/src/prolog/heap_print.rs b/src/prolog/heap_print.rs
index f901a5e418666170411196c99f91a664bd126971..cb8d7bd6a98564becb8fbf375bdd12adbb049898 100644 (file)
--- a/src/prolog/heap_print.rs
+++ b/src/prolog/heap_print.rs
@@ -1,6 +1,7 @@
 use prolog::ast::*;
 use prolog::heap_iter::*;
 
+use std::borrow::Cow;
 use std::cell::Cell;
 use std::rc::Rc;
 
@@ -143,18 +144,33 @@ pub struct HCPrinter<'a, Formatter, Outputter> {
     formatter:   Formatter,
     outputter:   Outputter,
     iter:        HCPreOrderIterator<'a>,
-    state_stack: Vec<TokenOrRedirect>
+    state_stack: Vec<TokenOrRedirect>,
+    heap_locs:   Cow<'a, HeapVarDict>
 }
 
 impl<'a, Formatter: HCValueFormatter, Outputter: HCValueOutputter>
     HCPrinter<'a, Formatter, Outputter>
 {
-    pub fn new(iter: HCPreOrderIterator<'a>, formatter: Formatter, outputter: Outputter)
-               -> Self
+    pub fn new(iter: HCPreOrderIterator<'a>, fmt: Formatter, output: Outputter) -> Self
     {
-        HCPrinter { formatter, outputter, iter, state_stack: vec![] }
+        HCPrinter { formatter: fmt,
+                    outputter: output,
+                    iter,
+                    state_stack: vec![],
+                    heap_locs: Cow::default() }
     }
 
+    pub fn from_heap_locs(iter: HCPreOrderIterator<'a>, fmt: Formatter,
+                          output: Outputter, heap_locs: &'a HeapVarDict)
+                          -> Self
+    {
+        HCPrinter { formatter: fmt,
+                    outputter: output,
+                    iter,
+                    state_stack: vec![],
+                    heap_locs: Cow::Borrowed(heap_locs) }
+    }
+    
     fn handle_heap_term(&mut self, heap_val: HeapCellValue) {
         match heap_val {
             HeapCellValue::NamedStr(arity, name, fixity) => {