mt-lang 0.2.0 → 0.2.1

data/std/serialize.mt

@@ -0,0 +1,68 @@
+import std.binary as bin
+import std.bytes as bytes
+import std.string as string
+
+
+function raw_unpack_error(message: str) -> bin.Error:
+    return bin.Error(code = -1, message = string.String.from_str(message))
+
+
+public function pack[T](v: ref[T]) -> bytes.Bytes:
+    let total = size_of(T)
+    var w = bin.Writer.with_capacity(total)
+    var src = unsafe: ptr[ubyte]<-ptr_of(v)
+    var i: ptr_uint = 0
+    while i < total:
+        w.write_ubyte(unsafe: read(src + i))
+        i += 1
+    return w.finish()
+
+
+public function unpack[T](source: span[ubyte]) -> Result[T, bin.Error]:
+    let total = size_of(T)
+    if source.len < total:
+        return Result[T, bin.Error].failure(
+            error = raw_unpack_error("source too short for target type")
+        )
+
+    var result = unsafe: zero[T]
+    var dest = unsafe: ptr[ubyte]<-ptr_of(result)
+    var i: ptr_uint = 0
+    while i < total:
+        unsafe: read(dest + i) = source[i]
+        i += 1
+    return Result[T, bin.Error].success(value = result)
+
+
+extending bin.Writer:
+    public editable function pack[T](v: ref[T]) -> void:
+        let total = size_of(T)
+        var src = unsafe: ptr[ubyte]<-ptr_of(v)
+        var i: ptr_uint = 0
+        while i < total:
+            this.write_ubyte(unsafe: read(src + i))
+            i += 1
+
+
+extending bin.Reader:
+    public editable function unpack[T]() -> Result[T, bin.Error]:
+        let total = size_of(T)
+        match this.read_bytes(total):
+            Result.failure as p:
+                return Result[T, bin.Error].failure(error = p.error)
+            Result.success as bp:
+                var raw_bytes = bp.value
+                defer raw_bytes.release()
+
+                let src_ptr = raw_bytes.data else:
+                    return Result[T, bin.Error].failure(
+                        error = raw_unpack_error("reader returned empty data")
+                    )
+
+                var result = unsafe: zero[T]
+                var dest = unsafe: ptr[ubyte]<-ptr_of(result)
+                var i: ptr_uint = 0
+                while i < total:
+                    unsafe: read(dest + i) = read(src_ptr + i)
+                    i += 1
+                return Result[T, bin.Error].success(value = result)

data/std/set.mt

