mt-lang 0.2.0 → 0.2.1

data/std/mem/arena.mt

@@ -0,0 +1,137 @@
+import std.mem.heap as heap
+
+public type Mark = ptr_uint
+
+public struct Arena:
+    memory: own[ubyte]?
+    capacity: ptr_uint
+    alignment: ptr_uint
+    offset: ptr_uint
+
+
+public function create(capacity_bytes: ptr_uint) -> Arena:
+    return create_aligned(capacity_bytes, 1)
+
+
+public function create_aligned(capacity_bytes: ptr_uint, alignment: ptr_uint) -> Arena:
+    let normalized_alignment = heap.normalize_alignment(alignment)
+    if normalized_alignment == 0:
+        fatal(c"arena.create_aligned requires a power-of-two alignment")
+
+    let memory = heap.alloc_bytes_aligned(capacity_bytes, normalized_alignment) else:
+        if capacity_bytes != 0:
+            fatal(c"arena.create_aligned out of memory")
+
+        return Arena(
+            memory = null,
+            capacity = 0,
+            alignment = normalized_alignment,
+            offset = 0,
+        )
+
+    return unsafe: Arena(
+            memory = own[ubyte]<-memory,
+            capacity = capacity_bytes,
+            alignment = normalized_alignment,
+            offset = 0
+        )
+
+
+public function create_for[T](count: ptr_uint) -> Arena:
+    let element_size = ptr_uint<-size_of(T)
+    if heap.mul_overflows(count, element_size):
+        fatal(c"arena.create_for size overflow")
+
+    return create_aligned(count * element_size, align_of(T))
+
+
+extending Arena:
+    public function mark() -> Mark:
+        return this.offset
+
+
+    public editable function reset(mark: Mark) -> void:
+        if mark > this.offset:
+            fatal(c"arena.reset invalid mark")
+
+        this.offset = mark
+
+
+    public function remaining_bytes() -> ptr_uint:
+        return this.capacity - this.offset
+
+
+    public editable function alloc_bytes(size_bytes: ptr_uint) -> ptr[ubyte]?:
+        return this.alloc_bytes_aligned(size_bytes, 1)
+
+
+    public editable function alloc_bytes_aligned(size_bytes: ptr_uint, alignment: ptr_uint) -> ptr[ubyte]?:
+        let backing = this.memory else:
+            return null
+        if alignment == 0:
+            return null
+        if (alignment & (alignment - 1)) != 0:
+            return null
+        if alignment > this.alignment:
+            return null
+
+        let mask = alignment - 1
+        if this.offset > heap.ptr_uint_max - mask:
+            return null
+
+        let aligned_offset = (this.offset + mask) & ~mask
+        if aligned_offset > this.capacity:
+            return null
+        if size_bytes > this.capacity - aligned_offset:
+            return null
+
+        let result = backing + aligned_offset
+        this.offset = aligned_offset + size_bytes
+        return result
+
+
+    public editable function alloc[T](count: ptr_uint) -> ptr[T]?:
+        let element_size = ptr_uint<-size_of(T)
+        if heap.mul_overflows(count, element_size):
+            return null
+
+        let memory = this.alloc_bytes_aligned(count * element_size, ptr_uint<-align_of(T)) else:
+            return null
+
+        return unsafe: ptr[T]<-memory
+
+
+    public editable function try_to_cstr(text: str) -> cstr?:
+        if text.len == heap.ptr_uint_max:
+            return null
+
+        let memory = this.alloc_bytes(text.len + 1) else:
+            return null
+
+        unsafe:
+            heap.copy_bytes(memory, ptr[ubyte]<-text.data, text.len)
+            let buffer = ptr[char]<-memory
+            read(buffer + text.len) = zero[char]
+            return cstr<-buffer
+
+
+    public editable function to_cstr(text: str) -> cstr:
+        if text.len == heap.ptr_uint_max:
+            fatal(c"arena.to_cstr size overflow")
+
+        let memory = this.alloc_bytes(text.len + 1) else:
+            fatal(c"arena.to_cstr out of memory")
+
+        unsafe:
+            heap.copy_bytes(memory, ptr[ubyte]<-text.data, text.len)
+            let buffer = ptr[char]<-memory
+            read(buffer + text.len) = zero[char]
+            return cstr<-buffer
+
+
+    public editable function release() -> void:
+        heap.release(this.memory)
+        this.memory = null
+        this.capacity = 0
+        this.alignment = 0
+        this.offset = 0

