mt-lang 0.2.0 → 0.2.1

data/std/curl/runtime.mt

@@ -0,0 +1,261 @@
+import std.bytes as bytes
+import std.curl as curl
+import std.c.curl as c
+import std.mem.arena as arena
+import std.mem.heap as heap
+import std.str as text
+import std.string as string
+import std.vec as vec
+
+const CURLE_OK_CODE: int = 0
+const CURLE_FAILED_INIT_CODE: int = 2
+const CURLE_URL_MALFORMAT_CODE: int = 3
+
+foreign function easy_setopt_writedata(curl_handle: ptr[c.CURL], user_data: ptr[void]) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-10001, user_data)
+foreign function easy_setopt_url(curl_handle: ptr[c.CURL], url: cstr) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-10002, url)
+foreign function easy_setopt_writefunction(curl_handle: ptr[c.CURL], write_callback: c.curl_write_callback) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-20011, write_callback)
+foreign function easy_setopt_followlocation(curl_handle: ptr[c.CURL], follow: ptr_int) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-52, follow)
+foreign function easy_setopt_timeout(curl_handle: ptr[c.CURL], timeout: int) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-13, timeout)
+foreign function easy_setopt_postfields(curl_handle: ptr[c.CURL], body: cstr) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-10015, body)
+foreign function easy_setopt_customrequest(curl_handle: ptr[c.CURL], method: cstr) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-10036, method)
+foreign function easy_setopt_nobody(curl_handle: ptr[c.CURL]) -> c.CURLcode = c.curl_easy_setopt(curl_handle, c.CURLoption<-44, 1)
+foreign function easy_getinfo_long(curl_handle: ptr[c.CURL], value: ptr[int]) -> c.CURLcode = c.curl_easy_getinfo(curl_handle, c.CURLINFO<-2097154, value)
+
+public struct HttpError:
+    code: curl.Code
+    message: string.String
+
+public struct HttpResponse:
+    status_code: int
+    body: bytes.Bytes
+
+
+extending HttpError:
+    public editable function release() -> void:
+        this.message.release()
+
+
+extending HttpResponse:
+    public editable function release() -> void:
+        this.body.release()
+
+
+    public function body_as_str() -> Option[str]:
+        return this.body.as_str()
+
+
+function write_response_chunk(data: ptr[char], size: ptr_uint, count: ptr_uint, user_data: ptr[void]) -> ptr_uint:
+    if size != 0 and count > heap.ptr_uint_max / size:
+        return 0
+
+    let total = size * count
+    if total == 0:
+        return 0
+
+    unsafe:
+        let buffer = ptr[vec.Vec[ubyte]]<-user_data
+        let chunk = span[ubyte](data = ptr[ubyte]<-data, len = total)
+        read(buffer).append_span(chunk)
+
+    return total
+
+
+public function code_message(code: curl.Code) -> str:
+    return text.cstr_as_str(curl.easy_strerror(code))
+
+
+public function get_bytes(url: str) -> Result[bytes.Bytes, curl.Code]:
+    if url.len == heap.ptr_uint_max:
+        return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_URL_MALFORMAT_CODE)
+
+    var scratch = arena.create(url.len + 1)
+    defer scratch.release()
+
+    let url_cstr = scratch.to_cstr(url)
+
+    let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
+    if int<-global_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= global_status)
+    defer curl.global_cleanup()
+
+    let handle = curl.easy_init() else:
+        return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_FAILED_INIT_CODE)
+    defer curl.easy_cleanup(handle)
+
+    var body = vec.Vec[ubyte].create()
+    defer body.release()
+
+    let write_function_status = easy_setopt_writefunction(handle, write_response_chunk)
+    if int<-write_function_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= write_function_status)
+
+    let write_data_status = easy_setopt_writedata(handle, unsafe: ptr[void]<-ptr_of(body))
+    if int<-write_data_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= write_data_status)
+
+    let url_status = easy_setopt_url(handle, url_cstr)
+    if int<-url_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= url_status)
+
+    let follow_status = easy_setopt_followlocation(handle, 1)
+    if int<-follow_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= follow_status)
+
+    let perform_status = curl.easy_perform(handle)
+    if int<-perform_status != CURLE_OK_CODE:
+        return Result[bytes.Bytes, curl.Code].failure(error= perform_status)
+
+    return Result[bytes.Bytes, curl.Code].success(value= bytes.Bytes.copy(body.as_span()))
+
+
+function http_error(code: curl.Code) -> HttpError:
+    let detail = text.cstr_as_str(curl.easy_strerror(code))
+    return HttpError(code = code, message = string.String.from_str(detail))
+
+
+public function get(url: str) -> Result[HttpResponse, HttpError]:
+    return do_request("GET", url, Option[str].none, 0)
+
+
+public function get_with_timeout(url: str, timeout_seconds: int) -> Result[HttpResponse, HttpError]:
+    return do_request("GET", url, Option[str].none, timeout_seconds)
+
+
+public function head(url: str) -> Result[HttpResponse, HttpError]:
+    return do_request("HEAD", url, Option[str].none, 0)
+
+
+public function head_with_timeout(url: str, timeout_seconds: int) -> Result[HttpResponse, HttpError]:
+    return do_request("HEAD", url, Option[str].none, timeout_seconds)
+
+
+public function delete(url: str) -> Result[HttpResponse, HttpError]:
+    return do_request("DELETE", url, Option[str].none, 0)
+
+
+public function delete_with_timeout(url: str, timeout_seconds: int) -> Result[HttpResponse, HttpError]:
+    return do_request("DELETE", url, Option[str].none, timeout_seconds)
+
+
+public function options(url: str) -> Result[HttpResponse, HttpError]:
+    return do_request("OPTIONS", url, Option[str].none, 0)
+
+
+public function options_with_timeout(url: str, timeout_seconds: int) -> Result[HttpResponse, HttpError]:
+    return do_request("OPTIONS", url, Option[str].none, timeout_seconds)
+
+
+public function post(url: str, body: str) -> Result[HttpResponse, HttpError]:
+    return do_request("POST", url, Option[str].some(value = body), 0)
+
+
+public function post_with_timeout(
+    url: str,
+    body: str,
+    timeout_seconds: int
+) -> Result[HttpResponse, HttpError]:
+    return do_request("POST", url, Option[str].some(value = body), timeout_seconds)
+
+
+public function put(url: str, body: str) -> Result[HttpResponse, HttpError]:
+    return do_request("PUT", url, Option[str].some(value = body), 0)
+
+
+public function put_with_timeout(
+    url: str,
+    body: str,
+    timeout_seconds: int
+) -> Result[HttpResponse, HttpError]:
+    return do_request("PUT", url, Option[str].some(value = body), timeout_seconds)
+
+
+public function patch(url: str, body: str) -> Result[HttpResponse, HttpError]:
+    return do_request("PATCH", url, Option[str].some(value = body), 0)
+
+
+public function patch_with_timeout(
+    url: str,
+    body: str,
+    timeout_seconds: int
+) -> Result[HttpResponse, HttpError]:
+    return do_request("PATCH", url, Option[str].some(value = body), timeout_seconds)
+
+
+public function request(
+    method: str,
+    url: str,
+    body: Option[str],
+    timeout: int
+) -> Result[HttpResponse, HttpError]:
+    return do_request(method, url, body, timeout)
+
+
+function do_request(
+    method: str,
+    url: str,
+    body: Option[str],
+    timeout: int
+) -> Result[HttpResponse, HttpError]:
+    let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
+    if int<-global_status != CURLE_OK_CODE:
+        return Result[HttpResponse, HttpError].failure(error = http_error(global_status))
+    defer curl.global_cleanup()
+
+    let handle = curl.easy_init() else:
+        return Result[HttpResponse, HttpError].failure(
+            error = HttpError(
+                code = curl.Code<-CURLE_FAILED_INIT_CODE,
+                message = string.String.from_str("curl_easy_init failed")
+            )
+        )
+    defer curl.easy_cleanup(handle)
+
+    var buffer = vec.Vec[ubyte].create()
+    defer buffer.release()
+
+    let _wfn = easy_setopt_writefunction(handle, write_response_chunk)
+    let _wdata = easy_setopt_writedata(handle, unsafe: ptr[void]<-ptr_of(buffer))
+
+    if url.len == heap.ptr_uint_max:
+        return Result[HttpResponse, HttpError].failure(
+            error = HttpError(
+                code = curl.Code<-CURLE_URL_MALFORMAT_CODE,
+                message = string.String.from_str("url too long")
+            )
+        )
+
+    var scratch = arena.create(url.len + 1)
+    defer scratch.release()
+
+    let url_cstr = scratch.to_cstr(url)
+    let _url = easy_setopt_url(handle, url_cstr)
+    let _follow = easy_setopt_followlocation(handle, 1)
+
+    if timeout > 0:
+        let _timeout = easy_setopt_timeout(handle, timeout)
+
+    if body.is_some():
+        let body_content = body.unwrap()
+        var body_scratch = arena.create(body_content.len + 1)
+        defer body_scratch.release()
+        let _pf = easy_setopt_postfields(handle, body_scratch.to_cstr(body_content))
+
+    if method.len > 0 and not method.starts_with("GET"):
+        var method_scratch = arena.create(method.len + 1)
+        defer method_scratch.release()
+        let _method = easy_setopt_customrequest(handle, method_scratch.to_cstr(method))
+
+    if method.starts_with("HEAD"):
+        let _nobody = easy_setopt_nobody(handle)
+
+    let code = curl.easy_perform(handle)
+    if int<-code != CURLE_OK_CODE:
+        return Result[HttpResponse, HttpError].failure(error = http_error(code))
+
+    var status: int = 0
+    let _info = easy_getinfo_long(handle, ptr_of(status))
+
+    let response_body = bytes.Bytes.copy(buffer.as_span())
+    return Result[HttpResponse, HttpError].success(
+        value = HttpResponse(status_code = status, body = response_body)
+    )

