mt-lang 0.2.0 → 0.2.1

data/std/c/zlib_support.h

@@ -0,0 +1,239 @@
+#ifndef MT_ZLIB_SUPPORT_H
+#define MT_ZLIB_SUPPORT_H
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+
+typedef struct mt_zlib_bytes {
+  uint8_t* data;
+  uintptr_t len;
+} mt_zlib_bytes;
+
+typedef struct mt_zlib_error {
+  int code;
+  char* message_data;
+  uintptr_t message_len;
+} mt_zlib_error;
+
+static inline void mt_zlib_reset_bytes(mt_zlib_bytes* value) {
+  if (value == NULL) {
+    return;
+  }
+
+  value->data = NULL;
+  value->len = 0;
+}
+
+static inline void mt_zlib_reset_error(mt_zlib_error* error) {
+  if (error == NULL) {
+    return;
+  }
+
+  error->code = 0;
+  error->message_data = NULL;
+  error->message_len = 0;
+}
+
+static inline int mt_zlib_set_message(mt_zlib_error* error, int code, const char* prefix, const char* detail) {
+  if (error == NULL) {
+    return code == 0 ? -1 : code;
+  }
+
+  size_t prefix_len = prefix == NULL ? 0 : strlen(prefix);
+  size_t detail_len = detail == NULL ? 0 : strlen(detail);
+  size_t separator_len = prefix_len != 0 && detail_len != 0 ? 2 : 0;
+  size_t total_len = prefix_len + separator_len + detail_len;
+
+  char* message = NULL;
+  if (total_len != 0) {
+    message = (char*) malloc(total_len);
+    if (message != NULL) {
+      size_t offset = 0;
+      if (prefix_len != 0) {
+        memcpy(message + offset, prefix, prefix_len);
+        offset += prefix_len;
+      }
+      if (separator_len != 0) {
+        memcpy(message + offset, ": ", separator_len);
+        offset += separator_len;
+      }
+      if (detail_len != 0) {
+        memcpy(message + offset, detail, detail_len);
+      }
+    }
+  }
+
+  error->code = code;
+  error->message_data = message;
+  error->message_len = (uintptr_t) total_len;
+  return code == 0 ? -1 : code;
+}
+
+static inline int mt_zlib_set_zlib_error(mt_zlib_error* error, int code, const char* prefix, const char* detail) {
+  return mt_zlib_set_message(error, code, prefix, detail == NULL ? zError(code) : detail);
+}
+
+static inline int mt_gzip_compress(const uint8_t* data, uintptr_t len, int level, mt_zlib_bytes* out_bytes, mt_zlib_error* out_error) {
+  mt_zlib_reset_bytes(out_bytes);
+  mt_zlib_reset_error(out_error);
+
+  if (len != 0 && data == NULL) {
+    return mt_zlib_set_message(out_error, -1, "gzip compress failed", "missing input data");
+  }
+  if (level < -1 || level > 9) {
+    return mt_zlib_set_message(out_error, -1, "gzip compress failed", "compression level must be between -1 and 9");
+  }
+  if (len > UINT_MAX || len > ULONG_MAX) {
+    return mt_zlib_set_message(out_error, -1, "gzip compress failed", "input exceeds zlib range limits");
+  }
+
+  z_stream stream;
+  memset(&stream, 0, sizeof(stream));
+
+  int rc = deflateInit2(&stream, level, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY);
+  if (rc != Z_OK) {
+    return mt_zlib_set_zlib_error(out_error, rc, "gzip compress failed", stream.msg);
+  }
+
+  uLong bound = deflateBound(&stream, (uLong) len);
+  if (bound > UINT_MAX) {
+    deflateEnd(&stream);
+    return mt_zlib_set_message(out_error, -1, "gzip compress failed", "compressed output exceeds zlib range limits");
+  }
+
+  size_t capacity = (size_t) bound;
+  if (capacity < 64) {
+    capacity = 64;
+  }
+
+  uint8_t* output = (uint8_t*) malloc(capacity);
+  if (output == NULL) {
+    deflateEnd(&stream);
+    return mt_zlib_set_message(out_error, Z_MEM_ERROR, "gzip compress failed", "out of memory");
+  }
+
+  stream.next_in = len == 0 ? Z_NULL : (Bytef*) data;
+  stream.avail_in = (uInt) len;
+  stream.next_out = output;
+  stream.avail_out = (uInt) capacity;
+
+  rc = deflate(&stream, Z_FINISH);
+  if (rc != Z_STREAM_END) {
+    const char* detail = stream.msg;
+    if (rc == Z_OK || rc == Z_BUF_ERROR) {
+      detail = "compressed output buffer too small";
+    }
+
+    free(output);
+    deflateEnd(&stream);
+    return mt_zlib_set_zlib_error(out_error, rc == Z_OK ? Z_BUF_ERROR : rc, "gzip compress failed", detail);
+  }
+
+  size_t produced = (size_t) stream.total_out;
+  rc = deflateEnd(&stream);
+  if (rc != Z_OK) {
+    free(output);
+    return mt_zlib_set_zlib_error(out_error, rc, "gzip compress failed", NULL);
+  }
+
+  out_bytes->data = output;
+  out_bytes->len = (uintptr_t) produced;
+  return 0;
+}
+
+static inline int mt_gzip_decompress(const uint8_t* data, uintptr_t len, mt_zlib_bytes* out_bytes, mt_zlib_error* out_error) {
+  mt_zlib_reset_bytes(out_bytes);
+  mt_zlib_reset_error(out_error);
+
+  if (len != 0 && data == NULL) {
+    return mt_zlib_set_message(out_error, -1, "gzip decompress failed", "missing input data");
+  }
+  if (len > UINT_MAX) {
+    return mt_zlib_set_message(out_error, -1, "gzip decompress failed", "input exceeds zlib range limits");
+  }
+
+  z_stream stream;
+  memset(&stream, 0, sizeof(stream));
+
+  int rc = inflateInit2(&stream, MAX_WBITS + 16);
+  if (rc != Z_OK) {
+    return mt_zlib_set_zlib_error(out_error, rc, "gzip decompress failed", stream.msg);
+  }
+
+  size_t capacity = (size_t) len;
+  if (capacity < 64) {
+    capacity = 64;
+  }
+
+  uint8_t* output = (uint8_t*) malloc(capacity);
+  if (output == NULL) {
+    inflateEnd(&stream);
+    return mt_zlib_set_message(out_error, Z_MEM_ERROR, "gzip decompress failed", "out of memory");
+  }
+
+  stream.next_in = len == 0 ? Z_NULL : (Bytef*) data;
+  stream.avail_in = (uInt) len;
+  stream.next_out = output;
+  stream.avail_out = (uInt) capacity;
+
+  while (true) {
+    rc = inflate(&stream, Z_NO_FLUSH);
+    if (rc == Z_STREAM_END) {
+      break;
+    }
+
+    if (rc == Z_OK) {
+      if (stream.avail_out == 0) {
+        size_t next_capacity = capacity > (size_t) (UINT_MAX / 2) ? (size_t) UINT_MAX : capacity * 2;
+        if (next_capacity <= capacity) {
+          free(output);
+          inflateEnd(&stream);
+          return mt_zlib_set_message(out_error, -1, "gzip decompress failed", "decompressed output exceeds zlib range limits");
+        }
+
+        uint8_t* resized = (uint8_t*) realloc(output, next_capacity);
+        if (resized == NULL) {
+          free(output);
+          inflateEnd(&stream);
+          return mt_zlib_set_message(out_error, Z_MEM_ERROR, "gzip decompress failed", "out of memory");
+        }
+
+        output = resized;
+        stream.next_out = output + capacity;
+        stream.avail_out = (uInt) (next_capacity - capacity);
+        capacity = next_capacity;
+      }
+
+      continue;
+    }
+
+    free(output);
+    inflateEnd(&stream);
+    if (rc == Z_BUF_ERROR && stream.avail_in == 0) {
+      return mt_zlib_set_message(out_error, rc, "gzip decompress failed", "truncated gzip stream");
+    }
+
+    return mt_zlib_set_zlib_error(out_error, rc, "gzip decompress failed", stream.msg);
+  }
+
+  size_t produced = (size_t) stream.total_out;
+  rc = inflateEnd(&stream);
+  if (rc != Z_OK) {
+    free(output);
+    return mt_zlib_set_zlib_error(out_error, rc, "gzip decompress failed", NULL);
+  }
+
+  if (produced == 0) {
+    free(output);
+    output = NULL;
+  }
+
+  out_bytes->data = output;
+  out_bytes->len = (uintptr_t) produced;
+  return 0;
+}
+
+#endif

