@thi.ng/wasm-api 0.4.0 → 0.7.0

package/cli.js

@@ -0,0 +1,142 @@
+import { flag, 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 { ConsoleLogger } from "@thi.ng/logger";
+import { resolve } from "path";
+import { generateTypes } from "./codegen.js";
+import { TYPESCRIPT } from "./codegen/typescript.js";
+import { isPrim } from "./codegen/utils.js";
+import { ZIG } from "./codegen/zig.js";
+const GENERATORS = { ts: TYPESCRIPT, zig: ZIG };
+const argOpts = {
+    config: string({
+        alias: "c",
+        hint: "FILE",
+        desc: "JSON config file with codegen options",
+    }),
+    debug: flag({ alias: "d", default: false, desc: "enable debug output" }),
+    dryRun: flag({
+        default: false,
+        desc: "enable dry run (don't overwrite files)",
+    }),
+    lang: oneOfMulti(Object.keys(GENERATORS), {
+        alias: "l",
+        desc: "target language",
+        default: ["ts", "zig"],
+        delim: ",",
+    }),
+    out: strings({ alias: "o", hint: "FILE", desc: "output file path" }),
+};
+export const INSTALL_DIR = resolve(`${process.argv[2]}/..`);
+export const PKG = readJSON(`${INSTALL_DIR}/package.json`);
+export const APP_NAME = PKG.name.split("/")[1];
+export const HEADER = `
+ █ █   █           │
+██ █               │
+ █ █ █ █   █ █ █ █ │ ${PKG.name} ${PKG.version}
+ █ █ █ █ █ █ █ █ █ │ Multi-language data bindings code generator
+                 █ │
+               █ █ │
+`;
+const usageOpts = {
+    lineWidth: process.stdout.columns,
+    prefix: `${HEADER}
+usage: ${APP_NAME} [OPTS] JSON-INPUT-FILE(S) ...
+       ${APP_NAME} --help
+
+`,
+    showGroupNames: true,
+    paramWidth: 32,
+};
+const showUsage = () => {
+    process.stderr.write(usage(argOpts, usageOpts));
+    process.exit(1);
+};
+const invalidSpec = (path, msg) => {
+    throw new Error(`invalid typedef: ${path}${msg ? ` (${msg})` : ""}`);
+};
+const addTypeSpec = (ctx, path, coll, spec) => {
+    if (!(spec.name && spec.type))
+        invalidSpec(path);
+    if (!(spec.type === "enum" || spec.type === "struct"))
+        invalidSpec(path, `${spec.name} type: ${spec.type}`);
+    if (coll[spec.name])
+        invalidSpec(path, `duplicate name: ${spec.name}`);
+    ctx.logger.debug(`registering ${spec.type}: ${spec.name}`);
+    coll[spec.name] = spec;
+    spec.__path = path;
+};
+const validateTypeRefs = (coll) => {
+    for (let spec of Object.values(coll)) {
+        if (spec.type !== "struct")
+            continue;
+        for (let f of spec.fields) {
+            if (!(isPrim(f.type) || coll[f.type])) {
+                invalidSpec(spec.__path, `structfield ${spec.name}.${f.name} of unknown type: ${f.type}`);
+            }
+        }
+    }
+};
+const parseTypeSpecs = (ctx, inputs) => {
+    const coll = {};
+    for (let path of inputs) {
+        try {
+            const spec = readJSON(resolve(path), ctx.logger);
+            if (isArray(spec)) {
+                for (let s of spec)
+                    addTypeSpec(ctx, path, coll, s);
+            }
+            else if (isPlainObject(spec)) {
+                addTypeSpec(ctx, path, coll, spec);
+            }
+            else {
+                invalidSpec(path);
+            }
+        }
+        catch (e) {
+            process.stderr.write(e.message);
+            process.exit(1);
+        }
+    }
+    validateTypeRefs(coll);
+    return coll;
+};
+const generateOutputs = ({ config, logger, opts }, coll) => {
+    for (let i = 0; i < opts.lang.length; i++) {
+        const lang = opts.lang[i];
+        logger.debug(`generating ${lang.toUpperCase()} output...`);
+        const src = generateTypes(coll, GENERATORS[lang](config[lang]), config.global);
+        if (opts.out) {
+            writeText(resolve(opts.out[i]), src, logger, opts.dryRun);
+        }
+        else {
+            process.stdout.write(src + "\n");
+        }
+    }
+};
+try {
+    const result = parse(argOpts, process.argv, { start: 3, usageOpts });
+    if (!result)
+        process.exit(1);
+    const { result: opts, rest } = result;
+    if (!rest.length)
+        showUsage();
+    if (opts.out && opts.lang.length != opts.out.length) {
+        illegalArgs(`expected ${opts.lang.length} outputs, but got ${opts.out.length}`);
+    }
+    const ctx = {
+        logger: new ConsoleLogger("wasm-api", opts.debug ? "DEBUG" : "INFO"),
+        config: {},
+        opts,
+    };
+    if (opts.config) {
+        ctx.config = readJSON(resolve(opts.config), ctx.logger);
+    }
+    generateOutputs(ctx, parseTypeSpecs(ctx, rest));
+}
+catch (e) {
+    if (!(e instanceof ParseError))
+        process.stderr.write(e.message);
+    process.exit(1);
+}

package/codegen/typescript.d.ts

@@ -0,0 +1,26 @@
+import { ICodeGen } from "../api.js";
+export interface TSOpts {
+    /**
+     * Indentation string
+     *
+     * @defaultValue "\t"
+     */
+    indent: string;
+    /**
+     * If true (default), forces uppercase enums
+     */
+    uppercaseEnums: boolean;
+}
+/**
+ * TypeScript code generator. Call with options and then pass to
+ * {@link generateTypes} (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates interface and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}. For structs it will also generate memory
+ * mapped wrappers with fully typed accessors.
+ *
+ * @param opts
+ */
+export declare const TYPESCRIPT: (opts?: Partial<TSOpts>) => ICodeGen;
+//# sourceMappingURL=typescript.d.ts.map

package/codegen/typescript.js

@@ -0,0 +1,153 @@
+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, } from "../api.js";
+import { isBigNumeric, isNumeric, isPrim, prefixLines } from "./utils.js";
+/**
+ * TypeScript code generator. Call with options and then pass to
+ * {@link generateTypes} (see its docs for further usage).
+ *
+ * @remarks
+ * This codegen generates interface and enum definitions for a {@link TypeColl}
+ * given to {@link generateTypes}. For structs it will also generate memory
+ * mapped wrappers with fully typed accessors.
+ *
+ * @param opts
+ */
+export const TYPESCRIPT = (opts) => {
+    const { indent, uppercaseEnums } = {
+        indent: "\t",
+        uppercaseEnums: true,
+        ...opts,
+    };
+    const I = indent;
+    const I2 = I + I;
+    const I3 = I2 + I;
+    const gen = {
+        pre: `import type { WasmTypeBase, WasmTypeConstructor } from "${PKG_NAME}";`,
+        doc: (doc, indent, acc) => {
+            if (doc.indexOf("\n") !== -1) {
+                acc.push(indent + "/**", prefixLines(indent + " * ", doc), indent + " */");
+            }
+            else {
+                acc.push(`${indent}/** ${doc} */`);
+            }
+        },
+        enum: (type, _, acc) => {
+            const e = type;
+            acc.push(`export enum ${e.name} {`);
+            for (let v of e.values) {
+                var line = indent;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, indent, acc);
+                    line += uppercaseEnums ? v.name.toUpperCase() : v.name;
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line += uppercaseEnums ? v.toUpperCase() : v;
+                }
+                acc.push(line + ",");
+            }
+            acc.push("}\n");
+            return acc;
+        },
+        struct: (type, types, acc) => {
+            const struct = type;
+            const returnTypes = {};
+            // interface definition
+            acc.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 + ";");
+            }
+            acc.push("}\n");
+            // 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}); },`);
+            for (let f of struct.fields) {
+                const offset = f.__offset || 0;
+                acc.push(`${I2}get ${f.name}(): ${returnTypes[f.name]} {`);
+                const prim = isPrim(f.type);
+                if (f.tag === "ptr") {
+                    acc.push(prim
+                        ? `${I3}return mem.${f.type}[${__ptrShift(offset, f.type)}];`
+                        : `${I3}return $${f.type}.instance(${__ptr(offset)});`);
+                }
+                else if (f.tag === "slice") {
+                    acc.push(`${I3}const len = ${__ptr(offset + 4)};`, prim
+                        ? `${I3}const addr = ${__ptrShift(offset, f.type)};
+${I3}return mem.${f.type}.subarray(addr, addr + len);`
+                        : `${I3}const addr = ${__ptr(offset)};\n${__mapArray(f, I3)}`);
+                }
+                else if (f.tag === "array" || f.tag === "vec") {
+                    acc.push(prim
+                        ? `${I3}const addr = ${__addrShift(offset, f.type)};
+${I3}return mem.${f.type}.subarray(addr, addr + ${f.len});`
+                        : `${I3}const addr = ${__addr(offset)};\n${__mapArray(f, I3, f.len)}`);
+                }
+                else {
+                    let setter;
+                    if (prim) {
+                        const addr = __mem(f.type, f.__offset);
+                        acc.push(`${I3}return ${addr};`);
+                        setter = `${addr} = x`;
+                    }
+                    else if (types[f.type].type === "enum") {
+                        const tag = types[f.type].tag;
+                        const addr = __mem(tag, f.__offset);
+                        acc.push(`${I3}return ${addr};`);
+                        setter = `${addr} = x`;
+                    }
+                    else {
+                        acc.push(`${I3}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};`);
+                }
+                // close field accessor
+                acc.push(`${I2}},`);
+            }
+            acc.push(`${I}})\n});\n`);
+            return acc;
+        },
+    };
+    return gen;
+};
+/** @internal */
+const __shift = (type) => BIT_SHIFTS[type];
+/** @internal */
+const __addr = (offset) => (offset > 0 ? `(base + ${offset})` : "base");
+/** @internal */
+const __addrShift = (offset, shift) => {
+    const bits = __shift(shift);
+    return __addr(offset) + (bits ? " >>> " + bits : "");
+};
+/** @internal */
+const __ptr = (offset) => `mem.${USIZE}[${__addrShift(offset, USIZE)}]`;
+/** @internal */
+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;`);

package/codegen/utils.d.ts

@@ -0,0 +1,29 @@
+import type { BigType } from "@thi.ng/api";
+import type { WasmPrim, WasmPrim32 } from "../api.js";
+/**
+ * Returns true iff `x` is a {@link WasmPrim32}.
+ *
+ * @param x
+ */
+export declare const isNumeric: (x: string) => x is WasmPrim32;
+/**
+ * Returns true iff `x` is a `i64` or `u64`.
+ *
+ * @param x
+ */
+export declare const isBigNumeric: (x: string) => x is BigType;
+/**
+ * Returns true iff `x` is a {@link WasmPrim}.
+ *
+ * @param x
+ */
+export declare const isPrim: (x: string) => x is WasmPrim;
+/**
+ * Splits given string into lines, prefixes each with given `prefix` and then
+ * returns rejoined result.
+ *
+ * @param prefix
+ * @param str
+ */
+export declare const prefixLines: (prefix: string, str: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/codegen/utils.js

@@ -0,0 +1,29 @@
+/**
+ * Returns true iff `x` is a {@link WasmPrim32}.
+ *
+ * @param x
+ */
+export const isNumeric = (x) => /^(([iu](8|16|32))|(f(32|64)))$/.test(x);
+/**
+ * Returns true iff `x` is a `i64` or `u64`.
+ *
+ * @param x
+ */
+export const isBigNumeric = (x) => /^[iu]64$/.test(x);
+/**
+ * Returns true iff `x` is a {@link WasmPrim}.
+ *
+ * @param x
+ */
+export const isPrim = (x) => isNumeric(x) || isBigNumeric(x);
+/**
+ * Splits given string into lines, prefixes each with given `prefix` and then
+ * returns rejoined result.
+ *
+ * @param prefix
+ * @param str
+ */
+export const prefixLines = (prefix, str) => str
+    .split("\n")
+    .map((line) => prefix + line)
+    .join("\n");

package/codegen/zig.d.ts

@@ -0,0 +1,22 @@
+import type { ICodeGen } from "../api.js";
+export interface ZigOpts {
+    /**
+     * If true, generates various struct & struct field analysis functions
+     * (sizes, alignment, offsets etc.).
+     *
+     * @defaultValue false
+     */
+    debug: boolean;
+}
+/**
+ * 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 ZIG: (opts?: Partial<ZigOpts>) => ICodeGen;
+//# sourceMappingURL=zig.d.ts.map

package/codegen/zig.js

@@ -0,0 +1,75 @@
+import { isString } from "@thi.ng/checks/is-string";
+import { prefixLines } 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 ZIG = (opts) => {
+    const { debug } = { debug: false, ...opts };
+    const gen = {
+        doc: (doc, indent, acc, topLevel = false) => {
+            acc.push(prefixLines(topLevel ? "//! " : indent + "/// ", doc));
+        },
+        enum: (e, _, acc) => {
+            acc.push(`pub const ${e.name} = enum(${e.tag}) {`);
+            for (let v of e.values) {
+                let line = `    `;
+                if (!isString(v)) {
+                    v.doc && gen.doc(v.doc, "    ", acc);
+                    line += v.name;
+                    if (v.value != null)
+                        line += ` = ${v.value}`;
+                }
+                else {
+                    line += v;
+                }
+                acc.push(line + ",");
+            }
+            acc.push("};\n");
+        },
+        struct: (struct, _, acc) => {
+            const name = struct.name;
+            acc.push(`pub const ${name} = struct {`);
+            const ftypes = {};
+            for (let f of struct.fields) {
+                f.doc && gen.doc(f.doc, "    ", acc);
+                var ftype;
+                switch (f.tag) {
+                    case "array":
+                        ftype = `[${f.len}]${f.type}`;
+                        break;
+                    case "slice":
+                        ftype = `[]${f.type}`;
+                        break;
+                    case "vec":
+                        ftype = `@Vector(${f.len}, ${f.type})`;
+                        break;
+                    case "ptr":
+                        ftype = `*${f.len ? `[${f.len}]` : ""}${f.type}`;
+                        break;
+                    case "scalar":
+                    default:
+                        ftype = f.type;
+                }
+                ftypes[f.name] = ftype;
+                acc.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]})`));
+            }
+            acc.push("");
+        },
+    };
+    return gen;
+};

