@wasm-fmt/clang-format
Version:
A tool to format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code
1,186 lines • 82.3 kB
JavaScript
export function createModule(Module) {
const ENVIRONMENT_IS_SHELL = false;
readBinary = () => Module.wasm;
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow
};
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory)
}
return scriptDirectory + path
}
var readAsync, readBinary;
if (ENVIRONMENT_IS_SHELL) {
readBinary = f => {
if (globalThis.readbuffer) {
return new Uint8Array(readbuffer(f))
}
let data = read(f, "binary");
assert(typeof data == "object");
return data
};
readAsync = async f => readBinary(f);
globalThis.clearTimeout ??= id => {};
globalThis.setTimeout ??= f => f();
arguments_ = globalThis.arguments || globalThis.scriptArgs;
if (globalThis.quit) {
quit_ = (status, toThrow) => {
setTimeout(() => {
if (!(toThrow instanceof ExitStatus)) {
let toLog = toThrow;
if (toThrow && typeof toThrow == "object" && toThrow.stack) {
toLog = [toThrow, toThrow.stack]
}
err(`exiting due to exception: ${toLog}`)
}
quit(status)
});
throw toThrow
}
}
if (typeof print != "undefined") {
globalThis.console ??= {};
console.log = print;
console.warn = console.error = globalThis.printErr ?? print
}
} else {
}
var out = console.log.bind(console);
var err = console.error.bind(console);
var wasmBinary;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort(text)
}
}
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var HEAP64, HEAPU64;
var runtimeInitialized = false;
function updateMemoryViews() {
var b = wasmMemory.buffer;
HEAP8 = new Int8Array(b);
HEAP16 = new Int16Array(b);
HEAPU8 = new Uint8Array(b);
HEAPU16 = new Uint16Array(b);
HEAP32 = new Int32Array(b);
HEAPU32 = new Uint32Array(b);
HEAPF32 = new Float32Array(b);
HEAPF64 = new Float64Array(b);
HEAP64 = new BigInt64Array(b);
HEAPU64 = new BigUint64Array(b)
}
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift())
}
}
callRuntimeCallbacks(onPreRuns)
}
function initRuntime() {
runtimeInitialized = true;
wasmExports["aa"]()
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift())
}
}
callRuntimeCallbacks(onPostRuns)
}
function abort(what) {
Module["onAbort"]?.(what);
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
throw e
}
var wasmBinaryFile;
function findWasmBinary() { return locateFile("clang-format-esm.wasm") }
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary)
}
if (readBinary) {
return readBinary(file)
}
throw "sync fetching of the wasm failed: you can preload it to Module[\"wasmBinary\"] manually, or emcc.py will do that for you when generating HTML (but not JS)"
}
function instantiateSync(file, info) {
var module;
var binary = getBinarySync(file);
module = binary;
if (!(module instanceof WebAssembly.Module))
module = new WebAssembly.Module(module);
var instance = new WebAssembly.Instance(module, info);
return [instance, module]
}
function getWasmImports() {
var imports = { a: wasmImports };
return imports
}
function createWasm() {
function receiveInstance(instance, module) {
wasmExports = instance.exports;
assignWasmExports(wasmExports);
updateMemoryViews();
return wasmExports
}
var info = getWasmImports();
if (Module["instantiateWasm"]) {
return new Promise(
(resolve,
reject) => { Module["instantiateWasm"](info, (inst, mod) => { resolve(receiveInstance(inst, mod)) }) })
}
wasmBinaryFile ??= findWasmBinary();
var result = instantiateSync(wasmBinaryFile, info);
return receiveInstance(result[0])
}
class ExitStatus {
name = "ExitStatus";
constructor(status) {
this.message = `Program terminated with exit(${status})`;
this.status = status
}
}
var callRuntimeCallbacks = callbacks => {
while (callbacks.length > 0) {
callbacks.shift()(Module)
}
};
var onPostRuns = [];
var addOnPostRun = cb => onPostRuns.push(cb);
var onPreRuns = [];
var addOnPreRun = cb => onPreRuns.push(cb);
var noExitRuntime = true;
var getWasmTableEntry = funcPtr => wasmTable.get(funcPtr);
var ___call_sighandler = (fp, sig) => getWasmTableEntry(fp)(sig);
class ExceptionInfo {
constructor(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24
}
set_type(type) { HEAPU32[this.ptr + 4 >> 2] = type }
get_type() { return HEAPU32[this.ptr + 4 >> 2] }
set_destructor(destructor) { HEAPU32[this.ptr + 8 >> 2] = destructor }
get_destructor() { return HEAPU32[this.ptr + 8 >> 2] }
set_caught(caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12] = caught
}
get_caught() { return HEAP8[this.ptr + 12] != 0 }
set_rethrown(rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13] = rethrown
}
get_rethrown() { return HEAP8[this.ptr + 13] != 0 }
init(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor)
}
set_adjusted_ptr(adjustedPtr) { HEAPU32[this.ptr + 16 >> 2] = adjustedPtr }
get_adjusted_ptr() { return HEAPU32[this.ptr + 16 >> 2] }
}
var exceptionLast = 0;
var uncaughtExceptionCount = 0;
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw exceptionLast
};
var ___syscall_chdir = path => {};
var ___syscall_faccessat = (dirfd, path, amode, flags) => {};
var ___syscall_fstat64 = (fd, buf) => {};
var ___syscall_getcwd = (buf, size) => {};
var ___syscall_getdents64 = (fd, dirp, count) => {};
var ___syscall_lstat64 = (path, buf) => {};
var ___syscall_newfstatat = (dirfd, path, buf, flags) => {};
var UTF8Decoder = globalThis.TextDecoder && new TextDecoder;
var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
var maxIdx = idx + maxBytesToRead;
if (ignoreNul)
return maxIdx;
while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
return idx
};
var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr))
}
var str = "";
while (idx < endPtr) {
var u0 = heapOrArray[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue
}
var u1 = heapOrArray[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue
}
var u2 = heapOrArray[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2
} else {
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63
}
if (u0 < 65536) {
str += String.fromCharCode(u0)
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
}
}
return str
};
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) =>
ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
var SYSCALLS = {
varargs: undefined,
getStr(ptr) {
var ret = UTF8ToString(ptr);
return ret
}
};
function ___syscall_openat(dirfd, path, flags, varargs) { SYSCALLS.varargs = varargs }
var ___syscall_readlinkat = (dirfd, path, buf, bufsize) => {};
var ___syscall_stat64 = (path, buf) => {};
var ___syscall_statfs64 = (path, size, buf) => {};
var ___syscall_unlinkat = (dirfd, path, flags) => {};
var __abort_js = () => abort("");
var structRegistrations = {};
var runDestructors = destructors => {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr)
}
};
function readPointer(pointer) { return this.fromWireType(HEAPU32[pointer >> 2]) }
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var InternalError = class InternalError extends Error {
constructor(message) {
super(message);
this.name = "InternalError"
}
};
var throwInternalError = message => {
throw new InternalError(message)
};
var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
myTypes.forEach(type => typeDependencies[type] = dependentTypes);
function onComplete(typeConverters) {
var myTypeConverters = getTypeConverters(typeConverters);
if (myTypeConverters.length !== myTypes.length) {
throwInternalError("Mismatched type converter count")
}
for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i])
}
}
var typeConverters = new Array(dependentTypes.length);
var unregisteredTypes = [];
var registered = 0;
for (let [i, dt] of dependentTypes.entries()) {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt]
} else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = []
}
awaitingDependencies[dt].push(() => {
typeConverters[i] = registeredTypes[dt];
++registered;
if (registered === unregisteredTypes.length) {
onComplete(typeConverters)
}
})
}
}
if (0 === unregisteredTypes.length) {
onComplete(typeConverters)
}
};
var __embind_finalize_value_object = structType => {
var reg = structRegistrations[structType];
delete structRegistrations[structType];
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
var fieldRecords = reg.fields;
var fieldTypes = fieldRecords.map(field => field.getterReturnType)
.concat(fieldRecords.map(field => field.setterArgumentType));
whenDependentTypesAreResolved([structType], fieldTypes, fieldTypes => {
var fields = {};
for (var [i, field] of fieldRecords.entries()) {
const getterReturnType = fieldTypes[i];
const getter = field.getter;
const getterContext = field.getterContext;
const setterArgumentType = fieldTypes[i + fieldRecords.length];
const setter = field.setter;
const setterContext = field.setterContext;
fields[field.fieldName] = {
read: ptr => getterReturnType.fromWireType(getter(getterContext, ptr)),
write: (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o));
runDestructors(destructors)
},
optional: getterReturnType.optional
}
}
return [{
name: reg.name,
fromWireType: ptr => {
var rv = {};
for (var i in fields) {
rv[i] = fields[i].read(ptr)
}
rawDestructor(ptr);
return rv
},
toWireType: (destructors, o) => {
for (var fieldName in fields) {
if (!(fieldName in o) && !fields[fieldName].optional) {
throw new TypeError(`Missing field: "${fieldName}"`)
}
}
var ptr = rawConstructor();
for (fieldName in fields) {
fields[fieldName].write(ptr, o[fieldName])
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr)
}
return ptr
},
readValueFromPointer: readPointer,
destructorFunction: rawDestructor
}]
})
};
var AsciiToString = ptr => {
var str = "";
while (1) {
var ch = HEAPU8[ptr++];
if (!ch)
return str;
str += String.fromCharCode(ch)
}
};
var BindingError = class BindingError extends Error {
constructor(message) {
super(message);
this.name = "BindingError"
}
};
var throwBindingError = message => {
throw new BindingError(message)
};
function sharedRegisterType(rawType, registeredInstance, options = {}) {
var name = registeredInstance.name;
if (!rawType) {
throwBindingError(`type "${name}" must have a positive integer typeid pointer`)
}
if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return
} else {
throwBindingError(`Cannot register type '${name}' twice`)
}
}
registeredTypes[rawType] = registeredInstance;
delete typeDependencies[rawType];
if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach(cb => cb())
}
}
function registerType(rawType, registeredInstance, options = {}) {
return sharedRegisterType(rawType, registeredInstance, options)
}
var integerReadValueFromPointer = (name, width, signed) => {
switch (width) {
case 1:
return signed ? pointer => HEAP8[pointer] : pointer => HEAPU8[pointer];
case 2:
return signed ? pointer => HEAP16[pointer >> 1] : pointer => HEAPU16[pointer >> 1];
case 4:
return signed ? pointer => HEAP32[pointer >> 2] : pointer => HEAPU32[pointer >> 2];
case 8:
return signed ? pointer => HEAP64[pointer >> 3] : pointer => HEAPU64[pointer >> 3];
default:
throw new TypeError(`invalid integer width (${width}): ${name}`)
}
};
var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
name = AsciiToString(name);
const isUnsignedType = minRange === 0n;
let fromWireType = value => value;
if (isUnsignedType) {
const bitSize = size * 8;
fromWireType = value => BigInt.asUintN(bitSize, value);
maxRange = fromWireType(maxRange)
}
registerType(primitiveType, {
name,
fromWireType,
toWireType: (destructors, value) => {
if (typeof value == "number") {
value = BigInt(value)
}
return value
},
readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType),
destructorFunction: null
})
};
var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
name = AsciiToString(name);
registerType(rawType, {
name,
fromWireType: function(wt) { return !!wt },
toWireType: function(destructors, o) { return o ? trueValue : falseValue },
readValueFromPointer: function(pointer) { return this.fromWireType(HEAPU8[pointer]) },
destructorFunction: null
})
};
var shallowCopyInternalPointer = o => ({
count: o.count,
deleteScheduled: o.deleteScheduled,
preservePointerOnDelete: o.preservePointerOnDelete,
ptr: o.ptr,
ptrType: o.ptrType,
smartPtr: o.smartPtr,
smartPtrType: o.smartPtrType
});
var throwInstanceAlreadyDeleted = obj => {
function getInstanceTypeName(handle) { return handle.$$.ptrType.registeredClass.name }
throwBindingError(getInstanceTypeName(obj) + " instance already deleted")
};
var finalizationRegistry = false;
var detachFinalizer = handle => {};
var runDestructor = $$ => {
if ($$.smartPtr) {
$$.smartPtrType.rawDestructor($$.smartPtr)
} else {
$$.ptrType.registeredClass.rawDestructor($$.ptr)
}
};
var releaseClassHandle = $$ => {
$$.count.value -= 1;
var toDelete = 0 === $$.count.value;
if (toDelete) {
runDestructor($$)
}
};
var attachFinalizer = handle => {
if (!globalThis.FinalizationRegistry) {
attachFinalizer = handle => handle;
return handle
}
finalizationRegistry = new FinalizationRegistry(info => { releaseClassHandle(info.$$) });
attachFinalizer = handle => {
var $$ = handle.$$;
var hasSmartPtr = !!$$.smartPtr;
if (hasSmartPtr) {
var info = { $$ };
finalizationRegistry.register(handle, info, handle)
}
return handle
};
detachFinalizer = handle => finalizationRegistry.unregister(handle);
return attachFinalizer(handle)
};
var deletionQueue = [];
var flushPendingDeletes = () => {
while (deletionQueue.length) {
var obj = deletionQueue.pop();
obj.$$.deleteScheduled = false;
obj["delete"]()
}
};
var delayFunction;
var init_ClassHandle = () => {
let proto = ClassHandle.prototype;
Object.assign(proto, {
isAliasOf(other) {
if (!(this instanceof ClassHandle)) {
return false
}
if (!(other instanceof ClassHandle)) {
return false
}
var leftClass = this.$$.ptrType.registeredClass;
var left = this.$$.ptr;
other.$$ = other.$$;
var rightClass = other.$$.ptrType.registeredClass;
var right = other.$$.ptr;
while (leftClass.baseClass) {
left = leftClass.upcast(left);
leftClass = leftClass.baseClass
}
while (rightClass.baseClass) {
right = rightClass.upcast(right);
rightClass = rightClass.baseClass
}
return leftClass === rightClass && left === right
},
clone() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.preservePointerOnDelete) {
this.$$.count.value += 1;
return this
} else {
var clone = attachFinalizer(Object.create(
Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
clone.$$.count.value += 1;
clone.$$.deleteScheduled = false;
return clone
}
},
delete () {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion")
}
detachFinalizer(this);
releaseClassHandle(this.$$);
if (!this.$$.preservePointerOnDelete) {
this.$$.smartPtr = undefined;
this.$$.ptr = undefined
}
},
isDeleted() { return !this.$$.ptr },
deleteLater() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion")
}
deletionQueue.push(this);
if (deletionQueue.length === 1 && delayFunction) {
delayFunction(flushPendingDeletes)
}
this.$$.deleteScheduled = true;
return this
}
});
const symbolDispose = Symbol.dispose;
if (symbolDispose) {
proto[symbolDispose] = proto["delete"]
}
};
function ClassHandle() {}
var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
var registeredPointers = {};
var ensureOverloadTable = (proto, methodName, humanName) => {
if (undefined === proto[methodName].overloadTable) {
var prevFunc = proto[methodName];
proto[methodName] = function(...args) {
if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${
args.length}) - expects one of (${proto[methodName].overloadTable})!`)
}
return proto[methodName].overloadTable[args.length].apply(this, args)
};
proto[methodName].overloadTable = [];
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
}
};
var exposePublicSymbol = (name, value, numArguments) => {
if (Module.hasOwnProperty(name)) {
if (undefined === numArguments ||
undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
throwBindingError(`Cannot register public name '${name}' twice`)
}
ensureOverloadTable(Module, name, name);
if (Module[name].overloadTable.hasOwnProperty(numArguments)) {
throwBindingError(
`Cannot register multiple overloads of a function with the same number of arguments (${
numArguments})!`)
}
Module[name].overloadTable[numArguments] = value
} else {
Module[name] = value;
Module[name].argCount = numArguments
}
};
var char_0 = 48;
var char_9 = 57;
var makeLegalFunctionName = name => {
name = name.replace(/[^a-zA-Z0-9_]/g, "$");
var f = name.charCodeAt(0);
if (f >= char_0 && f <= char_9) {
return `_${name}`
}
return name
};
function RegisteredClass(
name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
this.name = name;
this.constructor = constructor;
this.instancePrototype = instancePrototype;
this.rawDestructor = rawDestructor;
this.baseClass = baseClass;
this.getActualType = getActualType;
this.upcast = upcast;
this.downcast = downcast;
this.pureVirtualFunctions = []
}
var upcastPointer = (ptr, ptrClass, desiredClass) => {
while (ptrClass !== desiredClass) {
if (!ptrClass.upcast) {
throwBindingError(
`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)
}
ptr = ptrClass.upcast(ptr);
ptrClass = ptrClass.baseClass
}
return ptr
};
var embindRepr = v => {
if (v === null) {
return "null"
}
var t = typeof v;
if (t === "object" || t === "array" || t === "function") {
return v.toString()
} else {
return "" + v
}
};
function constNoSmartPtrRawPointerToWireType(destructors, handle) {
if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`)
}
return 0
}
if (!handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
}
if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)
}
var handleClass = handle.$$.ptrType.registeredClass;
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
return ptr
}
function genericPointerToWireType(destructors, handle) {
var ptr;
if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`)
}
if (this.isSmartPointer) {
ptr = this.rawConstructor();
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr)
}
return ptr
} else {
return 0
}
}
if (!handle || !handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
}
if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)
}
if (!this.isConst && handle.$$.ptrType.isConst) {
throwBindingError(`Cannot convert argument of type ${
handle.$$.smartPtrType ? handle.$$.smartPtrType.name
: handle.$$.ptrType.name} to parameter type ${this.name}`)
}
var handleClass = handle.$$.ptrType.registeredClass;
ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
if (this.isSmartPointer) {
if (undefined === handle.$$.smartPtr) {
throwBindingError("Passing raw pointer to smart pointer is illegal")
}
switch (this.sharingPolicy) {
case 0:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr
} else {
throwBindingError(`Cannot convert argument of type ${
handle.$$.smartPtrType ? handle.$$.smartPtrType.name
: handle.$$.ptrType.name} to parameter type ${this.name}`)
}
break;
case 1:
ptr = handle.$$.smartPtr;
break;
case 2:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr
} else {
var clonedHandle = handle["clone"]();
ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle["delete"]()));
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr)
}
}
break;
default:
throwBindingError("Unsupported sharing policy")
}
}
return ptr
}
function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
if (handle === null) {
if (this.isReference) {
throwBindingError(`null is not a valid ${this.name}`)
}
return 0
}
if (!handle.$$) {
throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
}
if (!handle.$$.ptr) {
throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)
}
if (handle.$$.ptrType.isConst) {
throwBindingError(
`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)
}
var handleClass = handle.$$.ptrType.registeredClass;
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
return ptr
}
var downcastPointer = (ptr, ptrClass, desiredClass) => {
if (ptrClass === desiredClass) {
return ptr
}
if (undefined === desiredClass.baseClass) {
return null
}
var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
if (rv === null) {
return null
}
return desiredClass.downcast(rv)
};
var registeredInstances = {};
var getBasestPointer = (class_, ptr) => {
if (ptr === undefined) {
throwBindingError("ptr should not be undefined")
}
while (class_.baseClass) {
ptr = class_.upcast(ptr);
class_ = class_.baseClass
}
return ptr
};
var getInheritedInstance = (class_, ptr) => {
ptr = getBasestPointer(class_, ptr);
return registeredInstances[ptr]
};
var makeClassHandle = (prototype, record) => {
if (!record.ptrType || !record.ptr) {
throwInternalError("makeClassHandle requires ptr and ptrType")
}
var hasSmartPtrType = !!record.smartPtrType;
var hasSmartPtr = !!record.smartPtr;
if (hasSmartPtrType !== hasSmartPtr) {
throwInternalError("Both smartPtrType and smartPtr must be specified")
}
record.count = { value: 1 };
return attachFinalizer(Object.create(prototype, { $$: { value: record, writable: true } }))
};
function RegisteredPointer_fromWireType(ptr) {
var rawPointer = this.getPointee(ptr);
if (!rawPointer) {
this.destructor(ptr);
return null
}
var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
if (undefined !== registeredInstance) {
if (0 === registeredInstance.$$.count.value) {
registeredInstance.$$.ptr = rawPointer;
registeredInstance.$$.smartPtr = ptr;
return registeredInstance["clone"]()
} else {
var rv = registeredInstance["clone"]();
this.destructor(ptr);
return rv
}
}
function makeDefaultHandle() {
if (this.isSmartPointer) {
return makeClassHandle(
this.registeredClass.instancePrototype,
{ ptrType: this.pointeeType, ptr: rawPointer, smartPtrType: this, smartPtr: ptr })
} else {
return makeClassHandle(this.registeredClass.instancePrototype, { ptrType: this, ptr })
}
}
var actualType = this.registeredClass.getActualType(rawPointer);
var registeredPointerRecord = registeredPointers[actualType];
if (!registeredPointerRecord) {
return makeDefaultHandle.call(this)
}
var toType;
if (this.isConst) {
toType = registeredPointerRecord.constPointerType
} else {
toType = registeredPointerRecord.pointerType
}
var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
if (dp === null) {
return makeDefaultHandle.call(this)
}
if (this.isSmartPointer) {
return makeClassHandle(
toType.registeredClass.instancePrototype,
{ ptrType: toType, ptr: dp, smartPtrType: this, smartPtr: ptr })
} else {
return makeClassHandle(toType.registeredClass.instancePrototype, { ptrType: toType, ptr: dp })
}
}
var init_RegisteredPointer = () => {
Object.assign(RegisteredPointer.prototype, {
getPointee(ptr) {
if (this.rawGetPointee) {
ptr = this.rawGetPointee(ptr)
}
return ptr
},
destructor(ptr) { this.rawDestructor?.(ptr) },
readValueFromPointer: readPointer,
fromWireType: RegisteredPointer_fromWireType
})
};
function RegisteredPointer(
name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee,
rawConstructor, rawShare, rawDestructor) {
this.name = name;
this.registeredClass = registeredClass;
this.isReference = isReference;
this.isConst = isConst;
this.isSmartPointer = isSmartPointer;
this.pointeeType = pointeeType;
this.sharingPolicy = sharingPolicy;
this.rawGetPointee = rawGetPointee;
this.rawConstructor = rawConstructor;
this.rawShare = rawShare;
this.rawDestructor = rawDestructor;
if (!isSmartPointer && registeredClass.baseClass === undefined) {
if (isConst) {
this.toWireType = constNoSmartPtrRawPointerToWireType;
this.destructorFunction = null
} else {
this.toWireType = nonConstNoSmartPtrRawPointerToWireType;
this.destructorFunction = null
}
} else {
this.toWireType = genericPointerToWireType
}
}
var replacePublicSymbol = (name, value, numArguments) => {
if (!Module.hasOwnProperty(name)) {
throwInternalError("Replacing nonexistent public symbol")
}
if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
Module[name].overloadTable[numArguments] = value
} else {
Module[name] = value;
Module[name].argCount = numArguments
}
};
var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
signature = AsciiToString(signature);
function makeDynCaller() {
var rtn = getWasmTableEntry(rawFunction);
return rtn
}
var fp = makeDynCaller();
if (typeof fp != "function") {
throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)
}
return fp
};
class UnboundTypeError extends Error {}
var getTypeName = type => {
var ptr = ___getTypeName(type);
var rv = AsciiToString(ptr);
_free(ptr);
return rv
};
var throwUnboundTypeError = (message, types) => {
var unboundTypes = [];
var seen = {};
function visit(type) {
if (seen[type]) {
return
}
if (registeredTypes[type]) {
return
}
if (typeDependencies[type]) {
typeDependencies[type].forEach(visit);
return
}
unboundTypes.push(type);
seen[type] = true
}
types.forEach(visit);
throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]))
};
var __embind_register_class =
(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType,
upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) => {
name = AsciiToString(name);
getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
upcast &&= embind__requireFunction(upcastSignature, upcast);
downcast &&= embind__requireFunction(downcastSignature, downcast);
rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
var legalFunctionName = makeLegalFunctionName(name);
exposePublicSymbol(legalFunctionName, function() {
throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType])
});
whenDependentTypesAreResolved(
[rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], base => {
base = base[0];
var baseClass;
var basePrototype;
if (baseClassRawType) {
baseClass = base.registeredClass;
basePrototype = baseClass.instancePrototype
} else {
basePrototype = ClassHandle.prototype
}
var constructor = createNamedFunction(name, function(...args) {
if (Object.getPrototypeOf(this) !== instancePrototype) {
throw new BindingError(`Use 'new' to construct ${name}`)
}
if (undefined === registeredClass.constructor_body) {
throw new BindingError(`${name} has no accessible constructor`)
}
var body = registeredClass.constructor_body[args.length];
if (undefined === body) {
throw new BindingError(`Tried to invoke ctor of ${
name} with invalid number of parameters (${args.length}) - expected (${
Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)
}
return body.apply(this, args)
});
var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } });
constructor.prototype = instancePrototype;
var registeredClass = new RegisteredClass(
name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast,
downcast);
if (registeredClass.baseClass) {
registeredClass.baseClass.__derivedClasses ??= [];
registeredClass.baseClass.__derivedClasses.push(registeredClass)
}
var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
var constPointerConverter =
new RegisteredPointer(name + " const*", registeredClass, false, true, false);
registeredPointers[rawType] = {
pointerType: pointerConverter,
constPointerType: constPointerConverter
};
replacePublicSymbol(legalFunctionName, constructor);
return [referenceConverter, pointerConverter, constPointerConverter]
})
};
function usesDestructorStack(argTypes) {
for (var i = 1; i < argTypes.length; ++i) {
if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
return true
}
}
return false
}
function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
var argCount = argTypes.length;
if (argCount < 2) {
throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")
}
var isClassMethodFunc = argTypes[1] !== null && classType !== null;
var needsDestructorStack = usesDestructorStack(argTypes);
var returns = !argTypes[0].isVoid;
var expectedArgCount = argCount - 2;
var argsWired = new Array(expectedArgCount);
var invokerFuncArgs = [];
var destructors = [];
var invokerFn = function(...args) {
destructors.length = 0;
var thisWired;
invokerFuncArgs.length = isClassMethodFunc ? 2 : 1;
invokerFuncArgs[0] = cppTargetFunc;
if (isClassMethodFunc) {
thisWired = argTypes[1].toWireType(destructors, this);
invokerFuncArgs[1] = thisWired
}
for (var i = 0; i < expectedArgCount; ++i) {
argsWired[i] = argTypes[i + 2].toWireType(destructors, args[i]);
invokerFuncArgs.push(argsWired[i])
}
var rv = cppInvokerFunc(...invokerFuncArgs);
function onDone(rv) {
if (needsDestructorStack) {
runDestructors(destructors)
} else {
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) {
var param = i === 1 ? thisWired : argsWired[i - 2];
if (argTypes[i].destructorFunction !== null) {
argTypes[i].destructorFunction(param)
}
}
}
if (returns) {
return argTypes[0].fromWireType(rv)
}
}
return onDone(rv)
};
return createNamedFunction(humanName, invokerFn)
}
var heap32VectorToArray = (count, firstElement) => {
var array = [];
for (var i = 0; i < count; i++) {
array.push(HEAPU32[firstElement + i * 4 >> 2])
}
return array
};
var getFunctionName = signature => {
signature = signature.trim();
const argsIndex = signature.indexOf("(");
if (argsIndex === -1)
return signature;
return signature.slice(0, argsIndex)
};
var __embind_register_class_class_function =
(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn, isAsync,
isNonnullReturn) => {
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
methodName = AsciiToString(methodName);
methodName = getFunctionName(methodName);
rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync);
whenDependentTypesAreResolved([], [rawClassType], classType => {
classType = classType[0];
var humanName = `${classType.name}.${methodName}`;
function unboundTypesHandler() {
throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes)
}
if (methodName.startsWith("@@")) {
methodName = Symbol[methodName.substring(2)]
}
var proto = classType.registeredClass.constructor;
if (undefined === proto[methodName]) {
unboundTypesHandler.argCount = argCount - 1;
proto[methodName] = unboundTypesHandler
} else {
ensureOverloadTable(proto, methodName, humanName);
proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler
}
whenDependentTypesAreResolved([], rawArgTypes, argTypes => {
var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn, isAsync);
if (undefined === proto[methodName].overloadTable) {
func.argCount = argCount - 1;
proto[methodName] = func
} else {
proto[methodName].overloadTable[argCount - 1] = func
}
if (classType.registeredClass.__derivedClasses) {
for (const derivedClass of classType.registeredClass.__derivedClasses) {
if (!derivedClass.constructor.hasOwnProperty(methodName)) {
derivedClass.constructor[methodName] = func
}
}
}
return []
});
return []
})
};
var __embind_register_class_constructor =
(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => {
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
invoker = embind__requireFunction(invokerSignature, invoker);
whenDependentTypesAreResolved([], [rawClassType], classType => {
classType = classType[0];
var humanName = `constructor ${classType.name}`;
if (undefined === classType.registeredClass.constructor_body) {
classType.registeredClass.constructor_body = []
}
if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${
argCount - 1}) for class '${
classType
.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)
}
classType.registeredClass.constructor_body[argCount - 1] = () => {
throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes)
};
whenDependentTypesAreResolved([], rawArgTypes, argTypes => {
argTypes.splice(1, 0, null);
classType.registeredClass.constructor_body[argCount - 1] =
craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
return []
});
return []
})
};
var __embind_register_class_function =
(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual,
isAsync, isNonnullReturn) => {
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
methodName = AsciiToString(methodName);
methodName = getFunctionName(methodName);
rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync);
whenDependentTypesAreResolved([], [rawClassType], classType => {
classType = classType[0];
var humanName = `${classType.name}.${methodName}`;
if (methodName.startsWith("@@")) {
methodName = Symbol[methodName.substring(2)]
}
if (isPureVirtual) {
classType.registeredClass.pureVirtualFunctions.push(methodName)
}
function unboundTypesHandler() {
throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes)
}
var proto = classType.registeredClass.instancePrototype;
var method = proto[methodName];
if (undefined === method || undefined === method.overloadTable && method.className !== classType.name &&
method.argCount === argCount - 2) {
unboundTypesHandler.argCount = argCount - 2;
unboundTypesHandler.className = classType.name;
proto[methodName] = unboundTypesHandler
} else {
ensureOverloadTable(proto, methodName, humanName);
proto[methodName].overloadTable[argCount - 2] = unboundTy