mt-lang 0.2.0 → 0.2.1

data/std/async/mailbox.mt

@@ -0,0 +1,191 @@
+import std.async as aio
+import std.async.libuv_runtime as aio_backend
+import std.deque as deque
+import std.libuv as libuv
+import std.mem.heap as heap
+import std.str as text
+import std.string as string
+import std.sync as sync
+import std.vec as vec
+
+type NativeHandle = libuv.uv_handle_t
+type NativeAsyncHandle = libuv.uv_async_t
+
+public struct Error:
+    code: int
+    message: string.String
+
+public struct Mailbox[T]:
+    state: ptr[MailboxState[T]]?
+
+struct MailboxStateBase:
+    destroy: fn(state_frame: ptr[void]) -> void
+
+struct MailboxState[T]:
+    destroy: fn(state_frame: ptr[void]) -> void
+    mutex: sync.Mutex
+    queue: deque.Deque[T]
+    handle: ptr[NativeAsyncHandle]?
+    closing: bool
+
+
+function libuv_error(code: int) -> Error:
+    return Error(code = code, message = string.String.from_str(text.cstr_as_str(libuv.strerror(code))))
+
+
+function mailbox_error(message: str) -> Error:
+    return Error(code = -1, message = string.String.from_str(message))
+
+
+function async_as_handle(handle: ptr[NativeAsyncHandle]) -> ptr[NativeHandle]:
+    return unsafe: ptr[NativeHandle]<-handle
+
+
+function handle_as_async(handle: ptr[NativeHandle]) -> ptr[NativeAsyncHandle]:
+    return unsafe: ptr[NativeAsyncHandle]<-handle
+
+
+function mailbox_async_callback(handle: ptr[NativeAsyncHandle]) -> void:
+    unsafe: handle
+
+
+function mailbox_destroy_state[T](state_frame: ptr[void]) -> void:
+    let state = unsafe: ptr[MailboxState[T]]<-state_frame
+
+    var mutex = unsafe: read(state).mutex
+    mutex.release()
+
+    var queue = unsafe: read(state).queue
+    queue.release()
+
+    heap.release(state)
+
+
+function mailbox_close_callback(handle: ptr[NativeHandle]) -> void:
+    let state_raw = libuv.handle_get_data(handle) else:
+        unsafe: heap.release_bytes(ptr[void]<-handle_as_async(handle))
+        return
+
+    unsafe:
+        heap.release_bytes(ptr[void]<-handle_as_async(handle))
+
+    let state_base = unsafe: ptr[MailboxStateBase]<-state_raw
+    unsafe: read(state_base).destroy(state_raw)
+
+
+function alloc_async_handle() -> ptr[NativeAsyncHandle]:
+    let handle_size = libuv.handle_size(libuv.uv_handle_type.UV_ASYNC)
+    return unsafe: ptr[NativeAsyncHandle]<-heap.must_alloc_zeroed_bytes(1, handle_size)
+
+
+public function create_on[T](runtime: aio.Runtime) -> Result[Mailbox[T], Error]:
+    let mutex_result = sync.create_mutex()
+    match mutex_result:
+        Result.failure as payload:
+            return Result[Mailbox[T], Error].failure(error = Error(
+                code = payload.error.code,
+                message = payload.error.message
+            ))
+        Result.success as payload:
+            let loop = aio_backend.runtime_loop(runtime)
+            let handle = alloc_async_handle()
+            let state = heap.must_alloc_zeroed[MailboxState[T]](1)
+            unsafe:
+                state.destroy = mailbox_destroy_state[T]
+                state.mutex = payload.value
+                state.queue = deque.Deque[T].create()
+                state.handle = handle
+                state.closing = false
+                libuv.handle_set_data(async_as_handle(handle), ptr[void]<-state)
+
+            let status_code = libuv.async_init(loop, handle, mailbox_async_callback)
+            if status_code != 0:
+                payload.value.release()
+                unsafe: heap.release_bytes(ptr[void]<-handle)
+                heap.release(state)
+                return Result[Mailbox[T], Error].failure(error = libuv_error(status_code))
+
+            return Result[Mailbox[T], Error].success(value = Mailbox[T](state = state))
+
+
+public function create[T]() -> Result[Mailbox[T], Error]:
+    return create_on[T](aio.current_runtime())
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending Mailbox[T]:
+    public editable function release() -> void:
+        let state = this.state else:
+            return
+
+        this.state = null
+
+        let handle = unsafe: read(state).handle else:
+            mailbox_destroy_state[T](unsafe: ptr[void]<-state)
+            return
+
+        unsafe: read(state).closing = true
+        libuv.close(async_as_handle(handle), mailbox_close_callback)
+
+
+    public function send(value: T) -> Result[bool, Error]:
+        let state = this.state else:
+            return Result[bool, Error].failure(error = mailbox_error("mailbox is released"))
+
+        var mutex = unsafe: read(state).mutex
+        mutex.lock()
+        defer mutex.unlock()
+
+        let handle = unsafe: read(state).handle else:
+            return Result[bool, Error].failure(error = mailbox_error("mailbox is closed"))
+
+        if unsafe: read(state).closing:
+            return Result[bool, Error].failure(error = mailbox_error("mailbox is closed"))
+
+        unsafe: read(state).queue.push_back(value)
+        let status_code = libuv.async_send(handle)
+        if status_code != 0:
+            let _ = unsafe: read(state).queue.pop_back()
+            return Result[bool, Error].failure(error = libuv_error(status_code))
+
+        return Result[bool, Error].success(value = true)
+
+
+    public function try_recv() -> Option[T]:
+        let state = this.state else:
+            return Option[T].none
+
+        var mutex = unsafe: read(state).mutex
+        mutex.lock()
+        defer mutex.unlock()
+        return unsafe: read(state).queue.pop_front()
+
+
+    public function drain() -> vec.Vec[T]:
+        let state = this.state else:
+            return vec.Vec[T].create()
+
+        var mutex = unsafe: read(state).mutex
+        mutex.lock()
+        defer mutex.unlock()
+
+        var drained = vec.Vec[T].with_capacity(unsafe: read(state).queue.len())
+        while true:
+            let message = unsafe: read(state).queue.pop_front()
+            if message.is_none():
+                return drained
+            drained.push(message.unwrap())
+
+
+    public function is_empty() -> bool:
+        let state = this.state else:
+            return true
+
+        var mutex = unsafe: read(state).mutex
+        mutex.lock()
+        defer mutex.unlock()
+        return unsafe: read(state).queue.is_empty()