data/std/mem/endian.mt

@@ -0,0 +1,51 @@
+public function swap_ushort(value: ushort) -> ushort:
+    return ushort<-(
+        ((uint<-value & 0x00ff) << 8) |
+        ((uint<-value & 0xff00) >> 8)
+    )
+
+
+public function swap_uint(value: uint) -> uint:
+    return (
+        ((value & 0x000000ff) << 24) |
+        ((value & 0x0000ff00) << 8) |
+        ((value & 0x00ff0000) >> 8) |
+        ((value & 0xff000000) >> 24)
+    )
+
+
+public function swap_ulong(value: ulong) -> ulong:
+    return (
+        ((value & 0x00000000000000fful) << 56) |
+        ((value & 0x000000000000ff00ul) << 40) |
+        ((value & 0x0000000000ff0000ul) << 24) |
+        ((value & 0x00000000ff000000ul) << 8) |
+        ((value & 0x000000ff00000000ul) >> 8) |
+        ((value & 0x0000ff0000000000ul) >> 24) |
+        ((value & 0x00ff000000000000ul) >> 40) |
+        ((value & 0xff00000000000000ul) >> 56)
+    )
+
+
+public function hton_ushort(value: ushort) -> ushort:
+    return swap_ushort(value)
+
+
+public function hton_uint(value: uint) -> uint:
+    return swap_uint(value)
+
+
+public function hton_ulong(value: ulong) -> ulong:
+    return swap_ulong(value)
+
+
+public function ntoh_ushort(value: ushort) -> ushort:
+    return swap_ushort(value)
+
+
+public function ntoh_uint(value: uint) -> uint:
+    return swap_uint(value)
+
+
+public function ntoh_ulong(value: ulong) -> ulong:
+    return swap_ulong(value)

data/std/mem/heap.mt

