@thi.ng/wasm-api 0.10.0 → 0.11.0

package/bridge.js

@@ -2,10 +2,10 @@ 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";
 import { EVENT_MEMORY_CHANGED, } from "./api.js";
-const B32 = BigInt(32);
+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
@@ -34,18 +34,18 @@ let WasmBridge = 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)),
@@ -61,6 +61,11 @@ let WasmBridge = class WasmBridge {
             debug: () => {
                 debugger;
             },
+            _panic: (addr, len) => {
+                throw new Panic(this.getString(addr, len));
+            },
+            timer: () => performance.now(),
+            epoch: () => BigInt(Date.now()),
         };
     }
     /**

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

package/codegen/c11.js

@@ -0,0 +1,125 @@
+import { isString } from "@thi.ng/checks/is-string";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { enumName, isPadding, isStringSlice, prefixLines, withIndentation, } from "./utils.js";
+const PRIM_ALIASES = {
+    i8: "int8_t",
+    u8: "uint8_t",
+    i16: "int16_t",
+    u16: "uint16_t",
+    i32: "int32_t",
+    u32: "uint32_t",
+    i64: "int64_t",
+    u64: "uint64_t",
+    f32: "float",
+    f64: "double",
+};
+/**
+ * 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 { typePrefix } = {
+        typePrefix: "",
+        ...opts,
+    };
+    const INDENT = "    ";
+    const SCOPES = [/\{$/, /^\}[ A-Za-z0-9_]*[;,]?$/];
+    const gen = {
+        pre: (opts) => `#pragma once
+${opts.debug ? "\n#include <stdalign.h>" : ""}
+#include <stddef.h>
+#include <stdint.h>${opts.pre ? `\n${opts.pre}` : ""}`,
+        post: () => opts.post || "",
+        doc: (doc, acc) => {
+            acc.push(prefixLines("// ", doc));
+        },
+        enum: (e, _, acc, opts) => {
+            if (!(e.tag === "i32" || e.tag === "u32")) {
+                unsupported(`enum ${e.name} must be a i32/u32 in C, but got '${e.tag}'`);
+            }
+            const name = typePrefix + e.name;
+            const lines = [];
+            lines.push(`typedef enum {`);
+            for (let v of e.values) {
+                let line;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, lines);
+                    line = enumName(opts, v.name);
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line = enumName(opts, v);
+                }
+                lines.push(line + ",");
+            }
+            lines.push(`} ${name};`, "");
+            acc.push(...withIndentation(lines, INDENT, ...SCOPES));
+        },
+        struct: (struct, coll, acc, opts) => {
+            const name = typePrefix + 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(`uint8_t __pad${padID++}[${f.pad}];`);
+                    continue;
+                }
+                f.doc && gen.doc(f.doc, res);
+                const fconst = f.const ? "const " : "";
+                let ftype = f.type === "string"
+                    ? isStringSlice(opts.stringType)
+                        ? __slice("char", fconst)
+                        : `${f.const !== false ? "const " : ""}char*`
+                    : PRIM_ALIASES[f.type] || f.type;
+                if (coll[ftype])
+                    ftype = typePrefix + ftype;
+                switch (f.tag) {
+                    case "array":
+                    case "vec":
+                        res.push(`${fconst}${ftype} ${f.name}[${f.len}];`);
+                        ftype = `${ftype}[${f.len}]`;
+                        break;
+                    case "slice":
+                        ftype = __slice(ftype, fconst);
+                        res.push(`${ftype} ${f.name};`);
+                        break;
+                    case "ptr":
+                        ftype = `${fconst}${ftype}*`;
+                        res.push(`${ftype} ${f.name};`);
+                        break;
+                    case "scalar":
+                    default:
+                        res.push(`${ftype} ${f.name};`);
+                }
+                ftypes[f.name] = ftype;
+            }
+            res.push("};");
+            if (opts.debug) {
+                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) {
+                    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]})`);
+                }
+            }
+            res.push("");
+            acc.push(...withIndentation(res, INDENT, ...SCOPES));
+        },
+    };
+    return gen;
+};
+const __slice = (type, $const) => `struct { ${$const}${type} *ptr; size_t len; }`;

package/codegen/typescript.d.ts

@@ -1,24 +1,14 @@
-import { ICodeGen } from "../api.js";
+import { CodeGenOptsBase, ICodeGen } from "../api.js";
 /**
  * TypeScript code generator options.
  */
-export interface TSOpts {
+export interface TSOpts extends CodeGenOptsBase {
     /**
      * Indentation string
      *
      * @defaultValue "\t"
      */
     indent: string;
-    /**
-     * If true (default), forces uppercase enums
-     *
-     * @defaultValue true
-     */
-    uppercaseEnums: boolean;
-    /**
-     * Same as {@link CodeGenOpts.stringType}.
-     */
-    stringType: "slice" | "ptr";
 }
 /**
  * TypeScript code generator. Call with options and then pass to