ed/WATL_Exercise
1
0
Fork 0
mirror of https://github.com/Ed94/WATL_Exercise.git synced 2025-08-04 22:32:43 -07:00
Code Issues Packages Projects Releases Wiki Activity

musing usage of slices in odin

Browse Source
This commit is contained in:
Edward R. Gonzalez
2025-07-19 16:58:13 -04:00
parent 39e04230d6
commit b1fecbfebc
2 changed files with 68 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
C/watl.v0.msvc.c
View File

@@ -450,7 +450,7 @@ void kt1l__populate_slice_a2(KT1L_Byte* kt, AllocatorInfo backing, KT1L_Meta m,
cast(KT1L_Byte*, kt), \ cast(KT1L_Byte*, kt), \
ainfo, \ ainfo, \
(KT1L_Meta){ \ (KT1L_Meta){ \
.slot_size = size_of(KT1L_Slot_Str8), \ .slot_size = size_of(tmpl(KT1L_Slot,type)), \
.kt_value_offset = offset_of(tmpl(KT1L_Slot,type), value), \ .kt_value_offset = offset_of(tmpl(KT1L_Slot,type), value), \
.type_width = size_of(type), \ .type_width = size_of(type), \
.type_name = lit(stringify(type)) \ .type_name = lit(stringify(type)) \
@@ -1085,7 +1085,7 @@ Slice_Byte varena__push(VArena* vm, SSIZE amount, SSIZE type_width, Opts_varena*
SSIZE current_offset = vm->reserve_start + vm->commit_used; SSIZE current_offset = vm->reserve_start + vm->commit_used;
SSIZE to_be_used = vm->commit_used + aligned_size; SSIZE to_be_used = vm->commit_used + aligned_size;
SSIZE reserve_left = vm->reserve - vm->commit_used; SSIZE reserve_left = vm->reserve - vm->commit_used;
SSIZE commit_left = vm->committed - vm->commit_used; SSIZE commit_left = vm->committed - vm->commit_used;
B32 exhausted = commit_left < to_be_used; B32 exhausted = commit_left < to_be_used;
assert(to_be_used < reserve_left); assert(to_be_used < reserve_left);
if (exhausted) if (exhausted)
@@ -1196,7 +1196,7 @@ void varena_allocator_proc(AllocatorProc_In in, AllocatorProc_Out* out)
} }
#pragma endregion VArena #pragma endregion VArena
#pragma region Arena (Casey-Ryan Composite Arena) #pragma region Arena (Chained Arena)
inline inline
Arena* arena__make(Opts_arena_make* opts) { Arena* arena__make(Opts_arena_make* opts) {
assert(opts != nullptr); assert(opts != nullptr);
@@ -1386,7 +1386,7 @@ void kt1l__populate_slice_a2(KT1L_Byte* kt, AllocatorInfo backing, KT1L_Meta m,
} }
kt->len = num_values; kt->len = num_values;
} }
#pragma endregion KT1l #pragma endregion KT1L
#pragma region Key Table 1-Layer Chained-Chunked_Cells (KT1CX) #pragma region Key Table 1-Layer Chained-Chunked_Cells (KT1CX)
inline inline
@@ -1663,14 +1663,14 @@ Str8 str8__fmt_kt1l(AllocatorInfo ainfo, Slice_Byte buffer, KT1L_Str8 table, Str
inline inline
Str8 str8__fmt_backed(AllocatorInfo tbl_backing, AllocatorInfo buf_backing, Str8 fmt_template, Slice_A2_Str8* entries) { Str8 str8__fmt_backed(AllocatorInfo tbl_backing, AllocatorInfo buf_backing, Str8 fmt_template, Slice_A2_Str8* entries) {
KT1L_Str8 kt; kt1l_populate_slice_a2(Str8, & kt, tbl_backing, *entries ); KT1L_Str8 kt; kt1l_populate_slice_a2(Str8, & kt, tbl_backing, *entries );
SSIZE buf_size = kilo(32); SSIZE buf_size = kilo(64);
Slice_Byte buffer = mem_alloc(buf_backing, buf_size); Slice_Byte buffer = mem_alloc(buf_backing, buf_size);
Str8 result = str8__fmt_kt1l(buf_backing, buffer, kt, fmt_template); Str8 result = str8__fmt_kt1l(buf_backing, buffer, kt, fmt_template);
return result; return result;
} }
Str8 str8__fmt(Str8 fmt_template, Slice_A2_Str8* entries) { Str8 str8__fmt(Str8 fmt_template, Slice_A2_Str8* entries) {
local_persist Byte tbl_mem[kilo(32)]; FArena tbl_arena = farena_make(slice_fmem(tbl_mem)); local_persist Byte tbl_mem[kilo(32)]; FArena tbl_arena = farena_make(slice_fmem(tbl_mem));
local_persist Byte buf_mem[kilo(128)]; local_persist Byte buf_mem[kilo(64)];
KT1L_Str8 kt = {0}; kt1l_populate_slice_a2(Str8, & kt, ainfo_farena(tbl_arena), *entries ); KT1L_Str8 kt = {0}; kt1l_populate_slice_a2(Str8, & kt, ainfo_farena(tbl_arena), *entries );
Str8 result = str8__fmt_kt1l((AllocatorInfo){0}, slice_fmem(buf_mem), kt, fmt_template); Str8 result = str8__fmt_kt1l((AllocatorInfo){0}, slice_fmem(buf_mem), kt, fmt_template);
return result; return result;

111
Odin/watl.v0.odin
View File

@@ -100,10 +100,17 @@ memory_copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -
return dst return dst
} }
Raw_Slice :: struct { SliceBytes :: struct {
data: rawptr, data: [^]byte,
len: int
}
SliceRaw :: struct ($Type: typeid) {
data: [^]Type,
len: int, len: int,
} }
slice_cursor :: proc "contextless" (s : $SliceType / []$Type) -> [^]Type {
return transmute([^]Type) raw_data(s)
}
slice_assert :: proc (s: $SliceType / []$Type) { slice_assert :: proc (s: $SliceType / []$Type) {
assert(len(s) > 0) assert(len(s) > 0)
assert(s != nil) assert(s != nil)
@@ -111,10 +118,16 @@ slice_assert :: proc (s: $SliceType / []$Type) {
slice_end :: proc "contextless" (s : $SliceType / []$Type) -> ^Type { slice_end :: proc "contextless" (s : $SliceType / []$Type) -> ^Type {
return & s[len(s) - 1] return & s[len(s) - 1]
} }
slice :: proc "contextless" (s: [^] $Type, num: int) -> []Type {
return transmute([]Type) SliceRaw { s, num }
}
@(require_results) @(require_results)
slice_to_bytes :: proc "contextless" (s: []$Type) -> []byte { slice_to_bytes :: proc "contextless" (s: []$Type) -> []byte {
return ([^]byte)(raw_data(s))[:len(s) * size_of(Type)] return ([^]byte)(raw_data(s))[:len(s) * size_of(Type)]
} }
slice_raw :: proc "contextless" (s: []$Type) -> SliceRaw(Type) {
return transmute(SliceRaw(Type)) s
}
slice_zero :: proc "contextless" (data: $SliceType / []$Type) { slice_zero :: proc "contextless" (data: $SliceType / []$Type) {
zero(raw_data(data), size_of(Type) * len(data)) zero(raw_data(data), size_of(Type) * len(data))
} }
@@ -357,7 +370,7 @@ farena_push :: proc(arena: ^FArena, $Type: typeid, amount: int, alignment: int =
assert(to_commit <= unused) assert(to_commit <= unused)
ptr := raw_data(arena.mem[arena.used:]) ptr := raw_data(arena.mem[arena.used:])
arena.used += to_commit arena.used += to_commit
return transmute([]Type) Raw_Slice { data = ptr, len = amount } return transmute([]Type) SliceBytes { data = ptr, len = amount }
} }
farena_reset :: proc(arena: ^FArena) { farena_reset :: proc(arena: ^FArena) {
arena.used = 0 arena.used = 0
@@ -412,7 +425,7 @@ farena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
break break
} }
arena.used += aligned_grow arena.used += aligned_grow
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size len = input.requested_size
} }
@@ -430,7 +443,7 @@ farena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
arena_end := uintptr(raw_data(arena.mem)) + uintptr(arena.used) arena_end := uintptr(raw_data(arena.mem)) + uintptr(arena.used)
if alloc_end != arena_end { if alloc_end != arena_end {
// Not at the end, can't shrink but return adjusted size // Not at the end, can't shrink but return adjusted size
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size len = input.requested_size
} }
@@ -440,7 +453,7 @@ farena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
aligned_original := align_pow2(len(input.old_allocation), MEMORY_ALIGNMENT_DEFAULT) aligned_original := align_pow2(len(input.old_allocation), MEMORY_ALIGNMENT_DEFAULT)
aligned_new := align_pow2(input.requested_size, input.alignment) aligned_new := align_pow2(input.requested_size, input.alignment)
arena.used -= (aligned_original - aligned_new) arena.used -= (aligned_original - aligned_new)
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size len = input.requested_size
} }
@@ -624,8 +637,8 @@ varena_push :: proc(va: ^VArena, $Type: typeid, amount: int, alignment: int = ME
} }
} }
va.commit_used = to_be_used va.commit_used = to_be_used
return transmute([]Type) Raw_Slice { return transmute([]Type) SliceBytes {
data = rawptr(uintptr(current_offset)), data = transmute([^]byte) uintptr(current_offset),
len = amount len = amount
} }
} }
@@ -649,7 +662,7 @@ varena_shrink :: proc(va: ^VArena, old_allocation: []byte, requested_size: int,
} }
assert(raw_data(old_allocation) == rawptr(uintptr(current_offset))) assert(raw_data(old_allocation) == rawptr(uintptr(current_offset)))
va.commit_used -= shrink_amount va.commit_used -= shrink_amount
return transmute([]byte) Raw_Slice { return transmute([]byte) SliceBytes {
data = raw_data(old_allocation), data = raw_data(old_allocation),
len = requested_size len = requested_size
} }
@@ -687,7 +700,7 @@ varena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
allocation := slice_to_bytes(varena_push(vm, byte, grow_amount, input.alignment)) allocation := slice_to_bytes(varena_push(vm, byte, grow_amount, input.alignment))
assert(raw_data(allocation) != nil) assert(raw_data(allocation) != nil)
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size len = input.requested_size
} }
@@ -704,7 +717,7 @@ varena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
} }
assert(raw_data(input.old_allocation) == rawptr(uintptr(current_offset))) assert(raw_data(input.old_allocation) == rawptr(uintptr(current_offset)))
vm.commit_used -= shrink_amount vm.commit_used -= shrink_amount
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size len = input.requested_size
} }
@@ -725,7 +738,7 @@ varena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Ou
} }
//endregion VArena //endregion VArena
//region Arena (Casey-Ryan Composite Arena) //region Arena (Chained Arena)
ArenaFlag :: enum u32 { ArenaFlag :: enum u32 {
No_Large_Pages, No_Large_Pages,
No_Chaining, No_Chaining,
@@ -772,12 +785,12 @@ arena_push :: proc(arena: ^Arena, $Type: typeid, amount: int, alignment: int = M
new_arena.prev = active new_arena.prev = active
active = arena.current active = arena.current
} }
result_ptr := rawptr(uintptr(active) + uintptr(pos_pre)) result_ptr := transmute([^]byte) (uintptr(active) + uintptr(pos_pre))
vresult := varena_push(active.backing, byte, size_aligned, alignment) vresult := varena_push(active.backing, byte, size_aligned, alignment)
slice_assert(vresult) slice_assert(vresult)
assert(raw_data(vresult) == result_ptr) assert(raw_data(vresult) == result_ptr)
active.pos = pos_pst active.pos = pos_pst
return transmute([]Type) Raw_Slice { data = result_ptr, len = amount } return transmute([]Type) SliceBytes { data = result_ptr, len = amount }
} }
arena_release :: proc(arena: ^Arena) { arena_release :: proc(arena: ^Arena) {
assert(arena != nil) assert(arena != nil)
@@ -848,7 +861,7 @@ arena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Out
vresult := varena_push(active.backing, byte, aligned_grow, input.alignment) vresult := varena_push(active.backing, byte, aligned_grow, input.alignment)
if len(vresult) > 0 { if len(vresult) > 0 {
active.pos += aligned_grow active.pos += aligned_grow
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size, len = input.requested_size,
} }
@@ -883,7 +896,7 @@ arena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Out
arena_end := uintptr(active) + uintptr(active.pos) arena_end := uintptr(active) + uintptr(active.pos)
if alloc_end != arena_end { if alloc_end != arena_end {
// Not at the end, can't shrink but return adjusted size // Not at the end, can't shrink but return adjusted size
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size, len = input.requested_size,
} }
@@ -895,7 +908,7 @@ arena_allocator_proc :: proc(input: AllocatorProc_In, output: ^AllocatorProc_Out
pos_reduction := aligned_original - aligned_new pos_reduction := aligned_original - aligned_new
active.pos -= pos_reduction active.pos -= pos_reduction
varena_shrink(active.backing, input.old_allocation, input.requested_size, input.alignment) varena_shrink(active.backing, input.old_allocation, input.requested_size, input.alignment)
output.allocation = transmute([]byte) Raw_Slice { output.allocation = transmute([]byte) SliceBytes {
data = raw_data(input.old_allocation), data = raw_data(input.old_allocation),
len = input.requested_size, len = input.requested_size,
} }
@@ -942,16 +955,16 @@ kt1l_populate_slice_a2_Slice_Byte :: proc(kt: ^[]byte, backing: AllocatorInfo, v
table_size_bytes := num_values * int(m.slot_size) table_size_bytes := num_values * int(m.slot_size)
kt^ = mem_alloc(backing, table_size_bytes) kt^ = mem_alloc(backing, table_size_bytes)
slice_assert(kt ^) slice_assert(kt ^)
kt_raw : Raw_Slice = transmute(Raw_Slice) kt^ kt_raw : SliceBytes = transmute(SliceBytes) kt^
for cursor in 0 ..< cast(uintptr) num_values { for cursor in 0 ..< cast(uintptr) num_values {
slot_offset := cursor * m.slot_size slot_offset := cursor * m.slot_size
slot_cursor := uintptr(kt_raw.data) + slot_offset slot_cursor := kt_raw.data[slot_offset:]
slot_key := cast(^u64) slot_cursor slot_key := cast(^u64) slot_cursor
slot_value := transmute([]byte) Raw_Slice { cast([^]byte) (slot_cursor + m.kt_value_offset), int(m.type_width)} slot_value := transmute([]byte) SliceBytes { slot_cursor[m.kt_value_offset:], int(m.type_width)}
a2_offset := cursor * m.type_width * 2 a2_offset := cursor * m.type_width * 2
a2_cursor := uintptr(& values[a2_offset]) a2_cursor := slice_cursor(values)[a2_offset:]
a2_key := (transmute(^[]byte) a2_cursor) ^ a2_key := (transmute(^[]byte) a2_cursor) ^
a2_value := transmute([]byte) Raw_Slice { rawptr(a2_cursor + m.type_width), int(m.type_width) } a2_value := transmute([]byte) SliceBytes { a2_cursor[m.type_width:], int(m.type_width) }
copy(slot_value, a2_value) copy(slot_value, a2_value)
slot_key^ = 0; hash64_djb8(slot_key, a2_key) slot_key^ = 0; hash64_djb8(slot_key, a2_key)
} }
@@ -959,7 +972,7 @@ kt1l_populate_slice_a2_Slice_Byte :: proc(kt: ^[]byte, backing: AllocatorInfo, v
} }
kt1l_populate_slice_a2 :: proc($Type: typeid, kt: ^[]KT1L_Slot(Type), backing: AllocatorInfo, values: [][2]Type) { kt1l_populate_slice_a2 :: proc($Type: typeid, kt: ^[]KT1L_Slot(Type), backing: AllocatorInfo, values: [][2]Type) {
assert(kt != nil) assert(kt != nil)
values_bytes := transmute([]byte) Raw_Slice{data = raw_data(values), len = len(values) * size_of([2]Type)} values_bytes := transmute([]byte) SliceBytes{data = raw_data(values), len = len(values) * size_of([2]Type)}
kt1l_populate_slice_a2_Slice_Byte(transmute(^[]byte) kt, backing, values_bytes, len(values), { kt1l_populate_slice_a2_Slice_Byte(transmute(^[]byte) kt, backing, values_bytes, len(values), {
slot_size = size_of(KT1L_Slot(Type)), slot_size = size_of(KT1L_Slot(Type)),
kt_value_offset = offset_of(KT1L_Slot(Type), KT1L_Slot(Type).value), kt_value_offset = offset_of(KT1L_Slot(Type), KT1L_Slot(Type).value),
@@ -1026,7 +1039,7 @@ kt1cx_init :: proc(info: KT1CX_Info, m: KT1CX_InfoMeta, result: ^KT1CX_Byte) {
assert(m.cell_pool_size >= 4 * Kilo) assert(m.cell_pool_size >= 4 * Kilo)
assert(m.table_size >= 4 * Kilo) assert(m.table_size >= 4 * Kilo)
assert(m.type_width > 0) assert(m.type_width > 0)
table_raw := transmute(Raw_Slice) mem_alloc(info.backing_table, m.table_size * m.cell_size) table_raw := transmute(SliceBytes) mem_alloc(info.backing_table, m.table_size * m.cell_size)
result.cell_pool = mem_alloc(info.backing_cells, m.cell_pool_size * m.cell_size) result.cell_pool = mem_alloc(info.backing_cells, m.cell_pool_size * m.cell_size)
slice_assert(result.cell_pool) slice_assert(result.cell_pool)
table_raw.len = m.table_size table_raw.len = m.table_size
@@ -1034,26 +1047,26 @@ kt1cx_init :: proc(info: KT1CX_Info, m: KT1CX_InfoMeta, result: ^KT1CX_Byte) {
slice_assert(result.table) slice_assert(result.table)
} }
kt1cx_clear :: proc(kt: KT1CX_Byte, m: KT1CX_ByteMeta) { kt1cx_clear :: proc(kt: KT1CX_Byte, m: KT1CX_ByteMeta) {
cursor := cast(uintptr) raw_data(kt.table) cursor := slice_cursor(kt.table)
num_cells := len(kt.table) num_cells := len(kt.table)
table_len := len(kt.table) * m.cell_size table_len := len(kt.table) * m.cell_size
for ; cursor != cast(uintptr) end(kt.table); cursor += cast(uintptr) m.cell_size for ; cursor != end(kt.table); cursor = cursor[m.cell_size:]
{ {
cell := Raw_Slice { rawptr(cursor), m.cell_size } cell := SliceBytes { cursor, m.cell_size }
slots := Raw_Slice { cell.data, m.cell_depth * m.slot_size } slots := SliceBytes { cell.data, m.cell_depth * m.slot_size }
slot_cursor := uintptr(slots.data) slot_cursor := slots.data
for;; { for;; {
slot := transmute([]byte) Raw_Slice { rawptr(slot_cursor), m.slot_size } slot := transmute([]byte) SliceBytes { slot_cursor, m.slot_size }
zero(slot) zero(slot)
if slot_cursor == cast(uintptr) end(transmute([]byte) slots) { if slot_cursor == end(transmute([]byte) slots) {
next := cast(rawptr) (slot_cursor + uintptr(m.cell_next_offset)) next := slot_cursor[m.cell_next_offset:]
if next != nil { if next != nil {
slots.data = next slots.data = next
slot_cursor = uintptr(next) slot_cursor = next
continue continue
} }
} }
slot_cursor += uintptr(m.slot_size) slot_cursor = slot_cursor[m.slot_size:]
} }
} }
} }
@@ -1064,22 +1077,22 @@ kt1cx_slot_id :: proc(kt: KT1CX_Byte, key: u64, m: KT1CX_ByteMeta) -> u64 {
kt1cx_get :: proc(kt: KT1CX_Byte, key: u64, m: KT1CX_ByteMeta) -> ^byte { kt1cx_get :: proc(kt: KT1CX_Byte, key: u64, m: KT1CX_ByteMeta) -> ^byte {
hash_index := kt1cx_slot_id(kt, key, m) hash_index := kt1cx_slot_id(kt, key, m)
cell_offset := uintptr(hash_index) * uintptr(m.cell_size) cell_offset := uintptr(hash_index) * uintptr(m.cell_size)
cell := Raw_Slice {& kt.table[cell_offset], m.cell_size} cell := SliceBytes {& kt.table[cell_offset], m.cell_size}
{ {
slots := Raw_Slice {cell.data, m.cell_depth * m.slot_size} slots := SliceBytes {cell.data, m.cell_depth * m.slot_size}
slot_cursor := uintptr(slots.data) slot_cursor := slots.data
for;; for;;
{ {
slot := transmute(^KT1CX_Byte_Slot) (slot_cursor + m.slot_key_offset) slot := transmute(^KT1CX_Byte_Slot) slot_cursor[m.slot_key_offset:]
if slot.occupied && slot.key == key { if slot.occupied && slot.key == key {
return cast(^byte) slot_cursor return cast(^byte) slot_cursor
} }
if slot_cursor == cast(uintptr) end(transmute([]byte) slots) if slot_cursor == end(transmute([]byte) slots)
{ {
cell_next := cast(rawptr) (uintptr(cell.data) + m.cell_next_offset) cell_next := cell.data[m.cell_next_offset:]
if cell_next != nil { if cell_next != nil {
slots.data = cell_next slots.data = cell_next
slot_cursor = uintptr(cell_next) slot_cursor = cell_next
cell.data = cell_next cell.data = cell_next
continue continue
} }
@@ -1087,16 +1100,16 @@ kt1cx_get :: proc(kt: KT1CX_Byte, key: u64, m: KT1CX_ByteMeta) -> ^byte {
return nil return nil
} }
} }
slot_cursor += uintptr(m.slot_size) slot_cursor = slot_cursor[m.slot_size:]
} }
} }
} }
kt1cx_set :: proc(kt: KT1CX_Byte, key: u64, value: []byte, backing_cells: AllocatorInfo, m: KT1CX_ByteMeta) -> ^byte { kt1cx_set :: proc(kt: KT1CX_Byte, key: u64, value: []byte, backing_cells: AllocatorInfo, m: KT1CX_ByteMeta) -> ^byte {
hash_index := kt1cx_slot_id(kt, key, m) hash_index := kt1cx_slot_id(kt, key, m)
cell_offset := uintptr(hash_index) * uintptr(m.cell_size) cell_offset := uintptr(hash_index) * uintptr(m.cell_size)
cell := Raw_Slice{& kt.table[cell_offset], m.cell_size} cell := SliceBytes{& kt.table[cell_offset], m.cell_size}
{ {
slots := Raw_Slice {cell.data, m.cell_depth * m.slot_size} slots := SliceBytes {cell.data, m.cell_depth * m.slot_size}
slot_cursor := uintptr(slots.data) slot_cursor := uintptr(slots.data)
for ;; for ;;
{ {
@@ -1222,11 +1235,11 @@ str8_fmt_kt1l :: proc(ainfo: AllocatorInfo, buffer: []byte, table: []KT1L_Slot(s
if ainfo.procedure != nil { if ainfo.procedure != nil {
assert(.Grow in allocator_query(ainfo).features) assert(.Grow in allocator_query(ainfo).features)
} }
cursor_buffer := uintptr(raw_data(buffer)) cursor_buffer := transmute(uintptr) raw_data(buffer)
buffer_remaining := len(buffer) buffer_remaining := len(buffer)
curr_code := fmt_template[0] curr_code := fmt_template[0]
cursor_fmt := cast(uintptr) raw_data(fmt_template) cursor_fmt := transmute(uintptr) raw_data(fmt_template)
left_fmt := len(fmt_template) left_fmt := len(fmt_template)
for ; left_fmt > 0 && buffer_remaining > 0; for ; left_fmt > 0 && buffer_remaining > 0;
{ {
@@ -1241,7 +1254,7 @@ str8_fmt_kt1l :: proc(ainfo: AllocatorInfo, buffer: []byte, table: []KT1L_Slot(s
} }
if curr_code == '<' if curr_code == '<'
{ {
// cursor_potential_token := transmute([^]u8) (cursor_fmt + 1)
} }
} }
return {} return {}
@@ -1292,8 +1305,8 @@ str8gen_init :: proc(gen: ^Str8Gen, ainfo: AllocatorInfo) {
} }
str8gen_make :: proc(ainfo: AllocatorInfo) -> Str8Gen { gen: Str8Gen; str8gen_init(& gen, ainfo); return gen } str8gen_make :: proc(ainfo: AllocatorInfo) -> Str8Gen { gen: Str8Gen; str8gen_init(& gen, ainfo); return gen }
str8gen_to_bytes :: proc(gen: Str8Gen) -> []byte { return transmute([]byte) Raw_Slice {data = gen.ptr, len = gen.len} } str8gen_to_bytes :: proc(gen: Str8Gen) -> []byte { return transmute([]byte) SliceBytes {data = gen.ptr, len = gen.len} }
str8_from_str8gen :: proc(gen: Str8Gen) -> string { return transmute(string) Raw_Slice {data = gen.ptr, len = gen.len} } str8_from_str8gen :: proc(gen: Str8Gen) -> string { return transmute(string) SliceBytes {data = gen.ptr, len = gen.len} }
str8gen_append_str8 :: proc(gen: ^Str8Gen, str: string) { str8gen_append_str8 :: proc(gen: ^Str8Gen, str: string) {
} }