data/std/async/runtime.mt

@@ -0,0 +1,87 @@
+import std.async.libuv_runtime as backend
+
+public type Runtime = backend.Runtime
+
+
+public function runtime_create() -> Runtime:
+    return backend.runtime_create()
+
+
+public function runtime_activate(runtime: Runtime) -> void:
+    backend.runtime_activate(runtime)
+
+
+public function runtime_deactivate() -> void:
+    backend.runtime_deactivate()
+
+
+public function runtime_release(runtime: ref[Runtime]) -> void:
+    backend.runtime_release(runtime)
+
+
+public function runtime_poll(runtime: Runtime) -> int:
+    return backend.runtime_poll(runtime)
+
+
+public function sleep(timeout: ptr_uint) -> Task[int]:
+    return backend.sleep(timeout)
+
+
+public function create_runtime() -> Result[Runtime, int]:
+    return backend.create_runtime()
+
+
+public function release_runtime(runtime: ref[Runtime]) -> int:
+    return backend.release_runtime(runtime)
+
+
+public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
+    return backend.sleep_on(runtime, timeout)
+
+
+public function work[T](run_work: fn() -> T) -> Task[T]:
+    return backend.work[T](run_work)
+
+
+public function current_runtime() -> Runtime:
+    return backend.current_runtime_handle()
+
+
+public function work_on[T](runtime: Runtime, run_work: fn() -> T) -> Task[T]:
+    return backend.work_on[T](runtime, run_work)
+
+
+public function pump(runtime: Runtime) -> void:
+    backend.pump(runtime)
+
+
+public function completed[T](task: Task[T]) -> bool:
+    return backend.completed[T](task)
+
+
+public function result[T](task: Task[T]) -> T:
+    return backend.result[T](task)
+
+
+public function wait_on[T](runtime: Runtime, task: Task[T]) -> T:
+    return backend.wait_on[T](runtime, task)
+
+
+public function run_on(runtime: Runtime, task: Task[void]) -> void:
+    backend.run_on(runtime, task)
+
+
+public function wait[T](root: proc() -> Task[T]) -> T:
+    return backend.wait[T](root)
+
+
+public function run(root: proc() -> Task[void]) -> void:
+    backend.run(root)
+
+
+public function with_runtime[T](body: proc(runtime: Runtime) -> T) -> T:
+    return backend.with_runtime[T](body)
+
+
+public function run_with_runtime(body: proc(runtime: Runtime) -> void) -> void:
+    backend.run_with_runtime(body)

