vyre-libs 0.6.1

vyre Category A library ecosystem - pure-IR compositions over vyre-ops hardware primitives
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
120
121
122

use crate::parsing::c::lex::tokens::TOK_LBRACE;
use vyre::ir::{Expr, Node};

/// Resolve brace scopes using the precomputed `c11_dual_bracket_match` brace-pair table.
///
/// `brace_pairs[open]` is the matching close-brace index or `u32::MAX` for an
/// unmatched open. This keeps semantic scope recovery from redoing the full
/// close-brace depth walk for every token in the release pipeline.
pub fn emit_brace_scope_resolution_from_pairs(
    tok_types: &str,
    brace_pairs: &str,
    node_idx: Expr,
) -> Vec<Node> {
    vec![
        Node::loop_for(
            "scope_pair_scan",
            Expr::u32(0),
            node_idx.clone(),
            vec![
                Node::let_bind(
                    "scope_pair_idx",
                    Expr::sub(
                        Expr::sub(node_idx.clone(), Expr::u32(1)),
                        Expr::var("scope_pair_scan"),
                    ),
                ),
                Node::let_bind(
                    "scope_pair_tok",
                    Expr::load(tok_types, Expr::var("scope_pair_idx")),
                ),
                Node::if_then(
                    Expr::and(
                        Expr::eq(Expr::var("scope_open"), Expr::u32(u32::MAX)),
                        Expr::eq(Expr::var("scope_pair_tok"), Expr::u32(TOK_LBRACE)),
                    ),
                    vec![
                        Node::let_bind(
                            "scope_pair_close",
                            Expr::load(brace_pairs, Expr::var("scope_pair_idx")),
                        ),
                        Node::if_then(
                            Expr::or(
                                Expr::eq(Expr::var("scope_pair_close"), Expr::u32(u32::MAX)),
                                Expr::ge(Expr::var("scope_pair_close"), node_idx.clone()),
                            ),
                            vec![Node::assign("scope_open", Expr::var("scope_pair_idx"))],
                        ),
                    ],
                ),
            ],
        ),
        Node::if_then(
            Expr::ne(Expr::var("scope_open"), Expr::u32(u32::MAX)),
            vec![
                Node::assign("scope_id", Expr::add(Expr::var("scope_open"), Expr::u32(1))),
                Node::let_bind("scope_parent_open", Expr::u32(u32::MAX)),
                Node::if_then(
                    Expr::gt(Expr::var("scope_open"), Expr::u32(0)),
                    vec![Node::loop_for(
                        "scope_pair_parent_scan",
                        Expr::u32(0),
                        Expr::var("scope_open"),
                        vec![
                            Node::let_bind(
                                "scope_pair_parent_idx",
                                Expr::sub(
                                    Expr::sub(Expr::var("scope_open"), Expr::u32(1)),
                                    Expr::var("scope_pair_parent_scan"),
                                ),
                            ),
                            Node::let_bind(
                                "scope_pair_parent_tok",
                                Expr::load(tok_types, Expr::var("scope_pair_parent_idx")),
                            ),
                            Node::if_then(
                                Expr::and(
                                    Expr::eq(
                                        Expr::var("scope_parent_open"),
                                        Expr::u32(u32::MAX),
                                    ),
                                    Expr::eq(
                                        Expr::var("scope_pair_parent_tok"),
                                        Expr::u32(TOK_LBRACE),
                                    ),
                                ),
                                vec![
                                    Node::let_bind(
                                        "scope_pair_parent_close",
                                        Expr::load(brace_pairs, Expr::var("scope_pair_parent_idx")),
                                    ),
                                    Node::if_then(
                                        Expr::or(
                                            Expr::eq(
                                                Expr::var("scope_pair_parent_close"),
                                                Expr::u32(u32::MAX),
                                            ),
                                            Expr::ge(
                                                Expr::var("scope_pair_parent_close"),
                                                Expr::var("scope_open"),
                                            ),
                                        ),
                                        vec![Node::assign(
                                            "scope_parent_open",
                                            Expr::var("scope_pair_parent_idx"),
                                        )],
                                    ),
                                ],
                            ),
                        ],
                    )],
                ),
                Node::if_then(
                    Expr::ne(Expr::var("scope_parent_open"), Expr::u32(u32::MAX)),
                    vec![Node::assign(
                        "scope_parent_id",
                        Expr::add(Expr::var("scope_parent_open"), Expr::u32(1)),
                    )],
                ),
            ],
        ),
    ]
}