BROKEN WIP: GARBAGE COLLECTION AND HEAP MANAGEMENT

Signed-off-by: Ava Affine <ava@sunnypup.io>

hyphae/src/heap.rs

@@ -15,123 +15,168 @@
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use core::fmt::{self, Formatter};
-use core::ops::Index;
+use core::ops::{Index, Deref, DerefMut};
+use core::ptr::NonNull;
 use core::cell::RefCell;
 
-use alloc::format;
 use alloc::rc::Rc;
 use alloc::vec::Vec;
+use alloc::boxed::Box;
 use alloc::string::String;
 
 use organelle::Number;
 
-#[derive(Default, Clone, PartialEq)]
+/* NOTE
+ * decided not to implement a cache or a singleton heap manager
+ * because I did not want to involve a datatype that would add
+ * unneeded logic to where and how the Rcs get allocated or that
+ * would require relocation if more Rcs were allocated. Any
+ * ADT containing the source data referenced by Gc would add
+ * overhead without value.
+ *
+ * Meanwhile, just using allocated-at-site Rcs provides accurate
+ * reference counting garbage collection. We hack the Box::into_raw
+ * function to pass around heap allocated Rcs.
+ */
+
+#[derive(Clone, PartialEq)]
 pub enum Datum {
     Number(Number),
     Bool(bool),
-    List(Rc<Ast>),
+    Cons(Cons),
     Symbol(String),
     Char(u8),
     String(Vec<u8>),
-    Vector(RefCell<Vec<Rc<Datum>>>),
+    Vector(RefCell<Vec<Gc<Datum>>>),
     ByteVector(RefCell<Vec<u8>>),
-    #[default]
-    None,
 }
 
-fn byte_to_escaped_char(b: u8) -> String {
-    // alarm, backspace, delete
-    match b {
-         _ if b > 31 && b < 127 => String::from(b as char),
-         _ => format!("x{:x}", b),
-    }
-}
-
-fn fmt_vec<T: fmt::Display>(ve: &RefCell<Vec<T>>) -> String {
-    let v = ve.borrow();
-    if v.len() == 0 {
-        return String::new()
-    }
-    let mut s = format!("{}", v[0]);
-    let mut i = v.iter();
-    i.next(); // discard
-    i.for_each(|e| {
-        s = format!("{} {}", s, e);
-    });
-
-    s
-}
-
-impl fmt::Display for Datum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Datum::Number(n) => write!(f, "{}", Into::<String>::into(*n)),
-            Datum::Bool(n) => write!(f, "{}", if *n {"#t"} else {"#f"}),
-            Datum::List(n) => write!(f, "{n}"),
-            Datum::Symbol(n) => write!(f, "{n}"),
-            Datum::Char(n) => write!(f, "#\\{}",
-                    byte_to_escaped_char(*n)),
-            Datum::String(n) =>
-                write!(f, "\"{}\"", String::from_utf8_lossy(&*n)),
-            Datum::Vector(n) => write!(f, "#({})", fmt_vec(n)),
-            Datum::ByteVector(n) => write!(f, "#u8({})", fmt_vec(n)),
-            Datum::None => Ok(())
-        }
-    }
-}
-
-/* WARNING
- * This is in a sense overloaded.
- * Instead of using this to print debugging information for the
- * Rust code, I have instead overloaded it to print the most
- * maximal expanded valid syntax for this Datum
+/* Gc
+ * This is a heap allocated Rc passed around such that it fits into
+ * a physical register. The pointer is to a Box<Rc<T>>, but custom 
+ * deref implementation will ensure that deref always points to the
+ * encapsulated T
  */
-impl fmt::Debug for Datum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Datum::Number(n) => write!(f, "{}", Into::<String>::into(*n)),
-            Datum::Bool(n) => write!(f, "{}", if *n {"#t"} else {"#f"}),
-            Datum::List(n) => write!(f, "{n}"),
-            Datum::Char(n) => write!(f, "{}",
-                    byte_to_escaped_char(*n)),
-            Datum::Symbol(n) => write!(f, "{n}"),
-            Datum::String(n) =>
-                write!(f, "\"{}\"", String::from_utf8_lossy(&*n)),
-            Datum::Vector(n)  => write!(f, "#({n:?})"),
-            Datum::ByteVector(n) => write!(f, "#u8({n:?})"),
-            Datum::None => Ok(())
+#[repr(transparent)]
+pub struct Gc<T>(NonNull<Rc<T>>);
+
+impl From<Rc<Datum>> for Gc<Datum> {
+    fn from(src: Rc<Datum>) -> Self {
+        Gc(NonNull::new(Box::into_raw(Box::new(src.clone())))
+            .expect("GC obj from rc nonnull ptr check"))
+    }
+}
+
+impl From<Datum> for Gc<Datum> {
+    fn from(value: Datum) -> Self {
+        Gc(NonNull::new(Box::into_raw(Box::new(Rc::from(value))))
+            .expect("GC obj from datum nonnull ptr check"))
+    }
+}
+
+impl<T: PartialEq> PartialEq for Gc<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.deref().eq(other.deref())
+    }
+    fn ne(&self, other: &Self) -> bool {
+        self.deref().ne(other.deref())
+    }
+}
+
+impl<T> Deref for Gc<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        unsafe {
+            Rc::<T>::as_ptr(self.0.as_ref())
+                .as_ref()
+                .expect("GC obj deref inconsistent rc ptr")
         }
     }
 }
 
+impl<T> DerefMut for Gc<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe {
+            (Rc::<T>::as_ptr(self.0.as_mut()) as *mut T)
+                .as_mut()
+                .expect("GC obj inconsistent rc ptr")
+        }
+    }
+}
 
