778 lines
24 KiB
JavaScript
778 lines
24 KiB
JavaScript
|
|
// Wasm glue
|
|
var Module = typeof Module != "undefined" ? Module : {};
|
|
var moduleOverrides = Object.assign({}, Module);
|
|
var arguments_ = [];
|
|
var thisProgram = "./this.program";
|
|
var quit_ = (status,toThrow)=>{
|
|
throw toThrow
|
|
}
|
|
;
|
|
var ENVIRONMENT_IS_WEB = typeof window == "object";
|
|
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
|
|
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
|
|
var scriptDirectory = "";
|
|
function locateFile(path) {
|
|
if (Module["locateFile"]) {
|
|
return Module["locateFile"](path, scriptDirectory)
|
|
}
|
|
return scriptDirectory + path
|
|
}
|
|
var read_, readAsync, readBinary, setWindowTitle;
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
var fs = require("fs");
|
|
var nodePath = require("path");
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
scriptDirectory = nodePath.dirname(scriptDirectory) + "/"
|
|
} else {
|
|
scriptDirectory = __dirname + "/"
|
|
}
|
|
read_ = (filename,binary)=>{
|
|
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
|
|
return fs.readFileSync(filename, binary ? undefined : "utf8")
|
|
}
|
|
;
|
|
readBinary = filename=>{
|
|
var ret = read_(filename, true);
|
|
if (!ret.buffer) {
|
|
ret = new Uint8Array(ret)
|
|
}
|
|
return ret
|
|
}
|
|
;
|
|
readAsync = (filename,onload,onerror)=>{
|
|
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
|
|
fs.readFile(filename, function(err, data) {
|
|
if (err)
|
|
onerror(err);
|
|
else
|
|
onload(data.buffer)
|
|
})
|
|
}
|
|
;
|
|
if (!Module["thisProgram"] && process.argv.length > 1) {
|
|
thisProgram = process.argv[1].replace(/\\/g, "/")
|
|
}
|
|
arguments_ = process.argv.slice(2);
|
|
if (typeof module != "undefined") {
|
|
module["exports"] = Module
|
|
}
|
|
process.on("uncaughtException", function(ex) {
|
|
if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
|
|
throw ex
|
|
}
|
|
});
|
|
var nodeMajor = process.versions.node.split(".")[0];
|
|
if (nodeMajor < 15) {
|
|
process.on("unhandledRejection", function(reason) {
|
|
throw reason
|
|
})
|
|
}
|
|
quit_ = (status,toThrow)=>{
|
|
process.exitCode = status;
|
|
throw toThrow
|
|
}
|
|
;
|
|
Module["inspect"] = function() {
|
|
return "[Emscripten Module object]"
|
|
}
|
|
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
scriptDirectory = self.location.href
|
|
} else if (typeof document != "undefined" && document.currentScript) {
|
|
scriptDirectory = document.currentScript.src
|
|
}
|
|
if (scriptDirectory.indexOf("blob:") !== 0) {
|
|
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
|
|
} else {
|
|
scriptDirectory = ""
|
|
}
|
|
{
|
|
read_ = url=>{
|
|
var xhr = new XMLHttpRequest;
|
|
xhr.open("GET", url, false);
|
|
xhr.send(null);
|
|
return xhr.responseText
|
|
}
|
|
;
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
readBinary = url=>{
|
|
var xhr = new XMLHttpRequest;
|
|
xhr.open("GET", url, false);
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.send(null);
|
|
return new Uint8Array(xhr.response)
|
|
}
|
|
}
|
|
readAsync = (url,onload,onerror)=>{
|
|
var xhr = new XMLHttpRequest;
|
|
xhr.open("GET", url, true);
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.onload = ()=>{
|
|
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
|
|
onload(xhr.response);
|
|
return
|
|
}
|
|
onerror()
|
|
}
|
|
;
|
|
xhr.onerror = onerror;
|
|
xhr.send(null)
|
|
}
|
|
}
|
|
setWindowTitle = title=>document.title = title
|
|
} else {}
|
|
var out = Module["print"] || console.log.bind(console);
|
|
var err = Module["printErr"] || console.warn.bind(console);
|
|
Object.assign(Module, moduleOverrides);
|
|
moduleOverrides = null;
|
|
if (Module["arguments"])
|
|
arguments_ = Module["arguments"];
|
|
if (Module["thisProgram"])
|
|
thisProgram = Module["thisProgram"];
|
|
if (Module["quit"])
|
|
quit_ = Module["quit"];
|
|
var wasmBinary;
|
|
if (Module["wasmBinary"])
|
|
wasmBinary = Module["wasmBinary"];
|
|
var noExitRuntime = Module["noExitRuntime"] || true;
|
|
if (typeof WebAssembly != "object") {
|
|
abort("no native wasm support detected")
|
|
}
|
|
var wasmMemory;
|
|
var ABORT = false;
|
|
var EXITSTATUS;
|
|
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
|
|
function updateMemoryViews() {
|
|
var b = wasmMemory.buffer;
|
|
Module["HEAP8"] = HEAP8 = new Int8Array(b);
|
|
Module["HEAP16"] = HEAP16 = new Int16Array(b);
|
|
Module["HEAP32"] = HEAP32 = new Int32Array(b);
|
|
Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
|
|
Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
|
|
Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
|
|
Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
|
|
Module["HEAPF64"] = HEAPF64 = new Float64Array(b)
|
|
}
|
|
var wasmTable;
|
|
var __ATPRERUN__ = [];
|
|
var __ATINIT__ = [];
|
|
var __ATPOSTRUN__ = [];
|
|
var runtimeInitialized = false;
|
|
function preRun() {
|
|
if (Module["preRun"]) {
|
|
if (typeof Module["preRun"] == "function")
|
|
Module["preRun"] = [Module["preRun"]];
|
|
while (Module["preRun"].length) {
|
|
addOnPreRun(Module["preRun"].shift())
|
|
}
|
|
}
|
|
callRuntimeCallbacks(__ATPRERUN__)
|
|
}
|
|
function initRuntime() {
|
|
runtimeInitialized = true;
|
|
callRuntimeCallbacks(__ATINIT__)
|
|
}
|
|
function postRun() {
|
|
if (Module["postRun"]) {
|
|
if (typeof Module["postRun"] == "function")
|
|
Module["postRun"] = [Module["postRun"]];
|
|
while (Module["postRun"].length) {
|
|
addOnPostRun(Module["postRun"].shift())
|
|
}
|
|
}
|
|
callRuntimeCallbacks(__ATPOSTRUN__)
|
|
}
|
|
function addOnPreRun(cb) {
|
|
__ATPRERUN__.unshift(cb)
|
|
}
|
|
function addOnInit(cb) {
|
|
__ATINIT__.unshift(cb)
|
|
}
|
|
function addOnPostRun(cb) {
|
|
__ATPOSTRUN__.unshift(cb)
|
|
}
|
|
var runDependencies = 0;
|
|
var runDependencyWatcher = null;
|
|
var dependenciesFulfilled = null;
|
|
function addRunDependency(id) {
|
|
runDependencies++;
|
|
if (Module["monitorRunDependencies"]) {
|
|
Module["monitorRunDependencies"](runDependencies)
|
|
}
|
|
}
|
|
function removeRunDependency(id) {
|
|
runDependencies--;
|
|
if (Module["monitorRunDependencies"]) {
|
|
Module["monitorRunDependencies"](runDependencies)
|
|
}
|
|
if (runDependencies == 0) {
|
|
if (runDependencyWatcher !== null) {
|
|
clearInterval(runDependencyWatcher);
|
|
runDependencyWatcher = null
|
|
}
|
|
if (dependenciesFulfilled) {
|
|
var callback = dependenciesFulfilled;
|
|
dependenciesFulfilled = null;
|
|
callback()
|
|
}
|
|
}
|
|
}
|
|
function abort(what) {
|
|
if (Module["onAbort"]) {
|
|
Module["onAbort"](what)
|
|
}
|
|
what = "Aborted(" + what + ")";
|
|
err(what);
|
|
ABORT = true;
|
|
EXITSTATUS = 1;
|
|
what += ". Build with -sASSERTIONS for more info.";
|
|
var e = new WebAssembly.RuntimeError(what);
|
|
throw e
|
|
}
|
|
var dataURIPrefix = "data:application/octet-stream;base64,";
|
|
function isDataURI(filename) {
|
|
return filename.startsWith(dataURIPrefix)
|
|
}
|
|
function isFileURI(filename) {
|
|
return filename.startsWith("file://")
|
|
}
|
|
var wasmBinaryFile;
|
|
wasmBinaryFile = "graph-wasm.wasm";
|
|
if (!isDataURI(wasmBinaryFile)) {
|
|
wasmBinaryFile = locateFile(wasmBinaryFile)
|
|
}
|
|
function getBinary(file) {
|
|
try {
|
|
if (file == wasmBinaryFile && wasmBinary) {
|
|
return new Uint8Array(wasmBinary)
|
|
}
|
|
if (readBinary) {
|
|
return readBinary(file)
|
|
}
|
|
throw "both async and sync fetching of the wasm failed"
|
|
} catch (err) {
|
|
abort(err)
|
|
}
|
|
}
|
|
function getBinaryPromise(binaryFile) {
|
|
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
|
|
if (typeof fetch == "function" && !isFileURI(binaryFile)) {
|
|
return fetch(binaryFile, {
|
|
credentials: "same-origin"
|
|
}).then(function(response) {
|
|
if (!response["ok"]) {
|
|
throw "failed to load wasm binary file at '" + binaryFile + "'"
|
|
}
|
|
return response["arrayBuffer"]()
|
|
}).catch(function() {
|
|
return getBinary(binaryFile)
|
|
})
|
|
} else {
|
|
if (readAsync) {
|
|
return new Promise(function(resolve, reject) {
|
|
readAsync(binaryFile, function(response) {
|
|
resolve(new Uint8Array(response))
|
|
}, reject)
|
|
}
|
|
)
|
|
}
|
|
}
|
|
}
|
|
return Promise.resolve().then(function() {
|
|
return getBinary(binaryFile)
|
|
})
|
|
}
|
|
function instantiateArrayBuffer(binaryFile, imports, receiver) {
|
|
return getBinaryPromise(binaryFile).then(function(binary) {
|
|
return WebAssembly.instantiate(binary, imports)
|
|
}).then(function(instance) {
|
|
return instance
|
|
}).then(receiver, function(reason) {
|
|
err("failed to asynchronously prepare wasm: " + reason);
|
|
abort(reason)
|
|
})
|
|
}
|
|
function instantiateAsync(binary, binaryFile, imports, callback) {
|
|
if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
|
|
return fetch(binaryFile, {
|
|
credentials: "same-origin"
|
|
}).then(function(response)
|
|
{
|
|
let responseClone = new Response(response.body, { headers: new Headers({"Content-Type": "application/wasm"}) });
|
|
var result = WebAssembly.instantiateStreaming(responseClone, imports);
|
|
return result.then(callback, function(reason) {
|
|
err("wasm streaming compile failed: " + reason);
|
|
err("falling back to ArrayBuffer instantiation");
|
|
return instantiateArrayBuffer(binaryFile, imports, callback)
|
|
})
|
|
})
|
|
} else {
|
|
return instantiateArrayBuffer(binaryFile, imports, callback)
|
|
}
|
|
}
|
|
function createWasm() {
|
|
var info = {
|
|
"a": wasmImports
|
|
};
|
|
function receiveInstance(instance, module) {
|
|
var exports = instance.exports;
|
|
Module["asm"] = exports;
|
|
wasmMemory = Module["asm"]["f"];
|
|
updateMemoryViews();
|
|
wasmTable = Module["asm"]["r"];
|
|
addOnInit(Module["asm"]["g"]);
|
|
removeRunDependency("wasm-instantiate");
|
|
return exports
|
|
}
|
|
addRunDependency("wasm-instantiate");
|
|
function receiveInstantiationResult(result) {
|
|
receiveInstance(result["instance"])
|
|
}
|
|
if (Module["instantiateWasm"]) {
|
|
try {
|
|
return Module["instantiateWasm"](info, receiveInstance)
|
|
} catch (e) {
|
|
err("Module.instantiateWasm callback failed with error: " + e);
|
|
return false
|
|
}
|
|
}
|
|
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
|
|
return {}
|
|
}
|
|
var tempDouble;
|
|
var tempI64;
|
|
var ASM_CONSTS = {
|
|
2304: $0=>{
|
|
console.log(UTF8ToString($0))
|
|
}
|
|
};
|
|
function ExitStatus(status) {
|
|
this.name = "ExitStatus";
|
|
this.message = "Program terminated with exit(" + status + ")";
|
|
this.status = status
|
|
}
|
|
function callRuntimeCallbacks(callbacks) {
|
|
while (callbacks.length > 0) {
|
|
callbacks.shift()(Module)
|
|
}
|
|
}
|
|
function getValue(ptr, type="i8") {
|
|
if (type.endsWith("*"))
|
|
type = "*";
|
|
switch (type) {
|
|
case "i1":
|
|
return HEAP8[ptr >> 0];
|
|
case "i8":
|
|
return HEAP8[ptr >> 0];
|
|
case "i16":
|
|
return HEAP16[ptr >> 1];
|
|
case "i32":
|
|
return HEAP32[ptr >> 2];
|
|
case "i64":
|
|
return HEAP32[ptr >> 2];
|
|
case "float":
|
|
return HEAPF32[ptr >> 2];
|
|
case "double":
|
|
return HEAPF64[ptr >> 3];
|
|
case "*":
|
|
return HEAPU32[ptr >> 2];
|
|
default:
|
|
abort("invalid type for getValue: " + type)
|
|
}
|
|
}
|
|
function setValue(ptr, value, type="i8") {
|
|
if (type.endsWith("*"))
|
|
type = "*";
|
|
switch (type) {
|
|
case "i1":
|
|
HEAP8[ptr >> 0] = value;
|
|
break;
|
|
case "i8":
|
|
HEAP8[ptr >> 0] = value;
|
|
break;
|
|
case "i16":
|
|
HEAP16[ptr >> 1] = value;
|
|
break;
|
|
case "i32":
|
|
HEAP32[ptr >> 2] = value;
|
|
break;
|
|
case "i64":
|
|
tempI64 = [value >>> 0, (tempDouble = value,
|
|
+Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)],
|
|
HEAP32[ptr >> 2] = tempI64[0],
|
|
HEAP32[ptr + 4 >> 2] = tempI64[1];
|
|
break;
|
|
case "float":
|
|
HEAPF32[ptr >> 2] = value;
|
|
break;
|
|
case "double":
|
|
HEAPF64[ptr >> 3] = value;
|
|
break;
|
|
case "*":
|
|
HEAPU32[ptr >> 2] = value;
|
|
break;
|
|
default:
|
|
abort("invalid type for setValue: " + type)
|
|
}
|
|
}
|
|
function _abort() {
|
|
abort("")
|
|
}
|
|
var readEmAsmArgsArray = [];
|
|
function readEmAsmArgs(sigPtr, buf) {
|
|
readEmAsmArgsArray.length = 0;
|
|
var ch;
|
|
buf >>= 2;
|
|
while (ch = HEAPU8[sigPtr++]) {
|
|
buf += ch != 105 & buf;
|
|
readEmAsmArgsArray.push(ch == 105 ? HEAP32[buf] : HEAPF64[buf++ >> 1]);
|
|
++buf
|
|
}
|
|
return readEmAsmArgsArray
|
|
}
|
|
function runEmAsmFunction(code, sigPtr, argbuf) {
|
|
var args = readEmAsmArgs(sigPtr, argbuf);
|
|
return ASM_CONSTS[code].apply(null, args)
|
|
}
|
|
function _emscripten_asm_const_int(code, sigPtr, argbuf) {
|
|
return runEmAsmFunction(code, sigPtr, argbuf)
|
|
}
|
|
function _emscripten_date_now() {
|
|
return Date.now()
|
|
}
|
|
function _emscripten_memcpy_big(dest, src, num) {
|
|
HEAPU8.copyWithin(dest, src, src + num)
|
|
}
|
|
function getHeapMax() {
|
|
return 2147483648
|
|
}
|
|
function emscripten_realloc_buffer(size) {
|
|
var b = wasmMemory.buffer;
|
|
try {
|
|
wasmMemory.grow(size - b.byteLength + 65535 >>> 16);
|
|
updateMemoryViews();
|
|
return 1
|
|
} catch (e) {}
|
|
}
|
|
function _emscripten_resize_heap(requestedSize) {
|
|
var oldSize = HEAPU8.length;
|
|
requestedSize = requestedSize >>> 0;
|
|
var maxHeapSize = getHeapMax();
|
|
if (requestedSize > maxHeapSize) {
|
|
return false
|
|
}
|
|
let alignUp = (x,multiple)=>x + (multiple - x % multiple) % multiple;
|
|
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
|
|
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
|
|
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
|
|
var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
|
|
var replacement = emscripten_realloc_buffer(newSize);
|
|
if (replacement) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
function getCFunc(ident) {
|
|
var func = Module["_" + ident];
|
|
return func
|
|
}
|
|
function writeArrayToMemory(array, buffer) {
|
|
HEAP8.set(array, buffer)
|
|
}
|
|
function lengthBytesUTF8(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
var c = str.charCodeAt(i);
|
|
if (c <= 127) {
|
|
len++
|
|
} else if (c <= 2047) {
|
|
len += 2
|
|
} else if (c >= 55296 && c <= 57343) {
|
|
len += 4;
|
|
++i
|
|
} else {
|
|
len += 3
|
|
}
|
|
}
|
|
return len
|
|
}
|
|
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
|
|
if (!(maxBytesToWrite > 0))
|
|
return 0;
|
|
var startIdx = outIdx;
|
|
var endIdx = outIdx + maxBytesToWrite - 1;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
var u = str.charCodeAt(i);
|
|
if (u >= 55296 && u <= 57343) {
|
|
var u1 = str.charCodeAt(++i);
|
|
u = 65536 + ((u & 1023) << 10) | u1 & 1023
|
|
}
|
|
if (u <= 127) {
|
|
if (outIdx >= endIdx)
|
|
break;
|
|
heap[outIdx++] = u
|
|
} else if (u <= 2047) {
|
|
if (outIdx + 1 >= endIdx)
|
|
break;
|
|
heap[outIdx++] = 192 | u >> 6;
|
|
heap[outIdx++] = 128 | u & 63
|
|
} else if (u <= 65535) {
|
|
if (outIdx + 2 >= endIdx)
|
|
break;
|
|
heap[outIdx++] = 224 | u >> 12;
|
|
heap[outIdx++] = 128 | u >> 6 & 63;
|
|
heap[outIdx++] = 128 | u & 63
|
|
} else {
|
|
if (outIdx + 3 >= endIdx)
|
|
break;
|
|
heap[outIdx++] = 240 | u >> 18;
|
|
heap[outIdx++] = 128 | u >> 12 & 63;
|
|
heap[outIdx++] = 128 | u >> 6 & 63;
|
|
heap[outIdx++] = 128 | u & 63
|
|
}
|
|
}
|
|
heap[outIdx] = 0;
|
|
return outIdx - startIdx
|
|
}
|
|
function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
|
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
|
|
}
|
|
function stringToUTF8OnStack(str) {
|
|
var size = lengthBytesUTF8(str) + 1;
|
|
var ret = stackAlloc(size);
|
|
stringToUTF8(str, ret, size);
|
|
return ret
|
|
}
|
|
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
|
|
function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
|
|
var endIdx = idx + maxBytesToRead;
|
|
var endPtr = idx;
|
|
while (heapOrArray[endPtr] && !(endPtr >= endIdx))
|
|
++endPtr;
|
|
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
|
|
}
|
|
function UTF8ToString(ptr, maxBytesToRead) {
|
|
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
|
|
}
|
|
function ccall(ident, returnType, argTypes, args, opts) {
|
|
var toC = {
|
|
"string": str=>{
|
|
var ret = 0;
|
|
if (str !== null && str !== undefined && str !== 0) {
|
|
ret = stringToUTF8OnStack(str)
|
|
}
|
|
return ret
|
|
}
|
|
,
|
|
"array": arr=>{
|
|
var ret = stackAlloc(arr.length);
|
|
writeArrayToMemory(arr, ret);
|
|
return ret
|
|
}
|
|
};
|
|
function convertReturnValue(ret) {
|
|
if (returnType === "string") {
|
|
return UTF8ToString(ret)
|
|
}
|
|
if (returnType === "boolean")
|
|
return Boolean(ret);
|
|
return ret
|
|
}
|
|
var func = getCFunc(ident);
|
|
var cArgs = [];
|
|
var stack = 0;
|
|
if (args) {
|
|
for (var i = 0; i < args.length; i++) {
|
|
var converter = toC[argTypes[i]];
|
|
if (converter) {
|
|
if (stack === 0)
|
|
stack = stackSave();
|
|
cArgs[i] = converter(args[i])
|
|
} else {
|
|
cArgs[i] = args[i]
|
|
}
|
|
}
|
|
}
|
|
var ret = func.apply(null, cArgs);
|
|
function onDone(ret) {
|
|
if (stack !== 0)
|
|
stackRestore(stack);
|
|
return convertReturnValue(ret)
|
|
}
|
|
ret = onDone(ret);
|
|
return ret
|
|
}
|
|
function cwrap(ident, returnType, argTypes, opts) {
|
|
var numericArgs = !argTypes || argTypes.every(type=>type === "number" || type === "boolean");
|
|
var numericRet = returnType !== "string";
|
|
if (numericRet && numericArgs && !opts) {
|
|
return getCFunc(ident)
|
|
}
|
|
return function() {
|
|
return ccall(ident, returnType, argTypes, arguments, opts)
|
|
}
|
|
}
|
|
var wasmImports = {
|
|
"b": _abort,
|
|
"e": _emscripten_asm_const_int,
|
|
"d": _emscripten_date_now,
|
|
"c": _emscripten_memcpy_big,
|
|
"a": _emscripten_resize_heap
|
|
};
|
|
var asm = createWasm();
|
|
var ___wasm_call_ctors = function() {
|
|
return (___wasm_call_ctors = Module["asm"]["g"]).apply(null, arguments)
|
|
};
|
|
var _SetBatchFractionSize = Module["_SetBatchFractionSize"] = function() {
|
|
return (_SetBatchFractionSize = Module["_SetBatchFractionSize"] = Module["asm"]["h"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetAttractionForce = Module["_SetAttractionForce"] = function() {
|
|
return (_SetAttractionForce = Module["_SetAttractionForce"] = Module["asm"]["i"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetLinkLength = Module["_SetLinkLength"] = function() {
|
|
return (_SetLinkLength = Module["_SetLinkLength"] = Module["asm"]["j"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetRepulsionForce = Module["_SetRepulsionForce"] = function() {
|
|
return (_SetRepulsionForce = Module["_SetRepulsionForce"] = Module["asm"]["k"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetCentralForce = Module["_SetCentralForce"] = function() {
|
|
return (_SetCentralForce = Module["_SetCentralForce"] = Module["asm"]["l"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetDt = Module["_SetDt"] = function() {
|
|
return (_SetDt = Module["_SetDt"] = Module["asm"]["m"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _Init = Module["_Init"] = function() {
|
|
return (_Init = Module["_Init"] = Module["asm"]["n"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _Update = Module["_Update"] = function() {
|
|
return (_Update = Module["_Update"] = Module["asm"]["o"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _SetPosition = Module["_SetPosition"] = function() {
|
|
return (_SetPosition = Module["_SetPosition"] = Module["asm"]["p"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _FreeMemory = Module["_FreeMemory"] = function() {
|
|
return (_FreeMemory = Module["_FreeMemory"] = Module["asm"]["q"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var ___errno_location = function() {
|
|
return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments)
|
|
};
|
|
var _malloc = Module["_malloc"] = function() {
|
|
return (_malloc = Module["_malloc"] = Module["asm"]["s"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var _free = Module["_free"] = function() {
|
|
return (_free = Module["_free"] = Module["asm"]["t"]).apply(null, arguments)
|
|
}
|
|
;
|
|
var stackSave = function() {
|
|
return (stackSave = Module["asm"]["u"]).apply(null, arguments)
|
|
};
|
|
var stackRestore = function() {
|
|
return (stackRestore = Module["asm"]["v"]).apply(null, arguments)
|
|
};
|
|
var stackAlloc = function() {
|
|
return (stackAlloc = Module["asm"]["w"]).apply(null, arguments)
|
|
};
|
|
var ___cxa_is_pointer_type = function() {
|
|
return (___cxa_is_pointer_type = Module["asm"]["__cxa_is_pointer_type"]).apply(null, arguments)
|
|
};
|
|
Module["cwrap"] = cwrap;
|
|
Module["setValue"] = setValue;
|
|
Module["getValue"] = getValue;
|
|
var calledRun;
|
|
dependenciesFulfilled = function runCaller() {
|
|
if (!calledRun)
|
|
run();
|
|
if (!calledRun)
|
|
dependenciesFulfilled = runCaller
|
|
}
|
|
;
|
|
function run() {
|
|
if (runDependencies > 0) {
|
|
return
|
|
}
|
|
preRun();
|
|
if (runDependencies > 0) {
|
|
return
|
|
}
|
|
function doRun() {
|
|
if (calledRun)
|
|
return;
|
|
calledRun = true;
|
|
Module["calledRun"] = true;
|
|
if (ABORT)
|
|
return;
|
|
initRuntime();
|
|
if (Module["onRuntimeInitialized"])
|
|
Module["onRuntimeInitialized"]();
|
|
postRun()
|
|
}
|
|
if (Module["setStatus"]) {
|
|
Module["setStatus"]("Running...");
|
|
setTimeout(function() {
|
|
setTimeout(function() {
|
|
Module["setStatus"]("")
|
|
}, 1);
|
|
doRun()
|
|
}, 1)
|
|
} else {
|
|
doRun()
|
|
}
|
|
}
|
|
if (Module["preInit"]) {
|
|
if (typeof Module["preInit"] == "function")
|
|
Module["preInit"] = [Module["preInit"]];
|
|
while (Module["preInit"].length > 0) {
|
|
Module["preInit"].pop()()
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
run();
|
|
}
|
|
catch(e)
|
|
{
|
|
console.error(e);
|
|
}
|