Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-05-25 04:55:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
cyclone/terminal/terminal.js
Justin Ethier a0248c8b24 Initial files
2021-04-21 20:03:02 -07:00

6792 lines
207 KiB
JavaScript
Raw Blame History

var Module = typeof Module !== "undefined" ? Module : {};
var moduleOverrides = {};
var key;
for (key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = function(status, toThrow) {
throw toThrow;
};
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
ENVIRONMENT_IS_WEB = typeof window === "object";
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string";
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
if (Module["ENVIRONMENT"]) {
throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)");
}
var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
if (ENVIRONMENT_IS_PTHREAD) {
buffer = Module["buffer"];
}
var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : undefined;
if (ENVIRONMENT_IS_WORKER) {
_scriptDir = self.location.href;
} else if (ENVIRONMENT_IS_NODE) {
_scriptDir = __filename;
}
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
var nodeFS;
var nodePath;
if (ENVIRONMENT_IS_NODE) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = require("path").dirname(scriptDirectory) + "/";
} else {
scriptDirectory = __dirname + "/";
}
read_ = function shell_read(filename, binary) {
if (!nodeFS) nodeFS = require("fs");
if (!nodePath) nodePath = require("path");
filename = nodePath["normalize"](filename);
return nodeFS["readFileSync"](filename, binary ? null : "utf8");
};
readBinary = function readBinary(filename) {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
if (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 instanceof ExitStatus)) {
throw ex;
}
});
process["on"]("unhandledRejection", abort);
quit_ = function(status) {
process["exit"](status);
};
Module["inspect"] = function() {
return "[Emscripten Module object]";
};
var nodeWorkerThreads;
try {
nodeWorkerThreads = require("worker_threads");
} catch (e) {
console.error('The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?');
throw e;
}
global.Worker = nodeWorkerThreads.Worker;
} else if (ENVIRONMENT_IS_SHELL) {
if (typeof read != "undefined") {
read_ = function shell_read(f) {
return read(f);
};
}
readBinary = function readBinary(f) {
var data;
if (typeof readbuffer === "function") {
return new Uint8Array(readbuffer(f));
}
data = read(f, "binary");
assert(typeof data === "object");
return data;
};
if (typeof scriptArgs != "undefined") {
arguments_ = scriptArgs;
} else if (typeof arguments != "undefined") {
arguments_ = arguments;
}
if (typeof quit === "function") {
quit_ = function(status) {
quit(status);
};
}
if (typeof print !== "undefined") {
if (typeof console === "undefined") console = {};
console.log = print;
console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
}
} 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.lastIndexOf("/") + 1);
} else {
scriptDirectory = "";
}
if (ENVIRONMENT_IS_NODE) {
read_ = function shell_read(filename, binary) {
if (!nodeFS) nodeFS = require("fs");
if (!nodePath) nodePath = require("path");
filename = nodePath["normalize"](filename);
return nodeFS["readFileSync"](filename, binary ? null : "utf8");
};
readBinary = function readBinary(filename) {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
} else {
read_ = function shell_read(url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = function readBinary(url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = function readAsync(url, onload, onerror) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = function xhr_onload() {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
setWindowTitle = function(title) {
document.title = title;
};
} else {
throw new Error("environment detection error");
}
if (ENVIRONMENT_IS_NODE) {
if (typeof performance === "undefined") {
global.performance = require("perf_hooks").performance;
}
}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);
for (key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
moduleOverrides = null;
if (Module["arguments"]) arguments_ = Module["arguments"];
if (!Object.getOwnPropertyDescriptor(Module, "arguments")) Object.defineProperty(Module, "arguments", {
configurable: true,
get: function() {
abort("Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (!Object.getOwnPropertyDescriptor(Module, "thisProgram")) Object.defineProperty(Module, "thisProgram", {
configurable: true,
get: function() {
abort("Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (Module["quit"]) quit_ = Module["quit"];
if (!Object.getOwnPropertyDescriptor(Module, "quit")) Object.defineProperty(Module, "quit", {
configurable: true,
get: function() {
abort("Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
assert(typeof Module["memoryInitializerPrefixURL"] === "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["pthreadMainPrefixURL"] === "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["cdInitializerPrefixURL"] === "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["filePackagePrefixURL"] === "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
assert(typeof Module["read"] === "undefined", "Module.read option was removed (modify read_ in JS)");
assert(typeof Module["readAsync"] === "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
assert(typeof Module["readBinary"] === "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
assert(typeof Module["setWindowTitle"] === "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)");
assert(typeof Module["TOTAL_MEMORY"] === "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
if (!Object.getOwnPropertyDescriptor(Module, "read")) Object.defineProperty(Module, "read", {
configurable: true,
get: function() {
abort("Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) Object.defineProperty(Module, "readAsync", {
configurable: true,
get: function() {
abort("Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) Object.defineProperty(Module, "readBinary", {
configurable: true,
get: function() {
abort("Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) Object.defineProperty(Module, "setWindowTitle", {
configurable: true,
get: function() {
abort("Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)");
var STACK_ALIGN = 16;
function alignMemory(size, factor) {
if (!factor) factor = STACK_ALIGN;
return Math.ceil(size / factor) * factor;
}
function getNativeTypeSize(type) {
switch (type) {
case "i1":
case "i8":
return 1;
case "i16":
return 2;
case "i32":
return 4;
case "i64":
return 8;
case "float":
return 4;
case "double":
return 8;
default:
{
if (type[type.length - 1] === "*") {
return 4;
} else if (type[0] === "i") {
var bits = Number(type.substr(1));
assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type);
return bits / 8;
} else {
return 0;
}
}
}
}
function warnOnce(text) {
if (!warnOnce.shown) warnOnce.shown = {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
err(text);
}
}
function convertJsFunctionToWasm(func, sig) {
if (typeof WebAssembly.Function === "function") {
var typeNames = {
"i": "i32",
"j": "i64",
"f": "f32",
"d": "f64"
};
var type = {
parameters: [],
results: sig[0] == "v" ? [] : [ typeNames[sig[0]] ]
};
for (var i = 1; i < sig.length; ++i) {
type.parameters.push(typeNames[sig[i]]);
}
return new WebAssembly.Function(type, func);
}
var typeSection = [ 1, 0, 1, 96 ];
var sigRet = sig.slice(0, 1);
var sigParam = sig.slice(1);
var typeCodes = {
"i": 127,
"j": 126,
"f": 125,
"d": 124
};
typeSection.push(sigParam.length);
for (var i = 0; i < sigParam.length; ++i) {
typeSection.push(typeCodes[sigParam[i]]);
}
if (sigRet == "v") {
typeSection.push(0);
} else {
typeSection = typeSection.concat([ 1, typeCodes[sigRet] ]);
}
typeSection[1] = typeSection.length - 2;
var bytes = new Uint8Array([ 0, 97, 115, 109, 1, 0, 0, 0 ].concat(typeSection, [ 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0 ]));
var module = new WebAssembly.Module(bytes);
var instance = new WebAssembly.Instance(module, {
"e": {
"f": func
}
});
var wrappedFunc = instance.exports["f"];
return wrappedFunc;
}
var freeTableIndexes = [];
var functionsInTableMap;
function getEmptyTableSlot() {
if (freeTableIndexes.length) {
return freeTableIndexes.pop();
}
try {
wasmTable.grow(1);
} catch (err) {
if (!(err instanceof RangeError)) {
throw err;
}
throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
}
return wasmTable.length - 1;
}
function addFunctionWasm(func, sig) {
if (!functionsInTableMap) {
functionsInTableMap = new WeakMap();
for (var i = 0; i < wasmTable.length; i++) {
var item = wasmTable.get(i);
if (item) {
functionsInTableMap.set(item, i);
}
}
}
if (functionsInTableMap.has(func)) {
return functionsInTableMap.get(func);
}
for (var i = 0; i < wasmTable.length; i++) {
assert(wasmTable.get(i) != func, "function in Table but not functionsInTableMap");
}
var ret = getEmptyTableSlot();
try {
wasmTable.set(ret, func);
} catch (err) {
if (!(err instanceof TypeError)) {
throw err;
}
assert(typeof sig !== "undefined", "Missing signature argument to addFunction: " + func);
var wrapped = convertJsFunctionToWasm(func, sig);
wasmTable.set(ret, wrapped);
}
functionsInTableMap.set(func, ret);
return ret;
}
function removeFunction(index) {
functionsInTableMap.delete(wasmTable.get(index));
freeTableIndexes.push(index);
}
function addFunction(func, sig) {
assert(typeof func !== "undefined");
if (typeof sig === "undefined") {
err("warning: addFunction(): You should provide a wasm function signature string as a second argument. This is not necessary for asm.js and asm2wasm, but can be required for the LLVM wasm backend, so it is recommended for full portability.");
}
return addFunctionWasm(func, sig);
}
function makeBigInt(low, high, unsigned) {
return unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
}
var tempRet0 = 0;
var setTempRet0 = function(value) {
tempRet0 = value;
};
var getTempRet0 = function() {
return tempRet0;
};
function getCompilerSetting(name) {
throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work";
}
var Atomics_load = Atomics.load;
var Atomics_store = Atomics.store;
var Atomics_compareExchange = Atomics.compareExchange;
var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
if (!Object.getOwnPropertyDescriptor(Module, "wasmBinary")) Object.defineProperty(Module, "wasmBinary", {
configurable: true,
get: function() {
abort("Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
var noExitRuntime;
if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
if (!Object.getOwnPropertyDescriptor(Module, "noExitRuntime")) Object.defineProperty(Module, "noExitRuntime", {
configurable: true,
get: function() {
abort("Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
if (typeof WebAssembly !== "object") {
abort("no native wasm support detected");
}
function setValue(ptr, value, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
if (noSafe) {
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;
default:
abort("invalid type for setValue: " + type);
}
} else {
switch (type) {
case "i1":
SAFE_HEAP_STORE(ptr | 0, value | 0, 1);
break;
case "i8":
SAFE_HEAP_STORE(ptr | 0, value | 0, 1);
break;
case "i16":
SAFE_HEAP_STORE(ptr | 0, value | 0, 2);
break;
case "i32":
SAFE_HEAP_STORE(ptr | 0, value | 0, 4);
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) ],
SAFE_HEAP_STORE(ptr | 0, tempI64[0] | 0, 4), SAFE_HEAP_STORE(ptr + 4 | 0, tempI64[1] | 0, 4);
break;
case "float":
SAFE_HEAP_STORE_D(ptr | 0, Math.fround(value), 4);
break;
case "double":
SAFE_HEAP_STORE_D(ptr | 0, +value, 8);
break;
default:
abort("invalid type for setValue: " + type);
}
}
}
function getValue(ptr, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
if (noSafe) {
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];
default:
abort("invalid type for getValue: " + type);
}
} else {
switch (type) {
case "i1":
return SAFE_HEAP_LOAD(ptr | 0, 1, 0) | 0;
case "i8":
return SAFE_HEAP_LOAD(ptr | 0, 1, 0) | 0;
case "i16":
return SAFE_HEAP_LOAD(ptr | 0, 2, 0) | 0;
case "i32":
return SAFE_HEAP_LOAD(ptr | 0, 4, 0) | 0;
case "i64":
return SAFE_HEAP_LOAD(ptr | 0, 8, 0) | 0;
case "float":
return Math.fround(SAFE_HEAP_LOAD_D(ptr | 0, 4, 0));
case "double":
return +SAFE_HEAP_LOAD_D(ptr | 0, 8, 0);
default:
abort("invalid type for getValue: " + type);
}
}
return null;
}
function getSafeHeapType(bytes, isFloat) {
switch (bytes) {
case 1:
return "i8";
case 2:
return "i16";
case 4:
return isFloat ? "float" : "i32";
case 8:
return "double";
default:
assert(0);
}
}
function SAFE_HEAP_STORE(dest, value, bytes, isFloat) {
if (dest <= 0) abort("segmentation fault storing " + bytes + " bytes to address " + dest);
if (dest % bytes !== 0) abort("alignment error storing to address " + dest + ", which was expected to be aligned to a multiple of " + bytes);
if (runtimeInitialized) {
var brk = _sbrk() >>> 0;
if (dest + bytes > brk) abort("segmentation fault, exceeded the top of the available dynamic heap when storing " + bytes + " bytes to address " + dest + ". DYNAMICTOP=" + brk);
assert(brk >= _emscripten_stack_get_base());
assert(brk <= HEAP8.length);
}
setValue(dest, value, getSafeHeapType(bytes, isFloat), 1);
return value;
}
function SAFE_HEAP_STORE_D(dest, value, bytes) {
return SAFE_HEAP_STORE(dest, value, bytes, true);
}
function SAFE_HEAP_LOAD(dest, bytes, unsigned, isFloat) {
if (dest <= 0) abort("segmentation fault loading " + bytes + " bytes from address " + dest);
if (dest % bytes !== 0) abort("alignment error loading from address " + dest + ", which was expected to be aligned to a multiple of " + bytes);
if (runtimeInitialized) {
var brk = _sbrk() >>> 0;
if (dest + bytes > brk) abort("segmentation fault, exceeded the top of the available dynamic heap when loading " + bytes + " bytes from address " + dest + ". DYNAMICTOP=" + brk);
assert(brk >= _emscripten_stack_get_base());
assert(brk <= HEAP8.length);
}
var type = getSafeHeapType(bytes, isFloat);
var ret = getValue(dest, type, 1);
if (unsigned) ret = unSign(ret, parseInt(type.substr(1), 10));
return ret;
}
function SAFE_HEAP_LOAD_D(dest, bytes, unsigned) {
return SAFE_HEAP_LOAD(dest, bytes, unsigned, true);
}
function SAFE_FT_MASK(value, mask) {
var ret = value & mask;
if (ret !== value) {
abort("Function table mask error: function pointer is " + value + " which is masked by " + mask + ", the likely cause of this is that the function pointer is being called by the wrong type.");
}
return ret;
}
function segfault() {
abort("segmentation fault");
}
function alignfault() {
abort("alignment fault");
}
function ftfault() {
abort("Function table mask error");
}
var wasmMemory;
var wasmModule;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text);
}
}
function getCFunc(ident) {
var func = Module["_" + ident];
assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
return func;
}
function ccall(ident, returnType, argTypes, args, opts) {
var toC = {
"string": function(str) {
var ret = 0;
if (str !== null && str !== undefined && str !== 0) {
var len = (str.length << 2) + 1;
ret = stackAlloc(len);
stringToUTF8(str, ret, len);
}
return ret;
},
"array": function(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;
assert(returnType !== "array", 'Return type should not be "array".');
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);
ret = convertReturnValue(ret);
if (stack !== 0) stackRestore(stack);
return ret;
}
function cwrap(ident, returnType, argTypes, opts) {
return function() {
return ccall(ident, returnType, argTypes, arguments, opts);
};
}
var ALLOC_NORMAL = 0;
var ALLOC_STACK = 1;
function allocate(slab, allocator) {
var ret;
assert(typeof allocator === "number", "allocate no longer takes a type argument");
assert(typeof slab !== "number", "allocate no longer takes a number as arg0");
if (allocator == ALLOC_STACK) {
ret = stackAlloc(slab.length);
} else {
ret = _malloc(slab.length);
}
if (slab.subarray || slab.slice) {
HEAPU8.set(slab, ret);
} else {
HEAPU8.set(new Uint8Array(slab), ret);
}
return ret;
}
function UTF8ArrayToString(heap, idx, maxBytesToRead) {
var endIdx = idx + maxBytesToRead;
var str = "";
while (!(idx >= endIdx)) {
var u0 = heap[idx++];
if (!u0) return str;
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heap[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
var u2 = heap[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
} else {
if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte 0x" + u0.toString(16) + " encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!");
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[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 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;
if (u >= 2097152) warnOnce("Invalid Unicode code point 0x" + u.toString(16) + " encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF).");
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) {
assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
function lengthBytesUTF8(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4;
}
return len;
}
function AsciiToString(ptr) {
var str = "";
while (1) {
var ch = SAFE_HEAP_LOAD(ptr++ | 0, 1, 1) >>> 0;
if (!ch) return str;
str += String.fromCharCode(ch);
}
}
function stringToAscii(str, outPtr) {
return writeAsciiToMemory(str, outPtr, false);
}
function UTF16ToString(ptr, maxBytesToRead) {
assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
var str = "";
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
var codeUnit = SAFE_HEAP_LOAD(ptr + i * 2 | 0, 2, 0) | 0;
if (codeUnit == 0) break;
str += String.fromCharCode(codeUnit);
}
return str;
}
function stringToUTF16(str, outPtr, maxBytesToWrite) {
assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
assert(typeof maxBytesToWrite == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
SAFE_HEAP_STORE(outPtr | 0, codeUnit | 0, 2);
outPtr += 2;
}
SAFE_HEAP_STORE(outPtr | 0, 0 | 0, 2);
return outPtr - startPtr;
}
function lengthBytesUTF16(str) {
return str.length * 2;
}
function UTF32ToString(ptr, maxBytesToRead) {
assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
var i = 0;
var str = "";
while (!(i >= maxBytesToRead / 4)) {
var utf32 = SAFE_HEAP_LOAD(ptr + i * 4 | 0, 4, 0) | 0;
if (utf32 == 0) break;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
} else {
str += String.fromCharCode(utf32);
}
}
return str;
}
function stringToUTF32(str, outPtr, maxBytesToWrite) {
assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!");
assert(typeof maxBytesToWrite == "number", "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647;
}
if (maxBytesToWrite < 4) return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i);
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
}
SAFE_HEAP_STORE(outPtr | 0, codeUnit | 0, 4);
outPtr += 4;
if (outPtr + 4 > endPtr) break;
}
SAFE_HEAP_STORE(outPtr | 0, 0 | 0, 4);
return outPtr - startPtr;
}
function lengthBytesUTF32(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
len += 4;
}
return len;
}
function allocateUTF8(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = _malloc(size);
if (ret) stringToUTF8Array(str, HEAP8, ret, size);
return ret;
}
function allocateUTF8OnStack(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = stackAlloc(size);
stringToUTF8Array(str, HEAP8, ret, size);
return ret;
}
function writeStringToMemory(string, buffer, dontAddNull) {
warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
var lastChar, end;
if (dontAddNull) {
end = buffer + lengthBytesUTF8(string);
lastChar = SAFE_HEAP_LOAD(end, 1, 0);
}
stringToUTF8(string, buffer, Infinity);
if (dontAddNull) SAFE_HEAP_STORE(end, lastChar, 1);
}
function writeArrayToMemory(array, buffer) {
assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
HEAP8.set(array, buffer);
}
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {
assert(str.charCodeAt(i) === str.charCodeAt(i) & 255);
SAFE_HEAP_STORE(buffer++ | 0, str.charCodeAt(i) | 0, 1);
}
if (!dontAddNull) SAFE_HEAP_STORE(buffer | 0, 0 | 0, 1);
}
function alignUp(x, multiple) {
if (x % multiple > 0) {
x += multiple - x % multiple;
}
return x;
}
var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateGlobalBufferAndViews(buf) {
buffer = buf;
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
Module["HEAP16"] = HEAP16 = new Int16Array(buf);
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
}
var TOTAL_STACK = 5242880;
if (Module["TOTAL_STACK"]) assert(TOTAL_STACK === Module["TOTAL_STACK"], "the stack size can no longer be determined at runtime");
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
if (!Object.getOwnPropertyDescriptor(Module, "INITIAL_MEMORY")) Object.defineProperty(Module, "INITIAL_MEMORY", {
configurable: true,
get: function() {
abort("Module.INITIAL_MEMORY has been replaced with plain INITIAL_MEMORY (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
}
});
assert(INITIAL_MEMORY >= TOTAL_STACK, "INITIAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, "JS engine does not provide full typed array support");
if (ENVIRONMENT_IS_PTHREAD) {
wasmMemory = Module["wasmMemory"];
buffer = Module["buffer"];
} else {
if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
} else {
wasmMemory = new WebAssembly.Memory({
"initial": INITIAL_MEMORY / 65536,
"maximum": INITIAL_MEMORY / 65536,
"shared": true
});
if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
err("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag");
if (ENVIRONMENT_IS_NODE) {
console.log("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)");
}
throw Error("bad memory");
}
}
}
if (wasmMemory) {
buffer = wasmMemory.buffer;
}
INITIAL_MEMORY = buffer.byteLength;
assert(INITIAL_MEMORY % 65536 === 0);
updateGlobalBufferAndViews(buffer);
var wasmTable;
function writeStackCookie() {
var max = _emscripten_stack_get_end();
assert((max & 3) == 0);
SAFE_HEAP_STORE(((max >> 2) + 1) * 4, 34821223, 4);
SAFE_HEAP_STORE(((max >> 2) + 2) * 4, 2310721022, 4);
}
function checkStackCookie() {
if (ABORT) return;
var max = _emscripten_stack_get_end();
var cookie1 = SAFE_HEAP_LOAD(((max >> 2) + 1) * 4, 4, 1);
var cookie2 = SAFE_HEAP_LOAD(((max >> 2) + 2) * 4, 4, 1);
if (cookie1 != 34821223 || cookie2 != 2310721022) {
abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" + cookie2.toString(16) + " " + cookie1.toString(16));
}
}
(function() {
var h16 = new Int16Array(1);
var h8 = new Int8Array(h16.buffer);
h16[0] = 25459;
if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian!";
})();
function abortFnPtrError(ptr, sig) {
var possibleSig = "";
for (var x in debug_tables) {
var tbl = debug_tables[x];
if (tbl[ptr]) {
possibleSig += 'as sig "' + x + '" pointing to function ' + tbl[ptr] + ", ";
}
}
abort("Invalid function pointer " + ptr + " called with signature '" + sig + "'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this). This pointer might make sense in another type signature: " + possibleSig);
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATEXIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
var runtimeExited = false;
if (ENVIRONMENT_IS_PTHREAD) runtimeInitialized = true;
function preRun() {
if (ENVIRONMENT_IS_PTHREAD) return;
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
checkStackCookie();
assert(!runtimeInitialized);
runtimeInitialized = true;
if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
TTY.init();
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
checkStackCookie();
if (ENVIRONMENT_IS_PTHREAD) return;
FS.ignorePermissions = false;
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
checkStackCookie();
if (ENVIRONMENT_IS_PTHREAD) return;
runtimeExited = true;
}
function postRun() {
checkStackCookie();
if (ENVIRONMENT_IS_PTHREAD) return;
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 addOnPreMain(cb) {
__ATMAIN__.unshift(cb);
}
function addOnExit(cb) {}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
var runDependencyTracking = {};
function getUniqueRunDependency(id) {
var orig = id;
while (1) {
if (!runDependencyTracking[id]) return id;
id = orig + Math.random();
}
}
function addRunDependency(id) {
assert(!ENVIRONMENT_IS_PTHREAD, "addRunDependency cannot be used in a pthread worker");
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (id) {
assert(!runDependencyTracking[id]);
runDependencyTracking[id] = 1;
if (runDependencyWatcher === null && typeof setInterval !== "undefined") {
runDependencyWatcher = setInterval(function() {
if (ABORT) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
return;
}
var shown = false;
for (var dep in runDependencyTracking) {
if (!shown) {
shown = true;
err("still waiting on run dependencies:");
}
err("dependency: " + dep);
}
if (shown) {
err("(end of list)");
}
}, 1e4);
}
} else {
err("warning: run dependency added without ID");
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (id) {
assert(runDependencyTracking[id]);
delete runDependencyTracking[id];
} else {
err("warning: run dependency removed without ID");
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
Module["preloadedImages"] = {};
Module["preloadedAudios"] = {};
function abort(what) {
if (Module["onAbort"]) {
Module["onAbort"](what);
}
if (ENVIRONMENT_IS_PTHREAD) console.error("Pthread aborting at " + new Error().stack);
what += "";
err(what);
ABORT = true;
EXITSTATUS = 1;
var output = "abort(" + what + ") at " + stackTrace();
what = output;
var e = new WebAssembly.RuntimeError(what);
throw e;
}
function hasPrefix(str, prefix) {
return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return hasPrefix(filename, dataURIPrefix);
}
var fileURIPrefix = "file://";
function isFileURI(filename) {
return hasPrefix(filename, fileURIPrefix);
}
function createExportWrapper(name, fixedasm) {
return function() {
var displayName = name;
var asm = fixedasm;
if (!fixedasm) {
asm = Module["asm"];
}
assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization");
assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)");
if (!asm[name]) {
assert(asm[name], "exported native function `" + displayName + "` not found");
}
return asm[name].apply(null, arguments);
};
}
var wasmBinaryFile = "terminal.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
function getBinary(file) {
try {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
} else {
throw "both async and sync fetching of the wasm failed";
}
} catch (err) {
abort(err);
}
}
function getBinaryPromise() {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
return fetch(wasmBinaryFile, {
credentials: "same-origin"
}).then(function(response) {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
}
return response["arrayBuffer"]();
}).catch(function() {
return getBinary(wasmBinaryFile);
});
}
return Promise.resolve().then(function() {
return getBinary(wasmBinaryFile);
});
}
function createWasm() {
var info = {
"env": asmLibraryArg,
"wasi_snapshot_preview1": asmLibraryArg
};
function receiveInstance(instance, module) {
var exports = instance.exports;
Module["asm"] = exports;
wasmTable = Module["asm"]["__indirect_function_table"];
assert(wasmTable, "table not found in wasm exports");
wasmModule = module;
if (!ENVIRONMENT_IS_PTHREAD) {
removeRunDependency("wasm-instantiate");
}
}
if (!ENVIRONMENT_IS_PTHREAD) {
addRunDependency("wasm-instantiate");
}
var trueModule = Module;
function receiveInstantiatedSource(output) {
assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
trueModule = null;
receiveInstance(output["instance"], output["module"]);
}
function instantiateArrayBuffer(receiver) {
return getBinaryPromise().then(function(binary) {
return WebAssembly.instantiate(binary, info);
}).then(receiver, function(reason) {
err("failed to asynchronously prepare wasm: " + reason);
abort(reason);
});
}
function instantiateAsync() {
if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === "function") {
return fetch(wasmBinaryFile, {
credentials: "same-origin"
}).then(function(response) {
var result = WebAssembly.instantiateStreaming(response, info);
return result.then(receiveInstantiatedSource, function(reason) {
err("wasm streaming compile failed: " + reason);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(receiveInstantiatedSource);
});
});
} else {
return instantiateArrayBuffer(receiveInstantiatedSource);
}
}
if (Module["instantiateWasm"]) {
try {
var exports = Module["instantiateWasm"](info, receiveInstance);
return exports;
} catch (e) {
err("Module.instantiateWasm callback failed with error: " + e);
return false;
}
}
instantiateAsync();
return {};
}
var tempDouble;
var tempI64;
var ASM_CONSTS = {
76088: function() {
throw "Canceled!";
},
76338: function($0, $1) {
setTimeout(function() {
__emscripten_do_dispatch_to_thread($0, $1);
}, 0);
}
};
function initPthreadsJS() {
PThread.initRuntime();
}
function abortStackOverflow(allocSize) {
abort("Stack overflow! Attempted to allocate " + allocSize + " bytes on the stack, but stack has only " + (_emscripten_stack_get_free() + allocSize) + " bytes available!");
}
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback(Module);
continue;
}
var func = callback.func;
if (typeof func === "number") {
if (callback.arg === undefined) {
wasmTable.get(func)();
} else {
wasmTable.get(func)(callback.arg);
}
} else {
func(callback.arg === undefined ? null : callback.arg);
}
}
}
function demangle(func) {
warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
return func;
}
function demangleAll(text) {
var regex = /\b_Z[\w\d_]+/g;
return text.replace(regex, function(x) {
var y = demangle(x);
return x === y ? x : y + " [" + x + "]";
});
}
var ERRNO_CODES = {
EPERM: 63,
ENOENT: 44,
ESRCH: 71,
EINTR: 27,
EIO: 29,
ENXIO: 60,
E2BIG: 1,
ENOEXEC: 45,
EBADF: 8,
ECHILD: 12,
EAGAIN: 6,
EWOULDBLOCK: 6,
ENOMEM: 48,
EACCES: 2,
EFAULT: 21,
ENOTBLK: 105,
EBUSY: 10,
EEXIST: 20,
EXDEV: 75,
ENODEV: 43,
ENOTDIR: 54,
EISDIR: 31,
EINVAL: 28,
ENFILE: 41,
EMFILE: 33,
ENOTTY: 59,
ETXTBSY: 74,
EFBIG: 22,
ENOSPC: 51,
ESPIPE: 70,
EROFS: 69,
EMLINK: 34,
EPIPE: 64,
EDOM: 18,
ERANGE: 68,
ENOMSG: 49,
EIDRM: 24,
ECHRNG: 106,
EL2NSYNC: 156,
EL3HLT: 107,
EL3RST: 108,
ELNRNG: 109,
EUNATCH: 110,
ENOCSI: 111,
EL2HLT: 112,
EDEADLK: 16,
ENOLCK: 46,
EBADE: 113,
EBADR: 114,
EXFULL: 115,
ENOANO: 104,
EBADRQC: 103,
EBADSLT: 102,
EDEADLOCK: 16,
EBFONT: 101,
ENOSTR: 100,
ENODATA: 116,
ETIME: 117,
ENOSR: 118,
ENONET: 119,
ENOPKG: 120,
EREMOTE: 121,
ENOLINK: 47,
EADV: 122,
ESRMNT: 123,
ECOMM: 124,
EPROTO: 65,
EMULTIHOP: 36,
EDOTDOT: 125,
EBADMSG: 9,
ENOTUNIQ: 126,
EBADFD: 127,
EREMCHG: 128,
ELIBACC: 129,
ELIBBAD: 130,
ELIBSCN: 131,
ELIBMAX: 132,
ELIBEXEC: 133,
ENOSYS: 52,
ENOTEMPTY: 55,
ENAMETOOLONG: 37,
ELOOP: 32,
EOPNOTSUPP: 138,
EPFNOSUPPORT: 139,
ECONNRESET: 15,
ENOBUFS: 42,
EAFNOSUPPORT: 5,
EPROTOTYPE: 67,
ENOTSOCK: 57,
ENOPROTOOPT: 50,
ESHUTDOWN: 140,
ECONNREFUSED: 14,
EADDRINUSE: 3,
ECONNABORTED: 13,
ENETUNREACH: 40,
ENETDOWN: 38,
ETIMEDOUT: 73,
EHOSTDOWN: 142,
EHOSTUNREACH: 23,
EINPROGRESS: 26,
EALREADY: 7,
EDESTADDRREQ: 17,
EMSGSIZE: 35,
EPROTONOSUPPORT: 66,
ESOCKTNOSUPPORT: 137,
EADDRNOTAVAIL: 4,
ENETRESET: 39,
EISCONN: 30,
ENOTCONN: 53,
ETOOMANYREFS: 141,
EUSERS: 136,
EDQUOT: 19,
ESTALE: 72,
ENOTSUP: 138,
ENOMEDIUM: 148,
EILSEQ: 25,
EOVERFLOW: 61,
ECANCELED: 11,
ENOTRECOVERABLE: 56,
EOWNERDEAD: 62,
ESTRPIPE: 135
};
function _emscripten_futex_wake(addr, count) {
if (addr <= 0 || addr > HEAP8.length || addr & 3 != 0 || count < 0) return -28;
if (count == 0) return 0;
if (count >= 2147483647) count = Infinity;
assert(__emscripten_main_thread_futex > 0);
var mainThreadWaitAddress = Atomics.load(HEAP32, __emscripten_main_thread_futex >> 2);
var mainThreadWoken = 0;
if (mainThreadWaitAddress == addr) {
assert(!ENVIRONMENT_IS_WEB);
var loadedAddr = Atomics.compareExchange(HEAP32, __emscripten_main_thread_futex >> 2, mainThreadWaitAddress, 0);
if (loadedAddr == mainThreadWaitAddress) {
--count;
mainThreadWoken = 1;
if (count <= 0) return 1;
}
}
var ret = Atomics.notify(HEAP32, addr >> 2, count);
if (ret >= 0) return ret + mainThreadWoken;
throw "Atomics.notify returned an unexpected value " + ret;
}
Module["_emscripten_futex_wake"] = _emscripten_futex_wake;
function killThread(pthread_ptr) {
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! killThread() can only ever be called from main application thread!";
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in killThread!";
SAFE_HEAP_STORE(pthread_ptr + 12 | 0, 0 | 0, 4);
var pthread = PThread.pthreads[pthread_ptr];
pthread.worker.terminate();
PThread.freeThreadData(pthread);
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1);
pthread.worker.pthread = undefined;
}
function cancelThread(pthread_ptr) {
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! cancelThread() can only ever be called from main application thread!";
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in cancelThread!";
var pthread = PThread.pthreads[pthread_ptr];
pthread.worker.postMessage({
"cmd": "cancel"
});
}
function cleanupThread(pthread_ptr) {
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! cleanupThread() can only ever be called from main application thread!";
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in cleanupThread!";
SAFE_HEAP_STORE(pthread_ptr + 12 | 0, 0 | 0, 4);
var pthread = PThread.pthreads[pthread_ptr];
if (pthread) {
var worker = pthread.worker;
PThread.returnWorkerToPool(worker);
}
}
var PThread = {
unusedWorkers: [],
runningWorkers: [],
initMainThreadBlock: function() {
assert(!ENVIRONMENT_IS_PTHREAD);
},
initRuntime: function() {
var tb = _malloc(228);
for (var i = 0; i < 228 / 4; ++i) SAFE_HEAP_STORE((tb / 4 + i) * 4, 0, 4);
SAFE_HEAP_STORE(tb + 12 | 0, tb | 0, 4);
var headPtr = tb + 152;
SAFE_HEAP_STORE(headPtr | 0, headPtr | 0, 4);
var tlsMemory = _malloc(512);
for (var i = 0; i < 128; ++i) SAFE_HEAP_STORE((tlsMemory / 4 + i) * 4, 0, 4);
Atomics.store(HEAPU32, tb + 100 >> 2, tlsMemory);
Atomics.store(HEAPU32, tb + 40 >> 2, tb);
__emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1);
_emscripten_register_main_browser_thread_id(tb);
},
initWorker: function() {},
pthreads: {},
threadExitHandlers: [],
setThreadStatus: function() {},
runExitHandlers: function() {
while (PThread.threadExitHandlers.length > 0) {
PThread.threadExitHandlers.pop()();
}
if (ENVIRONMENT_IS_PTHREAD && _pthread_self()) ___pthread_tsd_run_dtors();
},
threadExit: function(exitCode) {
var tb = _pthread_self();
if (tb) {
err("Pthread 0x" + tb.toString(16) + " exited.");
Atomics.store(HEAPU32, tb + 4 >> 2, exitCode);
Atomics.store(HEAPU32, tb + 0 >> 2, 1);
Atomics.store(HEAPU32, tb + 56 >> 2, 1);
Atomics.store(HEAPU32, tb + 60 >> 2, 0);
PThread.runExitHandlers();
_emscripten_futex_wake(tb + 0, 2147483647);
__emscripten_thread_init(0, 0, 0);
if (ENVIRONMENT_IS_PTHREAD) {
postMessage({
"cmd": "exit"
});
}
}
},
threadCancel: function() {
PThread.runExitHandlers();
var tb = _pthread_self();
Atomics.store(HEAPU32, tb + 4 >> 2, -1);
Atomics.store(HEAPU32, tb + 0 >> 2, 1);
_emscripten_futex_wake(tb + 0, 2147483647);
__emscripten_thread_init(0, 0, 0);
postMessage({
"cmd": "cancelDone"
});
},
terminateAllThreads: function() {
for (var t in PThread.pthreads) {
var pthread = PThread.pthreads[t];
if (pthread && pthread.worker) {
PThread.returnWorkerToPool(pthread.worker);
}
}
PThread.pthreads = {};
for (var i = 0; i < PThread.unusedWorkers.length; ++i) {
var worker = PThread.unusedWorkers[i];
assert(!worker.pthread);
worker.terminate();
}
PThread.unusedWorkers = [];
for (var i = 0; i < PThread.runningWorkers.length; ++i) {
var worker = PThread.runningWorkers[i];
var pthread = worker.pthread;
assert(pthread, "This Worker should have a pthread it is executing");
PThread.freeThreadData(pthread);
worker.terminate();
}
PThread.runningWorkers = [];
},
freeThreadData: function(pthread) {
if (!pthread) return;
if (pthread.threadInfoStruct) {
var tlsMemory = SAFE_HEAP_LOAD(pthread.threadInfoStruct + 100 | 0, 4, 0) | 0;
SAFE_HEAP_STORE(pthread.threadInfoStruct + 100 | 0, 0 | 0, 4);
_free(tlsMemory);
_free(pthread.threadInfoStruct);
}
pthread.threadInfoStruct = 0;
if (pthread.allocatedOwnStack && pthread.stackBase) _free(pthread.stackBase);
pthread.stackBase = 0;
if (pthread.worker) pthread.worker.pthread = null;
},
returnWorkerToPool: function(worker) {
delete PThread.pthreads[worker.pthread.thread];
PThread.unusedWorkers.push(worker);
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
PThread.freeThreadData(worker.pthread);
worker.pthread = undefined;
},
receiveObjectTransfer: function(data) {},
loadWasmModuleToWorker: function(worker, onFinishedLoading) {
worker.onmessage = function(e) {
var d = e["data"];
var cmd = d["cmd"];
if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;
if (d["targetThread"] && d["targetThread"] != _pthread_self()) {
var thread = PThread.pthreads[d.targetThread];
if (thread) {
thread.worker.postMessage(e.data, d["transferList"]);
} else {
console.error('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d["targetThread"] + ", but that thread no longer exists!");
}
PThread.currentProxiedOperationCallerThread = undefined;
return;
}
if (cmd === "processQueuedMainThreadWork") {
_emscripten_main_thread_process_queued_calls();
} else if (cmd === "spawnThread") {
spawnThread(e.data);
} else if (cmd === "cleanupThread") {
cleanupThread(d["thread"]);
} else if (cmd === "killThread") {
killThread(d["thread"]);
} else if (cmd === "cancelThread") {
cancelThread(d["thread"]);
} else if (cmd === "loaded") {
worker.loaded = true;
if (onFinishedLoading) onFinishedLoading(worker);
if (worker.runPthread) {
worker.runPthread();
delete worker.runPthread;
}
} else if (cmd === "print") {
out("Thread " + d["threadId"] + ": " + d["text"]);
} else if (cmd === "printErr") {
err("Thread " + d["threadId"] + ": " + d["text"]);
} else if (cmd === "alert") {
alert("Thread " + d["threadId"] + ": " + d["text"]);
} else if (cmd === "exit") {
var detached = worker.pthread && Atomics.load(HEAPU32, worker.pthread.thread + 64 >> 2);
if (detached) {
PThread.returnWorkerToPool(worker);
}
} else if (cmd === "exitProcess") {
err("exitProcess requested by worker");
try {
exit(d["returnCode"]);
} catch (e) {
if (e instanceof ExitStatus) return;
throw e;
}
} else if (cmd === "cancelDone") {
PThread.returnWorkerToPool(worker);
} else if (cmd === "objectTransfer") {
PThread.receiveObjectTransfer(e.data);
} else if (e.data.target === "setimmediate") {
worker.postMessage(e.data);
} else {
err("worker sent an unknown command " + cmd);
}
PThread.currentProxiedOperationCallerThread = undefined;
};
worker.onerror = function(e) {
err("pthread sent an error! " + e.filename + ":" + e.lineno + ": " + e.message);
};
if (ENVIRONMENT_IS_NODE) {
worker.on("message", function(data) {
worker.onmessage({
data: data
});
});
worker.on("error", function(data) {
worker.onerror(data);
});
worker.on("exit", function(data) {});
}
assert(wasmMemory instanceof WebAssembly.Memory, "WebAssembly memory should have been loaded by now!");
assert(wasmModule instanceof WebAssembly.Module, "WebAssembly Module should have been loaded by now!");
worker.postMessage({
"cmd": "load",
"urlOrBlob": Module["mainScriptUrlOrBlob"] || _scriptDir,
"wasmMemory": wasmMemory,
"wasmModule": wasmModule
});
},
allocateUnusedWorker: function() {
var pthreadMainJs = locateFile("terminal.worker.js");
PThread.unusedWorkers.push(new Worker(pthreadMainJs));
},
getNewWorker: function() {
if (PThread.unusedWorkers.length == 0) {
PThread.allocateUnusedWorker();
PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
}
if (PThread.unusedWorkers.length > 0) return PThread.unusedWorkers.pop(); else return null;
},
busySpinWait: function(msecs) {
var t = performance.now() + msecs;
while (performance.now() < t) {
}
}
};
function establishStackSpace(stackTop, stackMax) {
_emscripten_stack_set_limits(stackTop, stackMax);
stackRestore(stackTop);
writeStackCookie();
}
Module["establishStackSpace"] = establishStackSpace;
function getNoExitRuntime() {
return noExitRuntime;
}
Module["getNoExitRuntime"] = getNoExitRuntime;
function invokeEntryPoint(ptr, arg) {
return wasmTable.get(ptr)(arg);
}
Module["invokeEntryPoint"] = invokeEntryPoint;
function jsStackTrace() {
var error = new Error();
if (!error.stack) {
try {
throw new Error();
} catch (e) {
error = e;
}
if (!error.stack) {
return "(no stack trace available)";
}
}
return error.stack.toString();
}
function stackTrace() {
var js = jsStackTrace();
if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
return demangleAll(js);
}
function unSign(value, bits) {
if (value >= 0) {
return value;
}
return bits <= 32 ? 2 * Math.abs(1 << bits - 1) + value : Math.pow(2, bits) + value;
}
function ___assert_fail(condition, filename, line, func) {
abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
}
function ___call_main(argc, argv) {
var returnCode = _main(argc, argv);
out("Proxied main thread 0x" + _pthread_self().toString(16) + " finished with return code " + returnCode + ". EXIT_RUNTIME=0 set, so keeping main thread alive for asynchronous event operations.");
}
var _emscripten_get_now;
if (ENVIRONMENT_IS_NODE) {
_emscripten_get_now = function() {
var t = process["hrtime"]();
return t[0] * 1e3 + t[1] / 1e6;
};
} else if (ENVIRONMENT_IS_PTHREAD) {
_emscripten_get_now = function() {
return performance.now() - Module["__performance_now_clock_drift"];
};
} else if (typeof dateNow !== "undefined") {
_emscripten_get_now = dateNow;
} else _emscripten_get_now = function() {
return performance.now();
};
var _emscripten_get_now_is_monotonic = true;
function setErrNo(value) {
SAFE_HEAP_STORE(___errno_location() | 0, value | 0, 4);
return value;
}
function _clock_gettime(clk_id, tp) {
var now;
if (clk_id === 0) {
now = Date.now();
} else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
now = _emscripten_get_now();
} else {
setErrNo(28);
return -1;
}
SAFE_HEAP_STORE(tp | 0, now / 1e3 | 0 | 0, 4);
SAFE_HEAP_STORE(tp + 4 | 0, now % 1e3 * 1e3 * 1e3 | 0 | 0, 4);
return 0;
}
function ___clock_gettime(a0, a1) {
return _clock_gettime(a0, a1);
}
var PATH = {
splitPath: function(filename) {
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
return splitPathRe.exec(filename).slice(1);
},
normalizeArray: function(parts, allowAboveRoot) {
var up = 0;
for (var i = parts.length - 1; i >= 0; i--) {
var last = parts[i];
if (last === ".") {
parts.splice(i, 1);
} else if (last === "..") {
parts.splice(i, 1);
up++;
} else if (up) {
parts.splice(i, 1);
up--;
}
}
if (allowAboveRoot) {
for (;up; up--) {
parts.unshift("..");
}
}
return parts;
},
normalize: function(path) {
var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/";
path = PATH.normalizeArray(path.split("/").filter(function(p) {
return !!p;
}), !isAbsolute).join("/");
if (!path && !isAbsolute) {
path = ".";
}
if (path && trailingSlash) {
path += "/";
}
return (isAbsolute ? "/" : "") + path;
},
dirname: function(path) {
var result = PATH.splitPath(path), root = result[0], dir = result[1];
if (!root && !dir) {
return ".";
}
if (dir) {
dir = dir.substr(0, dir.length - 1);
}
return root + dir;
},
basename: function(path) {
if (path === "/") return "/";
path = PATH.normalize(path);
path = path.replace(/\/$/, "");
var lastSlash = path.lastIndexOf("/");
if (lastSlash === -1) return path;
return path.substr(lastSlash + 1);
},
extname: function(path) {
return PATH.splitPath(path)[3];
},
join: function() {
var paths = Array.prototype.slice.call(arguments, 0);
return PATH.normalize(paths.join("/"));
},
join2: function(l, r) {
return PATH.normalize(l + "/" + r);
}
};
function getRandomDevice() {
if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
var randomBuffer = new Uint8Array(1);
return function() {
crypto.getRandomValues(randomBuffer);
return randomBuffer[0];
};
} else if (ENVIRONMENT_IS_NODE) {
try {
var crypto_module = require("crypto");
return function() {
return crypto_module["randomBytes"](1)[0];
};
} catch (e) {}
}
return function() {
abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };");
};
}
var PATH_FS = {
resolve: function() {
var resolvedPath = "", resolvedAbsolute = false;
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path = i >= 0 ? arguments[i] : FS.cwd();
if (typeof path !== "string") {
throw new TypeError("Arguments to path.resolve must be strings");
} else if (!path) {
return "";
}
resolvedPath = path + "/" + resolvedPath;
resolvedAbsolute = path.charAt(0) === "/";
}
resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) {
return !!p;
}), !resolvedAbsolute).join("/");
return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
},
relative: function(from, to) {
from = PATH_FS.resolve(from).substr(1);
to = PATH_FS.resolve(to).substr(1);
function trim(arr) {
var start = 0;
for (;start < arr.length; start++) {
if (arr[start] !== "") break;
}
var end = arr.length - 1;
for (;end >= 0; end--) {
if (arr[end] !== "") break;
}
if (start > end) return [];
return arr.slice(start, end - start + 1);
}
var fromParts = trim(from.split("/"));
var toParts = trim(to.split("/"));
var length = Math.min(fromParts.length, toParts.length);
var samePartsLength = length;
for (var i = 0; i < length; i++) {
if (fromParts[i] !== toParts[i]) {
samePartsLength = i;
break;
}
}
var outputParts = [];
for (var i = samePartsLength; i < fromParts.length; i++) {
outputParts.push("..");
}
outputParts = outputParts.concat(toParts.slice(samePartsLength));
return outputParts.join("/");
}
};
var TTY = {
ttys: [],
init: function() {},
shutdown: function() {},
register: function(dev, ops) {
TTY.ttys[dev] = {
input: [],
output: [],
ops: ops
};
FS.registerDevice(dev, TTY.stream_ops);
},
stream_ops: {
open: function(stream) {
var tty = TTY.ttys[stream.node.rdev];
if (!tty) {
throw new FS.ErrnoError(43);
}
stream.tty = tty;
stream.seekable = false;
},
close: function(stream) {
stream.tty.ops.flush(stream.tty);
},
flush: function(stream) {
stream.tty.ops.flush(stream.tty);
},
read: function(stream, buffer, offset, length, pos) {
if (!stream.tty || !stream.tty.ops.get_char) {
throw new FS.ErrnoError(60);
}
var bytesRead = 0;
for (var i = 0; i < length; i++) {
var result;
try {
result = stream.tty.ops.get_char(stream.tty);
} catch (e) {
throw new FS.ErrnoError(29);
}
if (result === undefined && bytesRead === 0) {
throw new FS.ErrnoError(6);
}
if (result === null || result === undefined) break;
bytesRead++;
buffer[offset + i] = result;
}
if (bytesRead) {
stream.node.timestamp = Date.now();
}
return bytesRead;
},
write: function(stream, buffer, offset, length, pos) {
if (!stream.tty || !stream.tty.ops.put_char) {
throw new FS.ErrnoError(60);
}
try {
for (var i = 0; i < length; i++) {
stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
}
} catch (e) {
throw new FS.ErrnoError(29);
}
if (length) {
stream.node.timestamp = Date.now();
}
return i;
}
},
default_tty_ops: {
get_char: function(tty) {
if (!tty.input.length) {
var result = null;
if (ENVIRONMENT_IS_NODE) {
var BUFSIZE = 256;
var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE);
var bytesRead = 0;
try {
bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null);
} catch (e) {
if (e.toString().indexOf("EOF") != -1) bytesRead = 0; else throw e;
}
if (bytesRead > 0) {
result = buf.slice(0, bytesRead).toString("utf-8");
} else {
result = null;
}
} else if (typeof window != "undefined" && typeof window.prompt == "function") {
result = window.prompt("Input: ");
if (result !== null) {
result += "\n";
}
} else if (typeof readline == "function") {
result = readline();
if (result !== null) {
result += "\n";
}
}
if (!result) {
return null;
}
tty.input = intArrayFromString(result, true);
}
return tty.input.shift();
},
put_char: function(tty, val) {
if (val === null || val === 10) {
out(UTF8ArrayToString(tty.output, 0));
tty.output = [];
} else {
if (val != 0) tty.output.push(val);
}
},
flush: function(tty) {
if (tty.output && tty.output.length > 0) {
out(UTF8ArrayToString(tty.output, 0));
tty.output = [];
}
}
},
default_tty1_ops: {
put_char: function(tty, val) {
if (val === null || val === 10) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = [];
} else {
if (val != 0) tty.output.push(val);
}
},
flush: function(tty) {
if (tty.output && tty.output.length > 0) {
err(UTF8ArrayToString(tty.output, 0));
tty.output = [];
}
}
}
};
function mmapAlloc(size) {
var alignedSize = alignMemory(size, 16384);
var ptr = _malloc(alignedSize);
while (size < alignedSize) SAFE_HEAP_STORE(ptr + size++, 0, 1);
return ptr;
}
var MEMFS = {
ops_table: null,
mount: function(mount) {
return MEMFS.createNode(null, "/", 16384 | 511, 0);
},
createNode: function(parent, name, mode, dev) {
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
throw new FS.ErrnoError(63);
}
if (!MEMFS.ops_table) {
MEMFS.ops_table = {
dir: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
lookup: MEMFS.node_ops.lookup,
mknod: MEMFS.node_ops.mknod,
rename: MEMFS.node_ops.rename,
unlink: MEMFS.node_ops.unlink,
rmdir: MEMFS.node_ops.rmdir,
readdir: MEMFS.node_ops.readdir,
symlink: MEMFS.node_ops.symlink
},
stream: {
llseek: MEMFS.stream_ops.llseek
}
},
file: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr
},
stream: {
llseek: MEMFS.stream_ops.llseek,
read: MEMFS.stream_ops.read,
write: MEMFS.stream_ops.write,
allocate: MEMFS.stream_ops.allocate,
mmap: MEMFS.stream_ops.mmap,
msync: MEMFS.stream_ops.msync
}
},
link: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr,
readlink: MEMFS.node_ops.readlink
},
stream: {}
},
chrdev: {
node: {
getattr: MEMFS.node_ops.getattr,
setattr: MEMFS.node_ops.setattr
},
stream: FS.chrdev_stream_ops
}
};
}
var node = FS.createNode(parent, name, mode, dev);
if (FS.isDir(node.mode)) {
node.node_ops = MEMFS.ops_table.dir.node;
node.stream_ops = MEMFS.ops_table.dir.stream;
node.contents = {};
} else if (FS.isFile(node.mode)) {
node.node_ops = MEMFS.ops_table.file.node;
node.stream_ops = MEMFS.ops_table.file.stream;
node.usedBytes = 0;
node.contents = null;
} else if (FS.isLink(node.mode)) {
node.node_ops = MEMFS.ops_table.link.node;
node.stream_ops = MEMFS.ops_table.link.stream;
} else if (FS.isChrdev(node.mode)) {
node.node_ops = MEMFS.ops_table.chrdev.node;
node.stream_ops = MEMFS.ops_table.chrdev.stream;
}
node.timestamp = Date.now();
if (parent) {
parent.contents[name] = node;
}
return node;
},
getFileDataAsRegularArray: function(node) {
if (node.contents && node.contents.subarray) {
var arr = [];
for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
return arr;
}
return node.contents;
},
getFileDataAsTypedArray: function(node) {
if (!node.contents) return new Uint8Array(0);
if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
return new Uint8Array(node.contents);
},
expandFileStorage: function(node, newCapacity) {
var prevCapacity = node.contents ? node.contents.length : 0;
if (prevCapacity >= newCapacity) return;
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
var oldContents = node.contents;
node.contents = new Uint8Array(newCapacity);
if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
return;
},
resizeFileStorage: function(node, newSize) {
if (node.usedBytes == newSize) return;
if (newSize == 0) {
node.contents = null;
node.usedBytes = 0;
return;
}
if (!node.contents || node.contents.subarray) {
var oldContents = node.contents;
node.contents = new Uint8Array(newSize);
if (oldContents) {
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
}
node.usedBytes = newSize;
return;
}
if (!node.contents) node.contents = [];
if (node.contents.length > newSize) node.contents.length = newSize; else while (node.contents.length < newSize) node.contents.push(0);
node.usedBytes = newSize;
},
node_ops: {
getattr: function(node) {
var attr = {};
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
attr.ino = node.id;
attr.mode = node.mode;
attr.nlink = 1;
attr.uid = 0;
attr.gid = 0;
attr.rdev = node.rdev;
if (FS.isDir(node.mode)) {
attr.size = 4096;
} else if (FS.isFile(node.mode)) {
attr.size = node.usedBytes;
} else if (FS.isLink(node.mode)) {
attr.size = node.link.length;
} else {
attr.size = 0;
}
attr.atime = new Date(node.timestamp);
attr.mtime = new Date(node.timestamp);
attr.ctime = new Date(node.timestamp);
attr.blksize = 4096;
attr.blocks = Math.ceil(attr.size / attr.blksize);
return attr;
},
setattr: function(node, attr) {
if (attr.mode !== undefined) {
node.mode = attr.mode;
}
if (attr.timestamp !== undefined) {
node.timestamp = attr.timestamp;
}
if (attr.size !== undefined) {
MEMFS.resizeFileStorage(node, attr.size);
}
},
lookup: function(parent, name) {
throw FS.genericErrors[44];
},
mknod: function(parent, name, mode, dev) {
return MEMFS.createNode(parent, name, mode, dev);
},
rename: function(old_node, new_dir, new_name) {
if (FS.isDir(old_node.mode)) {
var new_node;
try {
new_node = FS.lookupNode(new_dir, new_name);
} catch (e) {}
if (new_node) {
for (var i in new_node.contents) {
throw new FS.ErrnoError(55);
}
}
}
delete old_node.parent.contents[old_node.name];
old_node.name = new_name;
new_dir.contents[new_name] = old_node;
old_node.parent = new_dir;
},
unlink: function(parent, name) {
delete parent.contents[name];
},
rmdir: function(parent, name) {
var node = FS.lookupNode(parent, name);
for (var i in node.contents) {
throw new FS.ErrnoError(55);
}
delete parent.contents[name];
},
readdir: function(node) {
var entries = [ ".", ".." ];
for (var key in node.contents) {
if (!node.contents.hasOwnProperty(key)) {
continue;
}
entries.push(key);
}
return entries;
},
symlink: function(parent, newname, oldpath) {
var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
node.link = oldpath;
return node;
},
readlink: function(node) {
if (!FS.isLink(node.mode)) {
throw new FS.ErrnoError(28);
}
return node.link;
}
},
stream_ops: {
read: function(stream, buffer, offset, length, position) {
var contents = stream.node.contents;
if (position >= stream.node.usedBytes) return 0;
var size = Math.min(stream.node.usedBytes - position, length);
assert(size >= 0);
if (size > 8 && contents.subarray) {
buffer.set(contents.subarray(position, position + size), offset);
} else {
for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
}
return size;
},
write: function(stream, buffer, offset, length, position, canOwn) {
assert(!(buffer instanceof ArrayBuffer));
if (!length) return 0;
var node = stream.node;
node.timestamp = Date.now();
if (buffer.subarray && (!node.contents || node.contents.subarray)) {
if (canOwn) {
assert(position === 0, "canOwn must imply no weird position inside the file");
node.contents = buffer.subarray(offset, offset + length);
node.usedBytes = length;
return length;
} else if (node.usedBytes === 0 && position === 0) {
node.contents = buffer.slice(offset, offset + length);
node.usedBytes = length;
return length;
} else if (position + length <= node.usedBytes) {
node.contents.set(buffer.subarray(offset, offset + length), position);
return length;
}
}
MEMFS.expandFileStorage(node, position + length);
if (node.contents.subarray && buffer.subarray) {
node.contents.set(buffer.subarray(offset, offset + length), position);
} else {
for (var i = 0; i < length; i++) {
node.contents[position + i] = buffer[offset + i];
}
}
node.usedBytes = Math.max(node.usedBytes, position + length);
return length;
},
llseek: function(stream, offset, whence) {
var position = offset;
if (whence === 1) {
position += stream.position;
} else if (whence === 2) {
if (FS.isFile(stream.node.mode)) {
position += stream.node.usedBytes;
}
}
if (position < 0) {
throw new FS.ErrnoError(28);
}
return position;
},
allocate: function(stream, offset, length) {
MEMFS.expandFileStorage(stream.node, offset + length);
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
},
mmap: function(stream, address, length, position, prot, flags) {
assert(address === 0);
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(43);
}
var ptr;
var allocated;
var contents = stream.node.contents;
if (!(flags & 2) && contents.buffer === buffer) {
allocated = false;
ptr = contents.byteOffset;
} else {
if (position > 0 || position + length < contents.length) {
if (contents.subarray) {
contents = contents.subarray(position, position + length);
} else {
contents = Array.prototype.slice.call(contents, position, position + length);
}
}
allocated = true;
ptr = mmapAlloc(length);
if (!ptr) {
throw new FS.ErrnoError(48);
}
HEAP8.set(contents, ptr);
}
return {
ptr: ptr,
allocated: allocated
};
},
msync: function(stream, buffer, offset, length, mmapFlags) {
if (!FS.isFile(stream.node.mode)) {
throw new FS.ErrnoError(43);
}
if (mmapFlags & 2) {
return 0;
}
var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
return 0;
}
}
};
var ERRNO_MESSAGES = {
0: "Success",
1: "Arg list too long",
2: "Permission denied",
3: "Address already in use",
4: "Address not available",
5: "Address family not supported by protocol family",
6: "No more processes",
7: "Socket already connected",
8: "Bad file number",
9: "Trying to read unreadable message",
10: "Mount device busy",
11: "Operation canceled",
12: "No children",
13: "Connection aborted",
14: "Connection refused",
15: "Connection reset by peer",
16: "File locking deadlock error",
17: "Destination address required",
18: "Math arg out of domain of func",
19: "Quota exceeded",
20: "File exists",
21: "Bad address",
22: "File too large",
23: "Host is unreachable",
24: "Identifier removed",
25: "Illegal byte sequence",
26: "Connection already in progress",
27: "Interrupted system call",
28: "Invalid argument",
29: "I/O error",
30: "Socket is already connected",
31: "Is a directory",
32: "Too many symbolic links",
33: "Too many open files",
34: "Too many links",
35: "Message too long",
36: "Multihop attempted",
37: "File or path name too long",
38: "Network interface is not configured",
39: "Connection reset by network",
40: "Network is unreachable",
41: "Too many open files in system",
42: "No buffer space available",
43: "No such device",
44: "No such file or directory",
45: "Exec format error",
46: "No record locks available",
47: "The link has been severed",
48: "Not enough core",
49: "No message of desired type",
50: "Protocol not available",
51: "No space left on device",
52: "Function not implemented",
53: "Socket is not connected",
54: "Not a directory",
55: "Directory not empty",
56: "State not recoverable",
57: "Socket operation on non-socket",
59: "Not a typewriter",
60: "No such device or address",
61: "Value too large for defined data type",
62: "Previous owner died",
63: "Not super-user",
64: "Broken pipe",
65: "Protocol error",
66: "Unknown protocol",
67: "Protocol wrong type for socket",
68: "Math result not representable",
69: "Read only file system",
70: "Illegal seek",
71: "No such process",
72: "Stale file handle",
73: "Connection timed out",
74: "Text file busy",
75: "Cross-device link",
100: "Device not a stream",
101: "Bad font file fmt",
102: "Invalid slot",
103: "Invalid request code",
104: "No anode",
105: "Block device required",
106: "Channel number out of range",
107: "Level 3 halted",
108: "Level 3 reset",
109: "Link number out of range",
110: "Protocol driver not attached",
111: "No CSI structure available",
112: "Level 2 halted",
113: "Invalid exchange",
114: "Invalid request descriptor",
115: "Exchange full",
116: "No data (for no delay io)",
117: "Timer expired",
118: "Out of streams resources",
119: "Machine is not on the network",
120: "Package not installed",
121: "The object is remote",
122: "Advertise error",
123: "Srmount error",
124: "Communication error on send",
125: "Cross mount point (not really error)",
126: "Given log. name not unique",
127: "f.d. invalid for this operation",
128: "Remote address changed",
129: "Can access a needed shared lib",
130: "Accessing a corrupted shared lib",
131: ".lib section in a.out corrupted",
132: "Attempting to link in too many libs",
133: "Attempting to exec a shared library",
135: "Streams pipe error",
136: "Too many users",
137: "Socket type not supported",
138: "Not supported",
139: "Protocol family not supported",
140: "Can't send after socket shutdown",
141: "Too many references",
142: "Host is down",
148: "No medium (in tape drive)",
156: "Level 2 not synchronized"
};
var FS = {
root: null,
mounts: [],
devices: {},
streams: [],
nextInode: 1,
nameTable: null,
currentPath: "/",
initialized: false,
ignorePermissions: true,
trackingDelegate: {},
tracking: {
openFlags: {
READ: 1,
WRITE: 2
}
},
ErrnoError: null,
genericErrors: {},
filesystems: null,
syncFSRequests: 0,
lookupPath: function(path, opts) {
path = PATH_FS.resolve(FS.cwd(), path);
opts = opts || {};
if (!path) return {
path: "",
node: null
};
var defaults = {
follow_mount: true,
recurse_count: 0
};
for (var key in defaults) {
if (opts[key] === undefined) {
opts[key] = defaults[key];
}
}
if (opts.recurse_count > 8) {
throw new FS.ErrnoError(32);
}
var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
return !!p;
}), false);
var current = FS.root;
var current_path = "/";
for (var i = 0; i < parts.length; i++) {
var islast = i === parts.length - 1;
if (islast && opts.parent) {
break;
}
current = FS.lookupNode(current, parts[i]);
current_path = PATH.join2(current_path, parts[i]);
if (FS.isMountpoint(current)) {
if (!islast || islast && opts.follow_mount) {
current = current.mounted.root;
}
}
if (!islast || opts.follow) {
var count = 0;
while (FS.isLink(current.mode)) {
var link = FS.readlink(current_path);
current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
var lookup = FS.lookupPath(current_path, {
recurse_count: opts.recurse_count
});
current = lookup.node;
if (count++ > 40) {
throw new FS.ErrnoError(32);
}
}
}
}
return {
path: current_path,
node: current
};
},
getPath: function(node) {
var path;
while (true) {
if (FS.isRoot(node)) {
var mount = node.mount.mountpoint;
if (!path) return mount;
return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
}
path = path ? node.name + "/" + path : node.name;
node = node.parent;
}
},
hashName: function(parentid, name) {
var hash = 0;
for (var i = 0; i < name.length; i++) {
hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
}
return (parentid + hash >>> 0) % FS.nameTable.length;
},
hashAddNode: function(node) {
var hash = FS.hashName(node.parent.id, node.name);
node.name_next = FS.nameTable[hash];
FS.nameTable[hash] = node;
},
hashRemoveNode: function(node) {
var hash = FS.hashName(node.parent.id, node.name);
if (FS.nameTable[hash] === node) {
FS.nameTable[hash] = node.name_next;
} else {
var current = FS.nameTable[hash];
while (current) {
if (current.name_next === node) {
current.name_next = node.name_next;
break;
}
current = current.name_next;
}
}
},
lookupNode: function(parent, name) {
var errCode = FS.mayLookup(parent);
if (errCode) {
throw new FS.ErrnoError(errCode, parent);
}
var hash = FS.hashName(parent.id, name);
for (var node = FS.nameTable[hash]; node; node = node.name_next) {
var nodeName = node.name;
if (node.parent.id === parent.id && nodeName === name) {
return node;
}
}
return FS.lookup(parent, name);
},
createNode: function(parent, name, mode, rdev) {
var node = new FS.FSNode(parent, name, mode, rdev);
FS.hashAddNode(node);
return node;
},
destroyNode: function(node) {
FS.hashRemoveNode(node);
},
isRoot: function(node) {
return node === node.parent;
},
isMountpoint: function(node) {
return !!node.mounted;
},
isFile: function(mode) {
return (mode & 61440) === 32768;
},
isDir: function(mode) {
return (mode & 61440) === 16384;
},
isLink: function(mode) {
return (mode & 61440) === 40960;
},
isChrdev: function(mode) {
return (mode & 61440) === 8192;
},
isBlkdev: function(mode) {
return (mode & 61440) === 24576;
},
isFIFO: function(mode) {
return (mode & 61440) === 4096;
},
isSocket: function(mode) {
return (mode & 49152) === 49152;
},
flagModes: {
"r": 0,
"r+": 2,
"w": 577,
"w+": 578,
"a": 1089,
"a+": 1090
},
modeStringToFlags: function(str) {
var flags = FS.flagModes[str];
if (typeof flags === "undefined") {
throw new Error("Unknown file open mode: " + str);
}
return flags;
},
flagsToPermissionString: function(flag) {
var perms = [ "r", "w", "rw" ][flag & 3];
if (flag & 512) {
perms += "w";
}
return perms;
},
nodePermissions: function(node, perms) {
if (FS.ignorePermissions) {
return 0;
}
if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
return 2;
} else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
return 2;
} else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
return 2;
}
return 0;
},
mayLookup: function(dir) {
var errCode = FS.nodePermissions(dir, "x");
if (errCode) return errCode;
if (!dir.node_ops.lookup) return 2;
return 0;
},
mayCreate: function(dir, name) {
try {
var node = FS.lookupNode(dir, name);
return 20;
} catch (e) {}
return FS.nodePermissions(dir, "wx");
},
mayDelete: function(dir, name, isdir) {
var node;
try {
node = FS.lookupNode(dir, name);
} catch (e) {
return e.errno;
}
var errCode = FS.nodePermissions(dir, "wx");
if (errCode) {
return errCode;
}
if (isdir) {
if (!FS.isDir(node.mode)) {
return 54;
}
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
return 10;
}
} else {
if (FS.isDir(node.mode)) {
return 31;
}
}
return 0;
},
mayOpen: function(node, flags) {
if (!node) {
return 44;
}
if (FS.isLink(node.mode)) {
return 32;
} else if (FS.isDir(node.mode)) {
if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
return 31;
}
}
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
},
MAX_OPEN_FDS: 4096,
nextfd: function(fd_start, fd_end) {
fd_start = fd_start || 0;
fd_end = fd_end || FS.MAX_OPEN_FDS;
for (var fd = fd_start; fd <= fd_end; fd++) {
if (!FS.streams[fd]) {
return fd;
}
}
throw new FS.ErrnoError(33);
},
getStream: function(fd) {
return FS.streams[fd];
},
createStream: function(stream, fd_start, fd_end) {
if (!FS.FSStream) {
FS.FSStream = function() {};
FS.FSStream.prototype = {
object: {
get: function() {
return this.node;
},
set: function(val) {
this.node = val;
}
},
isRead: {
get: function() {
return (this.flags & 2097155) !== 1;
}
},
isWrite: {
get: function() {
return (this.flags & 2097155) !== 0;
}
},
isAppend: {
get: function() {
return this.flags & 1024;
}
}
};
}
var newStream = new FS.FSStream();
for (var p in stream) {
newStream[p] = stream[p];
}
stream = newStream;
var fd = FS.nextfd(fd_start, fd_end);
stream.fd = fd;
FS.streams[fd] = stream;
return stream;
},
closeStream: function(fd) {
FS.streams[fd] = null;
},
chrdev_stream_ops: {
open: function(stream) {
var device = FS.getDevice(stream.node.rdev);
stream.stream_ops = device.stream_ops;
if (stream.stream_ops.open) {
stream.stream_ops.open(stream);
}
},
llseek: function() {
throw new FS.ErrnoError(70);
}
},
major: function(dev) {
return dev >> 8;
},
minor: function(dev) {
return dev & 255;
},
makedev: function(ma, mi) {
return ma << 8 | mi;
},
registerDevice: function(dev, ops) {
FS.devices[dev] = {
stream_ops: ops
};
},
getDevice: function(dev) {
return FS.devices[dev];
},
getMounts: function(mount) {
var mounts = [];
var check = [ mount ];
while (check.length) {
var m = check.pop();
mounts.push(m);
check.push.apply(check, m.mounts);
}
return mounts;
},
syncfs: function(populate, callback) {
if (typeof populate === "function") {
callback = populate;
populate = false;
}
FS.syncFSRequests++;
if (FS.syncFSRequests > 1) {
err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work");
}
var mounts = FS.getMounts(FS.root.mount);
var completed = 0;
function doCallback(errCode) {
assert(FS.syncFSRequests > 0);
FS.syncFSRequests--;
return callback(errCode);
}
function done(errCode) {
if (errCode) {
if (!done.errored) {
done.errored = true;
return doCallback(errCode);
}
return;
}
if (++completed >= mounts.length) {
doCallback(null);
}
}
mounts.forEach(function(mount) {
if (!mount.type.syncfs) {
return done(null);
}
mount.type.syncfs(mount, populate, done);
});
},
mount: function(type, opts, mountpoint) {
if (typeof type === "string") {
throw type;
}
var root = mountpoint === "/";
var pseudo = !mountpoint;
var node;
if (root && FS.root) {
throw new FS.ErrnoError(10);
} else if (!root && !pseudo) {
var lookup = FS.lookupPath(mountpoint, {
follow_mount: false
});
mountpoint = lookup.path;
node = lookup.node;
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(10);
}
if (!FS.isDir(node.mode)) {
throw new FS.ErrnoError(54);
}
}
var mount = {
type: type,
opts: opts,
mountpoint: mountpoint,
mounts: []
};
var mountRoot = type.mount(mount);
mountRoot.mount = mount;
mount.root = mountRoot;
if (root) {
FS.root = mountRoot;
} else if (node) {
node.mounted = mount;
if (node.mount) {
node.mount.mounts.push(mount);
}
}
return mountRoot;
},
unmount: function(mountpoint) {
var lookup = FS.lookupPath(mountpoint, {
follow_mount: false
});
if (!FS.isMountpoint(lookup.node)) {
throw new FS.ErrnoError(28);
}
var node = lookup.node;
var mount = node.mounted;
var mounts = FS.getMounts(mount);
Object.keys(FS.nameTable).forEach(function(hash) {
var current = FS.nameTable[hash];
while (current) {
var next = current.name_next;
if (mounts.indexOf(current.mount) !== -1) {
FS.destroyNode(current);
}
current = next;
}
});
node.mounted = null;
var idx = node.mount.mounts.indexOf(mount);
assert(idx !== -1);
node.mount.mounts.splice(idx, 1);
},
lookup: function(parent, name) {
return parent.node_ops.lookup(parent, name);
},
mknod: function(path, mode, dev) {
var lookup = FS.lookupPath(path, {
parent: true
});
var parent = lookup.node;
var name = PATH.basename(path);
if (!name || name === "." || name === "..") {
throw new FS.ErrnoError(28);
}
var errCode = FS.mayCreate(parent, name);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
if (!parent.node_ops.mknod) {
throw new FS.ErrnoError(63);
}
return parent.node_ops.mknod(parent, name, mode, dev);
},
create: function(path, mode) {
mode = mode !== undefined ? mode : 438;
mode &= 4095;
mode |= 32768;
return FS.mknod(path, mode, 0);
},
mkdir: function(path, mode) {
mode = mode !== undefined ? mode : 511;
mode &= 511 | 512;
mode |= 16384;
return FS.mknod(path, mode, 0);
},
mkdirTree: function(path, mode) {
var dirs = path.split("/");
var d = "";
for (var i = 0; i < dirs.length; ++i) {
if (!dirs[i]) continue;
d += "/" + dirs[i];
try {
FS.mkdir(d, mode);
} catch (e) {
if (e.errno != 20) throw e;
}
}
},
mkdev: function(path, mode, dev) {
if (typeof dev === "undefined") {
dev = mode;
mode = 438;
}
mode |= 8192;
return FS.mknod(path, mode, dev);
},
symlink: function(oldpath, newpath) {
if (!PATH_FS.resolve(oldpath)) {
throw new FS.ErrnoError(44);
}
var lookup = FS.lookupPath(newpath, {
parent: true
});
var parent = lookup.node;
if (!parent) {
throw new FS.ErrnoError(44);
}
var newname = PATH.basename(newpath);
var errCode = FS.mayCreate(parent, newname);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
if (!parent.node_ops.symlink) {
throw new FS.ErrnoError(63);
}
return parent.node_ops.symlink(parent, newname, oldpath);
},
rename: function(old_path, new_path) {
var old_dirname = PATH.dirname(old_path);
var new_dirname = PATH.dirname(new_path);
var old_name = PATH.basename(old_path);
var new_name = PATH.basename(new_path);
var lookup, old_dir, new_dir;
lookup = FS.lookupPath(old_path, {
parent: true
});
old_dir = lookup.node;
lookup = FS.lookupPath(new_path, {
parent: true
});
new_dir = lookup.node;
if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
if (old_dir.mount !== new_dir.mount) {
throw new FS.ErrnoError(75);
}
var old_node = FS.lookupNode(old_dir, old_name);
var relative = PATH_FS.relative(old_path, new_dirname);
if (relative.charAt(0) !== ".") {
throw new FS.ErrnoError(28);
}
relative = PATH_FS.relative(new_path, old_dirname);
if (relative.charAt(0) !== ".") {
throw new FS.ErrnoError(55);
}
var new_node;
try {
new_node = FS.lookupNode(new_dir, new_name);
} catch (e) {}
if (old_node === new_node) {
return;
}
var isdir = FS.isDir(old_node.mode);
var errCode = FS.mayDelete(old_dir, old_name, isdir);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
if (!old_dir.node_ops.rename) {
throw new FS.ErrnoError(63);
}
if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
throw new FS.ErrnoError(10);
}
if (new_dir !== old_dir) {
errCode = FS.nodePermissions(old_dir, "w");
if (errCode) {
throw new FS.ErrnoError(errCode);
}
}
try {
if (FS.trackingDelegate["willMovePath"]) {
FS.trackingDelegate["willMovePath"](old_path, new_path);
}
} catch (e) {
err("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
}
FS.hashRemoveNode(old_node);
try {
old_dir.node_ops.rename(old_node, new_dir, new_name);
} catch (e) {
throw e;
} finally {
FS.hashAddNode(old_node);
}
try {
if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path);
} catch (e) {
err("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
}
},
rmdir: function(path) {
var lookup = FS.lookupPath(path, {
parent: true
});
var parent = lookup.node;
var name = PATH.basename(path);
var node = FS.lookupNode(parent, name);
var errCode = FS.mayDelete(parent, name, true);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
if (!parent.node_ops.rmdir) {
throw new FS.ErrnoError(63);
}
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(10);
}
try {
if (FS.trackingDelegate["willDeletePath"]) {
FS.trackingDelegate["willDeletePath"](path);
}
} catch (e) {
err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
}
parent.node_ops.rmdir(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
} catch (e) {
err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
}
},
readdir: function(path) {
var lookup = FS.lookupPath(path, {
follow: true
});
var node = lookup.node;
if (!node.node_ops.readdir) {
throw new FS.ErrnoError(54);
}
return node.node_ops.readdir(node);
},
unlink: function(path) {
var lookup = FS.lookupPath(path, {
parent: true
});
var parent = lookup.node;
var name = PATH.basename(path);
var node = FS.lookupNode(parent, name);
var errCode = FS.mayDelete(parent, name, false);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
if (!parent.node_ops.unlink) {
throw new FS.ErrnoError(63);
}
if (FS.isMountpoint(node)) {
throw new FS.ErrnoError(10);
}
try {
if (FS.trackingDelegate["willDeletePath"]) {
FS.trackingDelegate["willDeletePath"](path);
}
} catch (e) {
err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
}
parent.node_ops.unlink(parent, name);
FS.destroyNode(node);
try {
if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
} catch (e) {
err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
}
},
readlink: function(path) {
var lookup = FS.lookupPath(path);
var link = lookup.node;
if (!link) {
throw new FS.ErrnoError(44);
}
if (!link.node_ops.readlink) {
throw new FS.ErrnoError(28);
}
return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
},
stat: function(path, dontFollow) {
var lookup = FS.lookupPath(path, {
follow: !dontFollow
});
var node = lookup.node;
if (!node) {
throw new FS.ErrnoError(44);
}
if (!node.node_ops.getattr) {
throw new FS.ErrnoError(63);
}
return node.node_ops.getattr(node);
},
lstat: function(path) {
return FS.stat(path, true);
},
chmod: function(path, mode, dontFollow) {
var node;
if (typeof path === "string") {
var lookup = FS.lookupPath(path, {
follow: !dontFollow
});
node = lookup.node;
} else {
node = path;
}
if (!node.node_ops.setattr) {
throw new FS.ErrnoError(63);
}
node.node_ops.setattr(node, {
mode: mode & 4095 | node.mode & ~4095,
timestamp: Date.now()
});
},
lchmod: function(path, mode) {
FS.chmod(path, mode, true);
},
fchmod: function(fd, mode) {
var stream = FS.getStream(fd);
if (!stream) {
throw new FS.ErrnoError(8);
}
FS.chmod(stream.node, mode);
},
chown: function(path, uid, gid, dontFollow) {
var node;
if (typeof path === "string") {
var lookup = FS.lookupPath(path, {
follow: !dontFollow
});
node = lookup.node;
} else {
node = path;
}
if (!node.node_ops.setattr) {
throw new FS.ErrnoError(63);
}
node.node_ops.setattr(node, {
timestamp: Date.now()
});
},
lchown: function(path, uid, gid) {
FS.chown(path, uid, gid, true);
},
fchown: function(fd, uid, gid) {
var stream = FS.getStream(fd);
if (!stream) {
throw new FS.ErrnoError(8);
}
FS.chown(stream.node, uid, gid);
},
truncate: function(path, len) {
if (len < 0) {
throw new FS.ErrnoError(28);
}
var node;
if (typeof path === "string") {
var lookup = FS.lookupPath(path, {
follow: true
});
node = lookup.node;
} else {
node = path;
}
if (!node.node_ops.setattr) {
throw new FS.ErrnoError(63);
}
if (FS.isDir(node.mode)) {
throw new FS.ErrnoError(31);
}
if (!FS.isFile(node.mode)) {
throw new FS.ErrnoError(28);
}
var errCode = FS.nodePermissions(node, "w");
if (errCode) {
throw new FS.ErrnoError(errCode);
}
node.node_ops.setattr(node, {
size: len,
timestamp: Date.now()
});
},
ftruncate: function(fd, len) {
var stream = FS.getStream(fd);
if (!stream) {
throw new FS.ErrnoError(8);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(28);
}
FS.truncate(stream.node, len);
},
utime: function(path, atime, mtime) {
var lookup = FS.lookupPath(path, {
follow: true
});
var node = lookup.node;
node.node_ops.setattr(node, {
timestamp: Math.max(atime, mtime)
});
},
open: function(path, flags, mode, fd_start, fd_end) {
if (path === "") {
throw new FS.ErrnoError(44);
}
flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
mode = typeof mode === "undefined" ? 438 : mode;
if (flags & 64) {
mode = mode & 4095 | 32768;
} else {
mode = 0;
}
var node;
if (typeof path === "object") {
node = path;
} else {
path = PATH.normalize(path);
try {
var lookup = FS.lookupPath(path, {
follow: !(flags & 131072)
});
node = lookup.node;
} catch (e) {}
}
var created = false;
if (flags & 64) {
if (node) {
if (flags & 128) {
throw new FS.ErrnoError(20);
}
} else {
node = FS.mknod(path, mode, 0);
created = true;
}
}
if (!node) {
throw new FS.ErrnoError(44);
}
if (FS.isChrdev(node.mode)) {
flags &= ~512;
}
if (flags & 65536 && !FS.isDir(node.mode)) {
throw new FS.ErrnoError(54);
}
if (!created) {
var errCode = FS.mayOpen(node, flags);
if (errCode) {
throw new FS.ErrnoError(errCode);
}
}
if (flags & 512) {
FS.truncate(node, 0);
}
flags &= ~(128 | 512 | 131072);
var stream = FS.createStream({
node: node,
path: FS.getPath(node),
flags: flags,
seekable: true,
position: 0,
stream_ops: node.stream_ops,
ungotten: [],
error: false
}, fd_start, fd_end);
if (stream.stream_ops.open) {
stream.stream_ops.open(stream);
}
if (Module["logReadFiles"] && !(flags & 1)) {
if (!FS.readFiles) FS.readFiles = {};
if (!(path in FS.readFiles)) {
FS.readFiles[path] = 1;
err("FS.trackingDelegate error on read file: " + path);
}
}
try {
if (FS.trackingDelegate["onOpenFile"]) {
var trackingFlags = 0;
if ((flags & 2097155) !== 1) {
trackingFlags |= FS.tracking.openFlags.READ;
}
if ((flags & 2097155) !== 0) {
trackingFlags |= FS.tracking.openFlags.WRITE;
}
FS.trackingDelegate["onOpenFile"](path, trackingFlags);
}
} catch (e) {
err("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message);
}
return stream;
},
close: function(stream) {
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(8);
}
if (stream.getdents) stream.getdents = null;
try {
if (stream.stream_ops.close) {
stream.stream_ops.close(stream);
}
} catch (e) {
throw e;
} finally {
FS.closeStream(stream.fd);
}
stream.fd = null;
},
isClosed: function(stream) {
return stream.fd === null;
},
llseek: function(stream, offset, whence) {
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(8);
}
if (!stream.seekable || !stream.stream_ops.llseek) {
throw new FS.ErrnoError(70);
}
if (whence != 0 && whence != 1 && whence != 2) {
throw new FS.ErrnoError(28);
}
stream.position = stream.stream_ops.llseek(stream, offset, whence);
stream.ungotten = [];
return stream.position;
},
read: function(stream, buffer, offset, length, position) {
if (length < 0 || position < 0) {
throw new FS.ErrnoError(28);
}
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(8);
}
if ((stream.flags & 2097155) === 1) {
throw new FS.ErrnoError(8);
}
if (FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(31);
}
if (!stream.stream_ops.read) {
throw new FS.ErrnoError(28);
}
var seeking = typeof position !== "undefined";
if (!seeking) {
position = stream.position;
} else if (!stream.seekable) {
throw new FS.ErrnoError(70);
}
var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
if (!seeking) stream.position += bytesRead;
return bytesRead;
},
write: function(stream, buffer, offset, length, position, canOwn) {
if (length < 0 || position < 0) {
throw new FS.ErrnoError(28);
}
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(8);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(8);
}
if (FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(31);
}
if (!stream.stream_ops.write) {
throw new FS.ErrnoError(28);
}
if (stream.seekable && stream.flags & 1024) {
FS.llseek(stream, 0, 2);
}
var seeking = typeof position !== "undefined";
if (!seeking) {
position = stream.position;
} else if (!stream.seekable) {
throw new FS.ErrnoError(70);
}
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
if (!seeking) stream.position += bytesWritten;
try {
if (stream.path && FS.trackingDelegate["onWriteToFile"]) FS.trackingDelegate["onWriteToFile"](stream.path);
} catch (e) {
err("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message);
}
return bytesWritten;
},
allocate: function(stream, offset, length) {
if (FS.isClosed(stream)) {
throw new FS.ErrnoError(8);
}
if (offset < 0 || length <= 0) {
throw new FS.ErrnoError(28);
}
if ((stream.flags & 2097155) === 0) {
throw new FS.ErrnoError(8);
}
if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
throw new FS.ErrnoError(43);
}
if (!stream.stream_ops.allocate) {
throw new FS.ErrnoError(138);
}
stream.stream_ops.allocate(stream, offset, length);
},
mmap: function(stream, address, length, position, prot, flags) {
if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
throw new FS.ErrnoError(2);
}
if ((stream.flags & 2097155) === 1) {
throw new FS.ErrnoError(2);
}
if (!stream.stream_ops.mmap) {
throw new FS.ErrnoError(43);
}
return stream.stream_ops.mmap(stream, address, length, position, prot, flags);
},
msync: function(stream, buffer, offset, length, mmapFlags) {
if (!stream || !stream.stream_ops.msync) {
return 0;
}
return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
},
munmap: function(stream) {
return 0;
},
ioctl: function(stream, cmd, arg) {
if (!stream.stream_ops.ioctl) {
throw new FS.ErrnoError(59);
}
return stream.stream_ops.ioctl(stream, cmd, arg);
},
readFile: function(path, opts) {
opts = opts || {};
opts.flags = opts.flags || 0;
opts.encoding = opts.encoding || "binary";
if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
throw new Error('Invalid encoding type "' + opts.encoding + '"');
}
var ret;
var stream = FS.open(path, opts.flags);
var stat = FS.stat(path);
var length = stat.size;
var buf = new Uint8Array(length);
FS.read(stream, buf, 0, length, 0);
if (opts.encoding === "utf8") {
ret = UTF8ArrayToString(buf, 0);
} else if (opts.encoding === "binary") {
ret = buf;
}
FS.close(stream);
return ret;
},
writeFile: function(path, data, opts) {
opts = opts || {};
opts.flags = opts.flags || 577;
var stream = FS.open(path, opts.flags, opts.mode);
if (typeof data === "string") {
var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
} else if (ArrayBuffer.isView(data)) {
FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
} else {
throw new Error("Unsupported data type");
}
FS.close(stream);
},
cwd: function() {
return FS.currentPath;
},
chdir: function(path) {
var lookup = FS.lookupPath(path, {
follow: true
});
if (lookup.node === null) {
throw new FS.ErrnoError(44);
}
if (!FS.isDir(lookup.node.mode)) {
throw new FS.ErrnoError(54);
}
var errCode = FS.nodePermissions(lookup.node, "x");
if (errCode) {
throw new FS.ErrnoError(errCode);
}
FS.currentPath = lookup.path;
},
createDefaultDirectories: function() {
FS.mkdir("/tmp");
FS.mkdir("/home");
FS.mkdir("/home/web_user");
},
createDefaultDevices: function() {
FS.mkdir("/dev");
FS.registerDevice(FS.makedev(1, 3), {
read: function() {
return 0;
},
write: function(stream, buffer, offset, length, pos) {
return length;
}
});
FS.mkdev("/dev/null", FS.makedev(1, 3));
TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
FS.mkdev("/dev/tty", FS.makedev(5, 0));
FS.mkdev("/dev/tty1", FS.makedev(6, 0));
var random_device = getRandomDevice();
FS.createDevice("/dev", "random", random_device);
FS.createDevice("/dev", "urandom", random_device);
FS.mkdir("/dev/shm");
FS.mkdir("/dev/shm/tmp");
},
createSpecialDirectories: function() {
FS.mkdir("/proc");
FS.mkdir("/proc/self");
FS.mkdir("/proc/self/fd");
FS.mount({
mount: function() {
var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73);
node.node_ops = {
lookup: function(parent, name) {
var fd = +name;
var stream = FS.getStream(fd);
if (!stream) throw new FS.ErrnoError(8);
var ret = {
parent: null,
mount: {
mountpoint: "fake"
},
node_ops: {
readlink: function() {
return stream.path;
}
}
};
ret.parent = ret;
return ret;
}
};
return node;
}
}, {}, "/proc/self/fd");
},
createStandardStreams: function() {
if (Module["stdin"]) {
FS.createDevice("/dev", "stdin", Module["stdin"]);
} else {
FS.symlink("/dev/tty", "/dev/stdin");
}
if (Module["stdout"]) {
FS.createDevice("/dev", "stdout", null, Module["stdout"]);
} else {
FS.symlink("/dev/tty", "/dev/stdout");
}
if (Module["stderr"]) {
FS.createDevice("/dev", "stderr", null, Module["stderr"]);
} else {
FS.symlink("/dev/tty1", "/dev/stderr");
}
var stdin = FS.open("/dev/stdin", 0);
var stdout = FS.open("/dev/stdout", 1);
var stderr = FS.open("/dev/stderr", 1);
assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")");
},
ensureErrnoError: function() {
if (FS.ErrnoError) return;
FS.ErrnoError = function ErrnoError(errno, node) {
this.node = node;
this.setErrno = function(errno) {
this.errno = errno;
for (var key in ERRNO_CODES) {
if (ERRNO_CODES[key] === errno) {
this.code = key;
break;
}
}
};
this.setErrno(errno);
this.message = ERRNO_MESSAGES[errno];
if (this.stack) {
Object.defineProperty(this, "stack", {
value: new Error().stack,
writable: true
});
this.stack = demangleAll(this.stack);
}
};
FS.ErrnoError.prototype = new Error();
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
[ 44 ].forEach(function(code) {
FS.genericErrors[code] = new FS.ErrnoError(code);
FS.genericErrors[code].stack = "<generic error, no stack>";
});
},
staticInit: function() {
FS.ensureErrnoError();
FS.nameTable = new Array(4096);
FS.mount(MEMFS, {}, "/");
FS.createDefaultDirectories();
FS.createDefaultDevices();
FS.createSpecialDirectories();
FS.filesystems = {
"MEMFS": MEMFS
};
},
init: function(input, output, error) {
assert(!FS.init.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
FS.init.initialized = true;
FS.ensureErrnoError();
Module["stdin"] = input || Module["stdin"];
Module["stdout"] = output || Module["stdout"];
Module["stderr"] = error || Module["stderr"];
FS.createStandardStreams();
},
quit: function() {
FS.init.initialized = false;
var fflush = Module["_fflush"];
if (fflush) fflush(0);
for (var i = 0; i < FS.streams.length; i++) {
var stream = FS.streams[i];
if (!stream) {
continue;
}
FS.close(stream);
}
},
getMode: function(canRead, canWrite) {
var mode = 0;
if (canRead) mode |= 292 | 73;
if (canWrite) mode |= 146;
return mode;
},
findObject: function(path, dontResolveLastLink) {
var ret = FS.analyzePath(path, dontResolveLastLink);
if (ret.exists) {
return ret.object;
} else {
return null;
}
},
analyzePath: function(path, dontResolveLastLink) {
try {
var lookup = FS.lookupPath(path, {
follow: !dontResolveLastLink
});
path = lookup.path;
} catch (e) {}
var ret = {
isRoot: false,
exists: false,
error: 0,
name: null,
path: null,
object: null,
parentExists: false,
parentPath: null,
parentObject: null
};
try {
var lookup = FS.lookupPath(path, {
parent: true
});
ret.parentExists = true;
ret.parentPath = lookup.path;
ret.parentObject = lookup.node;
ret.name = PATH.basename(path);
lookup = FS.lookupPath(path, {
follow: !dontResolveLastLink
});
ret.exists = true;
ret.path = lookup.path;
ret.object = lookup.node;
ret.name = lookup.node.name;
ret.isRoot = lookup.path === "/";
} catch (e) {
ret.error = e.errno;
}
return ret;
},
createPath: function(parent, path, canRead, canWrite) {
parent = typeof parent === "string" ? parent : FS.getPath(parent);
var parts = path.split("/").reverse();
while (parts.length) {
var part = parts.pop();
if (!part) continue;
var current = PATH.join2(parent, part);
try {
FS.mkdir(current);
} catch (e) {}
parent = current;
}
return current;
},
createFile: function(parent, name, properties, canRead, canWrite) {
var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
var mode = FS.getMode(canRead, canWrite);
return FS.create(path, mode);
},
createDataFile: function(parent, name, data, canRead, canWrite, canOwn) {
var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name) : parent;
var mode = FS.getMode(canRead, canWrite);
var node = FS.create(path, mode);
if (data) {
if (typeof data === "string") {
var arr = new Array(data.length);
for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
data = arr;
}
FS.chmod(node, mode | 146);
var stream = FS.open(node, 577);
FS.write(stream, data, 0, data.length, 0, canOwn);
FS.close(stream);
FS.chmod(node, mode);
}
return node;
},
createDevice: function(parent, name, input, output) {
var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
var mode = FS.getMode(!!input, !!output);
if (!FS.createDevice.major) FS.createDevice.major = 64;
var dev = FS.makedev(FS.createDevice.major++, 0);
FS.registerDevice(dev, {
open: function(stream) {
stream.seekable = false;
},
close: function(stream) {
if (output && output.buffer && output.buffer.length) {
output(10);
}
},
read: function(stream, buffer, offset, length, pos) {
var bytesRead = 0;
for (var i = 0; i < length; i++) {
var result;
try {
result = input();
} catch (e) {
throw new FS.ErrnoError(29);
}
if (result === undefined && bytesRead === 0) {
throw new FS.ErrnoError(6);
}
if (result === null || result === undefined) break;
bytesRead++;
buffer[offset + i] = result;
}
if (bytesRead) {
stream.node.timestamp = Date.now();
}
return bytesRead;
},
write: function(stream, buffer, offset, length, pos) {
for (var i = 0; i < length; i++) {
try {
output(buffer[offset + i]);
} catch (e) {
throw new FS.ErrnoError(29);
}
}
if (length) {
stream.node.timestamp = Date.now();
}
return i;
}
});
return FS.mkdev(path, mode, dev);
},
forceLoadFile: function(obj) {
if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
if (typeof XMLHttpRequest !== "undefined") {
throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
} else if (read_) {
try {
obj.contents = intArrayFromString(read_(obj.url), true);
obj.usedBytes = obj.contents.length;
} catch (e) {
throw new FS.ErrnoError(29);
}
} else {
throw new Error("Cannot load without read() or XMLHttpRequest.");
}
},
createLazyFile: function(parent, name, url, canRead, canWrite) {
function LazyUint8Array() {
this.lengthKnown = false;
this.chunks = [];
}
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
if (idx > this.length - 1 || idx < 0) {
return undefined;
}
var chunkOffset = idx % this.chunkSize;
var chunkNum = idx / this.chunkSize | 0;
return this.getter(chunkNum)[chunkOffset];
};
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
this.getter = getter;
};
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
var xhr = new XMLHttpRequest();
xhr.open("HEAD", url, false);
xhr.send(null);
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
var datalength = Number(xhr.getResponseHeader("Content-length"));
var header;
var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
var chunkSize = 1024 * 1024;
if (!hasByteServing) chunkSize = datalength;
var doXHR = function(from, to) {
if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
if (typeof Uint8Array != "undefined") xhr.responseType = "arraybuffer";
if (xhr.overrideMimeType) {
xhr.overrideMimeType("text/plain; charset=x-user-defined");
}
xhr.send(null);
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
if (xhr.response !== undefined) {
return new Uint8Array(xhr.response || []);
} else {
return intArrayFromString(xhr.responseText || "", true);
}
};
var lazyArray = this;
lazyArray.setDataGetter(function(chunkNum) {
var start = chunkNum * chunkSize;
var end = (chunkNum + 1) * chunkSize - 1;
end = Math.min(end, datalength - 1);
if (typeof lazyArray.chunks[chunkNum] === "undefined") {
lazyArray.chunks[chunkNum] = doXHR(start, end);
}
if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
return lazyArray.chunks[chunkNum];
});
if (usesGzip || !datalength) {
chunkSize = datalength = 1;
datalength = this.getter(0).length;
chunkSize = datalength;
out("LazyFiles on gzip forces download of the whole file when length is accessed");
}
this._length = datalength;
this._chunkSize = chunkSize;
this.lengthKnown = true;
};
if (typeof XMLHttpRequest !== "undefined") {
if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
var lazyArray = new LazyUint8Array();
Object.defineProperties(lazyArray, {
length: {
get: function() {
if (!this.lengthKnown) {
this.cacheLength();
}
return this._length;
}
},
chunkSize: {
get: function() {
if (!this.lengthKnown) {
this.cacheLength();
}
return this._chunkSize;
}
}
});
var properties = {
isDevice: false,
contents: lazyArray
};
} else {
var properties = {
isDevice: false,
url: url
};
}
var node = FS.createFile(parent, name, properties, canRead, canWrite);
if (properties.contents) {
node.contents = properties.contents;
} else if (properties.url) {
node.contents = null;
node.url = properties.url;
}
Object.defineProperties(node, {
usedBytes: {
get: function() {
return this.contents.length;
}
}
});
var stream_ops = {};
var keys = Object.keys(node.stream_ops);
keys.forEach(function(key) {
var fn = node.stream_ops[key];
stream_ops[key] = function forceLoadLazyFile() {
FS.forceLoadFile(node);
return fn.apply(null, arguments);
};
});
stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
FS.forceLoadFile(node);
var contents = stream.node.contents;
if (position >= contents.length) return 0;
var size = Math.min(contents.length - position, length);
assert(size >= 0);
if (contents.slice) {
for (var i = 0; i < size; i++) {
buffer[offset + i] = contents[position + i];
}
} else {
for (var i = 0; i < size; i++) {
buffer[offset + i] = contents.get(position + i);
}
}
return size;
};
node.stream_ops = stream_ops;
return node;
},
createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
Browser.init();
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
var dep = getUniqueRunDependency("cp " + fullname);
function processData(byteArray) {
function finish(byteArray) {
if (preFinish) preFinish();
if (!dontCreateFile) {
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
}
if (onload) onload();
removeRunDependency(dep);
}
var handled = false;
Module["preloadPlugins"].forEach(function(plugin) {
if (handled) return;
if (plugin["canHandle"](fullname)) {
plugin["handle"](byteArray, fullname, finish, function() {
if (onerror) onerror();
removeRunDependency(dep);
});
handled = true;
}
});
if (!handled) finish(byteArray);
}
addRunDependency(dep);
if (typeof url == "string") {
Browser.asyncLoad(url, function(byteArray) {
processData(byteArray);
}, onerror);
} else {
processData(url);
}
},
indexedDB: function() {
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
},
DB_NAME: function() {
return "EM_FS_" + window.location.pathname;
},
DB_VERSION: 20,
DB_STORE_NAME: "FILE_DATA",
saveFilesToDB: function(paths, onload, onerror) {
onload = onload || function() {};
onerror = onerror || function() {};
var indexedDB = FS.indexedDB();
try {
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
} catch (e) {
return onerror(e);
}
openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
out("creating db");
var db = openRequest.result;
db.createObjectStore(FS.DB_STORE_NAME);
};
openRequest.onsuccess = function openRequest_onsuccess() {
var db = openRequest.result;
var transaction = db.transaction([ FS.DB_STORE_NAME ], "readwrite");
var files = transaction.objectStore(FS.DB_STORE_NAME);
var ok = 0, fail = 0, total = paths.length;
function finish() {
if (fail == 0) onload(); else onerror();
}
paths.forEach(function(path) {
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
putRequest.onsuccess = function putRequest_onsuccess() {
ok++;
if (ok + fail == total) finish();
};
putRequest.onerror = function putRequest_onerror() {
fail++;
if (ok + fail == total) finish();
};
});
transaction.onerror = onerror;
};
openRequest.onerror = onerror;
},
loadFilesFromDB: function(paths, onload, onerror) {
onload = onload || function() {};
onerror = onerror || function() {};
var indexedDB = FS.indexedDB();
try {
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
} catch (e) {
return onerror(e);
}
openRequest.onupgradeneeded = onerror;
openRequest.onsuccess = function openRequest_onsuccess() {
var db = openRequest.result;
try {
var transaction = db.transaction([ FS.DB_STORE_NAME ], "readonly");
} catch (e) {
onerror(e);
return;
}
var files = transaction.objectStore(FS.DB_STORE_NAME);
var ok = 0, fail = 0, total = paths.length;
function finish() {
if (fail == 0) onload(); else onerror();
}
paths.forEach(function(path) {
var getRequest = files.get(path);
getRequest.onsuccess = function getRequest_onsuccess() {
if (FS.analyzePath(path).exists) {
FS.unlink(path);
}
FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
ok++;
if (ok + fail == total) finish();
};
getRequest.onerror = function getRequest_onerror() {
fail++;
if (ok + fail == total) finish();
};
});
transaction.onerror = onerror;
};
openRequest.onerror = onerror;
},
absolutePath: function() {
abort("FS.absolutePath has been removed; use PATH_FS.resolve instead");
},
createFolder: function() {
abort("FS.createFolder has been removed; use FS.mkdir instead");
},
createLink: function() {
abort("FS.createLink has been removed; use FS.symlink instead");
},
joinPath: function() {
abort("FS.joinPath has been removed; use PATH.join instead");
},
mmapAlloc: function() {
abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc");
},
standardizePath: function() {
abort("FS.standardizePath has been removed; use PATH.normalize instead");
}
};
var SYSCALLS = {
mappings: {},
DEFAULT_POLLMASK: 5,
umask: 511,
calculateAt: function(dirfd, path) {
if (path[0] !== "/") {
var dir;
if (dirfd === -100) {
dir = FS.cwd();
} else {
var dirstream = FS.getStream(dirfd);
if (!dirstream) throw new FS.ErrnoError(8);
dir = dirstream.path;
}
path = PATH.join2(dir, path);
}
return path;
},
doStat: function(func, path, buf) {
try {
var stat = func(path);
} catch (e) {
if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
return -54;
}
throw e;
}
SAFE_HEAP_STORE(buf | 0, stat.dev | 0, 4);
SAFE_HEAP_STORE(buf + 4 | 0, 0 | 0, 4);
SAFE_HEAP_STORE(buf + 8 | 0, stat.ino | 0, 4);
SAFE_HEAP_STORE(buf + 12 | 0, stat.mode | 0, 4);
SAFE_HEAP_STORE(buf + 16 | 0, stat.nlink | 0, 4);
SAFE_HEAP_STORE(buf + 20 | 0, stat.uid | 0, 4);
SAFE_HEAP_STORE(buf + 24 | 0, stat.gid | 0, 4);
SAFE_HEAP_STORE(buf + 28 | 0, stat.rdev | 0, 4);
SAFE_HEAP_STORE(buf + 32 | 0, 0 | 0, 4);
tempI64 = [ stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
SAFE_HEAP_STORE(buf + 40 | 0, tempI64[0] | 0, 4), SAFE_HEAP_STORE(buf + 44 | 0, tempI64[1] | 0, 4);
SAFE_HEAP_STORE(buf + 48 | 0, 4096 | 0, 4);
SAFE_HEAP_STORE(buf + 52 | 0, stat.blocks | 0, 4);
SAFE_HEAP_STORE(buf + 56 | 0, stat.atime.getTime() / 1e3 | 0 | 0, 4);
SAFE_HEAP_STORE(buf + 60 | 0, 0 | 0, 4);
SAFE_HEAP_STORE(buf + 64 | 0, stat.mtime.getTime() / 1e3 | 0 | 0, 4);
SAFE_HEAP_STORE(buf + 68 | 0, 0 | 0, 4);
SAFE_HEAP_STORE(buf + 72 | 0, stat.ctime.getTime() / 1e3 | 0 | 0, 4);
SAFE_HEAP_STORE(buf + 76 | 0, 0 | 0, 4);
tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
SAFE_HEAP_STORE(buf + 80 | 0, tempI64[0] | 0, 4), SAFE_HEAP_STORE(buf + 84 | 0, tempI64[1] | 0, 4);
return 0;
},
doMsync: function(addr, stream, len, flags, offset) {
var buffer = HEAPU8.slice(addr, addr + len);
FS.msync(stream, buffer, offset, len, flags);
},
doMkdir: function(path, mode) {
path = PATH.normalize(path);
if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
FS.mkdir(path, mode, 0);
return 0;
},
doMknod: function(path, mode, dev) {
switch (mode & 61440) {
case 32768:
case 8192:
case 24576:
case 4096:
case 49152:
break;
default:
return -28;
}
FS.mknod(path, mode, dev);
return 0;
},
doReadlink: function(path, buf, bufsize) {
if (bufsize <= 0) return -28;
var ret = FS.readlink(path);
var len = Math.min(bufsize, lengthBytesUTF8(ret));
var endChar = SAFE_HEAP_LOAD(buf + len, 1, 0);
stringToUTF8(ret, buf, bufsize + 1);
SAFE_HEAP_STORE(buf + len, endChar, 1);
return len;
},
doAccess: function(path, amode) {
if (amode & ~7) {
return -28;
}
var node;
var lookup = FS.lookupPath(path, {
follow: true
});
node = lookup.node;
if (!node) {
return -44;
}
var perms = "";
if (amode & 4) perms += "r";
if (amode & 2) perms += "w";
if (amode & 1) perms += "x";
if (perms && FS.nodePermissions(node, perms)) {
return -2;
}
return 0;
},
doDup: function(path, flags, suggestFD) {
var suggest = FS.getStream(suggestFD);
if (suggest) FS.close(suggest);
return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
},
doReadv: function(stream, iov, iovcnt, offset) {
var ret = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = SAFE_HEAP_LOAD(iov + i * 8 | 0, 4, 0) | 0;
var len = SAFE_HEAP_LOAD(iov + (i * 8 + 4) | 0, 4, 0) | 0;
var curr = FS.read(stream, HEAP8, ptr, len, offset);
if (curr < 0) return -1;
ret += curr;
if (curr < len) break;
}
return ret;
},
doWritev: function(stream, iov, iovcnt, offset) {
var ret = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = SAFE_HEAP_LOAD(iov + i * 8 | 0, 4, 0) | 0;
var len = SAFE_HEAP_LOAD(iov + (i * 8 + 4) | 0, 4, 0) | 0;
var curr = FS.write(stream, HEAP8, ptr, len, offset);
if (curr < 0) return -1;
ret += curr;
}
return ret;
},
varargs: undefined,
get: function() {
assert(SYSCALLS.varargs != undefined);
SYSCALLS.varargs += 4;
var ret = SAFE_HEAP_LOAD(SYSCALLS.varargs - 4 | 0, 4, 0) | 0;
return ret;
},
getStr: function(ptr) {
var ret = UTF8ToString(ptr);
return ret;
},
getStreamFromFD: function(fd) {
var stream = FS.getStream(fd);
if (!stream) throw new FS.ErrnoError(8);
return stream;
},
get64: function(low, high) {
if (low >= 0) assert(high === 0); else assert(high === -1);
return low;
}
};
function ___sys_fcntl64(fd, cmd, varargs) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(1, 1, fd, cmd, varargs);
SYSCALLS.varargs = varargs;
try {
var stream = SYSCALLS.getStreamFromFD(fd);
switch (cmd) {
case 0:
{
var arg = SYSCALLS.get();
if (arg < 0) {
return -28;
}
var newStream;
newStream = FS.open(stream.path, stream.flags, 0, arg);
return newStream.fd;
}
case 1:
case 2:
return 0;
case 3:
return stream.flags;
case 4:
{
var arg = SYSCALLS.get();
stream.flags |= arg;
return 0;
}
case 12:
{
var arg = SYSCALLS.get();
var offset = 0;
SAFE_HEAP_STORE(arg + offset | 0, 2 | 0, 2);
return 0;
}
case 13:
case 14:
return 0;
case 16:
case 8:
return -28;
case 9:
setErrNo(28);
return -1;
default:
{
return -28;
}
}
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___sys_ioctl(fd, op, varargs) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(2, 1, fd, op, varargs);
SYSCALLS.varargs = varargs;
try {
var stream = SYSCALLS.getStreamFromFD(fd);
switch (op) {
case 21509:
case 21505:
{
if (!stream.tty) return -59;
return 0;
}
case 21510:
case 21511:
case 21512:
case 21506:
case 21507:
case 21508:
{
if (!stream.tty) return -59;
return 0;
}
case 21519:
{
if (!stream.tty) return -59;
var argp = SYSCALLS.get();
SAFE_HEAP_STORE(argp | 0, 0 | 0, 4);
return 0;
}
case 21520:
{
if (!stream.tty) return -59;
return -28;
}
case 21531:
{
var argp = SYSCALLS.get();
return FS.ioctl(stream, op, argp);
}
case 21523:
{
if (!stream.tty) return -59;
return 0;
}
case 21524:
{
if (!stream.tty) return -59;
return 0;
}
default:
abort("bad ioctl syscall " + op);
}
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___sys_open(path, flags, varargs) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(3, 1, path, flags, varargs);
SYSCALLS.varargs = varargs;
try {
var pathname = SYSCALLS.getStr(path);
var mode = varargs ? SYSCALLS.get() : 0;
var stream = FS.open(pathname, flags, mode);
return stream.fd;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___sys_rmdir(path) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(4, 1, path);
try {
path = SYSCALLS.getStr(path);
FS.rmdir(path);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function ___sys_unlink(path) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(5, 1, path);
try {
path = SYSCALLS.getStr(path);
FS.unlink(path);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return -e.errno;
}
}
function __emscripten_notify_thread_queue(targetThreadId, mainThreadId) {
if (targetThreadId == mainThreadId) {
postMessage({
"cmd": "processQueuedMainThreadWork"
});
} else if (ENVIRONMENT_IS_PTHREAD) {
postMessage({
"targetThread": targetThreadId,
"cmd": "processThreadQueue"
});
} else {
var pthread = PThread.pthreads[targetThreadId];
var worker = pthread && pthread.worker;
if (!worker) {
err("Cannot send message to thread with ID " + targetThreadId + ", unknown thread ID!");
return;
}
worker.postMessage({
"cmd": "processThreadQueue"
});
}
return 1;
}
function _abort() {
abort();
}
function _dlerror() {
abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
}
function _dlopen(filename, flag) {
abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
}
function _dlsym(handle, symbol) {
abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
}
function _emscripten_asm_const_int(code, sigPtr, argbuf) {
var args = readAsmConstArgs(sigPtr, argbuf);
return ASM_CONSTS[code].apply(null, args);
}
function _emscripten_check_blocking_allowed() {
if (ENVIRONMENT_IS_NODE) return;
if (ENVIRONMENT_IS_WORKER) return;
warnOnce("Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread");
}
function _emscripten_conditional_set_current_thread_status_js(expectedStatus, newStatus) {}
function _emscripten_conditional_set_current_thread_status(expectedStatus, newStatus) {}
function _emscripten_futex_wait(addr, val, timeout) {
if (addr <= 0 || addr > HEAP8.length || addr & 3 != 0) return -28;
if (!ENVIRONMENT_IS_WEB) {
var ret = Atomics.wait(HEAP32, addr >> 2, val, timeout);
if (ret === "timed-out") return -73;
if (ret === "not-equal") return -6;
if (ret === "ok") return 0;
throw "Atomics.wait returned an unexpected value " + ret;
} else {
if (Atomics.load(HEAP32, addr >> 2) != val) {
return -6;
}
var tNow = performance.now();
var tEnd = tNow + timeout;
assert(__emscripten_main_thread_futex > 0);
var lastAddr = Atomics.exchange(HEAP32, __emscripten_main_thread_futex >> 2, addr);
assert(lastAddr == 0);
while (1) {
tNow = performance.now();
if (tNow > tEnd) {
lastAddr = Atomics.exchange(HEAP32, __emscripten_main_thread_futex >> 2, 0);
assert(lastAddr == addr || lastAddr == 0);
return -73;
}
lastAddr = Atomics.exchange(HEAP32, __emscripten_main_thread_futex >> 2, 0);
assert(lastAddr == addr || lastAddr == 0);
if (lastAddr == 0) {
break;
}
_emscripten_main_thread_process_queued_calls();
if (Atomics.load(HEAP32, addr >> 2) != val) {
return -6;
}
lastAddr = Atomics.exchange(HEAP32, __emscripten_main_thread_futex >> 2, addr);
assert(lastAddr == 0);
}
return 0;
}
}
function _longjmp(env, value) {
_setThrew(env, value || 1);
throw "longjmp";
}
function _emscripten_longjmp(a0, a1) {
return _longjmp(a0, a1);
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.copyWithin(dest, src, src + num);
}
function _emscripten_proxy_to_main_thread_js(index, sync) {
var numCallArgs = arguments.length - 2;
if (numCallArgs > 20 - 1) throw "emscripten_proxy_to_main_thread_js: Too many arguments " + numCallArgs + " to proxied function idx=" + index + ", maximum supported is " + (20 - 1) + "!";
var stack = stackSave();
var serializedNumCallArgs = numCallArgs;
var args = stackAlloc(serializedNumCallArgs * 8);
var b = args >> 3;
for (var i = 0; i < numCallArgs; i++) {
var arg = arguments[2 + i];
SAFE_HEAP_STORE_D((b + i) * 8, arg, 8);
}
var ret = _emscripten_run_in_main_runtime_thread_js(index, serializedNumCallArgs, args, sync);
stackRestore(stack);
return ret;
}
var _emscripten_receive_on_main_thread_js_callArgs = [];
var readAsmConstArgsArray = [];
function readAsmConstArgs(sigPtr, buf) {
assert(Array.isArray(readAsmConstArgsArray));
assert(buf % 16 == 0);
readAsmConstArgsArray.length = 0;
var ch;
buf >>= 2;
while (ch = SAFE_HEAP_LOAD(sigPtr++, 1, 1)) {
assert(ch === 100 || ch === 102 || ch === 105);
var double = ch < 105;
if (double && buf & 1) buf++;
readAsmConstArgsArray.push(double ? SAFE_HEAP_LOAD_D((buf++ >> 1) * 8, 8, 0) : SAFE_HEAP_LOAD(buf * 4, 4, 0));
++buf;
}
return readAsmConstArgsArray;
}
function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) {
_emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
var b = args >> 3;
for (var i = 0; i < numCallArgs; i++) {
_emscripten_receive_on_main_thread_js_callArgs[i] = SAFE_HEAP_LOAD_D((b + i) * 8, 8, 0);
}
var isEmAsmConst = index < 0;
var func = !isEmAsmConst ? proxiedFunctionTable[index] : ASM_CONSTS[-index - 1];
assert(func.length == numCallArgs, "Call args mismatch in emscripten_receive_on_main_thread_js");
return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
}
function _emscripten_get_heap_size() {
return HEAPU8.length;
}
function abortOnCannotGrowMemory(requestedSize) {
abort("Cannot enlarge memory arrays to size " + requestedSize + " bytes (OOM). Either (1) compile with -s INITIAL_MEMORY=X with X higher than the current value " + HEAP8.length + ", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ");
}
function _emscripten_resize_heap(requestedSize) {
requestedSize = requestedSize >>> 0;
abortOnCannotGrowMemory(requestedSize);
}
var JSEvents = {
inEventHandler: 0,
removeAllEventListeners: function() {
for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
JSEvents._removeHandler(i);
}
JSEvents.eventHandlers = [];
JSEvents.deferredCalls = [];
},
registerRemoveEventListeners: function() {
if (!JSEvents.removeEventListenersRegistered) {
__ATEXIT__.push(JSEvents.removeAllEventListeners);
JSEvents.removeEventListenersRegistered = true;
}
},
deferredCalls: [],
deferCall: function(targetFunction, precedence, argsList) {
function arraysHaveEqualContent(arrA, arrB) {
if (arrA.length != arrB.length) return false;
for (var i in arrA) {
if (arrA[i] != arrB[i]) return false;
}
return true;
}
for (var i in JSEvents.deferredCalls) {
var call = JSEvents.deferredCalls[i];
if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
return;
}
}
JSEvents.deferredCalls.push({
targetFunction: targetFunction,
precedence: precedence,
argsList: argsList
});
JSEvents.deferredCalls.sort(function(x, y) {
return x.precedence < y.precedence;
});
},
removeDeferredCalls: function(targetFunction) {
for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
JSEvents.deferredCalls.splice(i, 1);
--i;
}
}
},
canPerformEventHandlerRequests: function() {
return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
},
runDeferredCalls: function() {
if (!JSEvents.canPerformEventHandlerRequests()) {
return;
}
for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
var call = JSEvents.deferredCalls[i];
JSEvents.deferredCalls.splice(i, 1);
--i;
call.targetFunction.apply(null, call.argsList);
}
},
eventHandlers: [],
removeAllHandlersOnTarget: function(target, eventTypeString) {
for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
JSEvents._removeHandler(i--);
}
}
},
_removeHandler: function(i) {
var h = JSEvents.eventHandlers[i];
h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
JSEvents.eventHandlers.splice(i, 1);
},
registerOrRemoveHandler: function(eventHandler) {
var jsEventHandler = function jsEventHandler(event) {
++JSEvents.inEventHandler;
JSEvents.currentEventHandler = eventHandler;
JSEvents.runDeferredCalls();
eventHandler.handlerFunc(event);
JSEvents.runDeferredCalls();
--JSEvents.inEventHandler;
};
if (eventHandler.callbackfunc) {
eventHandler.eventListenerFunc = jsEventHandler;
eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
JSEvents.eventHandlers.push(eventHandler);
JSEvents.registerRemoveEventListeners();
} else {
for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
JSEvents._removeHandler(i--);
}
}
}
},
queueEventHandlerOnThread_iiii: function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) {
var stackTop = stackSave();
var varargs = stackAlloc(12);
SAFE_HEAP_STORE(varargs | 0, eventTypeId | 0, 4);
SAFE_HEAP_STORE(varargs + 4 | 0, eventData | 0, 4);
SAFE_HEAP_STORE(varargs + 8 | 0, userData | 0, 4);
__emscripten_call_on_thread(0, targetThread, 637534208, eventHandlerFunc, eventData, varargs);
stackRestore(stackTop);
},
getTargetThreadForEventCallback: function(targetThread) {
switch (targetThread) {
case 1:
return 0;
case 2:
return PThread.currentProxiedOperationCallerThread;
default:
return targetThread;
}
},
getNodeNameForTarget: function(target) {
if (!target) return "";
if (target == window) return "#window";
if (target == screen) return "#screen";
return target && target.nodeName ? target.nodeName : "";
},
fullscreenEnabled: function() {
return document.fullscreenEnabled || document.webkitFullscreenEnabled;
}
};
function stringToNewUTF8(jsString) {
var length = lengthBytesUTF8(jsString) + 1;
var cString = _malloc(length);
stringToUTF8(jsString, cString, length);
return cString;
}
function _emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height) {
var stackTop = stackSave();
var varargs = stackAlloc(12);
var targetCanvasPtr = 0;
if (targetCanvas) {
targetCanvasPtr = stringToNewUTF8(targetCanvas);
}
SAFE_HEAP_STORE(varargs | 0, targetCanvasPtr | 0, 4);
SAFE_HEAP_STORE(varargs + 4 | 0, width | 0, 4);
SAFE_HEAP_STORE(varargs + 8 | 0, height | 0, 4);
__emscripten_call_on_thread(0, targetThread, 657457152, 0, targetCanvasPtr, varargs);
stackRestore(stackTop);
}
function _emscripten_set_offscreencanvas_size_on_target_thread(targetThread, targetCanvas, width, height) {
targetCanvas = targetCanvas ? UTF8ToString(targetCanvas) : "";
_emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height);
}
function maybeCStringToJsString(cString) {
return cString > 2 ? UTF8ToString(cString) : cString;
}
var specialHTMLTargets = [ 0, typeof document !== "undefined" ? document : 0, typeof window !== "undefined" ? window : 0 ];
function findEventTarget(target) {
target = maybeCStringToJsString(target);
var domElement = specialHTMLTargets[target] || (typeof document !== "undefined" ? document.querySelector(target) : undefined);
return domElement;
}
function findCanvasEventTarget(target) {
return findEventTarget(target);
}
function _emscripten_set_canvas_element_size_calling_thread(target, width, height) {
var canvas = findCanvasEventTarget(target);
if (!canvas) return -4;
if (canvas.canvasSharedPtr) {
SAFE_HEAP_STORE(canvas.canvasSharedPtr | 0, width | 0, 4);
SAFE_HEAP_STORE(canvas.canvasSharedPtr + 4 | 0, height | 0, 4);
}
if (canvas.offscreenCanvas || !canvas.controlTransferredOffscreen) {
if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
var autoResizeViewport = false;
if (canvas.GLctxObject && canvas.GLctxObject.GLctx) {
var prevViewport = canvas.GLctxObject.GLctx.getParameter(2978);
autoResizeViewport = prevViewport[0] === 0 && prevViewport[1] === 0 && prevViewport[2] === canvas.width && prevViewport[3] === canvas.height;
}
canvas.width = width;
canvas.height = height;
if (autoResizeViewport) {
canvas.GLctxObject.GLctx.viewport(0, 0, width, height);
}
} else if (canvas.canvasSharedPtr) {
var targetThread = SAFE_HEAP_LOAD(canvas.canvasSharedPtr + 8 | 0, 4, 0) | 0;
_emscripten_set_offscreencanvas_size_on_target_thread(targetThread, target, width, height);
return 1;
} else {
return -4;
}
return 0;
}
function _emscripten_set_canvas_element_size_main_thread(target, width, height) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(6, 1, target, width, height);
return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
}
function _emscripten_set_canvas_element_size(target, width, height) {
var canvas = findCanvasEventTarget(target);
if (canvas) {
return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
} else {
return _emscripten_set_canvas_element_size_main_thread(target, width, height);
}
}
function _emscripten_set_current_thread_status_js(newStatus) {}
function _emscripten_set_current_thread_status(newStatus) {}
function _emscripten_set_thread_name(threadId, name) {}
function __webgl_enable_ANGLE_instanced_arrays(ctx) {
var ext = ctx.getExtension("ANGLE_instanced_arrays");
if (ext) {
ctx["vertexAttribDivisor"] = function(index, divisor) {
ext["vertexAttribDivisorANGLE"](index, divisor);
};
ctx["drawArraysInstanced"] = function(mode, first, count, primcount) {
ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
};
ctx["drawElementsInstanced"] = function(mode, count, type, indices, primcount) {
ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount);
};
return 1;
}
}
function __webgl_enable_OES_vertex_array_object(ctx) {
var ext = ctx.getExtension("OES_vertex_array_object");
if (ext) {
ctx["createVertexArray"] = function() {
return ext["createVertexArrayOES"]();
};
ctx["deleteVertexArray"] = function(vao) {
ext["deleteVertexArrayOES"](vao);
};
ctx["bindVertexArray"] = function(vao) {
ext["bindVertexArrayOES"](vao);
};
ctx["isVertexArray"] = function(vao) {
return ext["isVertexArrayOES"](vao);
};
return 1;
}
}
function __webgl_enable_WEBGL_draw_buffers(ctx) {
var ext = ctx.getExtension("WEBGL_draw_buffers");
if (ext) {
ctx["drawBuffers"] = function(n, bufs) {
ext["drawBuffersWEBGL"](n, bufs);
};
return 1;
}
}
function __webgl_enable_WEBGL_multi_draw(ctx) {
return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
}
var GL = {
counter: 1,
buffers: [],
programs: [],
framebuffers: [],
renderbuffers: [],
textures: [],
uniforms: [],
shaders: [],
vaos: [],
contexts: {},
offscreenCanvases: {},
timerQueriesEXT: [],
programInfos: {},
stringCache: {},
unpackAlignment: 4,
recordError: function recordError(errorCode) {
if (!GL.lastError) {
GL.lastError = errorCode;
}
},
getNewId: function(table) {
var ret = GL.counter++;
for (var i = table.length; i < ret; i++) {
table[i] = null;
}
return ret;
},
getSource: function(shader, count, string, length) {
var source = "";
for (var i = 0; i < count; ++i) {
var len = length ? SAFE_HEAP_LOAD(length + i * 4 | 0, 4, 0) | 0 : -1;
source += UTF8ToString(SAFE_HEAP_LOAD(string + i * 4 | 0, 4, 0) | 0, len < 0 ? undefined : len);
}
return source;
},
createContext: function(canvas, webGLContextAttributes) {
var ctx = canvas.getContext("webgl", webGLContextAttributes);
if (!ctx) return 0;
var handle = GL.registerContext(ctx, webGLContextAttributes);
return handle;
},
registerContext: function(ctx, webGLContextAttributes) {
var handle = _malloc(8);
SAFE_HEAP_STORE(handle + 4 | 0, _pthread_self() | 0, 4);
var context = {
handle: handle,
attributes: webGLContextAttributes,
version: webGLContextAttributes.majorVersion,
GLctx: ctx
};
if (ctx.canvas) ctx.canvas.GLctxObject = context;
GL.contexts[handle] = context;
if (typeof webGLContextAttributes.enableExtensionsByDefault === "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
GL.initExtensions(context);
}
return handle;
},
makeContextCurrent: function(contextHandle) {
GL.currentContext = GL.contexts[contextHandle];
Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
return !(contextHandle && !GLctx);
},
getContext: function(contextHandle) {
return GL.contexts[contextHandle];
},
deleteContext: function(contextHandle) {
if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null;
if (typeof JSEvents === "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
_free(GL.contexts[contextHandle].handle);
GL.contexts[contextHandle] = null;
},
initExtensions: function(context) {
if (!context) context = GL.currentContext;
if (context.initExtensionsDone) return;
context.initExtensionsDone = true;
var GLctx = context.GLctx;
__webgl_enable_ANGLE_instanced_arrays(GLctx);
__webgl_enable_OES_vertex_array_object(GLctx);
__webgl_enable_WEBGL_draw_buffers(GLctx);
GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
__webgl_enable_WEBGL_multi_draw(GLctx);
var exts = GLctx.getSupportedExtensions() || [];
exts.forEach(function(ext) {
if (ext.indexOf("lose_context") < 0 && ext.indexOf("debug") < 0) {
GLctx.getExtension(ext);
}
});
},
populateUniformTable: function(program) {
var p = GL.programs[program];
var ptable = GL.programInfos[program] = {
uniforms: {},
maxUniformLength: 0,
maxAttributeLength: -1,
maxUniformBlockNameLength: -1
};
var utable = ptable.uniforms;
var numUniforms = GLctx.getProgramParameter(p, 35718);
for (var i = 0; i < numUniforms; ++i) {
var u = GLctx.getActiveUniform(p, i);
var name = u.name;
ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length + 1);
if (name.slice(-1) == "]") {
name = name.slice(0, name.lastIndexOf("["));
}
var loc = GLctx.getUniformLocation(p, name);
if (loc) {
var id = GL.getNewId(GL.uniforms);
utable[name] = [ u.size, id ];
GL.uniforms[id] = loc;
for (var j = 1; j < u.size; ++j) {
var n = name + "[" + j + "]";
loc = GLctx.getUniformLocation(p, n);
id = GL.getNewId(GL.uniforms);
GL.uniforms[id] = loc;
}
}
}
}
};
var __emscripten_webgl_power_preferences = [ "default", "low-power", "high-performance" ];
function _emscripten_webgl_do_create_context(target, attributes) {
assert(attributes);
var a = attributes >> 2;
var powerPreference = SAFE_HEAP_LOAD((a + (24 >> 2)) * 4, 4, 0);
var contextAttributes = {
"alpha": !!SAFE_HEAP_LOAD((a + (0 >> 2)) * 4, 4, 0),
"depth": !!SAFE_HEAP_LOAD((a + (4 >> 2)) * 4, 4, 0),
"stencil": !!SAFE_HEAP_LOAD((a + (8 >> 2)) * 4, 4, 0),
"antialias": !!SAFE_HEAP_LOAD((a + (12 >> 2)) * 4, 4, 0),
"premultipliedAlpha": !!SAFE_HEAP_LOAD((a + (16 >> 2)) * 4, 4, 0),
"preserveDrawingBuffer": !!SAFE_HEAP_LOAD((a + (20 >> 2)) * 4, 4, 0),
"powerPreference": __emscripten_webgl_power_preferences[powerPreference],
"failIfMajorPerformanceCaveat": !!SAFE_HEAP_LOAD((a + (28 >> 2)) * 4, 4, 0),
majorVersion: SAFE_HEAP_LOAD((a + (32 >> 2)) * 4, 4, 0),
minorVersion: SAFE_HEAP_LOAD((a + (36 >> 2)) * 4, 4, 0),
enableExtensionsByDefault: SAFE_HEAP_LOAD((a + (40 >> 2)) * 4, 4, 0),
explicitSwapControl: SAFE_HEAP_LOAD((a + (44 >> 2)) * 4, 4, 0),
proxyContextToMainThread: SAFE_HEAP_LOAD((a + (48 >> 2)) * 4, 4, 0),
renderViaOffscreenBackBuffer: SAFE_HEAP_LOAD((a + (52 >> 2)) * 4, 4, 0)
};
var canvas = findCanvasEventTarget(target);
if (!canvas) {
return 0;
}
if (contextAttributes.explicitSwapControl) {
return 0;
}
var contextHandle = GL.createContext(canvas, contextAttributes);
return contextHandle;
}
function _emscripten_webgl_create_context(a0, a1) {
return _emscripten_webgl_do_create_context(a0, a1);
}
var ENV = {};
function getExecutableName() {
return thisProgram || "./this.program";
}
function getEnvStrings() {
if (!getEnvStrings.strings) {
var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
var env = {
"USER": "web_user",
"LOGNAME": "web_user",
"PATH": "/",
"PWD": "/",
"HOME": "/home/web_user",
"LANG": lang,
"_": getExecutableName()
};
for (var x in ENV) {
env[x] = ENV[x];
}
var strings = [];
for (var x in env) {
strings.push(x + "=" + env[x]);
}
getEnvStrings.strings = strings;
}
return getEnvStrings.strings;
}
function _environ_get(__environ, environ_buf) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(7, 1, __environ, environ_buf);
try {
var bufSize = 0;
getEnvStrings().forEach(function(string, i) {
var ptr = environ_buf + bufSize;
SAFE_HEAP_STORE(__environ + i * 4 | 0, ptr | 0, 4);
writeAsciiToMemory(string, ptr);
bufSize += string.length + 1;
});
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _environ_sizes_get(penviron_count, penviron_buf_size) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(8, 1, penviron_count, penviron_buf_size);
try {
var strings = getEnvStrings();
SAFE_HEAP_STORE(penviron_count | 0, strings.length | 0, 4);
var bufSize = 0;
strings.forEach(function(string) {
bufSize += string.length + 1;
});
SAFE_HEAP_STORE(penviron_buf_size | 0, bufSize | 0, 4);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _exit(status) {
exit(status);
}
function _fd_close(fd) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(9, 1, fd);
try {
var stream = SYSCALLS.getStreamFromFD(fd);
FS.close(stream);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _fd_read(fd, iov, iovcnt, pnum) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(10, 1, fd, iov, iovcnt, pnum);
try {
var stream = SYSCALLS.getStreamFromFD(fd);
var num = SYSCALLS.doReadv(stream, iov, iovcnt);
SAFE_HEAP_STORE(pnum | 0, num | 0, 4);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(11, 1, fd, offset_low, offset_high, whence, newOffset);
try {
var stream = SYSCALLS.getStreamFromFD(fd);
var HIGH_OFFSET = 4294967296;
var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
var DOUBLE_LIMIT = 9007199254740992;
if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
return -61;
}
FS.llseek(stream, offset, whence);
tempI64 = [ stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
SAFE_HEAP_STORE(newOffset | 0, tempI64[0] | 0, 4), SAFE_HEAP_STORE(newOffset + 4 | 0, tempI64[1] | 0, 4);
if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _fd_write(fd, iov, iovcnt, pnum) {
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(12, 1, fd, iov, iovcnt, pnum);
try {
var stream = SYSCALLS.getStreamFromFD(fd);
var num = SYSCALLS.doWritev(stream, iov, iovcnt);
SAFE_HEAP_STORE(pnum | 0, num | 0, 4);
return 0;
} catch (e) {
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
return e.errno;
}
}
function _getTempRet0() {
return getTempRet0() | 0;
}
function _pthread_cleanup_push(routine, arg) {
PThread.threadExitHandlers.push(function() {
wasmTable.get(routine)(arg);
});
}
function spawnThread(threadParams) {
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! spawnThread() can only ever be called from main application thread!";
var worker = PThread.getNewWorker();
if (worker.pthread !== undefined) throw "Internal error!";
if (!threadParams.pthread_ptr) throw "Internal error, no pthread ptr!";
PThread.runningWorkers.push(worker);
var tlsMemory = _malloc(128 * 4);
for (var i = 0; i < 128; ++i) {
SAFE_HEAP_STORE(tlsMemory + i * 4 | 0, 0 | 0, 4);
}
var stackHigh = threadParams.stackBase + threadParams.stackSize;
var pthread = PThread.pthreads[threadParams.pthread_ptr] = {
worker: worker,
stackBase: threadParams.stackBase,
stackSize: threadParams.stackSize,
allocatedOwnStack: threadParams.allocatedOwnStack,
thread: threadParams.pthread_ptr,
threadInfoStruct: threadParams.pthread_ptr
};
var tis = pthread.threadInfoStruct >> 2;
Atomics.store(HEAPU32, tis + (0 >> 2), 0);
Atomics.store(HEAPU32, tis + (4 >> 2), 0);
Atomics.store(HEAPU32, tis + (8 >> 2), 0);
Atomics.store(HEAPU32, tis + (64 >> 2), threadParams.detached);
Atomics.store(HEAPU32, tis + (100 >> 2), tlsMemory);
Atomics.store(HEAPU32, tis + (44 >> 2), 0);
Atomics.store(HEAPU32, tis + (40 >> 2), pthread.threadInfoStruct);
Atomics.store(HEAPU32, tis + (80 >> 2), threadParams.stackSize);
Atomics.store(HEAPU32, tis + (76 >> 2), stackHigh);
Atomics.store(HEAPU32, tis + (104 >> 2), threadParams.stackSize);
Atomics.store(HEAPU32, tis + (104 + 8 >> 2), stackHigh);
Atomics.store(HEAPU32, tis + (104 + 12 >> 2), threadParams.detached);
Atomics.store(HEAPU32, tis + (104 + 20 >> 2), threadParams.schedPolicy);
Atomics.store(HEAPU32, tis + (104 + 24 >> 2), threadParams.schedPrio);
var global_libc = _emscripten_get_global_libc();
var global_locale = global_libc + 40;
Atomics.store(HEAPU32, tis + (172 >> 2), global_locale);
worker.pthread = pthread;
var msg = {
"cmd": "run",
"start_routine": threadParams.startRoutine,
"arg": threadParams.arg,
"threadInfoStruct": threadParams.pthread_ptr,
"stackBase": threadParams.stackBase,
"stackSize": threadParams.stackSize
};
worker.runPthread = function() {
msg.time = performance.now();
worker.postMessage(msg, threadParams.transferList);
};
if (worker.loaded) {
worker.runPthread();
delete worker.runPthread;
}
}
function _pthread_getschedparam(thread, policy, schedparam) {
if (!policy && !schedparam) return ERRNO_CODES.EINVAL;
if (!thread) {
err("pthread_getschedparam called with a null thread pointer!");
return ERRNO_CODES.ESRCH;
}
var self = SAFE_HEAP_LOAD(thread + 12 | 0, 4, 0) | 0;
if (self !== thread) {
err("pthread_getschedparam attempted on thread " + thread + ", which does not point to a valid thread, or does not exist anymore!");
return ERRNO_CODES.ESRCH;
}
var schedPolicy = Atomics.load(HEAPU32, thread + 104 + 20 >> 2);
var schedPrio = Atomics.load(HEAPU32, thread + 104 + 24 >> 2);
if (policy) SAFE_HEAP_STORE(policy | 0, schedPolicy | 0, 4);
if (schedparam) SAFE_HEAP_STORE(schedparam | 0, schedPrio | 0, 4);
return 0;
}
function resetPrototype(constructor, attrs) {
var object = Object.create(constructor.prototype);
for (var key in attrs) {
if (attrs.hasOwnProperty(key)) {
object[key] = attrs[key];
}
}
return object;
}
function _pthread_create(pthread_ptr, attr, start_routine, arg) {
if (typeof SharedArrayBuffer === "undefined") {
err("Current environment does not support SharedArrayBuffer, pthreads are not available!");
return 6;
}
if (!pthread_ptr) {
err("pthread_create called with a null thread pointer!");
return 28;
}
var transferList = [];
var error = 0;
if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
return _emscripten_sync_run_in_main_thread_4(687865856, pthread_ptr, attr, start_routine, arg);
}
if (error) return error;
var stackSize = 0;
var stackBase = 0;
var detached = 0;
var schedPolicy = 0;
var schedPrio = 0;
if (attr && attr != -1) {
stackSize = SAFE_HEAP_LOAD(attr | 0, 4, 0) | 0;
stackSize += 81920;
stackBase = SAFE_HEAP_LOAD(attr + 8 | 0, 4, 0) | 0;
detached = (SAFE_HEAP_LOAD(attr + 12 | 0, 4, 0) | 0) !== 0;
var inheritSched = (SAFE_HEAP_LOAD(attr + 16 | 0, 4, 0) | 0) === 0;
if (inheritSched) {
var prevSchedPolicy = SAFE_HEAP_LOAD(attr + 20 | 0, 4, 0) | 0;
var prevSchedPrio = SAFE_HEAP_LOAD(attr + 24 | 0, 4, 0) | 0;
var parentThreadPtr = PThread.currentProxiedOperationCallerThread ? PThread.currentProxiedOperationCallerThread : _pthread_self();
_pthread_getschedparam(parentThreadPtr, attr + 20, attr + 24);
schedPolicy = SAFE_HEAP_LOAD(attr + 20 | 0, 4, 0) | 0;
schedPrio = SAFE_HEAP_LOAD(attr + 24 | 0, 4, 0) | 0;
SAFE_HEAP_STORE(attr + 20 | 0, prevSchedPolicy | 0, 4);
SAFE_HEAP_STORE(attr + 24 | 0, prevSchedPrio | 0, 4);
} else {
schedPolicy = SAFE_HEAP_LOAD(attr + 20 | 0, 4, 0) | 0;
schedPrio = SAFE_HEAP_LOAD(attr + 24 | 0, 4, 0) | 0;
}
} else {
stackSize = 2097152;
}
var allocatedOwnStack = stackBase == 0;
if (allocatedOwnStack) {
stackBase = _memalign(16, stackSize);
} else {
stackBase -= stackSize;
assert(stackBase > 0);
}
var threadInfoStruct = _malloc(228);
for (var i = 0; i < 228 >> 2; ++i) SAFE_HEAP_STORE(((threadInfoStruct >> 2) + i) * 4, 0, 4);
SAFE_HEAP_STORE(pthread_ptr | 0, threadInfoStruct | 0, 4);
SAFE_HEAP_STORE(threadInfoStruct + 12 | 0, threadInfoStruct | 0, 4);
var headPtr = threadInfoStruct + 152;
SAFE_HEAP_STORE(headPtr | 0, headPtr | 0, 4);
var threadParams = {
stackBase: stackBase,
stackSize: stackSize,
allocatedOwnStack: allocatedOwnStack,
schedPolicy: schedPolicy,
schedPrio: schedPrio,
detached: detached,
startRoutine: start_routine,
pthread_ptr: threadInfoStruct,
arg: arg,
transferList: transferList
};
if (ENVIRONMENT_IS_PTHREAD) {
threadParams.cmd = "spawnThread";
postMessage(threadParams, transferList);
} else {
spawnThread(threadParams);
}
return 0;
}
function _pthread_exit(status) {
if (!ENVIRONMENT_IS_PTHREAD) _exit(status); else PThread.threadExit(status);
if (ENVIRONMENT_IS_NODE) {
process.exit(status);
}
throw "unwind";
}
function _setTempRet0($i) {
setTempRet0($i | 0);
}
function _system(command) {
if (ENVIRONMENT_IS_NODE) {
if (!command) return 1;
var cmdstr = UTF8ToString(command);
if (!cmdstr.length) return 0;
var cp = require("child_process");
var ret = cp.spawnSync(cmdstr, [], {
shell: true,
stdio: "inherit"
});
var _W_EXITCODE = function(ret, sig) {
return ret << 8 | sig;
};
if (ret.status === null) {
var signalToNumber = function(sig) {
switch (sig) {
case "SIGHUP":
return 1;
case "SIGINT":
return 2;
case "SIGQUIT":
return 3;
case "SIGFPE":
return 8;
case "SIGKILL":
return 9;
case "SIGALRM":
return 14;
case "SIGTERM":
return 15;
}
return 2;
};
return _W_EXITCODE(0, signalToNumber(ret.signal));
}
return _W_EXITCODE(ret.status, 0);
}
if (!command) return 0;
setErrNo(6);
return -1;
}
if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock();
var FSNode = function(parent, name, mode, rdev) {
if (!parent) {
parent = this;
}
this.parent = parent;
this.mount = parent.mount;
this.mounted = null;
this.id = FS.nextInode++;
this.name = name;
this.mode = mode;
this.node_ops = {};
this.stream_ops = {};
this.rdev = rdev;
};
var readMode = 292 | 73;
var writeMode = 146;
Object.defineProperties(FSNode.prototype, {
read: {
get: function() {
return (this.mode & readMode) === readMode;
},
set: function(val) {
val ? this.mode |= readMode : this.mode &= ~readMode;
}
},
write: {
get: function() {
return (this.mode & writeMode) === writeMode;
},
set: function(val) {
val ? this.mode |= writeMode : this.mode &= ~writeMode;
}
},
isFolder: {
get: function() {
return FS.isDir(this.mode);
}
},
isDevice: {
get: function() {
return FS.isChrdev(this.mode);
}
}
});
FS.FSNode = FSNode;
FS.staticInit();
var GLctx;
var proxiedFunctionTable = [ null, ___sys_fcntl64, ___sys_ioctl, ___sys_open, ___sys_rmdir, ___sys_unlink, _emscripten_set_canvas_element_size_main_thread, _environ_get, _environ_sizes_get, _fd_close, _fd_read, _fd_seek, _fd_write ];
var ASSERTIONS = true;
function intArrayFromString(stringy, dontAddNull, length) {
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
var u8array = new Array(len);
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
if (dontAddNull) u8array.length = numBytesWritten;
return u8array;
}
function intArrayToString(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
var chr = array[i];
if (chr > 255) {
if (ASSERTIONS) {
assert(false, "Character code " + chr + " (" + String.fromCharCode(chr) + ") at offset " + i + " not in 0x00-0xFF.");
}
chr &= 255;
}
ret.push(String.fromCharCode(chr));
}
return ret.join("");
}
if (!ENVIRONMENT_IS_PTHREAD) __ATINIT__.push({
func: function() {
___wasm_call_ctors();
}
});
var asmLibraryArg = {
"__assert_fail": ___assert_fail,
"__call_main": ___call_main,
"__clock_gettime": ___clock_gettime,
"__sys_fcntl64": ___sys_fcntl64,
"__sys_ioctl": ___sys_ioctl,
"__sys_open": ___sys_open,
"__sys_rmdir": ___sys_rmdir,
"__sys_unlink": ___sys_unlink,
"_emscripten_notify_thread_queue": __emscripten_notify_thread_queue,
"abort": _abort,
"alignfault": alignfault,
"clock_gettime": _clock_gettime,
"dlerror": _dlerror,
"dlopen": _dlopen,
"dlsym": _dlsym,
"emscripten_asm_const_int": _emscripten_asm_const_int,
"emscripten_check_blocking_allowed": _emscripten_check_blocking_allowed,
"emscripten_conditional_set_current_thread_status": _emscripten_conditional_set_current_thread_status,
"emscripten_futex_wait": _emscripten_futex_wait,
"emscripten_futex_wake": _emscripten_futex_wake,
"emscripten_get_now": _emscripten_get_now,
"emscripten_longjmp": _emscripten_longjmp,
"emscripten_memcpy_big": _emscripten_memcpy_big,
"emscripten_receive_on_main_thread_js": _emscripten_receive_on_main_thread_js,
"emscripten_resize_heap": _emscripten_resize_heap,
"emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size,
"emscripten_set_current_thread_status": _emscripten_set_current_thread_status,
"emscripten_set_thread_name": _emscripten_set_thread_name,
"emscripten_webgl_create_context": _emscripten_webgl_create_context,
"environ_get": _environ_get,
"environ_sizes_get": _environ_sizes_get,
"exit": _exit,
"fd_close": _fd_close,
"fd_read": _fd_read,
"fd_seek": _fd_seek,
"fd_write": _fd_write,
"getTempRet0": _getTempRet0,
"initPthreadsJS": initPthreadsJS,
"invoke_iiii": invoke_iiii,
"invoke_vi": invoke_vi,
"invoke_viiii": invoke_viiii,
"memory": wasmMemory,
"pthread_cleanup_push": _pthread_cleanup_push,
"pthread_create": _pthread_create,
"pthread_exit": _pthread_exit,
"segfault": segfault,
"setTempRet0": _setTempRet0,
"system": _system
};
var asm = createWasm();
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");
var _sendToEval = Module["_sendToEval"] = createExportWrapper("sendToEval");
var _malloc = Module["_malloc"] = createExportWrapper("malloc");
var _main = Module["_main"] = createExportWrapper("main");
var _pthread_self = Module["_pthread_self"] = createExportWrapper("pthread_self");
var _free = Module["_free"] = createExportWrapper("free");
var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location");
var _fflush = Module["_fflush"] = createExportWrapper("fflush");
var _saveSetjmp = Module["_saveSetjmp"] = createExportWrapper("saveSetjmp");
var _testSetjmp = Module["_testSetjmp"] = createExportWrapper("testSetjmp");
var _realloc = Module["_realloc"] = createExportWrapper("realloc");
var _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = createExportWrapper("emscripten_get_global_libc");
var ___emscripten_pthread_data_constructor = Module["___emscripten_pthread_data_constructor"] = createExportWrapper("__emscripten_pthread_data_constructor");
var _emscripten_main_browser_thread_id = Module["_emscripten_main_browser_thread_id"] = createExportWrapper("emscripten_main_browser_thread_id");
var ___pthread_tsd_run_dtors = Module["___pthread_tsd_run_dtors"] = createExportWrapper("__pthread_tsd_run_dtors");
var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = createExportWrapper("emscripten_main_thread_process_queued_calls");
var _emscripten_register_main_browser_thread_id = Module["_emscripten_register_main_browser_thread_id"] = createExportWrapper("emscripten_register_main_browser_thread_id");
var __emscripten_do_dispatch_to_thread = Module["__emscripten_do_dispatch_to_thread"] = createExportWrapper("_emscripten_do_dispatch_to_thread");
var _emscripten_sync_run_in_main_thread_2 = Module["_emscripten_sync_run_in_main_thread_2"] = createExportWrapper("emscripten_sync_run_in_main_thread_2");
var _emscripten_sync_run_in_main_thread_4 = Module["_emscripten_sync_run_in_main_thread_4"] = createExportWrapper("emscripten_sync_run_in_main_thread_4");
var _emscripten_run_in_main_runtime_thread_js = Module["_emscripten_run_in_main_runtime_thread_js"] = createExportWrapper("emscripten_run_in_main_runtime_thread_js");
var __emscripten_call_on_thread = Module["__emscripten_call_on_thread"] = createExportWrapper("_emscripten_call_on_thread");
var _emscripten_proxy_main = Module["_emscripten_proxy_main"] = createExportWrapper("emscripten_proxy_main");
var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() {
return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
};
var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
};
var _emscripten_tls_init = Module["_emscripten_tls_init"] = createExportWrapper("emscripten_tls_init");
var __emscripten_thread_init = Module["__emscripten_thread_init"] = createExportWrapper("_emscripten_thread_init");
var stackSave = Module["stackSave"] = createExportWrapper("stackSave");
var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore");
var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc");
var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
};
var _emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = function() {
return (_emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = Module["asm"]["emscripten_stack_set_limits"]).apply(null, arguments);
};
var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
};
var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew");
var _sbrk = Module["_sbrk"] = createExportWrapper("sbrk");
var _memalign = Module["_memalign"] = createExportWrapper("memalign");
var _emscripten_get_sbrk_ptr = Module["_emscripten_get_sbrk_ptr"] = createExportWrapper("emscripten_get_sbrk_ptr");
var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");
var __emscripten_main_thread_futex = Module["__emscripten_main_thread_futex"] = 95188;
function invoke_viiii(index, a1, a2, a3, a4) {
var sp = stackSave();
try {
wasmTable.get(index)(a1, a2, a3, a4);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_iiii(index, a1, a2, a3) {
var sp = stackSave();
try {
return wasmTable.get(index)(a1, a2, a3);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
function invoke_vi(index, a1) {
var sp = stackSave();
try {
wasmTable.get(index)(a1);
} catch (e) {
stackRestore(sp);
if (e !== e + 0 && e !== "longjmp") throw e;
_setThrew(1, 0);
}
}
if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString")) Module["intArrayFromString"] = function() {
abort("'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString")) Module["intArrayToString"] = function() {
abort("'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
Module["ccall"] = ccall;
Module["cwrap"] = cwrap;
if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = function() {
abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getValue")) Module["getValue"] = function() {
abort("'getValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "allocate")) Module["allocate"] = function() {
abort("'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = function() {
abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ToString")) Module["UTF8ToString"] = function() {
abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() {
abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = function() {
abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = function() {
abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() {
abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = function() {
abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = function() {
abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = function() {
abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = function() {
abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = function() {
abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = function() {
abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeArrayToMemory")) Module["writeArrayToMemory"] = function() {
abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = function() {
abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency")) Module["addRunDependency"] = function() {
abort("'addRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency")) Module["removeRunDependency"] = function() {
abort("'removeRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder")) Module["FS_createFolder"] = function() {
abort("'FS_createFolder' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath")) Module["FS_createPath"] = function() {
abort("'FS_createPath' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile")) Module["FS_createDataFile"] = function() {
abort("'FS_createDataFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile")) Module["FS_createPreloadedFile"] = function() {
abort("'FS_createPreloadedFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile")) Module["FS_createLazyFile"] = function() {
abort("'FS_createLazyFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink")) Module["FS_createLink"] = function() {
abort("'FS_createLink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice")) Module["FS_createDevice"] = function() {
abort("'FS_createDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink")) Module["FS_unlink"] = function() {
abort("'FS_unlink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
};
if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = function() {
abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = function() {
abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = function() {
abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = function() {
abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = function() {
abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = function() {
abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() {
abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = function() {
abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "makeBigInt")) Module["makeBigInt"] = function() {
abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() {
abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = function() {
abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "print")) Module["print"] = function() {
abort("'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = function() {
abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = function() {
abort("'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = function() {
abort("'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = function() {
abort("'callMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = function() {
abort("'abort' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8")) Module["stringToNewUTF8"] = function() {
abort("'stringToNewUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "setFileTime")) Module["setFileTime"] = function() {
abort("'setFileTime' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "abortOnCannotGrowMemory")) Module["abortOnCannotGrowMemory"] = function() {
abort("'abortOnCannotGrowMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer")) Module["emscripten_realloc_buffer"] = function() {
abort("'emscripten_realloc_buffer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = function() {
abort("'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES")) Module["ERRNO_CODES"] = function() {
abort("'ERRNO_CODES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES")) Module["ERRNO_MESSAGES"] = function() {
abort("'ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "setErrNo")) Module["setErrNo"] = function() {
abort("'setErrNo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "DNS")) Module["DNS"] = function() {
abort("'DNS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getHostByName")) Module["getHostByName"] = function() {
abort("'getHostByName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GAI_ERRNO_MESSAGES")) Module["GAI_ERRNO_MESSAGES"] = function() {
abort("'GAI_ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "Protocols")) Module["Protocols"] = function() {
abort("'Protocols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "Sockets")) Module["Sockets"] = function() {
abort("'Sockets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getRandomDevice")) Module["getRandomDevice"] = function() {
abort("'getRandomDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "traverseStack")) Module["traverseStack"] = function() {
abort("'traverseStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE")) Module["UNWIND_CACHE"] = function() {
abort("'UNWIND_CACHE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "withBuiltinMalloc")) Module["withBuiltinMalloc"] = function() {
abort("'withBuiltinMalloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = function() {
abort("'readAsmConstArgsArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs")) Module["readAsmConstArgs"] = function() {
abort("'readAsmConstArgs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "mainThreadEM_ASM")) Module["mainThreadEM_ASM"] = function() {
abort("'mainThreadEM_ASM' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q")) Module["jstoi_q"] = function() {
abort("'jstoi_q' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s")) Module["jstoi_s"] = function() {
abort("'jstoi_s' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getExecutableName")) Module["getExecutableName"] = function() {
abort("'getExecutableName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = function() {
abort("'listenOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = function() {
abort("'autoResumeAudioContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "dynCallLegacy")) Module["dynCallLegacy"] = function() {
abort("'dynCallLegacy' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getDynCaller")) Module["getDynCaller"] = function() {
abort("'getDynCaller' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() {
abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "callRuntimeCallbacks")) Module["callRuntimeCallbacks"] = function() {
abort("'callRuntimeCallbacks' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "abortStackOverflow")) Module["abortStackOverflow"] = function() {
abort("'abortStackOverflow' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative")) Module["reallyNegative"] = function() {
abort("'reallyNegative' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "unSign")) Module["unSign"] = function() {
abort("'unSign' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "reSign")) Module["reSign"] = function() {
abort("'reSign' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "formatString")) Module["formatString"] = function() {
abort("'formatString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "PATH")) Module["PATH"] = function() {
abort("'PATH' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS")) Module["PATH_FS"] = function() {
abort("'PATH_FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS")) Module["SYSCALLS"] = function() {
abort("'SYSCALLS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "syscallMmap2")) Module["syscallMmap2"] = function() {
abort("'syscallMmap2' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "syscallMunmap")) Module["syscallMunmap"] = function() {
abort("'syscallMunmap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "JSEvents")) Module["JSEvents"] = function() {
abort("'JSEvents' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets")) Module["specialHTMLTargets"] = function() {
abort("'specialHTMLTargets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = function() {
abort("'maybeCStringToJsString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = function() {
abort("'findEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = function() {
abort("'findCanvasEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = function() {
abort("'polyfillSetImmediate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "demangle")) Module["demangle"] = function() {
abort("'demangle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "demangleAll")) Module["demangleAll"] = function() {
abort("'demangleAll' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace")) Module["jsStackTrace"] = function() {
abort("'jsStackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() {
abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings")) Module["getEnvStrings"] = function() {
abort("'getEnvStrings' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "checkWasiClock")) Module["checkWasiClock"] = function() {
abort("'checkWasiClock' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64")) Module["writeI53ToI64"] = function() {
abort("'writeI53ToI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped")) Module["writeI53ToI64Clamped"] = function() {
abort("'writeI53ToI64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling")) Module["writeI53ToI64Signaling"] = function() {
abort("'writeI53ToI64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped")) Module["writeI53ToU64Clamped"] = function() {
abort("'writeI53ToU64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling")) Module["writeI53ToU64Signaling"] = function() {
abort("'writeI53ToU64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64")) Module["readI53FromI64"] = function() {
abort("'readI53FromI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64")) Module["readI53FromU64"] = function() {
abort("'readI53FromU64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53")) Module["convertI32PairToI53"] = function() {
abort("'convertI32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53")) Module["convertU32PairToI53"] = function() {
abort("'convertU32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "uncaughtExceptionCount")) Module["uncaughtExceptionCount"] = function() {
abort("'uncaughtExceptionCount' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "exceptionLast")) Module["exceptionLast"] = function() {
abort("'exceptionLast' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = function() {
abort("'exceptionCaught' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfoAttrs")) Module["ExceptionInfoAttrs"] = function() {
abort("'ExceptionInfoAttrs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfo")) Module["ExceptionInfo"] = function() {
abort("'ExceptionInfo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "CatchInfo")) Module["CatchInfo"] = function() {
abort("'CatchInfo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = function() {
abort("'exception_addRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = function() {
abort("'exception_decRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "Browser")) Module["Browser"] = function() {
abort("'Browser' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "funcWrappers")) Module["funcWrappers"] = function() {
abort("'funcWrappers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() {
abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "setMainLoop")) Module["setMainLoop"] = function() {
abort("'setMainLoop' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = function() {
abort("'tempFixedLengthArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = function() {
abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = function() {
abort("'heapObjectForWebGLType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = function() {
abort("'heapAccessShiftForWebGLHeap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = function() {
abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet")) Module["emscriptenWebGLGet"] = function() {
abort("'emscriptenWebGLGet' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = function() {
abort("'computeUnpackAlignedImageSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData")) Module["emscriptenWebGLGetTexPixelData"] = function() {
abort("'emscriptenWebGLGetTexPixelData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform")) Module["emscriptenWebGLGetUniform"] = function() {
abort("'emscriptenWebGLGetUniform' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib")) Module["emscriptenWebGLGetVertexAttrib"] = function() {
abort("'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "writeGLArray")) Module["writeGLArray"] = function() {
abort("'writeGLArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "FS")) Module["FS"] = function() {
abort("'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "mmapAlloc")) Module["mmapAlloc"] = function() {
abort("'mmapAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "MEMFS")) Module["MEMFS"] = function() {
abort("'MEMFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "TTY")) Module["TTY"] = function() {
abort("'TTY' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS")) Module["PIPEFS"] = function() {
abort("'PIPEFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS")) Module["SOCKFS"] = function() {
abort("'SOCKFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "AL")) Module["AL"] = function() {
abort("'AL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode")) Module["SDL_unicode"] = function() {
abort("'SDL_unicode' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext")) Module["SDL_ttfContext"] = function() {
abort("'SDL_ttfContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio")) Module["SDL_audio"] = function() {
abort("'SDL_audio' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SDL")) Module["SDL"] = function() {
abort("'SDL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx")) Module["SDL_gfx"] = function() {
abort("'SDL_gfx' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GLUT")) Module["GLUT"] = function() {
abort("'GLUT' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "EGL")) Module["EGL"] = function() {
abort("'EGL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window")) Module["GLFW_Window"] = function() {
abort("'GLFW_Window' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GLFW")) Module["GLFW"] = function() {
abort("'GLFW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "GLEW")) Module["GLEW"] = function() {
abort("'GLEW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "IDBStore")) Module["IDBStore"] = function() {
abort("'IDBStore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError")) Module["runAndAbortIfError"] = function() {
abort("'runAndAbortIfError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
Module["PThread"] = PThread;
if (!Object.getOwnPropertyDescriptor(Module, "killThread")) Module["killThread"] = function() {
abort("'killThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "cleanupThread")) Module["cleanupThread"] = function() {
abort("'cleanupThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "cancelThread")) Module["cancelThread"] = function() {
abort("'cancelThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "spawnThread")) Module["spawnThread"] = function() {
abort("'spawnThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "establishStackSpace")) Module["establishStackSpace"] = function() {
abort("'establishStackSpace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "getNoExitRuntime")) Module["getNoExitRuntime"] = function() {
abort("'getNoExitRuntime' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "invokeEntryPoint")) Module["invokeEntryPoint"] = function() {
abort("'invokeEntryPoint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "resetPrototype")) Module["resetPrototype"] = function() {
abort("'resetPrototype' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = function() {
abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = function() {
abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = function() {
abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = function() {
abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = function() {
abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = function() {
abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString")) Module["UTF16ToString"] = function() {
abort("'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16")) Module["stringToUTF16"] = function() {
abort("'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = function() {
abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = function() {
abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = function() {
abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = function() {
abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = function() {
abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack")) Module["allocateUTF8OnStack"] = function() {
abort("'allocateUTF8OnStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
};
Module["writeStackCookie"] = writeStackCookie;
Module["checkStackCookie"] = checkStackCookie;
Module["PThread"] = PThread;
Module["wasmMemory"] = wasmMemory;
Module["ExitStatus"] = ExitStatus;
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL")) Object.defineProperty(Module, "ALLOC_NORMAL", {
configurable: true,
get: function() {
abort("'ALLOC_NORMAL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
}
});
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", {
configurable: true,
get: function() {
abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
}
});
var calledRun;
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = "Program terminated with exit(" + status + ")";
this.status = status;
}
var calledMain = false;
dependenciesFulfilled = function runCaller() {
if (!calledRun) run();
if (!calledRun) dependenciesFulfilled = runCaller;
};
function callMain(args) {
assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
assert(__ATPRERUN__.length == 0, "cannot call main when preRun functions remain to be called");
var entryFunction = Module["_emscripten_proxy_main"];
args = args || [];
var argc = args.length + 1;
var argv = stackAlloc((argc + 1) * 4);
SAFE_HEAP_STORE((argv >> 2) * 4, allocateUTF8OnStack(thisProgram), 4);
for (var i = 1; i < argc; i++) {
SAFE_HEAP_STORE(((argv >> 2) + i) * 4, allocateUTF8OnStack(args[i - 1]), 4);
}
SAFE_HEAP_STORE(((argv >> 2) + argc) * 4, 0, 4);
try {
var ret = entryFunction(argc, argv);
assert(ret == 0, "_emscripten_proxy_main failed to start proxy thread: " + ret);
} finally {
calledMain = true;
}
}
function run(args) {
args = args || arguments_;
if (runDependencies > 0) {
return;
}
_emscripten_stack_init();
writeStackCookie();
preRun();
if (runDependencies > 0) return;
function doRun() {
if (calledRun) return;
calledRun = true;
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
preMain();
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
if (shouldRunNow) callMain(args);
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function() {
setTimeout(function() {
Module["setStatus"]("");
}, 1);
doRun();
}, 1);
} else {
doRun();
}
checkStackCookie();
}
Module["run"] = run;
function checkUnflushedContent() {
var oldOut = out;
var oldErr = err;
var has = false;
out = err = function(x) {
has = true;
};
try {
var flush = Module["_fflush"];
if (flush) flush(0);
[ "stdout", "stderr" ].forEach(function(name) {
var info = FS.analyzePath("/dev/" + name);
if (!info) return;
var stream = info.object;
var rdev = stream.rdev;
var tty = TTY.ttys[rdev];
if (tty && tty.output && tty.output.length) {
has = true;
}
});
} catch (e) {}
out = oldOut;
err = oldErr;
if (has) {
warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.");
}
}
function exit(status, implicit) {
checkUnflushedContent();
if (implicit && noExitRuntime && status === 0) {
return;
}
if (!implicit) {
if (ENVIRONMENT_IS_PTHREAD) {
err("Pthread 0x" + _pthread_self().toString(16) + " called exit(), posting exitProcess.");
postMessage({
"cmd": "exitProcess",
"returnCode": status
});
throw new ExitStatus(status);
} else {
err("main thead called exit: noExitRuntime=" + noExitRuntime);
}
}
if (noExitRuntime) {
if (!implicit) {
var msg = "program exited (with status: " + status + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)";
err(msg);
}
} else {
PThread.terminateAllThreads();
EXITSTATUS = status;
exitRuntime();
if (Module["onExit"]) Module["onExit"](status);
ABORT = true;
}
quit_(status, new ExitStatus(status));
}
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
while (Module["preInit"].length > 0) {
Module["preInit"].pop()();
}
}
var shouldRunNow = true;
if (Module["noInitialRun"]) shouldRunNow = false;
noExitRuntime = !ENVIRONMENT_IS_PTHREAD;
if (!ENVIRONMENT_IS_PTHREAD) {
run();
} else {
PThread.initWorker();
}
Reference in a new issue View git blame Copy permalink