vyre-libs 0.6.3

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

use super::*;
use vyre_primitives::hash::fnv1a::fnv1a32;

inventory::submit! {
    crate::harness::OpEntry {
        id: "vyre-libs::parsing::c11_extract_functions",
        build: || c11_extract_functions(
            "tok_types", "paren_pairs", "brace_pairs", Expr::u32(6), "out_functions", "out_counts"
        ),
        test_inputs: Some(function_extract_inputs),
        expected_output: Some(function_extract_expected),
        category: Some("parsing"),
    }
}

inventory::submit! {
    crate::harness::OpEntry {
        id: "vyre-libs::parsing::c11_extract_calls",
        build: || c11_extract_calls(
            "tok_types", "paren_pairs", "functions", Expr::u32(9), Expr::u32(1), "out_calls", "out_counts"
        ),
        test_inputs: Some(call_extract_inputs),
        expected_output: Some(call_extract_expected),
        category: Some("parsing"),
    }
}

inventory::submit! {
    crate::harness::OpEntry {
        id: "vyre-libs::parsing::c11_build_call_graph",
        build: || c11_build_call_graph("calls", "fn_hashes", "tok_starts", "tok_lens", "haystack", Expr::u32(1), Expr::u32(1), Expr::u32(6), "out_edges", "out_counts"),
        test_inputs: Some(call_graph_inputs),
        expected_output: Some(call_graph_expected),
        category: Some("parsing"),
    }
}

use crate::scan::dispatch_io::pack_u32_slice as pack_u32;

fn function_extract_inputs() -> Vec<Vec<Vec<u8>>> {
    vec![vec![
        pack_u32(&[
            TOK_INT,
            TOK_IDENTIFIER,
            TOK_LPAREN,
            TOK_RPAREN,
            TOK_LBRACE,
            TOK_RBRACE,
        ]),
        pack_u32(&[u32::MAX, u32::MAX, 3, 2, u32::MAX, u32::MAX]),
        pack_u32(&[u32::MAX, u32::MAX, u32::MAX, u32::MAX, 5, 4]),
        vec![0u8; 6 * 3 * 4],
        pack_u32(&[0]),
    ]]
}

fn function_extract_expected() -> Vec<Vec<Vec<u8>>> {
    let mut functions = vec![0u32; 18];
    functions[3..6].copy_from_slice(&[1, 4, 5]);
    vec![vec![pack_u32(&functions), pack_u32(&[18])]]
}

fn call_extract_inputs() -> Vec<Vec<Vec<u8>>> {
    vec![vec![
        pack_u32(&[
            TOK_INT,
            TOK_IDENTIFIER,
            TOK_LPAREN,
            TOK_RPAREN,
            TOK_LBRACE,
            TOK_IDENTIFIER,
            TOK_LPAREN,
            TOK_RPAREN,
            TOK_SEMICOLON,
        ]),
        pack_u32(&[u32::MAX, u32::MAX, 3, 2, u32::MAX, u32::MAX, 7, 6, u32::MAX]),
        pack_u32(&[1, 4, 8]),
        vec![0u8; 9 * 4 * 4],
        pack_u32(&[0]),
    ]]
}

fn call_extract_expected() -> Vec<Vec<Vec<u8>>> {
    let mut calls = vec![0u32; 9 * 4];
    calls[21..24].copy_from_slice(&[5, 6, 7]);
    vec![vec![pack_u32(&calls), pack_u32(&[36])]]
}

fn call_graph_inputs() -> Vec<Vec<Vec<u8>>> {
    vec![vec![
        pack_u32(&[0, 5, 6, 7]),
        pack_u32(&[fnv1a32(b"foo")]),
        pack_u32(&[0, 0, 0, 0, 0, 0]),
        pack_u32(&[0, 0, 0, 0, 0, 3]),
        pack_u32(&[
            u32::from(b'f'),
            u32::from(b'o'),
            u32::from(b'o'),
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
        ]),
        vec![0u8; 4 * 4],
        pack_u32(&[0]),
    ]]
}

fn call_graph_expected() -> Vec<Vec<Vec<u8>>> {
    vec![vec![pack_u32(&[0, 0, 0, 0]), pack_u32(&[2])]]
}