hl-valdemar/brolang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

whole-function comptime folding for zero-runtime value calls

Browse Source
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-07-22 23:11:48 +02:00
parent 21ff291788
commit 8b50eb7606
24 changed files with 564 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files
std/static_string_map/static_string_map.bro
-106
View File
@@ -1,106 +0,0 @@
import "@std/mem"
StaticStringMap func($V type) type {
return struct {
keys [][]u8
values []V
len_indexes []u32
min_len u32
max_len u32
}
}
hide Pair func($V type) type {
return struct { []u8, V }
}
init func($V type, $N usize, $entries [N]Pair(V)) StaticStringMap(V) {
return ${
if N > usize(maxval!(u32)) {
compile_error!("static string map has too many entries")
}
keys [N]mut []u8 = undefined
values [N]mut V = undefined
for entries |entry, i| {
if entry.0.len > usize(maxval!(u32)) {
compile_error!("static string map key is too long")
}
for (usize(0))..i |prior| {
if mem.eql(u8, entry.0, entries[prior].0) {
compile_error!("duplicate static string map key")
}
}
keys[i] = entry.0
values[i] = entry.1
}
result :: done: {
if N == 0 {
len_indexes [0]mut u32 = undefined
yield :done StaticStringMap(V) {
keys = keys[..],
values = values[..],
len_indexes = len_indexes[..],
min_len = 0,
max_len = 0,
}
}
# ponytail: insertion sort is compile-time O(N²); replace if large maps affect builds.
i usize = 1
while i < N : i += 1 {
key :: keys[i]
value :: values[i]
j usize = i
while j > 0 and keys[j - 1].len > key.len : j -= 1 {
keys[j] = keys[j - 1]
values[j] = values[j - 1]
}
keys[j] = key
values[j] = value
}
min_len u32 :: u32(keys[0].len)
max_len u32 :: u32(keys[N - 1].len)
len_indexes [usize(max_len) + 1]mut u32 = undefined
entry_index usize = 0
length usize = 0
while length <= usize(max_len) : length += 1 {
while entry_index < N and keys[entry_index].len < length : entry_index += 1 {}
len_indexes[length] = u32(entry_index)
}
yield :done StaticStringMap(V) {
keys = keys[..],
values = values[..],
len_indexes = len_indexes[..],
min_len = min_len,
max_len = max_len,
}
}
yield result
}
}
get func($V type, map @StaticStringMap(V), key []u8) ?V {
if map.keys.len == 0 or key.len > usize(maxval!(u32)) {
return null
}
length u32 :: u32(key.len)
if length < map.min_len or length > map.max_len {
return null
}
index usize = usize(map.len_indexes[usize(length)])
while index < map.keys.len {
candidate :: map.keys[index]
if candidate.len != key.len {
return null
}
if mem.eql(u8, candidate, key) {
return map.values[index]
}
index += 1
}
return null
}
std/static_string_map/static_string_map.hon
+93
View File
@@ -0,0 +1,93 @@
import "@std/mem"
StaticStringMap func($V type) type {
return struct {
keys [][]u8
values []V
len_indexes []u32
min_len u32
max_len u32
}
}
hide Pair func($V type) type {
return struct { []u8, V }
}
init func($V type, $N usize, $entries [N]Pair(V)) StaticStringMap(V) {
if N > usize(maxval!(u32)) {
compile_error!("static string map has too many entries")
}
keys [N]mut []u8 = undefined
values [N]mut V = undefined
# assert no duplicate keys
for entries |entry, i| {
if entry.0.len > usize(maxval!(u32)) {
compile_error!("static string map key is too long")
}
for (0..i) |prior| if mem.eql(u8, entry.0, entries[prior].0) {
compile_error!("duplicate static string map key")
}
keys[i] = entry.0
values[i] = entry.1
}
if N == 0 {
len_indexes [0]u32 = undefined
return StaticStringMap(V){
keys = keys[..],
values = values[..],
len_indexes = len_indexes[..],
min_len = 0,
max_len = 0,
}
}
# fixme: insertion sort is compile-time O(N^2); replace if large maps affect builds
for 1..N |i| {
key :: keys[i]
value :: values[i]
j usize = i
while j > 0 and keys[j - 1].len > key.len : j -= 1 {
keys[j] = keys[j - 1]
values[j] = values[j - 1]
}
keys[j] = key
values[j] = value
}
min_len u32 :: u32(keys[0].len)
max_len u32 :: u32(keys[N - 1].len)
len_indexes [usize(max_len) + 1]mut u32 = undefined
entry_index usize = 0
for 0..=(usize(max_len)) |length| {
while entry_index < N and keys[entry_index].len < length : entry_index += 1 {}
len_indexes[length] = u32(entry_index)
}
return StaticStringMap(V) {
keys = keys[..],
values = values[..],
len_indexes = len_indexes[..],
min_len = min_len,
max_len = max_len,
}
}
get func($V type, map @StaticStringMap(V), key []u8) ?V {
if (map.keys.len == 0 or key.len > maxval!(u32)) return null
length u32 = u32(key.len)
if (length < map.min_len or length > map.max_len) return null
idx usize = usize(map.len_indexes[usize(length)])
while idx < map.keys.len : idx += 1 {
candidate :: map.keys[idx]
if (candidate.len != key.len) return null
if mem.eql(u8, candidate, key) return map.values[idx]
}
}
std/static_string_map/static_string_map.test.bro
-36
View File
@@ -1,36 +0,0 @@
import "@std/testing"
TokenKind :: enum {
keyword_if
keyword_else
keyword_for
keyword_return
}
keywords StaticStringMap(TokenKind) = init([
{"return", .keyword_return},
{"if", .keyword_if},
{"for", .keyword_for},
{"else", .keyword_else},
])
handles_length_bucket_lookups test {
try testing.expect(keywords.keys.len == 4)
try testing.expect(keywords.values.len == keywords.keys.len)
try testing.expect(keywords.len_indexes.len == 7)
try testing.expect_equal(some!(TokenKind.keyword_if), get(&keywords, "if"))
try testing.expect_equal(some!(TokenKind.keyword_else), get(&keywords, "else"))
try testing.expect_equal(some!(TokenKind.keyword_for), get(&keywords, "for"))
try testing.expect_equal(some!(TokenKind.keyword_return), get(&keywords, "return"))
try testing.expect_equal(null, get(&keywords, "no"))
try testing.expect_equal(null, get(&keywords, "four"))
try testing.expect_equal(null, get(&keywords, "longer-than-any-key"))
}
handles_empty_maps test {
empty StaticStringMap(TokenKind) = init([])
try testing.expect(empty.keys.len == 0)
try testing.expect(empty.values.len == 0)
try testing.expect(empty.len_indexes.len == 0)
try testing.expect_equal(null, get(&empty, "if"))
}
std/static_string_map/static_string_map.test.hon
View File