package/codegen.d.ts

@@ -0,0 +1,16 @@
+import { ICodeGen, TypeColl } from "./api.js";
+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;
+}
+export declare const prepareTypes: (types: TypeColl) => void;
+export declare const generateTypes: (types: TypeColl, codegen: ICodeGen, opts?: Partial<CodeGenOpts>) => string;
+//# sourceMappingURL=codegen.d.ts.map

package/codegen.js

@@ -0,0 +1,116 @@
+import { SIZEOF } from "@thi.ng/api/typedarray";
+import { align } from "@thi.ng/binary/align";
+import { ceilPow2 } from "@thi.ng/binary/pow";
+import { compareByKey } from "@thi.ng/compare/keys";
+import { compareNumDesc } from "@thi.ng/compare/numeric";
+import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
+import { PKG_NAME, USIZE_SIZE, } from "./api.js";
+import { isNumeric } from "./codegen/utils.js";
+const sizeOf = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (field, types) => {
+        if (field.__size)
+            return field.__size;
+        let size = 0;
+        if (field.tag === "ptr") {
+            size = USIZE_SIZE;
+        }
+        else if (field.tag === "slice") {
+            size = USIZE_SIZE * 2;
+        }
+        else {
+            size = isNumeric(field.type)
+                ? SIZEOF[field.type]
+                : sizeOf(types[field.type], types);
+            if (field.tag == "array" || field.tag === "vec") {
+                size *= field.len;
+            }
+        }
+        return (field.__size = align(size, field.__align));
+    },
+    enum: (type) => {
+        if (type.__size)
+            return type.__size;
+        return (type.__size = SIZEOF[type.tag]);
+    },
+    struct: (type, types) => {
+        if (type.__size)
+            return type.__size;
+        const struct = type;
+        let size = 0;
+        for (let f of struct.fields) {
+            size = align(size, f.__align);
+            f.__offset = size;
+            size += sizeOf(f, types);
+        }
+        return (type.__size = align(size, type.__align));
+    },
+});
+const alignOf = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (field, types) => {
+        if (field.__align)
+            return field.__align;
+        let align = isNumeric(field.type)
+            ? SIZEOF[field.type]
+            : alignOf(types[field.type], types);
+        if (field.tag === "vec") {
+            align *= ceilPow2(field.len);
+        }
+        field.__align = align;
+        return align;
+    },
+    enum: (e) => {
+        return (e.__align = SIZEOF[e.tag]);
+    },
+    struct: (type, types) => {
+        const struct = type;
+        let maxAlign = 0;
+        for (let f of struct.fields) {
+            maxAlign = Math.max(maxAlign, alignOf(f, types));
+        }
+        return (type.__align = maxAlign);
+    },
+});
+const prepareType = defmulti((x) => x.type, {}, {
+    [DEFAULT]: (x, types) => {
+        if (x.__align && x.__size)
+            return;
+        alignOf(x, types);
+        sizeOf(x, types);
+    },
+    struct: (x, types) => {
+        if (x.__align && x.__size)
+            return;
+        const struct = x;
+        alignOf(struct, types);
+        if (struct.auto) {
+            struct.fields.sort(compareByKey("__align", compareNumDesc));
+        }
+        for (let f of struct.fields) {
+            if (types[f.type]) {
+                prepareType(types[f.type], types);
+            }
+        }
+        sizeOf(struct, types);
+    },
+});
+export const prepareTypes = (types) => {
+    for (let id in types) {
+        prepareType(types[id], types);
+    }
+};
+export const generateTypes = (types, codegen, opts = {}) => {
+    prepareTypes(types);
+    const res = [];
+    codegen.doc(`Generated by ${PKG_NAME} at ${new Date().toISOString()} - DO NOT EDIT!`, "", res, true);
+    res.push("");
+    codegen.pre && res.push(codegen.pre, "");
+    opts.pre && res.push(opts.pre, "");
+    for (let id in types) {
+        const type = types[id];
+        type.doc && codegen.doc(type.doc, "", res);
+        codegen[type.type](type, types, res);
+    }
+    opts.post && res.push("", opts.post);
+    codegen.post && res.push("", codegen.post);
+    return res.join("\n");
+};

