fix toplevel heap view

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "scryer-prolog"
-version = "0.8.15"
+version = "0.8.16"
 authors = ["Mark Thom <markjordanthom@gmail.com>"]
 repository = "https://github.com/mthom/scryer-prolog"
 description = "A modern Prolog implementation written mostly in Rust."

src/prolog/machine/mod.rs

@@ -249,17 +249,7 @@ impl Machine {
 
         Ok(())
     }
-    
+        
-    pub fn remove_unbound_vars(&self, orig_heap_locs: &HeapVarDict, heap_locs: &mut HeapVarDict) {
-        for (var, addr) in orig_heap_locs.iter() {
-            match self.machine_st.store(self.machine_st.deref(addr.clone())) {
-                new_addr => if new_addr.is_ref() {
-                    heap_locs.remove(var);
-                }
-            }
-        }
-    }
-    
     pub fn add_batched_code(&mut self, code: Code, code_dir: CodeDir)
     {
         // error detection has finished, so update the master index of keys.
@@ -422,7 +412,27 @@ impl Machine {
         }
     }
 
-    pub fn heap_view<Outputter>(&self, var_dir: &HeapVarDict, mut output: Outputter) -> Outputter
+    pub fn toplevel_heap_view<Outputter>(&self, var_dir: &HeapVarDict, mut output: Outputter) -> Outputter
+       where Outputter: HCValueOutputter
+    {
+        let mut sorted_vars: Vec<(&Rc<Var>, &Addr)> = var_dir.iter().collect();
+        sorted_vars.sort_by_key(|ref v| v.0);
+
+        for (var, addr) in sorted_vars {
+            let addr = self.machine_st.store(self.machine_st.deref(addr.clone()));
+
+            if addr.is_ref() {
+                continue;
+            }
+            
+            output = self.machine_st.print_var_eq(var.clone(), addr, var_dir, output);
+        }
+
+        output
+    }
+
+    #[cfg(test)]
+    pub fn test_heap_view<Outputter>(&self, var_dir: &HeapVarDict, mut output: Outputter) -> Outputter
        where Outputter: HCValueOutputter
     {
         let mut sorted_vars: Vec<(&Rc<Var>, &Addr)> = var_dir.iter().collect();

src/prolog/write.rs

@@ -371,15 +371,11 @@ fn next_step(mut stdout: RawTerminal<std::io::Stdout>) -> ContinueResult
 
 pub fn print(wam: &mut Machine, result: EvalSession) {
     match result {
-        EvalSession::InitialQuerySuccess(alloc_locs, mut heap_locs) => {
+        EvalSession::InitialQuerySuccess(alloc_locs, mut heap_locs) =>
-            let orig_heap_locs = heap_locs.clone();
-
             loop {
-                wam.remove_unbound_vars(&orig_heap_locs, &mut heap_locs);
-
                 if wam.or_stack_is_empty() {
                     if heap_locs.is_empty() {
-                        let attr_goals = wam.attribute_goals(&orig_heap_locs);
+                        let attr_goals = wam.attribute_goals(&heap_locs);
 
                         if !attr_goals.is_empty() {
                             println!("{}.", attr_goals);
@@ -389,29 +385,30 @@ pub fn print(wam: &mut Machine, result: EvalSession) {
 
                         return;
                     }
-                } else if heap_locs.is_empty() && orig_heap_locs.is_empty() {
+                } else if heap_locs.is_empty() {
                     print!("true");
                     stdout().flush().unwrap();
                 }
 
                 let mut raw_stdout = stdout().into_raw_mode().unwrap();
 
-                if !heap_locs.is_empty() {
+                let bindings = if !heap_locs.is_empty() {
                     let mut output = PrinterOutputter::new();
-                    let bindings = wam.heap_view(&heap_locs, output).result();
+                    wam.toplevel_heap_view(&heap_locs, output).result()
+                } else {
+                    "".to_string()
+                };
 
-                    write!(raw_stdout, "{}", bindings).unwrap();
+                let attr_goals = wam.attribute_goals(&heap_locs);
-                    raw_stdout.flush().unwrap();
-                }
-
-                let attr_goals = wam.attribute_goals(&orig_heap_locs);
 
                 if !attr_goals.is_empty() {
-                    if heap_locs.is_empty() {
+                    if bindings.is_empty() {
                         write!(raw_stdout, "{}", attr_goals).unwrap();
                     } else {
-                        write!(raw_stdout, ", {}", attr_goals).unwrap();
+                        write!(raw_stdout, "{}, {}", bindings, attr_goals).unwrap();
                     }
+                } else {
+                    write!(raw_stdout, "{}", bindings).unwrap();
                 }
 
                 if !wam.or_stack_is_empty() {
@@ -440,7 +437,7 @@ pub fn print(wam: &mut Machine, result: EvalSession) {
                         return;
                     }
                 } else {
-                    if heap_locs.is_empty() && attr_goals.is_empty() {
+                    if bindings.is_empty() && attr_goals.is_empty() {
                         write!(raw_stdout, "true.\r\n").unwrap();
                     } else {
                         write!(raw_stdout, ".\r\n").unwrap();
@@ -448,8 +445,7 @@ pub fn print(wam: &mut Machine, result: EvalSession) {
 
                     break;
                 }
-            }
+            },        
-        },
         EvalSession::Error(e) => println!("{}", e),
         _ => {}
     };

src/tests.rs

@@ -86,12 +86,12 @@ pub fn collect_test_output(wam: &mut Machine, alloc_locs: AllocVarDict, mut heap
 {
     let mut output = TestOutputter::new();
 
-    output = wam.heap_view(&heap_locs, output);
+    output = wam.test_heap_view(&heap_locs, output);
     output.cache();
 
     while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
     {
-        output = wam.heap_view(&heap_locs, output);
+        output = wam.test_heap_view(&heap_locs, output);
         output.cache();
     }
 
@@ -104,7 +104,7 @@ pub fn collect_test_output_with_limit(wam: &mut Machine, alloc_locs: AllocVarDic
 {
     let mut output = TestOutputter::new();
 
-    output = wam.heap_view(&heap_locs, output);
+    output = wam.test_heap_view(&heap_locs, output);
     output.cache();
 
     let mut count  = 1;
@@ -115,7 +115,7 @@ pub fn collect_test_output_with_limit(wam: &mut Machine, alloc_locs: AllocVarDic
 
     while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
     {
-        output = wam.heap_view(&heap_locs, output);
+        output = wam.test_heap_view(&heap_locs, output);
         output.cache();
 
         count += 1;