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
111
112
113
114
115
116
117
118
119

use crate::Value;

use super::{Aml3Error, Aml3Parser};

pub struct Aml3Value;

impl Aml3Value {
    fn visit_number(parser: &mut Aml3Parser) -> Result<Value, Aml3Error> {
        let first = parser
            .consume()
            .ok_or_else(|| unreachable!("This is verified by the visit root"))?;

        let mut str = first.to_string();

        loop {
            let a = parser
                .consume_oneline()
                .ok_or_else(|| parser.error("Untermited number"))?;

            match a {
                b @ 'u' | b @ 'i' => {
                    let size = parser
                        .consume_until(' ')
                        .ok_or_else(|| parser.error_expected("number size", None))?;

                    return match &size as &str {
                        "8" => {
                            if b == 'u' {
                                Ok(Value::U8(str.parse::<u8>().map_err(|e| {
                                    parser.error(format!("Cannot parse u8: {e}"))
                                })?))
                            } else {
                                todo!()
                            }
                        }

                        _ => Err(parser.error("Unknown number size: {size}")),
                    };
                }
                _ => todo!("{a:?}"),
            }
        }
    }

    fn visit_string(parser: &mut Aml3Parser) -> Result<Value, Aml3Error> {
        parser.consume().expect("Already verified");

        // let str = parser
        //     .consume_until_oneline('"')
        //     .ok_or_else(|| parser.error("Malformed string"))?;

        let mut str = String::new();
        let mut escaping = false;
        loop {
            let c = parser
                .consume()
                .ok_or_else(|| parser.error("Untermited string"))?;

            match c {
                '\n' => return Err(parser.error("Unterminated string")),
                '\\' if escaping => str.push('\\'),
                '"' if escaping => str.push('"'),
                'n' if escaping => str.push('\n'),
                '"' => break,
                '\\' => {}

                _ => str.push(c),
            }

            if c == '\\' && !escaping {
                escaping = true;
            } else {
                escaping = false;
            }
        }

        // Consume following character expect for new line, supposed to be space
        let sp = parser.consume_oneline();
        if !matches!(sp, Some(' ') | None) {
            return Err(parser.error_expected("space", Some(format!("{:?}", sp.unwrap()))));
        }

        Ok(Value::String(str))
    }

    fn visit_bool(parser: &mut Aml3Parser) -> Result<Value, Aml3Error> {
        let v = parser
            .peek_until(' ')
            .ok_or_else(|| parser.error_expected("boolean value: true or false", None))?;

        match &v as &str {
            "true" => {
                parser.consume_until('\n');
                Ok(Value::Bool(true))
            }
            "false" => {
                parser.consume_until('\n');
                Ok(Value::Bool(false))
            }

            _ => Err(parser.error_expected("boolean value: true or false", Some(v))),
        }
    }

    pub fn visit(parser: &mut Aml3Parser) -> Result<Value, Aml3Error> {
        let first = parser
            .peek(0)
            .ok_or_else(|| parser.error_expected("value", None))?;

        match first {
            b if b.is_digit(10) => Self::visit_number(parser),
            '"' => Self::visit_string(parser),

            't' | 'f' => Self::visit_bool(parser),

            _ => Err(parser.error(format!("Unknown token: {first:?}"))),
        }
    }
}