@@ -0,0 +1,298 @@
+import std.c.libc as libc
+import std.cstring as cstring
+
+public const ptr_uint_max: ptr_uint = ~0
+public const minimum_alignment: ptr_uint = size_of(ptr[void])
+
+
+function valid_alignment(alignment: ptr_uint) -> bool:
+    if alignment == 0:
+        return false
+
+    return (alignment & (alignment - 1)) == 0
+
+
+public function normalize_alignment(alignment: ptr_uint) -> ptr_uint:
+    if not valid_alignment(alignment):
+        return 0
+
+    let minimum = minimum_alignment
+    if alignment < minimum:
+        return minimum
+
+    return alignment
+
+
+public function mul_overflows(left: ptr_uint, right: ptr_uint) -> bool:
+    if left != 0 and right > ptr_uint_max / left:
+        return true
+
+    return false
+
+
+public function alloc_bytes(size_bytes: ptr_uint) -> ptr[void]?:
+    if size_bytes == 0:
+        return null
+
+    return libc.malloc(size_bytes)
+
+
+public function must_alloc_bytes(size_bytes: ptr_uint) -> ptr[void]:
+    if size_bytes == 0:
+        fatal(c"heap.must_alloc_bytes requires size > 0")
+
+    let memory = alloc_bytes(size_bytes) else:
+        fatal(c"heap.must_alloc_bytes out of memory")
+
+    return memory
+
+
+public function alloc_bytes_aligned(size_bytes: ptr_uint, alignment: ptr_uint) -> ptr[void]?:
+    if size_bytes == 0:
+        return null
+
+    let normalized_alignment = normalize_alignment(alignment)
+    if normalized_alignment == 0:
+        return null
+
+    let mask = normalized_alignment - 1
+    if size_bytes > ptr_uint_max - mask:
+        return null
+
+    let rounded_size = (size_bytes + mask) & ~mask
+    return libc.aligned_alloc(normalized_alignment, rounded_size)
+
+
+public function must_alloc_bytes_aligned(size_bytes: ptr_uint, alignment: ptr_uint) -> ptr[void]:
+    if size_bytes == 0:
+        fatal(c"heap.must_alloc_bytes_aligned requires size > 0")
+
+    let normalized_alignment = normalize_alignment(alignment)
+    if normalized_alignment == 0:
+        fatal(c"heap.must_alloc_bytes_aligned requires a power-of-two alignment")
+
+    let memory = alloc_bytes_aligned(size_bytes, normalized_alignment) else:
+        fatal(c"heap.must_alloc_bytes_aligned out of memory")
+
+    return memory
+
+
+public function alloc_zeroed_bytes(count: ptr_uint, element_size_bytes: ptr_uint) -> ptr[void]?:
+    if count == 0 or element_size_bytes == 0:
+        return null
+
+    if mul_overflows(count, element_size_bytes):
+        return null
+
+    return libc.calloc(count, element_size_bytes)
+
+
+public function must_alloc_zeroed_bytes(count: ptr_uint, element_size_bytes: ptr_uint) -> ptr[void]:
+    if count == 0 or element_size_bytes == 0:
+        fatal(c"heap.must_alloc_zeroed_bytes requires count > 0 and element size > 0")
+
+    let memory = alloc_zeroed_bytes(count, element_size_bytes) else:
+        fatal(c"heap.must_alloc_zeroed_bytes out of memory")
+
+    return memory
+
+
+public function copy_bytes(destination: ptr[ubyte]?, source: ptr[ubyte]?, size_bytes: ptr_uint) -> void:
+    if size_bytes == 0:
+        return
+
+    if destination == null or source == null:
+        fatal(c"heap.copy_bytes requires non-null pointers for non-empty copies")
+
+    var index: ptr_uint = 0
+    while index < size_bytes:
+        unsafe:
+            read(destination + index) = read(source + index)
+        index += 1
+
+
+public function move_bytes(destination: ptr[ubyte]?, source: ptr[ubyte]?, size_bytes: ptr_uint) -> void:
+    if size_bytes == 0:
+        return
+
+    if destination == null or source == null:
+        fatal(c"heap.move_bytes requires non-null pointers for non-empty copies")
+
+    unsafe:
+        cstring.move_bytes(ptr[void]<-destination, ptr[void]<-source, size_bytes)
+
+
+public function resize_bytes(memory: ptr[void]?, size_bytes: ptr_uint) -> ptr[void]?:
+    if size_bytes == 0:
+        release_bytes(memory)
+        return null
+
+    return libc.realloc(memory, size_bytes)
+
+
+public function must_resize_bytes(memory: ptr[void]?, size_bytes: ptr_uint) -> ptr[void]:
+    if size_bytes == 0:
+        fatal(c"heap.must_resize_bytes requires size > 0")
+
+    let resized = resize_bytes(memory, size_bytes) else:
+        fatal(c"heap.must_resize_bytes out of memory")
+
+    return resized
+
+
+## Frees a raw memory allocation. The caller's binding is NOT nulled after
+## this call — a second `release_bytes` on the same pointer is a double-free.
+## This is inherent to by-value pointer parameters: the function cannot reach
+## the caller's binding to null it. For idempotent safe-release syntax, see
+## `release_and_null[T]` or use a scope-bound allocator such as `arena.Arena`.
+public function release_bytes(memory: ptr[void]?) -> void:
+    libc.free(memory)
+
+
+public function alloc[T](count: ptr_uint) -> own[T]?:
+    let alignment = ptr_uint<-align_of(T)
+    if alignment > minimum_alignment:
+        return null
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        return null
+
+    let memory = alloc_bytes(count * element_size) else:
+        return null
+
+    return unsafe: own[T]<-memory
+
+
+public function must_alloc[T](count: ptr_uint) -> own[T]:
+    if count == 0:
+        fatal(c"heap.must_alloc requires count > 0")
+
+    if ptr_uint<-align_of(T) > minimum_alignment:
+        fatal(c"heap.must_alloc does not support over-aligned types")
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        fatal(c"heap.must_alloc size overflow")
+
+    let memory = alloc[T](count) else:
+        fatal(c"heap.must_alloc out of memory")
+
+    return memory
+
+
+public function alloc_aligned[T](count: ptr_uint) -> own[T]?:
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        return null
+
+    let memory = alloc_bytes_aligned(count * element_size, align_of(T)) else:
+        return null
+
+    return unsafe: own[T]<-memory
+
+
+public function must_alloc_aligned[T](count: ptr_uint) -> own[T]:
+    if count == 0:
+        fatal(c"heap.must_alloc_aligned requires count > 0")
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        fatal(c"heap.must_alloc_aligned size overflow")
+
+    let memory = alloc_aligned[T](count) else:
+        fatal(c"heap.must_alloc_aligned out of memory")
+
+    return memory
+
+
+public function alloc_zeroed[T](count: ptr_uint) -> own[T]?:
+    let alignment = ptr_uint<-align_of(T)
+    if alignment > minimum_alignment:
+        return null
+
+    let memory = alloc_zeroed_bytes(count, size_of(T)) else:
+        return null
+
+    return unsafe: own[T]<-memory
+
+
+public function must_alloc_zeroed[T](count: ptr_uint) -> own[T]:
+    if count == 0:
+        fatal(c"heap.must_alloc_zeroed requires count > 0")
+
+    if ptr_uint<-align_of(T) > minimum_alignment:
+        fatal(c"heap.must_alloc_zeroed does not support over-aligned types")
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        fatal(c"heap.must_alloc_zeroed size overflow")
+
+    let memory = alloc_zeroed[T](count) else:
+        fatal(c"heap.must_alloc_zeroed out of memory")
+
+    return memory
+
+
+public function resize[T](memory: ptr[T]?, count: ptr_uint) -> own[T]?:
+    let alignment = ptr_uint<-align_of(T)
+    if alignment > minimum_alignment:
+        return null
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        return null
+
+    if memory == null:
+        let resized = resize_bytes(null, count * element_size) else:
+            return null
+
+        return unsafe: own[T]<-resized
+
+    unsafe:
+        let resized = resize_bytes(ptr[void]<-memory, count * element_size) else:
+            return null
+
+        return own[T]<-resized
+
+
+public function must_resize[T](memory: ptr[T]?, count: ptr_uint) -> own[T]:
+    if count == 0:
+        fatal(c"heap.must_resize requires count > 0")
+
+    if ptr_uint<-align_of(T) > minimum_alignment:
+        fatal(c"heap.must_resize does not support over-aligned types")
+
+    let element_size = ptr_uint<-size_of(T)
+    if mul_overflows(count, element_size):
+        fatal(c"heap.must_resize size overflow")
+
+    let resized = resize[T](memory, count) else:
+        fatal(c"heap.must_resize out of memory")
+
+    return resized
+
+
+## Frees a typed heap allocation. The caller's binding is NOT nulled — a
+## second `release` on the same pointer is a double-free. Prefer
+## `release_and_null[T]` when you need the binding nulled after freeing,
+## or use a scope-bound allocator such as `arena.Arena` for bulk free.
+public function release[T](memory: ptr[T]?) -> void:
+    unsafe: release_bytes(ptr[void]<-memory)
+
+
+## Frees a typed heap allocation and nulls the caller's binding so a second
+## release is a no-op. The binding is passed by `ref[ptr[T]?]` so the helper
+## can write `null` back into the caller's variable.
+##
+##     var mem = heap.must_alloc[MyStruct](1)
+##     heap.release_and_null(ref_of(mem))       # mem is now null
+##     heap.release_and_null(ref_of(mem))       # safe — no-op
+public function release_and_null[T](memory: ref[ptr[T]?]) -> void:
+    unsafe: release_bytes(ptr[void]<-read(memory))
+    read(memory) = null
+
+
+public function bytes_of[T](value: ref[T]) -> span[ubyte]:
+    unsafe:
+        return span[ubyte](data = ptr[ubyte]<-ptr_of(value), len = size_of(T))

