.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
lang/
alloc/
ast/
gen/
il/
layout/
lower/
manifest/
module/
parser/
resolver/
tests/
metadata.rad
2.6 KiB
printer.rad
33.0 KiB
refs.rad
66.5 KiB
tests.rad
23.6 KiB
scanner/
sexpr/
alloc.rad
1.2 KiB
ast.rad
36.0 KiB
gen.rad
513 B
il.rad
48.5 KiB
layout.rad
6.9 KiB
lower.rad
487.6 KiB
manifest.rad
22.5 KiB
module.rad
17.8 KiB
package.rad
1.5 KiB
parser.rad
114.1 KiB
pretty.rad
103.6 KiB
resolver.rad
508.1 KiB
scanner.rad
19.3 KiB
sexpr.rad
7.1 KiB
strings.rad
3.3 KiB
types.rad
620 B
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/lang/resolver/metadata.rad
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 | } |