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
120
121
122
123

use crate::operators::{BinaryOp, UnaryOp};
use crate::symbol_map::SymID;

#[derive(Clone, PartialEq, Debug)]
pub enum Token {
    Ctrl(Ctrl),
    Ident(SymID),
    Sym(SymID),
    Global(SymID),
    Float(f64),
    Int(i64),
    String(String),
    KeyWord(KeyWord),
}

#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Ctrl {
    Not,
    Divide,
    Modulo,
    And,
    Or,
    Lt,
    Lte,
    Gt,
    Gte,
    NotEqual,
    Push,
    Multiply,
    DoubleEqual,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    LeftCurly,
    RightCurly,
    Comma,
    Colon,
    Equal,
    SemiColon,
    End,
    Period,
    Plus,
    Minus,
    Carrot,
    HashTag,
    Tilde,
    Pipe,
    Ampersand,

    InterpolatedLeftCurly,
    InterpolatedRightCurly,
}

impl Ctrl {
    pub fn as_binop(&self) -> Option<BinaryOp> {
        match self {
            Ctrl::Plus => Some(BinaryOp::Plus),
            Ctrl::Minus => Some(BinaryOp::Minus),
            Ctrl::Multiply => Some(BinaryOp::Multiply),
            Ctrl::Divide => Some(BinaryOp::Divide),
            Ctrl::Modulo => Some(BinaryOp::Modulo),
            Ctrl::Gt => Some(BinaryOp::Gt),
            Ctrl::Gte => Some(BinaryOp::Gte),
            Ctrl::Lt => Some(BinaryOp::Lt),
            Ctrl::Lte => Some(BinaryOp::Lte),
            Ctrl::NotEqual => Some(BinaryOp::NotEqual),
            Ctrl::DoubleEqual => Some(BinaryOp::Equal),
            Ctrl::Or => Some(BinaryOp::Or),
            Ctrl::And => Some(BinaryOp::And),
            Ctrl::Push => Some(BinaryOp::Push),
            Ctrl::Carrot => Some(BinaryOp::BitXor),
            Ctrl::Pipe => Some(BinaryOp::BitOr),
            Ctrl::Ampersand => Some(BinaryOp::BitAnd),

            // maybe make bitshift be <>
            // Ctrl::DoubleGt => Some(BinaryOp::BitShift), we already have a push operator
            _ => None
        }
    }

    pub fn as_unaop(&self) -> Option<UnaryOp> {
        match self {
            Ctrl::Not => Some(UnaryOp::Not),
            Ctrl::Minus => Some(UnaryOp::Negate),
            Ctrl::Carrot => Some(UnaryOp::Pop),
            Ctrl::HashTag => Some(UnaryOp::Len),
            Ctrl::Tilde => Some(UnaryOp::BitFlip),
            _ => None
        }
    }
}

#[derive(Clone, Copy, PartialEq, Debug)]
pub enum KeyWord {
    Fn,
    If,
    Else,
    While,
    Continue,
    Break,
    Return,
    Null,
    False,
    True,
    Print,
    Read,
    Import,
    Type,
    Delete,
    Bind,
    Clone,
    For,
    In
}

#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Delimiter {
    DoubleQuote,
    SingleQuote,
    Backtick,
    Curly,
}