sphinx-lang 0.8.6

An intepreter for a dynamic language implemented in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use core::cell::Cell;
use core::ptr::NonNull;
use crate::runtime::gc::GC_STATE;
use crate::runtime::gc::trace::GcTrace;
use crate::runtime::gc::gcbox::{GcBox, WeakCell};

#[derive(Debug)]
pub(super) struct GcWeakCell<T> where T: GcTrace + ?Sized + 'static {
    ptr: Cell<Option<NonNull<GcBox<T>>>>,
}

unsafe impl<T> GcTrace for GcWeakCell<T> where T: GcTrace + ?Sized {
    fn trace(&self) { }
}

impl<T> GcWeakCell<T> where T: GcTrace + ?Sized {
    pub(super) fn new(gcbox: NonNull<GcBox<T>>) -> Self {
        Self {
            ptr: Cell::new(Some(gcbox))
        }
    }
    
    pub(super) fn get(&self) -> Option<NonNull<GcBox<T>>> {
        self.ptr.get()
    }
    
    pub(super) fn invalidate(&self) {
        if let Some(weak_ptr) = self.ptr.get() {
            log::debug!("{:#X} invalidate weak reference", weak_ptr.as_ptr() as *mut () as usize);
        }
        
        self.ptr.set(None)
    }
}

impl<T> Drop for GcWeakCell<T> where T: GcTrace + ?Sized {
    fn drop(&mut self) {
        if let Some(mut weak_ptr) = self.ptr.get() {
            log::debug!("{:#X} weak reference dropped", weak_ptr.as_ptr() as *mut () as usize);
            
            unsafe { weak_ptr.as_mut() }.clear_weak();
        }
    }
}

impl<T> WeakCell for GcWeakCell<T> where T: GcTrace + ?Sized {
    fn invalidate(&self) {
        GcWeakCell::invalidate(self)
    }
}


impl<T> GcBox<T> where T: GcTrace + ?Sized {
    /// Get a pointer to the weak reference allocation for this `GcBox<T>`
    /// if it already exists, otherwise allocate a new one
    pub(super) fn get_or_make_weak(mut self_ptr: NonNull<GcBox<T>>) -> NonNull<GcBox<GcWeakCell<T>>> {
        if let Some(weak_ptr) = unsafe { self_ptr.as_ref() }.header().weak() {
            weak_ptr.cast()
        } else {
            let weak_cell = GcWeakCell::new(self_ptr);
            let gcbox_weak = GcBox::new(weak_cell);
            
            // update the header weakref data
            let dyn_ptr = gcbox_weak.as_ptr() as *mut GcBox<dyn WeakCell>;
            unsafe { self_ptr.as_mut() }.header_mut()
                .set_weak(unsafe { Some(NonNull::new_unchecked(dyn_ptr)) });
            
            // insert the new GcBox<GcWeakCell<T>> into GC tracking
            GC_STATE.with(|gc| gc.borrow_mut().insert(gcbox_weak));
            
            gcbox_weak
        }
    }
    
    fn clear_weak(&mut self) {
        self.header_mut().set_weak(None);
    }
}