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
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

use super::*;

/** Loop-construct */

#[derive(Debug)]
pub struct ImlLoop {
    consuming: Option<Consumable>, // Consumable state
    init: ImlOp,
    condition: ImlOp,
    body: ImlOp,
}

impl ImlLoop {
    pub fn new(init: ImlOp, condition: ImlOp, body: ImlOp) -> ImlOp {
        Self {
            consuming: None,
            init,
            condition,
            body,
        }
        .into_op()
    }
}

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

    fn finalize(
        &mut self,
        values: &Vec<ImlValue>,
        stack: &mut Vec<(usize, bool)>,
    ) -> Option<Consumable> {
        let mut ret: Option<Consumable> = None;

        for part in [
            self.init.finalize(values, stack),
            self.condition.finalize(values, stack),
            self.body.finalize(values, stack),
        ] {
            if let Some(part) = part {
                ret = if let Some(ret) = ret {
                    Some(Consumable {
                        leftrec: ret.leftrec || part.leftrec,
                        nullable: ret.nullable || part.nullable,
                    })
                } else {
                    Some(part)
                }
            }
        }

        self.consuming = ret.clone();

        ret
    }

    fn compile(&self, parselet: &ImlParselet) -> Vec<Op> {
        let mut ret = Vec::new();

        ret.extend(self.init.compile(parselet));

        let mut body = self.condition.compile(parselet);
        if !body.is_empty() {
            body.push(Op::ForwardIfTrue(2));
            body.push(Op::Break);
        }

        body.extend(self.body.compile(parselet));

        ret.push(Op::Loop(
            body.len() + if self.consuming.is_some() { 3 } else { 2 },
        ));
        if self.consuming.is_some() {
            ret.push(Op::Fuse(body.len() + 2));
        }

        ret.extend(body);
        ret.push(Op::Continue);

        if self.consuming.is_some() {
            ret.push(Op::Break);
        }

        ret
    }
}

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