rockscript 0.2.0

Esolang called Rockscript
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

use std::ops;

use crate::lexer::Token;

#[derive(Debug, Clone)]
pub enum Statement {
    VarDef {
        name: String,
        value: Box<SpannedExpr>,
    },

    FnDef {
        name: String,
        params: Vec<String>,
        body: Vec<SpannedStatement>,
    },

    Return(Box<SpannedExpr>),

    BinaryOp {
        operation: BinaryOp,
        variable: String,
        value: Box<SpannedExpr>,
    },

    If {
        condition: Box<SpannedExpr>,
        body: Vec<SpannedStatement>,
        else_: Option<Vec<SpannedStatement>>,
    },

    While {
        condition: Box<SpannedExpr>,
        body: Vec<SpannedStatement>,
    },

    Break,

    Print(Box<SpannedExpr>),

    Expr(Box<SpannedExpr>),
}

#[derive(Debug, Clone)]
pub struct SpannedStatement {
    pub statement: Statement,
    pub span: ops::Range<usize>,
}

#[derive(Debug, Clone)]
pub enum Expression {
    Number(f64),
    Str(String),
    Boolean(bool),
    Identifier(String),

    FnCall {
        name: String,
        args: Vec<SpannedExpr>,
    },

    Weigh {
        left: Box<SpannedExpr>,
        right: Box<SpannedExpr>,
    },
}

#[derive(Debug, Clone)]
pub struct SpannedExpr {
    pub expr: Expression,
    pub span: ops::Range<usize>
}

#[derive(Debug, Clone)]
pub enum BinaryOp {
    Add,
    Sub,
    Mul,
    Div,
}

impl BinaryOp {
    pub fn from_token(token: Token) -> BinaryOp {
        match token {
            Token::Smash => BinaryOp::Add,
            Token::Chip => BinaryOp::Sub,
            Token::Mate => BinaryOp::Mul,
            Token::Split => BinaryOp::Div,
            _ => panic!("cant parse token into binary operation, this shouldnt panic unless theres a bug in the interpreter"),
        }
    }
}