ska: working nouncode rust interpreter with @uxor

Author: matthew-levan

hoon/codegen/sur/gene.hoon

@@ -148,8 +148,6 @@
 ::  t - target block
 ::  u - subject
 ::  v - subject but registerized
-::  w - walt
-::  x - sans
 ::  z - "zero" / true case
 ::
 ::  cases:

rust/ares/bin/cg.jam

@@ -5,7 +5,8 @@ use crate::jets::seam::util::get_by;
 use crate::jets::util::slot;
 use crate::jets::{Jet, JetErr::*};
 use crate::mem::{NockStack, Preserve};
-use crate::noun::{slot_pam, DirectAtom, Noun, D, NOUN_NONE, T};
+use crate::mug::mug_u32;
+use crate::noun::{slot_bar, slot_pam, DirectAtom, Noun, D, NOUN_NONE, T};
 use crate::unifying_equality::unifying_equality;
 use ares_macros::tas;
 use either::{Left, Right};
@@ -82,14 +83,14 @@ pub struct Pile {
 
 impl Pile {
     pub fn new(context: &mut Context, pile: Noun) -> Self {
-        let well = slot(pile, slot_pam(5))
+        let well = slot(pile, slot_pam(3))
             .unwrap()
             .as_atom()
             .unwrap()
             .as_u64()
             .unwrap() as usize;
         Self {
-            sans: slot(pile, slot_pam(3))
+            sans: slot(pile, slot_pam(1))
                 .unwrap()
                 .as_atom()
                 .unwrap()
@@ -114,28 +115,20 @@ impl Preserve for Pile {
     }
 }
 
-// +$  pile
-//   $:  =bell
-//       walt=(list @uvre)
-//       sans=$~(0v1 @uvre)  :: 0v0 reserved for indirect
-//       will=(map @uwoo blob)
-//       well=$~(0w2 @uwoo)  :: 0w0 indirect, 0w1 direct
-//   ==
-// hill=(map @uxor pile)
-
 #[derive(Copy, Clone)]
 pub struct Hill {
     pub lent: usize,
     pub data: *mut Pile,
 }
 
 impl Hill {
-    /// Transforms the $hill from the `CgContext` into a `Hill` structure and
+    /// Transforms the $hill from the `CgContext.fuji` into a `Hill` structure and
     /// allocates it on the NockStack.
     fn new(context: &mut Context) -> Self {
         let stack = &mut context.stack;
         let fuji = context.cg_context.fuji;
-        let well = slot(fuji, slot_pam(5)) // total number of blocks
+        let mut hill = slot(fuji, slot_pam(2)).expect("Codegen fuji should have hill");
+        let next = slot(fuji, slot_pam(3)) // total number of piles
             .expect("Codegen fuji should have next")
             .as_atom()
             .unwrap()
@@ -144,24 +137,23 @@ impl Hill {
         unsafe {
             let hill_p = stack.struct_alloc::<Hill>(1);
             *hill_p = Hill {
-                data: stack.struct_alloc::<Pile>(well),
-                lent: well,
+                data: stack.struct_alloc::<Pile>(next),
+                lent: next,
             };
-            let piles: &mut [Pile] = from_raw_parts_mut((*hill_p).data, well);
-            let mut hill = slot(fuji, slot_pam(2)).expect("Codegen fuji should have hill");
+            let pils: &mut [Pile] = from_raw_parts_mut((*hill_p).data, next);
             let mut i = 0;
-            while i < well {
+            while i < next {
                 // XX walk tree manually
                 let piln = get_by(&mut context.stack, &mut hill, &mut D(i as u64))
                     .unwrap()
                     .unwrap();
                 let pile = Pile::new(context, piln);
-                piles[i] = pile;
+                pils[i] = pile;
                 i += 1;
             }
             Self {
-                data: piles.as_mut_ptr(),
-                lent: well,
+                data: pils.as_mut_ptr(),
+                lent: next,
             }
         }
     }
@@ -170,21 +162,26 @@ impl Hill {
         unsafe { from_raw_parts(self.data as *const Pile, self.lent) }
     }
 
-    fn _as_mut_slice<'a>(&mut self) -> &'a mut [Pile] {
+    fn as_mut_slice<'a>(&mut self) -> &'a mut [Pile] {
         unsafe { from_raw_parts_mut(self.data as *mut Pile, self.lent) }
     }
 }
 
 impl Preserve for Hill {
     unsafe fn preserve(&mut self, stack: &mut NockStack) {
+        // if stack.is_in_frame(self as *const Hill) {
         let dest: *mut Hill = stack.struct_alloc_in_previous_frame(1);
-        copy_nonoverlapping(self as *mut Hill, dest, 1);
+        (*dest).data = stack.struct_alloc_in_previous_frame::<Pile>(self.lent);
+        (*dest).lent = self.lent;
+        copy_nonoverlapping::<Pile>(self.data, (*dest).data, self.lent);
         let mut i = 0;
         while i < self.lent {
-            let pile = (self.data as *mut Pile).add(i).as_mut().unwrap();
+            let pile = ((*dest).data as *mut Pile).add(i).as_mut().unwrap();
             stack.preserve(pile);
             i += 1;
         }
+        (*self) = *dest;
+        // }
     }
 
     unsafe fn assert_in_stack(&self, stack: &NockStack) {
@@ -208,7 +205,7 @@ pub struct Blocks {
 }
 
 impl Blocks {
-    /// Transforms the $hill from the `CgContext` into a `Blocks` structure and
+    /// Transforms the $will into a `Blocks` structure and
     /// allocates it on the NockStack.
     fn new(context: &mut Context, will: &mut Noun, well: usize) -> Self {
         let stack = &mut context.stack;
@@ -239,21 +236,26 @@ impl Blocks {
         unsafe { from_raw_parts(self.data as *const Noun, self.lent) }
     }
 
-    fn _as_mut_slice<'a>(&mut self) -> &'a mut [Noun] {
+    fn as_mut_slice<'a>(&mut self) -> &'a mut [Noun] {
         unsafe { from_raw_parts_mut(self.data as *mut Noun, self.lent) }
     }
 }
 
 impl Preserve for Blocks {
     unsafe fn preserve(&mut self, stack: &mut NockStack) {
+        // if stack.is_in_frame(self as *const Blocks) {
         let dest: *mut Blocks = stack.struct_alloc_in_previous_frame(1);
-        copy_nonoverlapping(self as *mut Blocks, dest, 1);
+        (*dest).data = stack.struct_alloc_in_previous_frame::<Noun>(self.lent);
+        (*dest).lent = self.lent;
+        copy_nonoverlapping::<Noun>(self.data, (*dest).data, self.lent);
         let mut i = 0;
         while i < self.lent {
-            let block = (self.data as *mut Noun).add(i).as_mut().unwrap();
-            stack.preserve(block);
+            let blob = ((*dest).data as *mut Noun).add(i).as_mut().unwrap();
+            stack.preserve(blob);
             i += 1;
         }
+        (*self) = *dest;
+        // }
     }
 
     unsafe fn assert_in_stack(&self, stack: &NockStack) {
@@ -779,7 +781,6 @@ pub fn cg_interpret_with_snapshot(
                 }
                 tas!(b"jmp") => {
                     // [%jmp a=@uxor v=(list @uvre)]
-                    eprintln!("jmp : {}", inst_cell);
                     let t_jmp = inst_cell.tail().as_cell().unwrap();
 
                     let jmp_a = t_jmp.head().as_atom().unwrap().as_u64().unwrap() as usize;

rust/ares/src/codegen.rs

@@ -1,8 +1,8 @@
 use crate::jets::util::slot;
 use crate::mem::NockStack;
+use crate::mug::mug_u32;
 use crate::noun::{Noun, D};
 use crate::serialization::cue_bytes;
-use crate::mug::mug_u32;
 use ares_macros::tas;
 use std::include_bytes;
 
@@ -11,7 +11,7 @@ pub fn load_cg(stack: &mut NockStack) -> (Noun, Noun) {
     let cg_bytes = include_bytes!("../bin/cg.jam");
     let cg_noun = cue_bytes(stack, cg_bytes);
     let cg_mug = mug_u32(stack, cg_noun);
-    eprintln!("codegen mug: {:x}", cg_mug);
+    // eprintln!("codegen mug: {:x}", cg_mug);
     assert!(unsafe { slot(cg_noun, 2).unwrap().raw_equals(D(tas!(b"cg"))) });
     (slot(cg_noun, 6).unwrap(), slot(cg_noun, 7).unwrap())
 }

rust/ares/src/load.rs

@@ -1,4 +1,4 @@
-use crate::codegen::{self, cg_interpret, Blocks, Hill, Pile};
+use crate::codegen::{self, cg_interpret, Hill, Pile};
 use crate::hamt::Hamt;
 use crate::interpreter::{inc, interpret, Error, Mote, WhichInterpreter};
 use crate::jets::cold::Cold;
@@ -88,6 +88,8 @@ struct SnapshotMem {
     pub arvo: Noun,
     pub cold: Cold,
     pub line: Noun,
+    pub fuji: Noun,
+    pub hill: Hill,
 }
 
 const PMA_CURRENT_SNAPSHOT_VERSION: u64 = 1;
@@ -132,6 +134,8 @@ impl Context {
                 (*snapshot_mem_ptr).arvo = self.arvo;
                 (*snapshot_mem_ptr).cold = self.nock_context.cold;
                 (*snapshot_mem_ptr).line = self.nock_context.cg_context.line;
+                // (*snapshot_mem_ptr).fuji = self.nock_context.cg_context.fuji;
+                // (*snapshot_mem_ptr).hill = self.nock_context.cg_context.hill;
                 snapshot_mem_ptr
             });
 
@@ -142,6 +146,8 @@ impl Context {
             self.event_num = (*snapshot.0).event_num;
             self.nock_context.cold = (*snapshot.0).cold;
             self.nock_context.cg_context.line = (*snapshot.0).line;
+            // self.nock_context.cg_context.fuji = (*snapshot.0).fuji;
+            // self.nock_context.cg_context.hill = (*snapshot.0).hill;
 
             handle
         };
@@ -247,6 +253,8 @@ impl Context {
     /// [event_update] and invocation of this function
     pub unsafe fn preserve_event_update_leftovers(&mut self) {
         let stack = &mut self.nock_context.stack;
+        stack.preserve(&mut self.nock_context.cg_context.fuji);
+        stack.preserve(&mut self.nock_context.cg_context.hill);
         stack.preserve(&mut self.nock_context.warm);
         stack.preserve(&mut self.nock_context.hot);
         stack.flip_top_frame(0);