data/std/c/zstd.mt

@@ -0,0 +1,231 @@
+# generated by mtc bindgen from /usr/include/zstd.h
+external
+
+link "zstd"
+include "zstd.h"
+
+enum ZSTD_ErrorCode: int
+    ZSTD_error_no_error = 0
+    ZSTD_error_GENERIC = 1
+    ZSTD_error_prefix_unknown = 10
+    ZSTD_error_version_unsupported = 12
+    ZSTD_error_frameParameter_unsupported = 14
+    ZSTD_error_frameParameter_windowTooLarge = 16
+    ZSTD_error_corruption_detected = 20
+    ZSTD_error_checksum_wrong = 22
+    ZSTD_error_literals_headerWrong = 24
+    ZSTD_error_dictionary_corrupted = 30
+    ZSTD_error_dictionary_wrong = 32
+    ZSTD_error_dictionaryCreation_failed = 34
+    ZSTD_error_parameter_unsupported = 40
+    ZSTD_error_parameter_combination_unsupported = 41
+    ZSTD_error_parameter_outOfBound = 42
+    ZSTD_error_tableLog_tooLarge = 44
+    ZSTD_error_maxSymbolValue_tooLarge = 46
+    ZSTD_error_maxSymbolValue_tooSmall = 48
+    ZSTD_error_cannotProduce_uncompressedBlock = 49
+    ZSTD_error_stabilityCondition_notRespected = 50
+    ZSTD_error_stage_wrong = 60
+    ZSTD_error_init_missing = 62
+    ZSTD_error_memory_allocation = 64
+    ZSTD_error_workSpace_tooSmall = 66
+    ZSTD_error_dstSize_tooSmall = 70
+    ZSTD_error_srcSize_wrong = 72
+    ZSTD_error_dstBuffer_null = 74
+    ZSTD_error_noForwardProgress_destFull = 80
+    ZSTD_error_noForwardProgress_inputEmpty = 82
+    ZSTD_error_frameIndex_tooLarge = 100
+    ZSTD_error_seekableIO = 102
+    ZSTD_error_dstBuffer_wrong = 104
+    ZSTD_error_srcBuffer_wrong = 105
+    ZSTD_error_sequenceProducer_failed = 106
+    ZSTD_error_externalSequences_invalid = 107
+    ZSTD_error_maxCode = 120
+
+external function ZSTD_getErrorString(code: ZSTD_ErrorCode) -> cstr
+external function ZSTD_versionNumber() -> uint
+external function ZSTD_versionString() -> cstr
+external function ZSTD_compress(dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, compressionLevel: int) -> ptr_uint
+external function ZSTD_decompress(dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], compressedSize: ptr_uint) -> ptr_uint
+external function ZSTD_getFrameContentSize(src: const_ptr[void], srcSize: ptr_uint) -> ulong
+external function ZSTD_getDecompressedSize(src: const_ptr[void], srcSize: ptr_uint) -> ulong
+external function ZSTD_findFrameCompressedSize(src: const_ptr[void], srcSize: ptr_uint) -> ptr_uint
+external function ZSTD_compressBound(srcSize: ptr_uint) -> ptr_uint
+external function ZSTD_isError(result: ptr_uint) -> uint
+external function ZSTD_getErrorCode(functionResult: ptr_uint) -> ZSTD_ErrorCode
+external function ZSTD_getErrorName(result: ptr_uint) -> cstr
+external function ZSTD_minCLevel() -> int
+external function ZSTD_maxCLevel() -> int
+external function ZSTD_defaultCLevel() -> int
+
+opaque ZSTD_CCtx = c"ZSTD_CCtx"
+
+external function ZSTD_createCCtx() -> ptr[ZSTD_CCtx]
+external function ZSTD_freeCCtx(cctx: ptr[ZSTD_CCtx]) -> ptr_uint
+external function ZSTD_compressCCtx(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, compressionLevel: int) -> ptr_uint
+
+opaque ZSTD_DCtx = c"ZSTD_DCtx"
+
+external function ZSTD_createDCtx() -> ptr[ZSTD_DCtx]
+external function ZSTD_freeDCtx(dctx: ptr[ZSTD_DCtx]) -> ptr_uint
+external function ZSTD_decompressDCtx(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint) -> ptr_uint
+
+enum ZSTD_strategy: int
+    ZSTD_fast = 1
+    ZSTD_dfast = 2
+    ZSTD_greedy = 3
+    ZSTD_lazy = 4
+    ZSTD_lazy2 = 5
+    ZSTD_btlazy2 = 6
+    ZSTD_btopt = 7
+    ZSTD_btultra = 8
+    ZSTD_btultra2 = 9
+
+enum ZSTD_cParameter: int
+    ZSTD_c_compressionLevel = 100
+    ZSTD_c_windowLog = 101
+    ZSTD_c_hashLog = 102
+    ZSTD_c_chainLog = 103
+    ZSTD_c_searchLog = 104
+    ZSTD_c_minMatch = 105
+    ZSTD_c_targetLength = 106
+    ZSTD_c_strategy = 107
+    ZSTD_c_targetCBlockSize = 130
+    ZSTD_c_enableLongDistanceMatching = 160
+    ZSTD_c_ldmHashLog = 161
+    ZSTD_c_ldmMinMatch = 162
+    ZSTD_c_ldmBucketSizeLog = 163
+    ZSTD_c_ldmHashRateLog = 164
+    ZSTD_c_contentSizeFlag = 200
+    ZSTD_c_checksumFlag = 201
+    ZSTD_c_dictIDFlag = 202
+    ZSTD_c_nbWorkers = 400
+    ZSTD_c_jobSize = 401
+    ZSTD_c_overlapLog = 402
+    ZSTD_c_experimentalParam1 = 500
+    ZSTD_c_experimentalParam2 = 10
+    ZSTD_c_experimentalParam3 = 1000
+    ZSTD_c_experimentalParam4 = 1001
+    ZSTD_c_experimentalParam5 = 1002
+    ZSTD_c_experimentalParam7 = 1004
+    ZSTD_c_experimentalParam8 = 1005
+    ZSTD_c_experimentalParam9 = 1006
+    ZSTD_c_experimentalParam10 = 1007
+    ZSTD_c_experimentalParam11 = 1008
+    ZSTD_c_experimentalParam12 = 1009
+    ZSTD_c_experimentalParam13 = 1010
+    ZSTD_c_experimentalParam14 = 1011
+    ZSTD_c_experimentalParam15 = 1012
+    ZSTD_c_experimentalParam16 = 1013
+    ZSTD_c_experimentalParam17 = 1014
+    ZSTD_c_experimentalParam18 = 1015
+    ZSTD_c_experimentalParam19 = 1016
+    ZSTD_c_experimentalParam20 = 1017
+
+struct ZSTD_bounds:
+    error: ptr_uint
+    lowerBound: int
+    upperBound: int
+
+external function ZSTD_cParam_getBounds(cParam: ZSTD_cParameter) -> ZSTD_bounds
+external function ZSTD_CCtx_setParameter(cctx: ptr[ZSTD_CCtx], param: ZSTD_cParameter, value: int) -> ptr_uint
+external function ZSTD_CCtx_setPledgedSrcSize(cctx: ptr[ZSTD_CCtx], pledgedSrcSize: ulong) -> ptr_uint
+
+enum ZSTD_ResetDirective: int
+    ZSTD_reset_session_only = 1
+    ZSTD_reset_parameters = 2
+    ZSTD_reset_session_and_parameters = 3
+
+external function ZSTD_CCtx_reset(cctx: ptr[ZSTD_CCtx], reset: ZSTD_ResetDirective) -> ptr_uint
+external function ZSTD_compress2(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint) -> ptr_uint
+
+enum ZSTD_dParameter: int
+    ZSTD_d_windowLogMax = 100
+    ZSTD_d_experimentalParam1 = 1000
+    ZSTD_d_experimentalParam2 = 1001
+    ZSTD_d_experimentalParam3 = 1002
+    ZSTD_d_experimentalParam4 = 1003
+    ZSTD_d_experimentalParam5 = 1004
+    ZSTD_d_experimentalParam6 = 1005
+
+external function ZSTD_dParam_getBounds(dParam: ZSTD_dParameter) -> ZSTD_bounds
+external function ZSTD_DCtx_setParameter(dctx: ptr[ZSTD_DCtx], param: ZSTD_dParameter, value: int) -> ptr_uint
+external function ZSTD_DCtx_reset(dctx: ptr[ZSTD_DCtx], reset: ZSTD_ResetDirective) -> ptr_uint
+
+struct ZSTD_inBuffer:
+    src: const_ptr[void]
+    size: ptr_uint
+    pos: ptr_uint
+
+struct ZSTD_outBuffer:
+    dst: ptr[void]
+    size: ptr_uint
+    pos: ptr_uint
+
+type ZSTD_CStream = ZSTD_CCtx
+
+external function ZSTD_createCStream() -> ptr[ZSTD_CStream]
+external function ZSTD_freeCStream(zcs: ptr[ZSTD_CStream]) -> ptr_uint
+
+flags ZSTD_EndDirective: int
+    ZSTD_e_continue = 0
+    ZSTD_e_flush = 1
+    ZSTD_e_end = 2
+
+external function ZSTD_compressStream2(cctx: ptr[ZSTD_CCtx], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer], endOp: ZSTD_EndDirective) -> ptr_uint
+external function ZSTD_CStreamInSize() -> ptr_uint
+external function ZSTD_CStreamOutSize() -> ptr_uint
+external function ZSTD_initCStream(zcs: ptr[ZSTD_CStream], compressionLevel: int) -> ptr_uint
+external function ZSTD_compressStream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer]) -> ptr_uint
+external function ZSTD_flushStream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer]) -> ptr_uint
+external function ZSTD_endStream(zcs: ptr[ZSTD_CStream], output: ptr[ZSTD_outBuffer]) -> ptr_uint
+
+type ZSTD_DStream = ZSTD_DCtx
+
+external function ZSTD_createDStream() -> ptr[ZSTD_DStream]
+external function ZSTD_freeDStream(zds: ptr[ZSTD_DStream]) -> ptr_uint
+external function ZSTD_initDStream(zds: ptr[ZSTD_DStream]) -> ptr_uint
+external function ZSTD_decompressStream(zds: ptr[ZSTD_DStream], output: ptr[ZSTD_outBuffer], input: ptr[ZSTD_inBuffer]) -> ptr_uint
+external function ZSTD_DStreamInSize() -> ptr_uint
+external function ZSTD_DStreamOutSize() -> ptr_uint
+external function ZSTD_compress_usingDict(ctx: ptr[ZSTD_CCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, dict: const_ptr[void], dictSize: ptr_uint, compressionLevel: int) -> ptr_uint
+external function ZSTD_decompress_usingDict(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, dict: const_ptr[void], dictSize: ptr_uint) -> ptr_uint
+
+opaque ZSTD_CDict = c"ZSTD_CDict"
+
+external function ZSTD_createCDict(dictBuffer: const_ptr[void], dictSize: ptr_uint, compressionLevel: int) -> ptr[ZSTD_CDict]
+external function ZSTD_freeCDict(CDict: ptr[ZSTD_CDict]) -> ptr_uint
+external function ZSTD_compress_usingCDict(cctx: ptr[ZSTD_CCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, cdict: const_ptr[ZSTD_CDict]) -> ptr_uint
+
+opaque ZSTD_DDict = c"ZSTD_DDict"
+
+external function ZSTD_createDDict(dictBuffer: const_ptr[void], dictSize: ptr_uint) -> ptr[ZSTD_DDict]
+external function ZSTD_freeDDict(ddict: ptr[ZSTD_DDict]) -> ptr_uint
+external function ZSTD_decompress_usingDDict(dctx: ptr[ZSTD_DCtx], dst: ptr[void], dstCapacity: ptr_uint, src: const_ptr[void], srcSize: ptr_uint, ddict: const_ptr[ZSTD_DDict]) -> ptr_uint
+external function ZSTD_getDictID_fromDict(dict: const_ptr[void], dictSize: ptr_uint) -> uint
+external function ZSTD_getDictID_fromCDict(cdict: const_ptr[ZSTD_CDict]) -> uint
+external function ZSTD_getDictID_fromDDict(ddict: const_ptr[ZSTD_DDict]) -> uint
+external function ZSTD_getDictID_fromFrame(src: const_ptr[void], srcSize: ptr_uint) -> uint
+external function ZSTD_CCtx_loadDictionary(cctx: ptr[ZSTD_CCtx], dict: const_ptr[void], dictSize: ptr_uint) -> ptr_uint
+external function ZSTD_CCtx_refCDict(cctx: ptr[ZSTD_CCtx], cdict: const_ptr[ZSTD_CDict]) -> ptr_uint
+external function ZSTD_CCtx_refPrefix(cctx: ptr[ZSTD_CCtx], prefix: const_ptr[void], prefixSize: ptr_uint) -> ptr_uint
+external function ZSTD_DCtx_loadDictionary(dctx: ptr[ZSTD_DCtx], dict: const_ptr[void], dictSize: ptr_uint) -> ptr_uint
+external function ZSTD_DCtx_refDDict(dctx: ptr[ZSTD_DCtx], ddict: const_ptr[ZSTD_DDict]) -> ptr_uint
+external function ZSTD_DCtx_refPrefix(dctx: ptr[ZSTD_DCtx], prefix: const_ptr[void], prefixSize: ptr_uint) -> ptr_uint
+external function ZSTD_sizeof_CCtx(cctx: const_ptr[ZSTD_CCtx]) -> ptr_uint
+external function ZSTD_sizeof_DCtx(dctx: const_ptr[ZSTD_DCtx]) -> ptr_uint
+external function ZSTD_sizeof_CStream(zcs: const_ptr[ZSTD_CStream]) -> ptr_uint
+external function ZSTD_sizeof_DStream(zds: const_ptr[ZSTD_DStream]) -> ptr_uint
+external function ZSTD_sizeof_CDict(cdict: const_ptr[ZSTD_CDict]) -> ptr_uint
+external function ZSTD_sizeof_DDict(ddict: const_ptr[ZSTD_DDict]) -> ptr_uint
+
+const ZSTD_VERSION_MAJOR: int = 1
+const ZSTD_VERSION_MINOR: int = 5
+const ZSTD_VERSION_RELEASE: int = 7
+const ZSTD_VERSION_STRING: cstr = c"1.5.7"
+const ZSTD_CLEVEL_DEFAULT: int = 3
+const ZSTD_MAGICNUMBER: uint = 4247762216
+const ZSTD_MAGIC_DICTIONARY: uint = 3962610743
+const ZSTD_MAGIC_SKIPPABLE_START: int = 407710288
+const ZSTD_MAGIC_SKIPPABLE_MASK: uint = 4294967280
+const ZSTD_BLOCKSIZELOG_MAX: int = 17

data/std/cell.mt

@@ -0,0 +1,60 @@
+import std.mem.heap as heap
+
+## Explicit single-value heap storage.
+##
+## This is the intended escape hatch for shared mutable proc state.
+## Allocation stays visible at the call site via `cell.alloc(...)`.
+public struct Cell[T]:
+    storage: own[T]?
+
+
+public function alloc[T](value: T) -> Cell[T]:
+    let storage = heap.must_alloc[T](1)
+    read(storage) = value
+    return Cell[T](storage = storage)
+
+
+extending Cell[T]:
+    public function as_ptr() -> ptr[T]:
+        let storage = this.storage else:
+            fatal(c"cell.Cell.as_ptr released cell")
+
+        return storage
+
+
+    public function get() -> T:
+        let storage = this.storage else:
+            fatal(c"cell.Cell.get released cell")
+
+        return read(storage)
+
+
+    public function set(value: T) -> void:
+        let storage = this.storage else:
+            fatal(c"cell.Cell.set released cell")
+
+        read(storage) = value
+
+
+    public function replace(value: T) -> T:
+        let storage = this.storage else:
+            fatal(c"cell.Cell.replace released cell")
+
+        let previous = read(storage)
+        read(storage) = value
+        return previous
+
+
+    public function update(body: proc(value: T) -> T) -> T:
+        let next = body(this.get())
+        this.set(next)
+        return next
+
+
+    public function is_released() -> bool:
+        return this.storage == null
+
+
+    public editable function release() -> void:
+        heap.release(this.storage)
+        this.storage = null

data/std/cgltf.mt

@@ -0,0 +1,115 @@
+# generated by mtc imported-bindings from std.c.cgltf using bindings/imported/cgltf.binding.json
+
+import std.c.cgltf as c
+
+public type camera_data = c.cgltf_camera_data
+public type size = c.cgltf_size
+public type ssize = c.cgltf_ssize
+public type float_ = c.cgltf_float
+public type int_ = c.cgltf_int
+public type uint_ = c.cgltf_uint
+public type bool_ = c.cgltf_bool
+public type file_type = c.cgltf_file_type
+public type result = c.cgltf_result
+public type memory_options = c.cgltf_memory_options
+public type file_options = c.cgltf_file_options
+public type options = c.cgltf_options
+public type buffer_view_type = c.cgltf_buffer_view_type
+public type attribute_type = c.cgltf_attribute_type
+public type component_type = c.cgltf_component_type
+public type type_ = c.cgltf_type
+public type primitive_type = c.cgltf_primitive_type
+public type alpha_mode = c.cgltf_alpha_mode
+public type animation_path_type = c.cgltf_animation_path_type
+public type interpolation_type = c.cgltf_interpolation_type
+public type camera_type = c.cgltf_camera_type
+public type light_type = c.cgltf_light_type
+public type data_free_method = c.cgltf_data_free_method
+public type extras = c.cgltf_extras
+public type extension = c.cgltf_extension
+public type buffer = c.cgltf_buffer
+public type meshopt_compression_mode = c.cgltf_meshopt_compression_mode
+public type meshopt_compression_filter = c.cgltf_meshopt_compression_filter
+public type meshopt_compression = c.cgltf_meshopt_compression
+public type buffer_view = c.cgltf_buffer_view
+public type accessor_sparse = c.cgltf_accessor_sparse
+public type accessor = c.cgltf_accessor
+public type attribute_ = c.cgltf_attribute
+public type image = c.cgltf_image
+public type filter_type = c.cgltf_filter_type
+public type wrap_mode = c.cgltf_wrap_mode
+public type sampler = c.cgltf_sampler
+public type texture = c.cgltf_texture
+public type texture_transform = c.cgltf_texture_transform
+public type texture_view = c.cgltf_texture_view
+public type pbr_metallic_roughness = c.cgltf_pbr_metallic_roughness
+public type pbr_specular_glossiness = c.cgltf_pbr_specular_glossiness
+public type clearcoat = c.cgltf_clearcoat
+public type transmission = c.cgltf_transmission
+public type ior = c.cgltf_ior
+public type specular = c.cgltf_specular
+public type volume = c.cgltf_volume
+public type sheen = c.cgltf_sheen
+public type emissive_strength = c.cgltf_emissive_strength
+public type iridescence = c.cgltf_iridescence
+public type diffuse_transmission = c.cgltf_diffuse_transmission
+public type anisotropy = c.cgltf_anisotropy
+public type dispersion = c.cgltf_dispersion
+public type material = c.cgltf_material
+public type material_mapping = c.cgltf_material_mapping
+public type morph_target = c.cgltf_morph_target
+public type draco_mesh_compression = c.cgltf_draco_mesh_compression
+public type mesh_gpu_instancing = c.cgltf_mesh_gpu_instancing
+public type primitive = c.cgltf_primitive
+public type mesh = c.cgltf_mesh
+public type skin = c.cgltf_skin
+public type camera_perspective = c.cgltf_camera_perspective
+public type camera_orthographic = c.cgltf_camera_orthographic
+public type camera = c.cgltf_camera
+public type light = c.cgltf_light
+public type node = c.cgltf_node
+public type scene = c.cgltf_scene
+public type animation_sampler = c.cgltf_animation_sampler
+public type animation_channel = c.cgltf_animation_channel
+public type animation = c.cgltf_animation
+public type material_variant = c.cgltf_material_variant
+public type asset = c.cgltf_asset
+public type data = c.cgltf_data
+
+public foreign function parse(options: const_ptr[options], data: const_ptr[void], size: ptr_uint, out_data: ptr[ptr[data]]) -> result = c.cgltf_parse
+public foreign function parse_file(options: const_ptr[options], path: str as cstr, out_data: ptr[ptr[data]]) -> result = c.cgltf_parse_file
+public foreign function load_buffers(options: const_ptr[options], data: ptr[data], gltf_path: str as cstr) -> result = c.cgltf_load_buffers
+public foreign function load_buffer_base64(options: const_ptr[options], size: ptr_uint, base64: str as cstr, out_data: ptr[ptr[void]]) -> result = c.cgltf_load_buffer_base64
+public foreign function decode_string(string: ptr[char]) -> size = c.cgltf_decode_string
+public foreign function decode_uri(uri: ptr[char]) -> size = c.cgltf_decode_uri
+public foreign function validate(data: ptr[data]) -> result = c.cgltf_validate
+public foreign function free(data: ptr[data]) -> void = c.cgltf_free
+public foreign function node_transform_local(node: const_ptr[node], out_matrix: ptr[float_]) -> void = c.cgltf_node_transform_local
+public foreign function node_transform_world(node: const_ptr[node], out_matrix: ptr[float_]) -> void = c.cgltf_node_transform_world
+public foreign function buffer_view_data(view: const_ptr[buffer_view]) -> const_ptr[ubyte] = c.cgltf_buffer_view_data
+public foreign function find_accessor(prim: const_ptr[primitive], type_: attribute_type, index: int) -> const_ptr[accessor] = c.cgltf_find_accessor
+public foreign function accessor_read_float(accessor: const_ptr[accessor], index: ptr_uint, out_: ptr[float_], element_size: ptr_uint) -> bool_ = c.cgltf_accessor_read_float
+public foreign function accessor_read_uint(accessor: const_ptr[accessor], index: ptr_uint, out_: ptr[uint_], element_size: ptr_uint) -> bool_ = c.cgltf_accessor_read_uint
+public foreign function accessor_read_index(accessor: const_ptr[accessor], index: ptr_uint) -> size = c.cgltf_accessor_read_index
+public foreign function num_components(type_: type_) -> size = c.cgltf_num_components
+public foreign function component_size(component_type: component_type) -> size = c.cgltf_component_size
+public foreign function calc_size(type_: type_, component_type: component_type) -> size = c.cgltf_calc_size
+public foreign function accessor_unpack_floats(accessor: const_ptr[accessor], out_: ptr[float_], float_count: ptr_uint) -> size = c.cgltf_accessor_unpack_floats
+public foreign function accessor_unpack_indices(accessor: const_ptr[accessor], out_: ptr[void], out_component_size: ptr_uint, index_count: ptr_uint) -> size = c.cgltf_accessor_unpack_indices
+public foreign function copy_extras_json(data: const_ptr[data], extras: const_ptr[extras], dest: ptr[char], dest_size: ptr[size]) -> result = c.cgltf_copy_extras_json
+public foreign function mesh_index(data: const_ptr[data], object: const_ptr[mesh]) -> size = c.cgltf_mesh_index
+public foreign function material_index(data: const_ptr[data], object: const_ptr[material]) -> size = c.cgltf_material_index
+public foreign function accessor_index(data: const_ptr[data], object: const_ptr[accessor]) -> size = c.cgltf_accessor_index
+public foreign function buffer_view_index(data: const_ptr[data], object: const_ptr[buffer_view]) -> size = c.cgltf_buffer_view_index
+public foreign function buffer_index(data: const_ptr[data], object: const_ptr[buffer]) -> size = c.cgltf_buffer_index
+public foreign function image_index(data: const_ptr[data], object: const_ptr[image]) -> size = c.cgltf_image_index
+public foreign function texture_index(data: const_ptr[data], object: const_ptr[texture]) -> size = c.cgltf_texture_index
+public foreign function sampler_index(data: const_ptr[data], object: const_ptr[sampler]) -> size = c.cgltf_sampler_index
+public foreign function skin_index(data: const_ptr[data], object: const_ptr[skin]) -> size = c.cgltf_skin_index
+public foreign function camera_index(data: const_ptr[data], object: const_ptr[camera]) -> size = c.cgltf_camera_index
+public foreign function light_index(data: const_ptr[data], object: const_ptr[light]) -> size = c.cgltf_light_index
+public foreign function node_index(data: const_ptr[data], object: const_ptr[node]) -> size = c.cgltf_node_index
+public foreign function scene_index(data: const_ptr[data], object: const_ptr[scene]) -> size = c.cgltf_scene_index
+public foreign function animation_index(data: const_ptr[data], object: const_ptr[animation]) -> size = c.cgltf_animation_index
+public foreign function animation_sampler_index(animation: const_ptr[animation], object: const_ptr[animation_sampler]) -> size = c.cgltf_animation_sampler_index
+public foreign function animation_channel_index(animation: const_ptr[animation], object: const_ptr[animation_channel]) -> size = c.cgltf_animation_channel_index