From: Mark Thom <markjordanthom@gmail.com>
Date: Sat, 9 Apr 2022 17:47:54 +0000 (-0600)
Subject: dereference bindings returned by stackful iterator (#1410, #1411)
X-Git-Tag: v0.9.1~67
X-Git-Url: https://git.sagredo.dev/?a=commitdiff_plain;h=ed803d30cd648ac821ab093b50800bf6c7fce51b;p=scryer-prolog.git

dereference bindings returned by stackful iterator (#1410, #1411)
---

diff --git a/src/machine/machine_state_impl.rs b/src/machine/machine_state_impl.rs
index 0822c9da..2686aef4 100644
--- a/src/machine/machine_state_impl.rs
+++ b/src/machine/machine_state_impl.rs
@@ -2047,16 +2047,16 @@ impl MachineState {
     }
 
     #[inline]
-    pub fn is_cyclic_term(&mut self, addr: HeapCellValue) -> bool {
-        if addr.is_constant() {
+    pub fn is_cyclic_term(&mut self, value: HeapCellValue) -> bool {
+        if value.is_constant() {
             return false;
         }
 
-        let addr = self.store(self.deref(addr));
-        let mut iter = stackful_preorder_iter(&mut self.heap, addr);
+        let mut iter = stackful_preorder_iter(&mut self.heap, value);
 
         while let Some(value) = iter.next() {
             if value.get_forwarding_bit() {
+                let value = unmark_cell_bits!(value);
                 let value = heap_bound_store(iter.heap, heap_bound_deref(iter.heap, value));
 
                 if value.is_compound() {
@@ -2514,11 +2514,20 @@ impl MachineState {
             return true;
         }
 
-        for v in stackful_preorder_iter(&mut self.heap, value) {
-            let v = unmark_cell_bits!(v);
+        let mut iter = stackful_preorder_iter(&mut self.heap, value);
 
-            if v.is_var() {
-                return true;
+        while let Some(value) = iter.next() {
+            let value = unmark_cell_bits!(value);
+
+            if value.is_var() {
+                let value = heap_bound_store(
+                    iter.heap,
+                    heap_bound_deref(iter.heap, value),
+                );
+
+                if value.is_var() {
+                    return true;
+                }
             }
         }
 
diff --git a/src/machine/system_calls.rs b/src/machine/system_calls.rs
index 110f55ac..6a572b8f 100644
--- a/src/machine/system_calls.rs
+++ b/src/machine/system_calls.rs
@@ -609,7 +609,7 @@ impl MachineState {
 
                 let value = unmark_cell_bits!(value);
 
-                if value.is_var() && !seen_set.contains(&value) {
+                if value.is_var() {
                     seen_set.insert(value);
                 }
             }
@@ -4902,26 +4902,29 @@ impl Machine {
             return;
         }
 
-        let mut seen_vec = vec![];
+        let mut seen_set = IndexSet::new();
 
         {
             let mut iter = stackful_preorder_iter(&mut self.machine_st.heap, stored_v);
 
-            while let Some(addr) = iter.next() {
-                let addr = unmark_cell_bits!(addr);
+            while let Some(value) = iter.next() {
+                let value = unmark_cell_bits!(value);
+
+                if value.is_var() {
+                    let value = heap_bound_store(
+                        iter.heap,
+                        heap_bound_deref(iter.heap, value)
+                    );
 
-                if addr.is_var() {
-                    seen_vec.push(addr);
+                    if value.is_var() {
+                        seen_set.insert(value);
+                    }
                 }
             }
         }
 
-        seen_vec.dedup_by(|v1, v2| {
-            compare_term_test!(self.machine_st, *v1, *v2) == Some(std::cmp::Ordering::Equal)
-        });
-
         let outcome = heap_loc_as_cell!(
-            iter_to_heap_list(&mut self.machine_st.heap, seen_vec.into_iter())
+            iter_to_heap_list(&mut self.machine_st.heap, seen_set.into_iter())
         );
 
         unify_fn!(self.machine_st, a2, outcome);