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

allow freeing immutable allocations

Browse Source
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-07-22 00:49:46 +02:00
parent 77696e19c9
commit 1d719c6a42
1 changed files with 20 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
std/mem/mem.hon
+20 -39
View File
@@ -28,29 +28,20 @@ raw_free func(allocator Allocator, memory ?*mut u8, size usize, alignment usize)
} }
eql func($T type, left, right []T) bool { eql func($T type, left, right []T) bool {
if left.len != right.len { if (left.len != right.len) return false
return false for (0..left.len) |i| if (left[i] != right[i]) {
} return false
i usize = 0
while i < left.len : i += 1 {
if left[i] != right[i] {
return false
}
} }
return true return true
} }
# allocate memory for a slice of type `T` with `count` elements. # allocate memory for a slice of type `T` with `count` elements.
alloc func($T type, allocator Allocator, count usize) []mut T ! AllocError { alloc func($T type, allocator Allocator, count usize) []mut T ! AllocError {
if count == 0 { if (count == 0) return empty_slice(T, 0)
return empty_slice(T, 0)
}
element_size usize :: sizeof!(T) element_size usize :: sizeof!(T)
if element_size == 0 { if (element_size == 0) return empty_slice(T, count)
return empty_slice(T, count)
}
if count > divtrunc!(maxval!(usize), element_size) { if count > divtrunc!(maxval!(usize), element_size) {
return .out_of_memory return .out_of_memory
} }
@@ -107,10 +98,14 @@ realloc func($T type, allocator Allocator, memory []mut T, new_count usize) []mu
# free memory allocated for a slice of type `T`. # free memory allocated for a slice of type `T`.
# note: memory must be freed with the same allocator that was used to allocate it. # note: memory must be freed with the same allocator that was used to allocate it.
free func($T type, allocator Allocator, memory []mut T) void { free func($T type, allocator Allocator, memory []T) void {
if memory.len != 0 and sizeof!(T) != 0 { if (memory.len == 0 or sizeof!(T) == 0) return
raw_free(allocator, ptrcast!(u8, memory.ptr), memory.len * sizeof!(T), alignof!(T)) raw_free(allocator, ptrcast!(
} u8,
constcast!(memory).ptr),
memory.len * sizeof!(T),
alignof!(T),
)
} }
# get an empty slice of type `T` with `count` elements. # get an empty slice of type `T` with `count` elements.
@@ -129,26 +124,18 @@ hide empty_storage [1]mut u64 = [0]
hide malloc_alignment usize :: 16 # ponytail: aarch64-macos libc malloc alignment assumption. hide malloc_alignment usize :: 16 # ponytail: aarch64-macos libc malloc alignment assumption.
hide power_of_two func(value usize) bool { hide power_of_two func(value usize) bool {
if value == 0 { if (value == 0) return false
return false
}
current usize = value current usize = value
while current > 1 { while current > 1 {
half usize = divtrunc!(current, 2) half usize = divtrunc!(current, 2)
if half * 2 != current { if (half * 2 != current) return false
return false
}
current = half current = half
} }
return true return true
} }
hide c_alloc func(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 { hide c_alloc func(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 {
if power_of_two(alignment) == false { if (power_of_two(alignment) == false) return null
return null
}
if alignment <= malloc_alignment { if alignment <= malloc_alignment {
return ptrcast!(u8, c.malloc(c_ulong(size))) return ptrcast!(u8, c.malloc(c_ulong(size)))
@@ -156,17 +143,13 @@ hide c_alloc func(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 {
memory [1]mut ?*mut anyopaque = [null] memory [1]mut ?*mut anyopaque = [null]
status c_int = c.posix_memalign((&memory).ptr, c_ulong(alignment), c_ulong(size)) status c_int = c.posix_memalign((&memory).ptr, c_ulong(alignment), c_ulong(size))
if status != 0 { if (status != 0) return null
return null
}
return ptrcast!(u8, memory[0]) return ptrcast!(u8, memory[0])
} }
hide c_realloc func(_ ?@mut anyopaque, memory ?*mut u8, old_size usize, new_size usize, alignment usize) ?*mut u8 { hide c_realloc func(_ ?@mut anyopaque, memory ?*mut u8, old_size usize, new_size usize, alignment usize) ?*mut u8 {
if power_of_two(alignment) == false { if (power_of_two(alignment) == false) return null
return null
}
if new_size == 0 { if new_size == 0 {
c.free(memory) c.free(memory)
@@ -181,9 +164,7 @@ hide c_realloc func(_ ?@mut anyopaque, memory ?*mut u8, old_size usize, new_size
new_memory ?*mut u8 = c_alloc(null, new_size, alignment) new_memory ?*mut u8 = c_alloc(null, new_size, alignment)
if new_memory |new_bytes| { if new_memory |new_bytes| {
copy_size usize = old_size copy_size usize = old_size
if new_size < copy_size { if (new_size < copy_size) copy_size = new_size
copy_size = new_size
}
memcopy!(new_bytes[..copy_size], old_memory[..copy_size]) memcopy!(new_bytes[..copy_size], old_memory[..copy_size])
c.free(old_memory) c.free(old_memory)
} }