nilang 0.4.1

A scripting language interpreter for Advent of Code
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

use hashbrown::HashMap;
use alloc::rc::Rc;

pub type SymID = u32;

pub struct SymbolMap {
    str_to_id: HashMap<Rc<String>, SymID>,
    id_to_str: Vec<Rc<String>>,
}

// special symbols
macro_rules! generate_intrinsic_syms {
    ($($name:ident),*) => {
        // Generate consts for each intrinsic symbol with sequential SymID.
        #[allow(non_camel_case_types)]
        #[repr(u32)]
        enum Intrinsics {
            $($name,)*
        }

        $(
            pub const $name: SymID = Intrinsics::$name as u32;
        )*

        impl SymbolMap {
            // Create the is_intrinsic function to check if a symbol is intrinsic.
            pub fn is_intrinsic(sym: SymID) -> bool {
                match sym {
                    $(
                        $name => true,
                    )*
                    _ => false,
                }
            }

            // Create the init function to insert each intrinsic symbol in the correct order.
            pub fn insert_intrinsics(&mut self) {
                let symbols = vec![
                    $(
                        stringify!($name).trim_end_matches("_SYM").to_ascii_lowercase(),
                    )*
                ];

                for symbol in symbols {
                    self.insert(symbol.to_string());
                }
            }
        }
    };
}

// Use the macro to generate the necessary parts.
generate_intrinsic_syms! {
    INT_SYM,
    FLOAT_SYM,
    STR_SYM,
    BOOL_SYM,
    SYM_SYM,
    NULL_SYM,
    LIST_SYM,
    MAP_SYM,
    FN_SYM,

    // Utility intrinsics
    ARGS_SYM,
    PATCH_SYM
}

// Non-intrinsic but reserved symbol IDs
pub const SELF_SYM: SymID = 11;
pub const ITER_SYM: SymID = 12;
pub const ITER_END_SYM: SymID = 13;

impl Default for SymbolMap {
    fn default() -> Self {
        Self::new()
    }
}

impl SymbolMap {
    pub fn new() -> Self {
        let mut this = Self {
            str_to_id: HashMap::new(),
            id_to_str: Vec::new(),
        };

        this.insert_intrinsics();

        // Insert reserved non-intrinsic symbols
        this.insert("self".to_string());
        this.insert("iter".to_string());
        this.insert("iter_end".to_string());

        this
    }


    pub fn get_id(&mut self, str: &str) -> SymID {
        let str = str.to_string();
        match self.str_to_id.get(&str) {
            Some(id) => *id,
            None => self.insert(str),
        }
    }

    pub fn get_str(&mut self, id: SymID) -> &str {
        &self.id_to_str[id as usize]
    }

    fn insert(&mut self, str: String) -> SymID {
        let id = self.id_to_str.len() as u32;
        let s = Rc::new(str);

        self.id_to_str.push(s.clone());
        self.str_to_id.insert(s.clone(), id);

        id
    }
}