-#[derive(Default, Clone, PartialEq)]
-pub struct Ast(pub Rc<Datum>, pub Rc<Datum>);
+// takes a pointer to target Rc
+macro_rules! shallow_copy_rc {
+    ( $src:expr ) => {
+        unsafe {
+            NonNull::new(Box::into_raw(Box::new((*$src).clone())))
+                .expect("GC obj shallow copy nonnull ptr check")
+        }
+    }
+}
 
-impl Ast {
-    pub fn subsl(&self, start: isize, end: isize) -> Ast {
+impl<T: Clone> Clone for Gc<T> {
+    fn clone(&self) -> Self {
+        Gc(shallow_copy_rc!(self.0.as_ptr()))
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        self.0 = shallow_copy_rc!(source.0.as_ptr());
+    }
+}
+
+impl<T> Drop for Gc<T> {
+    fn drop(&mut self) {
+        unsafe {
+            drop(Box::from_raw(self.0.as_ptr() as *mut Box<Rc<T>>))
+        }
+    }
+}
+
+impl<T: Clone> Gc<T> {
+    #[inline]
+    pub fn deep_copy(&self) -> Gc<T> {
+        Gc(unsafe {
+            NonNull::new(Box::into_raw(Box::new(Rc::from(
+                            (*(self.0.as_ptr())).clone()))))
+                .expect("GC obj deep copy nonnull ptr check")
+        })
+    }
+}
+
+#[derive(Clone, PartialEq)]
+pub struct Cons(pub Option<Gc<Datum>>, pub Option<Gc<Datum>>);
+
+impl Cons {
+    pub fn deep_copy(&self) -> Cons {
+        // TODO: recursive deep copy through the whole list
+        Cons(self.0.as_ref().map(|x| x.deep_copy()),
+             self.1.as_ref().map(|x| x.deep_copy()))
+    }
+
+    pub fn subsl(&self, start: isize, end: isize) -> Cons {
         if end - start == 1 {
-            return Ast(Rc::from(self[start as usize].clone()), Rc::from(Datum::None))
+            return Cons(Some(self[start as usize].clone()), None)
         }
 
         if end == 0 {
-            return Ast(
-                Rc::from((*(self.0)).clone()),
-                Rc::from(Datum::None)
+            return Cons(
+                self.0.clone(),
+                None
             )
         }
 
-        let Datum::List(ref next) = *self.1 else {
-            panic!("index into improper list form")
+        let Some(ref next) = self.1 else {
+            panic!("out of bounds subsl of cons list")
+        };
+
+        let Datum::Cons(ref next) = **next else {
+            panic!("subsl of cons list not in standard form")
         };
 
         if start <= 0 {
-            Ast(
-                Rc::from((*(self.0)).clone()),
-                Rc::from(Datum::List(
-                    Rc::from(next.subsl(start - 1, end - 1))))
-            )
+            Cons(self.0.clone(),
+                 Some(Datum::Cons(next.subsl(start - 1, end - 1))
+                                    .into()))
 
         } else {
             next.subsl(start - 1, end - 1)
@@ -139,81 +184,43 @@ impl Ast {
     }
 
     pub fn len(&self) -> usize {
-        let Datum::List(ref next) = *self.1 else {
+        let Some(_) = self.0 else {
+            return 0
+        };
+
+        let Some(ref next) = self.1 else {
             return 1
         };
+
+        let Datum::Cons(ref next) = **next else {
+            // weird list but okay
+            return 2
+        };
+
         1 + next.len()
     }
 }
 
-impl Iterator for Ast {
-    type Item = Rc<Datum>;
 
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Datum::List(n) = &*self.1 {
-            let tmp_pair = n;
-            self.0 = tmp_pair.0.clone();
-            self.1 = tmp_pair.1.clone();
-            return Some(self.0.clone());
-        }
-
-        if let Datum::None = *self.1 {
-            return None;
-        }
-
-        let tmp = self.1.clone();
-        self.0 = Rc::from(Datum::None);
-        self.1 = Rc::from(Datum::None);
-        return Some(tmp);
-    }
-}
-
-impl Index<usize> for Ast {
-    type Output = Datum;
+impl Index<usize> for Cons {
+    type Output = Gc<Datum>;
     fn index(&self, index: usize) -> &Self::Output {
         if index == 0 {
-            if let Datum::None = *self.0 {
-                panic!("out of bounds indexing into AST")
+            if let Some(data) = &self.0 {
+                data
             } else {
-                self.0.as_ref()
+                panic!("out of bounds indexing into cons list")
             }
         } else {
-            let Datum::List(ref next) = *self.1 else {
-                panic!("out of bounds indexing into AST")
+            let Some(ref next) = self.1 else {
+                panic!("out of bounds indexing into cons list")
             };
 
-            next.index(index - 1)
+            let Datum::Cons(ref next) = **next else {
+                panic!("cons list not in standard form")
+            };
+
+            &next[index - 1]
         }
     }
 }
-
-impl fmt::Display for Ast {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}", self.0)?;
-        let mut cur = self;
-        while let Datum::List(next) = &*cur.1 {
-            cur = &next;
-            write!(f, " {}", cur.0)?;
-        }
-
-        if let Datum::None = &*cur.1 {
-            write!(f, ")")
-        } else {
-            write!(f, " . {})", cur.1)
-        }
-    }
-}
-
-impl fmt::Debug for Ast {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}", self.0)?;
-        let mut cur = self;
-        let mut end = 1;
-        while let Datum::List(next) = &*cur.1 {
-            cur = &next;
-            end += 1;
-            write!(f, "({} . ", cur.0)?
-        }
-        write!(f, "{}{}", cur.1, ")".repeat(end))
-    }
-}