tokay 0.5.0

Tokay is a programming language designed for ad-hoc parsing, inspired by awk.
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

use super::*;

/** Expecting construct.

This constructs expects its body to be accepted.
On failure, an error message is raised as Reject::Error.
*/

#[derive(Debug)]
pub struct ImlExpect {
    body: ImlOp,
    msg: Option<String>,
}

impl ImlExpect {
    pub fn new(body: ImlOp, msg: Option<String>) -> ImlOp {
        Self { body, msg }.into_op()
    }
}

impl Compileable for ImlExpect {
    fn resolve(&mut self, usages: &mut Vec<Vec<ImlOp>>) {
        self.body.resolve(usages);
    }

    fn finalize(
        &mut self,
        values: &Vec<ImlValue>,
        stack: &mut Vec<(usize, bool)>,
    ) -> Option<Consumable> {
        self.body.finalize(values, stack)
    }

    fn compile(&self, parselet: &ImlParselet) -> Vec<Op> {
        let body = self.body.compile(parselet);

        let mut ret = vec![Op::Frame(body.len() + 2)];

        ret.extend(body);

        ret.extend(vec![
            Op::Forward(2),
            Op::Error(Some(if let Some(msg) = &self.msg {
                msg.clone()
            } else {
                format!("Expecting {}", self.body)
            })),
            Op::Close,
        ]);

        ret
    }
}

impl std::fmt::Display for ImlExpect {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "expect {}", self.body)
    }
}