@thi.ng/wasm-api 0.9.0 → 0.11.0

package/api.d.ts

@@ -1,6 +1,7 @@
-import type { BigType, FloatType, Fn, Fn2 } from "@thi.ng/api";
+import type { BigType, FloatType, Fn } from "@thi.ng/api";
 import type { WasmBridge } from "./bridge.js";
 export declare const PKG_NAME = "@thi.ng/wasm-api";
+export declare const EVENT_MEMORY_CHANGED = "memory-changed";
 export declare type BigIntArray = bigint[] | BigInt64Array | BigUint64Array;
 /**
  * Common interface for WASM/JS child APIs which will be used in combination
@@ -27,9 +28,9 @@ export interface IWasmAPI<T extends WasmExports = WasmExports> {
     getImports(): WebAssembly.ModuleImports;
 }
 /**
- * Base interface of exports declared by the WASM module. At the very least, the
- * module needs to export its memory and the functions defined in this
- * interface.
+ * Base interface of exports declared by the WASM module. At the very least, a
+ * compatible module needs to export its memory and the functions defined in
+ * this interface.
  *
  * @remarks
  * This interface is supposed to be extended with the concrete exports defined
@@ -45,21 +46,34 @@ export interface WasmExports {
      */
     memory: WebAssembly.Memory;
     /**
-     * Implementation specific memory allocation function (likely heap-based).
-     * If successful returns address of new memory block, or zero if
-     * unsuccessful.
+     * Implementation specific WASM memory allocation function. If successful
+     * returns address of new memory block, or zero if unsuccessful.
      *
      * @remarks
-     * In the supplied Zig bindings (see `/zig/core.zig`), by default this is
-     * using the `std.heap.GeneralPurposeAllocator` (which also automatically
-     * handles growing the WASM memory), however as mentioned the underlying
-     * mechanism is purposefully left to the actual WASM-side implementation. In
-     * a C program, this would likely use `malloc()` or similar...
+     * #### Zig
+     *
+     * Using the supplied Zig bindings (see `/include/wasmapi.zig`), it's the
+     * user's responsibility to define a public `WASM_ALLOCATOR` in the root
+     * source file to enable allocations, e.g. using the
+     * [`std.heap.GeneralPurposeAllocator`](https://ziglang.org/documentation/master/#Choosing-an-Allocator)
+     * (which also automatically handles growing the WASM memory). However, as
+     * mentioned, the underlying mechanism is purposefully left to the actual
+     * WASM-side implementation. If no allocator is defined this function
+     * returns zero, which in turn will cause {@link WasmBridge.allocate} to
+     * throw an error.
+     *
+     * #### C/C++
+     *
+     * Using the supplied C bindings (see `/include/wasmapi.h`), it's the user's
+     * responsibility to enable allocation support by defining the
+     * `WASMAPI_MALLOC` symbol (and compiling the WASM module with a malloc
+     * implementation).
      */
     _wasm_allocate(numBytes: number): number;
     /**
      * Implementation specific function to free a previously allocated chunk of
-     * of WASM memory (allocated via {@link WasmExports._wasm_allocate}).
+     * of WASM memory (allocated via {@link WasmExports._wasm_allocate}, also
+     * see remarks for that function).
      *
      * @param addr
      * @param numBytes
@@ -118,9 +132,9 @@ export interface CoreAPI extends WebAssembly.ModuleImports {
     printI32: Fn<number, void>;
     printU32: Fn<number, void>;
     printU32Hex: Fn<number, void>;
-    _printI64: Fn2<number, number, void>;
-    _printU64: Fn2<number, number, void>;
-    _printU64Hex: Fn2<number, number, void>;
+    printI64: Fn<bigint, void>;
+    printU64: Fn<bigint, void>;
+    printU64Hex: Fn<bigint, void>;
     printF32: Fn<number, void>;
     printF64: Fn<number, void>;
     _printI8Array: (addr: number, len: number) => void;
@@ -136,6 +150,9 @@ export interface CoreAPI extends WebAssembly.ModuleImports {
     _printStr0: (addr: number) => void;
     _printStr: (addr: number, len: number) => void;
     debug: () => void;
+    _panic: (addr: number, len: number) => void;
+    timer: () => number;
+    epoch: () => bigint;
 }
 export interface WasmTypeBase {
     /**
@@ -203,11 +220,18 @@ export interface Struct extends TopLevelType {
     /**
      * If true, struct fields will be re-ordered in descending order based on
      * their {@link TypeInfo.__align} size. This might result in overall smaller
-     * structs due to minimizing inter-field padding.
+     * structs due to minimizing implicit inter-field padding caused by
+     * alignment requirements. **If this option is enabled, then the struct MUST
+     * NOT contain any padding fields!**
      *
      * @defaultValue false
      */
     auto?: boolean;
