amvm 0.1.0

Apika's My Virtual Machine. A virtual machine with Intermediate Lenguage
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

use crate::{BinaryConditionKind, CommandExpression};

use super::{Aml3Error, Aml3Parser, Aml3Value, Aml3Variable};

pub struct Aml3Expr;

impl Aml3Expr {
    pub fn visit(parser: &mut Aml3Parser) -> Result<CommandExpression, Aml3Error> {
        let kind = parser
            .peek(0)
            .ok_or_else(|| parser.error_expected("expression", None))?;

        match kind {
            '+' => {
                let _ = parser.consume();

                Ok(CommandExpression::Addition(
                    Box::from(Aml3Expr::visit(parser)?),
                    Box::from(Aml3Expr::visit(parser)?),
                ))
            }
            '-' => {
                let _ = parser.consume();

                Ok(CommandExpression::Substraction(
                    Box::from(Aml3Expr::visit(parser)?),
                    Box::from(Aml3Expr::visit(parser)?),
                ))
            }
            '$' => Ok(CommandExpression::Var(Aml3Variable::visit(parser)?)),
            '.' => {
                let _ = parser.consume();

                Ok(CommandExpression::Property(
                    Box::from(Aml3Expr::visit(parser)?),
                    Box::from(Aml3Expr::visit(parser)?),
                ))
            }

            '!' | '>' | '<' | '=' => {
                let sk = parser.peek(1);

                match (kind, sk) {
                    ('>', Some('=')) => {
                        let _ = parser.consume();
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::GreaterThanEqual,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    ('>', _) => {
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::GreaterThan,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    ('<', Some('=')) => {
                        let _ = parser.consume();
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::LessThanEqual,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    ('<', _) => {
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::LessThan,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    ('=', Some('=')) => {
                        let _ = parser.consume();
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::Equal,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    ('!', Some('=')) => {
                        let _ = parser.consume();
                        let _ = parser.consume();

                        Ok(CommandExpression::BinaryCondition(
                            BinaryConditionKind::NotEqual,
                            Box::from(Aml3Expr::visit(parser)?),
                            Box::from(Aml3Expr::visit(parser)?),
                        ))
                    }
                    _ => Err(parser
                        .error_expected("boolean expression", Some(format!("{kind} + {sk:?}")))),
                }
            }

            _ => Ok(CommandExpression::Value(Aml3Value::visit(parser)?)),
        }
    }
}