data/std/async.mt

@@ -0,0 +1,87 @@
+import std.async.runtime as backend
+
+public type Runtime = backend.Runtime
+
+
+function runtime_create() -> Runtime:
+    return backend.runtime_create()
+
+
+function runtime_activate(runtime: Runtime) -> void:
+    backend.runtime_activate(runtime)
+
+
+function runtime_deactivate() -> void:
+    backend.runtime_deactivate()
+
+
+function runtime_release(runtime: ref[Runtime]) -> void:
+    backend.runtime_release(runtime)
+
+
+function runtime_poll(runtime: Runtime) -> int:
+    return backend.runtime_poll(runtime)
+
+
+public function sleep(timeout: ptr_uint) -> Task[int]:
+    return backend.sleep(timeout)
+
+
+public function create_runtime() -> Result[Runtime, int]:
+    return backend.create_runtime()
+
+
+public function release_runtime(runtime: ref[Runtime]) -> int:
+    return backend.release_runtime(runtime)
+
+
+public function sleep_on(runtime: Runtime, timeout: ptr_uint) -> Task[int]:
+    return backend.sleep_on(runtime, timeout)
+
+
+public function work[T](run_work: fn() -> T) -> Task[T]:
+    return backend.work[T](run_work)
+
+
+public function current_runtime() -> Runtime:
+    return backend.current_runtime()
+
+
+public function work_on[T](runtime: Runtime, run_work: fn() -> T) -> Task[T]:
+    return backend.work_on[T](runtime, run_work)
+
+
+public function pump(runtime: Runtime) -> void:
+    backend.pump(runtime)
+
+
+public function completed[T](task: Task[T]) -> bool:
+    return backend.completed[T](task)
+
+
+public function result[T](task: Task[T]) -> T:
+    return backend.result[T](task)
+
+
+public function wait_on[T](runtime: Runtime, task: Task[T]) -> T:
+    return backend.wait_on[T](runtime, task)
+
+
+public function run_on(runtime: Runtime, task: Task[void]) -> void:
+    backend.run_on(runtime, task)
+
+
+public function wait[T](root: proc() -> Task[T]) -> T:
+    return backend.wait[T](root)
+
+
+public function run(root: proc() -> Task[void]) -> void:
+    backend.run(root)
+
+
+public function with_runtime[T](body: proc(runtime: Runtime) -> T) -> T:
+    return backend.with_runtime[T](body)
+
+
+public function run_with_runtime(body: proc(runtime: Runtime) -> void) -> void:
+    backend.run_with_runtime(body)

data/std/base64.mt

