jevko.haxe/Jevko.hx at master · jevko/jevko.haxe · GitHub

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
@:structInit class Jevko {
    static public function main():Void {
        var jevko = Jevko.parse("a [b] c");
        trace(jevko);
    }

    static var escaper = "`";
    static var opener = "[";
    static var closer = "]";

    static public function parse(str: String): Jevko {
        var parents = new Array<Jevko>();
        var parent: Jevko = {subjevkos: []};
        var prefix = '';
        var h = 0;
        var isEscaped = false;
        var line = 1;
        var column = 1;

        var i = 0;
        while (i < str.length) {
            var c = str.charAt(i);

            if (isEscaped) {
                if (c == escaper || c == opener || c == closer) isEscaped = false;
                else throw 'Invalid digraph (${escaper}${c}) at ${line}:${column}!';
            } else if (c == escaper) {
                prefix += str.substring(h, i);
                h = i + 1;
                isEscaped = true;
            } else if (c == opener) {
                var jevko: Jevko = {subjevkos: []};
                parent.subjevkos.push({
                    prefix: prefix + str.substring(h, i),
                    jevko: jevko
                });
                prefix = '';
                h = i + 1;
                parents.push(parent);
                parent = jevko;
            } else if (c == closer) {
                parent.suffix = prefix + str.substring(h, i);
                prefix = '';
                h = i + 1;
                if (parents.length < 1) throw ('Unexpected closer (${closer}) at ${line}:${column}!');
                parent = parents.pop();
            }

            if (c == '\n') {
                ++line;
                column = 1;
            } else {
                ++column;
            }

            ++i;
        }
        if (isEscaped) throw ('Unexpected end after escaper (${escaper})!');

        if (parents.length > 0) throw ('Unexpected end: missing ${parents.length} closer(s) (${closer})!');

        parent.suffix = prefix + str.substring(h);
        //parent.opener = opener
        //parent.closer = closer
        //parent.escaper = escaper
        return parent;
    }
    public static function escape(str: String) {
        var ret = '';
        var i = 0;
        while (i < str.length) {
            var c = str.charAt(i);
            if (c == opener || c == closer || c == escaper) ret += escaper;
            ret += c;
            ++i;
        }
        return ret;
    }

    public function toString() {
        var ret = "";

        for (sub in this.subjevkos) {
            ret += '${Jevko.escape(sub.prefix)}${opener}${sub.jevko}${closer}';
        }
        return ret + Jevko.escape(this.suffix);
    }

    public var subjevkos: Array<Subjevko>;
    public var suffix: String;

    public inline function new(
        subjevkos: Array<Subjevko>,
        suffix: String = ""
    ) {
        this.subjevkos = subjevkos;
        this.suffix = suffix;
    }
}

@:structInit class Subjevko {
    public var prefix: String;
    public var jevko: Jevko;

    public function new(prefix: String, jevko: Jevko) {
        this.prefix = prefix;
        this.jevko = jevko;
    }
}