From 063f0da565c71af47f12345264050073e83b48af Mon Sep 17 00:00:00 2001
From: Mark Thom <markjordanthom@gmail.com>
Date: Sun, 20 Feb 2022 23:44:18 -0700
Subject: [PATCH] correct '$skip_max_list/4' for non-lists (#1276)

---
 src/machine/machine_errors.rs | 10 +++++-----
 src/machine/system_calls.rs   | 29 +++++++++++++----------------
 2 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/src/machine/machine_errors.rs b/src/machine/machine_errors.rs
index 718a57b4..889eb7ee 100644
--- a/src/machine/machine_errors.rs
+++ b/src/machine/machine_errors.rs
@@ -771,7 +771,7 @@ impl EvalError {
 pub enum CycleSearchResult {
     Cyclic(usize),
     EmptyList,
-    NotList,
+    NotList(usize, HeapCellValue), // the list length until the second argument in the heap
     PartialList(usize, Ref), // the list length (up to max), and an offset into the heap.
     ProperList(usize),       // the list length.
     PStrLocation(usize, usize), // list length (up to max), the heap address of the PStrOffset
@@ -792,7 +792,7 @@ impl MachineState {
                 let err = self.instantiation_error();
                 return Err(self.error_form(err, stub_gen()))
             }
-            CycleSearchResult::NotList => {
+            CycleSearchResult::NotList(..) => {
                 let err = self.type_error(ValidType::List, list);
                 return Err(self.error_form(err, stub_gen()));
             }
@@ -800,7 +800,7 @@ impl MachineState {
         };
 
         match BrentAlgState::detect_cycles(&self.heap, sorted) {
-            CycleSearchResult::NotList if !sorted.is_var() => {
+            CycleSearchResult::NotList(..) if !sorted.is_var() => {
                 let err = self.type_error(ValidType::List, sorted);
                 Err(self.error_form(err, stub_gen()))
             }
@@ -812,7 +812,7 @@ impl MachineState {
         let stub_gen = || functor_stub(atom!("keysort"), 2);
 
         match BrentAlgState::detect_cycles(&self.heap, list) {
-            CycleSearchResult::NotList if !list.is_var() => {
+            CycleSearchResult::NotList(..) if !list.is_var() => {
                 let err = self.type_error(ValidType::List, list);
                 Err(self.error_form(err, stub_gen()))
             }
@@ -878,7 +878,7 @@ impl MachineState {
                 let err = self.instantiation_error();
                 Err(self.error_form(err, stub_gen()))
             }
-            CycleSearchResult::NotList => {
+            CycleSearchResult::NotList(..) => {
                 let err = self.type_error(ValidType::List, pairs);
                 Err(self.error_form(err, stub_gen()))
             }
diff --git a/src/machine/system_calls.rs b/src/machine/system_calls.rs
index 647d4d14..314a35d4 100644
--- a/src/machine/system_calls.rs
+++ b/src/machine/system_calls.rs
@@ -164,14 +164,14 @@ impl BrentAlgState {
                 return if name == atom!("[]") && arity == 0 {
                     CycleSearchResult::ProperList(self.num_steps())
                 } else {
-                    CycleSearchResult::NotList
+                    CycleSearchResult::NotList(self.num_steps(), heap[self.hare])
                 };
             }
             (HeapCellValueTag::Lis, l) => {
                 return CycleSearchResult::UntouchedList(self.num_steps(), l);
             }
             _ => {
-                return CycleSearchResult::NotList;
+                return CycleSearchResult::NotList(self.num_steps(), heap[self.hare]);
             }
         );
     }
@@ -231,7 +231,7 @@ impl BrentAlgState {
                     return if name == atom!(".") && arity == 2 {
                         self.step(s+2)
                     } else {
-                        Some(CycleSearchResult::NotList)
+                        Some(CycleSearchResult::NotList(self.num_steps(), value))
                     };
                 }
                 (HeapCellValueTag::Atom, (name, arity)) => {
@@ -240,7 +240,7 @@ impl BrentAlgState {
                     return if name == atom!("[]") {
                         Some(CycleSearchResult::ProperList(self.num_steps()))
                     } else {
-                        Some(CycleSearchResult::NotList)
+                        Some(CycleSearchResult::NotList(self.num_steps(), value))
                     };
                 }
                 (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
@@ -252,7 +252,7 @@ impl BrentAlgState {
                     self.hare = h;
                 }
                 _ => {
-                    return Some(CycleSearchResult::NotList);
+                    return Some(CycleSearchResult::NotList(self.num_steps(), value));
                 }
             );
         }
@@ -298,21 +298,21 @@ impl BrentAlgState {
                 } else if name == atom!(".") && arity == 2 {
                     s + 2
                 } else {
-                    return CycleSearchResult::NotList;
+                    return CycleSearchResult::NotList(0, value);
                 }
             }
             (HeapCellValueTag::Atom, (name, arity)) => {
                 return if name == atom!("[]") && arity == 0 {
                     CycleSearchResult::EmptyList
                 } else {
-                    CycleSearchResult::NotList
+                    CycleSearchResult::NotList(0, value)
                 };
             }
             (HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar | HeapCellValueTag::Var) => {
                 return CycleSearchResult::PartialList(0, value.as_var().unwrap());
             }
             _ => {
-                return CycleSearchResult::NotList;
+                return CycleSearchResult::NotList(0, value);
             }
         );
 
@@ -397,21 +397,21 @@ impl BrentAlgState {
                         return CycleSearchResult::UntouchedList(0, s + 1);
                     }
                 } else {
-                    return CycleSearchResult::NotList;
+                    return CycleSearchResult::NotList(0, value);
                 }
             }
             (HeapCellValueTag::Atom, (name, arity)) => {
                 return if name == atom!("[]") && arity == 0 {
                     CycleSearchResult::EmptyList
                 } else {
-                    CycleSearchResult::NotList
+                    CycleSearchResult::NotList(0, value)
                 };
             }
             (HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar | HeapCellValueTag::Var) => {
                 return CycleSearchResult::PartialList(0, value.as_var().unwrap());
             }
             _ => {
-                return CycleSearchResult::NotList;
+                return CycleSearchResult::NotList(0, value);
             }
         );
 
@@ -540,11 +540,8 @@ impl MachineState {
             CycleSearchResult::ProperList(steps) => {
                 self.finalize_skip_max_list(steps as i64, empty_list_as_cell!())
             }
-            CycleSearchResult::NotList => {
-                let n = self.store(self.deref(self.registers[2]));
-
-                self.unify_fixnum(Fixnum::build_with(max_steps), n);
-                self.finalize_skip_max_list(max_steps, self.registers[3]);
+            CycleSearchResult::NotList(n, value) => {
+                self.finalize_skip_max_list(n as i64, value);
             }
             CycleSearchResult::Cyclic(lam) => {
                 self.skip_max_list_cycle(lam);
-- 
2.54.0