mt-lang 0.2.0 → 0.2.1

data/std/vec.mt

@@ -0,0 +1,433 @@
+import std.mem.heap as heap
+
+public struct Vec[T]:
+    data: own[T]?
+    len: ptr_uint
+    capacity: ptr_uint
+
+public struct Iter[T]:
+    data: ptr[T]?
+    index: ptr_uint
+    len: ptr_uint
+
+
+extending Vec[T]:
+    public static function create() -> Vec[T]:
+        return Vec[T](data = null, len = 0, capacity = 0)
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Vec[T]:
+        var result = Vec[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    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, index = 0, len = this.len)
+
+
+    public function as_span() -> span[T]:
+        if this.data == null and this.len != 0:
+            fatal(c"vec.Vec.as_span missing storage")
+
+        unsafe:
+            return span[T](data = ptr[T]<-this.data, len = this.len)
+
+
+    public function get(index: ptr_uint) -> ptr[T]?:
+        if index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"vec.Vec.get missing storage")
+
+        return unsafe: ptr[T]<-data + 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 function find(predicate: proc(value: ptr[T]) -> bool) -> ptr[T]?:
+        var iter = this.iter()
+        return iter.find(predicate)
+
+
+    public function find_index(predicate: proc(value: ptr[T]) -> bool) -> Option[ptr_uint]:
+        var iter = this.iter()
+        return iter.position(predicate)
+
+
+    public editable function clear() -> void:
+        this.len = 0
+
+
+    public editable function release() -> void:
+        heap.release(this.data)
+        this.data = null
+        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 resized = heap.resize[T](this.data, new_capacity) else:
+            fatal(c"vec.reserve out of memory")
+
+        this.data = resized
+        this.capacity = new_capacity
+
+
+    public editable function append_span(values: span[T]) -> void:
+        if values.len == 0:
+            return
+
+        let current_len = this.len
+        if values.len > heap.ptr_uint_max - current_len:
+            fatal(c"vec.append_span size overflow")
+
+        let new_len = current_len + values.len
+        let needs_growth = new_len > this.capacity
+
+        var copied: ptr[T]? = null
+        if needs_growth:
+            copied = heap.must_alloc[T](values.len)
+            unsafe:
+                let copied_ptr = ptr[T]<-copied
+                var index: ptr_uint = 0
+                while index < values.len:
+                    read(copied_ptr + index) = read(values.data + index)
+                    index += 1
+
+        this.reserve(new_len)
+
+        let data = this.data else:
+            fatal(c"vec.append_span missing storage")
+
+        unsafe:
+            let destination = ptr[T]<-data + current_len
+            if copied != null:
+                let copied_ptr = ptr[T]<-copied
+                var index: ptr_uint = 0
+                while index < values.len:
+                    read(destination + index) = read(copied_ptr + index)
+                    index += 1
+                heap.release(copied)
+            else:
+                var index: ptr_uint = 0
+                while index < values.len:
+                    read(destination + index) = read(values.data + index)
+                    index += 1
+
+        this.len = new_len
+
+
+    public editable function append_array[N](values: array[T, N]) -> void:
+        var local_values = values
+        this.append_span(local_values)
+
+
+    public editable function insert(index: ptr_uint, value: T) -> bool:
+        if index > this.len:
+            return false
+
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let data = this.data else:
+            fatal(c"vec.insert missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var current = this.len
+            while current > index:
+                let previous = current - 1
+                read(data_ptr + current) = read(data_ptr + previous)
+                current = previous
+            read(data_ptr + index) = value
+
+        this.len += 1
+        return true
+
+
+    public editable function push(value: T) -> void:
+        if this.len == this.capacity:
+            this.reserve(this.len + 1)
+
+        let data = this.data else:
+            fatal(c"vec.push missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            read(data_ptr + this.len) = value
+
+        this.len += 1
+
+
+    public editable function pop() -> Option[T]:
+        if this.len == 0:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"vec.pop missing storage")
+
+        let last_index = this.len - 1
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let value = read(data_ptr + last_index)
+            this.len = last_index
+            return Option[T].some(value = value)
+
+
+    public editable function remove(index: ptr_uint) -> Option[T]:
+        if index >= this.len:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"vec.remove missing storage")
+
+        let last_index = this.len - 1
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let removed = read(data_ptr + index)
+            var current = index
+            while current < last_index:
+                let next_index = current + 1
+                read(data_ptr + current) = read(data_ptr + next_index)
+                current = next_index
+            this.len = last_index
+            return Option[T].some(value = removed)
+
+
+    public editable function swap_remove(index: ptr_uint) -> Option[T]:
+        if index >= this.len:
+            return Option[T].none
+
+        let data = this.data else:
+            fatal(c"vec.swap_remove missing storage")
+
+        let last_index = this.len - 1
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            let removed = read(data_ptr + index)
+            if index != last_index:
+                read(data_ptr + index) = read(data_ptr + last_index)
+            this.len = last_index
+            return Option[T].some(value = removed)
+
+
+    public editable function swap(i: ptr_uint, j: ptr_uint) -> void:
+        if i >= this.len or j >= this.len:
+            return
+
+        let data = this.data else:
+            fatal(c"vec.swap missing storage")
+
+        if i == j:
+            return
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var temp = read(data_ptr + i)
+            read(data_ptr + i) = read(data_ptr + j)
+            read(data_ptr + j) = temp
+
+
+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"vec.Iter.next missing storage")
+
+        let current_index = this.index
+        this.index += 1
+        return unsafe: ptr[T]<-data + current_index
+
+
+    public editable function find(predicate: proc(value: ptr[T]) -> bool) -> ptr[T]?:
+        while true:
+            let current = this.next() else:
+                return null
+
+            if predicate(current):
+                return current
+
+
+    public editable function position(predicate: proc(value: ptr[T]) -> bool) -> Option[ptr_uint]:
+        while true:
+            let current_index = this.index
+            let current = this.next() else:
+                return Option[ptr_uint].none
+
+            if predicate(current):
+                return Option[ptr_uint].some(value = current_index)
+
+
+    public editable function any(predicate: proc(value: ptr[T]) -> bool) -> bool:
+        return this.find(predicate) != null
+
+
+    public editable function all(predicate: proc(value: ptr[T]) -> bool) -> bool:
+        while true:
+            let current = this.next() else:
+                return true
+
+            if not predicate(current):
+                return false
+
+
+    public editable function count(predicate: proc(value: ptr[T]) -> bool) -> ptr_uint:
+        var total: ptr_uint = 0
+        while true:
+            let current = this.next() else:
+                return total
+
+            if predicate(current):
+                total += 1
+
+
+    public editable function sort() -> void:
+        if this.len <= 1:
+            return
+
+        let data = this.data else:
+            fatal(c"vec.sort missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var gap = this.len
+            while true:
+                gap = gap * 10 / 13
+                if gap < 1:
+                    gap = 1
+
+                var i = gap
+                while i < this.len:
+                    var j = i
+                    let temp = read(data_ptr + j)
+                    while j >= gap and order[T](data_ptr + j - gap, temp) > 0:
+                        read(data_ptr + j) = read(data_ptr + j - gap)
+                        j -= gap
+
+                    read(data_ptr + j) = temp
+                    i += 1
+
+                if gap == 1:
+                    break
+
+
+    public editable function sort_by(comparator: proc(left: ptr[T], right: ptr[T]) -> int) -> void:
+        if this.len <= 1:
+            return
+
+        let data = this.data else:
+            fatal(c"vec.sort_by missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var gap = this.len
+            while true:
+                gap = gap * 10 / 13
+                if gap < 1:
+                    gap = 1
+
+                var i = gap
+                while i < this.len:
+                    var j = i
+                    var temp = read(data_ptr + j)
+                    while j >= gap and comparator(data_ptr + j - gap, ptr_of(temp)) > 0:
+                        read(data_ptr + j) = read(data_ptr + j - gap)
+                        j -= gap
+
+                    read(data_ptr + j) = temp
+                    i += 1
+
+                if gap == 1:
+                    break
+
+
+    public function binary_search(target: ptr[T]) -> Option[ptr_uint]:
+        let data = this.data else:
+            fatal(c"vec.binary_search missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var low: ptr_uint = 0
+            var high = this.len
+            while low < high:
+                let mid = low + (high - low) / 2
+                let cmp = order[T](target, data_ptr + mid)
+                if cmp < 0:
+                    high = mid
+                else if cmp > 0:
+                    low = mid + 1
+                else:
+                    return Option[ptr_uint].some(value = mid)
+
+            return Option[ptr_uint].none
+
+
+    public function binary_search_by(target: ptr[T], comparator: proc(target: ptr[T], element: ptr[T]) -> int) -> Option[ptr_uint]:
+        let data = this.data else:
+            fatal(c"vec.binary_search_by missing storage")
+
+        unsafe:
+            let data_ptr = ptr[T]<-data
+            var low: ptr_uint = 0
+            var high = this.len
+            while low < high:
+                let mid = low + (high - low) / 2
+                let cmp = comparator(target, data_ptr + mid)
+                if cmp < 0:
+                    high = mid
+                else if cmp > 0:
+                    low = mid + 1
+                else:
+                    return Option[ptr_uint].some(value = mid)
+
+            return Option[ptr_uint].none

data/std/zstd.mt

@@ -0,0 +1,94 @@
+# generated by mtc imported-bindings from std.c.zstd using bindings/imported/zstd.binding.json
+
+import std.c.zstd as c
+
+public type ZSTD_ErrorCode = c.ZSTD_ErrorCode
+public type ZSTD_CCtx = c.ZSTD_CCtx
+public type ZSTD_DCtx = c.ZSTD_DCtx
+public type ZSTD_strategy = c.ZSTD_strategy
+public type ZSTD_cParameter = c.ZSTD_cParameter
+public type ZSTD_bounds = c.ZSTD_bounds
+public type ZSTD_ResetDirective = c.ZSTD_ResetDirective
+public type ZSTD_dParameter = c.ZSTD_dParameter
+public type ZSTD_inBuffer = c.ZSTD_inBuffer
+public type ZSTD_outBuffer = c.ZSTD_outBuffer
+public type ZSTD_CStream = c.ZSTD_CStream
+public type ZSTD_EndDirective = c.ZSTD_EndDirective
+public type ZSTD_DStream = c.ZSTD_DStream
+public type ZSTD_CDict = c.ZSTD_CDict
+public type ZSTD_DDict = c.ZSTD_DDict
+
+public const ZSTD_VERSION_MAJOR: int = c.ZSTD_VERSION_MAJOR
+public const ZSTD_VERSION_MINOR: int = c.ZSTD_VERSION_MINOR
+public const ZSTD_VERSION_RELEASE: int = c.ZSTD_VERSION_RELEASE
+public const ZSTD_CLEVEL_DEFAULT: int = c.ZSTD_CLEVEL_DEFAULT
+public const ZSTD_MAGICNUMBER: uint = c.ZSTD_MAGICNUMBER
+public const ZSTD_MAGIC_DICTIONARY: uint = c.ZSTD_MAGIC_DICTIONARY
+public const ZSTD_MAGIC_SKIPPABLE_START: int = c.ZSTD_MAGIC_SKIPPABLE_START
+public const ZSTD_MAGIC_SKIPPABLE_MASK: uint = c.ZSTD_MAGIC_SKIPPABLE_MASK
+public const ZSTD_BLOCKSIZELOG_MAX: int = c.ZSTD_BLOCKSIZELOG_MAX
+
+public foreign function version_number() -> uint = c.ZSTD_versionNumber
+public foreign function version_string() -> cstr = c.ZSTD_versionString
+public foreign function compress(dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, compression_level: int) -> ptr_uint = c.ZSTD_compress
+public foreign function decompress(dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], compressed_size: ptr_uint) -> ptr_uint = c.ZSTD_decompress
+public foreign function get_frame_content_size(src: const_ptr[void], src_size: ptr_uint) -> ulong = c.ZSTD_getFrameContentSize
+public foreign function get_decompressed_size(src: const_ptr[void], src_size: ptr_uint) -> ulong = c.ZSTD_getDecompressedSize
+public foreign function find_frame_compressed_size(src: const_ptr[void], src_size: ptr_uint) -> ptr_uint = c.ZSTD_findFrameCompressedSize
+public foreign function compress_bound(src_size: ptr_uint) -> ptr_uint = c.ZSTD_compressBound
+public foreign function is_error(result: ptr_uint) -> uint = c.ZSTD_isError
+public foreign function get_error_name(result: ptr_uint) -> cstr = c.ZSTD_getErrorName
+public foreign function min_c_level() -> int = c.ZSTD_minCLevel
+public foreign function max_c_level() -> int = c.ZSTD_maxCLevel
+public foreign function default_c_level() -> int = c.ZSTD_defaultCLevel
+public foreign function create_c_ctx() -> ptr[ZSTD_CCtx] = c.ZSTD_createCCtx
+public foreign function free_c_ctx(cctx: ptr[ZSTD_CCtx]) -> ptr_uint = c.ZSTD_freeCCtx
+public foreign function compress_c_ctx(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, compression_level: int) -> ptr_uint = c.ZSTD_compressCCtx
+public foreign function create_d_ctx() -> ptr[ZSTD_DCtx] = c.ZSTD_createDCtx
+public foreign function free_d_ctx(dctx: ptr[ZSTD_DCtx]) -> ptr_uint = c.ZSTD_freeDCtx
+public foreign function decompress_d_ctx(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint) -> ptr_uint = c.ZSTD_decompressDCtx
+public foreign function c_ctx_set_parameter(cctx: ptr[ZSTD_CCtx], param: ZSTD_cParameter, value: int) -> ptr_uint = c.ZSTD_CCtx_setParameter
+public foreign function c_ctx_set_pledged_src_size(cctx: ptr[ZSTD_CCtx], pledged_src_size: ulong) -> ptr_uint = c.ZSTD_CCtx_setPledgedSrcSize
+public foreign function c_ctx_reset(cctx: ptr[ZSTD_CCtx], reset: ZSTD_ResetDirective) -> ptr_uint = c.ZSTD_CCtx_reset
+public foreign function compress2(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint) -> ptr_uint = c.ZSTD_compress2
+public foreign function d_ctx_set_parameter(dctx: ptr[ZSTD_DCtx], param: ZSTD_dParameter, value: int) -> ptr_uint = c.ZSTD_DCtx_setParameter
+public foreign function d_ctx_reset(dctx: ptr[ZSTD_DCtx], reset: ZSTD_ResetDirective) -> ptr_uint = c.ZSTD_DCtx_reset
+public foreign function create_c_stream() -> ptr[ZSTD_CStream] = c.ZSTD_createCStream
+public foreign function free_c_stream(zcs: ptr[ZSTD_CStream]) -> ptr_uint = c.ZSTD_freeCStream
+public foreign function compress_stream2(cctx: ptr[ZSTD_CCtx], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer], end_op: ZSTD_EndDirective) -> ptr_uint = c.ZSTD_compressStream2
+public foreign function c_stream_in_size() -> ptr_uint = c.ZSTD_CStreamInSize
+public foreign function c_stream_out_size() -> ptr_uint = c.ZSTD_CStreamOutSize
+public foreign function init_c_stream(zcs: ptr[ZSTD_CStream], compression_level: int) -> ptr_uint = c.ZSTD_initCStream
+public foreign function compress_stream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer]) -> ptr_uint = c.ZSTD_compressStream
+public foreign function flush_stream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer]) -> ptr_uint = c.ZSTD_flushStream
+public foreign function end_stream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer]) -> ptr_uint = c.ZSTD_endStream
+public foreign function create_d_stream() -> ptr[ZSTD_DStream] = c.ZSTD_createDStream
+public foreign function free_d_stream(zds: ptr[ZSTD_DStream]) -> ptr_uint = c.ZSTD_freeDStream
+public foreign function init_d_stream(zds: ptr[ZSTD_DStream]) -> ptr_uint = c.ZSTD_initDStream
+public foreign function decompress_stream(zds: ptr[ZSTD_DStream], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer]) -> ptr_uint = c.ZSTD_decompressStream
+public foreign function d_stream_in_size() -> ptr_uint = c.ZSTD_DStreamInSize
+public foreign function d_stream_out_size() -> ptr_uint = c.ZSTD_DStreamOutSize
+public foreign function compress_using_dict(ctx: ptr[ZSTD_CCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, dict: const_ptr[void], dict_size: ptr_uint, compression_level: int) -> ptr_uint = c.ZSTD_compress_usingDict
+public foreign function decompress_using_dict(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, dict: const_ptr[void], dict_size: ptr_uint) -> ptr_uint = c.ZSTD_decompress_usingDict
+public foreign function create_c_dict(dict_buffer: const_ptr[void], dict_size: ptr_uint, compression_level: int) -> ptr[ZSTD_CDict] = c.ZSTD_createCDict
+public foreign function free_c_dict(c_dict: ptr[ZSTD_CDict]) -> ptr_uint = c.ZSTD_freeCDict
+public foreign function compress_using_c_dict(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, cdict: const_ptr[ZSTD_CDict]) -> ptr_uint = c.ZSTD_compress_usingCDict
+public foreign function create_d_dict(dict_buffer: const_ptr[void], dict_size: ptr_uint) -> ptr[ZSTD_DDict] = c.ZSTD_createDDict
+public foreign function free_d_dict(ddict: ptr[ZSTD_DDict]) -> ptr_uint = c.ZSTD_freeDDict
+public foreign function decompress_using_d_dict(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dst_capacity: ptr_uint, src: const_ptr[void], src_size: ptr_uint, ddict: const_ptr[ZSTD_DDict]) -> ptr_uint = c.ZSTD_decompress_usingDDict
+public foreign function get_dict_id_from_dict(dict: const_ptr[void], dict_size: ptr_uint) -> uint = c.ZSTD_getDictID_fromDict
+public foreign function get_dict_id_from_c_dict(cdict: const_ptr[ZSTD_CDict]) -> uint = c.ZSTD_getDictID_fromCDict
+public foreign function get_dict_id_from_d_dict(ddict: const_ptr[ZSTD_DDict]) -> uint = c.ZSTD_getDictID_fromDDict
+public foreign function get_dict_id_from_frame(src: const_ptr[void], src_size: ptr_uint) -> uint = c.ZSTD_getDictID_fromFrame
+public foreign function c_ctx_load_dictionary(cctx: ptr[ZSTD_CCtx], dict: const_ptr[void], dict_size: ptr_uint) -> ptr_uint = c.ZSTD_CCtx_loadDictionary
+public foreign function c_ctx_ref_c_dict(cctx: ptr[ZSTD_CCtx], cdict: const_ptr[ZSTD_CDict]) -> ptr_uint = c.ZSTD_CCtx_refCDict
+public foreign function c_ctx_ref_prefix(cctx: ptr[ZSTD_CCtx], prefix: const_ptr[void], prefix_size: ptr_uint) -> ptr_uint = c.ZSTD_CCtx_refPrefix
+public foreign function d_ctx_load_dictionary(dctx: ptr[ZSTD_DCtx], dict: const_ptr[void], dict_size: ptr_uint) -> ptr_uint = c.ZSTD_DCtx_loadDictionary
+public foreign function d_ctx_ref_d_dict(dctx: ptr[ZSTD_DCtx], ddict: const_ptr[ZSTD_DDict]) -> ptr_uint = c.ZSTD_DCtx_refDDict
+public foreign function d_ctx_ref_prefix(dctx: ptr[ZSTD_DCtx], prefix: const_ptr[void], prefix_size: ptr_uint) -> ptr_uint = c.ZSTD_DCtx_refPrefix
+public foreign function sizeof_c_ctx(cctx: const_ptr[ZSTD_CCtx]) -> ptr_uint = c.ZSTD_sizeof_CCtx
+public foreign function sizeof_d_ctx(dctx: const_ptr[ZSTD_DCtx]) -> ptr_uint = c.ZSTD_sizeof_DCtx
+public foreign function sizeof_c_stream(zcs: const_ptr[ZSTD_CStream]) -> ptr_uint = c.ZSTD_sizeof_CStream
+public foreign function sizeof_d_stream(zds: const_ptr[ZSTD_DStream]) -> ptr_uint = c.ZSTD_sizeof_DStream
+public foreign function sizeof_c_dict(cdict: const_ptr[ZSTD_CDict]) -> ptr_uint = c.ZSTD_sizeof_CDict
+public foreign function sizeof_d_dict(ddict: const_ptr[ZSTD_DDict]) -> ptr_uint = c.ZSTD_sizeof_DDict