data/std/curl.mt

@@ -0,0 +1,38 @@
+# generated by mtc imported-bindings from std.c.curl using bindings/imported/curl.binding.json
+
+import std.c.curl as c
+
+public type EasyHandle = c.CURL
+public type ShareHandle = c.CURLSH
+public type Code = c.CURLcode
+public type CurlOption = c.CURLoption
+public type SList = c.curl_slist
+public type Info = c.CURLINFO
+
+public const CURLE_ALREADY_COMPLETE: int = c.CURLE_ALREADY_COMPLETE
+public const CURLOPT_OBSOLETE72: int = c.CURLOPT_OBSOLETE72
+public const CURLOPT_OBSOLETE40: int = c.CURLOPT_OBSOLETE40
+public const CURLINFO_STRING: int = c.CURLINFO_STRING
+public const CURLINFO_LONG: int = c.CURLINFO_LONG
+public const CURLINFO_DOUBLE: int = c.CURLINFO_DOUBLE
+public const CURLINFO_SLIST: int = c.CURLINFO_SLIST
+public const CURLINFO_PTR: int = c.CURLINFO_PTR
+public const CURLINFO_SOCKET: int = c.CURLINFO_SOCKET
+public const CURLINFO_OFF_T: int = c.CURLINFO_OFF_T
+public const CURLINFO_MASK: int = c.CURLINFO_MASK
+public const CURLINFO_TYPEMASK: int = c.CURLINFO_TYPEMASK
+public const CURL_GLOBAL_NOTHING: int = c.CURL_GLOBAL_NOTHING
+
+public foreign function easy_escape(curl: ptr[EasyHandle], string: str as cstr, length: int) -> ptr[char]? = c.curl_easy_escape
+public foreign function free(p: ptr[void]) -> void = c.curl_free
+public foreign function global_init(flag_bits: ptr_int) -> Code = c.curl_global_init
+public foreign function global_cleanup() -> void = c.curl_global_cleanup
+public foreign function slist_append(list: ptr[SList], data: str as cstr) -> ptr[SList] = c.curl_slist_append
+public foreign function slist_free_all(list: ptr[SList]) -> void = c.curl_slist_free_all
+public foreign function easy_strerror(error: Code) -> cstr = c.curl_easy_strerror
+public foreign function easy_pause(curl: ptr[EasyHandle], action: int) -> Code = c.curl_easy_pause
+public foreign function easy_init() -> ptr[EasyHandle]? = c.curl_easy_init
+public foreign function easy_perform(curl: ptr[EasyHandle]) -> Code = c.curl_easy_perform
+public foreign function easy_cleanup(curl: ptr[EasyHandle]) -> void = c.curl_easy_cleanup
+public foreign function easy_duphandle(curl: ptr[EasyHandle]) -> ptr[EasyHandle]? = c.curl_easy_duphandle
+public foreign function easy_reset(curl: ptr[EasyHandle]) -> void = c.curl_easy_reset