@@ -0,0 +1,185 @@
+import std.bytes as bytes
+import std.mem.heap as heap
+import std.str as text
+import std.string as string
+
+const BASE64_ALPHABET: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+const BASE64_URL_ALPHABET: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+const BASE64_PAD: ubyte = 61
+
+
+function lookup(value: ubyte) -> Option[ubyte]:
+    if value >= 65 and value <= 90:
+        return Option[ubyte].some(value = value - 65)
+
+    if value >= 97 and value <= 122:
+        return Option[ubyte].some(value = value - 71)
+
+    if value >= 48 and value <= 57:
+        return Option[ubyte].some(value = value + 4)
+
+    if value == 43 or value == 45:
+        return Option[ubyte].some(value = 62)
+
+    if value == 47 or value == 95:
+        return Option[ubyte].some(value = 63)
+
+    return Option[ubyte].none
+
+
+function encoded_len(input_len: ptr_uint) -> ptr_uint:
+    var padded_len = input_len
+    let remainder = padded_len % 3
+    if remainder != 0:
+        padded_len += 3 - remainder
+
+    return (padded_len / 3) * 4
+
+
+function encode_impl(input: span[ubyte], alphabet: str, use_padding: bool) -> string.String:
+    if input.len == 0:
+        return string.String.create()
+
+    let output_len = encoded_len(input.len)
+    var output = string.String.with_capacity(output_len)
+
+    var index: ptr_uint = 0
+    while index < input.len:
+        var triple: array[ubyte, 3]
+        var group_len: ubyte = 0
+
+        triple[0] = unsafe: read(input.data + index)
+        group_len += 1
+        index += 1
+
+        if index < input.len:
+            triple[1] = unsafe: read(input.data + index)
+            group_len += 1
+            index += 1
+        else:
+            triple[1] = 0
+
+        if index < input.len:
+            triple[2] = unsafe: read(input.data + index)
+            group_len += 1
+            index += 1
+        else:
+            triple[2] = 0
+
+        let combined = (ulong<-triple[0] << 16) | (ulong<-triple[1] << 8) | ulong<-triple[2]
+
+        let char0 = alphabet.byte_at(ptr_uint<-( (combined >> 18) & 0x3F) )
+        let char1 = alphabet.byte_at(ptr_uint<-( (combined >> 12) & 0x3F) )
+        output.push_byte(char0)
+        output.push_byte(char1)
+
+        if group_len >= 2:
+            let char2 = alphabet.byte_at(ptr_uint<-( (combined >> 6) & 0x3F) )
+            output.push_byte(char2)
+        else if use_padding:
+            output.push_byte(BASE64_PAD)
+
+        if group_len >= 3:
+            let char3 = alphabet.byte_at(ptr_uint<-(combined & 0x3F))
+            output.push_byte(char3)
+        else if use_padding:
+            output.push_byte(BASE64_PAD)
+
+    return output
+
+
+public function encode(input: span[ubyte]) -> string.String:
+    return encode_impl(input, BASE64_ALPHABET, true)
+
+
+public function encode_urlsafe(input: span[ubyte]) -> string.String:
+    return encode_impl(input, BASE64_URL_ALPHABET, false)
+
+public struct Error:
+    message: string.String
+
+
+function error_message(message: str) -> Error:
+    return Error(message = string.String.from_str(message))
+
+
+public function decode(text_value: str) -> Result[bytes.Bytes, Error]:
+    if text_value.len == 0:
+        return Result[bytes.Bytes, Error].success(value = bytes.Bytes.empty())
+
+    var effective_len = text_value.len
+    while effective_len > 0 and text_value.byte_at(effective_len - 1) == BASE64_PAD:
+        effective_len -= 1
+
+    if effective_len == 0:
+        return Result[bytes.Bytes, Error].success(value = bytes.Bytes.empty())
+
+    let remainder = effective_len % 4
+    if remainder == 1:
+        return Result[bytes.Bytes, Error].failure(error = error_message("base64: invalid input length"))
+
+    var output_len = (effective_len / 4) * 3
+    if remainder != 0:
+        output_len = output_len + remainder - 1
+
+    let output = heap.must_alloc[ubyte](output_len)
+    var out_index: ptr_uint = 0
+    var index: ptr_uint = 0
+
+    while index < effective_len:
+        let c0 = text_value.byte_at(index)
+        index += 1
+        let raw0_opt = lookup(c0) else:
+            heap.release(output)
+            return Result[bytes.Bytes, Error].failure(error = error_message("base64: invalid character"))
+        let raw0 = raw0_opt
+
+        var raw1: ubyte = 0
+        if index < effective_len:
+            let c1 = text_value.byte_at(index)
+            index += 1
+            let raw1_opt = lookup(c1) else:
+                heap.release(output)
+                return Result[bytes.Bytes, Error].failure(error = error_message("base64: invalid character"))
+            raw1 = raw1_opt
+
+        var raw2: ubyte = 0
+        if index < effective_len:
+            let c2 = text_value.byte_at(index)
+            index += 1
+            let raw2_opt = lookup(c2) else:
+                heap.release(output)
+                return Result[bytes.Bytes, Error].failure(error = error_message("base64: invalid character"))
+            raw2 = raw2_opt
+
+        var raw3: ubyte = 0
+        if index < effective_len:
+            let c3 = text_value.byte_at(index)
+            index += 1
+            let raw3_opt = lookup(c3) else:
+                heap.release(output)
+                return Result[bytes.Bytes, Error].failure(error = error_message("base64: invalid character"))
+            raw3 = raw3_opt
+
+        let combined = (ulong<-raw0 << 18) | (ulong<-raw1 << 12) | (ulong<-raw2 << 6) | ulong<-raw3
+
+        unsafe:
+            read(output + out_index) = ubyte<-( (combined >> 16) & 0xFF)
+        out_index += 1
+
+        if out_index < output_len:
+            unsafe:
+                read(output + out_index) = ubyte<-( (combined >> 8) & 0xFF)
+            out_index += 1
+
+        if out_index < output_len:
+            unsafe:
+                read(output + out_index) = ubyte<-(combined & 0xFF)
+            out_index += 1
+
+    return Result[bytes.Bytes, Error].success(value = bytes.Bytes(data = output, len = output_len))
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()