lib/std/lang/resolver/metadata.rad 2.6 KiB raw
1
//! Paged semantic node metadata for an incremental resolver.
2
3
use std::mem::heap;
4
5
/// Number of semantic entries in a full metadata page.
6
export constant PAGE: u32 = 4096;
7
8
/// Semantic metadata indexed by AST node ID.
9
export record Table {
10
    /// Disjoint pages of semantic data.
11
    pages: *mut [*mut [super::NodeData]],
12
    /// Number of initialized metadata entries.
13
    len: u32,
14
}
15
16
/// Split initialized metadata storage into disjoint, bounded pages.
17
export fn new(entries: *mut [super::NodeData], arena: &heap::Heap) -> Table {
18
    let count = entries.len;
19
    let mut pages: *mut [*mut [super::NodeData]] = &mut [];
20
    let mut first: u32 = 0;
21
    while first < count {
22
        let end = first + PAGE if count - first > PAGE else count;
23
        // Each page owns a disjoint part of the metadata storage.
24
        unsafe {
25
            let mut page: *mut [super::NodeData] = &mut entries[first .. end];
26
            set page.cap = end - first;
27
            try! pages.append(page, arena);
28
        }
29
        set first = end;
30
    }
31
    return Table { pages, len: count };
32
}
33
34
/// Initialize metadata for appended nodes without copying complete preceding pages.
35
export fn extend(table: &mut Table, count: u32, arena: &heap::Heap) {
36
    while table.len < count {
37
        let page = table.len / PAGE;
38
        let offset = table.len % PAGE;
39
        if offset > 0 {
40
            let length = PAGE
41
                if count - page * PAGE > PAGE
42
                else count - page * PAGE;
43
            try! table.pages[page].reserve(PAGE, arena);
44
            try! table.pages[page].resize(length, super::blankNodeData(), arena);
45
            set table.len = page * PAGE + length;
46
        } else {
47
            let length = PAGE
48
                if count - table.len > PAGE
49
                else count - table.len;
50
            let mut entries: *mut [super::NodeData] = &mut [];
51
            try! entries.reserve(PAGE, arena);
52
            try! entries.resize(length, super::blankNodeData(), arena);
53
            try! table.pages.append(entries, arena);
54
            set table.len += length;
55
        }
56
    }
57
}
58
59
/// Borrow the semantic metadata at an initialized node index.
60
export fn (table: &'r Table) get(index: u32) -> &'r super::NodeData {
61
    assert index < table.len, "get: node index out of bounds";
62
    return &table.pages[index / PAGE][index % PAGE];
63
}
64
65
/// Mutably borrow the semantic metadata at an initialized node index.
66
export fn (table: &'r mut Table) getMut(index: u32) -> &'r mut super::NodeData {
67
    assert index < table.len, "getMut: node index out of bounds";
68
    return &mut table.pages[index / PAGE][index % PAGE];
69
}