+    /**
+     * Optional qualifier for the kind of struct to be emitted (codegen specific
+     * interpretation, currently only used by {@link ZIG}).
+     */
+    tag?: "extern" | "packed";
 }
 export interface StructField extends TypeInfo {
     /**
@@ -246,6 +270,11 @@ export interface StructField extends TypeInfo {
      * TODO `opaque` currently unsupported.
      */
     type: WasmPrim | "string" | "opaque" | string;
+    /**
+     * Const qualifier (default is true for `string`, false for all other
+     * types). Only used for pointers or slices.
+     */
+    const?: boolean;
     /**
      * TODO currently unsupported & ignored!
      */
@@ -258,11 +287,19 @@ export interface StructField extends TypeInfo {
      * TODO currently unsupported & ignored!
      */
     default?: any;
+    /**
+     * If defined and > 0, the field will be considered for padding purposes only and
+     * the value provided is the number of bytes used.
+     */
+    pad?: number;
 }
 export interface Enum extends TopLevelType {
     type: "enum";
     /**
-     * No i64/u64 support, due to Typescript not supporting bigint enum values
+     * No i64/u64 support, due to Typescript not supporting bigint enum values.
+     * For C compatibility only i32 or u32 is allowed.
+     *
+     * @defaultValue "i32"
      */
     tag: Exclude<WasmPrim32, FloatType>;
     /**
@@ -285,27 +322,69 @@ export interface EnumValue {
      */
     doc?: string;
 }
+export interface CodeGenOptsBase {
+    /**
+     * Optional string to be injected before generated type defs (but after
+     * codegen's own prelude, if any)
+     */
+    pre: string;
+    /**
+     * Optional string to be injected after generated type defs (but before
+     * codegen's own epilogue, if any)
+     */
+    post: string;
+}
+/**
+ * Global/shared code generator options.
+ */
+export interface CodeGenOpts extends CodeGenOptsBase {
+    /**
+     * Identifier how strings are stored on WASM side, e.g. in Zig string
+     * literals are slices (8 bytes), in C just plain pointers (4 bytes).
+     *
+     * @defaultValue "slice"
+     */
+    stringType: "slice" | "ptr";
+    /**
+     * If true (default), forces uppercase enum identifiers
+     *
+     * @defaultValue true
+     */
+    uppercaseEnums: boolean;
+    /**
+     * Unless set to false, the generated output will be prefixed with a header
+     * line comment of generator meta data
+     */
+    header: boolean;
+    /**
+     * If true, codegens MAY generate various additional struct & struct field
+     * analysis functions (sizes, alignment, offsets etc.).
+     *
+     * @defaultValue false
+     */
+    debug: boolean;
+}
 export interface ICodeGen {
     /**
      * Optional prelude source, to be prepended before any generated type defs.
      */
-    pre?: string;
+    pre?: Fn<CodeGenOpts, string>;
     /**
      * Optional source code to be appended after any generated type defs.
      */
-    post?: string;
+    post?: Fn<CodeGenOpts, string>;
     /**
      * Docstring codegen
      */
-    doc: (doc: string, indent: string, acc: string[], topLevel?: boolean) => void;
+    doc: (doc: string, acc: string[], topLevel?: boolean) => void;
     /**
      * Codegen for enum types.
      */
-    enum: (type: Enum, types: TypeColl, acc: string[]) => void;
+    enum: (type: Enum, types: TypeColl, acc: string[], opts: CodeGenOpts) => void;
     /**
      * Codegen for struct types.
      */
-    struct: (type: Struct, types: TypeColl, acc: string[]) => void;
+    struct: (type: Struct, types: TypeColl, acc: string[], opts: CodeGenOpts) => void;
 }
 /**
  * WASM usize type. Assuming wasm32 until wasm64 surfaces, then need an option.

package/api.js

@@ -1,4 +1,5 @@
 export const PKG_NAME = "@thi.ng/wasm-api";
+export const EVENT_MEMORY_CHANGED = "memory-changed";
 /**
  * WASM usize type. Assuming wasm32 until wasm64 surfaces, then need an option.
  */

package/bridge.d.ts

@@ -1,7 +1,17 @@
 /// <reference types="node" />
-import type { NumericArray } from "@thi.ng/api";
+import type { Event, INotify, Listener, NumericArray } from "@thi.ng/api";
 import type { ILogger } from "@thi.ng/logger";
-import type { BigIntArray, CoreAPI, IWasmAPI, WasmExports, IWasmMemoryAccess } from "./api.js";
+import { BigIntArray, CoreAPI, IWasmAPI, IWasmMemoryAccess, WasmExports } from "./api.js";
+export declare const Panic: {
+    new (msg?: string | undefined): {
+        name: string;
+        message: string;
+        stack?: string | undefined;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
 export declare const OutOfMemoryError: {
     new (msg?: string | undefined): {
         name: string;
@@ -28,7 +38,7 @@ export declare const OutOfMemoryError: {
  * 64bit integers are handled via JS `BigInt` and hence require the host env to
  * support it. No polyfill is provided.
  */
-export declare class WasmBridge<T extends WasmExports = WasmExports> implements IWasmMemoryAccess {
+export declare class WasmBridge<T extends WasmExports = WasmExports> implements IWasmMemoryAccess, INotify {
     modules: Record<string, IWasmAPI<T>>;
     logger: ILogger;
     i8: Int8Array;
@@ -66,14 +76,23 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> implements
      * then initializes all declared bridge child API modules. Returns false if
      * any of the module initializations failed.
      *
+     * @remarks
+     * Emits the {@link EVENT_MEMORY_CHANGED} event just before returning (and
+     * AFTER all child API modules have been initialized).
+     *
      * @param exports
      */
     init(exports: T): Promise<boolean>;
     /**
-     * Called automatically. Initializes and/or updates the various typed WASM
-     * memory views (e.g. after growing the WASM memory).
+     * Called automatically during initialization. Initializes and/or updates
+     * the various typed WASM memory views (e.g. after growing the WASM memory
+     * and the previous buffer becoming detached). Unless `notify` is false,
+     * the {@link EVENT_MEMORY_CHANGED} event will be emitted if the memory
+     * views had to be updated.
+     *
+     * @param notify
      */
-    ensureMemory(): void;
+    ensureMemory(notify?: boolean): void;
     /**
      * Required use for WASM module instantiation to provide JS imports to the
      * module. Returns an object of all WASM imports declared by the bridge core
@@ -137,6 +156,10 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> implements
      * `numBytes` value must be the same as previously given to
      * {@link WasmBridge.allocate}.
      *
+     * @remarks
+     * This function always succeeds, regardless of presence of an active
+     * allocator on the WASM side or validity of given arguments.
+     *
      * @param addr
      * @param numBytes
      */
@@ -208,5 +231,11 @@ export declare class WasmBridge<T extends WasmExports = WasmExports> implements
      */
     setString(str: string, addr: number, maxBytes: number, terminate?: boolean): number;
     getElementById(addr: number, len?: number): HTMLElement;
+    /** {@inheritDoc @thi.ng/api#INotify.addListener} */
+    addListener(id: string, fn: Listener, scope?: any): boolean;
+    /** {@inheritDoc @thi.ng/api#INotify.removeListener} */
+    removeListener(id: string, fn: Listener, scope?: any): boolean;
+    /** {@inheritDoc @thi.ng/api#INotify.notify} */
+    notify(event: Event): void;
 }
 //# sourceMappingURL=bridge.d.ts.map

package/bridge.js

@@ -1,8 +1,11 @@
+import { __decorate } from "tslib";
+import { INotifyMixin } from "@thi.ng/api/mixins/inotify";
 import { defError } from "@thi.ng/errors/deferror";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
-import { U16, U32, U64HL, U8 } from "@thi.ng/hex";
+import { U16, U32, U64BIG, U8 } from "@thi.ng/hex";
 import { ConsoleLogger } from "@thi.ng/logger/console";
-const B32 = BigInt(32);
+import { EVENT_MEMORY_CHANGED, } from "./api.js";
+export const Panic = defError(() => "Panic");
 export const OutOfMemoryError = defError(() => "Out of memory");
 /**
  * The main interop API bridge between the JS host environment and a WebAssembly
@@ -20,7 +23,7 @@ export const OutOfMemoryError = defError(() => "Out of memory");
  * 64bit integers are handled via JS `BigInt` and hence require the host env to
  * support it. No polyfill is provided.
  */
-export class WasmBridge {
+let WasmBridge = class WasmBridge {
     constructor(modules = {}, logger = new ConsoleLogger("wasm")) {
         this.modules = modules;
         this.logger = logger;
@@ -31,18 +34,18 @@ export class WasmBridge {
         this.api = {
             printI8: logN,
             printU8: logN,
-            printU8Hex: (x) => this.logger.debug(`0x${U8(x)}`),
             printI16: logN,
             printU16: logN,
-            printU16Hex: (x) => this.logger.debug(`0x${U16(x)}`),
             printI32: logN,
             printU32: (x) => this.logger.debug(x >>> 0),
-            printU32Hex: (x) => this.logger.debug(`0x${U32(x)}`),
-            _printI64: (hi, lo) => this.logger.debug((BigInt(hi) << B32) | BigInt(lo)),
-            _printU64: (hi, lo) => this.logger.debug((BigInt(hi >>> 0) << B32) | BigInt(lo >>> 0)),
-            _printU64Hex: (hi, lo) => this.logger.debug(`0x${U64HL(hi, lo)}`),
+            printI64: (x) => this.logger.debug(x),
+            printU64: (x) => this.logger.debug(x),
             printF32: logN,
             printF64: logN,
+            printU8Hex: (x) => this.logger.debug(`0x${U8(x)}`),
+            printU16Hex: (x) => this.logger.debug(`0x${U16(x)}`),
+            printU32Hex: (x) => this.logger.debug(`0x${U32(x)}`),
+            printU64Hex: (x) => this.logger.debug(`0x${U64BIG(x)}`),
             _printI8Array: logA(this.getI8Array.bind(this)),
             _printU8Array: logA(this.getU8Array.bind(this)),
             _printI16Array: logA(this.getI16Array.bind(this)),
@@ -58,6 +61,11 @@ export class WasmBridge {
             debug: () => {
                 debugger;
             },
+            _panic: (addr, len) => {
+                throw new Panic(this.getString(addr, len));
+            },
+            timer: () => performance.now(),
+            epoch: () => BigInt(Date.now()),
         };
     }
     /**
@@ -86,24 +94,34 @@ export class WasmBridge {
      * then initializes all declared bridge child API modules. Returns false if
      * any of the module initializations failed.
      *
+     * @remarks
+     * Emits the {@link EVENT_MEMORY_CHANGED} event just before returning (and
+     * AFTER all child API modules have been initialized).
+     *
      * @param exports
      */
     async init(exports) {
         this.exports = exports;
-        this.ensureMemory();
+        this.ensureMemory(false);
         for (let id in this.modules) {
             this.logger.debug(`initializing API module: ${id}`);
             const status = await this.modules[id].init(this);
             if (!status)
                 return false;
         }
+        this.notify({ id: EVENT_MEMORY_CHANGED, value: this.exports.memory });
         return true;
     }
     /**
-     * Called automatically. Initializes and/or updates the various typed WASM
-     * memory views (e.g. after growing the WASM memory).
+     * Called automatically during initialization. Initializes and/or updates
+     * the various typed WASM memory views (e.g. after growing the WASM memory
+     * and the previous buffer becoming detached). Unless `notify` is false,
+     * the {@link EVENT_MEMORY_CHANGED} event will be emitted if the memory
+     * views had to be updated.
+     *
+     * @param notify
      */
-    ensureMemory() {
+    ensureMemory(notify = true) {
         const buf = this.exports.memory.buffer;
         if (this.u8 && this.u8.buffer === buf)
             return;
@@ -117,6 +135,11 @@ export class WasmBridge {
         this.u64 = new BigUint64Array(buf);
         this.f32 = new Float32Array(buf);
         this.f64 = new Float64Array(buf);
+        notify &&
+            this.notify({
+                id: EVENT_MEMORY_CHANGED,
+                value: this.exports.memory,
+            });
     }
     /**
      * Required use for WASM module instantiation to provide JS imports to the
@@ -192,7 +215,7 @@ export class WasmBridge {
         const addr = this.exports._wasm_allocate(numBytes);
         if (!addr)
             throw new OutOfMemoryError(`unable to allocate: ${numBytes}`);
-        this.logger.debug(`allocated ${numBytes} bytes @ 0x${U32(addr)}`);
+        this.logger.debug(`allocated ${numBytes} bytes @ 0x${U32(addr)} .. 0x${U32(addr + numBytes - 1)}`);
         this.ensureMemory();
         clear && this.u8.fill(0, addr, addr + numBytes);
         return addr;
@@ -203,6 +226,10 @@ export class WasmBridge {
      * `numBytes` value must be the same as previously given to
      * {@link WasmBridge.allocate}.
      *
+     * @remarks
+     * This function always succeeds, regardless of presence of an active
+     * allocator on the WASM side or validity of given arguments.
+     *
      * @param addr
      * @param numBytes
      */
@@ -403,4 +430,17 @@ export class WasmBridge {
         el == null && illegalArgs(`missing DOM element #${id}`);
         return el;
     }
-}
+    /** {@inheritDoc @thi.ng/api#INotify.addListener} */
+    // @ts-ignore: mixin
+    addListener(id, fn, scope) { }
+    /** {@inheritDoc @thi.ng/api#INotify.removeListener} */
+    // @ts-ignore: mixin
+    removeListener(id, fn, scope) { }
+    /** {@inheritDoc @thi.ng/api#INotify.notify} */
+    // @ts-ignore: mixin
+    notify(event) { }
+};
+WasmBridge = __decorate([
+    INotifyMixin
+], WasmBridge);
+export { WasmBridge };

package/cli.js

@@ -1,14 +1,16 @@
-import { flag, oneOfMulti, parse, ParseError, string, strings, usage, } from "@thi.ng/args";
+import { flag, oneOf, oneOfMulti, parse, ParseError, string, strings, usage, } from "@thi.ng/args";
 import { isArray, isPlainObject } from "@thi.ng/checks";
 import { illegalArgs } from "@thi.ng/errors";
-import { readJSON, writeText } from "@thi.ng/file-io";
+import { mutIn } from "@thi.ng/paths/mut-in";
+import { readJSON, readText, writeText } from "@thi.ng/file-io";
 import { ConsoleLogger } from "@thi.ng/logger";
 import { resolve } from "path";
 import { generateTypes } from "./codegen.js";
+import { C11 } from "./codegen/c11.js";
 import { TYPESCRIPT } from "./codegen/typescript.js";
-import { isWasmPrim, isWasmString } from "./codegen/utils.js";
+import { isPadding, isWasmPrim, isWasmString } from "./codegen/utils.js";
 import { ZIG } from "./codegen/zig.js";
-const GENERATORS = { ts: TYPESCRIPT, zig: ZIG };
+const GENERATORS = { c11: C11, ts: TYPESCRIPT, zig: ZIG };
 const argOpts = {
     config: string({
         alias: "c",
@@ -27,6 +29,11 @@ const argOpts = {
         delim: ",",
     }),
     out: strings({ alias: "o", hint: "FILE", desc: "output file path" }),
+    string: oneOf(["slice", "ptr"], {
+        alias: "s",
+        hint: "TYPE",
+        desc: "Force string type implementation",
+    }),
 };
 export const INSTALL_DIR = resolve(`${process.argv[2]}/..`);
 export const PKG = readJSON(`${INSTALL_DIR}/package.json`);
@@ -72,7 +79,10 @@ const validateTypeRefs = (coll) => {
         if (spec.type !== "struct")
             continue;
         for (let f of spec.fields) {
-            if (!(isWasmPrim(f.type) || isWasmString(f.type) || coll[f.type])) {
+            if (!(isPadding(f) ||
+                isWasmPrim(f.type) ||
+                isWasmString(f.type) ||
+                coll[f.type])) {
                 invalidSpec(spec.__path, `structfield ${spec.name}.${f.name} of unknown type: ${f.type}`);
             }
         }
@@ -127,12 +137,23 @@ try {
     }
     const ctx = {
         logger: new ConsoleLogger("wasm-api", opts.debug ? "DEBUG" : "INFO"),
-        config: {},
+        config: { global: {} },
         opts,
     };
     if (opts.config) {
         ctx.config = readJSON(resolve(opts.config), ctx.logger);
+        for (let id in ctx.config) {
+            const conf = ctx.config[id];
+            if (conf.pre && conf.pre[0] === "@") {
+                conf.pre = readText(conf.pre.substring(1), ctx.logger);
+            }
+            if (conf.post && conf.post[0] === "@") {
+                conf.post = readText(conf.post.substring(1), ctx.logger);
+            }
+        }
     }
+    opts.debug && mutIn(ctx, ["config", "global", "debug"], true);
+    opts.string && mutIn(ctx, ["config", "global", "stringType"], opts.string);
     generateOutputs(ctx, parseTypeSpecs(ctx, rest));
 }
 catch (e) {

package/codegen/c.d.ts

@@ -0,0 +1,33 @@
+import type { ICodeGen } from "../api.js";
+/**
+ * Zig code generator options.
+ */
+export interface COpts {
+    /**
+     * If true, generates various struct & struct field analysis functions
+     * (sizes, alignment, offsets etc.).
+     *
+     * @defaultValue false
+     */
+    debug: boolean;
+    /**
+     * Optional prelude
+     */
+    pre: string;
+    /**
+     * Optional postfix (inserted after the generated code)
+     */
+    post: string;
+}
+/**
+ * Zig code generator. Call with options and then pass to {@link generateTypes}
+ * (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates struct and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}.
+ *
+ * @param opts
+ */
+export declare const C11: (opts?: Partial<COpts>) => ICodeGen;
+//# sourceMappingURL=c.d.ts.map

package/codegen/c.js

@@ -0,0 +1,100 @@
+import { isString } from "@thi.ng/checks/is-string";
+import { isPadding, isStringSlice, prefixLines, withIndentation, } from "./utils.js";
+/**
+ * Zig code generator. Call with options and then pass to {@link generateTypes}
+ * (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates struct and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}.
+ *
+ * @param opts
+ */
+export const C11 = (opts = {}) => {
+    const { debug } = { debug: false, ...opts };
+    const INDENT = "    ";
+    const SCOPES = [/\{$/, /\}\)?[;,]?$/];
+    const gen = {
+        pre: (opts) => `#pragma once
+#include <stddef.h>
+#include <stdint.h>${opts.pre ? `\n${opts.pre}` : ""}`,
+        post: () => opts.post || "",
+        doc: (doc, acc) => {
+            acc.push(prefixLines("// ", doc));
+        },
+        enum: (e, _, acc) => {
+            const lines = [];
+            lines.push(`enum {`);
+            for (let v of e.values) {
+                let line;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, lines);
+                    line = `${e.name}_${v.name}`;
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line = v;
+                }
+                lines.push(line + ",");
+            }
+            lines.push("};", "");
+            acc.push(...withIndentation(lines, INDENT, ...SCOPES));
+        },
+        struct: (struct, _, acc, opts) => {
+            const name = struct.name;
+            const res = [];
+            res.push(`typedef struct ${name} ${name};`, `struct ${name} {`);
+            const ftypes = {};
+            let padID = 0;
+            for (let f of struct.fields) {
+                // autolabel explicit padding fields
+                if (isPadding(f)) {
+                    res.push(`__pad${padID++}: [${f.pad}]u8,`);
+                    continue;
+                }
+                f.doc && gen.doc(f.doc, res);
+                let ftype = f.type === "string"
+                    ? isStringSlice(opts.stringType)
+                        ? f.const !== false
+                            ? "[]const u8"
+                            : "[]u8"
+                        : f.const !== false
+                            ? "[*:0]const u8"
+                            : "[*:0]u8"
+                    : f.type;
+                switch (f.tag) {
+                    case "array":
+                    case "vec":
+                        ftype = `[${f.len}]${ftype}`;
+                        break;
+                    case "slice":
+                        ftype = `[]${f.const ? "const " : ""}${ftype}`;
+                        break;
+                    case "ptr":
+                        ftype = `*${f.const ? "const " : ""}${f.len ? `[${f.len}]` : ""}${ftype}`;
+                        break;
+                    case "scalar":
+                    default:
+                }
+                ftypes[f.name] = ftype;
+                res.push(`${f.name}: ${ftype},`);
+            }
+            res.push("};");
+            if (debug) {
+                res.push("");
+                const fn = (fname, body) => res.push(`size_t __attribute__((used)) ${name}_${fname}() {`, `return ${body};`, `}`);
+                fn("align", `alignof(${name})`);
+                fn("size", `sizeof(${name})`);
+                for (let f of struct.fields) {
+                    fn(f.name + "_align", `alignof(${ftypes[f.name]})`);
+                    fn(f.name + "_offset", `offsetOf(${name}, "${f.name}")`);
+                    fn(f.name + "_size", `sizeof(${ftypes[f.name]})`);
+                }
+            }
+            res.push("");
+            acc.push(...withIndentation(res, INDENT, ...SCOPES));
+        },
+    };
+    return gen;
+};

package/codegen/c11.d.ts

@@ -0,0 +1,22 @@
+import type { CodeGenOptsBase, ICodeGen } from "../api.js";
+/**
+ * Zig code generator options.
+ */
+export interface C11Opts extends CodeGenOptsBase {
+    /**
+     * Optional name prefix for generated types, e.g. `WASM_`.
+     */
+    typePrefix: string;
+}
+/**
+ * Zig code generator. Call with options and then pass to {@link generateTypes}
+ * (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates struct and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}.
+ *
+ * @param opts
+ */
+export declare const C11: (opts?: Partial<C11Opts>) => ICodeGen;
+//# sourceMappingURL=c11.d.ts.map