oris 0.2.1

An interpreter for Monkey
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

use crate::lex;

#[derive(Debug)]
pub(crate) enum Error {
    Lex(lex::Error),
    Incomplete(Incomplete),
    Mismatch(Mismatch),
}

#[derive(Debug)]
pub(crate) struct Incomplete {
    pub(crate) pos: usize,
    pub(crate) expected: Expected,
}

#[derive(Debug)]
pub(crate) struct Mismatch {
    pub(crate) left: lex::token::Token,
    pub(crate) right: Expected,
}

#[derive(Debug)]
pub(crate) enum Expected {
    Expr,
    Token(lex::token::Kind),
}

impl Error {
    pub(crate) fn pos(&self) -> usize {
        match self {
            Self::Lex(error) => error.pos,
            Self::Incomplete(incomplete) => incomplete.pos,
            Self::Mismatch(mismatch) => mismatch.left.pos,
        }
    }
}

impl From<lex::Error> for Error {
    fn from(error: lex::Error) -> Self {
        Self::Lex(error)
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::Lex(error) => error.fmt(f),
            Error::Incomplete(incomplete) => {
                write!(f, "miss {}", incomplete.expected)
            }
            Error::Mismatch(error) => {
                write!(f, "expect {}, found {:?}", error.right, error.left)
            }
        }
    }
}

impl std::fmt::Display for Expected {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Expr => f.write_str("expression"),
            Self::Token(token) => write!(f, "{:?}", token),
        }
    }
}