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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::*;

/** Conditional branch. */

#[derive(Debug)]
pub struct ImlIf {
    peek: bool,
    test: bool,
    then: ImlOp,
    else_: ImlOp,
}

impl ImlIf {
    pub fn new(then: ImlOp, else_: ImlOp) -> ImlOp {
        Self {
            peek: false,
            test: true,
            then,
            else_,
        }
        .into_op()
    }

    pub fn new_if_true(then: ImlOp, else_: ImlOp) -> ImlOp {
        Self {
            peek: true,
            test: true,
            then,
            else_,
        }
        .into_op()
    }

    pub fn new_if_false(then: ImlOp, else_: ImlOp) -> ImlOp {
        Self {
            peek: true,
            test: false,
            then,
            else_,
        }
        .into_op()
    }
}

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

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

        if let Some(else_) = self.else_.finalize(values, stack) {
            if let Some(then) = then {
                Some(Consumable {
                    leftrec: then.leftrec || else_.leftrec,
                    nullable: then.nullable || else_.nullable,
                })
            } else {
                Some(else_)
            }
        } else {
            then
        }
    }

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

        // Clone on peek
        if self.peek {
            ret.push(Op::Clone);
        }

        // Then-part
        let then = self.then.compile(parselet);

        let backpatch = ret.len();
        ret.push(Op::Nop);

        if self.peek {
            ret.push(Op::Drop)
        }

        let mut jump = then.len() + 1;
        ret.extend(then);

        if !self.peek {
            // Else-part
            let else_ = self.else_.compile(parselet);

            if !else_.is_empty() {
                ret.push(Op::Forward(else_.len() + 1));
                jump += 1;
                ret.extend(else_);
            }
        } else {
            jump += 1;
        }

        // Insert the final condition and its failure target.
        if self.test {
            ret[backpatch] = Op::ForwardIfFalse(jump);
        } else {
            ret[backpatch] = Op::ForwardIfTrue(jump);
        }

        ret
    }
}

impl std::fmt::Display for ImlIf {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "if {} else {}", self.then, self.else_)
    }
}