data/std/deque.mt

@@ -0,0 +1,348 @@
+import std.mem.heap as heap
+
+public struct Deque[T]:
+    data: own[T]?
+    head: ptr_uint
+    len: ptr_uint
+    capacity: ptr_uint
+
+public struct Iter[T]:
+    data: ptr[T]?
+    head: ptr_uint
+    len: ptr_uint
+    capacity: ptr_uint
+    index: ptr_uint
+
+
+extending Deque[T]:
+    public static function create() -> Deque[T]:
+        return Deque[T](data = null, head = 0, len = 0, capacity = 0)
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Deque[T]:
+        var result = Deque[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    static function physical_index(head: ptr_uint, capacity: ptr_uint, index: ptr_uint) -> ptr_uint:
+        let raw = head + index
+        if raw >= capacity:
+            return raw - capacity
+
+        return raw
+
+
+    static function next_index(index: ptr_uint, capacity: ptr_uint) -> ptr_uint:
+        if index + 1 == capacity:
+            return 0
+
+        return index + 1
+
+
+    static function previous_index(index: ptr_uint, capacity: ptr_uint) -> ptr_uint:
+        if index == 0:
+            return capacity - 1
+
+        return index - 1
+
+
+    public function len() -> ptr_uint:
+        return this.len
+
+
+    public function capacity() -> ptr_uint:
+        return this.capacity
+
+
+    public function is_empty() -> bool:
+        return this.len == 0
+
+
+    public function iter() -> Iter[T]:
+        return Iter[T](data = this.data, head = this.head, len = this.len, capacity = this.capacity, index = 0)
+
+
+    public function get(index: ptr_uint) -> ptr[T]?:
+        if index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"deque.Deque.get missing storage")
+
+        return unsafe: ptr[T]<-data + Deque[T].physical_index(this.head, this.capacity, index)
+
+
+    public function at(index: ptr_uint) -> Option[T]:
+        let p = this.get(index) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(p))
+
+
+    public function first() -> ptr[T]?:
+        return this.get(0)
+
+
+    public function last() -> ptr[T]?:
+        if this.len == 0:
+            return null
+
+        return this.get(this.len - 1)
+
+
+    public editable function clear() -> void:
+        this.head = 0
+        this.len = 0
+
+
+    public editable function release() -> void:
+        heap.release(this.data)
+        this.data = null
+        this.head = 0
+        this.len = 0
+        this.capacity = 0
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        if min_capacity <= this.capacity:
+            return
+
+        var new_capacity = this.capacity
+        if new_capacity == 0:
+            new_capacity = 4
+
+        while new_capacity < min_capacity:
+            if new_capacity > heap.ptr_uint_max / 2:
+                new_capacity = min_capacity
+            else:
+                new_capacity *= 2
+
+        let new_data = heap.must_alloc[T](new_capacity)
+        let old_data = this.data
+        if this.len != 0:
+            if old_data == null:
+                fatal(c"deque.reserve missing storage")
+
+            unsafe:
+                let old_ptr = ptr[T]<-old_data
+                let new_ptr = ptr[T]<-new_data
+                var index: ptr_uint = 0
+                while index < this.len:
+                    let source_index = Deque[T].physical_index(this.head, this.capacity, index)
+                    read(new_ptr + index) = read(old_ptr + source_index)
+                    index += 1
+
+        heap.release(old_data)
+        this.data = new_data
+        this.head = 0
+        this.capacity = new_capacity
+
+
+    public editable function push_back(value: T) -> void:
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let data = this.data else:
+            fatal(c"deque.push_back missing storage")
+
+        let tail_index = Deque[T].physical_index(this.head, this.capacity, this.len)
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            read(data_ptr + tail_index) = value
+
+        this.len += 1
+
+
+    public editable function push_front(value: T) -> void:
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let data = this.data else:
+            fatal(c"deque.push_front missing storage")
+
+        if this.len == 0:
+            this.head = 0
+        else:
+            this.head = Deque[T].previous_index(this.head, this.capacity)
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            read(data_ptr + this.head) = value
+
+        this.len += 1
+
+
+    public editable function insert(index: ptr_uint, value: T) -> bool:
+        if index > this.len:
+            return false
+
+        if index == 0:
+            this.push_front(value)
+            return true
+
+        if index == this.len:
+            this.push_back(value)
+            return true
+
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let data = this.data else:
+            fatal(c"deque.insert missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            if index < this.len - index:
+                let old_head = this.head
+                let new_head = Deque[T].previous_index(old_head, this.capacity)
+                var current: ptr_uint = 0
+                while current < index:
+                    let destination = Deque[T].physical_index(new_head, this.capacity, current)
+                    let source = Deque[T].physical_index(old_head, this.capacity, current)
+                    read(data_ptr + destination) = read(data_ptr + source)
+                    current += 1
+                this.head = new_head
+            else:
+                var current = this.len
+                while current > index:
+                    let destination = Deque[T].physical_index(this.head, this.capacity, current)
+                    let source = Deque[T].physical_index(this.head, this.capacity, current - 1)
+                    read(data_ptr + destination) = read(data_ptr + source)
+                    current -= 1
+
+            let target = Deque[T].physical_index(this.head, this.capacity, index)
+            read(data_ptr + target) = value
+
+        this.len += 1
+        return true
+
+
+    public editable function pop_back() -> Option[T]:
+        if this.len == 0:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"deque.pop_back missing storage")
+
+        let tail_index = Deque[T].physical_index(this.head, this.capacity, this.len - 1)
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let value = read(data_ptr + tail_index)
+            if this.len == 1:
+                this.head = 0
+                this.len = 0
+            else:
+                this.len -= 1
+            return Option[T].some(value = value)
+
+
+    public editable function pop_front() -> Option[T]:
+        if this.len == 0:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"deque.pop_front missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let value = read(data_ptr + this.head)
+            if this.len == 1:
+                this.head = 0
+                this.len = 0
+            else:
+                this.len -= 1
+                this.head = Deque[T].next_index(this.head, this.capacity)
+            return Option[T].some(value = value)
+
+
+    public editable function remove(index: ptr_uint) -> Option[T]:
+        if index >= this.len:
+            return Option[T].none
+
+        if index == 0:
+            return this.pop_front()
+
+        if index + 1 == this.len:
+            return this.pop_back()
+
+        let data = this.data else:
+            fatal(c"deque.remove missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let removed_index = Deque[T].physical_index(this.head, this.capacity, index)
+            let removed = read(data_ptr + removed_index)
+
+            if index < this.len / 2:
+                var current = index
+                while current > 0:
+                    let destination = Deque[T].physical_index(this.head, this.capacity, current)
+                    let source = Deque[T].physical_index(this.head, this.capacity, current - 1)
+                    read(data_ptr + destination) = read(data_ptr + source)
+                    current -= 1
+                this.head = Deque[T].next_index(this.head, this.capacity)
+            else:
+                var current = index
+                while current + 1 < this.len:
+                    let destination = Deque[T].physical_index(this.head, this.capacity, current)
+                    let source = Deque[T].physical_index(this.head, this.capacity, current + 1)
+                    read(data_ptr + destination) = read(data_ptr + source)
+                    current += 1
+
+            this.len -= 1
+            return Option[T].some(value = removed)
+
+
+    public editable function rotate_left(amount: ptr_uint) -> void:
+        if this.len <= 1:
+            return
+
+        let shift = amount % this.len
+        if shift == 0:
+            return
+
+        if shift > this.len - shift:
+            this.rotate_right(this.len - shift)
+            return
+
+        var remaining = shift
+        while remaining != 0:
+            this.push_back(this.pop_front().expect("deque rotate_left missing front value"))
+            remaining -= 1
+
+
+    public editable function rotate_right(amount: ptr_uint) -> void:
+        if this.len <= 1:
+            return
+
+        let shift = amount % this.len
+        if shift == 0:
+            return
+
+        if shift > this.len - shift:
+            this.rotate_left(this.len - shift)
+            return
+
+        var remaining = shift
+        while remaining != 0:
+            this.push_front(this.pop_back().expect("deque rotate_right missing back value"))
+            remaining -= 1
+
+
+extending Iter[T]:
+    public function iter() -> Iter[T]:
+        return this
+
+
+    public editable function next() -> ptr[T]?:
+        if this.index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"deque.Iter.next missing storage")
+
+        let current_index = this.index
+        this.index += 1
+        return unsafe: ptr[T]<-data + Deque[T].physical_index(this.head, this.capacity, current_index)