@@ -0,0 +1,124 @@
+import std.map as map
+
+public struct Set[T]:
+    values: map.Map[T, bool]
+
+
+extending Set[T]:
+    public static function create() -> Set[T]:
+        return Set[T](values = map.Map[T, bool].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Set[T]:
+        var result = Set[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function get(value: T) -> const_ptr[T]?:
+        return this.values.get_key(value)
+
+
+    public function at(value: T) -> Option[T]:
+        let p = this.get(value) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(ptr[T]<-p))
+
+
+    public function contains(value: T) -> bool:
+        return this.values.contains(value)
+
+
+    public function iter() -> map.Keys[T, bool]:
+        return this.values.keys()
+
+
+    public function is_subset(other: Set[T]) -> bool:
+        if this.len() > other.len():
+            return false
+
+        for value in this:
+            unsafe:
+                if not other.contains(read(ptr[T]<-value)):
+                    return false
+
+        return true
+
+
+    public function union_with(other: Set[T]) -> Set[T]:
+        var result = Set[T].with_capacity(this.len() + other.len())
+
+        for value in this:
+            unsafe:
+                result.insert(read(ptr[T]<-value))
+
+        for value in other:
+            unsafe:
+                result.insert(read(ptr[T]<-value))
+
+        return result
+
+
+    public function intersection(other: Set[T]) -> Set[T]:
+        var result = Set[T].with_capacity(this.len())
+
+        if this.len() <= other.len():
+            for value in this:
+                unsafe:
+                    let current = read(ptr[T]<-value)
+                    if other.contains(current):
+                        result.insert(current)
+        else:
+            for value in other:
+                unsafe:
+                    let current = read(ptr[T]<-value)
+                    if this.contains(current):
+                        result.insert(current)
+
+        return result
+
+
+    public function difference(other: Set[T]) -> Set[T]:
+        var result = Set[T].with_capacity(this.len())
+
+        for value in this:
+            unsafe:
+                let current = read(ptr[T]<-value)
+                if not other.contains(current):
+                    result.insert(current)
+
+        return result
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function insert(value: T) -> bool:
+        return this.values.set(value, true).is_none()
+
+
+    public editable function remove(value: T) -> bool:
+        return this.values.remove(value).is_some()

data/std/spatial.mt

@@ -0,0 +1,176 @@
+import std.vec as vec
+
+public struct SpatialGrid[T]:
+    cells: vec.Vec[vec.Vec[T]]
+    cell_size: float
+    cols: uint
+    rows: uint
+    origin_x: float
+    origin_y: float
+
+
+extending SpatialGrid[T]:
+    public editable function release() -> void:
+        var i: ptr_uint = 0
+        while i < this.cells.len():
+            let cell_ptr = this.cells.get(i) else:
+                break
+            unsafe: read(cell_ptr).release()
+            i += 1
+        this.cells.release()
+
+
+function cell_index[T](grid: ref[SpatialGrid[T]], x: float, y: float) -> Option[ptr_uint]:
+    let cx = int<-(float<-((x - grid.origin_x) / grid.cell_size))
+    let cy = int<-(float<-((y - grid.origin_y) / grid.cell_size))
+    if cx < 0 or cy < 0 or uint<-cx >= grid.cols or uint<-cy >= grid.rows:
+        return Option[ptr_uint].none()
+    return Option[ptr_uint].some(value = ptr_uint<-cx + ptr_uint<-cy * ptr_uint<-grid.cols)
+
+
+public function new[T](cell_size: float, width: float, height: float) -> SpatialGrid[T]:
+    var cols: uint = uint<-(float<-width / cell_size)
+    var rows: uint = uint<-(float<-height / cell_size)
+    if cols == 0:
+        cols = 1
+    if rows == 0:
+        rows = 1
+
+    var cells = vec.Vec[vec.Vec[T]].create()
+    var total: ptr_uint = ptr_uint<-cols * ptr_uint<-rows
+    var i: ptr_uint = 0
+    while i < total:
+        cells.push(vec.Vec[T].create())
+        i += 1
+
+    return SpatialGrid[T](
+        cells = cells,
+        cell_size = cell_size,
+        cols = cols,
+        rows = rows,
+        origin_x = 0.0,
+        origin_y = 0.0
+    )
+
+
+public function new_with_origin[T](
+    cell_size: float,
+    width: float,
+    height: float,
+    origin_x: float,
+    origin_y: float
+) -> SpatialGrid[T]:
+    var grid = new[T](cell_size, width, height)
+    grid.origin_x = origin_x
+    grid.origin_y = origin_y
+    return grid
+
+
+extending SpatialGrid[T]:
+    public editable function insert(entity: T, x: float, y: float) -> void:
+        let idx_opt = cell_index(ref_of(this), x, y)
+        match idx_opt:
+            Option.some as ip:
+                let cell_ptr = this.cells.get(ip.value) else:
+                    return
+                unsafe: read(cell_ptr).push(entity)
+            Option.none:
+                return
+
+
+    public editable function insert_many(items: span[T], xs: span[float], ys: span[float]) -> void:
+        var i: ptr_uint = 0
+        let count = items.len
+        while i < count:
+            this.insert(items[i], xs[i], ys[i])
+            i += 1
+
+
+    public editable function query_radius(x: float, y: float, radius: float) -> vec.Vec[T]:
+        var result = vec.Vec[T].create()
+        let min_x = x - radius
+        let min_y = y - radius
+        let max_x = x + radius
+        let max_y = y + radius
+
+        let min_idx = cell_index(ref_of(this), min_x, min_y)
+        let max_idx = cell_index(ref_of(this), max_x, max_y)
+
+        var start_col: ptr_uint = 0
+        var end_col: ptr_uint = ptr_uint<-this.cols
+        var start_row: ptr_uint = 0
+        var end_row: ptr_uint = ptr_uint<-this.rows
+
+        match min_idx:
+            Option.some as mp:
+                start_col = mp.value % ptr_uint<-this.cols
+                start_row = mp.value / ptr_uint<-this.cols
+            Option.none:
+                return result
+
+        match max_idx:
+            Option.some as mp:
+                let ec = mp.value % ptr_uint<-this.cols
+                let er = mp.value / ptr_uint<-this.cols
+                if ec + 1z < end_col:
+                    end_col = ec + 1z
+                if er + 1z < end_row:
+                    end_row = er + 1z
+            Option.none:
+                pass
+
+        var cy: ptr_uint = start_row
+        while cy < end_row:
+            var cx: ptr_uint = start_col
+            while cx < end_col:
+                let idx = cx + cy * ptr_uint<-this.cols
+                let cell_ptr = this.cells.get(idx) else:
+                    cx += 1
+                    continue
+                var cell = unsafe: read(cell_ptr)
+                var k: ptr_uint = 0
+                while k < cell.len():
+                    let item_ptr = cell.get(k) else:
+                        break
+                    result.push(unsafe: read(item_ptr))
+                    k += 1
+                cx += 1
+            cy += 1
+
+        return result
+
+
+    public editable function clear() -> void:
+        var i: ptr_uint = 0
+        while i < this.cells.len():
+            let cell_ptr = this.cells.get(i) else:
+                break
+            unsafe: read(cell_ptr).clear()
+            i += 1
+
+
+    public function cell_count() -> ptr_uint:
+        return ptr_uint<-this.cols * ptr_uint<-this.rows
+
+
+    public function occupied_cells() -> uint:
+        var count: ptr_uint = 0
+        var i: ptr_uint = 0
+        while i < this.cells.len():
+            let cell_ptr = this.cells.get(i) else:
+                break
+            if not unsafe: read(cell_ptr).is_empty():
+                count += 1
+            i += 1
+        return uint<-count
+
+
+    public function entity_count() -> ptr_uint:
+        var total: ptr_uint = 0
+        var i: ptr_uint = 0
+        while i < this.cells.len():
+            let cell_ptr = this.cells.get(i) else:
+                break
+            total += unsafe: read(cell_ptr).len()
+            i += 1
+        return total

data/std/sqlite3.mt

@@ -0,0 +1,151 @@
+# generated by mtc imported-bindings from std.c.sqlite3 using bindings/imported/sqlite3.binding.json
+
+import std.c.sqlite3 as c
+
+public type sqlite3_index_constraint = c.sqlite3_index_constraint
+public type sqlite3_index_orderby = c.sqlite3_index_orderby
+public type sqlite3_index_constraint_usage = c.sqlite3_index_constraint_usage
+public type sqlite3 = c.sqlite3
+public type sqlite3_int64 = c.sqlite3_int64
+public type sqlite3_uint64 = c.sqlite3_uint64
+public type sqlite3_file = c.sqlite3_file
+public type sqlite3_io_methods = c.sqlite3_io_methods
+public type sqlite3_vfs = c.sqlite3_vfs
+public type sqlite3_stmt = c.sqlite3_stmt
+public type sqlite3_value = c.sqlite3_value
+public type sqlite3_context = c.sqlite3_context
+public type sqlite3_module = c.sqlite3_module
+public type sqlite3_index_info = c.sqlite3_index_info
+public type sqlite3_vtab = c.sqlite3_vtab
+public type sqlite3_vtab_cursor = c.sqlite3_vtab_cursor
+public type sqlite3_blob = c.sqlite3_blob
+public type sqlite3_backup = c.sqlite3_backup
+
+public const OK: int = c.SQLITE_OK
+public const ERROR: int = c.SQLITE_ERROR
+public const INTERNAL: int = c.SQLITE_INTERNAL
+public const PERM: int = c.SQLITE_PERM
+public const ABORT: int = c.SQLITE_ABORT
+public const BUSY: int = c.SQLITE_BUSY
+public const LOCKED: int = c.SQLITE_LOCKED
+public const NOMEM: int = c.SQLITE_NOMEM
+public const READONLY: int = c.SQLITE_READONLY
+public const INTERRUPT: int = c.SQLITE_INTERRUPT
+public const IOERR: int = c.SQLITE_IOERR
+public const CORRUPT: int = c.SQLITE_CORRUPT
+public const NOTFOUND: int = c.SQLITE_NOTFOUND
+public const FULL: int = c.SQLITE_FULL
+public const CANTOPEN: int = c.SQLITE_CANTOPEN
+public const PROTOCOL: int = c.SQLITE_PROTOCOL
+public const EMPTY: int = c.SQLITE_EMPTY
+public const SCHEMA: int = c.SQLITE_SCHEMA
+public const TOOBIG: int = c.SQLITE_TOOBIG
+public const CONSTRAINT: int = c.SQLITE_CONSTRAINT
+public const MISMATCH: int = c.SQLITE_MISMATCH
+public const MISUSE: int = c.SQLITE_MISUSE
+public const NOLFS: int = c.SQLITE_NOLFS
+public const AUTH: int = c.SQLITE_AUTH
+public const FORMAT: int = c.SQLITE_FORMAT
+public const RANGE: int = c.SQLITE_RANGE
+public const NOTADB: int = c.SQLITE_NOTADB
+public const NOTICE: int = c.SQLITE_NOTICE
+public const WARNING: int = c.SQLITE_WARNING
+public const ROW: int = c.SQLITE_ROW
+public const DONE: int = c.SQLITE_DONE
+public const OPEN_READONLY: int = c.SQLITE_OPEN_READONLY
+public const OPEN_READWRITE: int = c.SQLITE_OPEN_READWRITE
+public const OPEN_CREATE: int = c.SQLITE_OPEN_CREATE
+public const OPEN_URI: int = c.SQLITE_OPEN_URI
+public const OPEN_MEMORY: int = c.SQLITE_OPEN_MEMORY
+public const INTEGER: int = c.SQLITE_INTEGER
+public const FLOAT: int = c.SQLITE_FLOAT
+public const BLOB: int = c.SQLITE_BLOB
+public const NULL: int = c.SQLITE_NULL
+public const TEXT: int = c.SQLITE_TEXT
+public const UTF8: int = c.SQLITE_UTF8
+public const UTF16LE: int = c.SQLITE_UTF16LE
+public const UTF16BE: int = c.SQLITE_UTF16BE
+public const UTF16: int = c.SQLITE_UTF16
+public const ANY: int = c.SQLITE_ANY
+public const DETERMINISTIC: int = c.SQLITE_DETERMINISTIC
+public const DIRECTONLY: int = c.SQLITE_DIRECTONLY
+public const SUBTYPE: int = c.SQLITE_SUBTYPE
+public const INNOCUOUS: int = c.SQLITE_INNOCUOUS
+public const RESULT_SUBTYPE: int = c.SQLITE_RESULT_SUBTYPE
+public const SELFORDER1: int = c.SQLITE_SELFORDER1
+public const INDEX_CONSTRAINT_EQ: int = c.SQLITE_INDEX_CONSTRAINT_EQ
+public const INDEX_CONSTRAINT_GT: int = c.SQLITE_INDEX_CONSTRAINT_GT
+public const INDEX_CONSTRAINT_LE: int = c.SQLITE_INDEX_CONSTRAINT_LE
+public const INDEX_CONSTRAINT_LT: int = c.SQLITE_INDEX_CONSTRAINT_LT
+public const INDEX_CONSTRAINT_GE: int = c.SQLITE_INDEX_CONSTRAINT_GE
+public const INDEX_CONSTRAINT_MATCH: int = c.SQLITE_INDEX_CONSTRAINT_MATCH
+public const INDEX_CONSTRAINT_LIKE: int = c.SQLITE_INDEX_CONSTRAINT_LIKE
+public const INDEX_CONSTRAINT_GLOB: int = c.SQLITE_INDEX_CONSTRAINT_GLOB
+public const INDEX_CONSTRAINT_REGEXP: int = c.SQLITE_INDEX_CONSTRAINT_REGEXP
+public const INDEX_CONSTRAINT_NE: int = c.SQLITE_INDEX_CONSTRAINT_NE
+public const INDEX_CONSTRAINT_ISNOT: int = c.SQLITE_INDEX_CONSTRAINT_ISNOT
+public const INDEX_CONSTRAINT_ISNOTNULL: int = c.SQLITE_INDEX_CONSTRAINT_ISNOTNULL
+public const INDEX_CONSTRAINT_ISNULL: int = c.SQLITE_INDEX_CONSTRAINT_ISNULL
+public const INDEX_CONSTRAINT_IS: int = c.SQLITE_INDEX_CONSTRAINT_IS
+public const INDEX_CONSTRAINT_LIMIT: int = c.SQLITE_INDEX_CONSTRAINT_LIMIT
+public const INDEX_CONSTRAINT_OFFSET: int = c.SQLITE_INDEX_CONSTRAINT_OFFSET
+public const INDEX_CONSTRAINT_FUNCTION: int = c.SQLITE_INDEX_CONSTRAINT_FUNCTION
+public const VTAB_CONSTRAINT_SUPPORT: int = c.SQLITE_VTAB_CONSTRAINT_SUPPORT
+public const VTAB_INNOCUOUS: int = c.SQLITE_VTAB_INNOCUOUS
+public const VTAB_DIRECTONLY: int = c.SQLITE_VTAB_DIRECTONLY
+public const VTAB_USES_ALL_SCHEMAS: int = c.SQLITE_VTAB_USES_ALL_SCHEMAS
+
+public foreign function libversion() -> cstr = c.sqlite3_libversion
+public foreign function sourceid() -> cstr = c.sqlite3_sourceid
+public foreign function libversion_number() -> int = c.sqlite3_libversion_number
+public foreign function close(arg0: ptr[sqlite3]) -> int = c.sqlite3_close
+public foreign function close_v2(arg0: ptr[sqlite3]) -> int = c.sqlite3_close_v2
+public foreign function exec(arg0: ptr[sqlite3], sql: str as cstr, callback: fn(arg0: ptr[void], arg1: int, arg2: ptr[ptr[char]], arg3: ptr[ptr[char]]) -> int, arg3: ptr[void], errmsg: ptr[ptr[char]]) -> int = c.sqlite3_exec
+public foreign function last_insert_rowid(arg0: ptr[sqlite3]) -> sqlite3_int64 = c.sqlite3_last_insert_rowid
+public foreign function changes(arg0: ptr[sqlite3]) -> int = c.sqlite3_changes
+public foreign function busy_timeout(arg0: ptr[sqlite3], ms: int) -> int = c.sqlite3_busy_timeout
+public foreign function free(arg0: ptr[void]) -> void = c.sqlite3_free
+public foreign function open(filename: str as cstr, pp_db: ptr[ptr[sqlite3]]) -> int = c.sqlite3_open
+public foreign function open_v2(filename: str as cstr, pp_db: ptr[ptr[sqlite3]], flags_: int, z_vfs: str as cstr) -> int = c.sqlite3_open_v2
+public foreign function errcode(db: ptr[sqlite3]) -> int = c.sqlite3_errcode
+public foreign function extended_errcode(db: ptr[sqlite3]) -> int = c.sqlite3_extended_errcode
+public foreign function errmsg(arg0: ptr[sqlite3]) -> cstr = c.sqlite3_errmsg
+public foreign function errstr(arg0: int) -> cstr = c.sqlite3_errstr
+public foreign function prepare_v2(db: ptr[sqlite3], z_sql: str as cstr, n_byte: int, pp_stmt: ptr[ptr[sqlite3_stmt]], pz_tail: ptr[cstr]) -> int = c.sqlite3_prepare_v2
+public foreign function bind_blob(arg0: ptr[sqlite3_stmt], arg1: int, arg2: const_ptr[void], n: int, arg4: fn(arg0: ptr[void]) -> void) -> int = c.sqlite3_bind_blob
+public foreign function bind_double(arg0: ptr[sqlite3_stmt], arg1: int, arg2: double) -> int = c.sqlite3_bind_double
+public foreign function bind_int(arg0: ptr[sqlite3_stmt], arg1: int, arg2: int) -> int = c.sqlite3_bind_int
+public foreign function bind_int64(arg0: ptr[sqlite3_stmt], arg1: int, arg2: long) -> int = c.sqlite3_bind_int64
+public foreign function bind_null(arg0: ptr[sqlite3_stmt], arg1: int) -> int = c.sqlite3_bind_null
+public foreign function bind_text(arg0: ptr[sqlite3_stmt], arg1: int, arg2: str as cstr, arg3: int, arg4: fn(arg0: ptr[void]) -> void) -> int = c.sqlite3_bind_text
+public foreign function bind_parameter_count(arg0: ptr[sqlite3_stmt]) -> int = c.sqlite3_bind_parameter_count
+public foreign function bind_parameter_index(arg0: ptr[sqlite3_stmt], z_name: str as cstr) -> int = c.sqlite3_bind_parameter_index
+public foreign function clear_bindings(arg0: ptr[sqlite3_stmt]) -> int = c.sqlite3_clear_bindings
+public foreign function column_count(p_stmt: ptr[sqlite3_stmt]) -> int = c.sqlite3_column_count
+public foreign function column_name(arg0: ptr[sqlite3_stmt], n: int) -> cstr = c.sqlite3_column_name
+public foreign function step(arg0: ptr[sqlite3_stmt]) -> int = c.sqlite3_step
+public foreign function column_blob(arg0: ptr[sqlite3_stmt], i_col: int) -> const_ptr[void] = c.sqlite3_column_blob
+public foreign function column_double(arg0: ptr[sqlite3_stmt], i_col: int) -> double = c.sqlite3_column_double
+public foreign function column_int(arg0: ptr[sqlite3_stmt], i_col: int) -> int = c.sqlite3_column_int
+public foreign function column_int64(arg0: ptr[sqlite3_stmt], i_col: int) -> sqlite3_int64 = c.sqlite3_column_int64
+public foreign function column_text(arg0: ptr[sqlite3_stmt], i_col: int) -> const_ptr[ubyte] = c.sqlite3_column_text
+public foreign function column_bytes(arg0: ptr[sqlite3_stmt], i_col: int) -> int = c.sqlite3_column_bytes
+public foreign function column_type(arg0: ptr[sqlite3_stmt], i_col: int) -> int = c.sqlite3_column_type
+public foreign function finalize(p_stmt: ptr[sqlite3_stmt]) -> int = c.sqlite3_finalize
+public foreign function reset(p_stmt: ptr[sqlite3_stmt]) -> int = c.sqlite3_reset
+public foreign function create_module(db: ptr[sqlite3], z_name: str as cstr, p: const_ptr[sqlite3_module], p_client_data: ptr[void]) -> int = c.sqlite3_create_module
+public foreign function create_module_v2(db: ptr[sqlite3], z_name: str as cstr, p: const_ptr[sqlite3_module], p_client_data: ptr[void], x_destroy: fn(arg0: ptr[void]) -> void) -> int = c.sqlite3_create_module_v2
+public foreign function drop_modules(db: ptr[sqlite3], az_keep: ptr[cstr]) -> int = c.sqlite3_drop_modules
+public foreign function declare_vtab(arg0: ptr[sqlite3], z_sql: str as cstr) -> int = c.sqlite3_declare_vtab
+public foreign function overload_function(arg0: ptr[sqlite3], z_func_name: str as cstr, n_arg: int) -> int = c.sqlite3_overload_function
+public foreign function vfs_find(z_vfs_name: str as cstr) -> ptr[sqlite3_vfs] = c.sqlite3_vfs_find
+public foreign function vfs_register(arg0: ptr[sqlite3_vfs], make_dflt: int) -> int = c.sqlite3_vfs_register
+public foreign function vfs_unregister(arg0: ptr[sqlite3_vfs]) -> int = c.sqlite3_vfs_unregister
+public foreign function vtab_on_conflict(arg0: ptr[sqlite3]) -> int = c.sqlite3_vtab_on_conflict
+public foreign function vtab_nochange(arg0: ptr[sqlite3_context]) -> int = c.sqlite3_vtab_nochange
+public foreign function vtab_collation(arg0: ptr[sqlite3_index_info], arg1: int) -> cstr = c.sqlite3_vtab_collation
+public foreign function vtab_distinct(arg0: ptr[sqlite3_index_info]) -> int = c.sqlite3_vtab_distinct
+public foreign function vtab_in(arg0: ptr[sqlite3_index_info], i_cons: int, b_handle: int) -> int = c.sqlite3_vtab_in
+public foreign function vtab_in_first(p_val: ptr[sqlite3_value], pp_out: ptr[ptr[sqlite3_value]]) -> int = c.sqlite3_vtab_in_first
+public foreign function vtab_in_next(p_val: ptr[sqlite3_value], pp_out: ptr[ptr[sqlite3_value]]) -> int = c.sqlite3_vtab_in_next
+public foreign function vtab_rhs_value(arg0: ptr[sqlite3_index_info], arg1: int, pp_val: ptr[ptr[sqlite3_value]]) -> int = c.sqlite3_vtab_rhs_value

data/std/stack.mt

@@ -0,0 +1,55 @@
+import std.deque as deque
+
+public struct Stack[T]:
+    values: deque.Deque[T]
+
+
+extending Stack[T]:
+    public static function create() -> Stack[T]:
+        return Stack[T](values = deque.Deque[T].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Stack[T]:
+        var result = Stack[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function iter() -> deque.Iter[T]:
+        return this.values.iter()
+
+
+    public function peek() -> ptr[T]?:
+        return this.values.last()
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function push(value: T) -> void:
+        this.values.push_back(value)
+
+
+    public editable function pop() -> Option[T]:
+        return this.values.pop_back()

data/std/stb_image.mt

@@ -0,0 +1,47 @@
+# generated by mtc imported-bindings from std.c.stb_image using bindings/imported/stb_image.binding.json
+
+import std.c.stb_image as c
+
+public type uc = c.stbi_uc
+public type us = c.stbi_us
+public type io_callbacks = c.stbi_io_callbacks
+
+public const VERSION: int = c.STBI_VERSION
+
+public foreign function load_from_memory(buffer: const_ptr[uc], len: int, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[uc]? = c.stbi_load_from_memory
+public foreign function load_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void], x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[uc]? = c.stbi_load_from_callbacks
+public foreign function load(filename: cstr, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[uc]? = c.stbi_load
+public foreign function load_gif_from_memory(buffer: const_ptr[uc], len: int, delays: ptr[ptr[int]], x: ptr[int], y: ptr[int], z: ptr[int], comp: ptr[int], req_comp: int) -> ptr[uc]? = c.stbi_load_gif_from_memory
+public foreign function load_16_from_memory(buffer: const_ptr[uc], len: int, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[us]? = c.stbi_load_16_from_memory
+public foreign function load_16_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void], x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[us]? = c.stbi_load_16_from_callbacks
+public foreign function load_16(filename: cstr, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[us]? = c.stbi_load_16
+public foreign function loadf_from_memory(buffer: const_ptr[uc], len: int, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[float]? = c.stbi_loadf_from_memory
+public foreign function loadf_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void], x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[float]? = c.stbi_loadf_from_callbacks
+public foreign function loadf(filename: cstr, x: ptr[int], y: ptr[int], channels_in_file: ptr[int], desired_channels: int) -> ptr[float]? = c.stbi_loadf
+public foreign function hdr_to_ldr_gamma(gamma: float) -> void = c.stbi_hdr_to_ldr_gamma
+public foreign function hdr_to_ldr_scale(scale: float) -> void = c.stbi_hdr_to_ldr_scale
+public foreign function ldr_to_hdr_gamma(gamma: float) -> void = c.stbi_ldr_to_hdr_gamma
+public foreign function ldr_to_hdr_scale(scale: float) -> void = c.stbi_ldr_to_hdr_scale
+public foreign function is_hdr_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void]) -> int = c.stbi_is_hdr_from_callbacks
+public foreign function is_hdr_from_memory(buffer: const_ptr[uc], len: int) -> int = c.stbi_is_hdr_from_memory
+public foreign function is_hdr(filename: str as cstr) -> int = c.stbi_is_hdr
+public foreign function failure_reason() -> cstr? = c.stbi_failure_reason
+public foreign function image_free(retval_from_stbi_load: ptr[void]) -> void = c.stbi_image_free
+public foreign function info_from_memory(buffer: const_ptr[uc], len: int, x: ptr[int], y: ptr[int], comp: ptr[int]) -> int = c.stbi_info_from_memory
+public foreign function info_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void], x: ptr[int], y: ptr[int], comp: ptr[int]) -> int = c.stbi_info_from_callbacks
+public foreign function is_16_bit_from_memory(buffer: const_ptr[uc], len: int) -> int = c.stbi_is_16_bit_from_memory
+public foreign function is_16_bit_from_callbacks(clbk: const_ptr[io_callbacks], user: ptr[void]) -> int = c.stbi_is_16_bit_from_callbacks
+public foreign function info(filename: str as cstr, x: ptr[int], y: ptr[int], comp: ptr[int]) -> int = c.stbi_info
+public foreign function is_16_bit(filename: str as cstr) -> int = c.stbi_is_16_bit
+public foreign function set_unpremultiply_on_load(flag_true_if_should_unpremultiply: int) -> void = c.stbi_set_unpremultiply_on_load
+public foreign function convert_iphone_png_to_rgb(flag_true_if_should_convert: int) -> void = c.stbi_convert_iphone_png_to_rgb
+public foreign function set_flip_vertically_on_load(flag_true_if_should_flip: int) -> void = c.stbi_set_flip_vertically_on_load
+public foreign function set_unpremultiply_on_load_thread(flag_true_if_should_unpremultiply: int) -> void = c.stbi_set_unpremultiply_on_load_thread
+public foreign function convert_iphone_png_to_rgb_thread(flag_true_if_should_convert: int) -> void = c.stbi_convert_iphone_png_to_rgb_thread
+public foreign function set_flip_vertically_on_load_thread(flag_true_if_should_flip: int) -> void = c.stbi_set_flip_vertically_on_load_thread
+public foreign function zlib_decode_malloc_guesssize(buffer: cstr, len: int, initial_size: int, outlen: ptr[int]) -> ptr[char]? = c.stbi_zlib_decode_malloc_guesssize
+public foreign function zlib_decode_malloc_guesssize_headerflag(buffer: cstr, len: int, initial_size: int, outlen: ptr[int], parse_header: int) -> ptr[char]? = c.stbi_zlib_decode_malloc_guesssize_headerflag
+public foreign function zlib_decode_malloc(buffer: cstr, len: int, outlen: ptr[int]) -> ptr[char]? = c.stbi_zlib_decode_malloc
+public foreign function zlib_decode_buffer(obuffer: ptr[char], olen: int, ibuffer: str as cstr, ilen: int) -> int = c.stbi_zlib_decode_buffer
+public foreign function zlib_decode_noheader_malloc(buffer: cstr, len: int, outlen: ptr[int]) -> ptr[char]? = c.stbi_zlib_decode_noheader_malloc
+public foreign function zlib_decode_noheader_buffer(obuffer: ptr[char], olen: int, ibuffer: str as cstr, ilen: int) -> int = c.stbi_zlib_decode_noheader_buffer

data/std/stb_image_resize2.mt

@@ -0,0 +1,41 @@
+# generated by mtc imported-bindings from std.c.stb_image_resize2 using bindings/imported/stb_image_resize2.binding.json
+
+import std.c.stb_image_resize2 as c
+
+public type uint8 = c.stbir_uint8
+public type uint16 = c.stbir_uint16
+public type uint32 = c.stbir_uint32
+public type uint64 = c.stbir_uint64
+public type pixel_layout = c.stbir_pixel_layout
+public type edge = c.stbir_edge
+public type filter = c.stbir_filter
+public type datatype = c.stbir_datatype
+public type input_callback = c.stbir_input_callback
+public type output_callback = c.stbir_output_callback
+public type _kernel_callback = c.stbir__kernel_callback
+public type _support_callback = c.stbir__support_callback
+public type _info = c.stbir__info
+public type STBIR_RESIZE = c.STBIR_RESIZE
+
+public foreign function resize_uint8_srgb(input_pixels: const_ptr[ubyte], input_w: int, input_h: int, input_stride_in_bytes: int, output_pixels: ptr[ubyte], output_w: int, output_h: int, output_stride_in_bytes: int, pixel_type: pixel_layout) -> ptr[ubyte] = c.stbir_resize_uint8_srgb
+public foreign function resize_uint8_linear(input_pixels: const_ptr[ubyte], input_w: int, input_h: int, input_stride_in_bytes: int, output_pixels: ptr[ubyte], output_w: int, output_h: int, output_stride_in_bytes: int, pixel_type: pixel_layout) -> ptr[ubyte] = c.stbir_resize_uint8_linear
+public foreign function resize_float_linear(input_pixels: const_ptr[float], input_w: int, input_h: int, input_stride_in_bytes: int, output_pixels: ptr[float], output_w: int, output_h: int, output_stride_in_bytes: int, pixel_type: pixel_layout) -> ptr[float] = c.stbir_resize_float_linear
+public foreign function resize(input_pixels: const_ptr[void], input_w: int, input_h: int, input_stride_in_bytes: int, output_pixels: ptr[void], output_w: int, output_h: int, output_stride_in_bytes: int, pixel_layout: pixel_layout, data_type: datatype, edge: edge, filter: filter) -> ptr[void] = c.stbir_resize
+public foreign function resize_init(resize: ptr[STBIR_RESIZE], input_pixels: const_ptr[void], input_w: int, input_h: int, input_stride_in_bytes: int, output_pixels: ptr[void], output_w: int, output_h: int, output_stride_in_bytes: int, pixel_layout: pixel_layout, data_type: datatype) -> void = c.stbir_resize_init
+public foreign function set_datatypes(resize: ptr[STBIR_RESIZE], input_type: datatype, output_type: datatype) -> void = c.stbir_set_datatypes
+public foreign function set_pixel_callbacks(resize: ptr[STBIR_RESIZE], input_cb: ptr[input_callback], output_cb: ptr[output_callback]) -> void = c.stbir_set_pixel_callbacks
+public foreign function set_user_data(resize: ptr[STBIR_RESIZE], user_data: ptr[void]) -> void = c.stbir_set_user_data
+public foreign function set_buffer_ptrs(resize: ptr[STBIR_RESIZE], input_pixels: const_ptr[void], input_stride_in_bytes: int, output_pixels: ptr[void], output_stride_in_bytes: int) -> void = c.stbir_set_buffer_ptrs
+public foreign function set_pixel_layouts(resize: ptr[STBIR_RESIZE], input_pixel_layout: pixel_layout, output_pixel_layout: pixel_layout) -> int = c.stbir_set_pixel_layouts
+public foreign function set_edgemodes(resize: ptr[STBIR_RESIZE], horizontal_edge: edge, vertical_edge: edge) -> int = c.stbir_set_edgemodes
+public foreign function set_filters(resize: ptr[STBIR_RESIZE], horizontal_filter: filter, vertical_filter: filter) -> int = c.stbir_set_filters
+public foreign function set_filter_callbacks(resize: ptr[STBIR_RESIZE], horizontal_filter: ptr[_kernel_callback], horizontal_support: ptr[_support_callback], vertical_filter: ptr[_kernel_callback], vertical_support: ptr[_support_callback]) -> int = c.stbir_set_filter_callbacks
+public foreign function set_pixel_subrect(resize: ptr[STBIR_RESIZE], subx: int, suby: int, subw: int, subh: int) -> int = c.stbir_set_pixel_subrect
+public foreign function set_input_subrect(resize: ptr[STBIR_RESIZE], s0: double, t0: double, s1: double, t1: double) -> int = c.stbir_set_input_subrect
+public foreign function set_output_pixel_subrect(resize: ptr[STBIR_RESIZE], subx: int, suby: int, subw: int, subh: int) -> int = c.stbir_set_output_pixel_subrect
+public foreign function set_non_pm_alpha_speed_over_quality(resize: ptr[STBIR_RESIZE], non_pma_alpha_speed_over_quality: int) -> int = c.stbir_set_non_pm_alpha_speed_over_quality
+public foreign function build_samplers(resize: ptr[STBIR_RESIZE]) -> int = c.stbir_build_samplers
+public foreign function free_samplers(resize: ptr[STBIR_RESIZE]) -> void = c.stbir_free_samplers
+public foreign function resize_extended(resize: ptr[STBIR_RESIZE]) -> int = c.stbir_resize_extended
+public foreign function build_samplers_with_splits(resize: ptr[STBIR_RESIZE], try_splits: int) -> int = c.stbir_build_samplers_with_splits
+public foreign function resize_extended_split(resize: ptr[STBIR_RESIZE], split_start: int, split_count: int) -> int = c.stbir_resize_extended_split