[ares] rustfmt

rust/ares/src/interpreter.rs

@@ -309,8 +309,10 @@ pub fn interpret(
                 Nock11ComputeHint => {
                     let hint = *stack.local_noun_pointer(1);
                     if let Ok(hint_cell) = hint.as_cell() {
-                    let formula = *stack.local_noun_pointer(2);
-                    if let Ok(found) = match_pre_hint(stack, newt, subject, hint_cell, formula, &cache) {
+                        let formula = *stack.local_noun_pointer(2);
+                        if let Ok(found) =
+                            match_pre_hint(stack, newt, subject, hint_cell, formula, &cache)
+                        {
                             res = found;
                             stack.preserve(&mut cache);
                             stack.preserve(&mut res);
@@ -344,7 +346,8 @@ pub fn interpret(
                     stack.pop();
                 }
             };
-    }});
+        }
+    });
     res
 }
 

rust/ares/src/lib.rs

@@ -10,9 +10,9 @@ pub mod newt;
 pub mod noun;
 pub mod serf;
 //pub mod bytecode;
+pub mod hamt;
 pub mod serialization;
 pub mod snapshot;
-pub mod hamt;
 
 /** Introduce useful functions for debugging
  *
@@ -36,9 +36,9 @@ macro_rules! gdb {
     };
 }
 
-#[cfg(debug_assertions)]
-#[global_allocator]
-static A: assert_no_alloc::AllocDisabler = assert_no_alloc::AllocDisabler;
+// #[cfg(debug_assertions)]
+// #[global_allocator]
+// static A: assert_no_alloc::AllocDisabler = assert_no_alloc::AllocDisabler;
 
 pub(crate) use gdb;
 

rust/ares/src/mem.rs

@@ -116,12 +116,8 @@ impl NockStack {
     pub fn in_frame<T>(&self, ptr: *const T) -> bool {
         let ptr_u64 = ptr as *const u64;
         match &self.polarity {
-            Polarity::East => {
-                ptr_u64 >= self.stack_pointer && ptr_u64 < self.frame_pointer
-            },
-            Polarity::West => {
-                ptr_u64 >= self.frame_pointer && ptr_u64 < self.stack_pointer
-            },
+            Polarity::East => ptr_u64 >= self.stack_pointer && ptr_u64 < self.frame_pointer,
+            Polarity::West => ptr_u64 >= self.frame_pointer && ptr_u64 < self.stack_pointer,
         }
     }
 
@@ -250,14 +246,16 @@ impl NockStack {
         let prev_stack_pointer_pointer = self.previous_stack_pointer_pointer_east();
         // note that the allocation is on the west frame, and thus resembles raw_alloc_west
         let alloc = *(prev_stack_pointer_pointer);
-        *prev_stack_pointer_pointer = (*prev_stack_pointer_pointer).add(word_size_of::<T>() * count);
+        *prev_stack_pointer_pointer =
+            (*prev_stack_pointer_pointer).add(word_size_of::<T>() * count);
         alloc as *mut T
     }
 
     unsafe fn struct_alloc_in_previous_frame_west<T>(&mut self, count: usize) -> *mut T {
         let prev_stack_pointer_pointer = self.previous_stack_pointer_pointer_west();
         // note that the allocation is on the east frame, and thus resembles raw_alloc_east
-        *prev_stack_pointer_pointer = (*prev_stack_pointer_pointer).sub(word_size_of::<T>() * count);
+        *prev_stack_pointer_pointer =
+            (*prev_stack_pointer_pointer).sub(word_size_of::<T>() * count);
         *prev_stack_pointer_pointer as *mut T
     }
 
@@ -871,11 +869,11 @@ impl Preserve for IndirectAtom {
 impl Preserve for Atom {
     unsafe fn preserve(&mut self, stack: &mut NockStack) {
         match self.as_either() {
-            Left(_direct) => {},
+            Left(_direct) => {}
             Right(mut indirect) => {
                 indirect.preserve(stack);
                 *self = indirect.as_atom();
-            },
+            }
         }
     }
 }
@@ -885,10 +883,10 @@ impl Preserve for Noun {
         match stack.polarity {
             Polarity::East => {
                 stack.copy_east(self);
-            },
+            }
             Polarity::West => {
                 stack.copy_west(self);
-            },
+            }
         }
     }
 }

rust/ares/src/noun.rs

@@ -183,10 +183,10 @@ impl fmt::Display for DirectAtom {
                 std::str::from_utf8_unchecked(&bytes[..n])
             })
         } else {
-        write!(f, "{}", self.0)
+            write!(f, "{}", self.0)
+        }
     }
 }
-}
 
 #[allow(non_snake_case)]
 pub const fn D(n: u64) -> Noun {

rust/ares/src/serf.rs

@@ -31,7 +31,7 @@ pub fn serf() -> io::Result<()> {
     snap_path.push("chk");
     create_dir_all(&snap_path)?;
 
-    let ref mut stack = NockStack::new(21 << 10 << 10, 0);
+    let ref mut stack = NockStack::new(96 << 10 << 10, 0);
     let ref mut newt = Newt::new();
     let mut event_number;
     let mut arvo;

rust/ares/src/serialization.rs

@@ -1,7 +1,7 @@
 use crate::assert_acyclic;
+use crate::hamt::MutHamt;
 use crate::mem::NockStack;
 use crate::noun::{Atom, Cell, DirectAtom, IndirectAtom, Noun};
-use crate::hamt::MutHamt;
 use bitvec::prelude::{BitSlice, Lsb0};
 use either::Either::{Left, Right};
 
@@ -49,7 +49,8 @@ pub fn cue(stack: &mut NockStack, buffer: Atom) -> Noun {
                     // 11 bits - cue backreference
                     cursor += 2;
                     unsafe {
-                        let mut backref_noun = Atom::new(stack, rub_backref(&mut cursor, buffer_bitslice)).as_noun();
+                        let mut backref_noun =
+                            Atom::new(stack, rub_backref(&mut cursor, buffer_bitslice)).as_noun();
                         let reffed_noun = backref_map
                             .lookup(stack, &mut backref_noun)
                             .expect("Invalid backref in cue");
@@ -191,10 +192,10 @@ pub fn jam(stack: &mut NockStack, noun: Noun) -> Atom {
                         } else {
                             jam_backref(stack, &mut state, backref);
                         }
-                    },
+                    }
                     Right(_cell) => {
                         jam_backref(stack, &mut state, backref);
-                    },
+                    }
                 }
                 unsafe {
                     stack.reclaim_in_previous_frame::<Noun>();