package/include/wasmapi.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define WASM_IMPORT(MODULE, TYPE, NAME, PREFIX)                     \
+  extern __attribute__((import_module(MODULE), import_name(#NAME))) \
+  TYPE PREFIX##NAME
+#define WASM_KEEP __attribute__((used))
+
+// Generate stubs only if explicitly disabled by defining this symbol
+#ifdef WASMAPI_NO_MALLOC
+size_t WASM_KEEP _wasm_allocate(size_t num_bytes) { return 0; }
+void WASM_KEEP _wasm_free(size_t addr) {}
+#else
+#include <stdlib.h>
+size_t WASM_KEEP _wasm_allocate(size_t numBytes) {
+  return (size_t)malloc(numBytes);
+}
+void WASM_KEEP _wasm_free(size_t addr) { free((void*)addr); }
+#endif
+
+WASM_IMPORT("wasmapi", void, printI8, wasm_)(int8_t x);
+WASM_IMPORT("wasmapi", void, printU8, wasm_)(uint8_t x);
+WASM_IMPORT("wasmapi", void, printU8Hex, wasm_)(uint8_t x);
+WASM_IMPORT("wasmapi", void, printI16, wasm_)(int16_t x);
+WASM_IMPORT("wasmapi", void, printU16, wasm_)(uint16_t x);
+WASM_IMPORT("wasmapi", void, printU16Hex, wasm_)(uint16_t x);
+WASM_IMPORT("wasmapi", void, printI32, wasm_)(int32_t x);
+WASM_IMPORT("wasmapi", void, printU32, wasm_)(uint32_t x);
+WASM_IMPORT("wasmapi", void, printU32Hex, wasm_)(uint32_t x);
+WASM_IMPORT("wasmapi", void, printI64, wasm_)(int64_t x);
+WASM_IMPORT("wasmapi", void, printU64, wasm_)(uint64_t x);
+WASM_IMPORT("wasmapi", void, printU64Hex, wasm_)(uint64_t x);
+WASM_IMPORT("wasmapi", void, printF32, wasm_)(float x);
+WASM_IMPORT("wasmapi", void, printF64, wasm_)(double x);
+
+WASM_IMPORT("wasmapi", void, _printI8Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU8Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI16Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU16Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI32Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU32Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printI64Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printU64Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printF32Array, wasm)(void* addr, size_t len);
+WASM_IMPORT("wasmapi", void, _printF64Array, wasm)(void* addr, size_t len);
+
+WASM_IMPORT("wasmapi", void, _printStr0, wasm)(void* addr);
+WASM_IMPORT("wasmapi", void, _printStr, wasm)(void* addr, size_t len);
+
+void wasm_printPtr(void* ptr) { wasm_printU32Hex((size_t)ptr); }
+
+#ifdef __cplusplus
+}
+#endif