brainterpreter 0.1.1

An interpreter for a Bauble toy programming language
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

use std::fmt::{Display, Formatter};

use crate::lexer::SourceToken;
use crate::source::Position;

/// Lexical token
#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    Plus,
    Minus,
    Star,
    Slash,
    DoubleQuote,
    LeftParen,
    RightParen,
    LeftCurly,
    RightCurly,
    LeftSquare,
    RightSquare,
    Equal,
    EqualEqual,
    Bang,
    BangEqual,
    Less,
    Greater,
    LessEqual,
    GreaterEqual,
    Semicolon,
    Comma,
    Number(f64),
    True,
    False,
    Print,
    If,
    Else,
    While,
    Let,
    Fun,
    Return,
    Nil,
    Identifier(String),
    StringLiteral(String),
    EndOfFile,
    Error,
}

impl Token {
    pub fn with_position(self, pos: Position) -> SourceToken {
        SourceToken::new(self, pos)
    }

    pub fn with_line(self, line: usize) -> SourceToken {
        SourceToken::new(self, Position::new(line, 0))
    }
}

impl Display for Token {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Token::Plus => write!(f, "+"),
            Token::Minus => write!(f, "-"),
            Token::Star => write!(f, "*"),
            Token::Slash => write!(f, "/"),
            Token::DoubleQuote => write!(f, "\""),
            Token::LeftParen => write!(f, "("),
            Token::RightParen => write!(f, ")"),
            Token::LeftCurly => write!(f, "{{"),
            Token::RightCurly => write!(f, "}}"),
            Token::LeftSquare => write!(f, "["),
            Token::RightSquare => write!(f, "]"),
            Token::Equal => write!(f, "="),
            Token::EqualEqual => write!(f, "=="),
            Token::Bang => write!(f, "!"),
            Token::BangEqual => write!(f, "!="),
            Token::Less => write!(f, "<"),
            Token::Greater => write!(f, ">"),
            Token::LessEqual => write!(f, "<="),
            Token::GreaterEqual => write!(f, ">="),
            Token::Semicolon => write!(f, ";"),
            Token::Comma => write!(f, ","),
            Token::Number(n) => write!(f, "{}", n),
            Token::True => write!(f, "true"),
            Token::False => write!(f, "false"),
            Token::Print => write!(f, "print"),
            Token::If => write!(f, "if"),
            Token::Else => write!(f, "else"),
            Token::While => write!(f, "while"),
            Token::Let => write!(f, "let"),
            Token::Fun => write!(f, "fun"),
            Token::Return => write!(f, "return"),
            Token::Nil => write!(f, "nil"),
            Token::Identifier(name) => write!(f, "{}", name),
            Token::StringLiteral(s) => write!(f, "{}", s),
            Token::EndOfFile => write!(f, "EOF"),
            Token::Error => write!(f, "Error"),
        }
    }
}