@thi.ng/wasm-api 0.10.0 → 0.11.0

package/codegen/typescript.js

@@ -1,7 +1,7 @@
 import { BIGINT_ARRAY_CTORS, BIT_SHIFTS, TYPEDARRAY_CTORS, } from "@thi.ng/api/typedarray";
 import { isString } from "@thi.ng/checks/is-string";
 import { PKG_NAME, USIZE, USIZE_SIZE, } from "../api.js";
-import { isBigNumeric, isNumeric, isWasmPrim, isWasmString, prefixLines, } from "./utils.js";
+import { enumName, isBigNumeric, isNumeric, isPadding, isStringSlice, isWasmPrim, isWasmString, pointerFields, prefixLines, stringFields, withIndentation, } from "./utils.js";
 /**
  * TypeScript code generator. Call with options and then pass to
  * {@link generateTypes} (see its docs for further usage).
@@ -13,156 +13,190 @@ import { isBigNumeric, isNumeric, isWasmPrim, isWasmString, prefixLines, } from
  *
  * @param opts
  */
-export const TYPESCRIPT = (opts) => {
-    const { indent, stringType, uppercaseEnums } = {
+export const TYPESCRIPT = (opts = {}) => {
+    const { indent } = {
         indent: "\t",
         stringType: "slice",
-        uppercaseEnums: true,
         ...opts,
     };
-    const I = indent;
-    const I2 = I + I;
-    const I3 = I2 + I;
+    const SCOPES = [/\{$/, /\}\)?[;,]?$/];
     const gen = {
-        pre: `import type { WasmTypeBase, WasmTypeConstructor } from "${PKG_NAME}";`,
-        doc: (doc, indent, acc) => {
+        pre: (opts) => `// @ts-ignore possibly includes unused imports
+import { Pointer, ${__stringImpl(opts)}, WasmTypeBase, WasmTypeConstructor } from "${PKG_NAME}";${opts.pre ? `\n${opts.pre}` : ""}`,
+        post: () => opts.post || "",
+        doc: (doc, acc) => {
             if (doc.indexOf("\n") !== -1) {
-                acc.push(indent + "/**", prefixLines(indent + " * ", doc), indent + " */");
+                acc.push("/**", prefixLines(indent + " * ", doc), " */");
             }
             else {
-                acc.push(`${indent}/** ${doc} */`);
+                acc.push(`/** ${doc} */`);
             }
         },
-        enum: (type, _, acc) => {
-            const e = type;
-            acc.push(`export enum ${e.name} {`);
+        enum: (e, _, acc, opts) => {
+            const res = [];
+            res.push(`export enum ${e.name} {`);
             for (let v of e.values) {
-                let line = indent;
+                let line;
                 if (!isString(v)) {
-                    v.doc && gen.doc(v.doc, indent, acc);
-                    line += uppercaseEnums ? v.name.toUpperCase() : v.name;
+                    v.doc && gen.doc(v.doc, res);
+                    line = enumName(opts, v.name);
                     if (v.value != null)
                         line += ` = ${v.value}`;
                 }
                 else {
-                    line += uppercaseEnums ? v.toUpperCase() : v;
+                    line = enumName(opts, v);
                 }
-                acc.push(line + ",");
+                res.push(line + ",");
             }
-            acc.push("}\n");
-            return acc;
+            res.push("}", "");
+            acc.push(...withIndentation(res, indent, ...SCOPES));
         },
-        struct: (type, types, acc) => {
-            const struct = type;
-            const returnTypes = {};
+        struct: (struct, types, acc, opts) => {
+            const fieldTypes = {};
+            const $stringImpl = __stringImpl(opts);
+            const lines = [];
             // interface definition
-            acc.push(`export interface ${struct.name} extends WasmTypeBase {`);
+            lines.push(`export interface ${struct.name} extends WasmTypeBase {`);
             for (let f of struct.fields) {
-                f.doc && gen.doc(f.doc, indent, acc);
-                let line = `${indent}${f.name}: `;
-                let rtype = "";
-                if (f.tag == "array" || f.tag == "slice" || f.tag === "vec") {
-                    rtype = isNumeric(f.type)
-                        ? TYPEDARRAY_CTORS[f.type].name
-                        : isBigNumeric(f.type)
-                            ? BIGINT_ARRAY_CTORS[f.type].name
-                            : f.type + "[]";
-                }
-                else if (!f.tag || f.tag === "scalar" || f.tag === "ptr") {
-                    rtype = isBigNumeric(f.type)
-                        ? "bigint"
-                        : isNumeric(f.type)
-                            ? "number"
-                            : f.type;
-                }
-                returnTypes[f.name] = rtype;
-                acc.push(line + rtype + ";");
+                if (isPadding(f))
+                    continue;
+                f.doc && gen.doc(f.doc, lines);
+                const ftype = __fieldType(f, opts);
+                fieldTypes[f.name] = ftype;
+                lines.push(`${f.name}: ${ftype};`);
             }
-            acc.push("}\n");
+            lines.push("}", "");
+            const pointerDecls = pointerFields(struct.fields).map((x) => {
+                return `let $${x.name}: ${fieldTypes[x.name]} | null = null;`;
+            });
+            const stringDecls = stringFields(struct.fields).map((x) => {
+                const suffix = x.tag === "array" || x.tag === "slice" ? "[]" : "";
+                return `let $${x.name}: ${$stringImpl}${suffix} | null = null;`;
+            });
             // type implementation
-            acc.push(`export const $${struct.name}: WasmTypeConstructor<${struct.name}> = (mem) => ({`, `${I}get align() { return ${struct.__align}; },`, `${I}get size() { return ${struct.__size}; },`, `${I}instance: (base) => ({`, `${I2}get __base() { return base; },`, `${I2}get __bytes() { return mem.u8.subarray(base, base + ${struct.__size}); },`);
+            lines.push(`export const $${struct.name}: WasmTypeConstructor<${struct.name}> = (mem) => ({`, `get align() {`, `return ${struct.__align};`, `},`, `get size() {`, `return ${struct.__size};`, `},`, `instance: (base) => {`, ...pointerDecls, ...stringDecls, `return {`, `get __base() {`, `return base;`, `},`, `get __bytes() {`, `return mem.u8.subarray(base, base + ${struct.__size});`, `},`);
             for (let f of struct.fields) {
+                // skip explicit padding fields
+                if (isPadding(f))
+                    continue;
+                const ftype = fieldTypes[f.name];
                 const offset = f.__offset || 0;
-                acc.push(`${I2}get ${f.name}(): ${returnTypes[f.name]} {`);
+                lines.push(`get ${f.name}(): ${ftype} {`);
                 const isPrim = isWasmPrim(f.type);
                 const isStr = isWasmString(f.type);
+                const isConst = isStr ? f.const !== false : !!f.const;
                 if (f.tag === "ptr") {
                     if (isPrim) {
-                        acc.push(`${I3}return mem.${f.type}[${__ptrShift(offset, f.type)}];`);
+                        const fn = f.len
+                            ? `(base) => mem.${f.type}.subarray(${__addrShift(0, f.type)}, (${__addrShift(0, f.type)}) + ${f.len})`
+                            : `(base) => mem.${f.type}[${__addrShift(0, f.type)}]`;
+                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)}, ${fn}));`);
                     }
                     else if (isStr) {
-                        acc.push(
-                        // double deref
-                        stringType === "slice"
-                            ? `${I3}return mem.getString(mem.${USIZE}[${__ptr(offset)} >>> ${USIZE_SIZE}])`
-                            : `${I3}return mem.getString(${__ptr(offset)})`);
+                        const fn = f.len
+                            ? [
+                                `(addr) => {`,
+                                ...__mapStringArray("buf", $stringImpl, f.len, isConst, true),
+                                `}`,
+                            ]
+                            : [
+                                `(addr) => new ${$stringImpl}(mem, addr, ${isConst})`,
+                            ];
+                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)},`, ...fn, `));`);
                     }
                     else {
-                        acc.push(`${I3}return $${f.type}.instance(${__ptr(offset)});`);
+                        const fn = f.len
+                            ? [`(addr) => {`, ...__mapArray(f, f.len), `}`]
+                            : [`(addr) => new $${f.type}.instance(addr)`];
+                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)},`, ...fn, `));`);
                     }
                 }
                 else if (f.tag === "slice") {
-                    acc.push(`${I3}const len = ${__ptr(offset + 4)};`);
+                    lines.push(`const len = ${__ptr(offset + 4)};`);
                     if (isPrim) {
-                        acc.push(`${I3}const addr = ${__ptrShift(offset, f.type)};`, `${I3}return mem.${f.type}.subarray(addr, addr + len);`);
+                        lines.push(`const addr = ${__ptrShift(offset, f.type)};`, `return mem.${f.type}.subarray(addr, addr + len);`);
                     }
                     else if (isStr) {
-                        acc.push(`${I3}const addr = ${__ptr(offset)};`, __mapStringArray(I3, stringType));
+                        lines.push(`const addr = ${__ptr(offset)};`, ...__mapStringArray("buf", $stringImpl, "len", isConst));
                     }
                     else {
-                        acc.push(`${I3}const addr = ${__ptr(offset)};`, __mapArray(f, I3));
+                        lines.push(`const addr = ${__ptr(offset)};`, ...__mapArray(f));
                     }
                 }
                 else if (f.tag === "array" || f.tag === "vec") {
                     if (isPrim) {
-                        acc.push(`${I3}const addr = ${__addrShift(offset, f.type)};`, `${I3}return mem.${f.type}.subarray(addr, addr + ${f.len});`);
+                        lines.push(`const addr = ${__addrShift(offset, f.type)};`, `return mem.${f.type}.subarray(addr, addr + ${f.len});`);
                     }
                     else if (isStr) {
-                        acc.push(`${I3}const addr = ${__addr(offset)};`, __mapStringArray(I3, stringType, f.len));
+                        lines.push(`if ($${f.name}) return $${f.name};`, `const addr = ${__addr(offset)};`, ...__mapStringArray(f.name, $stringImpl, f.len, isConst));
                     }
                     else {
-                        acc.push(`${I3}const addr = ${__addr(offset)};`, __mapArray(f, I3, f.len));
+                        lines.push(`const addr = ${__addr(offset)};`, ...__mapArray(f, f.len));
                     }
                 }
                 else {
                     let setter;
                     if (isPrim) {
                         const addr = __mem(f.type, f.__offset);
-                        acc.push(`${I3}return ${addr};`);
+                        lines.push(`return ${addr};`);
                         setter = `${addr} = x`;
                     }
                     else if (isStr) {
-                        acc.push(`${I3}return mem.getString(${__ptr(offset)})`);
-                        setter =
-                            stringType === "slice"
-                                ? `mem.setString(x, ${__ptr(offset)}, ${__ptr(offset + 4)} + 1, true);`
-                                : `throw new Error("unsupported for raw string pointers")`;
+                        lines.push(`return $${f.name} || ($${f.name} = new ${$stringImpl}(mem, ${__addr(offset)}, ${isConst}));`);
                     }
                     else if (types[f.type].type === "enum") {
                         const tag = types[f.type].tag;
                         const addr = __mem(tag, f.__offset);
-                        acc.push(`${I3}return ${addr};`);
+                        lines.push(`return ${addr};`);
                         setter = `${addr} = x`;
                     }
                     else {
-                        acc.push(`${I3}return $${f.type}(mem).instance(${__addr(offset)});`);
+                        lines.push(`return $${f.type}(mem).instance(${__addr(offset)});`);
                         setter = `mem.u8.set(x.__bytes, ${__addr(offset)})`;
                     }
-                    // close getter
-                    acc.push(`${I2}},`);
                     // setter
-                    acc.push(`${I2}set ${f.name}(x: ${returnTypes[f.name]}) {`, `${I3}${setter};`);
+                    if (setter) {
+                        lines.push(
+                        // close getter
+                        `},`, `set ${f.name}(x: ${fieldTypes[f.name]}) {`, `${setter};`);
+                    }
                 }
                 // close field accessor
-                acc.push(`${I2}},`);
+                lines.push(`},`);
             }
-            acc.push(`${I}})\n});\n`);
-            return acc;
+            lines.push("};", "}", "});", "");
+            acc.push(...withIndentation(lines, indent, ...SCOPES));
         },
     };
     return gen;
 };
 /** @internal */
+const __stringImpl = (opts) => isStringSlice(opts.stringType) ? "WasmStringSlice" : "WasmStringPtr";
+/** @internal */
+const __fieldType = (f, opts) => {
+    const ftype = f.tag == "array" ||
+        f.tag == "slice" ||
+        f.tag === "vec" ||
+        (f.tag === "ptr" && f.len)
+        ? isNumeric(f.type)
+            ? TYPEDARRAY_CTORS[f.type].name
+            : isBigNumeric(f.type)
+                ? BIGINT_ARRAY_CTORS[f.type].name
+                : isWasmString(f.type)
+                    ? __stringImpl(opts) + "[]"
+                    : f.type + "[]"
+        : !f.tag || f.tag === "scalar" || f.tag === "ptr"
+            ? isBigNumeric(f.type)
+                ? "bigint"
+                : isNumeric(f.type)
+                    ? "number"
+                    : isWasmString(f.type)
+                        ? __stringImpl(opts)
+                        : f.type
+            : f.type;
+    return f.tag === "ptr" ? `Pointer<${ftype}>` : ftype;
+};
+/** @internal */
 const __shift = (type) => BIT_SHIFTS[type];
 /** @internal */
 const __addr = (offset) => (offset > 0 ? `(base + ${offset})` : "base");
@@ -177,13 +211,15 @@ const __ptr = (offset) => `mem.${USIZE}[${__addrShift(offset, USIZE)}]`;
 const __ptrShift = (offset, shift) => __ptr(offset) + " >>> " + __shift(shift);
 const __mem = (type, offset) => `mem.${type}[${__addrShift(offset, type)}]`;
 /** @internal */
-const __mapArray = (f, indent, len = "len") => prefixLines(indent, `const inst = $${f.type}(mem);
-const slice: ${f.type}[] = [];
-for(let i = 0; i < ${len}; i++) slice.push(inst.instance(addr + i * ${f.__size}));
-return slice;`);
+const __mapArray = (f, len = "len") => [
+    `const inst = $${f.type}(mem);`,
+    `const slice: ${f.type}[] = [];`,
+    `for(let i = 0; i < ${len}; i++) slice.push(inst.instance(addr + i * ${f.__size}));`,
+    `return slice;`,
+];
 /** @internal */
-const __mapStringArray = (indent, type, len = "len") => prefixLines(indent, [
-    "const slice: string[] = [];",
-    `for(let i = 0; i < ${len}; i++) slice.push(mem.getString(mem.${USIZE}[(addr + i * ${USIZE_SIZE * (type === "slice" ? 2 : 1)}) >>> ${__shift(USIZE)}]));`,
-    "return slice;",
-]);
+const __mapStringArray = (name, type, len, isConst, isLocal = false) => [
+    isLocal ? `const $${name}: ${type}[] = [];` : `$${name} = [];`,
+    `for(let i = 0; i < ${len}; i++) $${name}.push(new ${type}(mem, addr + i * ${USIZE_SIZE * (type === "WasmStringSlice" ? 2 : 1)}, ${isConst}));`,
+    `return $${name};`,
+];

package/codegen/utils.d.ts

@@ -1,5 +1,5 @@
 import type { BigType } from "@thi.ng/api";
-import type { WasmPrim, WasmPrim32 } from "../api.js";
+import type { CodeGenOpts, StructField, WasmPrim, WasmPrim32 } from "../api.js";
 /**
  * Returns true iff `x` is a {@link WasmPrim32}.
  *
@@ -19,6 +19,7 @@ export declare const isBigNumeric: (x: string) => x is BigType;
  */
 export declare const isWasmPrim: (x: string) => x is WasmPrim;
 export declare const isWasmString: (x: string) => x is "string";
+export declare const isPadding: (f: StructField) => boolean;
 /**
  * Takes an array of strings or splits given string into lines, prefixes each
  * line with given `prefix` and then returns rejoined result.
@@ -27,4 +28,50 @@ export declare const isWasmString: (x: string) => x is "string";
  * @param str
  */
 export declare const prefixLines: (prefix: string, str: string | string[]) => string;
+/**
+ * Returns true if `type` is "slice".
+ *
+ * @param type
+ */
+export declare const isStringSlice: (type: CodeGenOpts["stringType"]) => type is "slice";
+/**
+ * Returns filtered array of struct fields of with "ptr" tag.
+ *
+ * @param fields
+ *
+ * @internal
+ */
+export declare const pointerFields: (fields: StructField[]) => StructField[];
+/**
+ * Returns filtered array of struct fields of only "string" fields.
+ *
+ * @param fields
+ *
+ * @internal
+ */
+export declare const stringFields: (fields: StructField[]) => StructField[];
+/**
+ * Returns enum identifier formatted according to given opts.
+ *
+ * @param opts
+ * @param name
+ *
+ * @internal
+ */
+export declare const enumName: (opts: CodeGenOpts, name: string) => string;
+/**
+ * Yields iterator of given lines, each with applied indentation based on given
+ * scope regexp's which are applied to each line to increase or decrease
+ * indentation level (the initial indentation level can be specified via
+ * optional `level` arg, default 0). If `scopeStart` succeeds, the indent is
+ * increased for the _next_ line. If `scopeEnd` succeeds the level is decreased
+ * for the _current_ line. ...
+ *
+ * @param lines
+ * @param indent
+ * @param scopeStart
+ * @param scopeEnd
+ * @param level
+ */
+export declare function withIndentation(lines: string[], indent: string, scopeStart: RegExp, scopeEnd: RegExp, level?: number): Generator<string, void, unknown>;
 //# sourceMappingURL=utils.d.ts.map

package/codegen/utils.js

@@ -18,6 +18,7 @@ export const isBigNumeric = (x) => /^[iu]64$/.test(x);
  */
 export const isWasmPrim = (x) => isNumeric(x) || isBigNumeric(x);
 export const isWasmString = (x) => x === "string";
+export const isPadding = (f) => f.pad != null && f.pad > 0;
 /**
  * Takes an array of strings or splits given string into lines, prefixes each
  * line with given `prefix` and then returns rejoined result.
@@ -28,3 +29,57 @@ export const isWasmString = (x) => x === "string";
 export const prefixLines = (prefix, str) => (isString(str) ? str.split("\n") : str)
     .map((line) => prefix + line)
     .join("\n");
+/**
+ * Returns true if `type` is "slice".
+ *
+ * @param type
+ */
+export const isStringSlice = (type) => type === "slice";
+/**
+ * Returns filtered array of struct fields of with "ptr" tag.
+ *
+ * @param fields
+ *
+ * @internal
+ */
+export const pointerFields = (fields) => fields.filter((f) => f.tag === "ptr");
+/**
+ * Returns filtered array of struct fields of only "string" fields.
+ *
+ * @param fields
+ *
+ * @internal
+ */
+export const stringFields = (fields) => fields.filter((f) => isWasmString(f.type) && f.tag !== "ptr");
+/**
+ * Returns enum identifier formatted according to given opts.
+ *
+ * @param opts
+ * @param name
+ *
+ * @internal
+ */
+export const enumName = (opts, name) => opts.uppercaseEnums ? name.toUpperCase() : name;
+/**
+ * Yields iterator of given lines, each with applied indentation based on given
+ * scope regexp's which are applied to each line to increase or decrease
+ * indentation level (the initial indentation level can be specified via
+ * optional `level` arg, default 0). If `scopeStart` succeeds, the indent is
+ * increased for the _next_ line. If `scopeEnd` succeeds the level is decreased
+ * for the _current_ line. ...
+ *
+ * @param lines
+ * @param indent
+ * @param scopeStart
+ * @param scopeEnd
+ * @param level
+ */
+export function* withIndentation(lines, indent, scopeStart, scopeEnd, level = 0) {
+    const stack = new Array(level).fill(indent);
+    for (let l of lines) {
+        scopeEnd.test(l) && stack.pop();
+        const curr = stack.length ? stack[stack.length - 1] : "";
+        yield curr + l;
+        scopeStart.test(l) && stack.push(curr + indent);
+    }
+}

package/codegen/zig.d.ts

@@ -1,15 +1,8 @@
-import type { ICodeGen } from "../api.js";
+import type { CodeGenOptsBase, ICodeGen } from "../api.js";
 /**
  * Zig code generator options.
  */
-export interface ZigOpts {
-    /**
-     * If true, generates various struct & struct field analysis functions
-     * (sizes, alignment, offsets etc.).
-     *
-     * @defaultValue false
-     */
-    debug: boolean;
+export interface ZigOpts extends CodeGenOptsBase {
 }
 /**
  * Zig code generator. Call with options and then pass to {@link generateTypes}

package/codegen/zig.js

@@ -1,5 +1,5 @@
 import { isString } from "@thi.ng/checks/is-string";
-import { prefixLines } from "./utils.js";
+import { enumName, 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).
@@ -10,64 +10,90 @@ import { prefixLines } from "./utils.js";
  *
  * @param opts
  */
-export const ZIG = (opts) => {
-    const { debug } = { debug: false, ...opts };
+export const ZIG = (opts = {}) => {
+    const INDENT = "    ";
+    const SCOPES = [/\{$/, /\}\)?[;,]?$/];
     const gen = {
-        doc: (doc, indent, acc, topLevel = false) => {
-            acc.push(prefixLines(topLevel ? "//! " : indent + "/// ", doc));
+        pre: () => opts.pre || "",
+        post: () => opts.post || "",
+        doc: (doc, acc, topLevel = false) => {
+            acc.push(prefixLines(topLevel ? "//! " : "/// ", doc));
         },
-        enum: (e, _, acc) => {
-            acc.push(`pub const ${e.name} = enum(${e.tag}) {`);
+        enum: (e, _, acc, opts) => {
+            const lines = [];
+            lines.push(`pub const ${e.name} = enum(${e.tag}) {`);
             for (let v of e.values) {
-                let line = `    `;
+                let line;
                 if (!isString(v)) {
-                    v.doc && gen.doc(v.doc, "    ", acc);
-                    line += v.name;
+                    v.doc && gen.doc(v.doc, lines);
+                    line = enumName(opts, v.name);
                     if (v.value != null)
                         line += ` = ${v.value}`;
                 }
                 else {
-                    line += v;
+                    line = enumName(opts, v);
                 }
-                acc.push(line + ",");
+                lines.push(line + ",");
             }
-            acc.push("};\n");
+            lines.push("};", "");
+            acc.push(...withIndentation(lines, INDENT, ...SCOPES));
         },
-        struct: (struct, _, acc) => {
+        struct: (struct, _, acc, opts) => {
             const name = struct.name;
-            acc.push(`pub const ${name} = struct {`);
+            const res = [];
+            res.push(`pub const ${name} = ${struct.tag ? struct.tag + " " : ""}struct {`);
             const ftypes = {};
+            let padID = 0;
             for (let f of struct.fields) {
-                f.doc && gen.doc(f.doc, "    ", acc);
-                let ftype = f.type === "string" ? "[]const u8" : f.type;
+                // 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":
                         ftype = `[${f.len}]${ftype}`;
                         break;
                     case "slice":
-                        ftype = `[]${ftype}`;
+                        ftype = `[]${f.const ? "const " : ""}${ftype}`;
                         break;
                     case "vec":
                         ftype = `@Vector(${f.len}, ${ftype})`;
                         break;
                     case "ptr":
-                        ftype = `*${f.len ? `[${f.len}]` : ""}${ftype}`;
+                        ftype = `*${f.const ? "const " : ""}${f.len ? `[${f.len}]` : ""}${ftype}`;
                         break;
                     case "scalar":
                     default:
                 }
                 ftypes[f.name] = ftype;
-                acc.push(`    ${f.name}: ${ftype},`);
+                res.push(`${f.name}: ${ftype},`);
             }
-            acc.push("};\n");
-            if (!debug)
-                return;
-            const fn = (fname, body) => `export fn ${name}_${fname}() usize { return ${body}; }`;
-            acc.push(fn("align", `@alignOf(${name})`), fn("size", `@sizeOf(${name})`));
-            for (let f of struct.fields) {
-                acc.push(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("};");
+            if (opts.debug) {
+                const fn = (fname, body) => res.push("", `export fn ${name}_${fname}() usize {`, `return ${body};`, `}`);
+                fn("align", `@alignOf(${name})`);
+                fn("size", `@sizeOf(${name})`);
+                for (let f of struct.fields) {
+                    if (isPadding(f))
+                        continue;
+                    fn(f.name + "_align", `@alignOf(${ftypes[f.name]})`);
+                    fn(f.name + "_offset", `@offsetOf(${name}, "${f.name}")`);
+                    fn(f.name + "_size", `@sizeOf(${ftypes[f.name]})`);
+                }
             }
-            acc.push("");
+            res.push("");
+            acc.push(...withIndentation(res, INDENT, ...SCOPES));
         },
     };
     return gen;

package/codegen.d.ts

@@ -1,26 +1,4 @@
-import { ICodeGen, TypeColl } from "./api.js";
-/**
- * Global/shared code generator options.
- */
-export interface CodeGenOpts {
-    /**
-     * 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;
-    /**
-     * 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";
-}
+import { CodeGenOpts, ICodeGen, TypeColl } from "./api.js";
 /**
  * Takes a type collection and analyzes each analyzed to compute individual
  * alignments and sizes.