mt-lang 0.2.0 → 0.2.2

data/std/cookie.mt

@@ -0,0 +1,198 @@
+import std.str as text
+import std.string as string
+import std.time as time
+
+public struct Cookie:
+    name: string.String
+    value: string.String
+    domain: Option[string.String]
+    path: Option[string.String]
+    max_age: Option[ptr_int]
+    expires: Option[time.Timestamp]
+    secure: bool
+    http_only: bool
+    same_site: Option[string.String]
+
+
+public function parse_set_cookie(header_value: str) -> Option[Cookie]:
+    var pos: ptr_uint = 0
+
+    let semi = find_byte_from(header_value, 59, pos)
+    var end = header_value.len
+    match semi:
+        Option.none:
+            pass
+        Option.some as s:
+            end = s.value
+
+    let part = header_value.slice(pos, end - pos).trim_ascii_whitespace()
+    if part.len == 0:
+        return Option[Cookie].none
+
+    var cookie = parse_name_value(part)?
+    match semi:
+        Option.none:
+            return Option[Cookie].some(value = cookie)
+        Option.some as s:
+            pos = s.value + 1
+
+    while pos < header_value.len:
+        let next_semi = find_byte_from(header_value, 59, pos)
+        var next_end = header_value.len
+        match next_semi:
+            Option.none:
+                pass
+            Option.some as ns:
+                next_end = ns.value
+
+        let next_part = header_value.slice(pos, next_end - pos).trim_ascii_whitespace()
+        if next_part.len > 0:
+            apply_attribute(ref_of(cookie), next_part)
+
+        match next_semi:
+            Option.none:
+                pos = header_value.len
+            Option.some as ns:
+                pos = ns.value + 1
+
+    return Option[Cookie].some(value = cookie)
+
+
+function parse_name_value(text_value: str) -> Option[Cookie]:
+    let eq = text_value.find_byte(61)
+    match eq:
+        Option.none:
+            return Option[Cookie].none
+        Option.some as e:
+            let name_text = text_value.slice(0, e.value).trim_ascii_whitespace()
+            let value_text = text_value.slice(e.value + 1, text_value.len - e.value - 1).trim_ascii_whitespace()
+
+            var cookie_value = string.String.from_str(value_text)
+            if cookie_value.len() >= 2 and cookie_value.as_str().byte_at(0) == 34:
+                let last = cookie_value.len() - 1
+                if cookie_value.as_str().byte_at(last) == 34:
+                    let inner = cookie_value.as_str().slice(1, last - 1)
+                    cookie_value.assign(inner)
+
+            let cookie = Cookie(
+                name = string.String.from_str(name_text),
+                value = cookie_value,
+                domain = Option[string.String].none,
+                path = Option[string.String].none,
+                max_age = Option[ptr_int].none,
+                expires = Option[time.Timestamp].none,
+                secure = false,
+                http_only = false,
+                same_site = Option[string.String].none
+            )
+
+            return Option[Cookie].some(value = cookie)
+
+
+function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
+    let eq = attribute_text.find_byte(61)
+    match eq:
+        Option.none:
+            var normalized = ascii_lower(attribute_text)
+            defer normalized.release()
+
+            if normalized.as_str().equal("secure"):
+                cookie.secure = true
+            else if normalized.as_str().equal("httponly"):
+                cookie.http_only = true
+
+        Option.some as e:
+            let key_text = attribute_text.slice(0, e.value).trim_ascii_whitespace()
+            let value_text = attribute_text.slice(e.value + 1, attribute_text.len - e.value - 1).trim_ascii_whitespace()
+
+            var normalized_key = ascii_lower(key_text)
+            defer normalized_key.release()
+
+            if normalized_key.as_str().equal("domain"):
+                cookie.domain = Option[string.String].some(value = string.String.from_str(value_text))
+            else if normalized_key.as_str().equal("path"):
+                cookie.path = Option[string.String].some(value = string.String.from_str(value_text))
+            else if normalized_key.as_str().equal("max-age"):
+                let parsed = parse_decimal(value_text)
+                match parsed:
+                    Option.some as payload:
+                        cookie.max_age = Option[ptr_int].some(value = ptr_int<-payload.value)
+                    Option.none:
+                        pass
+            else if normalized_key.as_str().equal("samesite"):
+                cookie.same_site = Option[string.String].some(value = ascii_lower(value_text))
+
+
+public function format_cookie(cookie: Cookie) -> string.String:
+    var result = string.String.with_capacity(cookie.name.len() + cookie.value.len() + 128)
+
+    result.append(cookie.name.as_str())
+    result.push_byte(61)
+    result.append(cookie.value.as_str())
+
+    return result
+
+
+function ascii_lower(text_value: str) -> string.String:
+    var result = string.String.with_capacity(text_value.len)
+    var index: ptr_uint = 0
+    while index < text_value.len:
+        let value = text_value.byte_at(index)
+        if value >= 65 and value <= 90:
+            result.push_byte(value + 32)
+        else:
+            result.push_byte(value)
+        index += 1
+
+    return result
+
+
+function find_byte_from(data: str, target: ubyte, start: ptr_uint) -> Option[ptr_uint]:
+    var index = start
+    while index < data.len:
+        if data.byte_at(index) == target:
+            return Option[ptr_uint].some(value = index)
+        index += 1
+
+    return Option[ptr_uint].none
+
+
+function parse_decimal(text_value: str) -> Option[ptr_uint]:
+    if text_value.len == 0:
+        return Option[ptr_uint].none
+
+    var value: ptr_uint = 0
+    var index: ptr_uint = 0
+    while index < text_value.len:
+        let current = text_value.byte_at(index)
+        if current < 48 or current > 57:
+            return Option[ptr_uint].none
+
+        value = value * 10 + ptr_uint<-(current - 48)
+        index += 1
+
+    return Option[ptr_uint].some(value = value)
+
+
+extending Cookie:
+    public editable function release() -> void:
+        this.name.release()
+        this.value.release()
+
+        match this.domain:
+            Option.some as payload:
+                payload.value.release()
+            Option.none:
+                pass
+
+        match this.path:
+            Option.some as payload:
+                payload.value.release()
+            Option.none:
+                pass
+
+        match this.same_site:
+            Option.some as payload:
+                payload.value.release()
+            Option.none:
+                pass

