fix functor! size calculations around indexing_code_ptr

src/functor_macro.rs

@@ -61,10 +61,17 @@ macro_rules! build_functor {
      [$($res:expr),*],
      $res_len:expr,
      [$($subfunctor:expr),*]) => ({
+        let (inner_functor, cell_size) = indexing_code_ptr($e);
+        let referent = if cell_size == 1 {
+            heap_loc_as_cell!(1u64 + count!($($dt)*) + $res_len)
+        } else {
+            str_loc_as_cell!(1u64 + count!($($dt)*) + $res_len)
+        };
+
         build_functor!([$($dt($($value),*)),*],
-                       [$($res, )* FunctorElement::Cell(str_loc_as_cell!(1u64 + count!($($dt)*) + $res_len))],
+                       [$($res, )* FunctorElement::Cell(referent)],
-                       3 + $res_len,
+                       1 + cell_size + $res_len,
-                       [$($subfunctor, )* FunctorElement::InnerFunctor(2, indexing_code_ptr($e))])
+                       [$($subfunctor, )* FunctorElement::InnerFunctor(cell_size, inner_functor)])
     });
     ([fixnum($e:expr) $(, $dt:ident($($value:tt),*))*],
      [$($res:expr),*],
@@ -171,20 +178,14 @@ macro_rules! build_functor {
     });
 }
 
-pub(crate) fn indexing_code_ptr(code_ptr: IndexingCodePtr) -> Vec<FunctorElement> {
+pub(crate) fn indexing_code_ptr(code_ptr: IndexingCodePtr) -> (Vec<FunctorElement>, u64) {
     match code_ptr {
         IndexingCodePtr::DynamicExternal(o) => {
-            functor!(atom!("dynamic_external"), [fixnum(o)])
+            (functor!(atom!("dynamic_external"), [fixnum(o)]), 2)
-        }
-        IndexingCodePtr::External(o) => {
-            functor!(atom!("external"), [fixnum(o)])
-        }
-        IndexingCodePtr::Internal(o) => {
-            functor!(atom!("internal"), [fixnum(o)])
-        }
-        IndexingCodePtr::Fail => {
-            vec![FunctorElement::Cell(atom_as_cell!(atom!("fail")))]
         }
+        IndexingCodePtr::External(o) => (functor!(atom!("external"), [fixnum(o)]), 2),
+        IndexingCodePtr::Internal(o) => (functor!(atom!("internal"), [fixnum(o)]), 2),
+        IndexingCodePtr::Fail => (vec![FunctorElement::Cell(atom_as_cell!(atom!("fail")))], 1),
     }
 }
 

src/machine/dispatch.rs

@@ -242,7 +242,6 @@ impl MachineState {
                 c
             }
             (HeapCellValueTag::Atom, (_name, arity)) => {
-                // if arity == 0 { c } else { s }
                 debug_assert!(arity == 0);
                 c
             }

src/machine/heap.rs

@@ -1092,7 +1092,7 @@ pub fn heap_bound_store(heap: &impl SizedHeap, value: HeapCellValue) -> HeapCell
 }
 
 #[allow(dead_code)]
-pub fn print_heap_terms(heap: &Heap, h: usize) {
+pub fn print_heap_terms(heap: &impl SizedHeap, h: usize) {
     for idx in 0..heap.cell_len() {
         let term = heap[idx];
         println!("{} : {:?}", h + idx, term);

src/machine/system_calls.rs

@@ -7307,20 +7307,19 @@ impl Machine {
         walk_code(&self.code, index_ptr, |instr| {
             let old_len = functors.len();
             instr.enqueue_functors(&mut self.machine_st.arena, &mut functors);
-            let new_len = functors.len();
 
-            for index in old_len..new_len {
+            for functor in &functors[old_len..] {
-                let functor_len = functors[index].len();
+                let functor_len = functor.len();
 
                 match functor_len {
                     0 => {}
                     1 => {
                         functor_list.push(heap_loc_as_cell!(h));
-                        h += cell_index!(Heap::compute_functor_byte_size(&functors[index]));
+                        h += cell_index!(Heap::compute_functor_byte_size(functor));
                     }
                     _ => {
                         functor_list.push(str_loc_as_cell!(h));
-                        h += cell_index!(Heap::compute_functor_byte_size(&functors[index]));
+                        h += cell_index!(Heap::compute_functor_byte_size(functor));
                     }
                 };
             }