ankha 0.2.3

Ankha scripting toolset
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

pub mod array;
pub mod channel;
pub mod closure;
pub mod dictionary;
pub mod event;
pub mod option;
pub mod promise;
pub mod reflection;
pub mod thread;

use crate::script::AnkhaExpression;
use intuicio_backend_vm::{debugger::PrintDebugger, scope::VmScope};
use intuicio_core::{
    registry::Registry, script::ScriptBuilder, types::struct_type::NativeStructBuilder,
};
use intuicio_data::{
    data_stack::DataStack,
    managed::{
        DynamicManaged, DynamicManagedLazy, DynamicManagedRef, DynamicManagedRefMut, Managed,
        ManagedLazy, ManagedRef, ManagedRefMut,
        gc::{DynamicManagedGc, ManagedGc},
    },
};

pub type AnkhaVmScope<'a> = VmScope<'a, AnkhaExpression>;
pub type AnkhaScriptBuilder<'a> = ScriptBuilder<'a, AnkhaExpression>;

pub fn install(registry: &mut Registry) {
    registry.add_type(NativeStructBuilder::new_uninitialized::<DynamicManaged>().build());
    registry.add_type(NativeStructBuilder::new_uninitialized::<DynamicManagedRef>().build());
    registry.add_type(NativeStructBuilder::new_uninitialized::<DynamicManagedRefMut>().build());
    registry.add_type(NativeStructBuilder::new_uninitialized::<DynamicManagedLazy>().build());
    registry.add_type(NativeStructBuilder::new_uninitialized::<DynamicManagedGc>().build());
    crate::library::option::install(registry);
    crate::library::array::install(registry);
    crate::library::dictionary::install(registry);
    crate::library::reflection::install(registry);
    crate::library::channel::install(registry);
    crate::library::event::install(registry);
    crate::library::closure::install(registry);
    crate::library::promise::install(registry);
    crate::library::thread::install(registry);
}

pub fn printables(debugger: PrintDebugger) -> PrintDebugger {
    debugger
        .printable_custom::<DynamicManaged>(|debugger, value| {
            if let Some((type_name, value)) = debugger.display_raw(*value.type_hash(), unsafe {
                value.as_ptr_raw().cast::<()>()
            }) {
                format!("DynamicManaged <{}>:\n{}", type_name, value)
            } else {
                "DynamicManaged".to_owned()
            }
        })
        .printable_custom::<DynamicManagedRef>(|debugger, value| {
            if let Some((type_name, value)) = debugger.display_raw(*value.type_hash(), unsafe {
                value.as_ptr_raw().unwrap().cast::<()>()
            }) {
                format!("DynamicManagedRef <{}>:\n{}", type_name, value)
            } else {
                "DynamicManagedRef".to_owned()
            }
        })
        .printable_custom::<DynamicManagedRefMut>(|debugger, value| {
            if let Some((type_name, value)) = debugger.display_raw(*value.type_hash(), unsafe {
                value.as_ptr_raw().unwrap().cast::<()>()
            }) {
                format!("DynamicManagedRefMut <{}>:\n{}", type_name, value)
            } else {
                "DynamicManagedRefMut".to_owned()
            }
        })
        .printable_custom::<DynamicManagedLazy>(|debugger, value| {
            if let Some((type_name, value)) = debugger.display_raw(*value.type_hash(), unsafe {
                value.as_ptr_raw().unwrap().cast::<()>()
            }) {
                format!("DynamicManagedLazy <{}>:\n{}", type_name, value)
            } else {
                "DynamicManagedLazy".to_owned()
            }
        })
        .printable_custom::<DynamicManagedGc>(|debugger, value| {
            if let Some((type_name, value)) = debugger.display_raw(value.type_hash(), unsafe {
                value.as_ptr_raw().cast::<()>()
            }) {
                format!("DynamicManagedGc <{}>:\n{}", type_name, value)
            } else {
                "DynamicManagedGc".to_owned()
            }
        })
}

pub struct AnkhaManagedStack<'a> {
    stack: &'a mut DataStack,
}

impl<'a> AnkhaManagedStack<'a> {
    pub fn new(stack: &'a mut DataStack) -> Self {
        Self { stack }
    }

    pub fn push<T>(&mut self, data: Managed<T>) {
        self.stack.push(
            data.into_dynamic()
                .ok()
                .expect("Failed to convert Managed into DynamicManaged"),
        );
    }

    pub fn push_ref<T>(&mut self, data: ManagedRef<T>) {
        self.stack.push(data.into_dynamic());
    }

    pub fn push_ref_mut<T>(&mut self, data: ManagedRefMut<T>) {
        self.stack.push(data.into_dynamic());
    }

    pub fn push_lazy<T>(&mut self, data: ManagedLazy<T>) {
        self.stack.push(data.into_dynamic());
    }

    pub fn push_gc<T>(&mut self, data: ManagedGc<T>) {
        self.stack.push(data.into_dynamic());
    }

    pub fn pop<T>(&mut self) -> Option<Managed<T>> {
        self.stack.pop::<DynamicManaged>()?.into_typed().ok()
    }

    pub fn pop_ref<T>(&mut self) -> Option<ManagedRef<T>> {
        self.stack.pop::<DynamicManagedRef>()?.into_typed().ok()
    }

    pub fn pop_ref_mut<T>(&mut self) -> Option<ManagedRefMut<T>> {
        self.stack.pop::<DynamicManagedRefMut>()?.into_typed().ok()
    }

    pub fn pop_lazy<T>(&mut self) -> Option<ManagedLazy<T>> {
        self.stack.pop::<DynamicManagedLazy>()?.into_typed().ok()
    }

    pub fn pop_gc<T>(&mut self) -> Option<ManagedGc<T>> {
        Some(self.stack.pop::<DynamicManagedGc>()?.into_typed())
    }
}