data/std/counter.mt

@@ -0,0 +1,160 @@
+import std.linked_map as linked_map
+import std.linked_map_view as linked_map_view
+import std.mem.heap as heap
+
+public struct Entry[T]:
+    key: const_ptr[T]
+    count: ptr_uint
+
+public struct Entries[T]:
+    values: linked_map_view.SnapshotEntries[T, ptr_uint]
+
+public struct Counter[T]:
+    values: linked_map.LinkedMap[T, ptr_uint]
+    total: ptr_uint
+
+
+extending Counter[T]:
+    public static function create() -> Counter[T]:
+        return Counter[T](values = linked_map.LinkedMap[T, ptr_uint].create(), total = 0)
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Counter[T]:
+        var result = Counter[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function total_count() -> ptr_uint:
+        return this.total
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.total == 0
+
+
+    public function count(value: T) -> ptr_uint:
+        let stored = this.values.get(value) else:
+            return 0
+
+        unsafe:
+            return read(stored)
+
+
+    public function contains(value: T) -> bool:
+        return this.values.contains(value)
+
+
+    public function iter() -> Entries[T]:
+        return this.entries()
+
+
+    public function keys() -> linked_map.Keys[T, ptr_uint]:
+        return this.values.keys()
+
+
+    public function counts() -> linked_map_view.SnapshotValues[T, ptr_uint]:
+        return linked_map_view.SnapshotValues[T, ptr_uint].create(this.values.entries())
+
+
+    public function entries() -> Entries[T]:
+        return Entries[T](values = linked_map_view.SnapshotEntries[T, ptr_uint].create(this.values.entries()))
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+        this.total = 0
+
+
+    public editable function release() -> void:
+        this.values.release()
+        this.total = 0
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function add(value: T, amount: ptr_uint) -> ptr_uint:
+        if amount == 0:
+            let stored = this.values.get(value) else:
+                return 0
+
+            unsafe:
+                return read(stored)
+
+        if this.total > heap.ptr_uint_max - amount:
+            fatal(c"counter.Counter.add total count overflow")
+
+        let current = this.values.get_or_insert(value, 0z)
+        unsafe:
+            if read(current) > heap.ptr_uint_max - amount:
+                fatal(c"counter.Counter.add entry count overflow")
+            read(current) += amount
+
+        this.total += amount
+        unsafe:
+            return read(current)
+
+
+    public editable function increment(value: T) -> ptr_uint:
+        return this.add(value, 1)
+
+
+    public editable function remove_one(value: T) -> bool:
+        let current = this.values.get(value) else:
+            return false
+
+        unsafe:
+            let count = read(current)
+            if count <= 1:
+                let removed = this.values.remove(value)
+                match removed:
+                    Option.none:
+                        fatal(c"counter.Counter.remove_one missing value")
+                    Option.some:
+                        if this.total == 0:
+                            fatal(c"counter.Counter.remove_one missing total")
+                        this.total -= 1
+                        return true
+
+            read(current) = count - 1
+
+        if this.total == 0:
+            fatal(c"counter.Counter.remove_one missing total")
+        this.total -= 1
+        return true
+
+
+    public editable function remove(value: T) -> Option[ptr_uint]:
+        let removed = this.values.remove(value)
+        match removed:
+            Option.none:
+                return Option[ptr_uint].none
+            Option.some as payload:
+                if this.total < payload.value:
+                    fatal(c"counter.Counter.remove total underflow")
+                this.total -= payload.value
+                return Option[ptr_uint].some(value = payload.value)
+
+
+extending Entries[T]:
+    public function iter() -> Entries[T]:
+        return this
+
+
+    public editable function next() -> bool:
+        return this.values.next()
+
+
+    public function current() -> Entry[T]:
+        let entry = this.values.current()
+        return Entry[T](key = entry.key, count = entry.value)

data/std/crypto.mt

@@ -0,0 +1,74 @@
+import std.bytes as bytes
+import std.c.crypto as raw
+import std.mem.heap as heap
+import std.string as string
+
+public struct Error:
+    message: string.String
+
+
+function status_error(message: str) -> Error:
+    return Error(message = string.String.from_str(message))
+
+
+public function sha256(data: span[ubyte]) -> bytes.Bytes:
+    let digest = heap.must_alloc[ubyte](raw.SHA256_DIGEST_LENGTH)
+    let ok = raw.mt_sha256(data.data, data.len, digest)
+    if ok == 0:
+        heap.release(digest)
+        return bytes.Bytes.empty()
+
+    return bytes.Bytes(data = digest, len = raw.SHA256_DIGEST_LENGTH)
+
+
+public function sha256_to_str(data: span[ubyte]) -> string.String:
+    var digest = sha256(data)
+    defer digest.release()
+
+    var result = string.String.with_capacity(raw.SHA256_DIGEST_LENGTH * 2)
+    var index: ptr_uint = 0
+    let digest_span = digest.as_span()
+    while index < raw.SHA256_DIGEST_LENGTH:
+        let value = unsafe: read(digest_span.data + index)
+        let high = value >> 4
+        let low = value & 0x0F
+        result.push_byte(hex_digit(high))
+        result.push_byte(hex_digit(low))
+        index += 1
+
+    return result
+
+
+public function hmac_sha256(key: span[ubyte], data: span[ubyte]) -> bytes.Bytes:
+    let digest = heap.must_alloc[ubyte](raw.SHA256_DIGEST_LENGTH)
+    let ok = raw.mt_hmac_sha256(key.data, key.len, data.data, data.len, digest)
+    if ok == 0:
+        heap.release(digest)
+        return bytes.Bytes.empty()
+
+    return bytes.Bytes(data = digest, len = raw.SHA256_DIGEST_LENGTH)
+
+
+public function random_bytes(count: ptr_uint) -> Result[bytes.Bytes, Error]:
+    if count == 0:
+        return Result[bytes.Bytes, Error].failure(error = status_error("random_bytes: count must be greater than zero"))
+
+    let buffer = heap.must_alloc[ubyte](count)
+    let ok = raw.mt_random_bytes(buffer, count)
+    if ok == 0:
+        heap.release(buffer)
+        return Result[bytes.Bytes, Error].failure(error = status_error("random_bytes: failed to generate random data"))
+
+    return Result[bytes.Bytes, Error].success(value = bytes.Bytes(data = buffer, len = count))
+
+
+function hex_digit(value: ubyte) -> ubyte:
+    if value < 10:
+        return 48 + value
+
+    return 97 + (value - 10)
+
+
+extending Error:
+    public editable function release() -> void:
+        this.message.release()

data/std/cstring.mt

@@ -0,0 +1,13 @@
+import std.c.string as c
+
+public foreign function copy_bytes(destination: ptr[void], source: const_ptr[void], size_bytes: ptr_uint) -> ptr[void] = c.mt_string_memcpy
+public foreign function move_bytes(destination: ptr[void], source: const_ptr[void], size_bytes: ptr_uint) -> ptr[void] = c.mt_string_memmove
+public foreign function set_bytes(destination: ptr[void], value: int, size_bytes: ptr_uint) -> ptr[void] = c.mt_string_memset
+public foreign function compare_bytes(left: const_ptr[void], right: const_ptr[void], size_bytes: ptr_uint) -> int = c.mt_string_memcmp
+public foreign function find_byte(source: const_ptr[void], value: int, size_bytes: ptr_uint) -> ptr[void]? = c.mt_string_memchr
+public foreign function length(text: str as cstr) -> ptr_uint = c.mt_string_strlen
+public foreign function compare(left: str as cstr, right: str as cstr) -> int = c.mt_string_strcmp
+public foreign function compare_prefix(left: str as cstr, right: str as cstr, size_bytes: ptr_uint) -> int = c.mt_string_strncmp
+public foreign function find_char(text: str as cstr, value: int) -> ptr[char]? = c.mt_string_strchr
+public foreign function find_last_char(text: str as cstr, value: int) -> ptr[char]? = c.mt_string_strrchr
+public foreign function find_substring(haystack: str as cstr, needle: str as cstr) -> ptr[char]? = c.mt_string_strstr

data/std/ctype.mt

@@ -0,0 +1,52 @@
+import std.c.ctype as c
+
+
+public function is_alnum(value: int) -> bool:
+    return c.mt_ctype_isalnum(value) != 0
+
+
+public function is_alpha(value: int) -> bool:
+    return c.mt_ctype_isalpha(value) != 0
+
+
+public function is_blank(value: int) -> bool:
+    return c.mt_ctype_isblank(value) != 0
+
+
+public function is_cntrl(value: int) -> bool:
+    return c.mt_ctype_iscntrl(value) != 0
+
+
+public function is_digit(value: int) -> bool:
+    return c.mt_ctype_isdigit(value) != 0
+
+
+public function is_graph(value: int) -> bool:
+    return c.mt_ctype_isgraph(value) != 0
+
+
+public function is_lower(value: int) -> bool:
+    return c.mt_ctype_islower(value) != 0
+
+
+public function is_print(value: int) -> bool:
+    return c.mt_ctype_isprint(value) != 0
+
+
+public function is_punct(value: int) -> bool:
+    return c.mt_ctype_ispunct(value) != 0
+
+
+public function is_space(value: int) -> bool:
+    return c.mt_ctype_isspace(value) != 0
+
+
+public function is_upper(value: int) -> bool:
+    return c.mt_ctype_isupper(value) != 0
+
+
+public function is_xdigit(value: int) -> bool:
+    return c.mt_ctype_isxdigit(value) != 0
+
+public foreign function to_lower(value: int) -> int = c.mt_ctype_tolower
+public foreign function to_upper(value: int) -> int = c.mt_ctype_toupper