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

use super::parallel_common::{
    regular_parallel_buffers, regular_parallel_classifier, regular_parallel_token_start_expr,
    RegularParallelMode, REGULAR_PARALLEL_WORKGROUP_SIZE,
};
use super::*;

pub fn c11_lexer_regular_ranked(
    haystack: &str,
    out_tok_types: &str,
    out_tok_starts: &str,
    out_tok_lens: &str,
    out_counts: &str,
    haystack_len: u32,
) -> Program {
    let t = Expr::InvocationId { axis: 0 };
    let mut classify_at_pos = regular_parallel_classifier(
        haystack,
        haystack_len,
        t.clone(),
        RegularParallelMode::Ranked,
    );
    classify_at_pos.push(Node::if_then(
        Expr::eq(Expr::var("emit"), Expr::u32(1)),
        vec![
            Node::store(out_tok_types, Expr::var("rank"), Expr::var("tok_type")),
            Node::store(out_tok_starts, Expr::var("rank"), Expr::var("pos")),
            Node::store(out_tok_lens, Expr::var("rank"), Expr::var("tok_len")),
        ],
    ));

    Program::wrapped(
        regular_parallel_buffers(
            haystack,
            out_tok_types,
            out_tok_starts,
            out_tok_lens,
            out_counts,
            haystack_len,
        ),
        [REGULAR_PARALLEL_WORKGROUP_SIZE, 1, 1],
        vec![wrap_anonymous(
            "vyre-libs::parsing::c_lexer_regular_ranked",
            vec![
                Node::if_then(
                    Expr::lt(t.clone(), Expr::buf_len(haystack)),
                    vec![Node::if_then(
                        regular_parallel_token_start_expr(haystack, haystack_len, t.clone()),
                        classify_at_pos,
                    )],
                ),
                Node::if_then(
                    Expr::eq(t, Expr::u32(0)),
                    vec![
                        Node::let_bind("token_count", Expr::u32(0)),
                        Node::loop_for(
                            "count_scan",
                            Expr::u32(0),
                            Expr::buf_len(haystack),
                            vec![Node::if_then(
                                regular_parallel_token_start_expr(
                                    haystack,
                                    haystack_len,
                                    Expr::var("count_scan"),
                                ),
                                vec![Node::assign(
                                    "token_count",
                                    Expr::add(Expr::var("token_count"), Expr::u32(1)),
                                )],
                            )],
                        ),
                        Node::store(out_counts, Expr::u32(0), Expr::var("token_count")),
                    ],
                ),
            ],
        )],
    )
    .with_entry_op_id("vyre-libs::parsing::c_lexer_regular_ranked")
    .with_non_composable_with_self(true)
}