ralix 0.2.0

A simple, type-safe, tree walking interpreter
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

use crate::{
    Expression, Parser, ParserDiagnostic, ParserResult, Token,
    expressions::{InfixOperator, PrefixOperator},
    parser::expressions::Precedence,
};

impl Parser<'_> {
    pub fn parse_infix_expression(&mut self, left: Expression) -> ParserResult<Expression> {
        let operator = match &self.current_token {
            Token::Plus => InfixOperator::Add,
            Token::Minus => InfixOperator::Subtract,
            Token::Asterisk => InfixOperator::Multiply,
            Token::Slash => InfixOperator::Divide,
            Token::Percent => InfixOperator::Remainder,
            Token::Or => InfixOperator::Or,
            Token::And => InfixOperator::And,
            Token::Equal => InfixOperator::Equals,
            Token::NotEqual => InfixOperator::NotEquals,
            Token::GreaterThan => InfixOperator::Greater,
            Token::GreatEqual => InfixOperator::GreatEq,
            Token::LessThan => InfixOperator::Less,
            Token::LessEqual => InfixOperator::LessEq,
            Token::Ampersant => InfixOperator::BitwiseAnd,
            Token::Pipe => InfixOperator::BitwiseOr,
            Token::Caret => InfixOperator::BitwiseXOr,
            Token::ShiftRight => InfixOperator::BitShiftRight,
            Token::ShiftLeft => InfixOperator::BitShiftLeft,
            t => return Err(ParserDiagnostic::UnknownInfixOp(t.literal())),
        };

        let precedence = Precedence::of(&self.current_token);
        self.next_token();
        let right = self.parse_expression(precedence)?;

        Ok(Expression::Infix {
            left: left.into(),
            operator,
            right: right.into(),
        })
    }

    pub fn parse_prefix_expression(&mut self) -> ParserResult<Expression> {
        let operator = match &self.current_token {
            Token::Bang | Token::Not => PrefixOperator::Not,
            Token::Minus => PrefixOperator::Neg,
            Token::Asterisk => PrefixOperator::Deref,
            Token::Ampersant => PrefixOperator::AddrOf,
            Token::Tilde => PrefixOperator::BitwiseNot,
            t => return Err(ParserDiagnostic::UnknownInfixOp(t.literal())),
        };

        self.next_token();
        let right = self.parse_expression(Precedence::Prefix)?;

        Ok(Expression::Prefix {
            operator,
            right: Box::new(right),
        })
    }

    pub fn parse_lparen_items(&mut self) -> ParserResult<Expression> {
        self.consume_current_token(Token::LParen);

        let expr = self.parse_expression(Precedence::Lowest)?;

        self.next_token();
        // if self.is_current_token(Token::RParen) {
        Ok(expr)
        // } else {
        //     todo!("Tuple expressions not implemented... YET!")
        // }
    }
}