data/std/mem/pool.mt

@@ -0,0 +1,164 @@
+import std.mem.heap as heap
+
+
+function slot_alignment(slot_size_bytes: ptr_uint, base_alignment: ptr_uint) -> ptr_uint:
+    if slot_size_bytes == 0:
+        return base_alignment
+
+    var alignment = base_alignment
+    while alignment > 1 and (slot_size_bytes & (alignment - 1)) != 0:
+        alignment = alignment / 2
+
+    return alignment
+
+public struct Pool:
+    memory: ptr[ubyte]?
+    occupancy: ptr[bool]?
+    slot_size: ptr_uint
+    slot_alignment: ptr_uint
+    slot_count: ptr_uint
+    used_count: ptr_uint
+
+
+public function create(slot_size_bytes: ptr_uint, slot_count: ptr_uint) -> Pool:
+    return create_aligned(slot_size_bytes, slot_count, 1)
+
+
+public function create_aligned(slot_size_bytes: ptr_uint, slot_count: ptr_uint, alignment: ptr_uint) -> Pool:
+    let normalized_alignment = heap.normalize_alignment(alignment)
+    if normalized_alignment == 0:
+        fatal(c"pool.create_aligned requires a power-of-two alignment")
+
+    if slot_count == 0:
+        return Pool(
+            memory = null,
+            occupancy = null,
+            slot_size = slot_size_bytes,
+            slot_alignment = slot_alignment(slot_size_bytes, normalized_alignment),
+            slot_count = 0,
+            used_count = 0
+        )
+
+    if slot_size_bytes == 0:
+        fatal(c"pool.create_aligned requires slot size > 0 when slot count > 0")
+
+    if heap.mul_overflows(slot_size_bytes, slot_count):
+        fatal(c"pool.create size overflow")
+
+    let total_size = slot_size_bytes * slot_count
+    let memory = heap.alloc_bytes_aligned(total_size, normalized_alignment) else:
+        fatal(c"pool.create_aligned out of memory")
+
+    let occupancy = heap.alloc_zeroed[bool](slot_count) else:
+        heap.release_bytes(memory)
+        fatal(c"pool.create occupancy out of memory")
+
+    return unsafe: Pool(
+            memory = ptr[ubyte]<-memory,
+            occupancy = occupancy,
+            slot_size = slot_size_bytes,
+            slot_alignment = slot_alignment(slot_size_bytes, normalized_alignment),
+            slot_count = slot_count,
+            used_count = 0
+        )
+
+
+public function slot_size_for[T]() -> ptr_uint:
+    let size = ptr_uint<-size_of(T)
+    let alignment = ptr_uint<-align_of(T)
+    let mask = alignment - 1
+    if size > heap.ptr_uint_max - mask:
+        fatal(c"pool.slot_size_for overflow")
+
+    return (size + mask) & ~mask
+
+
+public function create_for[T](slot_count: ptr_uint) -> Pool:
+    return create_aligned(slot_size_for[T](), slot_count, align_of(T))
+
+
+extending Pool:
+    public function remaining_slots() -> ptr_uint:
+        return this.slot_count - this.used_count
+
+
+    public editable function alloc_bytes() -> ptr[ubyte]?:
+        let memory = this.memory else:
+            return null
+        let occupancy = this.occupancy else:
+            return null
+
+        var index: ptr_uint = 0
+        while index < this.slot_count:
+            unsafe:
+                let state_ptr = occupancy + index
+                if not (read(state_ptr)):
+                    read(state_ptr) = true
+                    this.used_count = this.used_count + 1
+                    return memory + (index * this.slot_size)
+            index = index + 1
+
+        return null
+
+
+    public editable function alloc[T]() -> ptr[T]?:
+        let size = ptr_uint<-size_of(T)
+        let alignment = ptr_uint<-align_of(T)
+        let mask = alignment - 1
+        if size > heap.ptr_uint_max - mask:
+            return null
+
+        let slot_size = (size + mask) & ~mask
+        if this.slot_alignment < alignment:
+            return null
+        if this.slot_size < slot_size:
+            return null
+
+        let memory = this.alloc_bytes() else:
+            return null
+
+        return unsafe: ptr[T]<-memory
+
+
+    public editable function release_bytes(slot: ptr[ubyte]?) -> bool:
+        if slot == null:
+            return false
+
+        let memory = this.memory else:
+            return false
+        let occupancy = this.occupancy else:
+            return false
+
+        var index: ptr_uint = 0
+        while index < this.slot_count:
+            unsafe:
+                let candidate = memory + (index * this.slot_size)
+                if candidate == slot:
+                    let state_ptr = occupancy + index
+                    if not (read(state_ptr)):
+                        return false
+
+                    read(state_ptr) = false
+                    this.used_count = this.used_count - 1
+                    return true
+            index = index + 1
+
+        return false
+
+
+    public editable function release_slot[T](slot: ptr[T]?) -> bool:
+        if slot == null:
+            return false
+
+        return unsafe: this.release_bytes(ptr[ubyte]<-slot)
+
+
+    public editable function release() -> void:
+        heap.release(this.memory)
+        heap.release(this.occupancy)
+        this.memory = null
+        this.occupancy = null
+        this.slot_size = 0
+        this.slot_alignment = 0
+        this.slot_count = 0
+        this.used_count = 0

data/std/mem/stack.mt

@@ -0,0 +1,47 @@
+import std.mem.arena as arena
+
+public type Mark = arena.Mark
+
+public struct Stack:
+    arena: arena.Arena
+
+
+public function create(capacity_bytes: ptr_uint) -> Stack:
+    return create_aligned(capacity_bytes, 1)
+
+
+public function create_aligned(capacity_bytes: ptr_uint, alignment: ptr_uint) -> Stack:
+    return Stack(arena = arena.create_aligned(capacity_bytes, alignment))
+
+
+public function create_for[T](count: ptr_uint) -> Stack:
+    return Stack(arena = arena.create_for[T](count))
+
+
+extending Stack:
+    public function mark() -> Mark:
+        return this.arena.mark()
+
+
+    public editable function reset(mark: Mark) -> void:
+        this.arena.reset(mark)
+
+
+    public function remaining_bytes() -> ptr_uint:
+        return this.arena.remaining_bytes()
+
+
+    public editable function alloc_bytes(size_bytes: ptr_uint) -> ptr[ubyte]?:
+        return this.arena.alloc_bytes(size_bytes)
+
+
+    public editable function alloc_bytes_aligned(size_bytes: ptr_uint, alignment: ptr_uint) -> ptr[ubyte]?:
+        return this.arena.alloc_bytes_aligned(size_bytes, alignment)
+
+
+    public editable function alloc[T](count: ptr_uint) -> ptr[T]?:
+        return this.arena.alloc[T](count)
+
+
+    public editable function release() -> void:
+        this.arena.release()